[InlineCost] Add cl::opt to allow full inline cost to be computed for debugging purposes.

[haicheng]

Summary

Currently, the inline cost model will bail once the inline cost exceeds the inline threshold in order to avoid unnecessary compile-time. However, when debugging I found it useful to compute the full cost, so I added this command line option to override the default behavior.

I wanted to see if others thought this might be useful. I also wanted to have someone more familiar with the inline cost model double check to make sure the patch is correct.

Chad

[haicheng]

lib/Analysis/InlineCost.cpp

1070

I think you need to skip this, too.

[mcrosier]

lib/Analysis/InlineCost.cpp

1070

I believe you're correct. Thanks, Haicheng.

[chandlerc]

Why abandon? FWIW, this does seem really useful. I'd also suggest wiring it up so that when optimization remarks are enabled, we do the extra compile time work to give that a detailed answer. (Or maybe set a *really high* threshold below which we give a reasonably exact answer...)

[mcrosier]

In D35850#829883, @chandlerc wrote:

Why abandon? FWIW, this does seem really useful. I'd also suggest wiring it up so that when optimization remarks are enabled, we do the extra compile time work to give that a detailed answer. (Or maybe set a *really high* threshold below which we give a reasonably exact answer...)

I just didn't think there was any interest, but if you think it might be useful, I'll revive the patch.

[mcrosier]

@haicheng has offered to take up this work!

[haicheng]

Take the work from Chad.

[haicheng]

Wire up with Optimization Remarks.

[eraman]

analyzeBlock bails out when inlining is not feasible due to things like recursive call, dynamic alloca etc. Arguably it doesn't make sense to compute the full inline cost even with this new option (and that's the behavior with this patch). In that case, especially with the ORE hookup, there should be some indication that the cost is not fully computed because the callee can not get inlined even if cost < threshold.

[haicheng]

In D35850#837071, @eraman wrote:

analyzeBlock bails out when inlining is not feasible due to things like recursive call, dynamic alloca etc. Arguably it doesn't make sense to compute the full inline cost even with this new option (and that's the behavior with this patch). In that case, especially with the ORE hookup, there should be some indication that the cost is not fully computed because the callee can not get inlined even if cost < threshold.

With option -inline-cost-full enabled, the output of optimization remarks is like below if anything like recursive call, dynamic alloca is found.

foz not inlined into bar because it should never be inlined (cost=never)

Pelease let me know how do you want it to be changed.

Haicheng

[haicheng]

Change the output of optimization remarks to something like below if anything like recursive call, dynamic alloca is found

foz is recursive and allocates too much stack space. Cost is not fully computed
foz not inlined into bar because it should never be inlined (cost=never)

Is this okay? Thank you.

[eraman]

In D35850#843955, @haicheng wrote:

Change the output of optimization remarks to something like below if anything like recursive call, dynamic alloca is found

foz is recursive and allocates too much stack space. Cost is not fully computed
foz not inlined into bar because it should never be inlined (cost=never)

Is this okay? Thank you.

Yes, that looks good. Even just a "Cost is not fully computed" is fine.

[mcrosier]

lib/Analysis/InlineCost.cpp

1226

unilinable -> uninlinable

[haicheng]

Fixed a typo found by Chad. Thank you.

[mcrosier]

LGTM.

lib/Analysis/InlineCost.cpp

HotCallSiteThreshold("hot-callsite-threshold", cl::Hidden, cl::init(3000),
                          cl::desc("Threshold for hot callsites "));
 
 static cl::opt<int> ColdCallSiteRelFreq(
     "cold-callsite-rel-freq", cl::Hidden, cl::init(2), cl::ZeroOrMore,
     cl::desc("Maxmimum block frequency, expressed as a percentage of caller's "
              "entry frequency, for a callsite to be cold in the absence of "
              "profile information."));
 
+static cl::opt<bool> ComputeFullInlineCost(
+    "inline-cost-full", cl::Hidden, cl::init(false),
+    cl::desc("Compute the full inline cost of a call site even when the cost "
+             "exceeds the threshold."));
+
 namespace {
 
 class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
   typedef InstVisitor<CallAnalyzer, bool> Base;
   friend class InstVisitor<CallAnalyzer, bool>;
 
   /// The TargetTransformInfo available for this compilation.
   const TargetTransformInfo &TTI;
bool CallAnalyzer::visitSwitchInst(SwitchInst &SI) {
   // Exit early for a large switch, assuming one case needs at least one
   // instruction.
   // FIXME: This is not true for a bit test, but ignore such case for now to
   // save compile-time.
   int64_t CostLowerBound =
       std::min((int64_t)CostUpperBound,
                (int64_t)SI.getNumCases() * InlineConstants::InstrCost + Cost);
 
   if (CostLowerBound > Threshold) {
     Cost = CostLowerBound;
     return false;
   }
 
   unsigned JumpTableSize = 0;
   unsigned NumCaseCluster =
       TTI.getEstimatedNumberOfCaseClusters(SI, JumpTableSize);
 
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
 
     // If the visit this instruction detected an uninlinable pattern, abort.
     if (IsRecursiveCall || ExposesReturnsTwice || HasDynamicAlloca ||
         HasIndirectBr || HasFrameEscape)
       return false;
 
     // If the caller is a recursive function then we don't want to inline
     // functions which allocate a lot of stack space because it would increase
     // the caller stack usage dramatically.
     if (IsCallerRecursive &&
         AllocatedSize > InlineConstants::TotalAllocaSizeRecursiveCaller)
       return false;
 
     // Check if we've past the maximum possible threshold so we don't spin in
     // huge basic blocks that will never inline.
-    if (Cost > Threshold)
+    if (Cost > Threshold && !ComputeFullInlineCost)
       return false;
   }
 
   return true;
 }
 
 /// \brief Compute the base pointer and cumulative constant offsets for V.
 ///
if (OnlyOneCallAndLocalLinkage)
     Cost -= InlineConstants::LastCallToStaticBonus;
 
   // If this function uses the coldcc calling convention, prefer not to inline
   // it.
   if (F.getCallingConv() == CallingConv::Cold)
     Cost += InlineConstants::ColdccPenalty;
 
   // Check if we're done. This can happen due to bonuses and penalties.
-  if (Cost > Threshold)
+  if (Cost > Threshold && !ComputeFullInlineCost)
     return false;
 
   if (F.empty())
     return true;
 
   Function *Caller = CS.getInstruction()->getParent()->getParent();
   // Check if the caller function is recursive itself.
   for (User *U : Caller->users()) {
typedef SetVector<BasicBlock *, SmallVector<BasicBlock *, 16>,
                     SmallPtrSet<BasicBlock *, 16>>
       BBSetVector;
   BBSetVector BBWorklist;
   BBWorklist.insert(&F.getEntryBlock());
   // Note that we *must not* cache the size, this loop grows the worklist.
   for (unsigned Idx = 0; Idx != BBWorklist.size(); ++Idx) {
     // Bail out the moment we cross the threshold. This means we'll under-count
     // the cost, but only when undercounting doesn't matter.
-    if (Cost > Threshold)
+    if (Cost > Threshold && !ComputeFullInlineCost)
       break;
 
     BasicBlock *BB = BBWorklist[Idx];
     if (BB->empty())
       continue;
 
     // Disallow inlining a blockaddress. A blockaddress only has defined
     // behavior for an indirect branch in the same function, and we do not
InlineCost llvm::getInlineCost(
   // Calls to functions with always-inline attributes should be inlined
   // whenever possible.
   if (CS.hasFnAttr(Attribute::AlwaysInline)) {
     if (isInlineViable(*Callee))
       return llvm::InlineCost::getAlways();
     return llvm::InlineCost::getNever();
   }
 
+  Function *Caller = CS.getCaller();
   // Never inline functions with conflicting attributes (unless callee has
   // always-inline attribute).
-  if (!functionsHaveCompatibleAttributes(CS.getCaller(), Callee, CalleeTTI))
+  if (!functionsHaveCompatibleAttributes(Caller, Callee, CalleeTTI))
     return llvm::InlineCost::getNever();
 
   // Don't inline this call if the caller has the optnone attribute.
-  if (CS.getCaller()->hasFnAttribute(Attribute::OptimizeNone))
+  if (Caller->hasFnAttribute(Attribute::OptimizeNone))
     return llvm::InlineCost::getNever();
 
   // Don't inline functions which can be interposed at link-time.  Don't inline
   // functions marked noinline or call sites marked noinline.
   // Note: inlining non-exact non-interposable functions is fine, since we know
   // we have *a* correct implementation of the source level function.
   if (Callee->isInterposable() || Callee->hasFnAttribute(Attribute::NoInline) ||
       CS.isNoInline())
     return llvm::InlineCost::getNever();
 
   DEBUG(llvm::dbgs() << "      Analyzing call of " << Callee->getName()
-                     << "...\n");
+                     << "... (Caller:" << Caller->getName() << ")\n");
 
   CallAnalyzer CA(CalleeTTI, GetAssumptionCache, GetBFI, PSI, *Callee, CS,
                   Params);
   bool ShouldInline = CA.analyzeCall(CS);
 
   DEBUG(CA.dump());
 
   // Check if there was a reason to force inlining or no inlining.