[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

Chandler Carruth chandlerc at google.com
Tue Jun 19 22:41:20 PDT 2012


On Tue, Jun 19, 2012 at 10:38 PM, Andrew Trick <atrick at apple.com> wrote:

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

Is there a specific clang commandline flag that you'd like tested? If so,
we can throw some serious testing at it very easily.


>
> 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
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20120619/b4193ccc/attachment.html>


More information about the llvm-commits mailing list