Slightly increase LastCallToStaticBonus for cold callsites

[kongyi]

Summary

r309441 changed LastCallToStaticBonus inling bonus to 0 for cold callsites, so that the caller has better chance of getting inlined. This makes sense for large callsites but for small callsites not inlining can actually make caller larger.

Slightly increased the bonus from 0 to 50. This resulted in LLVM test-suite mean text size reduced by 0.02%, with no significant performance change observed.

[kongyi]

Ping...

[eraman]

The only case where not inlining results in a bigger caller size is when the cost of inlining a callsite is negative. But such callsites always get inlined as the threshold is always positive. Why do you require an additional bonus to get those callsites inlined?

[fedor.sergeev]

Btw, please, take a look at this review: https://reviews.llvm.org/D60740
I have not found time to integrate it yet, but it slightly changes the approach on handling this bonus
(main idea is to apply it to threshold, like majority of other bonues, instead of applying it to cost).

It might change your approach here...

llvm/lib/Analysis/InlineCost.cpp

void CallAnalyzer::updateThreshold(CallBase &Call, Function &Callee) {
   // guaranteed to reduce code size.
   //
   // These bonus percentages may be set to 0 based on properties of the caller
   // and the callsite.
   int SingleBBBonusPercent = 50;
   int VectorBonusPercent = 150;
   int LastCallToStaticBonus = InlineConstants::LastCallToStaticBonus;
 
-  // Lambda to set all the above bonus and bonus percentages to 0.
-  auto DisallowAllBonuses = [&]() {
+  // Lambda to significantly reduce all the above bonus and bonus percentages.
+  auto ReduceAllBonuses = [&]() {
     SingleBBBonusPercent = 0;
     VectorBonusPercent = 0;
-    LastCallToStaticBonus = 0;
+    LastCallToStaticBonus = 50;
   };
 
   // Use the OptMinSizeThreshold or OptSizeThreshold knob if they are available
   // and reduce the threshold if the caller has the necessary attribute.
   if (Caller->hasMinSize()) {
     Threshold = MinIfValid(Threshold, Params.OptMinSizeThreshold);
     // For minsize, we want to disable the single BB bonus and the vector
     // bonuses, but not the last-call-to-static bonus. Inlining the last call to
if (!Caller->hasOptSize() && HotCallSiteThreshold) {
       LLVM_DEBUG(dbgs() << "Hot callsite.\n");
       // FIXME: This should update the threshold only if it exceeds the
       // current threshold, but AutoFDO + ThinLTO currently relies on this
       // behavior to prevent inlining of hot callsites during ThinLTO
       // compile phase.
       Threshold = HotCallSiteThreshold.getValue();
     } else if (isColdCallSite(Call, CallerBFI)) {
       LLVM_DEBUG(dbgs() << "Cold callsite.\n");
-      // Do not apply bonuses for a cold callsite including the
+      // Significantly reduce bonuses for a cold callsite including the
       // LastCallToStatic bonus. While this bonus might result in code size
       // reduction, it can cause the size of a non-cold caller to increase
       // preventing it from being inlined.
-      DisallowAllBonuses();
+      ReduceAllBonuses();
       Threshold = MinIfValid(Threshold, Params.ColdCallSiteThreshold);
     } else if (PSI) {
       // Use callee's global profile information only if we have no way of
       // determining this via callsite information.
       if (PSI->isFunctionEntryHot(&Callee)) {
         LLVM_DEBUG(dbgs() << "Hot callee.\n");
         // If callsite hotness can not be determined, we may still know
         // that the callee is hot and treat it as a weaker hint for threshold
         // increase.
         Threshold = MaxIfValid(Threshold, Params.HintThreshold);
       } else if (PSI->isFunctionEntryCold(&Callee)) {
         LLVM_DEBUG(dbgs() << "Cold callee.\n");
-        // Do not apply bonuses for a cold callee including the
+        // Significantly reduce bonuses for a cold callee including the
         // LastCallToStatic bonus. While this bonus might result in code size
         // reduction, it can cause the size of a non-cold caller to increase
         // preventing it from being inlined.
-        DisallowAllBonuses();
+        ReduceAllBonuses();
         Threshold = MinIfValid(Threshold, Params.ColdThreshold);
       }
     }
   }
 
   // Finally, take the target-specific inlining threshold multiplier into
   // account.
   Threshold *= TTI.getInliningThresholdMultiplier();

llvm/test/Transforms/Inline/last-call-no-bonus.ll

 ; This code is virtually identical to last-call-bonus.ll, but the callsites
 ; to the internal functions are cold, thereby preventing the last call to
 ; static bonus from being applied.
 
-; RUN: opt < %s -passes='function(require<opt-remark-emit>,unroll),require<profile-summary>,cgscc(inline)' -unroll-threshold=15000 -inline-threshold=250 -S | FileCheck %s
+; RUN: opt < %s -passes='function(require<opt-remark-emit>,unroll),require<profile-summary>,cgscc(inline)' -unroll-threshold=15000 -inline-threshold=0 -S | FileCheck %s
 
 ; CHECK-LABEL: define internal i32 @baz
 define internal i32 @baz() {
 entry:
   br label %bb1
 
 bb1:
   %ind = phi i32 [ 0, %entry ], [ %inc, %bb1 ]
for.exit:
   br i1 %b, label %bb2, label %ret, !prof !0
 bb2:
 ; CHECK: call i32 @baz
   call i32 @baz()
   br label %ret
 ret:
   ret i32 0
 }
+
+define internal i32 @bac() {
+  call void @extern()
+  ret i32 0
+}
+
 ; CHECK-LABEL: define i32 @foo
 define i32 @foo(i1 %b) {
 entry:
   br i1 %b, label %bb1, label %ret, !prof !0
 bb1:
 ; CHECK: call i32 @bar
   call i32 @bar(i1 %b)
+; CHECK-NOT: call i32 @bac
+  call i32 @bac()
   br label %ret
 ret:
   ret i32 0
 }
 
 declare void @extern()
 
 !0 = !{!"branch_weights", i32 1, i32 2500}