[llvm][Inline] Add interface to return cost-benefit stuff

[taolq]

Summary

Return cost-benefit stuff which is computed by cost-benefit analysis.

[mtrofin]

llvm/include/llvm/Analysis/InlineCost.h

299

why do you need the 2 of them? (I don't see a user for either... well, ok, the second calls the first, but other than that)

I think it would be good to hook up to where you want to use this. In particular, if the user will always want the InlineCost, too, it wouldn't be ideal if the callsite analysis happened twice (once for InlineCost, once for the cost benefit pair). So one way you could expose the cost/benefit pair is by having it as a field in the InlineCost; at that point, too, you could either just have the 'cost' and 'benefit' as fields of InlineCost, or see if the struct design I mention below makes more sense.

llvm/lib/Analysis/InlineCost.cpp

495

Nit: the problem with std::pair where both elements are of the same type is that it's not clear to the reader which is which, without reading comments - which is added work (also comments go out of sync eventually).

Alternative: define a little struct with named fields, makes it all crystal-clear; additionally, when using an IDE, autocompletion makes it very easily discoverable.

Even better alternative, from maintainability perspective: define the struct, and make the fields const and set them through the ctor. So then a reader understands that the object, once constructed, won't mutate, so it removes a concern from understanding the code (basically, the values could only have come from when it was constructed, so less code to chase around)

[taolq]

• add struct to represent cost-benefit pair
• remove redundant interface to return cost-benefit pair

[mtrofin]

llvm/include/llvm/Analysis/InlineCost.h

63

const, both here and below.

[taolq]

llvm/include/llvm/Analysis/InlineCost.h

63

I have been trying to use const, but it still doesn't go well. It still needs an assignment operation.
In ReplayInlineAdvisor::getAdviceImpl

Optional<InlineCost> InlineRecommended = None;
if (Iter != InlineSitesFromRemarks.end()) {
  InlineRecommended = llvm::InlineCost::getAlways("found in replay");
}

By the way, it is always passed by value, just like the Cost or Threshold.
So I think it is safe to use w/o const, right?

[mtrofin]

llvm/include/llvm/Analysis/InlineCost.h

63

It's not about safety, it's readability and maintainability: avoiding folks later having to chase down fields to figure out where they are set.

A way to address this would be to make CostBenefitPair a class, expose the fields through const accessors, and then you can have the default assignment operator.

[taolq]

• use const accessors to keep readability and maintainability

[mtrofin]

lgtm, one comment

llvm/include/llvm/Analysis/InlineCost.h

64

you can return const APInt &, I think APInt is a bit larger than a pointer

[taolq]

• return const APInt&

llvm/include/llvm/Analysis/InlineCost.h

 /// 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;
 } // namespace InlineConstants
 
+// The cost-benefit pair computed by cost-benefit analysis.
+class CostBenefitPair {
+public:
+  CostBenefitPair(APInt Cost, APInt Benefit) : Cost(Cost), Benefit(Benefit) {}
+  CostBenefitPair(const CostBenefitPair &CBP)
+      : Cost(CBP.getCost()), Benefit(CBP.getBenefit()) {}
+
+  const APInt &getCost() const { return Cost; }
+
+  const APInt &getBenefit() const { return Benefit; }
+
+private:
+  APInt Cost;
+  APInt Benefit;
+};
+
 /// Represents the cost of inlining a function.
 ///
 /// This supports special values for functions which should "always" or
 /// "never" be inlined. Otherwise, the cost represents a unitless amount;
 /// smaller values increase the likelihood of the function being inlined.
 ///
 /// Objects of this type also provide the adjusted threshold for inlining
 /// based on the information available for a particular callsite. They can be
 /// directly tested to determine if inlining should occur given the cost and
 /// threshold for this cost metric.
 class InlineCost {
   enum SentinelValues { AlwaysInlineCost = INT_MIN, NeverInlineCost = INT_MAX };
 
   /// The estimated cost of inlining this callsite.
   int Cost = 0;
 
   /// The adjusted threshold against which this cost was computed.
   int Threshold = 0;
 
   /// Must be set for Always and Never instances.
   const char *Reason = nullptr;
 
+  /// The cost-benefit pair computed by cost-benefit analysis.
+  Optional<CostBenefitPair> CostBenefit = None;
+
   // Trivial constructor, interesting logic in the factory functions below.
-  InlineCost(int Cost, int Threshold, const char *Reason = nullptr)
-      : Cost(Cost), Threshold(Threshold), Reason(Reason) {
+  InlineCost(int Cost, int Threshold, const char *Reason = nullptr,
+             Optional<CostBenefitPair> CostBenefit = None)
+      : Cost(Cost), Threshold(Threshold), Reason(Reason),
+        CostBenefit(CostBenefit) {
     assert((isVariable() || Reason) &&
            "Reason must be provided for Never or Always");
   }
 
 public:
   static InlineCost get(int Cost, int Threshold) {
     assert(Cost > AlwaysInlineCost && "Cost crosses sentinel value");
     assert(Cost < NeverInlineCost && "Cost crosses sentinel value");
     return InlineCost(Cost, Threshold);
   }
-  static InlineCost getAlways(const char *Reason) {
-    return InlineCost(AlwaysInlineCost, 0, Reason);
+  static InlineCost getAlways(const char *Reason,
+                              Optional<CostBenefitPair> CostBenefit = None) {
+    return InlineCost(AlwaysInlineCost, 0, Reason, CostBenefit);
   }
-  static InlineCost getNever(const char *Reason) {
-    return InlineCost(NeverInlineCost, 0, Reason);
+  static InlineCost getNever(const char *Reason,
+                             Optional<CostBenefitPair> CostBenefit = None) {
+    return InlineCost(NeverInlineCost, 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 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;
   }
 
   /// Get the cost delta from the threshold for inlining.

 /// - an integer, representing the cost.
 Optional<int> getInliningCostEstimate(
     CallBase &Call, TargetTransformInfo &CalleeTTI,
     function_ref<AssumptionCache &(Function &)> GetAssumptionCache,
     function_ref<BlockFrequencyInfo &(Function &)> GetBFI = nullptr,
     ProfileSummaryInfo *PSI = nullptr,
     OptimizationRemarkEmitter *ORE = nullptr);
 
 /// Minimal filter to detect invalid constructs for inlining.
 InlineResult isInlineViable(Function &Callee);
 
 // This pass is used to annotate instructions during the inline process for
 // debugging and analysis. The main purpose of the pass is to see and test
 // inliner's decisions when creating new optimizations to InlineCost.
 struct InlineCostAnnotationPrinterPass
     : PassInfoMixin<InlineCostAnnotationPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit InlineCostAnnotationPrinterPass(raw_ostream &OS) : OS(OS) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
 };
 } // namespace llvm
 
 #endif

llvm/lib/Analysis/InlineCost.cpp

class InlineCostCallAnalyzer final : public CallAnalyzer {
 
   // The static size of live but cold basic blocks.  This is "static" in the
   // sense that it's not weighted by profile counts at all.
   int ColdSize = 0;
 
   // Whether inlining is decided by cost-benefit analysis.
   bool DecidedByCostBenefit = false;
 
+  // The cost-benefit pair computed by cost-benefit analysis.
+  Optional<CostBenefitPair> CostBenefit = None;
+
   bool SingleBB = true;
 
   unsigned SROACostSavings = 0;
   unsigned SROACostSavingsLost = 0;
 
   /// The mapping of caller Alloca values to their accumulated cost savings. If
   /// we have to disable SROA for one of the allocas, this tells us how much
   /// cost must be added.
Optional<bool> costBenefitAnalysis() {
 
     // Remove the cost of the cold basic blocks.
     int Size = Cost - ColdSize;
 
     // Allow tiny callees to be inlined regardless of whether they meet the
     // savings threshold.
     Size = Size > InlineSizeAllowance ? Size - InlineSizeAllowance : 1;
 
+    CostBenefit.emplace(APInt(128, Size), CycleSavings);
+
     // Return true if the savings justify the cost of inlining.  Specifically,
     // we evaluate the following inequality:
     //
     //  CycleSavings      PSI->getOrCompHotCountThreshold()
     // -------------- >= -----------------------------------
     //       Size              InlineSavingsMultiplier
     //
     // Note that the left hand side is specific to a call site.  The right hand
Optional<InstructionCostDetail> getCostDetails(const Instruction *I) {
     if (InstructionCostDetailMap.find(I) != InstructionCostDetailMap.end())
       return InstructionCostDetailMap[I];
     return None;
   }
 
   virtual ~InlineCostCallAnalyzer() {}
   int getThreshold() { return Threshold; }
   int getCost() { return Cost; }
+  Optional<CostBenefitPair> getCostBenefitPair() { return CostBenefit; }
   bool wasDecidedByCostBenefit() { return DecidedByCostBenefit; }
 };
 } // namespace
 
 /// Test whether the given value is an Alloca-derived function argument.
 bool CallAnalyzer::isAllocaDerivedArg(Value *V) {
   return SROAArgValues.count(V);
 }
InlineCost llvm::getInlineCost(
 
   LLVM_DEBUG(CA.dump());
 
   // Always make cost benefit based decision explicit.
   // We use always/never here since threshold is not meaningful,
   // as it's not what drives cost-benefit analysis.
   if (CA.wasDecidedByCostBenefit()) {
     if (ShouldInline.isSuccess())
-      return InlineCost::getAlways("benefit over cost");
+      return InlineCost::getAlways("benefit over cost",
+                                   CA.getCostBenefitPair());
     else
-      return InlineCost::getNever("cost over benefit");
+      return InlineCost::getNever("cost over benefit", CA.getCostBenefitPair());
   }
 
   // Check if there was a reason to force inlining or no inlining.
   if (!ShouldInline.isSuccess() && CA.getCost() < CA.getThreshold())
     return InlineCost::getNever(ShouldInline.getFailureReason());
   if (ShouldInline.isSuccess() && CA.getCost() >= CA.getThreshold())
     return InlineCost::getAlways("empty function");