[Inline][PGO] Skip block-frequency weighted simplified instructions in the callee when computing cycle savings

[mingmingl]

Summary

• SimplifiedValues track the instructions that could be simplified away (to constants) without inlining the callee. From the cost estimation, when an instruction cannot be simplified away, it adds to cost (https://github.com/llvm/llvm-project/blob/e7b4c93f5e609728bbfc4d7d34b29cd6ac92a0b0/llvm/lib/Analysis/InlineCost.cpp#L2483-L2486) If I understand correctly they don't add to savings of inlining the function.

Tested on an internal workload. Didn't see regressions. Got reduced '.text.hot' and a small improvements (still verifying using different versions of code)

[mingmingl]

hmm the evaluation of simplified values indeed look at caller information so this sounds reasonable then. Sorry about the noise!

llvm/lib/Analysis/InlineCost.cpp

std::optional<bool> costBenefitAnalysis() {
     // TODO: Improve this hacky condition.
     if (Threshold == 0)
       return std::nullopt;
 
     assert(GetBFI);
     BlockFrequencyInfo *CalleeBFI = &(GetBFI(F));
     assert(CalleeBFI);
 
-    // The cycle savings expressed as the sum of InstrCost
-    // multiplied by the estimated dynamic count of each instruction we can
-    // avoid.  Savings come from the call site cost, such as argument setup and
-    // the call instruction, as well as the instructions that are folded.
+    // The cycle savings expressed as savings come from the call site cost, such as argument setup and
+    // the call instruction.
     //
     // We use 128-bit APInt here to avoid potential overflow.  This variable
     // should stay well below 10^^24 (or 2^^80) in practice.  This "worst" case
     // assumes that we can avoid or fold a billion instructions, each with a
     // profile count of 10^^15 -- roughly the number of cycles for a 24-hour
     // period on a 4GHz machine.
     APInt CycleSavings(128, 0);
 
-    for (auto &BB : F) {
-      APInt CurrentSavings(128, 0);
-      for (auto &I : BB) {
-        if (BranchInst *BI = dyn_cast<BranchInst>(&I)) {
-          // Count a conditional branch as savings if it becomes unconditional.
-          if (BI->isConditional() &&
-              isa_and_nonnull<ConstantInt>(
-                  SimplifiedValues.lookup(BI->getCondition()))) {
-            CurrentSavings += InstrCost;
-          }
-        } else if (Value *V = dyn_cast<Value>(&I)) {
-          // Count an instruction as savings if we can fold it.
-          if (SimplifiedValues.count(V)) {
-            CurrentSavings += InstrCost;
-          }
-        }
-      }
-
-      auto ProfileCount = CalleeBFI->getBlockProfileCount(&BB);
-      CurrentSavings *= *ProfileCount;
-      CycleSavings += CurrentSavings;
-    }
-
-    // Compute the cycle savings per call.
-    auto EntryProfileCount = F.getEntryCount();
-    assert(EntryProfileCount && EntryProfileCount->getCount());
-    auto EntryCount = EntryProfileCount->getCount();
-    CycleSavings += EntryCount / 2;
-    CycleSavings = CycleSavings.udiv(EntryCount);
-
     // Compute the total savings for the call site.
     auto *CallerBB = CandidateCall.getParent();
     BlockFrequencyInfo *CallerBFI = &(GetBFI(*(CallerBB->getParent())));
     CycleSavings += getCallsiteCost(this->CandidateCall, DL);
     CycleSavings *= *CallerBFI->getBlockProfileCount(CallerBB);
 
     // Remove the cost of the cold basic blocks.
     int Size = Cost - ColdSize;