Add optimization remarks to the loop unroller and vectorizer.

[dnovillo]

Summary

This calls emitOptimizationRemark from the loop unroller and vectorizer
at the point where they make a positive transformation.

[dnovillo]

• Add vectorization and interleave factor reporting.

[hfinkel]

Thanks for working on this!

include/llvm/Analysis/LoopInfo.h

465 ↗

(On Diff #8740)

Why are you looking in the pre-header first? That does not seem to make sense because the start of the preheader could be pretty far away from the start of the loop.

Maybe looking in the preheader makes sense, but you should specifically look for the *last* location somehow I'd think.

lib/Transforms/Utils/LoopUnroll.cpp

242 ↗

(On Diff #8740)

This message should be improved. If I unroll a loop with 5 iterations, I've not unrolled it 5 times -- then I'd have 25 iterations ;)

How about: "completely unrolled loop with N iterations".

246 ↗

(On Diff #8740)

Here too, maybe something like: "unrolled loop by a factor of N"

lib/Transforms/Vectorize/LoopVectorize.cpp

1194 ↗

(On Diff #8740)

Sounds like we're calling this "interleaving factor". The capitalization seems odd here, nothing else is capitalized.

[dnovillo]

• Review feedback.

[dnovillo]

Hal, do you think this is good enough to commit?

Thanks. Diego.

[hfinkel]

Yep, LGTM. Thanks!

[zinovy.nis]

lib/Transforms/Vectorize/LoopVectorize.cpp

1197 ↗

(On Diff #8778)

Your code will report loop as vectorized even if it was only unrolled.
Please see lines

InnerLoopVectorizer LB(L, SE, LI, DT, DL, TLI, VF.Width, UF);
   LB.vectorize(&LVL);
   ++LoopsVectorized;
 }

and above. Is it the desired behavior?

[hfinkel]

Good point, vectorized with VF == 1 is confusing. We should report the VF == 1 cases as just, 'unrolled with interleaving factor N'.

(We should also also say "interleave factor" or "unrolling interleave factor" in the regular case; we've decided to use the "interleave" terminology for the associated pragma).

[dnovillo]

• 00.diff1 KBDownload

[zinovy.nis]

You don't need to add metadata to

test/Transforms/LoopVectorize/X86/vectorization-remarks.ll

And if optimization remarks are only emitted in DEBUG (or RELEASE+ASSERTS) build, please add the following line in the beginning of your file. Thanks.

REQUIRES: asserts

[dnovillo]

Closed by commit rL207528 (authored by @dnovillo).

llvm/trunk/include/llvm/Analysis/LoopInfo.h

public:
   void getUniqueExitBlocks(SmallVectorImpl<BasicBlock *> &ExitBlocks) const;
 
   /// getUniqueExitBlock - If getUniqueExitBlocks would return exactly one
   /// block, return that block. Otherwise return null.
   BasicBlock *getUniqueExitBlock() const;
 
   void dump() const;
 
+  /// \brief Return the debug location of the start of this loop.
+  /// This looks for a BB terminating instruction with a known debug
+  /// location by looking at the preheader and header blocks. If it
+  /// cannot find a terminating instruction with location information,
+  /// it returns an unknown location.
+  DebugLoc getStartLoc() const {
+    DebugLoc StartLoc;
+    BasicBlock *HeadBB;
+
+    // Try the pre-header first.
+    if ((HeadBB = getLoopPreheader()) != nullptr) {
+      StartLoc = HeadBB->getTerminator()->getDebugLoc();
+      if (!StartLoc.isUnknown())
+        return StartLoc;
+    }
+
+    // If we have no pre-header or there are no instructions with debug
+    // info in it, try the header.
+    HeadBB = getHeader();
+    if (HeadBB)
+      StartLoc = HeadBB->getTerminator()->getDebugLoc();
+
+    return StartLoc;
+  }
+
 private:
   friend class LoopInfoBase<BasicBlock, Loop>;
   explicit Loop(BasicBlock *BB) : LoopBase<BasicBlock, Loop>(BB) {}
 };
 
 //===----------------------------------------------------------------------===//
 /// LoopInfo - This class builds and contains all of the top level loop
 /// structures in the specified function.

llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp

 #include "llvm/Transforms/Utils/UnrollLoop.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/LoopIterator.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/SimplifyIndVar.h"
 using namespace llvm;
if (TripCount != 0) {
     BreakoutTrip = TripCount % Count;
     TripMultiple = 0;
   } else {
     // Figure out what multiple to use.
     BreakoutTrip = TripMultiple =
       (unsigned)GreatestCommonDivisor64(Count, TripMultiple);
   }
 
+  // Report the unrolling decision.
+  DebugLoc LoopLoc = L->getStartLoc();
+  Function *F = Header->getParent();
+  LLVMContext &Ctx = F->getContext();
+
   if (CompletelyUnroll) {
     DEBUG(dbgs() << "COMPLETELY UNROLLING loop %" << Header->getName()
           << " with trip count " << TripCount << "!\n");
+    Ctx.emitOptimizationRemark(DEBUG_TYPE, *F, LoopLoc,
+                               Twine("completely unrolled loop with ") +
+                                   Twine(TripCount) + " iterations");
   } else {
     DEBUG(dbgs() << "UNROLLING loop %" << Header->getName()
           << " by " << Count);
+    Twine DiagMsg("unrolled loop by a factor of " + Twine(Count));
     if (TripMultiple == 0 || BreakoutTrip != TripMultiple) {
       DEBUG(dbgs() << " with a breakout at trip " << BreakoutTrip);
+      DiagMsg.concat(" with a breakout at trip " + Twine(BreakoutTrip));
     } else if (TripMultiple != 1) {
       DEBUG(dbgs() << " with " << TripMultiple << " trips per branch");
+      DiagMsg.concat(" with " + Twine(TripMultiple) + " trips per branch");
     } else if (RuntimeTripCount) {
       DEBUG(dbgs() << " with run-time trip count");
+      DiagMsg.concat(" with run-time trip count");
     }
     DEBUG(dbgs() << "!\n");
+    Ctx.emitOptimizationRemark(DEBUG_TYPE, *F, LoopLoc, DiagMsg);
   }
 
   bool ContinueOnTrue = L->contains(BI->getSuccessor(0));
   BasicBlock *LoopExit = BI->getSuccessor(ContinueOnTrue);
 
   // For the first iteration of the loop, we should use the precloned values for
   // PHI nodes.  Insert associations now.
   ValueToValueMapTy LastValueMap;

llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp

if (VF.Width == 1) {
       InnerLoopVectorizer LB(L, SE, LI, DT, DL, TLI, VF.Width, UF);
       LB.vectorize(&LVL);
       ++LoopsVectorized;
     }
 
     // Mark the loop as already vectorized to avoid vectorizing again.
     Hints.setAlreadyVectorized(L);
 
+    // Report the vectorization decision.
+    F->getContext().emitOptimizationRemark(
+        DEBUG_TYPE, *F, L->getStartLoc(),
+        Twine("vectorized loop (vectorization factor: ") + Twine(VF.Width) +
+            ", unroll factor: " + Twine(UF) + ")");
+
     DEBUG(verifyFunction(*L->getHeader()->getParent()));
     return true;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredID(LoopSimplifyID);
     AU.addRequiredID(LCSSAID);
     AU.addRequired<BlockFrequencyInfo>();