[llvm] 9db6e97 - [LoopVectorize] NFC: Change computeFeasibleMaxVF to operate on ElementCount.
Sander de Smalen via llvm-commits
llvm-commits at lists.llvm.org
Wed Feb 10 01:11:01 PST 2021
Author: Sander de Smalen
Date: 2021-02-10T08:52:10Z
New Revision: 9db6e97a8605f6a447ed171e59d5fa46fdfdc432
URL: https://github.com/llvm/llvm-project/commit/9db6e97a8605f6a447ed171e59d5fa46fdfdc432
DIFF: https://github.com/llvm/llvm-project/commit/9db6e97a8605f6a447ed171e59d5fa46fdfdc432.diff
LOG: [LoopVectorize] NFC: Change computeFeasibleMaxVF to operate on ElementCount.
This patch is NFC and changes occurrences of `unsigned MaxVectorSize`
to work on type ElementCount.
This patch is a preparatory patch with the ultimate goal of making
`computeMaxVF()` return both a max fixed VF and a max scalable VF,
so that `selectVectorizationFactor()` can pick the most cost-effective
vectorization factor.
Reviewed By: kmclaughlin
Differential Revision: https://reviews.llvm.org/D96018
Added:
Modified:
llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 9d8b7c1c07e7..8fb4196288ba 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -5760,39 +5760,40 @@ LoopVectorizationCostModel::computeFeasibleMaxVF(unsigned ConstTripCount,
// 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.
- unsigned MaxVectorSize = PowerOf2Floor(WidestRegister / WidestType);
+ auto MaxVectorSize =
+ ElementCount::getFixed(PowerOf2Floor(WidestRegister / WidestType));
LLVM_DEBUG(dbgs() << "LV: The Smallest and Widest types: " << SmallestType
<< " / " << WidestType << " bits.\n");
LLVM_DEBUG(dbgs() << "LV: The Widest register safe to use is: "
<< WidestRegister << " bits.\n");
- assert(MaxVectorSize <= WidestRegister &&
+ assert(MaxVectorSize.getFixedValue() <= WidestRegister &&
"Did not expect to pack so many elements"
" into one vector!");
- if (MaxVectorSize == 0) {
+ if (MaxVectorSize.getFixedValue() == 0) {
LLVM_DEBUG(dbgs() << "LV: The target has no vector registers.\n");
- MaxVectorSize = 1;
- return ElementCount::getFixed(MaxVectorSize);
- } else if (ConstTripCount && ConstTripCount < MaxVectorSize &&
+ return ElementCount::getFixed(1);
+ } else if (ConstTripCount && ConstTripCount < MaxVectorSize.getFixedValue() &&
isPowerOf2_32(ConstTripCount)) {
// We need to clamp the VF to be the ConstTripCount. There is no point in
// choosing a higher viable VF as done in the loop below.
LLVM_DEBUG(dbgs() << "LV: Clamping the MaxVF to the constant trip count: "
<< ConstTripCount << "\n");
- MaxVectorSize = ConstTripCount;
- return ElementCount::getFixed(MaxVectorSize);
+ return ElementCount::getFixed(ConstTripCount);
}
- unsigned MaxVF = MaxVectorSize;
+ ElementCount MaxVF = MaxVectorSize;
if (TTI.shouldMaximizeVectorBandwidth(!isScalarEpilogueAllowed()) ||
(MaximizeBandwidth && isScalarEpilogueAllowed())) {
// Collect all viable vectorization factors larger than the default MaxVF
// (i.e. MaxVectorSize).
SmallVector<ElementCount, 8> VFs;
- unsigned NewMaxVectorSize = WidestRegister / SmallestType;
- for (unsigned VS = MaxVectorSize * 2; VS <= NewMaxVectorSize; VS *= 2)
- VFs.push_back(ElementCount::getFixed(VS));
+ auto MaxVectorSizeMaxBW =
+ ElementCount::getFixed(WidestRegister / SmallestType);
+ for (ElementCount VS = MaxVectorSize * 2;
+ ElementCount::isKnownLE(VS, MaxVectorSizeMaxBW); VS *= 2)
+ VFs.push_back(VS);
// For each VF calculate its register usage.
auto RUs = calculateRegisterUsage(VFs);
@@ -5801,25 +5802,25 @@ LoopVectorizationCostModel::computeFeasibleMaxVF(unsigned ConstTripCount,
// ones.
for (int i = RUs.size() - 1; i >= 0; --i) {
bool Selected = true;
- for (auto& pair : RUs[i].MaxLocalUsers) {
+ for (auto &pair : RUs[i].MaxLocalUsers) {
unsigned TargetNumRegisters = TTI.getNumberOfRegisters(pair.first);
if (pair.second > TargetNumRegisters)
Selected = false;
}
if (Selected) {
- MaxVF = VFs[i].getKnownMinValue();
+ MaxVF = VFs[i];
break;
}
}
- if (unsigned MinVF = TTI.getMinimumVF(SmallestType)) {
- if (MaxVF < MinVF) {
+ if (auto MinVF = ElementCount::getFixed(TTI.getMinimumVF(SmallestType))) {
+ if (ElementCount::isKnownLT(MaxVF, MinVF)) {
LLVM_DEBUG(dbgs() << "LV: Overriding calculated MaxVF(" << MaxVF
<< ") with target's minimum: " << MinVF << '\n');
MaxVF = MinVF;
}
}
}
- return ElementCount::getFixed(MaxVF);
+ return MaxVF;
}
VectorizationFactor
More information about the llvm-commits
mailing list