// recurseBasicBlock() - This calculates the ProfileInfo estimation for a // single block and then recurses into the successors. // The algorithm preserves the flow condition, meaning that the sum of the // weight of the incoming edges must be equal the block weight which must in // turn be equal to the sume of the weights of the outgoing edges. // Since the flow of an block is deterimined from the current state of the // flow, once an edge has a flow assigned this flow is never changed again, // otherwise it would be possible to violate the flow condition in another // block. void ProfileEstimatorPass::recurseBasicBlock(BasicBlock *BB) { // Break the recursion if this BasicBlock was already visited. if (BBToVisit.find(BB) == BBToVisit.end()) return; // Read the LoopInfo for this block. bool BBisHeader = LI->isLoopHeader(BB); Loop* BBLoop = LI->getLoopFor(BB); // To get the block weight, read all incoming edges. double BBWeight = 0; std::set<BasicBlock*> ProcessedPreds; for ( pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB); bbi != bbe; ++bbi ) { // If this block was not considered already, add weight. Edge edge = getEdge(*bbi,BB); double w = getEdgeWeight(edge); if (ProcessedPreds.insert(*bbi).second) { BBWeight += ignoreMissing(w); } // If this block is a loop header and the predecessor is contained in this // loop, thus the edge is a backedge, continue and do not check if the // value is valid. if (BBisHeader && BBLoop->contains(*bbi)) { printEdgeError(edge, "but is backedge, continuing"); continue; } // If the edges value is missing (and this is no loop header, and this is // no backedge) return, this block is currently non estimatable. if (w == MissingValue) { printEdgeError(edge, "returning"); return; } } if (getExecutionCount(BB) != MissingValue) { BBWeight = getExecutionCount(BB); } // Fetch all necessary information for current block. SmallVector<Edge, 8> ExitEdges; SmallVector<Edge, 8> Edges; if (BBLoop) { BBLoop->getExitEdges(ExitEdges); } // If this is a loop header, consider the following: // Exactly the flow that is entering this block, must exit this block too. So // do the following: // *) get all the exit edges, read the flow that is already leaving this // loop, remember the edges that do not have any flow on them right now. // (The edges that have already flow on them are most likely exiting edges of // other loops, do not touch those flows because the previously caclulated // loopheaders would not be exact anymore.) // *) In case there is not a single exiting edge left, create one at the loop // latch to prevent the flow from building up in the loop. // *) Take the flow that is not leaving the loop already and distribute it on // the remaining exiting edges. // (This ensures that all flow that enters the loop also leaves it.) // *) Increase the flow into the loop by increasing the weight of this block. // There is at least one incoming backedge that will bring us this flow later // on. (So that the flow condition in this node is valid again.) if (BBisHeader) { double incoming = BBWeight; // Subtract the flow leaving the loop. std::set<Edge> ProcessedExits; for (SmallVector<Edge, 8>::iterator ei = ExitEdges.begin(), ee = ExitEdges.end(); ei != ee; ++ei) { if (ProcessedExits.insert(*ei).second) { double w = getEdgeWeight(*ei); if (w == MissingValue) { Edges.push_back(*ei); // Check if there is a necessary minimal weight, if yes, subtract it // from weight. if (MinimalWeight.find(*ei) != MinimalWeight.end()) { incoming -= MinimalWeight[*ei]; DEBUG(dbgs() << "Reserving " << format("%.20g",MinimalWeight[*ei]) << " at " << (*ei) << "\n"); } } else { incoming -= w; } } } // If no exit edges, create one: if (Edges.size() == 0) { BasicBlock *Latch = BBLoop->getLoopLatch(); if (Latch) { Edge edge = getEdge(Latch,0); EdgeInformation[BB->getParent()][edge] = BBWeight; printEdgeWeight(edge); edge = getEdge(Latch, BB); EdgeInformation[BB->getParent()][edge] = BBWeight * ExecCount; printEdgeWeight(edge); } } // Distribute remaining weight to the exting edges. To prevent fractions // from building up and provoking precision problems the weight which is to // be distributed is split and the rounded, the last edge gets a somewhat // bigger value, but we are close enough for an estimation. double fraction = floor(incoming/Edges.size()); for (SmallVector<Edge, 8>::iterator ei = Edges.begin(), ee = Edges.end(); ei != ee; ++ei) { double w = 0; if (ei != (ee-1)) { w = fraction; incoming -= fraction; } else { w = incoming; } EdgeInformation[BB->getParent()][*ei] += w; // Read necessary minimal weight. if (MinimalWeight.find(*ei) != MinimalWeight.end()) { EdgeInformation[BB->getParent()][*ei] += MinimalWeight[*ei]; DEBUG(dbgs() << "Additionally " << format("%.20g",MinimalWeight[*ei]) << " at " << (*ei) << "\n"); } printEdgeWeight(*ei); // Add minimal weight to paths to all exit edges, this is used to ensure // that enough flow is reaching this edges. Path p; const BasicBlock *Dest = GetPath(BB, (*ei).first, p, GetPathToDest); while (Dest != BB) { const BasicBlock *Parent = p.find(Dest)->second; Edge e = getEdge(Parent, Dest); if (MinimalWeight.find(e) == MinimalWeight.end()) { MinimalWeight[e] = 0; } MinimalWeight[e] += w; DEBUG(dbgs() << "Minimal Weight for " << e << ": " << format("%.20g",MinimalWeight[e]) << "\n"); Dest = Parent; } } // Increase flow into the loop. BBWeight *= (ExecCount+1); } BlockInformation[BB->getParent()][BB] = BBWeight; // Up until now we considered only the loop exiting edges, now we have a // definite block weight and must distribute this onto the outgoing edges. // Since there may be already flow attached to some of the edges, read this // flow first and remember the edges that have still now flow attached. Edges.clear(); std::set<BasicBlock*> ProcessedSuccs; succ_iterator bbi = succ_begin(BB), bbe = succ_end(BB); // Also check for (BB,0) edges that may already contain some flow. (But only // in case there are no successors.) if (bbi == bbe) { Edge edge = getEdge(BB,0); EdgeInformation[BB->getParent()][edge] = BBWeight; printEdgeWeight(edge); } for ( ; bbi != bbe; ++bbi ) { if (ProcessedSuccs.insert(*bbi).second) { Edge edge = getEdge(BB,*bbi); double w = getEdgeWeight(edge); if (w != MissingValue) { BBWeight -= getEdgeWeight(edge); } else { Edges.push_back(edge); // If minimal weight is necessary, reserve weight by subtracting weight // from block weight, this is readded later on. if (MinimalWeight.find(edge) != MinimalWeight.end()) { BBWeight -= MinimalWeight[edge]; DEBUG(dbgs() << "Reserving " << format("%.20g",MinimalWeight[edge]) << " at " << edge << "\n"); } } } } double fraction = Edges.size() ? floor(BBWeight/Edges.size()) : 0.0; // Finally we know what flow is still not leaving the block, distribute this // flow onto the empty edges. for (SmallVector<Edge, 8>::iterator ei = Edges.begin(), ee = Edges.end(); ei != ee; ++ei) { if (ei != (ee-1)) { EdgeInformation[BB->getParent()][*ei] += fraction; BBWeight -= fraction; } else { EdgeInformation[BB->getParent()][*ei] += BBWeight; } // Readd minial necessary weight. if (MinimalWeight.find(*ei) != MinimalWeight.end()) { EdgeInformation[BB->getParent()][*ei] += MinimalWeight[*ei]; DEBUG(dbgs() << "Additionally " << format("%.20g",MinimalWeight[*ei]) << " at " << (*ei) << "\n"); } printEdgeWeight(*ei); } // This block is visited, mark this before the recursion. BBToVisit.erase(BB); // Recurse into successors. for (succ_iterator bbi = succ_begin(BB), bbe = succ_end(BB); bbi != bbe; ++bbi) { recurseBasicBlock(*bbi); } }