[llvm-branch-commits] [llvm] 7698a01 - [llvm-cov gcov] Replace Donald B. Johnson's cycle enumeration with iterative cycle finding
Fangrui Song via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Dec 11 18:33:03 PST 2020
Author: Fangrui Song
Date: 2020-12-11T18:28:16-08:00
New Revision: 7698a01808222c95adfac0820d78a2f730f37b82
URL: https://github.com/llvm/llvm-project/commit/7698a01808222c95adfac0820d78a2f730f37b82
DIFF: https://github.com/llvm/llvm-project/commit/7698a01808222c95adfac0820d78a2f730f37b82.diff
LOG: [llvm-cov gcov] Replace Donald B. Johnson's cycle enumeration with iterative cycle finding
gcov computes the line execution count as the sum of (a) counts from
predecessors on other lines and (b) the sum of loop execution counts of blocks
on the same line (think of loops on one line).
For (b), we use Donald B. Johnson's cycle enumeration algorithm and perform
cycle cancelling for each cycle. This number of candidate cycles were
exponential and D93036 made it polynomial by skipping zero count cycles. The
time complexity is high (O(V*E^2) (it could be O(E^2) but the linear `Blocks`
check made it higher) and the implementation is complex.
We could just identify loops and sum all back edges. However, this requires a
dominator tree construction which is more complex. The time complexity can be
decreased to almost linear, though.
This patch just performs cycle cancelling iteratively. Add two members
`traversable` and `incoming` to GCOVArc. There are 3 states:
* `!traversable`: blocks not on this line or explored blocks
* `traversable && incoming == nullptr`: unexplored blocks
* `traversable && incoming != nullptr`: blocks which are being explored (on the stack)
If an arc points to a block being explored, a cycle has been found.
Let E be the number of arcs. Every time a cycle is found, at least one arc is
saturated (`edgeCount` reduced to 0), so there are at most E cycles. Finding one
cycle takes O(E) time, so the overall time complexity is O(E^2). Note that we
always augment through a back edge and never need to augment its reverse edge so
reverse edges in traditional flow networks are not needed.
Reviewed By: xinhaoyuan
Differential Revision: https://reviews.llvm.org/D93073
Added:
Modified:
llvm/include/llvm/ProfileData/GCOV.h
llvm/lib/ProfileData/GCOV.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ProfileData/GCOV.h b/llvm/include/llvm/ProfileData/GCOV.h
index b15c5a6a6c65..d4f0b9120577 100644
--- a/llvm/include/llvm/ProfileData/GCOV.h
+++ b/llvm/include/llvm/ProfileData/GCOV.h
@@ -292,15 +292,10 @@ class GCOVBlock {
void print(raw_ostream &OS) const;
void dump() const;
- static uint64_t getCycleCount(const Edges &Path);
- static void unblock(const GCOVBlock *U, BlockVector &Blocked,
- BlockVectorLists &BlockLists);
- static void trimZeroCountSuffix(Edges &Path);
- static bool lookForCircuit(const GCOVBlock *V, const GCOVBlock *Start,
- Edges &Path, BlockVector &Blocked,
- BlockVectorLists &BlockLists,
- const BlockVector &Blocks, uint64_t &Count);
- static void getCyclesCount(const BlockVector &Blocks, uint64_t &Count);
+ static uint64_t
+ augmentOneCycle(GCOVBlock *src,
+ std::vector<std::pair<GCOVBlock *, size_t>> &stack);
+ static uint64_t getCyclesCount(const BlockVector &blocks);
static uint64_t getLineCount(const BlockVector &Blocks);
public:
@@ -309,6 +304,8 @@ class GCOVBlock {
SmallVector<GCOVArc *, 2> pred;
SmallVector<GCOVArc *, 2> succ;
SmallVector<uint32_t, 4> lines;
+ bool traversable = false;
+ GCOVArc *incoming = nullptr;
};
void gcovOneInput(const GCOV::Options &options, StringRef filename,
diff --git a/llvm/lib/ProfileData/GCOV.cpp b/llvm/lib/ProfileData/GCOV.cpp
index b8bc0cc48376..2e1ba3338394 100644
--- a/llvm/lib/ProfileData/GCOV.cpp
+++ b/llvm/lib/ProfileData/GCOV.cpp
@@ -421,120 +421,84 @@ void GCOVBlock::print(raw_ostream &OS) const {
LLVM_DUMP_METHOD void GCOVBlock::dump() const { print(dbgs()); }
#endif
-//===----------------------------------------------------------------------===//
-// Cycles detection
-//
-// The algorithm in GCC is based on the algorithm by Hawick & James:
-// "Enumerating Circuits and Loops in Graphs with Self-Arcs and Multiple-Arcs"
-// http://complexity.massey.ac.nz/cstn/013/cstn-013.pdf.
-//
-// An optimization is to skip any arc with zero count and to backtrack if the
-// current path has such arcs: any cycle with such arc makes no contribution to
-// the final cycle count. This reduces the complexity from exponential to
-// polynomial of the arcs.
-
-/// Get the count for the detected cycle.
-uint64_t GCOVBlock::getCycleCount(const Edges &Path) {
- uint64_t CycleCount = std::numeric_limits<uint64_t>::max();
- for (auto E : Path) {
- CycleCount = std::min(E->cycleCount, CycleCount);
- }
- for (auto E : Path) {
- E->cycleCount -= CycleCount;
- }
- return CycleCount;
-}
-
-/// Unblock a vertex previously marked as blocked.
-void GCOVBlock::unblock(const GCOVBlock *U, BlockVector &Blocked,
- BlockVectorLists &BlockLists) {
- auto it = find(Blocked, U);
- if (it == Blocked.end()) {
- return;
- }
-
- const size_t index = it - Blocked.begin();
- Blocked.erase(it);
-
- const BlockVector ToUnblock(BlockLists[index]);
- BlockLists.erase(BlockLists.begin() + index);
- for (auto GB : ToUnblock) {
- GCOVBlock::unblock(GB, Blocked, BlockLists);
- }
-}
-
-void GCOVBlock::trimZeroCountSuffix(Edges &Path) {
- for (size_t index = 0; index < Path.size(); ++index) {
- if (Path[index]->cycleCount == 0) {
- Path.resize(index);
- return;
+uint64_t
+GCOVBlock::augmentOneCycle(GCOVBlock *src,
+ std::vector<std::pair<GCOVBlock *, size_t>> &stack) {
+ GCOVBlock *u;
+ size_t i;
+ stack.clear();
+ stack.emplace_back(src, 0);
+ src->incoming = (GCOVArc *)1; // Mark u available for cycle detection
+ for (;;) {
+ std::tie(u, i) = stack.back();
+ if (i == u->succ.size()) {
+ u->traversable = false;
+ stack.pop_back();
+ if (stack.empty())
+ break;
+ continue;
}
- }
-}
-
-bool GCOVBlock::lookForCircuit(const GCOVBlock *V, const GCOVBlock *Start,
- Edges &Path, BlockVector &Blocked,
- BlockVectorLists &BlockLists,
- const BlockVector &Blocks, uint64_t &Count) {
- Blocked.push_back(V);
- BlockLists.emplace_back(BlockVector());
- bool FoundCircuit = false;
- const size_t PrefixLength = Path.size();
-
- for (auto E : V->dsts()) {
- const GCOVBlock *W = &E->dst;
- if (E->cycleCount == 0 || W < Start || find(Blocks, W) == Blocks.end()) {
+ ++stack.back().second;
+ GCOVArc *succ = u->succ[i];
+ // Ignore saturated arcs (cycleCount has been reduced to 0) and visited
+ // blocks. Ignore self arcs to guard against bad input (.gcno has no
+ // self arcs).
+ if (succ->cycleCount == 0 || !succ->dst.traversable || &succ->dst == u)
+ continue;
+ if (succ->dst.incoming == nullptr) {
+ succ->dst.incoming = succ;
+ stack.emplace_back(&succ->dst, 0);
continue;
}
-
- Path.push_back(E);
-
- if (W == Start) {
- // We've a cycle.
- Count += GCOVBlock::getCycleCount(Path);
- trimZeroCountSuffix(Path);
- FoundCircuit = true;
- } else if (find(Blocked, W) == Blocked.end() && // W is not blocked.
- GCOVBlock::lookForCircuit(W, Start, Path, Blocked, BlockLists,
- Blocks, Count)) {
- FoundCircuit = true;
+ uint64_t minCount = succ->cycleCount;
+ for (GCOVBlock *v = u;;) {
+ minCount = std::min(minCount, v->incoming->cycleCount);
+ v = &v->incoming->src;
+ if (v == &succ->dst)
+ break;
}
-
- if (Path.size() > PrefixLength)
- Path.pop_back();
- else if (Path.size() < PrefixLength)
- break;
- }
-
- if (FoundCircuit) {
- GCOVBlock::unblock(V, Blocked, BlockLists);
- } else {
- for (auto E : V->dsts()) {
- const GCOVBlock *W = &E->dst;
- if (E->cycleCount == 0 || W < Start || find(Blocks, W) == Blocks.end()) {
- continue;
- }
- const size_t index = find(Blocked, W) - Blocked.begin();
- BlockVector &List = BlockLists[index];
- if (find(List, V) == List.end()) {
- List.push_back(V);
- }
+ succ->cycleCount -= minCount;
+ for (GCOVBlock *v = u;;) {
+ v->incoming->cycleCount -= minCount;
+ v = &v->incoming->src;
+ if (v == &succ->dst)
+ break;
}
+ return minCount;
}
-
- return FoundCircuit;
+ return 0;
}
-/// Get the count for the list of blocks which lie on the same line.
-void GCOVBlock::getCyclesCount(const BlockVector &Blocks, uint64_t &Count) {
- for (auto Block : Blocks) {
- Edges Path;
- BlockVector Blocked;
- BlockVectorLists BlockLists;
-
- GCOVBlock::lookForCircuit(Block, Block, Path, Blocked, BlockLists, Blocks,
- Count);
+// Get the total execution count of loops among blocks on the same line.
+// Assuming a reducible flow graph, the count is the sum of back edge counts.
+// Identifying loops is complex, so we simply find cycles and perform cycle
+// cancelling iteratively.
+uint64_t GCOVBlock::getCyclesCount(const BlockVector &blocks) {
+ std::vector<std::pair<GCOVBlock *, size_t>> stack;
+ uint64_t count = 0, d;
+ for (;;) {
+ // Make blocks on the line traversable and try finding a cycle.
+ for (auto b : blocks) {
+ const_cast<GCOVBlock *>(b)->traversable = true;
+ const_cast<GCOVBlock *>(b)->incoming = nullptr;
+ }
+ d = 0;
+ for (auto block : blocks) {
+ auto *b = const_cast<GCOVBlock *>(block);
+ if (b->traversable && (d = augmentOneCycle(b, stack)) > 0)
+ break;
+ }
+ if (d == 0)
+ break;
+ count += d;
+ }
+ // If there is no more loop, all traversable bits should have been cleared.
+ // This property is needed by subsequent calls.
+ for (auto b : blocks) {
+ assert(!b->traversable);
+ (void)b;
}
+ return count;
}
//===----------------------------------------------------------------------===//
@@ -726,7 +690,7 @@ void Context::collectSourceLine(SourceInfo &si, Summary *summary,
arc->cycleCount = arc->count;
}
- GCOVBlock::getCyclesCount(line.blocks, count);
+ count += GCOVBlock::getCyclesCount(line.blocks);
line.count = count;
if (line.exists) {
++summary->lines;
More information about the llvm-branch-commits
mailing list