[LoopVectorize] Pass parameters explicitly to MemoryDepChecker

[anemet]

Summary

Rather than using globals. This prepares the class to be moved outside the
LoopVectorizer.

It's not great how all these are passed through in LoopAccessAnalysis but this
is all expected to change once the class start servicing the Loop Distribution
pass as well where these parameters make no sense.

NFC. This is part of the patchset that splits out the memory dependence logic
from LoopVectorizationLegality into a new class LoopAccessAnalysis.
LoopAccessAnalysis will be used by the new Loop Distribution pass.

[hfinkel]

I think it would be better to collect these into a struct describing vectorization thresholds.

[anemet]

In D7284#115788, @hfinkel wrote:

I think it would be better to collect these into a struct describing vectorization thresholds.

Sure, I can do that. (I was going to wait and see how this shapes up with LoopDist as another client. The MemoryDepChecker would have to somehow be specialized further for the Vectorizer.)

[hfinkel]

• Original Message -----

From: "Adam Nemet" <[e-mail]>
To: [e-mail], [e-mail], [e-mail]
Cc: [e-mail]
Sent: Friday, January 30, 2015 12:01:32 PM
Subject: Re: [PATCH] [LoopVectorize] Pass parameters explicitly to MemoryDepChecker

In http://reviews.llvm.org/D7284#115788, @hfinkel wrote:

I think it would be better to collect these into a struct
describing vectorization thresholds.

Sure, I can do that. (I was going to wait and see how this shapes up
with LoopDist as another client. The MemoryDepChecker would have to
somehow be specialized further for the Vectorizer.)

Understood; but I think you might as well do that now. We can always refactor things again later.

-Hal

http://reviews.llvm.org/D7284

EMAIL PREFERENCES

http://reviews.llvm.org/settings/panel/emailpreferences/

[anemet]

Rebased and addressed Hal's comments

[hfinkel]

LGTM.

lib/Transforms/Vectorize/LoopVectorize.cpp

712

MSVC2012 sometimes has problems with syntax like this, and you might need to construct by name if it complains -- the buildbots will tell you ;)

[anemet]

r227754

lib/Transforms/Vectorize/LoopVectorize.cpp

 /// For memory dependences that cannot be determined at compile time, it
 /// generates run-time checks to prove independence.  This is done by
 /// AccessAnalysis::canCheckPtrAtRT and the checks are maintained by the
 /// RuntimePointerCheck class.
 class LoopAccessAnalysis {
 public:
   LoopAccessAnalysis(Function *F, Loop *L, ScalarEvolution *SE,
                      const DataLayout *DL, const TargetLibraryInfo *TLI,
-                     AliasAnalysis *AA, DominatorTree *DT) :
+                     AliasAnalysis *AA, DominatorTree *DT,
+                     unsigned MaxVectorWidth, unsigned VectorizationFactor,
+                     unsigned VectorizationInterleave,
+                     unsigned RuntimeMemoryCheckThreshold) :
       TheFunction(F), TheLoop(L), SE(SE), DL(DL), TLI(TLI), AA(AA), DT(DT),
-      NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1U) {
+      NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1U),
+      MaxVectorWidth(MaxVectorWidth), VectorizationFactor(VectorizationFactor),
+      VectorizationInterleave(VectorizationInterleave),
+      RuntimeMemoryCheckThreshold(RuntimeMemoryCheckThreshold) {
   }
 
   /// Return true we can analyze the memory accesses in the loop and there are
   /// no memory dependence cycles.  Replaces symbolic strides using Strides.
   bool canVectorizeMemory(ValueToValueMap &Strides);
 
   RuntimePointerCheck *getRuntimePointerCheck() { return &PtrRtCheck; }
 
private:
   const TargetLibraryInfo *TLI;
   AliasAnalysis *AA;
   DominatorTree *DT;
 
   unsigned NumLoads;
   unsigned NumStores;
 
   unsigned MaxSafeDepDistBytes;
+
+  /// \brief Maximum simd width.
+  unsigned MaxVectorWidth;
+
+  /// \brief VF as overridden by the user.
+  unsigned VectorizationFactor;
+  /// \brief Interleave factor as overridden by the user.
+  unsigned VectorizationInterleave;
+
+  /// \\brief When performing memory disambiguation checks at runtime do not
+  /// make more than this number of comparisons.
+  unsigned RuntimeMemoryCheckThreshold;
 };
 
 /// LoopVectorizationLegality checks if it is legal to vectorize a loop, and
 /// to what vectorization factor.
 /// This class does not look at the profitability of vectorization, only the
 /// legality. This class has two main kinds of checks:
 /// * Memory checks - The code in canVectorizeMemory checks if vectorization
 ///   will change the order of memory accesses in a way that will change the
 ///   correctness of the program.
 /// * Scalars checks - The code in canVectorizeInstrs and canVectorizeMemory
 /// checks for a number of different conditions, such as the availability of a
 /// single induction variable, that all types are supported and vectorize-able,
 /// etc. This code reflects the capabilities of InnerLoopVectorizer.
 /// This class is also used by InnerLoopVectorizer for identifying
 /// induction variable and the different reduction variables.
 class LoopVectorizationLegality {
 public:
   LoopVectorizationLegality(Loop *L, ScalarEvolution *SE, const DataLayout *DL,
                             DominatorTree *DT, TargetLibraryInfo *TLI,
                             AliasAnalysis *AA, Function *F,
                             const TargetTransformInfo *TTI)
       : NumPredStores(0), TheLoop(L), SE(SE), DL(DL), TLI(TLI), TheFunction(F),
         TTI(TTI), Induction(nullptr), WidestIndTy(nullptr),
-        LAA(F, L, SE, DL, TLI, AA, DT), HasFunNoNaNAttr(false) {
+        LAA(F, L, SE, DL, TLI, AA, DT, MaxVectorWidth, VectorizationFactor,
+            VectorizationInterleave, RuntimeMemoryCheckThreshold),
+        HasFunNoNaNAttr(false) {
   }
 
   /// This enum represents the kinds of reductions that we support.
   enum ReductionKind {
     RK_NoReduction, ///< Not a reduction.
     RK_IntegerAdd,  ///< Sum of integers.
     RK_IntegerMult, ///< Product of integers.
     RK_IntegerOr,   ///< Bitwise or logical OR of numbers.

 ///
 ///  * Zero distances and all accesses have the same size.
 ///
 class MemoryDepChecker {
 public:
   typedef PointerIntPair<Value *, 1, bool> MemAccessInfo;
   typedef SmallPtrSet<MemAccessInfo, 8> MemAccessInfoSet;
 
-  MemoryDepChecker(ScalarEvolution *Se, const DataLayout *Dl, const Loop *L)
+  MemoryDepChecker(ScalarEvolution *Se, const DataLayout *Dl, const Loop *L,
+                   unsigned MaxVectorWidth, unsigned VectorizationFactor,
+                   unsigned VectorizationInterleave)
       : SE(Se), DL(Dl), InnermostLoop(L), AccessIdx(0),
-        ShouldRetryWithRuntimeCheck(false) {}
+        ShouldRetryWithRuntimeCheck(false), MaxVectorWidth(MaxVectorWidth),
+        VectorizationFactor(VectorizationFactor),
+        VectorizationInterleave(VectorizationInterleave) {}
 
   /// \brief Register the location (instructions are given increasing numbers)
   /// of a write access.
   void addAccess(StoreInst *SI) {
     Value *Ptr = SI->getPointerOperand();
     Accesses[MemAccessInfo(Ptr, true)].push_back(AccessIdx);
     InstMap.push_back(SI);
     ++AccessIdx;
private:
 
   // We can access this many bytes in parallel safely.
   unsigned MaxSafeDepDistBytes;
 
   /// \brief If we see a non-constant dependence distance we can still try to
   /// vectorize this loop with runtime checks.
   bool ShouldRetryWithRuntimeCheck;
 
+  /// \brief Maximum simd width.
+  unsigned MaxVectorWidth;
+
+  /// \brief VF as overridden by the user.
+  unsigned VectorizationFactor;
+  /// \brief Interleave factor as overridden by the user.
+  unsigned VectorizationInterleave;
+
   /// \brief Check whether there is a plausible dependence between the two
   /// accesses.
   ///
   /// Access \p A must happen before \p B in program order. The two indices
   /// identify the index into the program order map.
   ///
   /// This function checks  whether there is a plausible dependence (or the
   /// absence of such can't be proved) between the two accesses. If there is a
bool LoopAccessAnalysis::canVectorizeMemory(ValueToValueMap &Strides) {
   // Holds all the different accesses in the loop.
   unsigned NumReads = 0;
   unsigned NumReadWrites = 0;
 
   PtrRtCheck.Pointers.clear();
   PtrRtCheck.Need = false;
 
   const bool IsAnnotatedParallel = TheLoop->isAnnotatedParallel();
-  MemoryDepChecker DepChecker(SE, DL, TheLoop);
+  MemoryDepChecker DepChecker(SE, DL, TheLoop, MaxVectorWidth,
+                              VectorizationFactor, VectorizationInterleave);
 
   // For each block.
   for (Loop::block_iterator bb = TheLoop->block_begin(),
        be = TheLoop->block_end(); bb != be; ++bb) {
 
     // Scan the BB and collect legal loads and stores.
     for (BasicBlock::iterator it = (*bb)->begin(), e = (*bb)->end(); it != e;
          ++it) {