void simplifyPFBlock(const Edges& toUnlink, const PFBlock& block, Blocks& simplifiedBlocks, Nodes& history) { // take a block, unlink some of the edges and // create smaller blocks or a simplified blocks // or if nothing has changed take a copy of the original block if (toUnlink.size() == 0) { // no change needed, just make a copy of block PFBlock newblock(block.elementIds(), block.edges(), simplifiedBlocks.size(), 's'); // will copy edges and ids PDebug::write("Made {}", newblock); auto id = newblock.id(); simplifiedBlocks.emplace(id, std::move(newblock)); // update history makeHistoryLinks(block.elementIds(), {id}, history); } else { Edges modifiedEdges; for (auto edge : block.edges()) { // copying edges Edge e = edge.second; if (toUnlink.find(edge.first) != toUnlink.end()) { e.setLinked(false); } modifiedEdges.emplace(e.key(), e); } // create new blocks and add into simplifiedBlocks buildPFBlocks(block.elementIds(), modifiedEdges, 's', simplifiedBlocks, history); } }
void PatchMgr::getEdgeCandidates(Scope &scope, Point::Type, Candidates &ret) { Edges edges; getEdges(scope, edges); for (Edges::iterator iter = edges.begin(); iter != edges.end(); ++iter) { ret.push_back(Candidate(Location::Edge(*iter), Point::EdgeDuring)); } }
void Mutation::__cleanup(Module *m) { VLOG(50) << ">>>>> clean up"; LOG_MODULE; for(Edges::iterator e = m->e_begin(); e != m->e_end(); e++) { if((*e)->sourceNode() == NULL || (*e)->destinationNode() == NULL) m->removeEdge(*e); } Edges toBeRemoved; for(Edges::iterator e = m->e_begin(); e != m->e_end(); e++) { for(Edges::iterator f = m->e_begin(); f != m->e_end(); f++) { if((*e)->sourceNode()->label() == (*f)->sourceNode()->label() && (*e)->sourceNode() != (*f)->sourceNode() && (*e) != (*f)) { toBeRemoved.push_back(*e); } } } for(Edges::iterator e = toBeRemoved.begin(); e != toBeRemoved.end(); e++) { m->removeEdge(*e); } LOG_MODULE; VLOG(50) << "<<<<< clean up"; }
inline bool onEdge(const Point & point, const Poly & poly, const Edges & edges, const S & eps) { for(auto j = edges.begin(), jend = edges.end(); j != jend; ++j) { auto & p1 = poly[*j]; auto & p2 = *j == 0 ? poly.back() : poly[*j - 1]; if(onEdge(point, p1, p2, eps)) return true; } return false; }
void split() { Nodes nodes; Edges es; printf("test: bend2()\n"); addNode(nodes,100,100,40,20); addNode(nodes,100,130,40,20); addNode(nodes,70,160,40,20); addNode(nodes,180,190,40,20); EdgePoints p1; addToPath(p1,nodes[0],EdgePoint::CENTRE); addToPath(p1,nodes[1],EdgePoint::BL); addToPath(p1,nodes[1],EdgePoint::TL); addToPath(p1,nodes[3],EdgePoint::CENTRE); es.push_back(new Edge(100,p1)); EdgePoints p2; addToPath(p2,nodes[2],EdgePoint::CENTRE); addToPath(p2,nodes[3],EdgePoint::CENTRE); es.push_back(new Edge(50,p2)); const size_t V = nodes.size(); vpsc::Constraints cs; vpsc::Variables vs; getVariables(nodes,vs); { // scope for t, so that t gets destroyed before es TopologyConstraints t(vpsc::HORIZONTAL,nodes,es,vs,cs); writeFile(nodes,es,"split-0.svg"); // test computeStress double stress=t.computeStress(); printf("Stress=%f\n",stress); //assert(fabs(expectedStress-stress)<1e-4); valarray<double> g(V); cola::SparseMap h(V); for(unsigned i=1;i<5;i++) { g=0; h.clear(); t.gradientProjection(g,h); stringstream ss; ss << "split-" << i << ".svg"; writeFile(nodes,es,ss.str().c_str()); } } for_each(nodes.begin(),nodes.end(),delete_node()); for_each(es.begin(),es.end(),delete_object()); for_each(cs.begin(),cs.end(),delete_object()); for_each(vs.begin(),vs.end(),delete_object()); }
BlockSplitter::BlockSplitter(const Edges& unlinkEdges, PFBlock& block, Nodes& historynodes) : m_blocks() { Edges modifiedEdges; for (auto edge : block.edges()) { // copy edges Edge e = edge.second; if (unlinkEdges.find(edge.first) != unlinkEdges.end()) { e.setLinked(false); } modifiedEdges.emplace(e.key(), std::move(e)); } BlockBuilder bbuilder{block.elementIds(), std::move(modifiedEdges), historynodes}; m_blocks = bbuilder.moveBlocks(); block.setActive(false); }
void dumpDotGraph() { std::ofstream file("/tmp/shiboken_graph.dot"); file << "digraph D {\n"; Edges::const_iterator i = m_edges.begin(); for (; i != m_edges.end(); ++i) { SbkObjectType* node1 = i->first; const NodeList& nodeList = i->second; NodeList::const_iterator j = nodeList.begin(); for (; j != nodeList.end(); ++j) file << '"' << (*j)->super.ht_type.tp_name << "\" -> \"" << node1->super.ht_type.tp_name << "\"\n"; } file << "}\n"; }
PFBlock::PFBlock(const Ids& element_ids, Edges& edges) : m_uniqueId(Id::makeBlockId()), m_isActive(true), m_elementIds(element_ids) { PFBlock::tempBlockCount += 1; // extract the relevant parts of the complete set of edges and store this within the block // note the edges will be removed from the edges unordered_map for (auto id1 : m_elementIds) { for (auto id2 : m_elementIds) { if (id1 >= id2) continue; // move the edge from one unordered map to the other auto e = edges.find(Edge::makeKey(id1, id2)); if (e == edges.end()) throw std::range_error("Required Edge is missing from edges collection"); m_edges.emplace(e->second.key(), std::move(e->second)); edges.erase(e); } } }
int main(int argc, char *argv[]) { typedef std::pair<int, int> Edge; typedef std::vector<Edge> Edges; Edges edges; Edge edge; edge = std::make_pair(0, 1); edges.push_back(edge); std::cout << edge.first << " ---- " << edge.second << std::endl; edge = std::make_pair(1, 0); edges.push_back(edge); std::cout << edge.first << " ---- " << edge.second << std::endl; for(Edges::iterator it = edges.begin(); it != edges.end(); it++) { std::cout << (*it).first << " --- " << (*it).second << std::endl; } return 0; }
SbkObjectType* identifyType(void** cptr, SbkObjectType* type, SbkObjectType* baseType) const { Edges::const_iterator edgesIt = m_edges.find(type); if (edgesIt != m_edges.end()) { const NodeList& adjNodes = m_edges.find(type)->second; NodeList::const_iterator i = adjNodes.begin(); for (; i != adjNodes.end(); ++i) { SbkObjectType* newType = identifyType(cptr, *i, baseType); if (newType) return newType; } } void* typeFound = ((type->d && type->d->type_discovery) ? type->d->type_discovery(*cptr, baseType) : 0); if (typeFound) { // This "typeFound != type" is needed for backwards compatibility with old modules using a newer version of // libshiboken because old versions of type_discovery function used to return a SbkObjectType* instead of // a possible variation of the C++ instance pointer (*cptr). if (typeFound != type) *cptr = typeFound; return type; } else { return 0; } }
/* * compute the stress: * \f[ * \sigma = \sum_{e \in E} \left( d_e - \sum_{s \in S(e)} |s| \right)^2 * \f] */ double computeStress(const Edges& es) { return sum_over(es.begin(),es.end(),0.0,ComputeStress()); }
//_________________________________________________________________________________________________ void DCE::runImpl() { bool early = false; getArg("early", early); if (early && !irManager->getCGFlags()->earlyDCEOn) { return; } irManager->updateLivenessInfo(); irManager->calculateOpndStatistics(); BitSet ls(irManager->getMemoryManager(), irManager->getOpndCount()); const Nodes& nodes = irManager->getFlowGraph()->getNodesPostOrder(); #ifdef ORDER MemoryManager mm("dce_parents"); U_32 opndCount = irManager->getOpndCount(); bool * isParentOpnd = new(mm) bool [opndCount]; memset(isParentOpnd, 0, sizeof(bool) * opndCount); for (Nodes::const_iterator it = nodes.begin(),end = nodes.end(); it!=end; ++it) { Node* node = *it; for (Inst * inst=(Inst*)node->getLastInst(); inst!=NULL; inst=inst->getPrevInst()) { Opnd* load_obj = inst->getParentObjectLoad(); if (load_obj) { isParentOpnd[load_obj->getId()] = true; } Opnd* store_obj = inst->getParentObjectStore(); if (store_obj) { isParentOpnd[store_obj->getId()] = true; } } } #endif for (Nodes::const_iterator it = nodes.begin(),end = nodes.end(); it!=end; ++it) { Node* node = *it; if (node->isBlockNode()) { //Here we'll try to remove redundant branches that could appear after //branch translations. All such branches are supposed to be conditional. Inst * inst = (Inst *)node->getLastInst(); if(inst && node->getOutEdges().size() > 1) { Edges edges = node->getOutEdges(); for (Edges::const_iterator ite1 = ++edges.begin(), end = edges.end(); ite1 != end; ++ite1) { for (Edges::const_iterator ite2 = edges.begin(); ite1 != ite2; ++ite2) { Edge *edge1 = *ite1; Edge *edge2 = *ite2; assert(edge1 != edge2); //If this condition is satisfied then there are at least two branches with //the same destination if (edge1->getTargetNode() == edge2->getTargetNode()) { //Check that edges are conditional and the last instruction is branch, //the other situations are not permitted at the moment assert(inst->hasKind(Inst::Kind_BranchInst)); assert(edge1->getKind() == Edge::Kind_True || edge1->getKind() == Edge::Kind_False); assert(edge2->getKind() == Edge::Kind_True || edge2->getKind() == Edge::Kind_False); //Remove last instruction if it is a branch inst->unlink(); irManager->getFlowGraph()->removeEdge(edge2); } } } } irManager->getLiveAtExit(node, ls); for (Inst * inst=(Inst*)node->getLastInst(), * prevInst=NULL; inst!=NULL; inst=prevInst) { prevInst=inst->getPrevInst(); // Prevent debug traps or instructions with side effects // like (MOVS) from being removed. bool deadInst=!inst->hasSideEffect() && (inst->getMnemonic() != Mnemonic_INT3); #ifdef ORDER //yzm for (unsigned int i = 0 ; i < inst->getOpndCount() ; i ++) { Opnd* opnd = inst->getOpnd(i); if (isParentOpnd[opnd->getId()]) deadInst = false; } #endif if (deadInst) { if (inst->hasKind(Inst::Kind_CopyPseudoInst)) { Opnd * opnd=inst->getOpnd(1); if (opnd->getType()->isFP() && opnd->getDefiningInst()!=NULL && opnd->getDefiningInst()->getMnemonic()==Mnemonic_CALL) { deadInst=false; } } if (deadInst) { Inst::Opnds opnds(inst, Inst::OpndRole_All); for (Inst::Opnds::iterator ito = opnds.begin(); ito != opnds.end(); ito = opnds.next(ito)) { Opnd * opnd = inst->getOpnd(ito); if ((ls.getBit(opnd->getId()) && (inst->getOpndRoles(ito) & Inst::OpndRole_Def)) || (((opnd->getMemOpndKind()&(MemOpndKind_Heap|MemOpndKind_StackManualLayout))!=0) && (inst->getMnemonic() != Mnemonic_LEA))) { deadInst=false; break; } } } } if (deadInst) { inst->unlink(); } else { irManager->updateLiveness(inst, ls); } } irManager->getLiveAtEntry(node)->copyFrom(ls); } } irManager->eliminateSameOpndMoves(); irManager->getFlowGraph()->purgeEmptyNodes(); irManager->getFlowGraph()->mergeAdjacentNodes(true, false); irManager->getFlowGraph()->purgeUnreachableNodes(); irManager->packOpnds(); irManager->invalidateLivenessInfo(); }
void Graph::sort_edges() { std::sort(edges.begin(), edges.end()); }