[llvm-commits] [llvm] r158790 - in /llvm/trunk: include/llvm/Analysis/LoopInfo.h include/llvm/Analysis/LoopInfoImpl.h lib/Analysis/LoopInfo.cpp lib/CodeGen/MachineLoopInfo.cpp
Evan Cheng
evan.cheng at apple.com
Wed Jun 20 01:27:21 PDT 2012
Wow nice!
Evan
On Jun 19, 2012, at 10:23 PM, Andrew Trick <atrick at apple.com> wrote:
> Author: atrick
> Date: Wed Jun 20 00:23:33 2012
> New Revision: 158790
>
> URL: http://llvm.org/viewvc/llvm-project?rev=158790&view=rev
> Log:
> A new algorithm for computing LoopInfo. Temporarily disabled.
>
> -stable-loops enables a new algorithm for generating the Loop
> forest. It differs from the original algorithm in a few respects:
>
> - Not determined by use-list order.
> - Initially guarantees RPO order of block and subloops.
> - Linear in the number of CFG edges.
> - Nonrecursive.
>
> I didn't want to change the LoopInfo API yet, so the block lists are
> still inclusive. This seems strange to me, and it means that building
> LoopInfo is not strictly linear, but it may not be a problem in
> practice. At least the block lists start out in RPO order now. In the
> future we may add an attribute or wrapper analysis that allows other
> passes to assume RPO order.
>
> The primary motivation of this work was not to optimize LoopInfo, but
> to allow reproducing performance issues by decomposing the compilation
> stages. I'm often unable to do this with the current LoopInfo, because
> the loop tree order determines Loop pass order. Serializing the IR
> tends to invert the order, which reverses the optimization order. This
> makes it nearly impossible to debug interdependent loop optimizations
> such as LSR.
>
> I also believe this will provide more stable performance results across time.
>
> Modified:
> llvm/trunk/include/llvm/Analysis/LoopInfo.h
> llvm/trunk/include/llvm/Analysis/LoopInfoImpl.h
> llvm/trunk/lib/Analysis/LoopInfo.cpp
> llvm/trunk/lib/CodeGen/MachineLoopInfo.cpp
>
> Modified: llvm/trunk/include/llvm/Analysis/LoopInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/LoopInfo.h?rev=158790&r1=158789&r2=158790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/LoopInfo.h (original)
> +++ llvm/trunk/include/llvm/Analysis/LoopInfo.h Wed Jun 20 00:23:33 2012
> @@ -97,6 +97,9 @@
> BlockT *getHeader() const { return Blocks.front(); }
> LoopT *getParentLoop() const { return ParentLoop; }
>
> + /// setParentLoop is a raw interface for bypassing addChildLoop.
> + void setParentLoop(LoopT *L) { ParentLoop = L; }
> +
> /// contains - Return true if the specified loop is contained within in
> /// this loop.
> ///
> @@ -122,6 +125,7 @@
> /// iterator/begin/end - Return the loops contained entirely within this loop.
> ///
> const std::vector<LoopT *> &getSubLoops() const { return SubLoops; }
> + std::vector<LoopT *> &getSubLoopsVector() { return SubLoops; }
> typedef typename std::vector<LoopT *>::const_iterator iterator;
> iterator begin() const { return SubLoops.begin(); }
> iterator end() const { return SubLoops.end(); }
> @@ -130,6 +134,7 @@
> /// getBlocks - Get a list of the basic blocks which make up this loop.
> ///
> const std::vector<BlockT*> &getBlocks() const { return Blocks; }
> + std::vector<BlockT*> &getBlocksVector() { return Blocks; }
> typedef typename std::vector<BlockT*>::const_iterator block_iterator;
> block_iterator block_begin() const { return Blocks.begin(); }
> block_iterator block_end() const { return Blocks.end(); }
> @@ -528,6 +533,9 @@
> /// inserted into L instead.
> void InsertLoopInto(LoopT *L, LoopT *Parent);
>
> + /// Create the loop forest using a stable algorithm.
> + void Analyze(DominatorTreeBase<BlockT> &DomTree);
> +
> // Debugging
>
> void print(raw_ostream &OS) const;
>
> Modified: llvm/trunk/include/llvm/Analysis/LoopInfoImpl.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/LoopInfoImpl.h?rev=158790&r1=158789&r2=158790&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/LoopInfoImpl.h (original)
> +++ llvm/trunk/include/llvm/Analysis/LoopInfoImpl.h Wed Jun 20 00:23:33 2012
> @@ -16,6 +16,7 @@
> #define LLVM_ANALYSIS_LOOP_INFO_IMPL_H
>
> #include "llvm/Analysis/LoopInfo.h"
> +#include "llvm/ADT/PostOrderIterator.h"
>
> namespace llvm {
>
> @@ -531,6 +532,204 @@
> L->ParentLoop = Parent;
> }
>
> +//===----------------------------------------------------------------------===//
> +/// Stable LoopInfo Analysis - Build a loop tree using stable iterators so the
> +/// result does / not depend on use list (block predecessor) order.
> +///
> +
> +/// Discover a subloop with the specified backedges such that: All blocks within
> +/// this loop are mapped to this loop or a subloop. And all subloops within this
> +/// loop have their parent loop set to this loop or a subloop.
> +template<class BlockT, class LoopT>
> +static void discoverAndMapSubloop(LoopT *L, ArrayRef<BlockT*> Backedges,
> + LoopInfoBase<BlockT, LoopT> *LI,
> + DominatorTreeBase<BlockT> &DomTree) {
> + typedef GraphTraits<Inverse<BlockT*> > InvBlockTraits;
> +
> + unsigned NumBlocks = 0;
> + unsigned NumSubloops = 0;
> +
> + // Perform a backward CFG traversal using a worklist.
> + std::vector<BlockT *> ReverseCFGWorklist(Backedges.begin(), Backedges.end());
> + while (!ReverseCFGWorklist.empty()) {
> + BlockT *PredBB = ReverseCFGWorklist.back();
> + ReverseCFGWorklist.pop_back();
> +
> + LoopT *Subloop = LI->getLoopFor(PredBB);
> + if (!Subloop) {
> + if (!DomTree.isReachableFromEntry(PredBB))
> + continue;
> +
> + // This is an undiscovered block. Map it to the current loop.
> + LI->changeLoopFor(PredBB, L);
> + ++NumBlocks;
> + if (PredBB == L->getHeader())
> + continue;
> + // Push all block predecessors on the worklist.
> + ReverseCFGWorklist.insert(ReverseCFGWorklist.end(),
> + InvBlockTraits::child_begin(PredBB),
> + InvBlockTraits::child_end(PredBB));
> + }
> + else {
> + // This is a discovered block. Find its outermost discovered loop.
> + while (LoopT *Parent = Subloop->getParentLoop())
> + Subloop = Parent;
> +
> + // If it is already discovered to be a subloop of this loop, continue.
> + if (Subloop == L)
> + continue;
> +
> + // Discover a subloop of this loop.
> + Subloop->setParentLoop(L);
> + ++NumSubloops;
> + NumBlocks += Subloop->getBlocks().capacity();
> + PredBB = Subloop->getHeader();
> + // Continue traversal along predecessors that are not loop-back edges from
> + // within this subloop tree itself. Note that a predecessor may directly
> + // reach another subloop that is not yet discovered to be a subloop of
> + // this loop, which we must traverse.
> + for (typename InvBlockTraits::ChildIteratorType PI =
> + InvBlockTraits::child_begin(PredBB),
> + PE = InvBlockTraits::child_end(PredBB); PI != PE; ++PI) {
> + if (LI->getLoopFor(*PI) != Subloop)
> + ReverseCFGWorklist.push_back(*PI);
> + }
> + }
> + }
> + L->getSubLoopsVector().reserve(NumSubloops);
> + L->getBlocksVector().reserve(NumBlocks);
> +}
> +
> +namespace {
> +/// Populate all loop data in a stable order during a single forward DFS.
> +template<class BlockT, class LoopT>
> +class PopulateLoopsDFS {
> + typedef GraphTraits<BlockT*> BlockTraits;
> + typedef typename BlockTraits::ChildIteratorType SuccIterTy;
> +
> + LoopInfoBase<BlockT, LoopT> *LI;
> + DenseSet<const BlockT *> VisitedBlocks;
> + std::vector<std::pair<BlockT*, SuccIterTy> > DFSStack;
> +
> +public:
> + PopulateLoopsDFS(LoopInfoBase<BlockT, LoopT> *li):
> + LI(li) {}
> +
> + void traverse(BlockT *EntryBlock);
> +
> +protected:
> + void reverseInsertIntoLoop(BlockT *Block);
> +
> + BlockT *dfsSource() { return DFSStack.back().first; }
> + SuccIterTy &dfsSucc() { return DFSStack.back().second; }
> + SuccIterTy dfsSuccEnd() { return BlockTraits::child_end(dfsSource()); }
> +
> + void pushBlock(BlockT *Block) {
> + DFSStack.push_back(std::make_pair(Block, BlockTraits::child_begin(Block)));
> + }
> +};
> +} // anonymous
> +
> +/// Top-level driver for the forward DFS within the loop.
> +template<class BlockT, class LoopT>
> +void PopulateLoopsDFS<BlockT, LoopT>::traverse(BlockT *EntryBlock) {
> + pushBlock(EntryBlock);
> + VisitedBlocks.insert(EntryBlock);
> + while (!DFSStack.empty()) {
> + // Traverse the leftmost path as far as possible.
> + while (dfsSucc() != dfsSuccEnd()) {
> + BlockT *BB = *dfsSucc();
> + ++dfsSucc();
> + if (!VisitedBlocks.insert(BB).second)
> + continue;
> +
> + // Push the next DFS successor onto the stack.
> + pushBlock(BB);
> + }
> + // Visit the top of the stack in postorder and backtrack.
> + reverseInsertIntoLoop(dfsSource());
> + DFSStack.pop_back();
> + }
> +}
> +
> +/// Add a single Block to its ancestor loops in PostOrder. If the block is a
> +/// subloop header, add the subloop to its parent in PostOrder, then reverse the
> +/// Block and Subloop vectors of the now complete subloop to achieve RPO.
> +template<class BlockT, class LoopT>
> +void PopulateLoopsDFS<BlockT, LoopT>::reverseInsertIntoLoop(BlockT *Block) {
> + for (LoopT *Subloop = LI->getLoopFor(Block);
> + Subloop; Subloop = Subloop->getParentLoop()) {
> +
> + if (Block != Subloop->getHeader()) {
> + Subloop->getBlocksVector().push_back(Block);
> + continue;
> + }
> + if (Subloop->getParentLoop())
> + Subloop->getParentLoop()->getSubLoopsVector().push_back(Subloop);
> + else
> + LI->addTopLevelLoop(Subloop);
> +
> + // For convenience, Blocks and Subloops are inserted in postorder. Reverse
> + // the lists, except for the loop header, which is always at the beginning.
> + std::reverse(Subloop->getBlocksVector().begin()+1,
> + Subloop->getBlocksVector().end());
> + std::reverse(Subloop->getSubLoopsVector().begin(),
> + Subloop->getSubLoopsVector().end());
> + }
> +}
> +
> +/// Analyze LoopInfo discovers loops during a postorder DominatorTree traversal
> +/// interleaved with backward CFG traversals within each subloop
> +/// (discoverAndMapSubloop). The backward traversal skips inner subloops, so
> +/// this part of the algorithm is linear in the number of CFG edges. Subloop and
> +/// Block vectors are then populated during a single forward CFG traversal
> +/// (PopulateLoopDFS).
> +///
> +/// During the two CFG traversals each block is seen three times:
> +/// 1) Discovered and mapped by a reverse CFG traversal.
> +/// 2) Visited during a forward DFS CFG traversal.
> +/// 3) Reverse-inserted in the loop in postorder following forward DFS.
> +///
> +/// The Block vectors are inclusive, so step 3 requires loop-depth number of
> +/// insertions per block.
> +template<class BlockT, class LoopT>
> +void LoopInfoBase<BlockT, LoopT>::
> +Analyze(DominatorTreeBase<BlockT> &DomTree) {
> +
> + // Postorder traversal of the dominator tree.
> + DomTreeNodeBase<BlockT>* DomRoot = DomTree.getRootNode();
> + for (po_iterator<DomTreeNodeBase<BlockT>*> DomIter = po_begin(DomRoot),
> + DomEnd = po_end(DomRoot); DomIter != DomEnd; ++DomIter) {
> +
> + BlockT *Header = DomIter->getBlock();
> + SmallVector<BlockT *, 4> Backedges;
> +
> + // Check each predecessor of the potential loop header.
> + typedef GraphTraits<Inverse<BlockT*> > InvBlockTraits;
> + for (typename InvBlockTraits::ChildIteratorType PI =
> + InvBlockTraits::child_begin(Header),
> + PE = InvBlockTraits::child_end(Header); PI != PE; ++PI) {
> +
> + BlockT *Backedge = *PI;
> +
> + // If Header dominates predBB, this is a new loop. Collect the backedges.
> + if (DomTree.dominates(Header, Backedge)
> + && DomTree.isReachableFromEntry(Backedge)) {
> + Backedges.push_back(Backedge);
> + }
> + }
> + // Perform a backward CFG traversal to discover and map blocks in this loop.
> + if (!Backedges.empty()) {
> + LoopT *L = new LoopT(Header);
> + discoverAndMapSubloop(L, ArrayRef<BlockT*>(Backedges), this, DomTree);
> + }
> + }
> + // Perform a single forward CFG traversal to populate block and subloop
> + // vectors for all loops.
> + PopulateLoopsDFS<BlockT, LoopT> DFS(this);
> + DFS.traverse(DomRoot->getBlock());
> +}
> +
> // Debugging
> template<class BlockT, class LoopT>
> void LoopInfoBase<BlockT, LoopT>::print(raw_ostream &OS) const {
>
> Modified: llvm/trunk/lib/Analysis/LoopInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/LoopInfo.cpp?rev=158790&r1=158789&r2=158790&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/LoopInfo.cpp (original)
> +++ llvm/trunk/lib/Analysis/LoopInfo.cpp Wed Jun 20 00:23:33 2012
> @@ -44,6 +44,10 @@
> VerifyLoopInfoX("verify-loop-info", cl::location(VerifyLoopInfo),
> cl::desc("Verify loop info (time consuming)"));
>
> +static cl::opt<bool>
> +StableLoopInfo("stable-loops", cl::Hidden, cl::init(false),
> + cl::desc("Compute a stable loop tree."));
> +
> char LoopInfo::ID = 0;
> INITIALIZE_PASS_BEGIN(LoopInfo, "loops", "Natural Loop Information", true, true)
> INITIALIZE_PASS_DEPENDENCY(DominatorTree)
> @@ -512,7 +516,10 @@
> //
> bool LoopInfo::runOnFunction(Function &) {
> releaseMemory();
> - LI.Calculate(getAnalysis<DominatorTree>().getBase()); // Update
> + if (StableLoopInfo)
> + LI.Analyze(getAnalysis<DominatorTree>().getBase());
> + else
> + LI.Calculate(getAnalysis<DominatorTree>().getBase()); // Update
> return false;
> }
>
>
> Modified: llvm/trunk/lib/CodeGen/MachineLoopInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineLoopInfo.cpp?rev=158790&r1=158789&r2=158790&view=diff
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/MachineLoopInfo.cpp (original)
> +++ llvm/trunk/lib/CodeGen/MachineLoopInfo.cpp Wed Jun 20 00:23:33 2012
> @@ -18,6 +18,7 @@
> #include "llvm/CodeGen/MachineDominators.h"
> #include "llvm/CodeGen/Passes.h"
> #include "llvm/Analysis/LoopInfoImpl.h"
> +#include "llvm/Support/CommandLine.h"
> #include "llvm/Support/Debug.h"
> using namespace llvm;
>
> @@ -25,6 +26,10 @@
> template class llvm::LoopBase<MachineBasicBlock, MachineLoop>;
> template class llvm::LoopInfoBase<MachineBasicBlock, MachineLoop>;
>
> +static cl::opt<bool>
> +StableLoopInfo("stable-machine-loops", cl::Hidden, cl::init(false),
> + cl::desc("Compute a stable loop tree."));
> +
> char MachineLoopInfo::ID = 0;
> INITIALIZE_PASS_BEGIN(MachineLoopInfo, "machine-loops",
> "Machine Natural Loop Construction", true, true)
> @@ -36,7 +41,10 @@
>
> bool MachineLoopInfo::runOnMachineFunction(MachineFunction &) {
> releaseMemory();
> - LI.Calculate(getAnalysis<MachineDominatorTree>().getBase()); // Update
> + if (StableLoopInfo)
> + LI.Analyze(getAnalysis<MachineDominatorTree>().getBase());
> + else
> + LI.Calculate(getAnalysis<MachineDominatorTree>().getBase()); // Update
> return false;
> }
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list