[LV][NFC] Optimize out an extra call to isMoreProfitable

[ebrevnov]

Summary

Current implementation of selecting best cost for epilog vectorization is sub-optimal and can be improved by ~2x. The problem is that isMoreProfitable is called twice. First we compare cost of each candidate against scalar cost and cache those ones that are more optimal than the scalar one. Second we travers via cached VFs and try to find most beneficial among them. The thing is that we don't really need to know which ones are better than the scalar one. It's simply enough to do the second step plus one compare against scalar cost.

[ebrevnov]

Ping

[lebedev.ri]

This review may be stuck/dead, consider abandoning if no longer relevant.
Removing myself as reviewer in attempt to clean dashboard.

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

 //===- LoopVectorize.cpp - A Loop Vectorizer ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the LLVM loop vectorizer. This pass modifies 'vectorizable' loops
public:
 
   /// Values to ignore in the cost model when VF > 1.
   SmallPtrSet<const Value *, 16> VecValuesToIgnore;
 
   /// All element types found in the loop.
   SmallPtrSet<Type *, 16> ElementTypesInLoop;
 
   /// Profitable vector factors.
-  SmallVector<VectorizationFactor, 8> ProfitableVFs;
+  SmallVector<VectorizationFactor, 8> CachedVFs;
 
   /// Cached cost of one scalar iteraton;
   VectorizationFactor ScalarVF = {ElementCount::getFixed(1),
                                   InstructionCost::getInvalid()};
 };
 } // end namespace llvm
 
 /// Helper struct to manage generating runtime checks for vectorization.
for (const auto &i : VFCandidates) {
 
     if (!C.second && !ForceVectorization) {
       LLVM_DEBUG(
           dbgs() << "LV: Not considering vector loop of width " << i
                  << " because it will not generate any vector instructions.\n");
       continue;
     }
 
-    // If profitable add it to ProfitableVF list.
-    if (isMoreProfitable(Candidate, getScalarVF()))
-      ProfitableVFs.push_back(Candidate);
+    // Cache calculated cost of the candidate since it will be needed again
+    // during epilogue vectorization cost modeling.
+    CachedVFs.push_back(Candidate);
 
     if (isMoreProfitable(Candidate, ChosenFactor))
       ChosenFactor = Candidate;
   }
 
   // Emit a report of VFs with invalid costs in the loop.
   if (!InvalidCosts.empty()) {
     // Group the remarks per instruction, keeping the instruction order from
bool LoopVectorizationCostModel::isEpilogueVectorizationProfitable(
   if (VF.getFixedValue() >= EpilogueVectorizationMinVF)
     return true;
   return false;
 }
 
 VectorizationFactor
 LoopVectorizationCostModel::selectEpilogueVectorizationFactor(
     const ElementCount MainLoopVF, const LoopVectorizationPlanner &LVP) {
-  VectorizationFactor Result = VectorizationFactor::Disabled();
+  VectorizationFactor Result = getScalarVF();
   if (!EnableEpilogueVectorization) {
     LLVM_DEBUG(dbgs() << "LEV: Epilogue vectorization is disabled.\n";);
     return Result;
   }
 
   if (!isScalarEpilogueAllowed()) {
     LLVM_DEBUG(
         dbgs() << "LEV: Unable to vectorize epilogue because no epilogue is "
LLVM_DEBUG(
         dbgs()
             << "LEV: Epilogue vectorization skipped due to opt for size.\n";);
     return Result;
   }
 
   if (!isEpilogueVectorizationProfitable(MainLoopVF))
     return Result;
 
-  for (auto &NextVF : ProfitableVFs)
+  for (auto &NextVF : CachedVFs) {
+    if (NextVF.Width.isScalar())
+      continue;
     if (ElementCount::isKnownLT(NextVF.Width, MainLoopVF) &&
-        (Result.Width.getFixedValue() == 1 ||
-         isMoreProfitable(NextVF, Result)) &&
+        isMoreProfitable(NextVF, Result) &&
         LVP.hasPlanWithVFs({MainLoopVF, NextVF.Width}))
       Result = NextVF;
+  }
 
   if (Result != VectorizationFactor::Disabled())
     LLVM_DEBUG(dbgs() << "LEV: Vectorizing epilogue loop with VF = "
                       << Result.Width.getFixedValue() << "\n";);
   return Result;
 }
 
 std::pair<unsigned, unsigned>