2014-02-06 05:37:03 +01:00
|
|
|
//===- LazyCallGraph.cpp - Analysis of a Module's call graph --------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Analysis/LazyCallGraph.h"
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2014-03-04 12:01:28 +01:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2014-03-06 04:23:41 +01:00
|
|
|
#include "llvm/IR/InstVisitor.h"
|
2014-02-06 05:37:03 +01:00
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/PassManager.h"
|
2014-04-21 07:04:24 +02:00
|
|
|
#include "llvm/Support/Debug.h"
|
2014-02-06 05:37:03 +01:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 04:48:03 +02:00
|
|
|
#define DEBUG_TYPE "lcg"
|
|
|
|
|
2014-02-06 05:37:03 +01:00
|
|
|
static void findCallees(
|
|
|
|
SmallVectorImpl<Constant *> &Worklist, SmallPtrSetImpl<Constant *> &Visited,
|
2014-03-10 03:14:14 +01:00
|
|
|
SmallVectorImpl<PointerUnion<Function *, LazyCallGraph::Node *>> &Callees,
|
2014-04-23 06:00:17 +02:00
|
|
|
DenseMap<Function *, size_t> &CalleeIndexMap) {
|
2014-02-06 05:37:03 +01:00
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Constant *C = Worklist.pop_back_val();
|
|
|
|
|
|
|
|
if (Function *F = dyn_cast<Function>(C)) {
|
|
|
|
// Note that we consider *any* function with a definition to be a viable
|
|
|
|
// edge. Even if the function's definition is subject to replacement by
|
|
|
|
// some other module (say, a weak definition) there may still be
|
|
|
|
// optimizations which essentially speculate based on the definition and
|
|
|
|
// a way to check that the specific definition is in fact the one being
|
|
|
|
// used. For example, this could be done by moving the weak definition to
|
|
|
|
// a strong (internal) definition and making the weak definition be an
|
|
|
|
// alias. Then a test of the address of the weak function against the new
|
|
|
|
// strong definition's address would be an effective way to determine the
|
|
|
|
// safety of optimizing a direct call edge.
|
2014-04-23 06:00:17 +02:00
|
|
|
if (!F->isDeclaration() &&
|
|
|
|
CalleeIndexMap.insert(std::make_pair(F, Callees.size())).second) {
|
2014-04-21 07:04:24 +02:00
|
|
|
DEBUG(dbgs() << " Added callable function: " << F->getName()
|
|
|
|
<< "\n");
|
2014-03-10 03:14:14 +01:00
|
|
|
Callees.push_back(F);
|
2014-04-21 07:04:24 +02:00
|
|
|
}
|
2014-02-06 05:37:03 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-03-03 11:42:58 +01:00
|
|
|
for (Value *Op : C->operand_values())
|
2014-11-19 08:49:26 +01:00
|
|
|
if (Visited.insert(cast<Constant>(Op)).second)
|
2014-03-03 11:42:58 +01:00
|
|
|
Worklist.push_back(cast<Constant>(Op));
|
2014-02-06 05:37:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
LazyCallGraph::Node::Node(LazyCallGraph &G, Function &F)
|
|
|
|
: G(&G), F(F), DFSNumber(0), LowLink(0) {
|
2014-04-21 07:04:24 +02:00
|
|
|
DEBUG(dbgs() << " Adding functions called by '" << F.getName()
|
|
|
|
<< "' to the graph.\n");
|
|
|
|
|
2014-02-06 05:37:03 +01:00
|
|
|
SmallVector<Constant *, 16> Worklist;
|
|
|
|
SmallPtrSet<Constant *, 16> Visited;
|
|
|
|
// Find all the potential callees in this function. First walk the
|
|
|
|
// instructions and add every operand which is a constant to the worklist.
|
2014-03-09 13:20:34 +01:00
|
|
|
for (BasicBlock &BB : F)
|
|
|
|
for (Instruction &I : BB)
|
|
|
|
for (Value *Op : I.operand_values())
|
2014-03-03 11:42:58 +01:00
|
|
|
if (Constant *C = dyn_cast<Constant>(Op))
|
2014-11-19 08:49:26 +01:00
|
|
|
if (Visited.insert(C).second)
|
2014-02-06 05:37:03 +01:00
|
|
|
Worklist.push_back(C);
|
|
|
|
|
|
|
|
// We've collected all the constant (and thus potentially function or
|
|
|
|
// function containing) operands to all of the instructions in the function.
|
|
|
|
// Process them (recursively) collecting every function found.
|
2014-04-23 06:00:17 +02:00
|
|
|
findCallees(Worklist, Visited, Callees, CalleeIndexMap);
|
2014-02-06 05:37:03 +01:00
|
|
|
}
|
|
|
|
|
2014-04-28 13:10:23 +02:00
|
|
|
void LazyCallGraph::Node::insertEdgeInternal(Function &Callee) {
|
|
|
|
if (Node *N = G->lookup(Callee))
|
2014-04-30 12:48:36 +02:00
|
|
|
return insertEdgeInternal(*N);
|
|
|
|
|
|
|
|
CalleeIndexMap.insert(std::make_pair(&Callee, Callees.size()));
|
|
|
|
Callees.push_back(&Callee);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LazyCallGraph::Node::insertEdgeInternal(Node &CalleeN) {
|
|
|
|
CalleeIndexMap.insert(std::make_pair(&CalleeN.getFunction(), Callees.size()));
|
|
|
|
Callees.push_back(&CalleeN);
|
2014-04-28 13:10:23 +02:00
|
|
|
}
|
|
|
|
|
2014-04-27 03:59:50 +02:00
|
|
|
void LazyCallGraph::Node::removeEdgeInternal(Function &Callee) {
|
|
|
|
auto IndexMapI = CalleeIndexMap.find(&Callee);
|
|
|
|
assert(IndexMapI != CalleeIndexMap.end() &&
|
|
|
|
"Callee not in the callee set for this caller?");
|
|
|
|
|
[LCG] Actually test the *basic* edge removal bits (IE, the non-SCC
bits), and discover that it's totally broken. Yay tests. Boo bug. Fix
the basic edge removal so that it works by nulling out the removed edges
rather than actually removing them. This leaves the indices valid in the
map from callee to index, and preserves some of the locality for
iterating over edges. The iterator is made bidirectional to reflect that
it now has to skip over null entries, and the skipping logic is layered
onto it.
As future work, I would like to track essentially the "load factor" of
the edge list, and when it falls below a threshold do a compaction.
An alternative I considered (and continue to consider) is storing the
callees in a doubly linked list where each element of the list is in
a set (which is essentially the classical linked-hash-table
datastructure). The problem with that approach is that either you need
to heap allocate the linked list nodes and use pointers to them, or use
a bucket hash table (with even *more* linked list pointer overhead!),
etc. It's pretty easy to get 5x overhead for values that are just
pointers. So far, I think punching holes in the vector, and periodic
compaction is likely to be much more efficient overall in the space/time
tradeoff.
llvm-svn: 207619
2014-04-30 09:45:27 +02:00
|
|
|
Callees[IndexMapI->second] = nullptr;
|
2014-04-27 03:59:50 +02:00
|
|
|
CalleeIndexMap.erase(IndexMapI);
|
|
|
|
}
|
|
|
|
|
2014-04-18 22:44:16 +02:00
|
|
|
LazyCallGraph::LazyCallGraph(Module &M) : NextDFSNumber(0) {
|
2014-04-21 07:04:24 +02:00
|
|
|
DEBUG(dbgs() << "Building CG for module: " << M.getModuleIdentifier()
|
|
|
|
<< "\n");
|
2014-03-09 13:20:34 +01:00
|
|
|
for (Function &F : M)
|
|
|
|
if (!F.isDeclaration() && !F.hasLocalLinkage())
|
2014-04-23 06:00:17 +02:00
|
|
|
if (EntryIndexMap.insert(std::make_pair(&F, EntryNodes.size())).second) {
|
2014-04-21 07:04:24 +02:00
|
|
|
DEBUG(dbgs() << " Adding '" << F.getName()
|
|
|
|
<< "' to entry set of the graph.\n");
|
2014-03-09 13:20:34 +01:00
|
|
|
EntryNodes.push_back(&F);
|
2014-04-21 07:04:24 +02:00
|
|
|
}
|
2014-02-06 05:37:03 +01:00
|
|
|
|
|
|
|
// Now add entry nodes for functions reachable via initializers to globals.
|
|
|
|
SmallVector<Constant *, 16> Worklist;
|
|
|
|
SmallPtrSet<Constant *, 16> Visited;
|
2014-03-09 13:20:34 +01:00
|
|
|
for (GlobalVariable &GV : M.globals())
|
|
|
|
if (GV.hasInitializer())
|
2014-11-19 08:49:26 +01:00
|
|
|
if (Visited.insert(GV.getInitializer()).second)
|
2014-03-09 13:20:34 +01:00
|
|
|
Worklist.push_back(GV.getInitializer());
|
2014-02-06 05:37:03 +01:00
|
|
|
|
2014-04-21 07:04:24 +02:00
|
|
|
DEBUG(dbgs() << " Adding functions referenced by global initializers to the "
|
|
|
|
"entry set.\n");
|
2014-04-23 06:00:17 +02:00
|
|
|
findCallees(Worklist, Visited, EntryNodes, EntryIndexMap);
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
|
[LCG] Actually test the *basic* edge removal bits (IE, the non-SCC
bits), and discover that it's totally broken. Yay tests. Boo bug. Fix
the basic edge removal so that it works by nulling out the removed edges
rather than actually removing them. This leaves the indices valid in the
map from callee to index, and preserves some of the locality for
iterating over edges. The iterator is made bidirectional to reflect that
it now has to skip over null entries, and the skipping logic is layered
onto it.
As future work, I would like to track essentially the "load factor" of
the edge list, and when it falls below a threshold do a compaction.
An alternative I considered (and continue to consider) is storing the
callees in a doubly linked list where each element of the list is in
a set (which is essentially the classical linked-hash-table
datastructure). The problem with that approach is that either you need
to heap allocate the linked list nodes and use pointers to them, or use
a bucket hash table (with even *more* linked list pointer overhead!),
etc. It's pretty easy to get 5x overhead for values that are just
pointers. So far, I think punching holes in the vector, and periodic
compaction is likely to be much more efficient overall in the space/time
tradeoff.
llvm-svn: 207619
2014-04-30 09:45:27 +02:00
|
|
|
for (auto &Entry : EntryNodes) {
|
|
|
|
assert(!Entry.isNull() &&
|
|
|
|
"We can't have removed edges before we finish the constructor!");
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
if (Function *F = Entry.dyn_cast<Function *>())
|
2014-04-26 11:45:55 +02:00
|
|
|
SCCEntryNodes.push_back(F);
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
else
|
2014-04-26 11:45:55 +02:00
|
|
|
SCCEntryNodes.push_back(&Entry.get<Node *>()->getFunction());
|
[LCG] Actually test the *basic* edge removal bits (IE, the non-SCC
bits), and discover that it's totally broken. Yay tests. Boo bug. Fix
the basic edge removal so that it works by nulling out the removed edges
rather than actually removing them. This leaves the indices valid in the
map from callee to index, and preserves some of the locality for
iterating over edges. The iterator is made bidirectional to reflect that
it now has to skip over null entries, and the skipping logic is layered
onto it.
As future work, I would like to track essentially the "load factor" of
the edge list, and when it falls below a threshold do a compaction.
An alternative I considered (and continue to consider) is storing the
callees in a doubly linked list where each element of the list is in
a set (which is essentially the classical linked-hash-table
datastructure). The problem with that approach is that either you need
to heap allocate the linked list nodes and use pointers to them, or use
a bucket hash table (with even *more* linked list pointer overhead!),
etc. It's pretty easy to get 5x overhead for values that are just
pointers. So far, I think punching holes in the vector, and periodic
compaction is likely to be much more efficient overall in the space/time
tradeoff.
llvm-svn: 207619
2014-04-30 09:45:27 +02:00
|
|
|
}
|
2014-02-06 05:37:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
LazyCallGraph::LazyCallGraph(LazyCallGraph &&G)
|
2014-04-18 22:44:16 +02:00
|
|
|
: BPA(std::move(G.BPA)), NodeMap(std::move(G.NodeMap)),
|
|
|
|
EntryNodes(std::move(G.EntryNodes)),
|
2014-04-23 06:00:17 +02:00
|
|
|
EntryIndexMap(std::move(G.EntryIndexMap)), SCCBPA(std::move(G.SCCBPA)),
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
SCCMap(std::move(G.SCCMap)), LeafSCCs(std::move(G.LeafSCCs)),
|
|
|
|
DFSStack(std::move(G.DFSStack)),
|
2014-04-18 22:44:16 +02:00
|
|
|
SCCEntryNodes(std::move(G.SCCEntryNodes)),
|
|
|
|
NextDFSNumber(G.NextDFSNumber) {
|
2014-04-18 13:02:33 +02:00
|
|
|
updateGraphPtrs();
|
|
|
|
}
|
|
|
|
|
|
|
|
LazyCallGraph &LazyCallGraph::operator=(LazyCallGraph &&G) {
|
|
|
|
BPA = std::move(G.BPA);
|
2014-04-18 22:44:16 +02:00
|
|
|
NodeMap = std::move(G.NodeMap);
|
2014-04-18 13:02:33 +02:00
|
|
|
EntryNodes = std::move(G.EntryNodes);
|
2014-04-23 06:00:17 +02:00
|
|
|
EntryIndexMap = std::move(G.EntryIndexMap);
|
2014-04-18 13:02:33 +02:00
|
|
|
SCCBPA = std::move(G.SCCBPA);
|
|
|
|
SCCMap = std::move(G.SCCMap);
|
|
|
|
LeafSCCs = std::move(G.LeafSCCs);
|
|
|
|
DFSStack = std::move(G.DFSStack);
|
|
|
|
SCCEntryNodes = std::move(G.SCCEntryNodes);
|
2014-04-18 22:44:16 +02:00
|
|
|
NextDFSNumber = G.NextDFSNumber;
|
2014-04-18 13:02:33 +02:00
|
|
|
updateGraphPtrs();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2014-04-27 03:59:50 +02:00
|
|
|
void LazyCallGraph::SCC::insert(Node &N) {
|
2014-04-26 03:03:46 +02:00
|
|
|
N.DFSNumber = N.LowLink = -1;
|
|
|
|
Nodes.push_back(&N);
|
2014-04-27 03:59:50 +02:00
|
|
|
G->SCCMap[&N] = this;
|
2014-04-26 03:03:46 +02:00
|
|
|
}
|
|
|
|
|
2014-05-01 14:12:42 +02:00
|
|
|
bool LazyCallGraph::SCC::isDescendantOf(const SCC &C) const {
|
|
|
|
// Walk up the parents of this SCC and verify that we eventually find C.
|
|
|
|
SmallVector<const SCC *, 4> AncestorWorklist;
|
|
|
|
AncestorWorklist.push_back(this);
|
|
|
|
do {
|
|
|
|
const SCC *AncestorC = AncestorWorklist.pop_back_val();
|
|
|
|
if (AncestorC->isChildOf(C))
|
|
|
|
return true;
|
|
|
|
for (const SCC *ParentC : AncestorC->ParentSCCs)
|
|
|
|
AncestorWorklist.push_back(ParentC);
|
|
|
|
} while (!AncestorWorklist.empty());
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-04-30 12:48:36 +02:00
|
|
|
void LazyCallGraph::SCC::insertIntraSCCEdge(Node &CallerN, Node &CalleeN) {
|
|
|
|
// First insert it into the caller.
|
|
|
|
CallerN.insertEdgeInternal(CalleeN);
|
|
|
|
|
|
|
|
assert(G->SCCMap.lookup(&CallerN) == this && "Caller must be in this SCC.");
|
|
|
|
assert(G->SCCMap.lookup(&CalleeN) == this && "Callee must be in this SCC.");
|
|
|
|
|
|
|
|
// Nothing changes about this SCC or any other.
|
|
|
|
}
|
|
|
|
|
2014-05-01 14:18:20 +02:00
|
|
|
void LazyCallGraph::SCC::insertOutgoingEdge(Node &CallerN, Node &CalleeN) {
|
|
|
|
// First insert it into the caller.
|
|
|
|
CallerN.insertEdgeInternal(CalleeN);
|
|
|
|
|
|
|
|
assert(G->SCCMap.lookup(&CallerN) == this && "Caller must be in this SCC.");
|
|
|
|
|
|
|
|
SCC &CalleeC = *G->SCCMap.lookup(&CalleeN);
|
|
|
|
assert(&CalleeC != this && "Callee must not be in this SCC.");
|
|
|
|
assert(CalleeC.isDescendantOf(*this) &&
|
|
|
|
"Callee must be a descendant of the Caller.");
|
|
|
|
|
|
|
|
// The only change required is to add this SCC to the parent set of the callee.
|
|
|
|
CalleeC.ParentSCCs.insert(this);
|
|
|
|
}
|
|
|
|
|
2014-05-04 11:38:32 +02:00
|
|
|
SmallVector<LazyCallGraph::SCC *, 1>
|
|
|
|
LazyCallGraph::SCC::insertIncomingEdge(Node &CallerN, Node &CalleeN) {
|
|
|
|
// First insert it into the caller.
|
|
|
|
CallerN.insertEdgeInternal(CalleeN);
|
|
|
|
|
|
|
|
assert(G->SCCMap.lookup(&CalleeN) == this && "Callee must be in this SCC.");
|
|
|
|
|
|
|
|
SCC &CallerC = *G->SCCMap.lookup(&CallerN);
|
|
|
|
assert(&CallerC != this && "Caller must not be in this SCC.");
|
|
|
|
assert(CallerC.isDescendantOf(*this) &&
|
|
|
|
"Caller must be a descendant of the Callee.");
|
|
|
|
|
|
|
|
// The algorithm we use for merging SCCs based on the cycle introduced here
|
|
|
|
// is to walk the SCC inverted DAG formed by the parent SCC sets. The inverse
|
|
|
|
// graph has the same cycle properties as the actual DAG of the SCCs, and
|
|
|
|
// when forming SCCs lazily by a DFS, the bottom of the graph won't exist in
|
|
|
|
// many cases which should prune the search space.
|
|
|
|
//
|
|
|
|
// FIXME: We can get this pruning behavior even after the incremental SCC
|
|
|
|
// formation by leaving behind (conservative) DFS numberings in the nodes,
|
|
|
|
// and pruning the search with them. These would need to be cleverly updated
|
|
|
|
// during the removal of intra-SCC edges, but could be preserved
|
|
|
|
// conservatively.
|
|
|
|
|
|
|
|
// The set of SCCs that are connected to the caller, and thus will
|
|
|
|
// participate in the merged connected component.
|
|
|
|
SmallPtrSet<SCC *, 8> ConnectedSCCs;
|
|
|
|
ConnectedSCCs.insert(this);
|
|
|
|
ConnectedSCCs.insert(&CallerC);
|
|
|
|
|
|
|
|
// We build up a DFS stack of the parents chains.
|
|
|
|
SmallVector<std::pair<SCC *, SCC::parent_iterator>, 8> DFSSCCs;
|
|
|
|
SmallPtrSet<SCC *, 8> VisitedSCCs;
|
|
|
|
int ConnectedDepth = -1;
|
|
|
|
SCC *C = this;
|
|
|
|
parent_iterator I = parent_begin(), E = parent_end();
|
|
|
|
for (;;) {
|
|
|
|
while (I != E) {
|
|
|
|
SCC &ParentSCC = *I++;
|
|
|
|
|
|
|
|
// If we have already processed this parent SCC, skip it, and remember
|
|
|
|
// whether it was connected so we don't have to check the rest of the
|
|
|
|
// stack. This also handles when we reach a child of the 'this' SCC (the
|
|
|
|
// callee) which terminates the search.
|
|
|
|
if (ConnectedSCCs.count(&ParentSCC)) {
|
|
|
|
ConnectedDepth = std::max<int>(ConnectedDepth, DFSSCCs.size());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (VisitedSCCs.count(&ParentSCC))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// We fully explore the depth-first space, adding nodes to the connected
|
|
|
|
// set only as we pop them off, so "recurse" by rotating to the parent.
|
|
|
|
DFSSCCs.push_back(std::make_pair(C, I));
|
|
|
|
C = &ParentSCC;
|
|
|
|
I = ParentSCC.parent_begin();
|
|
|
|
E = ParentSCC.parent_end();
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we've found a connection anywhere below this point on the stack (and
|
|
|
|
// thus up the parent graph from the caller), the current node needs to be
|
|
|
|
// added to the connected set now that we've processed all of its parents.
|
|
|
|
if ((int)DFSSCCs.size() == ConnectedDepth) {
|
|
|
|
--ConnectedDepth; // We're finished with this connection.
|
|
|
|
ConnectedSCCs.insert(C);
|
|
|
|
} else {
|
|
|
|
// Otherwise remember that its parents don't ever connect.
|
|
|
|
assert(ConnectedDepth < (int)DFSSCCs.size() &&
|
|
|
|
"Cannot have a connected depth greater than the DFS depth!");
|
|
|
|
VisitedSCCs.insert(C);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DFSSCCs.empty())
|
|
|
|
break; // We've walked all the parents of the caller transitively.
|
|
|
|
|
|
|
|
// Pop off the prior node and position to unwind the depth first recursion.
|
|
|
|
std::tie(C, I) = DFSSCCs.pop_back_val();
|
|
|
|
E = C->parent_end();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we have identified all of the SCCs which need to be merged into
|
|
|
|
// a connected set with the inserted edge, merge all of them into this SCC.
|
|
|
|
// FIXME: This operation currently creates ordering stability problems
|
|
|
|
// because we don't use stably ordered containers for the parent SCCs or the
|
|
|
|
// connected SCCs.
|
|
|
|
unsigned NewNodeBeginIdx = Nodes.size();
|
|
|
|
for (SCC *C : ConnectedSCCs) {
|
|
|
|
if (C == this)
|
|
|
|
continue;
|
|
|
|
for (SCC *ParentC : C->ParentSCCs)
|
|
|
|
if (!ConnectedSCCs.count(ParentC))
|
|
|
|
ParentSCCs.insert(ParentC);
|
|
|
|
C->ParentSCCs.clear();
|
|
|
|
|
|
|
|
for (Node *N : *C) {
|
|
|
|
for (Node &ChildN : *N) {
|
|
|
|
SCC &ChildC = *G->SCCMap.lookup(&ChildN);
|
|
|
|
if (&ChildC != C)
|
|
|
|
ChildC.ParentSCCs.erase(C);
|
|
|
|
}
|
|
|
|
G->SCCMap[N] = this;
|
|
|
|
Nodes.push_back(N);
|
|
|
|
}
|
|
|
|
C->Nodes.clear();
|
|
|
|
}
|
|
|
|
for (auto I = Nodes.begin() + NewNodeBeginIdx, E = Nodes.end(); I != E; ++I)
|
|
|
|
for (Node &ChildN : **I) {
|
|
|
|
SCC &ChildC = *G->SCCMap.lookup(&ChildN);
|
|
|
|
if (&ChildC != this)
|
|
|
|
ChildC.ParentSCCs.insert(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
// We return the list of SCCs which were merged so that callers can
|
|
|
|
// invalidate any data they have associated with those SCCs. Note that these
|
|
|
|
// SCCs are no longer in an interesting state (they are totally empty) but
|
|
|
|
// the pointers will remain stable for the life of the graph itself.
|
|
|
|
return SmallVector<SCC *, 1>(ConnectedSCCs.begin(), ConnectedSCCs.end());
|
|
|
|
}
|
|
|
|
|
2014-04-27 03:59:50 +02:00
|
|
|
void LazyCallGraph::SCC::removeInterSCCEdge(Node &CallerN, Node &CalleeN) {
|
|
|
|
// First remove it from the node.
|
|
|
|
CallerN.removeEdgeInternal(CalleeN.getFunction());
|
|
|
|
|
|
|
|
assert(G->SCCMap.lookup(&CallerN) == this &&
|
|
|
|
"The caller must be a member of this SCC.");
|
|
|
|
|
|
|
|
SCC &CalleeC = *G->SCCMap.lookup(&CalleeN);
|
|
|
|
assert(&CalleeC != this &&
|
|
|
|
"This API only supports the rmoval of inter-SCC edges.");
|
|
|
|
|
|
|
|
assert(std::find(G->LeafSCCs.begin(), G->LeafSCCs.end(), this) ==
|
|
|
|
G->LeafSCCs.end() &&
|
2014-04-23 13:03:03 +02:00
|
|
|
"Cannot have a leaf SCC caller with a different SCC callee.");
|
|
|
|
|
|
|
|
bool HasOtherCallToCalleeC = false;
|
|
|
|
bool HasOtherCallOutsideSCC = false;
|
|
|
|
for (Node *N : *this) {
|
2014-04-27 03:59:50 +02:00
|
|
|
for (Node &OtherCalleeN : *N) {
|
|
|
|
SCC &OtherCalleeC = *G->SCCMap.lookup(&OtherCalleeN);
|
2014-04-24 01:34:48 +02:00
|
|
|
if (&OtherCalleeC == &CalleeC) {
|
2014-04-23 13:03:03 +02:00
|
|
|
HasOtherCallToCalleeC = true;
|
|
|
|
break;
|
|
|
|
}
|
2014-04-24 01:34:48 +02:00
|
|
|
if (&OtherCalleeC != this)
|
2014-04-23 13:03:03 +02:00
|
|
|
HasOtherCallOutsideSCC = true;
|
|
|
|
}
|
|
|
|
if (HasOtherCallToCalleeC)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Because the SCCs form a DAG, deleting such an edge cannot change the set
|
|
|
|
// of SCCs in the graph. However, it may cut an edge of the SCC DAG, making
|
|
|
|
// the caller no longer a parent of the callee. Walk the other call edges
|
|
|
|
// in the caller to tell.
|
|
|
|
if (!HasOtherCallToCalleeC) {
|
2014-04-24 11:22:31 +02:00
|
|
|
bool Removed = CalleeC.ParentSCCs.erase(this);
|
2014-04-23 13:03:03 +02:00
|
|
|
(void)Removed;
|
|
|
|
assert(Removed &&
|
|
|
|
"Did not find the caller SCC in the callee SCC's parent list!");
|
|
|
|
|
|
|
|
// It may orphan an SCC if it is the last edge reaching it, but that does
|
|
|
|
// not violate any invariants of the graph.
|
|
|
|
if (CalleeC.ParentSCCs.empty())
|
2014-04-27 03:59:50 +02:00
|
|
|
DEBUG(dbgs() << "LCG: Update removing " << CallerN.getFunction().getName()
|
|
|
|
<< " -> " << CalleeN.getFunction().getName()
|
|
|
|
<< " edge orphaned the callee's SCC!\n");
|
2014-04-23 13:03:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// It may make the Caller SCC a leaf SCC.
|
|
|
|
if (!HasOtherCallOutsideSCC)
|
2014-04-27 03:59:50 +02:00
|
|
|
G->LeafSCCs.push_back(this);
|
2014-04-23 13:03:03 +02:00
|
|
|
}
|
|
|
|
|
2014-04-26 11:06:53 +02:00
|
|
|
void LazyCallGraph::SCC::internalDFS(
|
|
|
|
SmallVectorImpl<std::pair<Node *, Node::iterator>> &DFSStack,
|
|
|
|
SmallVectorImpl<Node *> &PendingSCCStack, Node *N,
|
|
|
|
SmallVectorImpl<SCC *> &ResultSCCs) {
|
|
|
|
Node::iterator I = N->begin();
|
|
|
|
N->LowLink = N->DFSNumber = 1;
|
|
|
|
int NextDFSNumber = 2;
|
2014-04-23 13:03:03 +02:00
|
|
|
for (;;) {
|
2014-04-24 11:59:59 +02:00
|
|
|
assert(N->DFSNumber != 0 && "We should always assign a DFS number "
|
2014-04-26 05:36:42 +02:00
|
|
|
"before processing a node.");
|
2014-04-23 13:03:03 +02:00
|
|
|
|
2014-04-25 08:45:06 +02:00
|
|
|
// We simulate recursion by popping out of the nested loop and continuing.
|
2014-04-26 11:06:53 +02:00
|
|
|
Node::iterator E = N->end();
|
|
|
|
while (I != E) {
|
2014-04-25 08:45:06 +02:00
|
|
|
Node &ChildN = *I;
|
2014-04-27 03:59:50 +02:00
|
|
|
if (SCC *ChildSCC = G->SCCMap.lookup(&ChildN)) {
|
2014-04-25 11:52:44 +02:00
|
|
|
// Check if we have reached a node in the new (known connected) set of
|
|
|
|
// this SCC. If so, the entire stack is necessarily in that set and we
|
|
|
|
// can re-start.
|
|
|
|
if (ChildSCC == this) {
|
2014-04-27 03:59:50 +02:00
|
|
|
insert(*N);
|
2014-04-26 03:03:46 +02:00
|
|
|
while (!PendingSCCStack.empty())
|
2014-04-27 03:59:50 +02:00
|
|
|
insert(*PendingSCCStack.pop_back_val());
|
2014-04-26 03:03:46 +02:00
|
|
|
while (!DFSStack.empty())
|
2014-04-27 03:59:50 +02:00
|
|
|
insert(*DFSStack.pop_back_val().first);
|
2014-04-26 11:06:53 +02:00
|
|
|
return;
|
2014-04-25 11:52:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// If this child isn't currently in this SCC, no need to process it.
|
|
|
|
// However, we do need to remove this SCC from its SCC's parent set.
|
2014-04-25 11:08:10 +02:00
|
|
|
ChildSCC->ParentSCCs.erase(this);
|
2014-04-26 11:06:53 +02:00
|
|
|
++I;
|
2014-04-25 08:45:06 +02:00
|
|
|
continue;
|
2014-04-23 13:03:03 +02:00
|
|
|
}
|
|
|
|
|
2014-04-25 08:45:06 +02:00
|
|
|
if (ChildN.DFSNumber == 0) {
|
|
|
|
// Mark that we should start at this child when next this node is the
|
|
|
|
// top of the stack. We don't start at the next child to ensure this
|
|
|
|
// child's lowlink is reflected.
|
2014-04-26 05:36:42 +02:00
|
|
|
DFSStack.push_back(std::make_pair(N, I));
|
2014-04-25 08:45:06 +02:00
|
|
|
|
2014-04-26 11:06:53 +02:00
|
|
|
// Continue, resetting to the child node.
|
2014-04-25 08:45:06 +02:00
|
|
|
ChildN.LowLink = ChildN.DFSNumber = NextDFSNumber++;
|
2014-04-26 05:36:42 +02:00
|
|
|
N = &ChildN;
|
2014-04-26 11:06:53 +02:00
|
|
|
I = ChildN.begin();
|
|
|
|
E = ChildN.end();
|
|
|
|
continue;
|
2014-04-24 13:05:20 +02:00
|
|
|
}
|
2014-04-23 13:03:03 +02:00
|
|
|
|
2014-05-15 03:52:21 +02:00
|
|
|
// Track the lowest link of the children, if any are still in the stack.
|
2014-04-25 08:45:06 +02:00
|
|
|
// Any child not on the stack will have a LowLink of -1.
|
|
|
|
assert(ChildN.LowLink != 0 &&
|
|
|
|
"Low-link must not be zero with a non-zero DFS number.");
|
|
|
|
if (ChildN.LowLink >= 0 && ChildN.LowLink < N->LowLink)
|
|
|
|
N->LowLink = ChildN.LowLink;
|
2014-04-26 11:06:53 +02:00
|
|
|
++I;
|
2014-04-25 08:45:06 +02:00
|
|
|
}
|
|
|
|
|
2014-04-26 11:06:53 +02:00
|
|
|
if (N->LowLink == N->DFSNumber) {
|
2014-04-27 03:59:50 +02:00
|
|
|
ResultSCCs.push_back(G->formSCC(N, PendingSCCStack));
|
2014-04-26 11:06:53 +02:00
|
|
|
if (DFSStack.empty())
|
|
|
|
return;
|
|
|
|
} else {
|
2014-04-26 05:36:42 +02:00
|
|
|
// At this point we know that N cannot ever be an SCC root. Its low-link
|
|
|
|
// is not its dfs-number, and we've processed all of its children. It is
|
|
|
|
// just sitting here waiting until some node further down the stack gets
|
|
|
|
// low-link == dfs-number and pops it off as well. Move it to the pending
|
|
|
|
// stack which is pulled into the next SCC to be formed.
|
|
|
|
PendingSCCStack.push_back(N);
|
2014-04-25 08:45:06 +02:00
|
|
|
|
2014-04-26 05:36:42 +02:00
|
|
|
assert(!DFSStack.empty() && "We shouldn't have an empty stack!");
|
2014-04-25 08:45:06 +02:00
|
|
|
}
|
2014-04-24 13:05:20 +02:00
|
|
|
|
2014-04-26 11:06:53 +02:00
|
|
|
N = DFSStack.back().first;
|
|
|
|
I = DFSStack.back().second;
|
|
|
|
DFSStack.pop_back();
|
2014-04-23 13:03:03 +02:00
|
|
|
}
|
2014-04-26 11:06:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SmallVector<LazyCallGraph::SCC *, 1>
|
2014-04-27 03:59:50 +02:00
|
|
|
LazyCallGraph::SCC::removeIntraSCCEdge(Node &CallerN,
|
|
|
|
Node &CalleeN) {
|
|
|
|
// First remove it from the node.
|
|
|
|
CallerN.removeEdgeInternal(CalleeN.getFunction());
|
|
|
|
|
2014-04-28 12:49:06 +02:00
|
|
|
// We return a list of the resulting *new* SCCs in postorder.
|
2014-04-26 11:06:53 +02:00
|
|
|
SmallVector<SCC *, 1> ResultSCCs;
|
|
|
|
|
|
|
|
// Direct recursion doesn't impact the SCC graph at all.
|
2014-04-27 03:59:50 +02:00
|
|
|
if (&CallerN == &CalleeN)
|
2014-04-26 11:06:53 +02:00
|
|
|
return ResultSCCs;
|
|
|
|
|
|
|
|
// The worklist is every node in the original SCC.
|
|
|
|
SmallVector<Node *, 1> Worklist;
|
|
|
|
Worklist.swap(Nodes);
|
|
|
|
for (Node *N : Worklist) {
|
|
|
|
// The nodes formerly in this SCC are no longer in any SCC.
|
|
|
|
N->DFSNumber = 0;
|
|
|
|
N->LowLink = 0;
|
2014-04-27 03:59:50 +02:00
|
|
|
G->SCCMap.erase(N);
|
2014-04-26 11:06:53 +02:00
|
|
|
}
|
|
|
|
assert(Worklist.size() > 1 && "We have to have at least two nodes to have an "
|
|
|
|
"edge between them that is within the SCC.");
|
|
|
|
|
|
|
|
// The callee can already reach every node in this SCC (by definition). It is
|
|
|
|
// the only node we know will stay inside this SCC. Everything which
|
|
|
|
// transitively reaches Callee will also remain in the SCC. To model this we
|
|
|
|
// incrementally add any chain of nodes which reaches something in the new
|
|
|
|
// node set to the new node set. This short circuits one side of the Tarjan's
|
|
|
|
// walk.
|
2014-04-27 03:59:50 +02:00
|
|
|
insert(CalleeN);
|
2014-04-26 11:06:53 +02:00
|
|
|
|
|
|
|
// We're going to do a full mini-Tarjan's walk using a local stack here.
|
|
|
|
SmallVector<std::pair<Node *, Node::iterator>, 4> DFSStack;
|
|
|
|
SmallVector<Node *, 4> PendingSCCStack;
|
|
|
|
do {
|
|
|
|
Node *N = Worklist.pop_back_val();
|
|
|
|
if (N->DFSNumber == 0)
|
2014-04-27 03:59:50 +02:00
|
|
|
internalDFS(DFSStack, PendingSCCStack, N, ResultSCCs);
|
2014-04-26 11:06:53 +02:00
|
|
|
|
|
|
|
assert(DFSStack.empty() && "Didn't flush the entire DFS stack!");
|
|
|
|
assert(PendingSCCStack.empty() && "Didn't flush all pending SCC nodes!");
|
|
|
|
} while (!Worklist.empty());
|
2014-04-23 13:03:03 +02:00
|
|
|
|
|
|
|
// Now we need to reconnect the current SCC to the graph.
|
|
|
|
bool IsLeafSCC = true;
|
2014-04-25 11:52:44 +02:00
|
|
|
for (Node *N : Nodes) {
|
2014-04-24 01:34:48 +02:00
|
|
|
for (Node &ChildN : *N) {
|
2014-04-27 03:59:50 +02:00
|
|
|
SCC &ChildSCC = *G->SCCMap.lookup(&ChildN);
|
2014-04-25 11:52:44 +02:00
|
|
|
if (&ChildSCC == this)
|
|
|
|
continue;
|
2014-04-24 01:34:48 +02:00
|
|
|
ChildSCC.ParentSCCs.insert(this);
|
2014-04-23 13:03:03 +02:00
|
|
|
IsLeafSCC = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifndef NDEBUG
|
2014-04-28 12:49:06 +02:00
|
|
|
if (!ResultSCCs.empty())
|
2014-04-23 13:03:03 +02:00
|
|
|
assert(!IsLeafSCC && "This SCC cannot be a leaf as we have split out new "
|
|
|
|
"SCCs by removing this edge.");
|
2014-04-27 03:59:50 +02:00
|
|
|
if (!std::any_of(G->LeafSCCs.begin(), G->LeafSCCs.end(),
|
2014-04-23 13:03:03 +02:00
|
|
|
[&](SCC *C) { return C == this; }))
|
|
|
|
assert(!IsLeafSCC && "This SCC cannot be a leaf as it already had child "
|
|
|
|
"SCCs before we removed this edge.");
|
|
|
|
#endif
|
|
|
|
// If this SCC stopped being a leaf through this edge removal, remove it from
|
|
|
|
// the leaf SCC list.
|
2014-04-28 12:49:06 +02:00
|
|
|
if (!IsLeafSCC && !ResultSCCs.empty())
|
2014-04-27 03:59:50 +02:00
|
|
|
G->LeafSCCs.erase(std::remove(G->LeafSCCs.begin(), G->LeafSCCs.end(), this),
|
|
|
|
G->LeafSCCs.end());
|
2014-04-23 13:03:03 +02:00
|
|
|
|
|
|
|
// Return the new list of SCCs.
|
|
|
|
return ResultSCCs;
|
|
|
|
}
|
|
|
|
|
2014-04-28 13:10:23 +02:00
|
|
|
void LazyCallGraph::insertEdge(Node &CallerN, Function &Callee) {
|
|
|
|
assert(SCCMap.empty() && DFSStack.empty() &&
|
|
|
|
"This method cannot be called after SCCs have been formed!");
|
|
|
|
|
|
|
|
return CallerN.insertEdgeInternal(Callee);
|
|
|
|
}
|
|
|
|
|
2014-04-23 13:03:03 +02:00
|
|
|
void LazyCallGraph::removeEdge(Node &CallerN, Function &Callee) {
|
2014-04-27 03:59:50 +02:00
|
|
|
assert(SCCMap.empty() && DFSStack.empty() &&
|
|
|
|
"This method cannot be called after SCCs have been formed!");
|
2014-04-23 13:03:03 +02:00
|
|
|
|
2014-04-27 03:59:50 +02:00
|
|
|
return CallerN.removeEdgeInternal(Callee);
|
2014-04-23 13:03:03 +02:00
|
|
|
}
|
|
|
|
|
2014-04-24 01:20:36 +02:00
|
|
|
LazyCallGraph::Node &LazyCallGraph::insertInto(Function &F, Node *&MappedN) {
|
|
|
|
return *new (MappedN = BPA.Allocate()) Node(*this, F);
|
2014-04-18 13:02:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void LazyCallGraph::updateGraphPtrs() {
|
2014-04-17 09:25:59 +02:00
|
|
|
// Process all nodes updating the graph pointers.
|
2014-04-27 03:59:50 +02:00
|
|
|
{
|
|
|
|
SmallVector<Node *, 16> Worklist;
|
|
|
|
for (auto &Entry : EntryNodes)
|
|
|
|
if (Node *EntryN = Entry.dyn_cast<Node *>())
|
|
|
|
Worklist.push_back(EntryN);
|
|
|
|
|
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Node *N = Worklist.pop_back_val();
|
|
|
|
N->G = this;
|
|
|
|
for (auto &Callee : N->Callees)
|
[LCG] Actually test the *basic* edge removal bits (IE, the non-SCC
bits), and discover that it's totally broken. Yay tests. Boo bug. Fix
the basic edge removal so that it works by nulling out the removed edges
rather than actually removing them. This leaves the indices valid in the
map from callee to index, and preserves some of the locality for
iterating over edges. The iterator is made bidirectional to reflect that
it now has to skip over null entries, and the skipping logic is layered
onto it.
As future work, I would like to track essentially the "load factor" of
the edge list, and when it falls below a threshold do a compaction.
An alternative I considered (and continue to consider) is storing the
callees in a doubly linked list where each element of the list is in
a set (which is essentially the classical linked-hash-table
datastructure). The problem with that approach is that either you need
to heap allocate the linked list nodes and use pointers to them, or use
a bucket hash table (with even *more* linked list pointer overhead!),
etc. It's pretty easy to get 5x overhead for values that are just
pointers. So far, I think punching holes in the vector, and periodic
compaction is likely to be much more efficient overall in the space/time
tradeoff.
llvm-svn: 207619
2014-04-30 09:45:27 +02:00
|
|
|
if (!Callee.isNull())
|
|
|
|
if (Node *CalleeN = Callee.dyn_cast<Node *>())
|
|
|
|
Worklist.push_back(CalleeN);
|
2014-04-27 03:59:50 +02:00
|
|
|
}
|
|
|
|
}
|
2014-04-17 09:25:59 +02:00
|
|
|
|
2014-04-27 03:59:50 +02:00
|
|
|
// Process all SCCs updating the graph pointers.
|
|
|
|
{
|
|
|
|
SmallVector<SCC *, 16> Worklist(LeafSCCs.begin(), LeafSCCs.end());
|
|
|
|
|
|
|
|
while (!Worklist.empty()) {
|
|
|
|
SCC *C = Worklist.pop_back_val();
|
|
|
|
C->G = this;
|
|
|
|
Worklist.insert(Worklist.end(), C->ParentSCCs.begin(),
|
|
|
|
C->ParentSCCs.end());
|
|
|
|
}
|
2014-04-17 09:25:59 +02:00
|
|
|
}
|
2014-02-06 05:37:03 +01:00
|
|
|
}
|
|
|
|
|
2014-04-24 13:05:20 +02:00
|
|
|
LazyCallGraph::SCC *LazyCallGraph::formSCC(Node *RootN,
|
|
|
|
SmallVectorImpl<Node *> &NodeStack) {
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
// The tail of the stack is the new SCC. Allocate the SCC and pop the stack
|
|
|
|
// into it.
|
2014-04-27 03:59:50 +02:00
|
|
|
SCC *NewSCC = new (SCCBPA.Allocate()) SCC(*this);
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
|
2014-04-24 13:05:20 +02:00
|
|
|
while (!NodeStack.empty() && NodeStack.back()->DFSNumber > RootN->DFSNumber) {
|
2014-04-26 03:03:46 +02:00
|
|
|
assert(NodeStack.back()->LowLink >= RootN->LowLink &&
|
2014-04-23 12:31:17 +02:00
|
|
|
"We cannot have a low link in an SCC lower than its root on the "
|
|
|
|
"stack!");
|
2014-04-27 03:59:50 +02:00
|
|
|
NewSCC->insert(*NodeStack.pop_back_val());
|
2014-04-23 12:31:17 +02:00
|
|
|
}
|
2014-04-27 03:59:50 +02:00
|
|
|
NewSCC->insert(*RootN);
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
|
|
|
|
// A final pass over all edges in the SCC (this remains linear as we only
|
|
|
|
// do this once when we build the SCC) to connect it to the parent sets of
|
|
|
|
// its children.
|
|
|
|
bool IsLeafSCC = true;
|
|
|
|
for (Node *SCCN : NewSCC->Nodes)
|
2014-04-24 01:34:48 +02:00
|
|
|
for (Node &SCCChildN : *SCCN) {
|
|
|
|
SCC &ChildSCC = *SCCMap.lookup(&SCCChildN);
|
2014-05-01 14:16:31 +02:00
|
|
|
if (&ChildSCC == NewSCC)
|
|
|
|
continue;
|
2014-04-24 01:34:48 +02:00
|
|
|
ChildSCC.ParentSCCs.insert(NewSCC);
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
IsLeafSCC = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// For the SCCs where we fine no child SCCs, add them to the leaf list.
|
|
|
|
if (IsLeafSCC)
|
|
|
|
LeafSCCs.push_back(NewSCC);
|
|
|
|
|
|
|
|
return NewSCC;
|
|
|
|
}
|
|
|
|
|
2014-04-23 08:09:03 +02:00
|
|
|
LazyCallGraph::SCC *LazyCallGraph::getNextSCCInPostOrder() {
|
2014-04-26 11:28:00 +02:00
|
|
|
Node *N;
|
|
|
|
Node::iterator I;
|
|
|
|
if (!DFSStack.empty()) {
|
|
|
|
N = DFSStack.back().first;
|
|
|
|
I = DFSStack.back().second;
|
|
|
|
DFSStack.pop_back();
|
|
|
|
} else {
|
2014-04-23 08:09:03 +02:00
|
|
|
// If we've handled all candidate entry nodes to the SCC forest, we're done.
|
2014-04-26 11:45:55 +02:00
|
|
|
do {
|
|
|
|
if (SCCEntryNodes.empty())
|
|
|
|
return nullptr;
|
2014-04-23 08:09:03 +02:00
|
|
|
|
2014-04-26 11:45:55 +02:00
|
|
|
N = &get(*SCCEntryNodes.pop_back_val());
|
|
|
|
} while (N->DFSNumber != 0);
|
2014-04-26 11:28:00 +02:00
|
|
|
I = N->begin();
|
|
|
|
N->LowLink = N->DFSNumber = 1;
|
2014-04-24 11:59:59 +02:00
|
|
|
NextDFSNumber = 2;
|
2014-04-23 08:09:03 +02:00
|
|
|
}
|
|
|
|
|
2014-04-24 23:19:30 +02:00
|
|
|
for (;;) {
|
2014-04-24 13:05:20 +02:00
|
|
|
assert(N->DFSNumber != 0 && "We should always assign a DFS number "
|
|
|
|
"before placing a node onto the stack.");
|
|
|
|
|
2014-04-26 11:28:00 +02:00
|
|
|
Node::iterator E = N->end();
|
|
|
|
while (I != E) {
|
2014-04-24 01:34:48 +02:00
|
|
|
Node &ChildN = *I;
|
|
|
|
if (ChildN.DFSNumber == 0) {
|
2014-04-23 12:31:17 +02:00
|
|
|
// Mark that we should start at this child when next this node is the
|
|
|
|
// top of the stack. We don't start at the next child to ensure this
|
|
|
|
// child's lowlink is reflected.
|
2014-04-26 11:28:00 +02:00
|
|
|
DFSStack.push_back(std::make_pair(N, N->begin()));
|
2014-04-23 12:31:17 +02:00
|
|
|
|
|
|
|
// Recurse onto this node via a tail call.
|
2014-04-24 11:59:59 +02:00
|
|
|
assert(!SCCMap.count(&ChildN) &&
|
|
|
|
"Found a node with 0 DFS number but already in an SCC!");
|
|
|
|
ChildN.LowLink = ChildN.DFSNumber = NextDFSNumber++;
|
2014-04-26 11:28:00 +02:00
|
|
|
N = &ChildN;
|
|
|
|
I = ChildN.begin();
|
|
|
|
E = ChildN.end();
|
|
|
|
continue;
|
2014-04-23 12:31:17 +02:00
|
|
|
}
|
|
|
|
|
2014-05-15 03:52:21 +02:00
|
|
|
// Track the lowest link of the children, if any are still in the stack.
|
2014-04-24 01:34:48 +02:00
|
|
|
assert(ChildN.LowLink != 0 &&
|
2014-04-24 00:28:13 +02:00
|
|
|
"Low-link must not be zero with a non-zero DFS number.");
|
2014-04-24 01:34:48 +02:00
|
|
|
if (ChildN.LowLink >= 0 && ChildN.LowLink < N->LowLink)
|
|
|
|
N->LowLink = ChildN.LowLink;
|
2014-04-26 11:28:00 +02:00
|
|
|
++I;
|
2014-04-23 08:09:03 +02:00
|
|
|
}
|
|
|
|
|
2014-04-23 12:31:17 +02:00
|
|
|
if (N->LowLink == N->DFSNumber)
|
|
|
|
// Form the new SCC out of the top of the DFS stack.
|
2014-04-24 13:05:20 +02:00
|
|
|
return formSCC(N, PendingSCCStack);
|
|
|
|
|
|
|
|
// At this point we know that N cannot ever be an SCC root. Its low-link
|
|
|
|
// is not its dfs-number, and we've processed all of its children. It is
|
|
|
|
// just sitting here waiting until some node further down the stack gets
|
|
|
|
// low-link == dfs-number and pops it off as well. Move it to the pending
|
|
|
|
// stack which is pulled into the next SCC to be formed.
|
|
|
|
PendingSCCStack.push_back(N);
|
2014-04-26 11:28:00 +02:00
|
|
|
|
|
|
|
assert(!DFSStack.empty() && "We never found a viable root!");
|
|
|
|
N = DFSStack.back().first;
|
|
|
|
I = DFSStack.back().second;
|
|
|
|
DFSStack.pop_back();
|
2014-04-24 23:19:30 +02:00
|
|
|
}
|
2014-04-23 08:09:03 +02:00
|
|
|
}
|
|
|
|
|
2014-02-06 05:37:03 +01:00
|
|
|
char LazyCallGraphAnalysis::PassID;
|
|
|
|
|
|
|
|
LazyCallGraphPrinterPass::LazyCallGraphPrinterPass(raw_ostream &OS) : OS(OS) {}
|
|
|
|
|
2015-01-14 01:27:45 +01:00
|
|
|
static void printNodes(raw_ostream &OS, LazyCallGraph::Node &N,
|
|
|
|
SmallPtrSetImpl<LazyCallGraph::Node *> &Printed) {
|
|
|
|
// Recurse depth first through the nodes.
|
|
|
|
for (LazyCallGraph::Node &ChildN : N)
|
|
|
|
if (Printed.insert(&ChildN).second)
|
|
|
|
printNodes(OS, ChildN, Printed);
|
|
|
|
|
|
|
|
OS << " Call edges in function: " << N.getFunction().getName() << "\n";
|
|
|
|
for (LazyCallGraph::iterator I = N.begin(), E = N.end(); I != E; ++I)
|
|
|
|
OS << " -> " << I->getFunction().getName() << "\n";
|
|
|
|
|
|
|
|
OS << "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
static void printSCC(raw_ostream &OS, LazyCallGraph::SCC &SCC) {
|
|
|
|
ptrdiff_t SCCSize = std::distance(SCC.begin(), SCC.end());
|
|
|
|
OS << " SCC with " << SCCSize << " functions:\n";
|
|
|
|
|
|
|
|
for (LazyCallGraph::Node *N : SCC)
|
|
|
|
OS << " " << N->getFunction().getName() << "\n";
|
|
|
|
|
|
|
|
OS << "\n";
|
|
|
|
}
|
|
|
|
|
2015-01-05 03:47:05 +01:00
|
|
|
PreservedAnalyses LazyCallGraphPrinterPass::run(Module &M,
|
2014-03-10 03:14:14 +01:00
|
|
|
ModuleAnalysisManager *AM) {
|
2015-01-14 01:27:45 +01:00
|
|
|
LazyCallGraph &G = AM->getResult<LazyCallGraphAnalysis>(M);
|
|
|
|
|
|
|
|
OS << "Printing the call graph for module: " << M.getModuleIdentifier()
|
|
|
|
<< "\n\n";
|
|
|
|
|
|
|
|
SmallPtrSet<LazyCallGraph::Node *, 16> Printed;
|
|
|
|
for (LazyCallGraph::Node &N : G)
|
|
|
|
if (Printed.insert(&N).second)
|
|
|
|
printNodes(OS, N, Printed);
|
|
|
|
|
|
|
|
for (LazyCallGraph::SCC &SCC : G.postorder_sccs())
|
|
|
|
printSCC(OS, SCC);
|
[LCG] Add support for building persistent and connected SCCs to the
LazyCallGraph. This is the start of the whole point of this different
abstraction, but it is just the initial bits. Here is a run-down of
what's going on here. I'm planning to incorporate some (or all) of this
into comments going forward, hopefully with better editing and wording.
=]
The crux of the problem with the traditional way of building SCCs is
that they are ephemeral. The new pass manager however really needs the
ability to associate analysis passes and results of analysis passes with
SCCs in order to expose these analysis passes to the SCC passes. Making
this work is kind-of the whole point of the new pass manager. =]
So, when we're building SCCs for the call graph, we actually want to
build persistent nodes that stick around and can be reasoned about
later. We'd also like the ability to walk the SCC graph in more complex
ways than just the traditional postorder traversal of the current CGSCC
walk. That means that in addition to being persistent, the SCCs need to
be connected into a useful graph structure.
However, we still want the SCCs to be formed lazily where possible.
These constraints are quite hard to satisfy with the SCC iterator. Also,
using that would bypass our ability to actually add data to the nodes of
the call graph to facilite implementing the Tarjan walk. So I've
re-implemented things in a more direct and embedded way. This
immediately makes it easy to get the persistence and connectivity
correct, and it also allows leveraging the existing nodes to simplify
the algorithm. I've worked somewhat to make this implementation more
closely follow the traditional paper's nomenclature and strategy,
although it is still a bit obtuse because it isn't recursive, using
an explicit stack and a tail call instead, and it is interruptable,
resuming each time we need another SCC.
The other tricky bit here, and what actually took almost all the time
and trials and errors I spent building this, is exactly *what* graph
structure to build for the SCCs. The naive thing to build is the call
graph in its newly acyclic form. I wrote about 4 versions of this which
did precisely this. Inevitably, when I experimented with them across
various use cases, they became incredibly awkward. It was all
implementable, but it felt like a complete wrong fit. Square peg, round
hole. There were two overriding aspects that pushed me in a different
direction:
1) We want to discover the SCC graph in a postorder fashion. That means
the root node will be the *last* node we find. Using the call-SCC DAG
as the graph structure of the SCCs results in an orphaned graph until
we discover a root.
2) We will eventually want to walk the SCC graph in parallel, exploring
distinct sub-graphs independently, and synchronizing at merge points.
This again is not helped by the call-SCC DAG structure.
The structure which, quite surprisingly, ended up being completely
natural to use is the *inverse* of the call-SCC DAG. We add the leaf
SCCs to the graph as "roots", and have edges to the caller SCCs. Once
I switched to building this structure, everything just fell into place
elegantly.
Aside from general cleanups (there are FIXMEs and too few comments
overall) that are still needed, the other missing piece of this is
support for iterating across levels of the SCC graph. These will become
useful for implementing #2, but they aren't an immediate priority.
Once SCCs are in good shape, I'll be working on adding mutation support
for incremental updates and adding the pass manager that this analysis
enables.
llvm-svn: 206581
2014-04-18 12:50:32 +02:00
|
|
|
|
2014-02-06 05:37:03 +01:00
|
|
|
return PreservedAnalyses::all();
|
|
|
|
}
|