[NFC][InlineAdvisor] Inform advisor when the module is invalidated

[mtrofin]

Summary

This avoids unnecessary re-calculation of module-wide features in the
MLInlineAdvisor. In cases where function passes don't invalidate
functions (and, thus, don't invalidate the module), but we re-process a
CGSCC, we currently refreshed module features unnecessarily. The
overhead of fetching cached results (albeit they weren't themselves
invalidated) was noticeable in certain modules' compilations.

We don't want to just invalidate the advisor object, though, via the
analysis manager, because we'd then need to re-create expensive state
(like the model evaluator in the ML 'development' mode).

[phosek]

LGTM

[aeubanks]

It looks like the expensive part is recalculating FunctionPropertiesAnalysis in getLocalCalls(). Since you're only using DirectCallsToDefinedFunctions, could you implement that yourself rather than relying on the potentially expensive FunctionPropertiesAnalysis? For example, it looks like it needs to construct all the loops in the function which could be expensive.
Counting by hand the number of direct calls should be quick and unnoticeable in terms of compile time.

[mtrofin]

In D113644#3124903, @aeubanks wrote:

It looks like the expensive part is recalculating FunctionPropertiesAnalysis in getLocalCalls(). Since you're only using DirectCallsToDefinedFunctions, could you implement that yourself rather than relying on the potentially expensive FunctionPropertiesAnalysis? For example, it looks like it needs to construct all the loops in the function which could be expensive.
Counting by hand the number of direct calls should be quick and unnoticeable in terms of compile time.

You mean avoid using the analysis infra altogether there? I could, but:

• I'd still need to compute stuff unnecessarily in this scenario
• we may later want to rely on some other analysis results, so we'd be back to this place.

[aeubanks]

are you actually seeing compile time improvements with this patch?

if nothing has been invalidated, then FunctionPropertiesAnalysis is still cached, and the recalculation would be negligible since we're just iterating through each function in the module and getting a cached int for each one and summing them together, which is basically free

[mtrofin]

In D113644#3125023, @aeubanks wrote:

are you actually seeing compile time improvements with this patch?

yes. significant

if nothing has been invalidated, then FunctionPropertiesAnalysis is still cached, and the recalculation would be negligible since we're just iterating through each function in the module and getting a cached int for each one and summing them together, which is basically free

that cache retrieval is what's not free, when the scale is large.

[aeubanks]

you could create a new module analysis which computes NodeCount/EdgeCount via FunctionPropertiesAnalysis. that's the most NPM-y way of doing this. then you'd MAM.getResult<MyModulePropertiesAnalysis>(M) which would only recalculate if it's been invalidated

but if this is to unblock something you can land this first

[mtrofin]

In D113644#3125070, @aeubanks wrote:

you could create a new module analysis which computes NodeCount/EdgeCount via FunctionPropertiesAnalysis. that's the most NPM-y way of doing this. then you'd MAM.getResult<MyModulePropertiesAnalysis>(M) which would only recalculate if it's been invalidated

but if this is to unblock something you can land this first

ack - thanks; yes, leme unblock Fuchsia with this, then I'll try the cleaner method.

llvm/include/llvm/Analysis/InlineAdvisor.h

public:
   /// between Inliner pass runs (for the same module).
   virtual void onPassEntry() {}
 
   /// This must be called when the Inliner pass is exited, as function passes
   /// may be run subsequently. This allows an implementation of InlineAdvisor
   /// to prepare for a partial update.
   virtual void onPassExit() {}
 
+  /// Called when the module is invalidated. We let the advisor implementation
+  /// decide what to refresh - in the case of the development mode
+  /// implementation, for example, we wouldn't want to delete the whole object
+  /// and need to re-load the model evaluator.
+  virtual void onModuleInvalidated() {}
+
 protected:
   InlineAdvisor(Module &M, FunctionAnalysisManager &FAM);
   virtual std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) = 0;
   virtual std::unique_ptr<InlineAdvice> getMandatoryAdvice(CallBase &CB,
                                                            bool Advice);
 
   Module &M;
   FunctionAnalysisManager &FAM;

 class InlineAdvisorAnalysis : public AnalysisInfoMixin<InlineAdvisorAnalysis> {
 public:
   static AnalysisKey Key;
   InlineAdvisorAnalysis() = default;
   struct Result {
     Result(Module &M, ModuleAnalysisManager &MAM) : M(M), MAM(MAM) {}
     bool invalidate(Module &, const PreservedAnalyses &PA,
                     ModuleAnalysisManager::Invalidator &) {
+      if (Advisor && !PA.areAllPreserved())
+        Advisor->onModuleInvalidated();
       // Check whether the analysis has been explicitly invalidated. Otherwise,
       // it's stateless and remains preserved.
       auto PAC = PA.getChecker<InlineAdvisorAnalysis>();
       return !PAC.preservedWhenStateless();
     }
     bool tryCreate(InlineParams Params, InliningAdvisorMode Mode,
                    const ReplayInlinerSettings &ReplaySettings);
     InlineAdvisor *getAdvisor() const { return Advisor.get(); }

llvm/include/llvm/Analysis/MLInlineAdvisor.h

public:
 
   int64_t getIRSize(const Function &F) const { return F.getInstructionCount(); }
   void onSuccessfulInlining(const MLInlineAdvice &Advice,
                             bool CalleeWasDeleted);
 
   bool isForcedToStop() const { return ForceStop; }
   int64_t getLocalCalls(Function &F);
   const MLModelRunner &getModelRunner() const { return *ModelRunner.get(); }
+  void onModuleInvalidated() override { Invalid = true; }
 
 protected:
   std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) override;
 
   std::unique_ptr<InlineAdvice> getMandatoryAdvice(CallBase &CB,
                                                    bool Advice) override;
 
   virtual std::unique_ptr<MLInlineAdvice> getMandatoryAdviceImpl(CallBase &CB);
 
   virtual std::unique_ptr<MLInlineAdvice>
   getAdviceFromModel(CallBase &CB, OptimizationRemarkEmitter &ORE);
 
   std::unique_ptr<MLModelRunner> ModelRunner;
 
 private:
   int64_t getModuleIRSize() const;
 
+  bool Invalid = true;
   std::unique_ptr<CallGraph> CG;
 
   int64_t NodeCount = 0;
   int64_t EdgeCount = 0;
   std::map<const Function *, unsigned> FunctionLevels;
   const int32_t InitialIRSize = 0;
   int32_t CurrentIRSize = 0;
 

llvm/lib/Analysis/MLInlineAdvisor.cpp

for (auto *CGNode : CGNodes) {
         FunctionLevels[F] = Level;
     }
   }
 }
 
 void MLInlineAdvisor::onPassEntry() {
   // Function passes executed between InlinerPass runs may have changed the
   // module-wide features.
+  if (!Invalid)
+    return;
   NodeCount = 0;
   EdgeCount = 0;
   for (auto &F : M)
     if (!F.isDeclaration()) {
       ++NodeCount;
       EdgeCount += getLocalCalls(F);
     }
+  Invalid = false;
 }
 
 int64_t MLInlineAdvisor::getLocalCalls(Function &F) {
   return FAM.getResult<FunctionPropertiesAnalysis>(F)
       .DirectCallsToDefinedFunctions;
 }
 
 // Update the internal state of the advisor, and force invalidate feature