void printEdges(Node n){ Edge thisEdge = n->head; while (thisEdge != NULL) { printEdge(thisEdge); thisEdge = thisEdge->next; } }
void Graph :: outputGraphXML(string filepath){ //ofstream xmloutfile; xmloutfile.open (filepath.c_str()); if (!xmloutfile) { printf("ERROR OPENING OUTPUT XML FILE \n"); } else{ int numnodes = adjlist.size(); int numedges = edgelist.size(); xmloutfile << "<?xml version=\"1.0\" standalone=\"no\" ?>" << endl; xmloutfile << "\t<DNVGRAPH>" << endl; xmloutfile << "\t\t <Level value=\"0\" numberOfNodes=\" " << numnodes <<"\" numberOfEdges=\"" << numedges <<"\">" << endl; //output nodes for(int n=0; n<adjlist.size(); n++) printNode(adjlist.at(n)); //output edges for(int e=0; e< edgelist.size(); e++) printEdge(edgelist.at(e)); //for_each(adjlist.begin(), adjlist.end(), printNode); //for_each(edgelist.begin(), edgelist.end(), printEdge); } xmloutfile.close(); }
void print_adj_list(struct list_edges* list){ struct list_edges* node = list; while(node!= NULL) { printEdge(node->edge_node); node = node->next; } }
bool VisitorDot::visitExtend( WitnessExtend * w ) { // left child if( w->hasLeft() ) { Witness* left = w->left().get_ptr(); printEdge(w,left); } // right child if( w->hasRight() ) { Witness* right = w->right().get_ptr(); printEdge(w,right); } // this printNode(w, "green", "(x) " + w->weight()->toString()); return true; }
// One match at a time bool pCFGIterator::matchSendRecv(const pCFGNode& pcfgn, set<unsigned int>& sendPSets, set<unsigned int>& recvPSets, set<unsigned int>& blockedPSets, set<unsigned int>& activePSets, set<unsigned int>& releasedPSets) { set<unsigned int>::iterator send_it, recv_it; bool matched = false; for(send_it = sendPSets.begin(); send_it != sendPSets.end(); send_it++) { // try to match each recv for a given send const DataflowNode& dfSend = pcfgn.getCurNode(*send_it); SgNode* sgnSend = dfSend.getNode(); pcfgMatchAnnotation *sendAnnotation = dynamic_cast<pcfgMatchAnnotation*> (sgnSend->getAttribute("pCFGAnnotation")); ROSE_ASSERT(sendAnnotation != NULL); pair<string, int> sendSource = sendAnnotation->getSource(); pair<string, int> sendTarget = sendAnnotation->getTarget(); for(recv_it = recvPSets.begin(); recv_it != recvPSets.end(); recv_it++) { const DataflowNode& dfRecv = pcfgn.getCurNode(*recv_it); SgNode* sgnRecv = dfRecv.getNode(); pcfgMatchAnnotation *recvAnnotation = dynamic_cast<pcfgMatchAnnotation*> (sgnRecv->getAttribute("pCFGAnnotation")); ROSE_ASSERT(recvAnnotation != NULL); pair<string, int> recvSource = recvAnnotation->getSource(); pair<string, int> recvTarget = recvAnnotation->getTarget(); if(sendSource == recvTarget && recvSource == sendTarget) { // we have a match matched = true; break; } } if(matched) break; } if(matched) { int sendPSet = *send_it; int recvPSet = *recv_it; // move send/ recv psets from blocked to active pCFGNode& ref = const_cast<pCFGNode&>(pcfgn); // downgrade the const cast printEdge(ref.getCurAncsNode(sendPSet), ref.getCurAncsNode(recvPSet), "red"); movePSet(sendPSet, activePSets, blockedPSets); movePSet(recvPSet, activePSets, blockedPSets); releasedPSets.insert(sendPSet); releasedPSets.insert(recvPSet); } else { cout << "ERROR: No matches available in blocked state\n"; } return matched; }
void printGraph(Graph g, void(printNode)(void *node), void(printEdge)(void *node, void *toNode)){ Node nodecursor = g->node; while(nodecursor != NULL){ printNode(nodecursor->nodeData); EdgeList edgelistcursor = nodecursor->edges; while(edgelistcursor != NULL){ printEdge(edgelistcursor->edgeData, edgelistcursor->to->nodeData); edgelistcursor = edgelistcursor->next; } nodecursor = nodecursor->next; } }
bool VisitorDot::visitMerge( WitnessMerge * w ) { // Caller if (w->hasCaller()) { Witness* caller = w->caller().get_ptr(); printEdge(w,caller); } // Rule if (w->hasRule()) { Witness *rule = w->rule().get_ptr(); printEdge(w,rule); } // Callee if (w->hasCallee()) { Witness* callee = w->callee().get_ptr(); printEdge(w,callee); } // this printNode(w, "purple", "(M) " + w->weight()->toString()); return true; }
// Create a dot file containing the tree. void printFsm(FSM* fsm) { FILE* handle = fopen("fsm.dot", "w"); fprintf(handle, "digraph G {\n"); fprintf(handle, " rankdir = LR;\n"); fprintf(handle, " Start->0;\n"); fprintf(handle, " Start [ shape = plaintext ];\n"); unsigned n = fsm->numberStates; for (unsigned i = 0; i < n; ++i) { if (fsm->symbol[i] == 0) { printEdge(handle, i, fsm->next1[i]); if (fsm->next1[i] != fsm->next2[i]) { printEdge(handle, i, fsm->next2[i]); } } else { fprintf(handle, " %u -> %u [label = %c];\n", i, fsm->next1[i], fsm->symbol[i]); } } fprintf(handle, " %u [ peripheries = 2 ];\n", n - 1); fprintf(handle, "}\n"); fclose(handle); system("dot -Tps fsm.dot -o fsm.ps; gv fsm.ps &"); }
bool VisitorDot::visitCombine( WitnessCombine * w ) { std::list< witness_t >::iterator it = w->children().begin(); std::list< witness_t >::iterator itEND = w->children().end(); // each child for( ; it != itEND ; it++ ) { Witness* child = it->get_ptr(); printEdge(w,child); } // this printNode(w, "lightblue", "(+) " + w->weight()->toString()); return true; }
static inline void readAndPrintRequest(std::istream &in, std::ostream &out, Edge *currentEdge) { std::string tmp; in >> tmp; ci_string whatToPrint(tmp.c_str()); if (whatToPrint == ci_string("current")) { printEdge(out,currentEdge); } else if (whatToPrint == ci_string("left")) { printFace(out,currentEdge->Left()); } else if (whatToPrint == ci_string("right")) { printFace(out,currentEdge->Right()); } else { out << "Unknown print operation requested..." << std::endl; } }
int main(){ struct vertex* head = NULL; GraphAddVertex(&head,6); GraphAddVertex(&head,5); GraphAddVertex(&head,4); GraphAddVertex(&head,3); GraphAddVertex(&head,2); GraphAddVertex(&head,1); printVertex(head); GraphAddEdge(head,1,2,1); struct edge* ed = head->edges; printf("%d\n",ed==NULL); printEdge(head); return 0; }
// pCFG_FWDataflow::runAnalysis invokes runAnalysis_pCFG // Walks the pCFG to create dot representation // Annotations used to match send/recv calls, process set names // Transfer functions are only used to determine // 1. NextState for a processSet // 2. to block a particular processSet // 3. Split a process set based on rank dependent condition bool pCFGIterator::runAnalysis_pCFG(const Function& func, NodeState* state, pCFG_Checkpoint* chkpt) { std::cout << "CLIENT RUN ANALYSIS PCFG\n"; string indent=""; DataflowNode funcCFGStart = cfgUtils::getFuncStartCFG(func.get_definition()); DataflowNode funcCFGEnd = cfgUtils::getFuncEndCFG(func.get_definition()); ostringstream funcNameAsString; funcNameAsString << "Function " << func.get_name().getString() << "()"; if(pCFGIteratorDebugLevel >= 1) { Dbg::enterFunc(funcNameAsString.str()); Dbg::dbg << indent << "Entering : " << funcNameAsString.str() << endl; } // current pCFG node pCFGNode curNode; // currently active set<unsigned int> activePSets; // currently blocked set<unsigned int> blockedPSets; // currently resumed from blocked // skip transfer function set<unsigned int> releasedPSets; // psets requiring merge set<unsigned int> mergePSets; // end sets set<unsigned int> endPSets; // Not restarting from a checkpoint // start with single process set // initialize to start from top of function if(chkpt == NULL) { vector<DataflowNode> initDFNodes; initDFNodes.push_back(funcCFGStart); curNode.init(initDFNodes); activePSets.insert(0); // set up dot properties for initial node curNode.set_id(1); // curNode.set_dot_attr("blue"); curNode.set_dot_attr(0); nodeouts << curNode.toDot() << endl; npcfgnodes = 1; } // restarting from chkpt else { curNode = chkpt->n; activePSets = chkpt->activePSets; blockedPSets = chkpt->blockedPSets; releasedPSets = chkpt->releasedPSets; Dbg::dbg << indent << "RESTARTING FROM CHKPT " << chkpt->str(indent+" ") << endl; } // bool shouldMatch = false; bool movedPSet = false; // outer-loop // apply dataflow on all process sets // match send/recv when all process sets are blocked do { bool modified = false; // move until every pset is blocked // perform send/recv matching after this loop while(activePSets.size() > 0) { int curPSet; // The current process set is the next active one or the process set that // performed the split from which we're restarting // (the latter special condition is only needed to keep the output more readable) if(chkpt==NULL) { // pick in canonical order curPSet = *(activePSets.begin()); } else { curPSet = chkpt->splitPSet; } printSubGraphInit(curPSet); // If we're restarting, we don't need the checkpoint any more if(chkpt) { delete chkpt; chkpt = NULL; } // process the curPset until it is blocked while(1) { pair<set<pCFGNode>::iterator, bool> insertReturn = visitedPCFGNodes.insert(curNode); //bool firstTimeVisit = insertReturn.second; // may be required // dataflow node corresponding to this pset const DataflowNode& dfNode = curNode.getCurNode(curPSet); // SgNode *sgn = dfNode.getNode(); // get the state corresponding to this analysis // lattice information above/below // NodeState* state = pCFGState::getNodeState(func, curNode, this); // ROSE_ASSERT(state != NULL); NodeState* state = NULL; // We may need state information to decide if merge,split or blocked required //vector<Lattice*>& dfInfoAbove = state->getLatticeAboveMod (this); //vector<Lattice*>& dfInfoBelow = state->getLatticeBelowMod (this); // create descendant pcfg node // initalization happens as the analysis progresses // TODO: Use annotations to decide if the nod should be created pCFGNode descNode(curNode); //TODO: Check if need to merge // merge => two psets at same dataflow node & same status // update modified = // if we resume from blocked state // if(releasedPSets.erase(curPSet) > 0) { descNode.advanceOut(curPSet); descNode.set_id(++npcfgnodes); // descNode.set_dot_attr("blue"); descNode.set_dot_attr(curPSet); if(movedPSet) { // do not update ancestor as it was set earlier for this pset // reset the flag movedPSet = false; } else { descNode.updateAncsNode(curPSet, curNode); } modified = true; //TODO: update lattice //TODO: update modified if update lattice changes state } // regular pset // apply transfer function else { // ------------------------------------------------------------------------- // Overwrite the Lattices below this node with the lattices above this node. // The transfer function will then operate on these Lattices to produce the // correct state below this node. // The new information below this pCFGNode. Initially a copy of the above information vector<Lattice*> dfInfoNewBelow; // Initialize dfInfoNewBelow to be the copy of the information above this node. // It will then get pushed through the transfer function before being unioned // with and widened into the information below this node. // for(vector<Lattice*>::const_iterator itA=dfInfoAbove.begin(); itA != dfInfoAbove.end(); itA++) // { // if(pCFGIteratorDebugLevel >= 1) { // Dbg::dbg << indent << " Pre-Transfer Above: Lattice "<<j<<": \n "<<(*itA)->str(" ")<<endl; // } // dfInfoNewBelow.push_back((*itA)->copy()); // } bool isSplitPSet = false; bool isSplitPNode = false; bool isBlockPSet = false; bool isDeadPSet = false; bool isMergePSet = false; //TODO: Apply transfer function //TODO: update modified as a result of transfer // Transfer function determines values for above bool variables // <<<<<<<<<<< TRANSFER FUNCTION >>>>>>>>>>>> vector<DataflowNode> splitPSetNodes; modified = transfer(descNode, curPSet, func, *state, dfInfoNewBelow, isDeadPSet, isSplitPSet, splitPSetNodes, isSplitPNode, isBlockPSet, isMergePSet); if(curNode.getCurNode(curPSet) == funcCFGEnd) { // break // move curPSet from active to end set movePSet(curPSet, endPSets, activePSets); break; } if(isDeadPSet) { // Cannot be in this node // stop progress return false; } // if the analysis needs to split // condition independent of else if(isSplitPNode) { } //NOTE:descNode should be updated by transfer function else if(isSplitPSet) { modified = true; performPSetSplit(curPSet, curNode, descNode, splitPSetNodes, activePSets); // set dot properties descNode.set_id(++npcfgnodes); // descNode.set_dot_attr("red"); descNode.set_dot_attr(curPSet); } // if curPSet wants to block else if(isBlockPSet) { movePSet(curPSet, blockedPSets, activePSets); if(!movedPSet) { curNode.updateAncsNode(curPSet, curNode); } else { movedPSet = false; } movedPSet = true; printSubGraphEnd(); break; } else if(isMergePSet) { movePSet(curPSet, mergePSets, activePSets); if(!movedPSet) { curNode.updateAncsNode(curPSet, curNode); } else { movedPSet = false; } movedPSet = true; printSubGraphEnd(); break; } else { Dbg::dbg << indent << descNode.str() <<"\n"; descNode.advanceOut(curPSet); if(movedPSet) { // do not update ancestor as it was set earlier for this pset // reset the flag movedPSet = false; } else { descNode.updateAncsNode(curPSet, curNode); } // set dot propeties descNode.set_id(++npcfgnodes); // descNode.set_dot_attr("blue"); descNode.set_dot_attr(curPSet); modified = true; } // <<<<<<<<<<< TRANSFER FUNCTION >>>>>>>>>>>> }// end else if(modified) { //TODO: propagate state if required // print dot node, dot edge // make the edge from curnode to descnode // print next transition for pretty printing printNode(descNode); printEdge(descNode.getCurAncsNode(curPSet), descNode); curNode = descNode; modified = false; } // this processSet is blocked //NOTE: modified = false -> fixpoint reached else { return true; } } // end of while(1) -> curPset is blocked or reached end of function //movedPSet = true; } // end of while(activePsets.size > 0) -> all psets are blocked or require merge // All process sets at this point are either blocked or requires merge //TODO: need some asserts on total number of process sets here //TODO: handle different merge points if(mergePSets.size() > 1) { // return true; // we need to merge all process sets in mergepsets // pick the first pset from the mergePSets // this will be the activepset in the next node unsigned int activepset = *(mergePSets.begin()); DataflowNode curDfNode = curNode.getCurNode(activepset); // make a copy vector<DataflowNode> initDF; initDF.push_back(curDfNode); pCFGNode descNode(initDF); // dot properties descNode.set_id(++npcfgnodes); // descNode.set_dot_attr("green"); descNode.set_dot_attr(activepset); printNode(descNode); // draw edges from all nodes to this descNode for(set<unsigned int>::iterator i = mergePSets.begin(); i != mergePSets.end(); i++) { printEdge(curNode.getCurAncsNode(*i), descNode); } descNode.updateAncsNode(activepset, descNode); // set the transition curNode = descNode; // mark visited visitedPCFGNodes.insert(descNode); releasedPSets.insert(activepset); activePSets.insert(activepset); mergePSets.clear(); // we dont want to process blocked yet } //<<<<<< MatchSendRecv >>>>>>>>> //TODO: Determine next descNode based on match //TODO: Activate all non-split psets else if(blockedPSets.size() > 0) { // if blocked at funcCFGEnd, then don't execute // match send recv set<unsigned int> sendPSets; set<unsigned int> recvPSets; // cout << curNode.str() << endl; filterSendRecv(curNode, blockedPSets, sendPSets, recvPSets); ROSE_ASSERT(sendPSets.size() + recvPSets.size() == blockedPSets.size()); bool matched = matchSendRecv(curNode, sendPSets, recvPSets, blockedPSets, activePSets, releasedPSets); if(matched) { cout << "MATCH...\n"; } } //<<<<<< MatchSendRecv >>>>>>>>> } while(activePSets.size() > 0); // end of do-while //TODO: Check if all pSets are at funcCFGEnd //TODO: Create chkpts if not present //TODO: split(set<chkpts>) // inserts new chkpts to set of already existing chkpts // runAnalysis() takes care of starting from the chkpt // All process sets are blocked and they cannot be unblocked via send-receive matching. // Check if this state was reached because all process sets are at the end of the application int curPSet=0; for(vector<DataflowNode>::const_iterator it=curNode.getPSetDFNodes().begin(); it!=curNode.getPSetDFNodes().end(); it++, curPSet++) { // If some process set is not at the end of this function if(*it != funcCFGEnd) { // Dbg::dbg << indent << "WARNING: in un-releaseable state process set "<<curPSet<<" is not at function end! Instead, n.pSetDFNodes["<<curPSet<<"]="<<(*it).str()<<endl; //ROSE_ASSERT(0); // Checkpoint this analysis. We may return to it later and discover that not all these process states // are actually possible. if(analysisDebugLevel>=1) Dbg::dbg << indent << "@@@ Shelving this blocked partition for now.\n"; set<pCFG_Checkpoint*> chkpt; chkpt.insert(new pCFG_Checkpoint(curNode, func, state, activePSets, blockedPSets)); split(chkpt); } } // At this point the analysis has reached the end of the function and does not need to propagate // any dataflow further down this function's pCFG. We will now return without creating a checkpoint. if(analysisDebugLevel>=1) Dbg::exitFunc(funcNameAsString.str()); printSubGraphEnd(); return true; }
void BiGraph::print() { printPoint(); printEdge(); };