void TransCFG::print(std::ostream& out, FuncId funcId,
const ProfData* profData) const {
out << "digraph TransCFG { // function: "
<< Func::fromFuncId(funcId)->fullName()->data() << "\n";
// find max node weight
int64_t maxWeight = 1; // 1 to avoid div by 0
for (auto tid : nodes()) {
auto w = weight(tid);
if (w > maxWeight) maxWeight = w;
}
// print nodes
for (auto const tid : nodes()) {
auto const w = weight(tid);
uint32_t coldness = 255 - (255 * w / maxWeight);
auto const rec = profData->transRec(tid);
auto const bcStart = rec->startBcOff();
auto const bcStop = rec->lastBcOff();
auto const shape = "box";
out << folly::sformat(
"t{} [shape={},label=\"T: {}\\np: {}\\n"
"bc: [{}-{})\",style=filled,fillcolor=\"#ff{:02x}{:02x}\"];\n",
tid, shape, tid, w, bcStart, bcStop, coldness, coldness);
}
// print arcs
for (auto srcId : nodes()) {
for (auto arc : outArcs(srcId)) {
auto const w = arc->weight();
out << folly::sformat("t{} -> t{} [color=\"{}\",label=\"{}\"] ;\n",
srcId,
arc->dst(),
arc->guessed() ? "red" : "green4",
w);
}
}
out << "}\n";
}
RegionDescPtr selectHotTrace(HotTransContext& ctx,
TransIDSet& selectedSet,
TransIDVec* selectedVec /* = nullptr */) {
auto region = std::make_shared<RegionDesc>();
TransID tid = ctx.tid;
TransID prevId = kInvalidTransID;
selectedSet.clear();
if (selectedVec) selectedVec->clear();
TypedLocations accumPostConds;
// Maps from BlockIds to accumulated post conditions for that block.
// Used to determine if we can add branch-over edges by checking the
// pre-conditions of the successor block.
hphp_hash_map<RegionDesc::BlockId, TypedLocations> blockPostConds;
auto numBCInstrs = ctx.maxBCInstrs;
FTRACE(1, "selectHotTrace: starting with maxBCInstrs = {}\n", numBCInstrs);
while (!selectedSet.count(tid)) {
auto rec = ctx.profData->transRec(tid);
auto blockRegion = rec->region();
if (blockRegion == nullptr) break;
// Break if region would be larger than the specified limit.
if (blockRegion->instrSize() > numBCInstrs) {
FTRACE(2, "selectHotTrace: breaking region at Translation {} because "
"size would exceed of maximum translation limit\n", tid);
break;
}
// If the debugger is attached, only allow single-block regions.
if (prevId != kInvalidTransID && isDebuggerAttachedProcess()) {
FTRACE(2, "selectHotTrace: breaking region at Translation {} "
"because of debugger is attached\n", tid);
break;
}
// Break if block is not the first and it corresponds to the main
// function body entry. This is to prevent creating multiple
// large regions containing the function body (starting at various
// DV funclets).
if (prevId != kInvalidTransID) {
auto const func = rec->func();
auto const bcOffset = rec->startBcOff();
if (func->base() == bcOffset) {
FTRACE(2, "selectHotTrace: breaking region because reached the main "
"function body entry at Translation {} (BC offset {})\n",
tid, bcOffset);
break;
}
}
if (prevId != kInvalidTransID) {
auto sk = rec->srcKey();
if (ctx.profData->optimized(sk)) {
FTRACE(2, "selectHotTrace: breaking region because next sk already "
"optimized, for Translation {}\n", tid);
break;
}
}
bool hasPredBlock = !region->empty();
RegionDesc::BlockId predBlockId = (hasPredBlock ?
region->blocks().back().get()->id() : 0);
auto const& newFirstBlock = blockRegion->entry();
auto newFirstBlockId = newFirstBlock->id();
// Add blockRegion's blocks and arcs to region.
region->append(*blockRegion);
numBCInstrs -= blockRegion->instrSize();
assertx(numBCInstrs >= 0);
if (hasPredBlock) {
region->addArc(predBlockId, newFirstBlockId);
}
selectedSet.insert(tid);
if (selectedVec) selectedVec->push_back(tid);
const auto lastSk = rec->lastSrcKey();
if (breaksRegion(lastSk)) {
FTRACE(2, "selectHotTrace: breaking region because of last instruction "
"in Translation {}: {}\n", tid, opcodeToName(lastSk.op()));
break;
}
auto outArcs = ctx.cfg->outArcs(tid);
if (outArcs.size() == 0) {
FTRACE(2, "selectHotTrace: breaking region because there's no successor "
"for Translation {}\n", tid);
break;
}
auto newLastBlock = blockRegion->blocks().back();
discardPoppedTypes(accumPostConds,
blockRegion->entry()->initialSpOffset());
mergePostConds(accumPostConds, newLastBlock->postConds());
blockPostConds[newLastBlock->id()] = accumPostConds;
TransCFG::ArcPtrVec possibleOutArcs;
for (auto arc : outArcs) {
auto dstRec = ctx.profData->transRec(arc->dst());
auto possibleNext = dstRec->region()->entry();
if (preCondsAreSatisfied(possibleNext, accumPostConds)) {
possibleOutArcs.emplace_back(arc);
}
}
if (possibleOutArcs.size() == 0) {
FTRACE(2, "selectHotTrace: breaking region because postcondition check "
"pruned all successors of Translation {}\n", tid);
break;
}
auto maxWeight = std::numeric_limits<int64_t>::min();
TransCFG::Arc* maxArc = nullptr;
for (auto arc : possibleOutArcs) {
if (arc->weight() >= maxWeight) {
maxWeight = arc->weight();
maxArc = arc;
}
}
assertx(maxArc != nullptr);
prevId = tid;
tid = maxArc->dst();
}
FTRACE(3, "selectHotTrace: before chainRetransBlocks:\n{}\n", show(*region));
region->chainRetransBlocks();
FTRACE(3, "selectHotTrace: after chainRetransBlocks:\n{}\n", show(*region));
return region;
}
