[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 23:01:09 PDT 2012
On Tue, Jun 19, 2012 at 10:46 PM, Andrew Trick <atrick at apple.com> wrote:
>
> On Jun 19, 2012, at 10:41 PM, Chandler Carruth <chandlerc at google.com>
> wrote:
>
> 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.
>
>
> I don't expect any performance impact other than accidental (which I have
> seen plenty of). LoopInfo compile time is hopefully a bit faster now on
> average but it's hardly measurable (I saw +1%).
>
> However, if you want to do some correctness testing just do your usual
> thing with:
>
> -mllvm -stable-loops -mllvm -stable-machine-loops
>
Yea, this is mostly for correctness testing. I can do a before/after test
run with these flags across our entire codebase, and all of our automated
tests tomorrow. I'll let you know if anything unusual shows up.
-Chandler
> Thanks!
> -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
>>
>> _______________________________________________
>> 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/fecc2689/attachment.html>
More information about the llvm-commits
mailing list