Commit 1ba4b82f authored by Cullen Rhodes's avatar Cullen Rhodes
Browse files

[LAA] NFC: Rename [get]MaxSafeRegisterWidth -> [get]MaxSafeVectorWidthInBits 

MaxSafeRegisterWidth is a misnomer since it actually returns the maximum
safe vector width. Register suggests it relates directly to a physical
register where it could be a vector spanning one or more physical
registers.

Reviewed By: sdesmalen

Differential Revision: https://reviews.llvm.org/D91727
parent ecabb39c

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

+6 −3
Original line number Diff line number Diff line
@@ -171,7 +171,8 @@ public: 


  MemoryDepChecker(PredicatedScalarEvolution &PSE, const Loop *L)

      : PSE(PSE), InnermostLoop(L), AccessIdx(0), MaxSafeDepDistBytes(0),

        MaxSafeRegisterWidth(-1U), FoundNonConstantDistanceDependence(false),

        MaxSafeVectorWidthInBits(-1U),

        FoundNonConstantDistanceDependence(false),

        Status(VectorizationSafetyStatus::Safe), RecordDependences(true) {}



  /// Register the location (instructions are given increasing numbers)
@@ -210,7 +211,9 @@ public: 


  /// Return the number of elements that are safe to operate on

  /// simultaneously, multiplied by the size of the element in bits.

  uint64_t getMaxSafeRegisterWidth() const { return MaxSafeRegisterWidth; }

  uint64_t getMaxSafeVectorWidthInBits() const {

    return MaxSafeVectorWidthInBits;

  }



  /// In same cases when the dependency check fails we can still

  /// vectorize the loop with a dynamic array access check.
@@ -275,7 +278,7 @@ private: 
  /// operate on simultaneously, multiplied by the size of the element in bits.

  /// The size of the element is taken from the memory access that is most

  /// restrictive.

  uint64_t MaxSafeRegisterWidth;

  uint64_t MaxSafeVectorWidthInBits;



  /// If we see a non-constant dependence distance we can still try to

  /// vectorize this loop with runtime checks.

llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h

+2 −2
Original line number Diff line number Diff line
@@ -311,8 +311,8 @@ public: 


  unsigned getMaxSafeDepDistBytes() { return LAI->getMaxSafeDepDistBytes(); }



  uint64_t getMaxSafeRegisterWidth() const {

    return LAI->getDepChecker().getMaxSafeRegisterWidth();

  uint64_t getMaxSafeVectorWidthInBits() const {

    return LAI->getDepChecker().getMaxSafeVectorWidthInBits();

  }



  bool hasStride(Value *V) { return LAI->hasStride(V); }

llvm/lib/Analysis/LoopAccessAnalysis.cpp

+1 −1
Original line number Diff line number Diff line
@@ -1654,7 +1654,7 @@ MemoryDepChecker::isDependent(const MemAccessInfo &A, unsigned AIdx, 
  LLVM_DEBUG(dbgs() << "LAA: Positive distance " << Val.getSExtValue()

                    << " with max VF = " << MaxVF << '\n');

  uint64_t MaxVFInBits = MaxVF * TypeByteSize * 8;

  MaxSafeRegisterWidth = std::min(MaxSafeRegisterWidth, MaxVFInBits);

  MaxSafeVectorWidthInBits = std::min(MaxSafeVectorWidthInBits, MaxVFInBits);

  return Dependence::BackwardVectorizable;

}

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

+2 −2
Original line number Diff line number Diff line
@@ -5369,9 +5369,9 @@ LoopVectorizationCostModel::computeFeasibleMaxVF(unsigned ConstTripCount) { 
  // It is computed by MaxVF * sizeOf(type) * 8, where type is taken from

  // the memory accesses that is most restrictive (involved in the smallest

  // dependence distance).

  unsigned MaxSafeRegisterWidth = Legal->getMaxSafeRegisterWidth();

  unsigned MaxSafeVectorWidthInBits = Legal->getMaxSafeVectorWidthInBits();



  WidestRegister = std::min(WidestRegister, MaxSafeRegisterWidth);

  WidestRegister = std::min(WidestRegister, MaxSafeVectorWidthInBits);



  // Ensure MaxVF is a power of 2; the dependence distance bound may not be.

  // Note that both WidestRegister and WidestType may not be a powers of 2.