[Inliner] Make the CallPenalty configurable

[flip1995]

Summary

Tests with multiple benchmarks, like Embench [1], showed that the
CallPenalty magic number has the most influence on inlining decisions
when optimizing for size.

On the other hand, there was no good default value for this parameter.
Some benchmarks profited strongly from a reduced call penalty. On
example is the picojpeg benchmark compiled for RISC-V, which got 6%
smaller with a CallPenalty of 10 instead of 12. Other benchmarks
increased in size, like matmult.

This commit makes the compromise of turning the magic number constant of
CallPenalty into a configurable value. This introduces the flag
--inline-call-penalty. With that flag users can fine tune the inliner
to their needs.

The CallPenalty constant was also used for loops. This commit replaces
the CallPenalty constant with a new LoopPenalty constant that is now
used instead.

This is a slimmed down version of https://reviews.llvm.org/D30899

[1]: https://github.com/embench/embench-iot

[aeubanks]

seems reasonable

[flip1995]

Is there anything for me to do on the CI failures? I can't reproduce them locally and I can't really tell how they could be caused by this revision, since it doesn't change anything about the default behavior.

[xgupta]

You can ignore them.

llvm/include/llvm/Analysis/InlineCost.h

 const int OptMinSizeThreshold = 5;
 
 /// Use when -O3 is specified.
 const int OptAggressiveThreshold = 250;
 
 // Various magic constants used to adjust heuristics.
 const int InstrCost = 5;
 const int IndirectCallThreshold = 100;
-const int CallPenalty = 25;
+const int LoopPenalty = 25;
 const int LastCallToStaticBonus = 15000;
 const int ColdccPenalty = 2000;
 /// Do not inline functions which allocate this many bytes on the stack
 /// when the caller is recursive.
 const unsigned TotalAllocaSizeRecursiveCaller = 1024;
 /// Do not inline dynamic allocas that have been constant propagated to be
 /// static allocas above this amount in bytes.
 const uint64_t MaxSimplifiedDynamicAllocaToInline = 65536;

llvm/lib/Analysis/InlineCost.cpp

cl::desc("Maximum block frequency, expressed as a percentage of caller's "
              "profile information."));
 
 static cl::opt<int> HotCallSiteRelFreq(
     "hot-callsite-rel-freq", cl::Hidden, cl::init(60), cl::ZeroOrMore,
     cl::desc("Minimum block frequency, expressed as a multiple of caller's "
              "entry frequency, for a callsite to be hot in the absence of "
              "profile information."));
 
+static cl::opt<int> CallPenalty(
+    "inline-call-penalty", cl::Hidden, cl::init(25),
+    cl::desc("Call penalty that is applied per callsite when inlining"));
+
 static cl::opt<bool> OptComputeFullInlineCost(
     "inline-cost-full", cl::Hidden, cl::init(false), cl::ZeroOrMore,
     cl::desc("Compute the full inline cost of a call site even when the cost "
              "exceeds the threshold."));
 
 static cl::opt<bool> InlineCallerSupersetNoBuiltin(
     "inline-caller-superset-nobuiltin", cl::Hidden, cl::init(true),
     cl::ZeroOrMore,
void onDisableSROA(AllocaInst *Arg) override {
     SROACostSavingsLost += CostIt->second;
     SROAArgCosts.erase(CostIt);
   }
 
   void onDisableLoadElimination() override {
     addCost(LoadEliminationCost);
     LoadEliminationCost = 0;
   }
-  void onCallPenalty() override { addCost(InlineConstants::CallPenalty); }
+  void onCallPenalty() override { addCost(CallPenalty); }
   void onCallArgumentSetup(const CallBase &Call) override {
     // Pay the price of the argument setup. We account for the average 1
     // instruction per call argument setup here.
     addCost(Call.arg_size() * InlineConstants::InstrCost);
   }
   void onLoadRelativeIntrinsic() override {
     // This is normally lowered to 4 LLVM instructions.
     addCost(3 * InlineConstants::InstrCost);
if (IsIndirectCall && BoostIndirectCalls) {
                                 GetAssumptionCache, GetBFI, PSI, ORE, false);
       if (CA.analyze().isSuccess()) {
         // We were able to inline the indirect call! Subtract the cost from the
         // threshold to get the bonus we want to apply, but don't go below zero.
         Cost -= std::max(0, CA.getThreshold() - CA.getCost());
       }
     } else
       // Otherwise simply add the cost for merely making the call.
-      addCost(InlineConstants::CallPenalty);
+      addCost(CallPenalty);
   }
 
   void onFinalizeSwitch(unsigned JumpTableSize,
                         unsigned NumCaseCluster) override {
     // If suitable for a jump table, consider the cost for the table size and
     // branch to destination.
     // Maximum valid cost increased in this function.
     if (JumpTableSize) {
if (Caller->hasMinSize()) {
       LoopInfo LI(DT);
       int NumLoops = 0;
       for (Loop *L : LI) {
         // Ignore loops that will not be executed
         if (DeadBlocks.count(L->getHeader()))
           continue;
         NumLoops++;
       }
-      addCost(NumLoops * InlineConstants::CallPenalty);
+      addCost(NumLoops * InlineConstants::LoopPenalty);
     }
 
     // We applied the maximum possible vector bonus at the beginning. Now,
     // subtract the excess bonus, if any, from the Threshold before
     // comparing against Cost.
     if (NumVectorInstructions <= NumInstructions / 10)
       Threshold -= VectorBonus;
     else if (NumVectorInstructions <= NumInstructions / 2)
void onDisableSROA(AllocaInst *Arg) override {
     SROACosts.erase(CostIt);
   }
 
   void onDisableLoadElimination() override {
     set(InlineCostFeatureIndex::LoadElimination, 1);
   }
 
   void onCallPenalty() override {
-    increment(InlineCostFeatureIndex::CallPenalty,
-              InlineConstants::CallPenalty);
+    increment(InlineCostFeatureIndex::CallPenalty, CallPenalty);
   }
 
   void onCallArgumentSetup(const CallBase &Call) override {
     increment(InlineCostFeatureIndex::CallArgumentSetup,
               Call.arg_size() * InlineConstants::InstrCost);
   }
 
   void onLoadRelativeIntrinsic() override {
InlineResult finalizeAnalysis() override {
     if (Caller->hasMinSize()) {
       DominatorTree DT(F);
       LoopInfo LI(DT);
       for (Loop *L : LI) {
         // Ignore loops that will not be executed
         if (DeadBlocks.count(L->getHeader()))
           continue;
         increment(InlineCostFeatureIndex::NumLoops,
-                  InlineConstants::CallPenalty);
+                  InlineConstants::LoopPenalty);
       }
     }
     set(InlineCostFeatureIndex::DeadBlocks, DeadBlocks.size());
     set(InlineCostFeatureIndex::SimplifiedInstructions,
         NumInstructionsSimplified);
     set(InlineCostFeatureIndex::ConstantArgs, NumConstantArgs);
     set(InlineCostFeatureIndex::ConstantOffsetPtrArgs,
         NumConstantOffsetPtrArgs);
if (Call.isByValArgument(I)) {
       Cost += 2 * NumStores * InlineConstants::InstrCost;
     } else {
       // For non-byval arguments subtract off one instruction per call
       // argument.
       Cost += InlineConstants::InstrCost;
     }
   }
   // The call instruction also disappears after inlining.
-  Cost += InlineConstants::InstrCost + InlineConstants::CallPenalty;
+  Cost += InlineConstants::InstrCost + CallPenalty;
   return Cost;
 }
 
 InlineCost llvm::getInlineCost(
     CallBase &Call, const InlineParams &Params, TargetTransformInfo &CalleeTTI,
     function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
     function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
     function_ref<BlockFrequencyInfo &(Function &)> GetBFI,

llvm/test/Transforms/Inline/inline-call-penalty-option.ll

+; Check that calls are not inlined if the call penalty is low. The value of the
+; call penalty is provided with the '--inline-call-penalty' option.
+;
+; RUN: opt < %s -inline --inline-call-penalty=0 --inline-threshold=5 -S | FileCheck %s
+; RUN: opt < %s -inline --inline-threshold=5 -S | FileCheck %s -check-prefix=DEFAULT_CALL_PENALTY
+
+define i32 @X9(i32 %x) nounwind {
+  %x2 = add i32 %x, %x
+  %x3 = add i32 %x2, %x
+  %x4 = add i32 %x3, %x
+  %x5 = add i32 %x4, %x
+  %x6 = add i32 %x5, %x
+  %x7 = add i32 %x6, %x
+  %x8 = add i32 %x7, %x
+  %x9 = add i32 %x8, %x
+
+  ret i32 %x9
+}
+
+define i32 @f1(i32 %x) nounwind {
+  %res = call i32 @X9(i32 %x)
+  ret i32 %res
+; CHECK-LABEL: @f1(
+; CHECK: %res = call i32 @X9
+
+; DEFAULT_CALL_PENALTY-LABEL: @f1(
+; DEFAULT_CALL_PENALTY-NOT: call
+}