[Analysis] Introduce getStaticBonusApplied (NFC)

[kazu]

Summary

InlineCostCallAnalyzer encourages inlining of the last call to the
static function by subtracting LastCallToStaticBonus from Cost.

This patch introduces getStaticBonusApplied to make available the
amount of LastCallToStaticBonus applied.

The intent is to allow the module inliner to determine whether
inlining a given call site is expected to reduce the caller size with
an expression like:

IC.getCost() + IC.getStaticBonusApplied() < 0

This patch does not add a use of getStaticBonus yet.

[davidxl]

llvm/include/llvm/Analysis/InlineCost.h

155

should this include other bonuses added too? In that case, the interface name should change accordingly.

[mtrofin]

This is NFC, right? Is the use of it too complicated - not sure how I feel about code without use.

llvm/include/llvm/Analysis/InlineCost.h

99

is this ever mutated?

[kazu]

In D134373#3806428, @mtrofin wrote:

This is NFC, right? Is the use of it too complicated - not sure how I feel about code without use.

I've uploaded another patch (https://reviews.llvm.org/D134376) just to show the use site. You'll find:

bool P1ReducesCallerSize = -1000 < P1.Cost && P1.Cost < 0;

I'd like to be able to say:

bool P1ReducesCallerSize = P1.Cost + P1.LastCallToStaticBonusApplied < 0;

llvm/include/llvm/Analysis/InlineCost.h

99

Good point. const is fine here. I'll add const here. I'll submit a follow-up patch to make Cost and Threshold const also.

155

Maybe not. At the moment, I am not planning to expose other bonuses applied.

[kazu]

Add const.

[kazu]

Please take a look. Thanks!

• I've added "NFC" to the title.
• I've added const to the immutable member.
• For use, please see https://reviews.llvm.org/D134376. Look for:

bool P1ReducesCallerSize = -1000 < P1.Cost && P1.Cost < 0;

where I would like so say something like:

bool P1ReducesCallerSize = P1.Cost + IC.getLastCallToStaticBonusApplied() < 0;

[davidxl]

llvm/include/llvm/Analysis/InlineCost.h

155

Consider changing the name to be getStaticBonusApplied () to be more flexible. If in the future, the data needs to be fetched selectively, parameters can be added for that.

[kazu]

Rebased.

Changed the type of LastCallToStaticBonusApplied to "int" from "const
int". I've made this change to be consistent with other fields, which
are also non-const. Note that I've reverted
https://reviews.llvm.org/D134388 to accommodate Yevgeny Rouban's
downstream branch where a field of InlineCost changes.

[kazu]

I've renamed to getLastCallToStaticBonusApplied to
getStaticBonusApplied and made corresponding changes to the underlying
variable name.

[kazu]

Please take a look. Thanks!

Again, for a use case, please see https://reviews.llvm.org/D134376 and look for a hack:

bool P1ReducesCallerSize = -1000 < P1.Cost && P1.Cost < 0;

where I would like so say something like:

bool P1ReducesCallerSize = P1.Cost + IC.getStaticBonusApplied() < 0;

[kazu]

I've updated the patch title and description as well. Please take a look. Thanks!

[davidxl]

lgtm

llvm/include/llvm/Analysis/InlineCost.h

class InlineCost {
   enum SentinelValues { AlwaysInlineCost = INT_MIN, NeverInlineCost = INT_MAX };
 
   /// The estimated cost of inlining this callsite.
   const int Cost = 0;
 
   /// The adjusted threshold against which this cost was computed.
   const int Threshold = 0;
 
+  /// The amount of LastCallToStaticBonus that has been applied.
+  const int LastCallToStaticBonusApplied = 0;
+
   /// Must be set for Always and Never instances.
   const char *const Reason = nullptr;
 
   /// The cost-benefit pair computed by cost-benefit analysis.
   const Optional<CostBenefitPair> CostBenefit = None;
 
   // Trivial constructor, interesting logic in the factory functions below.
-  InlineCost(int Cost, int Threshold, const char *Reason = nullptr,
+  InlineCost(int Cost, int Threshold, int LastCallToStaticBonusApplied,
+             const char *Reason = nullptr,
              Optional<CostBenefitPair> CostBenefit = None)
-      : Cost(Cost), Threshold(Threshold), Reason(Reason),
-        CostBenefit(CostBenefit) {
+      : Cost(Cost), Threshold(Threshold),
+        LastCallToStaticBonusApplied(LastCallToStaticBonusApplied),
+        Reason(Reason), CostBenefit(CostBenefit) {
     assert((isVariable() || Reason) &&
            "Reason must be provided for Never or Always");
   }
 
 public:
-  static InlineCost get(int Cost, int Threshold) {
+  static InlineCost get(int Cost, int Threshold,
+                        int LastCallToStaticBonus = 0) {
     assert(Cost > AlwaysInlineCost && "Cost crosses sentinel value");
     assert(Cost < NeverInlineCost && "Cost crosses sentinel value");
-    return InlineCost(Cost, Threshold);
+    return InlineCost(Cost, Threshold, LastCallToStaticBonus);
   }
   static InlineCost getAlways(const char *Reason,
                               Optional<CostBenefitPair> CostBenefit = None) {
-    return InlineCost(AlwaysInlineCost, 0, Reason, CostBenefit);
+    return InlineCost(AlwaysInlineCost, 0, 0, Reason, CostBenefit);
   }
   static InlineCost getNever(const char *Reason,
                              Optional<CostBenefitPair> CostBenefit = None) {
-    return InlineCost(NeverInlineCost, 0, Reason, CostBenefit);
+    return InlineCost(NeverInlineCost, 0, 0, Reason, CostBenefit);
   }
 
   /// Test whether the inline cost is low enough for inlining.
   explicit operator bool() const { return Cost < Threshold; }
 
   bool isAlways() const { return Cost == AlwaysInlineCost; }
   bool isNever() const { return Cost == NeverInlineCost; }
   bool isVariable() const { return !isAlways() && !isNever(); }
 
   /// Get the inline cost estimate.
   /// It is an error to call this on an "always" or "never" InlineCost.
   int getCost() const {
     assert(isVariable() && "Invalid access of InlineCost");
     return Cost;
   }
 
   /// Get the threshold against which the cost was computed
   int getThreshold() const {
     assert(isVariable() && "Invalid access of InlineCost");
     return Threshold;
   }
 
+  /// Get the amount of LastCallToStaticBonus applied.
+  int getLastCallToStaticBonusApplied() const {
+    assert(isVariable() && "Invalid access of InlineCost");
+    return LastCallToStaticBonusApplied;
+  }
+
   /// Get the cost-benefit pair which was computed by cost-benefit analysis
   Optional<CostBenefitPair> getCostBenefit() const { return CostBenefit; }
 
   /// Get the reason of Always or Never.
   const char *getReason() const {
     assert((Reason || isVariable()) &&
            "InlineCost reason must be set for Always or Never");
     return Reason;

llvm/lib/Analysis/InlineCost.cpp

class InlineCostCallAnalyzer final : public CallAnalyzer {
   // accounting for the given instruction. The map is filled only with the
   // flag PrintInstructionComments on.
   DenseMap<const Instruction *, InstructionCostDetail> InstructionCostDetailMap;
 
   /// Upper bound for the inlining cost. Bonuses are being applied to account
   /// for speculative "expected profit" of the inlining decision.
   int Threshold = 0;
 
+  /// The amount of LastCallToStaticBonus applied.
+  int LastCallToStaticBonusApplied = 0;
+
   /// Attempt to evaluate indirect calls to boost its inline cost.
   const bool BoostIndirectCalls;
 
   /// Ignore the threshold when finalizing analysis.
   const bool IgnoreThreshold;
 
   // True if the cost-benefit-analysis-based inliner is enabled.
   const bool CostBenefitAnalysisEnabled;
Optional<InstructionCostDetail> getCostDetails(const Instruction *I) {
     if (InstructionCostDetailMap.find(I) != InstructionCostDetailMap.end())
       return InstructionCostDetailMap[I];
     return None;
   }
 
   virtual ~InlineCostCallAnalyzer() = default;
   int getThreshold() const { return Threshold; }
   int getCost() const { return Cost; }
+  int getLastCallToStaticBonusApplied() const {
+    return LastCallToStaticBonusApplied;
+  }
   Optional<CostBenefitPair> getCostBenefitPair() { return CostBenefit; }
   bool wasDecidedByCostBenefit() const { return DecidedByCostBenefit; }
   bool wasDecidedByCostThreshold() const { return DecidedByCostThreshold; }
 };
 
 // Return true if CB is the sole call to local function Callee.
 static bool isSoleCallToLocalFunction(const CallBase &CB,
                                       const Function &Callee) {
void InlineCostCallAnalyzer::updateThreshold(CallBase &Call, Function &Callee) {
   Threshold *= TTI.getInliningThresholdMultiplier();
 
   SingleBBBonus = Threshold * SingleBBBonusPercent / 100;
   VectorBonus = Threshold * VectorBonusPercent / 100;
 
   // If there is only one call of the function, and it has internal linkage,
   // the cost of inlining it drops dramatically. It may seem odd to update
   // Cost in updateThreshold, but the bonus depends on the logic in this method.
-  if (isSoleCallToLocalFunction(Call, F))
+  if (isSoleCallToLocalFunction(Call, F)) {
     Cost -= LastCallToStaticBonus;
+    LastCallToStaticBonusApplied = LastCallToStaticBonus;
+  }
 }
 
 bool CallAnalyzer::visitCmpInst(CmpInst &I) {
   Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
   // First try to handle simplified comparisons.
   if (simplifyInstruction(I))
     return true;
 
if (CA.wasDecidedByCostBenefit()) {
     if (ShouldInline.isSuccess())
       return InlineCost::getAlways("benefit over cost",
                                    CA.getCostBenefitPair());
     else
       return InlineCost::getNever("cost over benefit", CA.getCostBenefitPair());
   }
 
   if (CA.wasDecidedByCostThreshold())
-    return InlineCost::get(CA.getCost(), CA.getThreshold());
+    return InlineCost::get(CA.getCost(), CA.getThreshold(),
+                           CA.getLastCallToStaticBonusApplied());
 
   // No details on how the decision was made, simply return always or never.
   return ShouldInline.isSuccess()
              ? InlineCost::getAlways("empty function")
              : InlineCost::getNever(ShouldInline.getFailureReason());
 }
 
 InlineResult llvm::isInlineViable(Function &F) {