[SelectOpti][4/5] Loop Heuristics

[apostolakis]

Summary

This patch adds the loop-level heuristics for determining whether branches are more profitable than conditional moves.
These heuristics apply to only inner-most loops.

Depends on D120231

[apostolakis]

Merge

[apostolakis]

Rebase and move tests

[apostolakis]

Use opt tests instead of llc ones

[apostolakis]

Rebase

[apostolakis]

Rebase and add more comments for methods

[davidxl]

A high level comment. I saw ScalingUpFactor is used in many places. It may be better to directly use Scaled64 data type instead of uint64 to avoid that.

[apostolakis]

Use Scaled64 instead of using ScalingUpFactor.

[apostolakis]

In D120232#3460939, @davidxl wrote:

A high level comment. I saw ScalingUpFactor is used in many places. It may be better to directly use Scaled64 data type instead of uint64 to avoid that.

I used ScalingUpFactor to get a decent precision without increasing compile time (due to non-integer ops), but it is a bit hacky and it seems better to directly use Scaled64.

[davidxl]

llvm/lib/CodeGen/SelectOptimize.cpp

394

Not clear about what the second condition actually means. What is the cost of select group?

404

Should this be missed optimization or Analysis. The message probably also needs more context to be useful.

566

Add a parameter?

571

Add explanation of this heuristic.

581

Document the return value.

584

Perhaps passing by pointer explicitly?

588

why only 2 iterations?

616

Should this exclude the selection instruction itself for non-pred case?

644

should it weighted with misprediction rate?

648

Should Sum (of cost in a SI group) be used instead of max?

690

Should it be scaled by CondCost instead of taking the max?

710

Should there be an early return here?

[apostolakis]

llvm/lib/CodeGen/SelectOptimize.cpp

394

Yes that was unclear. Clarified the second condition.

404

I would prefer to stick to miss and pass remarks and not add analysis. It seems to me more natural and easier to know what to query for.
Changed though the code to emit more fine-grained and informative remarks for these cases.

566

Added.

571

Added.

581

Done.

584

Sure. Changed it.

588

Two iterations suffice to determine if the the loop's critical path involves loop-carried dependences and compute the rate that the critical path increases from one iteration to another.

616

It would be correct to exclude the select instructions from here but for the select instructions the INonPredCost is overwritten later on. So, we can skip adding a conditional here.

644

Actually it is weighted with the misprediction rate:
MispredictCost = max(MispredictPenalty, CondCost) * MispredictRate

648

This computes the critical path which essentially is the cost of the last instruction of the critical path (and thus the instruction with the highest latency). This is regardless of how many select groups are included in the loop. These groups may or may not be part of the path.

690

I do not think it should be scaled. The cost we want to compute are the cycles lost due to flushing the pipeline after a mispredict. If the CondCost is small, the operands of the condition are ready when needed and the MispredictPenalty (which depends on the pipeline depth and where the branch condition is determined in the pipeline) captures the mispredict cost . If the CondCost is very big, then the cycles lost end up being the latency of determining the condition, which is essentially CondCost. For in-between cases, the correct answer is not really the max but there is still some overlap. Therefore, max seemed a reasonable choice and it also seemed to be experimentally the best option among other versions I tested.

710

Good catch! Yes, erased by mistake the early return when I converted to Scaled64.

[apostolakis]

Address review comments.

[davidxl]

llvm/lib/CodeGen/SelectOptimize.cpp

396

The second heuristic is similar to the first one -- they are related to latency. Does it make more sense to consider the total pressure on resources?

Also it will be helpful to document in which function herusitc i and ii) are implemented.

572

Perhaps name Diff to Gain to indicate it is the gain from converting Pred to NonPred.

llvm/test/CodeGen/X86/select-optimize.ll

213

Add more test cases to cover other heuristics like gradiant

[apostolakis]

llvm/lib/CodeGen/SelectOptimize.cpp

396

Yes both heuristics are related to latency. But the first one is at a loop-level and all select groups are considered together (if all remain selects or all converted to branches; would be too expensive to try all different combinations), while the second one examines each select group separately. There are cases where one particular select group is unprofitable (or unnecessary) to convert while all the other ones should be converted. The second check allows us to prevent a conversion on the unprofitable one or save some code size if there is no perf diff.

I think considering total pressure on resources would be a separate patch that needs some exploration.

Improved the comments to clarify and added some pointers as suggested.

572

Good point. Changed it.
I actually also added more info in the opti remarks for this part of the code to make tuning of all the thresholds easier.

llvm/test/CodeGen/X86/select-optimize.ll

213

Yep I should have more testing coverage. Added.

[apostolakis]

Address comments with more testing and tweaks.

[bsmith]

llvm/lib/CodeGen/SelectOptimize.cpp

648

Is this really what we want though? As an example, a workload I'm looking at has a structure akin to:

----------------------------critical path
     \------------select-store
     \------------select-store
     \------------select-store
     \------------select-store
     \------------select-store

None of the selects are on the critical path, however they are still significant in terms of cost. This may be for a future patch that looks at resources, but it may be better to cost each path with a select on it individually, rather than costing the loop as a whole.

[apostolakis]

llvm/lib/CodeGen/SelectOptimize.cpp

648

There are definitely more cases that we might want to consider beyond the critical path. Yet, focusing on the critical path for this initial series of this new optimization will help catch the most obvious patterns and reduce the chances of regressions. Cases such as the one you mention will indeed need modeling of the resources and more testing, since there are definitely cases where you want to avoid a branch for non-critical-path selects.

I could add an option to disable the loop-level heuristics (that checks the reduction in the critical path, see line 462) and thus reduce the decision to the cost of each individual select (see line 465 and 478). This will allow experimenting with some of these cases. These costs will capture the gains for all the paths but it will not explicitly capture the total cost of each path. For your case, it will report the gain of converting the selects to branches (new vs old select cost) but it will not report the total cost of each path, i.e., select_cost + store_cost. Could try to add monitoring of all the local maximum in the loop and report them if you want.

[bsmith]

llvm/lib/CodeGen/SelectOptimize.cpp

648

An option to disable the critical path check would be good in the meantime I think. If I manually remove that check then this patch series, alongside the other patch you have to sink instructions, provide a very significant speedup for my case.

[apostolakis]

llvm/lib/CodeGen/SelectOptimize.cpp

648

Added the option to disable the critical path check.

[apostolakis]

Add option to disable the critical path check.

[davidxl]

lgtm

llvm/lib/CodeGen/SelectOptimize.cpp

 //===--- SelectOptimize.cpp - Convert select to branches if profitable ---===//
 //
 // 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 pass converts selects to conditional jumps when profitable.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"

 STATISTIC(NumSelectOptAnalyzed,
           "Number of select groups considered for conversion to branch");
 STATISTIC(NumSelectConvertedExpColdOperand,
           "Number of select groups converted due to expensive cold operand");
 STATISTIC(NumSelectConvertedHighPred,
           "Number of select groups converted due to high-predictability");
 STATISTIC(NumSelectUnPred,
           "Number of select groups not converted due to unpredictability");
+STATISTIC(NumSelectConvertedLoop,
+          "Number of select groups converted due to loop-level analysis");
 STATISTIC(NumSelectsConverted, "Number of selects converted");
 
 static cl::opt<unsigned> ColdOperandThreshold(
     "cold-operand-threshold",
     cl::desc("Maximum frequency of path for an operand to be considered cold."),
     cl::init(20), cl::Hidden);
 
+static cl::opt<unsigned>
+    LoopGradientGain("loop-gradient-gain",
+                     cl::desc("Gradient gain threshold (%)."), cl::init(25),
+                     cl::Hidden);
+
+static cl::opt<unsigned>
+    GainCycleThreshold("select-converter-loop-threshold",
+                       cl::desc("Minimum gain per loop (in cycles) threshold."),
+                       cl::init(4), cl::Hidden);
+
+static cl::opt<unsigned> MispredictDefaultRate(
+    "mispredict-default-rate", cl::Hidden, cl::init(25),
+    cl::desc("Default mispredict rate (initialized to 25%)."));
+
 namespace {
 
 class SelectOptimize : public FunctionPass {
   const TargetMachine *TM = nullptr;
   const TargetSubtargetInfo *TSI;
   const TargetLowering *TLI = nullptr;
   const TargetTransformInfo *TTI = nullptr;
   const LoopInfo *LI;
   DominatorTree *DT;
   std::unique_ptr<BlockFrequencyInfo> BFI;
   std::unique_ptr<BranchProbabilityInfo> BPI;
   ProfileSummaryInfo *PSI;
   OptimizationRemarkEmitter *ORE;
+  TargetSchedModel TSchedModel;
+
+  // Scaling up factor to avoid precision issues with integer division.
+  const unsigned ScalingUpFactor = 1000;
 
 public:
   static char ID;
 
   SelectOptimize() : FunctionPass(ID) {
     initializeSelectOptimizePass(*PassRegistry::getPassRegistry());
   }
 
public:
   }
 
 private:
   // Select groups consist of consecutive select instructions with the same
   // condition.
   using SelectGroup = SmallVector<SelectInst *, 2>;
   using SelectGroups = SmallVector<SelectGroup, 2>;
 
+  struct CostInfo {
+    /// Predicated cost (with selects as conditional moves).
+    uint64_t PredCost;
+    /// Non-predicated cost (with selects converted to branches).
+    uint64_t NonPredCost;
+  };
+
   bool optimizeSelects(Function &F);
   void optimizeSelectsBase(Function &F, SelectGroups &ProfSIGroups);
   void optimizeSelectsInnerLoops(Function &F, SelectGroups &ProfSIGroups);
   void convertProfitableSIGroups(SelectGroups &ProfSIGroups);
   void collectSelectGroups(BasicBlock &BB, SelectGroups &SIGroups);
   void findProfitableSIGroupsBase(SelectGroups &SIGroups,
                                   SelectGroups &ProfSIGroups);
+  void findProfitableSIGroupsInnerLoops(const Loop *L, SelectGroups &SIGroups,
+                                        SelectGroups &ProfSIGroups);
   bool isConvertToBranchProfitableBase(const SmallVector<SelectInst *, 2> &ASI);
   bool hasExpensiveColdOperand(const SmallVector<SelectInst *, 2> &ASI);
   void getOneUseSlice(Instruction *I, SmallVector<Instruction *, 2> &Slice);
   bool isSelectHighlyPredictable(const SelectInst *SI);
+  bool checkLoopHeuristics(CostInfo LoopDepth[2]);
+  bool computeLoopCosts(const Loop *L, const SelectGroups &SIGroups,
+                        DenseMap<const Instruction *, CostInfo> &InstCostMap,
+                        CostInfo LoopCost[2]);
+  SmallPtrSet<const Instruction *, 2> getSIset(const SelectGroups &SIGroups);
+  Optional<uint64_t> computeInstCost(const Instruction *I);
+  uint64_t getMispredictionCost(const SelectInst *SI, const uint64_t CondCost);
+  uint64_t predictedPathCost(uint64_t TrueCost, uint64_t FalseCost,
+                             const SelectInst *SI);
   bool isExpensiveInst(Instruction *I);
   bool isSelectKindSupported(SelectInst *SI);
 };
 } // namespace
 
 char SelectOptimize::ID = 0;
 
 INITIALIZE_PASS_BEGIN(SelectOptimize, DEBUG_TYPE, "Optimize selects", false,
bool SelectOptimize::runOnFunction(Function &F) {
 
   TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   BPI.reset(new BranchProbabilityInfo(F, *LI));
   BFI.reset(new BlockFrequencyInfo(F, *BPI, *LI));
   PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
   ORE = &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE();
+  TSchedModel.init(TSI);
 
   // When optimizing for size, selects are preferable over branches.
   if (F.hasOptSize() || llvm::shouldOptimizeForSize(&F, PSI, BFI.get()))
     return false;
 
   return optimizeSelects(F);
 }
 
for (BasicBlock &BB : F) {
     collectSelectGroups(BB, SIGroups);
   }
 
   // Determine for which select groups it is profitable converting to branches.
   findProfitableSIGroupsBase(SIGroups, ProfSIGroups);
 }
 
 void SelectOptimize::optimizeSelectsInnerLoops(Function &F,
-                                               SelectGroups &ProfSIGroups) {}
+                                               SelectGroups &ProfSIGroups) {
+  SmallVector<Loop *, 4> Loops(LI->begin(), LI->end());
+  // Need to check size on each iteration as we accumulate child loops.
+  for (unsigned long i = 0; i < Loops.size(); ++i)
+    for (Loop *ChildL : Loops[i]->getSubLoops())
+      Loops.push_back(ChildL);
+
+  for (Loop *L : Loops) {
+    if (!L->isInnermost())
+      continue;
+
+    SelectGroups SIGroups;
+    for (BasicBlock *BB : L->getBlocks())
+      collectSelectGroups(*BB, SIGroups);
+
+    findProfitableSIGroupsInnerLoops(L, SIGroups, ProfSIGroups);
+  }
+}
 
 /// If \p isTrue is true, return the true value of \p SI, otherwise return
 /// false value of \p SI. If the true/false value of \p SI is defined by any
 /// select instructions in \p Selects, look through the defining select
 /// instruction until the true/false value is not defined in \p Selects.
 static Value *
 getTrueOrFalseValue(SelectInst *SI, bool isTrue,
                     const SmallPtrSet<const Instruction *, 2> &Selects) {
void SelectOptimize::findProfitableSIGroupsBase(SelectGroups &SIGroups,
                                                 SelectGroups &ProfSIGroups) {
   for (SelectGroup &ASI : SIGroups) {
     ++NumSelectOptAnalyzed;
     if (isConvertToBranchProfitableBase(ASI))
       ProfSIGroups.push_back(ASI);
   }
 }
 
+void SelectOptimize::findProfitableSIGroupsInnerLoops(
+    const Loop *L, SelectGroups &SIGroups, SelectGroups &ProfSIGroups) {
+  NumSelectOptAnalyzed += SIGroups.size();
+  // For each select group in an inner-most loop,
+  // a branch is more preferable than a select/conditional-move if:
+  // i) conversion to branches satisfies loop-level heuristics including
+  //    reducing the loop's critical path by some threshold; and
+  // ii) the cost of the select group is cheaper (in terms of latency) compared
+  //     to the select version.
+
+  DenseMap<const Instruction *, CostInfo> InstCostMap;
+  CostInfo LoopCost[2] = {{0, 0}, {0, 0}};
+  if (!computeLoopCosts(L, SIGroups, InstCostMap, LoopCost) ||
+      !checkLoopHeuristics(LoopCost)) {
+    OptimizationRemarkMissed ORmissL(DEBUG_TYPE, "SelectOpti",
+                                     L->getHeader()->getFirstNonPHI());
+    ORmissL << "Did not convert any select in the loop to branch due to "
+               "loop-level heuristics.";
+    ORE->emit(ORmissL);
+    return;
+  }
+
+  for (SelectGroup &ASI : SIGroups) {
+    // Assuming infinite resources, the cost of a group of instructions is the
+    // cost of the most expensive instruction of the group.
+    uint64_t SelectCost = 0, BranchCost = 0;
+    for (SelectInst *SI : ASI) {
+      SelectCost = std::max(SelectCost, InstCostMap[SI].PredCost);
+      BranchCost = std::max(BranchCost, InstCostMap[SI].NonPredCost);
+    }
+    if (BranchCost < SelectCost) {
+      OptimizationRemark OR(DEBUG_TYPE, "SelectOpti", ASI.front());
+      OR << "Profitable to convert to branch (loop analysis). BranchCost="
+         << std::to_string(BranchCost)
+         << ", SelectCost=" << std::to_string(SelectCost) << ". ";
+      ORE->emit(OR);
+      ++NumSelectConvertedLoop;
+      ProfSIGroups.push_back(ASI);
+    } else {
+      OptimizationRemarkMissed ORmiss(DEBUG_TYPE, "SelectOpti", ASI.front());
+      ORmiss << "Select is more profitable (loop analysis). BranchCost="
+             << std::to_string(BranchCost)
+             << ", SelectCost=" << std::to_string(SelectCost) << ". ";
+      ORE->emit(ORmiss);
+    }
+  }
+}
+
 bool SelectOptimize::isConvertToBranchProfitableBase(
     const SmallVector<SelectInst *, 2> &ASI) {
   SelectInst *SI = ASI.front();
   OptimizationRemark OR(DEBUG_TYPE, "SelectOpti", SI);
   OptimizationRemarkMissed ORmiss(DEBUG_TYPE, "SelectOpti", SI);
 
   // If unpredictable, branch form is more profitable.
   if (SI->getMetadata(LLVMContext::MD_unpredictable)) {
if (Sum != 0) {
       auto Probability = BranchProbability::getBranchProbability(Max, Sum);
       if (Probability > TTI->getPredictableBranchThreshold())
         return true;
     }
   }
   return false;
 }
 
+bool SelectOptimize::checkLoopHeuristics(CostInfo LoopCost[2]) {
+  // Loop-level checks to determine if a non-predicated version (with branches)
+  // of the loop is more profitable than its predicated version.
+  uint64_t Diff[2] = {LoopCost[0].PredCost - LoopCost[0].NonPredCost,
+                      LoopCost[1].PredCost - LoopCost[1].NonPredCost};
+
+  // Profitably converting to branches need to reduce the loop's critical path
+  // by at least some threshold (absolute gain of GainCycleThreshold cycles and
+  // relative gain of 12.5%).
+  if (Diff[1] < GainCycleThreshold * ScalingUpFactor &&
+      Diff[1] * 8 < LoopCost[1].PredCost)
+    return false;
+
+  // If the loop's critical path involves loop-carried dependences, the gradient
+  // of the gain needs to be at least LoopGradientGain% (defaults to 25%).
+  if (Diff[1] > Diff[0] &&
+      (Diff[1] - Diff[0]) * 100 <
+          (LoopCost[1].PredCost - LoopCost[0].PredCost) * LoopGradientGain)
+    return false;
+
+  // Non-predicated version of the loop is more profitable than its
+  // predicated version.
+  return true;
+}
+
+bool SelectOptimize::computeLoopCosts(
+    const Loop *L, const SelectGroups &SIGroups,
+    DenseMap<const Instruction *, CostInfo> &InstCostMap,
+    CostInfo LoopCost[2]) {
+  const auto &SIset = getSIset(SIGroups);
+  // Compute instruction and loop-critical-path costs across two iterations for
+  // both predicated and non-predicated version.
+  const unsigned Iterations = 2;
+  for (unsigned Iter = 0; Iter < Iterations; ++Iter) {
+    // Cost of the loop's critical path.
+    CostInfo &MaxCost = LoopCost[Iter];
+    for (BasicBlock *BB : L->getBlocks()) {
+      for (const Instruction &I : *BB) {
+        if (I.isDebugOrPseudoInst())
+          continue;
+        // Compute the predicated and non-predicated cost of the instruction.
+        uint64_t IPredCost = 0, INonPredCost = 0;
+
+        // Assume infinite resources that allow to fully exploit the available
+        // instruction-level parallelism.
+        // InstCost = InstLatency + max(Op1Cost, Op2Cost, … OpNCost)
+        for (const Use &U : I.operands()) {
+          auto UI = dyn_cast<Instruction>(U.get());
+          if (!UI)
+            continue;
+          if (InstCostMap.count(UI)) {
+            IPredCost = std::max(IPredCost, InstCostMap[UI].PredCost);
+            INonPredCost = std::max(INonPredCost, InstCostMap[UI].NonPredCost);
+          }
+        }
+        auto ILatency = computeInstCost(&I);
+        if (!ILatency.hasValue())
+          return false;
+        IPredCost += ScalingUpFactor * ILatency.getValue();
+        INonPredCost += ScalingUpFactor * ILatency.getValue();
+
+        // For a select that can be converted to branch,
+        // compute its cost as a branch (non-predicated cost).
+        //
+        // BranchCost = PredictedPathCost + MispredictCost
+        // PredictedPathCost = TrueOpCost * TrueProb + FalseOpCost * FalseProb
+        // MispredictCost = max(MispredictPenalty, CondCost) * MispredictRate
+        if (SIset.contains(&I)) {
+          auto SI = dyn_cast<SelectInst>(&I);
+
+          uint64_t TrueOpCost = 0, FalseOpCost = 0;
+          if (auto *TI = dyn_cast<Instruction>(SI->getTrueValue()))
+            if (InstCostMap.count(TI))
+              TrueOpCost = InstCostMap[TI].NonPredCost;
+          if (auto *FI = dyn_cast<Instruction>(SI->getFalseValue()))
+            if (InstCostMap.count(FI))
+              FalseOpCost = InstCostMap[FI].NonPredCost;
+          uint64_t PredictedPathCost =
+              predictedPathCost(TrueOpCost, FalseOpCost, SI);
+
+          uint64_t CondCost = 0;
+          if (auto *CI = dyn_cast<Instruction>(SI->getCondition()))
+            if (InstCostMap.count(CI))
+              CondCost = InstCostMap[CI].NonPredCost;
+          uint64_t MispredictCost = getMispredictionCost(SI, CondCost);
+
+          INonPredCost = PredictedPathCost + MispredictCost;
+        }
+
+        InstCostMap[&I] = {IPredCost, INonPredCost};
+        MaxCost.PredCost = std::max(MaxCost.PredCost, IPredCost);
+        MaxCost.NonPredCost = std::max(MaxCost.NonPredCost, INonPredCost);
+      }
+    }
+  }
+  return true;
+}
+
+SmallPtrSet<const Instruction *, 2>
+SelectOptimize::getSIset(const SelectGroups &SIGroups) {
+  SmallPtrSet<const Instruction *, 2> SIset;
+  for (const SelectGroup &ASI : SIGroups)
+    for (const SelectInst *SI : ASI)
+      SIset.insert(SI);
+  return SIset;
+}
+
+Optional<uint64_t> SelectOptimize::computeInstCost(const Instruction *I) {
+  InstructionCost ICost =
+      TTI->getInstructionCost(I, TargetTransformInfo::TCK_Latency);
+  if (auto OC = ICost.getValue())
+    return Optional<uint64_t>(OC.getValue());
+  return Optional<uint64_t>(None);
+}
+
+uint64_t SelectOptimize::getMispredictionCost(const SelectInst *SI,
+                                              const uint64_t CondCost) {
+  uint64_t MispredictPenalty = TSchedModel.getMCSchedModel()->MispredictPenalty;
+
+  // Account for the default misprediction rate when using a branch
+  // (conservatively set to 25% by default).
+  uint64_t MispredictRate = MispredictDefaultRate;
+  // If the select condition is obviously predictable, then the misprediction
+  // rate is zero.
+  if (isSelectHighlyPredictable(SI))
+    MispredictRate = 0;
+
+  // CondCost is included to account for cases where the computation of the
+  // condition is part of a long dependence chain (potentially loop-carried)
+  // that would delay detection of a misprediction and increase its cost.
+  uint64_t MispredictCost = divideCeil(
+      std::max(ScalingUpFactor * MispredictPenalty, CondCost) * MispredictRate,
+      100);
+  return MispredictCost;
+}
+
+// Returns the cost of a branch when the prediction is correct.
+// TrueCost * TrueProbability + FalseCost * FalseProbability.
+uint64_t SelectOptimize::predictedPathCost(uint64_t TrueCost,
+                                           uint64_t FalseCost,
+                                           const SelectInst *SI) {
+  uint64_t TrueWeight, FalseWeight;
+  if (SI->extractProfMetadata(TrueWeight, FalseWeight)) {
+    uint64_t SumWeight = TrueWeight + FalseWeight;
+    if (SumWeight != 0)
+      return divideCeil(TrueCost * TrueWeight + FalseCost * FalseWeight,
+                        SumWeight);
+  }
+  // Without branch weight metadata, we assume 75% for the one path and 25% for
+  // the other, and pick the result with the biggest cost.
+  return std::max(divideCeil(TrueCost * 3 + FalseCost, 4),
+                  divideCeil(FalseCost * 3 + TrueCost, 4));
+}
+
 bool SelectOptimize::isExpensiveInst(Instruction *I) {
   return TTI->getInstructionCost(I, TargetTransformInfo::TCK_Latency) >=
          TargetTransformInfo::TCC_Expensive;
 }
 
 bool SelectOptimize::isSelectKindSupported(SelectInst *SI) {
   bool VectorCond = !SI->getCondition()->getType()->isIntegerTy(1);
   if (VectorCond)
     return false;
   TargetLowering::SelectSupportKind SelectKind;
   if (SI->getType()->isVectorTy())
     SelectKind = TargetLowering::ScalarCondVectorVal;
   else
     SelectKind = TargetLowering::ScalarValSelect;
   return TLI->isSelectSupported(SelectKind);
 }

llvm/test/CodeGen/X86/select-optimize.ll

 ; CHECK-NEXT:    ret i32 [[ADD]]
 ;
   %load = load i32, i32* %b, align 4
   %sel = select i1 %cmp, i32 %x, i32 %load
   %add = add i32 %sel, %load
   ret i32 %add
 }
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Test loop heuristic: loop-level critical-path analysis
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use of cmov in this test would put a load and a fsub on the critical path.
+;; Loop-level analysis should decide to form a branch.
+;;
+;;double cmov_on_critical_path(int n, double x, double *a) {
+;;  for (int i = 0; i < n; i++) {
+;;    double r = a[i];
+;;    if (x > r)
+;;      // 50% of iterations
+;;      x -= r;
+;;  }
+;;  return x;
+;;}
+define double @cmov_on_critical_path(i32 %n, double %x, double* nocapture %a) {
+; CHECK-LABEL: @cmov_on_critical_path(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i32 [[N:%.*]], 0
+; CHECK-NEXT:    br i1 [[CMP1]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
+; CHECK:       for.cond.cleanup:
+; CHECK-NEXT:    ret double [[X:%.*]]
+; CHECK:       for.body.preheader:
+; CHECK-NEXT:    [[WIDE_TRIP_COUNT:%.*]] = zext i32 [[N]] to i64
+; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
+; CHECK:       for.body:
+; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[SELECT_END:%.*]] ], [ 0, [[FOR_BODY_PREHEADER]] ]
+; CHECK-NEXT:    [[X1:%.*]] = phi double [ [[X2:%.*]], [[SELECT_END]] ], [ [[X]], [[FOR_BODY_PREHEADER]] ]
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds double, double* [[A:%.*]], i64 [[INDVARS_IV]]
+; CHECK-NEXT:    [[R:%.*]] = load double, double* [[ARRAYIDX]], align 8
+; CHECK-NEXT:    [[SUB:%.*]] = fsub double [[X1]], [[R]]
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ogt double [[X1]], [[R]]
+; CHECK-NEXT:    [[X2_FROZEN:%.*]] = freeze i1 [[CMP2]]
+; CHECK-NEXT:    br i1 [[X2_FROZEN]], label [[SELECT_END]], label [[SELECT_FALSE:%.*]], !prof [[PROF20:![0-9]+]]
+; CHECK:       select.false:
+; CHECK-NEXT:    br label [[SELECT_END]]
+; CHECK:       select.end:
+; CHECK-NEXT:    [[X2]] = phi double [ [[SUB]], [[FOR_BODY]] ], [ [[X1]], [[SELECT_FALSE]] ]
+; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
+; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i64 [[INDVARS_IV_NEXT]], [[WIDE_TRIP_COUNT]]
+; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_EXIT:%.*]], label [[FOR_BODY]]
+; CHECK:       for.exit:
+; CHECK-NEXT:    ret double [[X2]]
+;
+entry:
+  %cmp1 = icmp sgt i32 %n, 0
+  br i1 %cmp1, label %for.body.preheader, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %entry
+  ret double %x
+
+for.body.preheader:                               ; preds = %entry
+  %wide.trip.count = zext i32 %n to i64
+  br label %for.body
+
+for.body:                                         ; preds = %for.body.preheader, %for.body
+  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %for.body.preheader ]
+  %x1 = phi double [ %x2, %for.body ], [ %x, %for.body.preheader ]
+  %arrayidx = getelementptr inbounds double, double* %a, i64 %indvars.iv
+  %r = load double, double* %arrayidx, align 8
+  %sub = fsub double %x1, %r
+  %cmp2 = fcmp ogt double %x1, %r
+  %x2 = select i1 %cmp2, double %sub, double %x1, !prof !18
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, %wide.trip.count
+  br i1 %exitcond, label %for.exit, label %for.body
+
+for.exit:                                         ; preds = %for.body
+  ret double %x2
+}
+
 !llvm.module.flags = !{!0}
 !0 = !{i32 1, !"ProfileSummary", !1}
 !1 = !{!2, !3, !4, !5, !6, !7, !8, !9}
 !2 = !{!"ProfileFormat", !"InstrProf"}
 !3 = !{!"TotalCount", i64 10000}
 !4 = !{!"MaxCount", i64 10}
 !5 = !{!"MaxInternalCount", i64 1}
 !6 = !{!"MaxFunctionCount", i64 1000}