Rename getMaximumUnrollFactor().

[spatel]

Summary

"getMaximumUnrollFactor()" isn't used by the loop unroller at all. It's strictly a loop vectorizer variable, so I propose renaming it to "getMaxVectorUnrollFactor()" with this patch. No functional change intended.

Ideally, I think we would move this subtarget-specific variable into the SchedMachineModel. That's where we already have a variable for "LoopMicroOpBufferSize" which is used by the loop unroller. If that's a good change, let me know, and I'll work on a patch for it.

[hfinkel]

I agree that this should be renamed. We actually call this the interleaving factor (not the unrolling factor) in user-facing things (like the pragmas and metadata); I think the renaming should reflect that.

[rengolin]

I agree with Hal, interleave factor is a much better name, and is independent of the loop (or any other) vectorizer. The comments should also be changed to explain that.

--renato

[spatel]

Thanks very much for the feedback, Hal and Renato.

I wasn't aware of the pragmas in clang - good to know about those.

In this version of the patch, I have changed the name to "getMaxVectorInterleaveFactor". I also made a bunch of interior changes in LoopVectorizer...but there are 2 "seams" where we still use "unroll":

1. I stopped short of changing the cl::opt names - if we really want to unify on "interleave" I assume we want to change those too so they match the pragmas? That will require changing 80+ test cases in test-suite. If everyone agrees that is better, I'll certainly make that change too.

2. Eventually the interleave factor becomes an ingredient in "UF", the unroll factor: if (UF > MaxInterleaveSize) UF = MaxInterleaveSize;

I have not looked at the logic in LV close enough to know if "UF" is the appropriate name. Any opinions?

[aschwaighofer]

I also thing it makes sense to rename this to interleave factor to point out the difference between interleaved unrolling vs concatenating unrolling. Interleaving is not necessarily tied to vectorization. The fact that we interleave in the vectorizer is just an artifact of our implementation. I think it should be getMaxInterleaveFactor(). We are not necessarily interleaving vector instructions.

Thanks for cleaning this up!

[rengolin]

Hi Sanjay,

In this version of the patch, I have changed the name to "getMaxVectorInterleaveFactor". I also made a bunch of interior changes in LoopVectorizer...but there are 2 "seams" where we still use "unroll":

Please, drop the "Vector" as it's not directly related to the interleaving.

1. I stopped short of changing the cl::opt names - if we really want to unify on "interleave" I assume we want to change those too so they match the pragmas? That will require changing 80+ test cases in test-suite. If everyone agrees that is better, I'll certainly make that change too.

That's a good point. We certainly could, but that'd have to be an alias, at least for now.

Arnold, how public are those flags nowadays? The decision to either keep it forever, rename now or anything in between will have to be based on that.

2. Eventually the interleave factor becomes an ingredient in "UF", the unroll factor: if (UF > MaxInterleaveSize) UF = MaxInterleaveSize;

I have not looked at the logic in LV close enough to know if "UF" is the appropriate name. Any opinions?

I think the name is correct as it is.

IIRC, UF is the actual unrolling factor, which bases its decision ultimately on the interleave factor, since it's generally not profitable to "just unroll" at a factor greater than the interleave, even if the data dependencies allow it.

cheers,
--renato

[spatel]

Changed name to: "getMaxInterleaveFactor" - sorry that I missed the earlier comment that this is independent of the vectorizer.

[spatel]

Ping.

There's still a question of whether to change the cl::opt names either in this patch or later?

[hfinkel]

• Original Message -----

From: "Sanjay Patel" <[e-mail]>
To: [e-mail], [e-mail], [e-mail], "renato golin" <[e-mail]>,
[e-mail]
Cc: [e-mail], [e-mail]
Sent: Wednesday, September 3, 2014 11:11:54 AM
Subject: Re: [PATCH] Rename getMaximumUnrollFactor().

Ping.

There's still a question of whether to change the cl::opt names
either in this patch or later?

Those are for development and debugging. I think that either is fine, but you might as well do it now for consistency.

-Hal

http://reviews.llvm.org/D5066

[spatel]

Rebased and updated to change the cl::opt params - and so affects lots of LV testcases that use that param.

Please let me know if this is ok to commit. Thanks!

[rengolin]

Hi Sanjay,

LGTM, Thanks!

[spatel]

Closed by commit rL217528 (authored by @spatel).

[spatel]

Thanks all for the review - committed at r217528.

include/llvm/Analysis/TargetTransformInfo.h

public:
   /// \return The number of scalar or vector registers that the target has.
   /// If 'Vectors' is true, it returns the number of vector registers. If it is
   /// set to false, it returns the number of scalar registers.
   virtual unsigned getNumberOfRegisters(bool Vector) const;
 
   /// \return The width of the largest scalar or vector register type.
   virtual unsigned getRegisterBitWidth(bool Vector) const;
 
-  /// \return The maximum unroll factor that the vectorizer should try to
-  /// perform for this target. This number depends on the level of parallelism
-  /// and the number of execution units in the CPU.
-  virtual unsigned getMaximumUnrollFactor() const;
+  /// \return The maximum interleave factor that the loop vectorizer should try
+  /// to perform for this target. This number depends on the level of
+  /// parallelism and the number of execution units in the CPU.
+  virtual unsigned getMaxVectorInterleaveFactor() const;
 
   /// \return The expected cost of arithmetic ops, such as mul, xor, fsub, etc.
   virtual unsigned
   getArithmeticInstrCost(unsigned Opcode, Type *Ty,
                          OperandValueKind Opd1Info = OK_AnyValue,
                          OperandValueKind Opd2Info = OK_AnyValue,
                          OperandValueProperties Opd1PropInfo = OP_None,
                          OperandValueProperties Opd2PropInfo = OP_None) const;

lib/Analysis/TargetTransformInfo.cpp

 unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const {
   return PrevTTI->getNumberOfRegisters(Vector);
 }
 
 unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const {
   return PrevTTI->getRegisterBitWidth(Vector);
 }
 
-unsigned TargetTransformInfo::getMaximumUnrollFactor() const {
-  return PrevTTI->getMaximumUnrollFactor();
+unsigned TargetTransformInfo::getMaxVectorInterleaveFactor() const {
+  return PrevTTI->getMaxVectorInterleaveFactor();
 }
 
 unsigned TargetTransformInfo::getArithmeticInstrCost(
     unsigned Opcode, Type *Ty, OperandValueKind Op1Info,
     OperandValueKind Op2Info, OperandValueProperties Opd1PropInfo,
     OperandValueProperties Opd2PropInfo) const {
   return PrevTTI->getArithmeticInstrCost(Opcode, Ty, Op1Info, Op2Info,
                                          Opd1PropInfo, Opd2PropInfo);
struct NoTTI final : ImmutablePass, TargetTransformInfo {
   unsigned getNumberOfRegisters(bool Vector) const override {
     return 8;
   }
 
   unsigned  getRegisterBitWidth(bool Vector) const override {
     return 32;
   }
 
-  unsigned getMaximumUnrollFactor() const override {
+  unsigned getMaxVectorInterleaveFactor() const override {
     return 1;
   }
 
   unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
                                   OperandValueKind, OperandValueProperties,
                                   OperandValueProperties) const override {
     return 1;
   }

lib/CodeGen/BasicTargetTransformInfo.cpp

void getUnrollingPreferences(Loop *L,
                                UnrollingPreferences &UP) const override;
 
   /// @}
 
   /// \name Vector TTI Implementations
   /// @{
 
   unsigned getNumberOfRegisters(bool Vector) const override;
-  unsigned getMaximumUnrollFactor() const override;
+  unsigned getMaxVectorInterleaveFactor() const override;
   unsigned getRegisterBitWidth(bool Vector) const override;
   unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
                                   OperandValueKind, OperandValueProperties,
                                   OperandValueProperties) const override;
   unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
                           int Index, Type *SubTp) const override;
   unsigned getCastInstrCost(unsigned Opcode, Type *Dst,
                             Type *Src) const override;

 unsigned BasicTTI::getNumberOfRegisters(bool Vector) const {
   return 1;
 }
 
 unsigned BasicTTI::getRegisterBitWidth(bool Vector) const {
   return 32;
 }
 
-unsigned BasicTTI::getMaximumUnrollFactor() const {
+unsigned BasicTTI::getMaxVectorInterleaveFactor() const {
   return 1;
 }
 
 unsigned BasicTTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
                                           OperandValueKind, OperandValueKind,
                                           OperandValueProperties,
                                           OperandValueProperties) const {
   // Check if any of the operands are vector operands.

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

unsigned getRegisterBitWidth(bool Vector) const override {
     if (Vector) {
       if (ST->hasNEON())
         return 128;
       return 0;
     }
     return 64;
   }
 
-  unsigned getMaximumUnrollFactor() const override;
+  unsigned getMaxVectorInterleaveFactor() const override;
 
   unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src) const
       override;
 
   unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) const
       override;
 
   unsigned getArithmeticInstrCost(
if (!I->isVectorTy())
       continue;
     if (I->getScalarSizeInBits() * I->getVectorNumElements() == 128)
       Cost += getMemoryOpCost(Instruction::Store, I, 128, 0) +
         getMemoryOpCost(Instruction::Load, I, 128, 0);
   }
   return Cost;
 }
 
-unsigned AArch64TTI::getMaximumUnrollFactor() const {
+unsigned AArch64TTI::getMaxVectorInterleaveFactor() const {
   if (ST->isCortexA57() || ST->isCyclone())
     return 4;
   return 2;
 }

lib/Target/ARM/ARMTargetTransformInfo.cpp

if (Vector) {
       if (ST->hasNEON())
         return 128;
       return 0;
     }
 
     return 32;
   }
 
-  unsigned getMaximumUnrollFactor() const override {
+  unsigned getMaxVectorInterleaveFactor() const override {
     // These are out of order CPUs:
     if (ST->isCortexA15() || ST->isSwift())
       return 2;
     return 1;
   }
 
   unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
                           int Index, Type *SubTp) const override;

lib/Target/PowerPC/PPCTargetTransformInfo.cpp

public:
 
   /// @}
 
   /// \name Vector TTI Implementations
   /// @{
 
   virtual unsigned getNumberOfRegisters(bool Vector) const override;
   virtual unsigned getRegisterBitWidth(bool Vector) const override;
-  virtual unsigned getMaximumUnrollFactor() const override;
+  virtual unsigned getMaxVectorInterleaveFactor() const override;
   virtual unsigned
   getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
                          OperandValueKind, OperandValueProperties,
                          OperandValueProperties) const override;
   virtual unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
                                   int Index, Type *SubTp) const override;
   virtual unsigned getCastInstrCost(unsigned Opcode, Type *Dst,
                                     Type *Src) const override;
unsigned PPCTTI::getRegisterBitWidth(bool Vector) const {
   }
 
   if (ST->isPPC64())
     return 64;
   return 32;
 
 }
 
-unsigned PPCTTI::getMaximumUnrollFactor() const {
+unsigned PPCTTI::getMaxVectorInterleaveFactor() const {
   unsigned Directive = ST->getDarwinDirective();
   // The 440 has no SIMD support, but floating-point instructions
   // have a 5-cycle latency, so unroll by 5x for latency hiding.
   if (Directive == PPC::DIR_440)
     return 5;
 
   // The A2 has no SIMD support, but floating-point instructions
   // have a 6-cycle latency, so unroll by 6x for latency hiding.

lib/Target/R600/AMDGPUTargetTransformInfo.cpp

public:
 
   void getUnrollingPreferences(Loop *L,
                                UnrollingPreferences &UP) const override;
 
   PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const override;
 
   unsigned getNumberOfRegisters(bool Vector) const override;
   unsigned getRegisterBitWidth(bool Vector) const override;
-  unsigned getMaximumUnrollFactor() const override;
+  unsigned getMaxVectorInterleaveFactor() const override;
 
   /// @}
 };
 
 } // end anonymous namespace
 
 INITIALIZE_AG_PASS(AMDGPUTTI, TargetTransformInfo, "AMDGPUtti",
                    "AMDGPU Target Transform Info", true, true, false)
unsigned AMDGPUTTI::getNumberOfRegisters(bool Vec) const {
 
   return 4 * 128; // XXX - 4 channels. Should these count as vector instead?
 }
 
 unsigned AMDGPUTTI::getRegisterBitWidth(bool) const {
   return 32;
 }
 
-unsigned AMDGPUTTI::getMaximumUnrollFactor() const {
+unsigned AMDGPUTTI::getMaxVectorInterleaveFactor() const {
   // Semi-arbitrary large amount.
   return 64;
 }

lib/Target/X86/X86TargetTransformInfo.cpp

public:
 
   /// @}
 
   /// \name Vector TTI Implementations
   /// @{
 
   unsigned getNumberOfRegisters(bool Vector) const override;
   unsigned getRegisterBitWidth(bool Vector) const override;
-  unsigned getMaximumUnrollFactor() const override;
+  unsigned getMaxVectorInterleaveFactor() const override;
   unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
                                   OperandValueKind, OperandValueProperties,
                                   OperandValueProperties) const override;
   unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
                           int Index, Type *SubTp) const override;
   unsigned getCastInstrCost(unsigned Opcode, Type *Dst,
                             Type *Src) const override;
   unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
unsigned X86TTI::getRegisterBitWidth(bool Vector) const {
   }
 
   if (ST->is64Bit())
     return 64;
   return 32;
 
 }
 
-unsigned X86TTI::getMaximumUnrollFactor() const {
+unsigned X86TTI::getMaxVectorInterleaveFactor() const {
   if (ST->isAtom())
     return 1;
 
   // Sandybridge and Haswell have multiple execution ports and pipelined
   // vector units.
   if (ST->hasAVX())
     return 4;
 

lib/Transforms/Vectorize/LoopVectorize.cpp

 static cl::opt<unsigned> ForceTargetNumScalarRegs(
     "force-target-num-scalar-regs", cl::init(0), cl::Hidden,
     cl::desc("A flag that overrides the target's number of scalar registers."));
 
 static cl::opt<unsigned> ForceTargetNumVectorRegs(
     "force-target-num-vector-regs", cl::init(0), cl::Hidden,
     cl::desc("A flag that overrides the target's number of vector registers."));
 
-/// Maximum vectorization unroll count.
-static const unsigned MaxUnrollFactor = 16;
+/// Maximum vectorization interleave count.
+static const unsigned MaxInterleaveFactor = 16;
 
 static cl::opt<unsigned> ForceTargetMaxScalarUnrollFactor(
     "force-target-max-scalar-unroll", cl::init(0), cl::Hidden,
-    cl::desc("A flag that overrides the target's max unroll factor for scalar "
-             "loops."));
+    cl::desc("A flag that overrides the target's max unroll/interleave factor "
+             "for scalar loops."));
 
 static cl::opt<unsigned> ForceTargetMaxVectorUnrollFactor(
     "force-target-max-vector-unroll", cl::init(0), cl::Hidden,
-    cl::desc("A flag that overrides the target's max unroll factor for "
-             "vectorized loops."));
+    cl::desc("A flag that overrides the target's max unroll/interleave factor "
+             "for vectorized loops."));
 
 static cl::opt<unsigned> ForceTargetInstructionCost(
     "force-target-instruction-cost", cl::init(0), cl::Hidden,
     cl::desc("A flag that overrides the target's expected cost for "
              "an instruction to a single constant value. Mostly "
              "useful for getting consistent testing."));
 
 static cl::opt<unsigned> SmallLoopCost(

 class LoopVectorizeHints {
 public:
   enum ForceKind {
     FK_Undefined = -1, ///< Not selected.
     FK_Disabled = 0,   ///< Forcing disabled.
     FK_Enabled = 1,    ///< Forcing enabled.
   };
 
-  LoopVectorizeHints(const Loop *L, bool DisableUnrolling)
+  LoopVectorizeHints(const Loop *L, bool DisableInterleaving)
       : Width(VectorizationFactor),
-        Unroll(DisableUnrolling),
+        Interleave(DisableInterleaving),
         Force(FK_Undefined),
         LoopID(L->getLoopID()) {
     getHints(L);
     // force-vector-unroll overrides DisableUnrolling.
     if (VectorizationUnroll.getNumOccurrences() > 0)
-      Unroll = VectorizationUnroll;
+      Interleave = VectorizationUnroll;
 
-    DEBUG(if (DisableUnrolling && Unroll == 1) dbgs()
+    DEBUG(if (DisableInterleaving && Interleave == 1) dbgs()
           << "LV: Unrolling disabled by the pass manager\n");
   }
 
   /// Return the loop metadata prefix.
   static StringRef Prefix() { return "llvm.loop."; }
 
   MDNode *createHint(LLVMContext &Context, StringRef Name, unsigned V) const {
     SmallVector<Value*, 2> Vals;
std::string emitRemark() const {
     if (Force == LoopVectorizeHints::FK_Disabled)
       R << "vectorization is explicitly disabled";
     else {
       R << "use -Rpass-analysis=loop-vectorize for more info";
       if (Force == LoopVectorizeHints::FK_Enabled) {
         R << " (Force=true";
         if (Width != 0)
           R << ", Vector Width=" << Width;
-        if (Unroll != 0)
-          R << ", Interleave Count=" << Unroll;
+        if (Interleave != 0)
+          R << ", Interleave Count=" << Interleave;
         R << ")";
       }
     }
 
     return R.str();
   }
 
   unsigned getWidth() const { return Width; }
-  unsigned getUnroll() const { return Unroll; }
+  unsigned getInterleave() const { return Interleave; }
   enum ForceKind getForce() const { return Force; }
   MDNode *getLoopID() const { return LoopID; }
 
 private:
   /// Find hints specified in the loop metadata.
   void getHints(const Loop *L) {
     if (!LoopID)
       return;
if (Hint == "vectorize.width") {
         DEBUG(dbgs() << "LV: ignoring invalid width hint metadata\n");
     } else if (Hint == "vectorize.enable") {
       if (C->getBitWidth() == 1)
         Force = Val == 1 ? LoopVectorizeHints::FK_Enabled
                          : LoopVectorizeHints::FK_Disabled;
       else
         DEBUG(dbgs() << "LV: ignoring invalid enable hint metadata\n");
     } else if (Hint == "interleave.count") {
-      if (isPowerOf2_32(Val) && Val <= MaxUnrollFactor)
-        Unroll = Val;
+      if (isPowerOf2_32(Val) && Val <= MaxInterleaveFactor)
+        Interleave = Val;
       else
-        DEBUG(dbgs() << "LV: ignoring invalid unroll hint metadata\n");
+        DEBUG(dbgs() << "LV: ignoring invalid interleave hint metadata\n");
     } else {
       DEBUG(dbgs() << "LV: ignoring unknown hint " << Hint << '\n');
     }
   }
 
   /// Vectorization width.
   unsigned Width;
-  /// Vectorization unroll factor.
-  unsigned Unroll;
+  /// Vectorization interleave factor.
+  unsigned Interleave;
   /// Vectorization forced
   enum ForceKind Force;
 
   MDNode *LoopID;
 };
 
 static void emitMissedWarning(Function *F, Loop *L,
                               const LoopVectorizeHints &LH) {
   emitOptimizationRemarkMissed(F->getContext(), DEBUG_TYPE, *F,
                                L->getStartLoc(), LH.emitRemark());
 
   if (LH.getForce() == LoopVectorizeHints::FK_Enabled) {
     if (LH.getWidth() != 1)
       emitLoopVectorizeWarning(
           F->getContext(), *F, L->getStartLoc(),
           "failed explicitly specified loop vectorization");
-    else if (LH.getUnroll() != 1)
+    else if (LH.getInterleave() != 1)
       emitLoopInterleaveWarning(
           F->getContext(), *F, L->getStartLoc(),
           "failed explicitly specified loop interleaving");
   }
 }
 
 static void addInnerLoop(Loop &L, SmallVectorImpl<Loop *> &V) {
   if (L.empty())
#endif /* NDEBUG */
 
     DEBUG(dbgs() << "LV: Loop hints:"
                  << " force="
                  << (Hints.getForce() == LoopVectorizeHints::FK_Disabled
                          ? "disabled"
                          : (Hints.getForce() == LoopVectorizeHints::FK_Enabled
                                 ? "enabled"
                                 : "?")) << " width=" << Hints.getWidth()
-                 << " unroll=" << Hints.getUnroll() << "\n");
+                 << " interleave=" << Hints.getInterleave() << "\n");
 
     // Function containing loop
     Function *F = L->getHeader()->getParent();
 
     // Looking at the diagnostic output is the only way to determine if a loop
     // was vectorized (other than looking at the IR or machine code), so it
     // is important to generate an optimization remark for each loop. Most of
     // these messages are generated by emitOptimizationRemarkAnalysis. Remarks
#endif /* NDEBUG */
 
     if (!AlwaysVectorize && Hints.getForce() != LoopVectorizeHints::FK_Enabled) {
       DEBUG(dbgs() << "LV: Not vectorizing: No #pragma vectorize enable.\n");
       emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
                                      L->getStartLoc(), Hints.emitRemark());
       return false;
     }
 
-    if (Hints.getWidth() == 1 && Hints.getUnroll() == 1) {
+    if (Hints.getWidth() == 1 && Hints.getInterleave() == 1) {
       DEBUG(dbgs() << "LV: Not vectorizing: Disabled/already vectorized.\n");
       emitOptimizationRemarkAnalysis(
           F->getContext(), DEBUG_TYPE, *F, L->getStartLoc(),
           "loop not vectorized: vector width and interleave count are "
           "explicitly set to 1");
       return false;
     }
 
LoopVectorizationCostModel::selectUnrollFactor(bool OptForSize,
   // 1. If the code has reductions, then we unroll in order to break the cross
   // iteration dependency.
   // 2. If the loop is really small, then we unroll in order to reduce the loop
   // overhead.
   // 3. We don't unroll if we think that we will spill registers to memory due
   // to the increased register pressure.
 
   // Use the user preference, unless 'auto' is selected.
-  int UserUF = Hints->getUnroll();
+  int UserUF = Hints->getInterleave();
   if (UserUF != 0)
     return UserUF;
 
   // When we optimize for size, we don't unroll.
   if (OptForSize)
     return 1;
 
   // We used the distance for the unroll factor.
LoopVectorizationCostModel::selectUnrollFactor(bool OptForSize,
   unsigned UF = PowerOf2Floor((TargetNumRegisters - R.LoopInvariantRegs) /
                               R.MaxLocalUsers);
 
   // Don't count the induction variable as unrolled.
   if (EnableIndVarRegisterHeur)
     UF = PowerOf2Floor((TargetNumRegisters - R.LoopInvariantRegs - 1) /
                        std::max(1U, (R.MaxLocalUsers - 1)));
 
-  // Clamp the unroll factor ranges to reasonable factors.
-  unsigned MaxUnrollSize = TTI.getMaximumUnrollFactor();
+  // Clamp the interleave factor ranges to reasonable factors.
+  unsigned MaxInterleaveSize = TTI.getMaxVectorInterleaveFactor();
 
   // Check if the user has overridden the unroll max.
   if (VF == 1) {
     if (ForceTargetMaxScalarUnrollFactor.getNumOccurrences() > 0)
-      MaxUnrollSize = ForceTargetMaxScalarUnrollFactor;
+      MaxInterleaveSize = ForceTargetMaxScalarUnrollFactor;
   } else {
     if (ForceTargetMaxVectorUnrollFactor.getNumOccurrences() > 0)
-      MaxUnrollSize = ForceTargetMaxVectorUnrollFactor;
+      MaxInterleaveSize = ForceTargetMaxVectorUnrollFactor;
   }
 
   // If we did not calculate the cost for VF (because the user selected the VF)
   // then we calculate the cost of VF here.
   if (LoopCost == 0)
     LoopCost = expectedCost(VF);
 
-  // Clamp the calculated UF to be between the 1 and the max unroll factor
+  // Clamp the calculated UF to be between the 1 and the max interleave factor
   // that the target allows.
-  if (UF > MaxUnrollSize)
-    UF = MaxUnrollSize;
+  if (UF > MaxInterleaveSize)
+    UF = MaxInterleaveSize;
   else if (UF < 1)
     UF = 1;
 
   // Unroll if we vectorized this loop and there is a reduction that could
   // benefit from unrolling.
   if (VF > 1 && Legal->getReductionVars()->size()) {
     DEBUG(dbgs() << "LV: Unrolling because of reductions.\n");
     return UF;