[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

Andrew Trick atrick at apple.com
Tue Jun 19 22:38:25 PDT 2012


Please review and try to break this. I plan to enable it by default shortly.
-Andy

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