[inliner] Add per-SCC-pass InlineAdvisor printing option

[Northbadge]

Summary

Adds option to print the contents of the Inline Advisor after each SCC Inliner pass

[mtrofin]

overall lgtm, some nits. Also, for the commit message, it's not that the "advisor prints", rather, that we have a way to print at SCC level - if you can rephrase.

Can you also add a test?

llvm/lib/Transforms/IPO/Inliner.cpp

109

nit: EnablePostSCCAdvisorPrinting / enable-scc-inline-advisor-printing

...just to hint to the reader what the relation with the other printing is.

[Northbadge]

Resolve comments and added tests.

[mtrofin]

lgtm, just please move the ml one down into test/Transforms/Inline/ML

llvm/test/Transforms/Inline/enable-inline-advisor-printing-ml.ll

1 ↗

(On Diff #436568)

this should go under the ML subfolder there.

[Northbadge]

Added one more test case.

[Northbadge]

Moved ML test

llvm/include/llvm/Analysis/InlineAdvisor.h

 //===- InlineAdvisor.h - Inlining decision making abstraction -*- C++ ---*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 #ifndef LLVM_ANALYSIS_INLINEADVISOR_H
 #define LLVM_ANALYSIS_INLINEADVISOR_H
 
+#include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/PassManager.h"
 #include <memory>
 
 namespace llvm {
 class BasicBlock;

 class InlineAdvisorAnalysisPrinterPass
     : public PassInfoMixin<InlineAdvisorAnalysisPrinterPass> {
   raw_ostream &OS;
 
 public:
   explicit InlineAdvisorAnalysisPrinterPass(raw_ostream &OS) : OS(OS) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+
+  PreservedAnalyses run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
 };
 
 std::unique_ptr<InlineAdvisor>
 getReleaseModeAdvisor(Module &M, ModuleAnalysisManager &MAM);
 
 std::unique_ptr<InlineAdvisor>
 getDevelopmentModeAdvisor(Module &M, ModuleAnalysisManager &MAM,
                           std::function<bool(CallBase &)> GetDefaultAdvice);

llvm/lib/Analysis/InlineAdvisor.cpp

 InlineAdvisorAnalysisPrinterPass::run(Module &M, ModuleAnalysisManager &MAM) {
   const auto *IA = MAM.getCachedResult<InlineAdvisorAnalysis>(M);
   if (!IA)
     OS << "No Inline Advisor\n";
   else
     IA->getAdvisor()->print(OS);
   return PreservedAnalyses::all();
 }
+
+PreservedAnalyses InlineAdvisorAnalysisPrinterPass::run(
+    LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM, LazyCallGraph &CG,
+    CGSCCUpdateResult &UR) {
+  const auto &MAMProxy =
+      AM.getResult<ModuleAnalysisManagerCGSCCProxy>(InitialC, CG);
+
+  if (InitialC.size() == 0) {
+    OS << "SCC is empty!\n";
+    return PreservedAnalyses::all();
+  }
+  Module &M = *InitialC.begin()->getFunction().getParent();
+  const auto *IA = MAMProxy.getCachedResult<InlineAdvisorAnalysis>(M);
+  if (!IA)
+    OS << "No Inline Advisor\n";
+  else
+    IA->getAdvisor()->print(OS);
+  return PreservedAnalyses::all();
+}

llvm/lib/Transforms/IPO/Inliner.cpp

cl::desc(
         "multiplied by intra-scc-cost-multiplier). This is to prevent tons of "
         "inlining through a child SCC which can cause terrible compile times"));
 
 /// A flag for test, so we can print the content of the advisor when running it
 /// as part of the default (e.g. -O3) pipeline.
 static cl::opt<bool> KeepAdvisorForPrinting("keep-inline-advisor-for-printing",
                                             cl::init(false), cl::Hidden);
 
+/// Allows printing the contents of the advisor after each SCC inliner pass.
+static cl::opt<bool>
+    EnablePostSCCAdvisorPrinting("enable-scc-inline-advisor-printing",
+                                 cl::init(false), cl::Hidden);
+
 extern cl::opt<InlinerFunctionImportStatsOpts> InlinerFunctionImportStats;
 
 static cl::opt<std::string> CGSCCInlineReplayFile(
     "cgscc-inline-replay", cl::init(""), cl::value_desc("filename"),
     cl::desc(
         "Optimization remarks file containing inline remarks to be replayed "
         "by cgscc inlining."),
     cl::Hidden);
ModuleInlinerWrapperPass::ModuleInlinerWrapperPass(InlineParams Params,
                                                    InliningAdvisorMode Mode,
                                                    unsigned MaxDevirtIterations)
     : Params(Params), Mode(Mode), MaxDevirtIterations(MaxDevirtIterations) {
   // Run the inliner first. The theory is that we are walking bottom-up and so
   // the callees have already been fully optimized, and we want to inline them
   // into the callers so that our optimizations can reflect that.
   // For PreLinkThinLTO pass, we disable hot-caller heuristic for sample PGO
   // because it makes profile annotation in the backend inaccurate.
-  if (MandatoryFirst)
+  if (MandatoryFirst) {
     PM.addPass(InlinerPass(/*OnlyMandatory*/ true));
+    if (EnablePostSCCAdvisorPrinting)
+      PM.addPass(InlineAdvisorAnalysisPrinterPass(dbgs()));
+  }
   PM.addPass(InlinerPass());
+  if (EnablePostSCCAdvisorPrinting)
+    PM.addPass(InlineAdvisorAnalysisPrinterPass(dbgs()));
 }
 
 PreservedAnalyses ModuleInlinerWrapperPass::run(Module &M,
                                                 ModuleAnalysisManager &MAM) {
   auto &IAA = MAM.getResult<InlineAdvisorAnalysis>(M);
   if (!IAA.tryCreate(Params, Mode,
                      {CGSCCInlineReplayFile,
                       CGSCCInlineReplayScope,

llvm/test/Transforms/Inline/ML/enable-inline-advisor-printing-ml.ll

+; REQUIRES: llvm_inliner_model_autogenerated
+
+; RUN: opt -enable-ml-inliner=release -passes=scc-oz-module-inliner \
+; RUN:     -keep-inline-advisor-for-printing \
+; RUN:     -enable-scc-inline-advisor-printing -S < %s 2>&1 | FileCheck %s
+
+; RUN: opt -enable-ml-inliner=release -passes=scc-oz-module-inliner \
+; RUN:     -keep-inline-advisor-for-printing -mandatory-inlining-first=0 \
+; RUN:     -enable-scc-inline-advisor-printing -S < %s 2>&1 \
+; RUN:     | FileCheck %s --check-prefix=TWO
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local noundef i32 @_Z3fooi(i32 noundef %y) {
+entry:
+  ret i32 %y
+}
+
+define dso_local noundef i32 @main(i32 noundef %argc, ptr noundef %argv) {
+entry:
+  %call = call noundef i32 @_Z3fooi(i32 noundef %argc)
+  ret i32 %call
+}
+
+; CHECK: [MLInlineAdvisor] Nodes:
+; CHECK-SAME: 2 Edges: 1
+; CHECK: [MLInlineAdvisor] Nodes:
+; CHECK-SAME: 2 Edges: 1
+; CHECK: [MLInlineAdvisor] Nodes:
+; CHECK-SAME: 2 Edges: 1
+; CHECK: [MLInlineAdvisor] Nodes:
+; CHECK-SAME: 2 Edges: 0
+; CHECK-NOT: [MLInlineAdvisor] Nodes:
+
+; TWO: [MLInlineAdvisor] Nodes:
+; TWO-SAME: 2 Edges: 1
+; TWO: [MLInlineAdvisor] Nodes:
+; TWO-SAME: 2 Edges: 0
+; TWO-NOT: [MLInlineAdvisor] Nodes:

llvm/test/Transforms/Inline/enable-inline-advisor-printing.ll

+; RUN: opt -passes=inliner-wrapper -keep-inline-advisor-for-printing \
+; RUN:     -enable-scc-inline-advisor-printing -S < %s 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local noundef i32 @_Z3fooi(i32 noundef %y) {
+entry:
+  ret i32 %y
+}
+
+define dso_local noundef i32 @main(i32 noundef %argc, ptr noundef %argv) {
+entry:
+  %call = call noundef i32 @_Z3fooi(i32 noundef %argc)
+  ret i32 %call
+}
+
+; CHECK-COUNT-4: Unimplemented InlineAdvisor print