int main(int argc,char** argv) {
cout << "Hello Lord Firal" << endl;
int i;
// create program state
ProgramState* state = new ProgramState();
state->setRunning(true);
// read in flags
while((i=getopt(argc,argv,"tu:")) != EOF) {
switch(i) {
case 'u': {
state->setRunning(false);
break;
}
case 'l': {
// load in the parameter
break;
}
default:
break;
}
}
// process flags
// run the program
if(state->getRunning()) {
Lazy* program = new Lazy(state);
program->run();
delete program;
}
return 0;
}
/// Decrement the number of times this state is referenced.
void ProgramStateRelease(const ProgramState *state) {
assert(state->refCount > 0);
ProgramState *s = const_cast<ProgramState*>(state);
if (--s->refCount == 0) {
ProgramStateManager &Mgr = s->getStateManager();
Mgr.StateSet.RemoveNode(s);
s->~ProgramState();
Mgr.freeStates.push_back(s);
}
}
void ProgramStateManager::recycleUnusedStates() {
for (std::vector<ProgramState*>::iterator i = recentlyAllocatedStates.begin(),
e = recentlyAllocatedStates.end(); i != e; ++i) {
ProgramState *state = *i;
if (state->referencedByExplodedNode())
continue;
StateSet.RemoveNode(state);
freeStates.push_back(state);
state->~ProgramState();
}
recentlyAllocatedStates.clear();
}
void IfStatement::execute(ProgramState &state) {
bool evalTrue = false;
switch (op) {
case EQ:
evalTrue = state.getValueOf(variableName) == value;
break;
case NEQ:
evalTrue = state.getValueOf(variableName) != value;
break;
case LT:
evalTrue = state.getValueOf(variableName) < value;
break;
case LEQ:
evalTrue = state.getValueOf(variableName) <= value;
break;
case GT:
evalTrue = state.getValueOf(variableName) > value;
break;
case GEQ:
evalTrue = state.getValueOf(variableName) >= value;
break;
}
if(evalTrue) {
state.setPC(lineNumber);
}
else {
state.incrementPC();
}
}
ProgramStateRef
ProgramStateManager::removeDeadBindings(ProgramStateRef state,
const StackFrameContext *LCtx,
SymbolReaper& SymReaper) {
// This code essentially performs a "mark-and-sweep" of the VariableBindings.
// The roots are any Block-level exprs and Decls that our liveness algorithm
// tells us are live. We then see what Decls they may reference, and keep
// those around. This code more than likely can be made faster, and the
// frequency of which this method is called should be experimented with
// for optimum performance.
ProgramState NewState = *state;
NewState.Env = EnvMgr.removeDeadBindings(NewState.Env, SymReaper, state);
// Clean up the store.
StoreRef newStore = StoreMgr->removeDeadBindings(NewState.getStore(), LCtx,
SymReaper);
NewState.setStore(newStore);
SymReaper.setReapedStore(newStore);
return getPersistentState(NewState);
}
ProgramStateRef ProgramStateManager::getPersistentState(ProgramState &State) {
llvm::FoldingSetNodeID ID;
State.Profile(ID);
void *InsertPos;
if (ProgramState *I = StateSet.FindNodeOrInsertPos(ID, InsertPos))
return I;
ProgramState *newState = nullptr;
if (!freeStates.empty()) {
newState = freeStates.back();
freeStates.pop_back();
}
else {
newState = (ProgramState*) Alloc.Allocate<ProgramState>();
}
new (newState) ProgramState(State);
StateSet.InsertNode(newState, InsertPos);
return newState;
}
void ReturnStatement::execute(ProgramState &state) {
state.popPC();
}
void GotoStatement::execute(ProgramState &state) {
state.setPC(lineNumber);
}
void SetUpOrLoadInitialState(CommandLineOpts &inception_state, SeqListClass &my_keys, TrackProgress &my_progress, ImageSpecClass &my_image_spec, SlicedPrequel& my_prequel_setup)
{
if ( !inception_state.bkg_control.signal_chunks.restart_from.empty() )
{
// restarting from saved computational state
// beadfind, bfmask.bin and beadfind.h5 will be ignored
// note that if we are here we will never load the separator data
inception_state.sys_context.GenerateContext (); // find our directories
inception_state.sys_context.SetUpAnalysisLocation();
LoadBeadFindState(inception_state, my_keys, my_image_spec);
}
else if (inception_state.mod_control.reusePriorBeadfind && inception_state.bkg_control.signal_chunks.restart_from.empty())
{
// starting execution fresh, justBeadFind already run
// get any state from beadFind
LoadBeadFindState(inception_state, my_keys, my_image_spec);
// save current command line options to state file
std::string stateFile = inception_state.sys_context.analysisLocation + "/analysisState.json";
if (rename(stateFile.c_str(),(inception_state.sys_context.analysisLocation+"/analysisState_beadfind.json").c_str()) )
{
fprintf(stdout, "Unable to copy beadfind analysisState.json");
}
SetUpKeys(my_keys, inception_state.key_context, inception_state.flow_context);
ProgramState state ( stateFile );
state.Save ( inception_state,my_keys,my_image_spec );
state.WriteState();
// region layout saved in inception_state.loc_context
// region definitions in background model via my_prequel_setup
my_prequel_setup.SetRegions ( inception_state.loc_context.numRegions,
my_image_spec.rows,my_image_spec.cols,
inception_state.loc_context.regionXSize,
inception_state.loc_context.regionYSize );
my_prequel_setup.FileLocations ( inception_state.sys_context.analysisLocation );
}
else
{
// starting execution fresh, justBeadFind not run
inception_state.SetUpProcessing();
CreateResultsFolder (inception_state.sys_context.GetResultsFolder());
inception_state.sys_context.SetUpAnalysisLocation();
// convert from old key representatino to more useful modern style
SetUpKeys(my_keys, inception_state.key_context, inception_state.flow_context);
//@TODO: side effects here on the entire image class
// after this point, Images will behave differently when read in
SetUpToProcessImages ( my_image_spec, inception_state );
// region layout saved into inception_state.loc_context
SetUpRegionsForAnalysis ( my_image_spec.rows, my_image_spec.cols, inception_state.loc_context );
// region layout shared in background model and beadfind via my_prequel_setup
my_prequel_setup.SetRegions ( inception_state.loc_context.numRegions,
my_image_spec.rows,my_image_spec.cols,
inception_state.loc_context.regionXSize,
inception_state.loc_context.regionYSize );
my_prequel_setup.FileLocations ( inception_state.sys_context.analysisLocation );
}
strncpy(ImageTransformer::PCATest,inception_state.img_control.PCATest,sizeof(ImageTransformer::PCATest)-1);
fprintf(stdout, "Analysis region size is width %d, height %d\n", inception_state.loc_context.regionXSize, inception_state.loc_context.regionYSize);
}
const ProgramState *ProgramState::makeWithStore(const StoreRef &store) const {
ProgramState NewSt = *this;
NewSt.setStore(store);
return getStateManager().getPersistentState(NewSt);
}
int main(int argc, char* argv[])
{
if (argc == 1) {
// We don't have arguments, we start the graphical interface.
QApplication a(argc, argv);
ComplexNetsGui::MainWindow w;
w.show();
return a.exec();
} else {
// We read the arguments sent at the command line.
ProgramState *state = new ProgramState();
struct gengetopt_args_info *args_info = (struct gengetopt_args_info *) malloc(sizeof(struct gengetopt_args_info));
if (cmdline_parser(argc, argv, args_info) != 0) {
usageErrorMessage("There was an error reading from the command line.");
ERROR_EXIT;
}
if (args_info->input_file_given) {
if (args_info->erdos_given || args_info->barabasi_given || args_info->hot_given || args_info->molloy_given || args_info->hyperbolic_given) {
usageErrorMessage("Cannot load a graph from an input file and generate a model at the same time.");
ERROR_EXIT;
}
if (args_info->weighted_given) {
state->setWeighted(true);
}
if (args_info->digraph_given) {
state->setDigraph(true);
}
string path = args_info->input_file_arg;
try {
state->readGraphFromFile(path.c_str());
cout << "Succesfully read graph from file " + path + "\n";
} catch (const FileNotFoundException& e) {
errorMessage("The specified input was not found in the filesystem.");
ERROR_EXIT;
} catch (const DuplicatedEdgeLoading& ex) {
errorMessage("The specified input file has duplicated edges.");
ERROR_EXIT;
} catch (...) {
errorMessage("There were problems reading the input file.");
ERROR_EXIT;
}
} else if (args_info->erdos_given) {
if (!args_info->n_given) {
usageErrorMessage("Erdos-Renyi graph generation requires a number of nodes.");
ERROR_EXIT;
}
if (!args_info->p_given) {
usageErrorMessage("Erdos-Renyi graph generation requires a probability.");
ERROR_EXIT;
}
int n = args_info->n_arg;
float p = args_info->p_arg;
VALIDATE_POS(n);
VALIDATE_P(p);
state->setErdosRenyiGraph(n, p);
cout << "Succesfully created an Erdos-Renyi graph with " + to_string(n) + " nodes.\n";
} else if (args_info->barabasi_given) {
if (!args_info->m0_given) {
usageErrorMessage("Barabasi-Albert graph generation requires an initial number of nodes.");
ERROR_EXIT;
}
if (!args_info->m_given) {
usageErrorMessage("Barabasi-Albert graph generation requires a number of nodes to attach with new nodes.");
ERROR_EXIT;
}
if (!args_info->n_given) {
usageErrorMessage("Barabasi-Albert graph generation requires a number of nodes.");
ERROR_EXIT;
}
int n = args_info->n_arg;
int m0 = args_info->m0_arg;
int m = args_info->m_arg;
VALIDATE_POS(n);
VALIDATE_POS(m0);
VALIDATE_POS(m);
if (m > m0) {
usageErrorMessage("The number of nodes to attach cannot be greater than the initial number of nodes.");
ERROR_EXIT;
}
state->setBarabasiAlbertGraph(m0, m, n);
cout << "Succesfully created a Barabasi-Albert graph with " + to_string(n) + " nodes.\n";
} else if (args_info->hot_given) {
if (!args_info->n_given) {
usageErrorMessage("Extended Hot graph generation requires a number of nodes.");
ERROR_EXIT;
}
if (!args_info->m_given) {
usageErrorMessage("Extended Hot graph generation requires the number of edges in each new vertex.");
ERROR_EXIT;
}
if (!args_info->xi_given) {
usageErrorMessage("Extended Hot graph generation requires the parameter used to select the neighbors for a new vertex.");
ERROR_EXIT;
}
if (!args_info->q_given) {
usageErrorMessage("Extended Hot graph generation requires the number of edges added in the graph after of connect a vertex.");
ERROR_EXIT;
}
if (!args_info->r_given) {
usageErrorMessage("Extended Hot graph generation requires the parameter user to selected the edges in the graph after connecting a vertex.");
ERROR_EXIT;
}
if (!args_info->t_given) {
usageErrorMessage("Extended Hot graph generation requires the parameter user select between how many loops the core is recalculated.");
ERROR_EXIT;
}
int n = args_info->n_arg;
int m = args_info->m_arg;
float xi = args_info->xi_arg;
int q = args_info->q_arg;
float r = args_info->r_arg;
int t = args_info->t_arg;
VALIDATE_POS(n);
VALIDATE_POS(m);
VALIDATE_POS(q);
VALIDATE_POS(xi);
VALIDATE_POS(r);
VALIDATE_POS(t);
state->setExtendedHotGraph(m, n, xi, q, r, t);
cout << "Succesfully created an Extended Hot graph with " + to_string(n) + " nodes.\n";
} else if (args_info->molloy_given) {
if (!args_info->ks_given) {
usageErrorMessage("A file with Ks and its nodes is needed to create a Molloy Reed graph.");
ERROR_EXIT;
}
string path = args_info->ks_arg;
state->setMolloyReedGraph(path);
} else if (args_info->hyperbolic_given) {
if (!args_info->n_given) {
usageErrorMessage("Hiperbolic graph generation requires a number of nodes.");
ERROR_EXIT;
}
if (!args_info->a_given) {
usageErrorMessage("Hiperbolic graph generation requires a radial density.");
ERROR_EXIT;
}
if (!args_info->deg_given) {
usageErrorMessage("Hiperbolic graph generation requires an average node degree.");
ERROR_EXIT;
}
int n = args_info->n_arg;
float a = args_info->a_arg;
float c = args_info->deg_arg;
state->setHiperbolicGraph(n, a, c);
} else {
usageErrorMessage("A network must be specified in order to work.");
ERROR_EXIT;
}
if (args_info->betweenness_given) {
//if (state->isWeighted()) {
// errorMessage("Betweenness for weighted graphs is not supported.");
// ERROR_EXIT;
//}else{
printf("Weighted Betweenness");
int vertex_id = args_info->betweenness_arg;
double ret = state->betweenness((unsigned int)args_info->betweenness_arg);
if(ret != -1) {
cout << "Betweenness for vertex " + to_string(vertex_id) + " is: " + to_string(ret) + ".\n";
}else {
errorMessage("Invalid vertex id");
}
//}
} else if (args_info->ddist_given) {
int degree = args_info->ddist_arg;
if (!state->isDigraph()) {
double ret = state->degreeDistribution(degree);
if(ret != -1) {
cout << "Degree distribution for degree " + to_string(degree) + " is: " + to_string(ret) + ".\n";
}else {
cout << "There are no vertices with degree " + to_string(degree) + ".\n";
}
} else {
double ret1 = state->inDegreeDistribution(degree);
double ret2 = state->outDegreeDistribution(degree);
if(ret1 != -1) {
cout << "In-Degree distribution for degree " + to_string(degree) + " is: " + to_string(ret1) + ".\n";
}else {
cout << "There are no vertices with degree " + to_string(degree) + ".\n";
}
if(ret2 != -1) {
cout << "Out-Degree distribution for degree " + to_string(degree) + " is: " + to_string(ret2) + ".\n";
}else {
cout << "There are no vertices with degree " + to_string(degree) + ".\n";
}
}
} else if (args_info->clustering_given) {
int vertex_id = args_info->clustering_arg;
double ret = state->clustering(vertex_id);
if(ret != -1) {
cout << "Clustering coefficient for vertex " + to_string(vertex_id) + " is: " + to_string(ret) + ".\n";
} else {
errorMessage("Invalid vertex id");
}
} else if (args_info->knn_given) {
int vertex_id = args_info->knn_arg;
double ret = state->clustering(vertex_id);
if(ret != -1) {
cout << "Nearest neighbors degree for vertex " + to_string(vertex_id) + " is: " + to_string(ret) + ".\n";
} else {
errorMessage("Invalid vertex id");
}
} else if (args_info->maxCliqueExact_given) {
int max_time = args_info->maxCliqueExact_arg;
std::list<int> ret = state->maxCliqueExact(max_time);
if(!ret.empty()) {
cout << "Max clique size is: " + to_string(ret.size()) + ".\n";
cout << "Max clique is: ";
for(std::list<int>::iterator iterator = ret.begin();iterator != ret.end();iterator++){
cout << to_string<int>(*iterator).c_str() << " ";
}
cout << ".\n";
} else {
errorMessage("Time out.");
ERROR_EXIT;
}
} else if (args_info->maxCliqueAprox_given) {
std::list<int> ret = state->maxCliqueAprox();
if(!ret.empty()) {
cout << "Max clique size is: " + to_string(ret.size()) + ".\n";
cout << "Max clique is:";
for(std::list<int>::iterator iterator = ret.begin();iterator != ret.end();iterator++){
cout << " " << to_string<int>(*iterator).c_str() ;
}
cout << ".\n";
} else {
errorMessage("Unknown error.");
}
}else if (args_info->shell_given) {
int vertex_id = args_info->shell_arg;
double ret = state->shellIndex(vertex_id);
if(ret != -1) {
cout << "Shell index for vertex " + to_string(vertex_id) + " is: " + to_string(ret) + ".\n";
} else {
errorMessage("Invalid vertex id");
}
}
if (args_info->print_deg_given) {
if (args_info->erdos_given || args_info->barabasi_given || args_info->hot_given || args_info->molloy_given || args_info->hyperbolic_given
|| args_info->input_file_given) {
state->printDegrees();
} else {
usageErrorMessage("You have specified the print-deg options but no graph was loaded or generated. Ignoring.");
}
}
if (args_info->output_file_given) {
string path = args_info->output_file_arg;
if (args_info->betweenness_output_given || args_info->ddist_output_given ||
args_info->clustering_output_given || args_info->maxCliqueExact_output_given ||
args_info->maxCliqueAprox_output_given || args_info->knn_output_given ||
args_info->shell_output_given) {
string functionMessage = "";
if (args_info->betweenness_output_given) {
//if (state->isWeighted()) {
// errorMessage("Betweenness for weighted graphs is not supported.");
// ERROR_EXIT;
//} else {
state->exportBetweennessVsDegree(path);
functionMessage = "betweenness";
//}
} else if (args_info->ddist_output_given) {
state->exportDegreeDistribution(path, args_info->log_bin_given, args_info->log_bin_arg);
functionMessage = "degreeDistribution";
} else if (args_info->clustering_output_given) {
state->exportClusteringVsDegree(path);
functionMessage = "clustering coefficient";
} else if (args_info->knn_output_given) {
state->exportNearestNeighborsDegreeVsDegree(path);
functionMessage = "nearest neighbors degree";
} else if (args_info->shell_output_given) {
if (state->isWeighted()) {
errorMessage("Shell index for weighted graphs is not supported.");
ERROR_EXIT;
} else {
state->exportShellIndexVsDegree(path);
functionMessage = "shellIndex";
}
} if (args_info->maxCliqueExact_output_given) {
int max_time = args_info->maxCliqueExact_output_arg;
if(!state->exportMaxCliqueExact(path, max_time)) {
errorMessage("Time out.");
ERROR_EXIT;
}
functionMessage = "max clique distribution";
} else if (args_info->maxCliqueAprox_output_given) {
state->exportMaxCliqueAprox(path);
functionMessage = "max clique distribution aproximation";
}
cout << "Succesfully exported " + functionMessage + " in output file " + path + ".\n";
} else {
state->exportCurrentGraph(path);
cout << "Succesfully saved graph in file " + path + ".\n";
}
}
}
}
