[ModuleInliner] Factor out common code in InlineOrder.cpp (NFC)

[kazu]

Summary

This patch factors out common code in InlineOrder.cpp.

Without this patch, the model is to ask classes like SizePriority and
CostPriority to compare a pair of call sites:

bool hasLowerPriority(const CallBase *L, const CallBase *R) const override {

while these priority classes have their own caches of priorities:

DenseMap<const CallBase *, PriorityT> Priorities;

This model results in a lot of duplicate code like hasLowerPriority
and updateAndCheckDecreased.

This patch changes the model so that priority classes just have two
methods to compute a priority for a given call site and to compare two
previously computed priorities (as opposed to call sites).

Facilities like hasLowerPriority and updateAndCheckDecreased move to
PriorityInlineOrder along with the map from call sites to their
priorities. PriorityInlineOrder becomes a template class so that it
can accommodate different priority classes.

[kazu]

Please take look. Thanks!

[taolq]

LGTM.
Thanks for the job.

[kazu]

In D134149#3806022, @taolq wrote:

LGTM.
Thanks for the job.

Thanks Liqiang for the review!

llvm/lib/Analysis/InlineOrder.cpp

llvm::InlineCost getInlineCostWrapper(CallBase &CB,
   auto &CalleeTTI = FAM.getResult<TargetIRAnalysis>(Callee);
   bool RemarksEnabled =
       Callee.getContext().getDiagHandlerPtr()->isMissedOptRemarkEnabled(
           DEBUG_TYPE);
   return getInlineCost(CB, Params, CalleeTTI, GetAssumptionCache, GetTLI,
                        GetBFI, PSI, RemarksEnabled ? &ORE : nullptr);
 }
 
-class InlinePriority {
+class SizePriority {
 public:
-  virtual ~InlinePriority() = default;
-  virtual bool hasLowerPriority(const CallBase *L, const CallBase *R) const = 0;
-  virtual void update(const CallBase *CB) = 0;
-  virtual bool updateAndCheckDecreased(const CallBase *CB) = 0;
-};
-
-class SizePriority : public InlinePriority {
-  using PriorityT = unsigned;
-  DenseMap<const CallBase *, PriorityT> Priorities;
-
-  PriorityT evaluate(const CallBase *CB) {
+  SizePriority() = default;
+  SizePriority(const CallBase *CB, FunctionAnalysisManager &,
+               const InlineParams &) {
     Function *Callee = CB->getCalledFunction();
-    return Callee->getInstructionCount();
+    Size = Callee->getInstructionCount();
   }
 
-  bool isMoreDesirable(const PriorityT &P1, const PriorityT &P2) const {
-    return P1 < P2;
-  }
-
-public:
-  bool hasLowerPriority(const CallBase *L, const CallBase *R) const override {
-    const auto I1 = Priorities.find(L);
-    const auto I2 = Priorities.find(R);
-    assert(I1 != Priorities.end() && I2 != Priorities.end());
-    return isMoreDesirable(I2->second, I1->second);
+  static bool isMoreDesirable(const SizePriority &P1, const SizePriority &P2) {
+    return P1.Size < P2.Size;
   }
 
-  // Update the priority associated with CB.
-  void update(const CallBase *CB) override { Priorities[CB] = evaluate(CB); };
-
-  bool updateAndCheckDecreased(const CallBase *CB) override {
-    auto It = Priorities.find(CB);
-    const auto OldPriority = It->second;
-    It->second = evaluate(CB);
-    const auto NewPriority = It->second;
-    return isMoreDesirable(OldPriority, NewPriority);
-  }
+private:
+  unsigned Size;
 };
 
-class CostPriority : public InlinePriority {
-  using PriorityT = int;
-  DenseMap<const CallBase *, PriorityT> Priorities;
-  std::function<InlineCost(const CallBase *)> getInlineCost;
-
-  PriorityT evaluate(const CallBase *CB) {
-    auto IC = getInlineCost(CB);
-    int Cost = 0;
+class CostPriority {
+public:
+  CostPriority() = default;
+  CostPriority(const CallBase *CB, FunctionAnalysisManager &FAM,
+               const InlineParams &Params) {
+    auto IC = getInlineCostWrapper(const_cast<CallBase &>(*CB), FAM, Params);
     if (IC.isVariable())
       Cost = IC.getCost();
     else
       Cost = IC.isNever() ? INT_MAX : INT_MIN;
-    return Cost;
   }
 
-  bool isMoreDesirable(const PriorityT &P1, const PriorityT &P2) const {
-    return P1 < P2;
+  static bool isMoreDesirable(const CostPriority &P1, const CostPriority &P2) {
+    return P1.Cost < P2.Cost;
   }
 
-public:
-  CostPriority() = delete;
-  CostPriority(std::function<InlineCost(const CallBase *)> getInlineCost)
-      : getInlineCost(getInlineCost){};
+private:
+  int Cost;
+};
+
+template <typename PriorityT>
+class PriorityInlineOrder : public InlineOrder<std::pair<CallBase *, int>> {
+  using T = std::pair<CallBase *, int>;
 
-  bool hasLowerPriority(const CallBase *L, const CallBase *R) const override {
+  bool hasLowerPriority(const CallBase *L, const CallBase *R) const {
     const auto I1 = Priorities.find(L);
     const auto I2 = Priorities.find(R);
     assert(I1 != Priorities.end() && I2 != Priorities.end());
-    return isMoreDesirable(I2->second, I1->second);
+    return PriorityT::isMoreDesirable(I2->second, I1->second);
   }
 
-  // Update the priority associated with CB.
-  void update(const CallBase *CB) override { Priorities[CB] = evaluate(CB); };
-
-  bool updateAndCheckDecreased(const CallBase *CB) override {
+  bool updateAndCheckDecreased(const CallBase *CB) {
     auto It = Priorities.find(CB);
     const auto OldPriority = It->second;
-    It->second = evaluate(CB);
+    It->second = PriorityT(CB, FAM, Params);
     const auto NewPriority = It->second;
-    return isMoreDesirable(OldPriority, NewPriority);
+    return PriorityT::isMoreDesirable(OldPriority, NewPriority);
   }
-};
-
-class PriorityInlineOrder : public InlineOrder<std::pair<CallBase *, int>> {
-  using T = std::pair<CallBase *, int>;
 
   // A call site could become less desirable for inlining because of the size
   // growth from prior inlining into the callee. This method is used to lazily
   // update the desirability of a call site if it's decreasing. It is only
   // called on pop() or front(), not every time the desirability changes. When
   // the desirability of the front call site decreases, an updated one would be
   // pushed right back into the heap. For simplicity, those cases where
   // the desirability of a call site increases are ignored here.
   void adjust() {
-    while (PriorityPtr->updateAndCheckDecreased(Heap.front())) {
+    while (updateAndCheckDecreased(Heap.front())) {
       std::pop_heap(Heap.begin(), Heap.end(), isLess);
       std::push_heap(Heap.begin(), Heap.end(), isLess);
     }
   }
 
 public:
-  PriorityInlineOrder(std::unique_ptr<InlinePriority> PriorityPtr)
-      : PriorityPtr(std::move(PriorityPtr)) {
-    isLess = [this](const CallBase *L, const CallBase *R) {
-      return this->PriorityPtr->hasLowerPriority(L, R);
+  PriorityInlineOrder(FunctionAnalysisManager &FAM, const InlineParams &Params)
+      : FAM(FAM), Params(Params) {
+    isLess = [&](const CallBase *L, const CallBase *R) {
+      return hasLowerPriority(L, R);
     };
   }
 
   size_t size() override { return Heap.size(); }
 
   void push(const T &Elt) override {
     CallBase *CB = Elt.first;
     const int InlineHistoryID = Elt.second;
 
     Heap.push_back(CB);
-    PriorityPtr->update(CB);
+    Priorities[CB] = PriorityT(CB, FAM, Params);
     std::push_heap(Heap.begin(), Heap.end(), isLess);
     InlineHistoryMap[CB] = InlineHistoryID;
   }
 
   T pop() override {
     assert(size() > 0);
     adjust();
 
void erase_if(function_ref<bool(T)> Pred) override {
     llvm::erase_if(Heap, PredWrapper);
     std::make_heap(Heap.begin(), Heap.end(), isLess);
   }
 
 private:
   SmallVector<CallBase *, 16> Heap;
   std::function<bool(const CallBase *L, const CallBase *R)> isLess;
   DenseMap<CallBase *, int> InlineHistoryMap;
-  std::unique_ptr<InlinePriority> PriorityPtr;
+  DenseMap<const CallBase *, PriorityT> Priorities;
+  FunctionAnalysisManager &FAM;
+  const InlineParams &Params;
 };
 
 } // namespace
 
 std::unique_ptr<InlineOrder<std::pair<CallBase *, int>>>
 llvm::getInlineOrder(FunctionAnalysisManager &FAM, const InlineParams &Params) {
   switch (UseInlinePriority) {
   case InlinePriorityMode::Size:
     LLVM_DEBUG(dbgs() << "    Current used priority: Size priority ---- \n");
-    return std::make_unique<PriorityInlineOrder>(
-        std::make_unique<SizePriority>());
+    return std::make_unique<PriorityInlineOrder<SizePriority>>(FAM, Params);
 
   case InlinePriorityMode::Cost:
     LLVM_DEBUG(dbgs() << "    Current used priority: Cost priority ---- \n");
-    return std::make_unique<PriorityInlineOrder>(
-        std::make_unique<CostPriority>([&](const CallBase *CB) -> InlineCost {
-          return getInlineCostWrapper(const_cast<CallBase &>(*CB), FAM, Params);
-        }));
+    return std::make_unique<PriorityInlineOrder<CostPriority>>(FAM, Params);
 
   default:
     llvm_unreachable("Unsupported Inline Priority Mode");
     break;
   }
   return nullptr;
 }