[New PM][PassInstrumentation] Adding PassInstrumentation to the AnalysisManager runs

[fedor.sergeev]

Summary

As a prerequisite to pass-times implementation which needs to time both passes
and analyses, adding instrumentation points to the Analysis Manager.
The are two functional differences between Pass and Analysis instrumentation:

• the latter does not increment pass execution counter
• it does not provide ability to skip execution of the corresponding analysis

[fedor.sergeev]

rebased

[fedor.sergeev]

ehm... forgot to commit before the update

[fedor.sergeev]

no major changes, just rebased

[fedor.sergeev]

rebased

[fedor.sergeev]

adding unittest changes

[fedor.sergeev]

rebased

[fedor.sergeev]

adding const to Analysis argument of callbacks.

[fedor.sergeev]

rebased

[philip.pfaffe]

This looks entirely straightforward.

test/Other/new-pm-thinlto-defaults.ll

69

Why does this change?

[fedor.sergeev]

test/Other/new-pm-thinlto-defaults.ll

69

Since this analysis is now run for analyses as well, order of executions somewhat changes (naturally, those analyses that hit cache are not run, including passinstrumenation one). Full debugging output made perfect sense to me, though it really took some time to figure out a proper set of checks that works for all RUNs, and now I honestly do not remember exact sequence.

[fedor.sergeev]

rebased

[fedor.sergeev]

rebased

[fedor.sergeev]

rebased

include/llvm/IR/PassInstrumentation.h

 };
 
 /// This class provides implementation for pass instrumentation interface.
 /// It manages callbacks registration, as well as passes control to the
 /// registered callbacks when Pass Managers call a specific instrumentation
 /// point.
 class PassInstrumentation {
 public:
-  // Before/After Pass callbacks accept IRUnits, so they need to take them
+  // Before/After callbacks accept IRUnits, so they need to take them
   // as pointers, wrapped with llvm::Any
   using BeforePassFunc = bool(PassInstanceID, Any, PassExecutionCounter);
   using AfterPassFunc = void(PassInstanceID, Any, PassExecutionCounter);
   using BeforeAnalysisFunc = void(PassInstanceID, Any, PassExecutionCounter);
   using AfterAnalysisFunc = void(PassInstanceID, Any, PassExecutionCounter);
 
 public:
   PassInstrumentation() {}
 
   /// Copying PassInstrumentation is not intended.
   PassInstrumentation(const PassInstrumentation &) = delete;
   void operator=(const PassInstrumentation &) = delete;
 
   /// BeforePass instrumentation point - takes \p PassID identifier for the
   /// pass instance to be executed and constant reference to IR it operates on.
   /// \Returns true if pass is allowed to be executed.
   template <typename IRUnitT>
   bool runBeforePass(PassInstanceID PassID, const IRUnitT &);
 
   /// AfterPass instrumentation point - takes \p PassID identifier for the
   /// pass instance to be executed and constant reference to IR it operates on.
   template <typename IRUnitT>
   void runAfterPass(PassInstanceID PassID, const IRUnitT &) const;
 
+  template <typename IRUnitT>
+  void runBeforeAnalysis(PassInstanceID PassID, const IRUnitT &) const;
+
+  template <typename IRUnitT>
+  void runAfterAnalysis(PassInstanceID PassID, const IRUnitT &) const;
+
   void startPipeline() const;
   void endPipeline() const;
 
   void registerBeforePassCallback(const std::function<BeforePassFunc> &C) {
     BeforePassCallbacks.push_back(C);
   }
 
   void registerAfterPassCallback(const std::function<AfterPassFunc> &C) {
     AfterPassCallbacks.push_back(C);
   }
 
+  void
+  registerBeforeAnalysisCallback(const std::function<BeforeAnalysisFunc> &C) {
+    BeforeAnalysisCallbacks.push_back(C);
+  }
+
+  void
+  registerAfterAnalysisCallback(const std::function<AfterAnalysisFunc> &C) {
+    AfterAnalysisCallbacks.push_back(C);
+  }
+
   void registerStartPipelineCallback(const std::function<void()> &C) {
     StartPipelineCallbacks.push_back(C);
   }
   void registerEndPipelineCallback(const std::function<void()> &C) {
     EndPipelineCallbacks.push_back(C);
   }
 
   bool empty() const;
 
 private:
   PassExecutionCounter PC;
 
   // instrumentation callbacks
 
   SmallVector<std::function<BeforePassFunc>, 4> BeforePassCallbacks;
   SmallVector<std::function<AfterPassFunc>, 4> AfterPassCallbacks;
+  SmallVector<std::function<BeforeAnalysisFunc>, 4> BeforeAnalysisCallbacks;
+  SmallVector<std::function<AfterAnalysisFunc>, 4> AfterAnalysisCallbacks;
   SmallVector<std::function<void()>, 2> StartPipelineCallbacks;
   SmallVector<std::function<void()>, 2> EndPipelineCallbacks;
 };
 
 } // namespace llvm
 
 #endif

include/llvm/IR/PassManager.h

ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR,
 
     // If we don't have a cached result for this function, look up the pass and
     // run it to produce a result, which we then add to the cache.
     if (Inserted) {
       auto &P = this->lookUpPass(ID);
       if (DebugLogging)
         dbgs() << "Running analysis: " << P.name() << " on " << IR.getName()
                << "\n";
+
+      PassInstrumentation* PI = nullptr;
+      if (ID != PassInstrumentationProxy::ID()) {
+        PI = getPassInstrumentation(IR, std::tuple<ExtraArgTs...>(ExtraArgs...));
+        if (PI) PI->runBeforeAnalysis(&P, IR);
+      }
+
       AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
       ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));
 
+      if (PI)
+        PI->runAfterAnalysis(&P, IR);
+
       // P.run may have inserted elements into AnalysisResults and invalidated
       // RI.
       RI = AnalysisResults.find({ID, &IR});
       assert(RI != AnalysisResults.end() && "we just inserted it!");
 
       RI->second = std::prev(ResultList.end());
     }
 

lib/IR/PassInstrumentation.cpp

 
 template <typename IRUnitT>
 void PassInstrumentation::runAfterPass(PassInstanceID PassID,
                                        const IRUnitT &IR) const {
   for (auto &C : AfterPassCallbacks)
     C(PassID, llvm::Any(&IR), PC);
 }
 
+template <typename IRUnitT>
+void PassInstrumentation::runBeforeAnalysis(PassInstanceID PassID,
+                                                const IRUnitT &IR) const {
+  for (auto &C : BeforeAnalysisCallbacks)
+    C(PassID, llvm::Any(&IR), PC);
+}
+
+template <typename IRUnitT>
+void PassInstrumentation::runAfterAnalysis(PassInstanceID PassID,
+                                               const IRUnitT &IR) const {
+  for (auto &C : AfterAnalysisCallbacks)
+    C(PassID, llvm::Any(&IR), PC);
+}
+
 void PassInstrumentation::startPipeline() const {
   for (auto &C : StartPipelineCallbacks)
     C();
 }
 
 void PassInstrumentation::endPipeline() const {
   for (auto &C : EndPipelineCallbacks)
     C();
 }
 
 bool PassInstrumentation::empty() const {
   return BeforePassCallbacks.empty() && AfterPassCallbacks.empty() &&
-         StartPipelineCallbacks.empty() && EndPipelineCallbacks.empty();
+    BeforeAnalysisCallbacks.empty() && AfterAnalysisCallbacks.empty() &&
 }
 
 template bool PassInstrumentation::runBeforePass(PassInstanceID PassID,
                                                  const Module &IR);
 template bool PassInstrumentation::runBeforePass(PassInstanceID PassID,
                                                  const Function &IR);
 template bool PassInstrumentation::runBeforePass(PassInstanceID PassID,
                                                  const Loop &IR);
 template bool
 PassInstrumentation::runBeforePass(PassInstanceID PassID,
                                    const LazyCallGraph::SCC &IR);
 template void PassInstrumentation::runAfterPass(PassInstanceID PassID,
                                                 const Module &IR) const;
 template void PassInstrumentation::runAfterPass(PassInstanceID PassID,
                                                 const Function &IR) const;
 template void PassInstrumentation::runAfterPass(PassInstanceID PassID,
                                                 const Loop &IR) const;
 template void
 PassInstrumentation::runAfterPass(PassInstanceID PassID,
                                   const LazyCallGraph::SCC &IR) const;
+template void PassInstrumentation::runBeforeAnalysis(PassInstanceID PassID,
+                                                         const Module &IR) const;
+template void PassInstrumentation::runBeforeAnalysis(PassInstanceID PassID,
+                                                         const Function &IR) const;
+template void PassInstrumentation::runBeforeAnalysis(PassInstanceID PassID,
+                                                         const Loop &IR) const;
+template void
+PassInstrumentation::runBeforeAnalysis(PassInstanceID PassID,
+                                           const LazyCallGraph::SCC &IR) const;
+template void PassInstrumentation::runAfterAnalysis(PassInstanceID PassID,
+                                                        const Module &IR) const;
+template void PassInstrumentation::runAfterAnalysis(PassInstanceID PassID,
+                                                        const Function &IR) const;
+template void PassInstrumentation::runAfterAnalysis(PassInstanceID PassID,
+                                                        const Loop &IR) const;
+template void
+PassInstrumentation::runAfterAnalysis(PassInstanceID PassID,
+                                          const LazyCallGraph::SCC &IR) const;
 
 AnalysisKey PassInstrumentationProxy::Key;
 
 } // namespace llvm

test/Other/new-pm-lto-defaults.ll

 ; CHECK-O2-DAG: Running analysis: AssumptionAnalysis on foo
 ; CHECK-O2-DAG: Running analysis: DominatorTreeAnalysis on foo
 ; CHECK-O2-NEXT: Running pass: CalledValuePropagationPass
 ; CHECK-O-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor<{{.*}}PostOrderFunctionAttrsPass>
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}SCC
 ; CHECK-O1-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Function
 ; CHECK-O-NEXT: Running analysis: LazyCallGraphAnalysis
 ; CHECK-O-NEXT: Running analysis: FunctionAnalysisManagerCGSCCProxy
+; CHECK-O-NEXT: Running analysis: PassInstrumentationProxy
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy<{{.*}}LazyCallGraph{{.*}}>
 ; CHECK-O-NEXT: Running analysis: AAManager
+; CHECK-O1-NEXT: Running analysis: PassInstrumentationProxy
 ; CHECK-O1-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: ReversePostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: CallGraphAnalysis
 ; CHECK-O-NEXT: Running pass: GlobalSplitPass
 ; CHECK-O-NEXT: Running pass: WholeProgramDevirtPass
 ; CHECK-O1-NEXT: Running pass: LowerTypeTestsPass
 ; CHECK-O2-NEXT: Running pass: GlobalOptPass
 ; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PromotePass>

test/Other/new-pm-thinlto-defaults.ll

 ; CHECK-O-NEXT: Running pass: ForceFunctionAttrsPass
 ; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass
 ; CHECK-DIS-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}AddDiscriminatorsPass{{.*}}>
 ; CHECK-DIS-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-POSTLINK-O-NEXT: Running pass: PGOIndirectCallPromotion
 ; CHECK-POSTLINK-O-NEXT: Running analysis: ProfileSummaryAnalysis
 ; CHECK-POSTLINK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-POSTLINK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis
+; CHECK-POSTLINK-O-NEXT: Running analysis: PassInstrumentationProxy
 ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module{{.*}}>
 ; CHECK-O-NEXT: Starting llvm::Module pass manager run.
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-PRELINK-O-NODIS-NEXT: Running analysis: InnerAnalysisManagerProxy
-; CHECK-O-NEXT: Running analysis: PassInstrumentationProxy
+; CHECK-PRELINK-O-NEXT: Running analysis: PassInstrumentationProxy
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-O-NEXT: Running analysis: AssumptionAnalysis
 ; CHECK-O-NEXT: Running pass: SROA
 ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis
 ; CHECK-O-NEXT: Running pass: EarlyCSEPass
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis

unittests/IR/PassBuilderCallbacksTest.cpp

 struct MockPassInstrumentationCallbacks {
   MockPassInstrumentationCallbacks() {
     ON_CALL(*this, runBeforePass(_, _, _)).WillByDefault(Return(true));
     // Generic EXPECT_CALLs are needed to match instrumentation on unimportant
     // parts of a pipeline that we do not care about (e.g. various passes added
     // by default by PassBuilder - Verifier pass etc).
     EXPECT_CALL(*this, runBeforePass(_, _, Ge(0))).Times(AnyNumber());
     EXPECT_CALL(*this, runAfterPass(_, _, Ge(1))).Times(AnyNumber());
+    EXPECT_CALL(*this, runBeforeAnalysis(_, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*this, runAfterAnalysis(_, _, _)).Times(AnyNumber());
   }
   MOCK_METHOD3(runBeforePass,
-               bool(PassInstanceID PassID, llvm::Any, PassExecutionCounter));
+               bool(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
   MOCK_METHOD3(runAfterPass,
-               void(PassInstanceID PassID, llvm::Any, PassExecutionCounter));
+               void(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD3(runBeforeAnalysis,
+               void(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD3(runAfterAnalysis,
+               void(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD0(startPipeline, void());
+  MOCK_METHOD0(endPipeline, void());
 };
 
 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
   SMDiagnostic Err;
   return parseAssemblyString(IR, Err, C);
 }
 
 /// Helper for HasName matcher that returns getName both for IRUnit and
PassBuilderCallbacksTest()
     PB.registerPassInstrumentation([this](PassInstrumentation &_PI) {
       using namespace std::placeholders;
       _PI.registerBeforePassCallback(
           std::bind(&MockPassInstrumentationCallbacks::runBeforePass,
                     &PassInstrumentationCallbacks, _1, _2, _3));
       _PI.registerAfterPassCallback(
           std::bind(&MockPassInstrumentationCallbacks::runAfterPass,
                     &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerBeforeAnalysisCallback(
+          std::bind(&MockPassInstrumentationCallbacks::runBeforeAnalysis,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerAfterAnalysisCallback(
+          std::bind(&MockPassInstrumentationCallbacks::runAfterAnalysis,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerStartPassManagerCallback(
+          std::bind(&MockPassInstrumentationCallbacks::startPassManager,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerFinishPassManagerCallback(
+          std::bind(&MockPassInstrumentationCallbacks::finishPassManager,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerStartPipelineCallback(
+          std::bind(&MockPassInstrumentationCallbacks::startPipeline,
+                    &PassInstrumentationCallbacks));
+      _PI.registerEndPipelineCallback(
+          std::bind(&MockPassInstrumentationCallbacks::endPipeline,
+                    &PassInstrumentationCallbacks));
+      _PI.registerStartIterationCallback(
+          std::bind(&MockPassInstrumentationCallbacks::startIteration,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
     });
     /// Register builtin analyses and cross-register the analysis proxies
     PB.registerModuleAnalyses(AM);
     PB.registerCGSCCAnalyses(CGAM);
     PB.registerFunctionAnalyses(FAM);
     PB.registerLoopAnalyses(LAM);
     PB.crossRegisterProxies(LAM, FAM, CGAM, AM);
   }
TEST_F(ModuleCallbacksTest, InstrumentedPasses) {
   EXPECT_CALL(PassHandle, run(HasName("<string>"), _))
       .WillOnce(Invoke(getAnalysisResult));
 
   {
     testing::InSequence InstrumentationExpectationsSequenced;
     EXPECT_CALL(PassInstrumentationCallbacks,
                 runBeforePass(_, HasName("<string>"), Eq(1)));
     EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(_, HasName("<string>"), Eq(1)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(_, HasName("<string>"), Eq(1)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
                 runAfterPass(_, HasName("<string>"), Eq(1)));
   }
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;
 
   PM.run(*M, AM);
TEST_F(FunctionCallbacksTest, InstrumentedPasses) {
   EXPECT_CALL(PassHandle, run(HasName("foo"), _))
       .WillOnce(Invoke(getAnalysisResult));
 
   {
     testing::InSequence InstrumentationExpectationsSequenced;
     EXPECT_CALL(
         PassInstrumentationCallbacks,
         runBeforePass(HasNameRegex("MockPassHandle"), HasName("foo"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                  HasName("foo"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                 HasName("foo"), Ge(3)));
     EXPECT_CALL(
         PassInstrumentationCallbacks,
         runAfterPass(HasNameRegex("MockPassHandle"), HasName("foo"), Ge(3)));
   }
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;
TEST_F(LoopCallbacksTest, InstrumentedPasses) {
   EXPECT_CALL(PassHandle, run(HasName("loop"), _, _, _))
       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
   {
     testing::InSequence InstrumentationExpectationsSequenced;
     EXPECT_CALL(PassInstrumentationCallbacks,
                 runBeforePass(HasNameRegex("MockPassHandle"),
                               HasName("loop"), Ge(5)));
     EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                  HasName("loop"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                 HasName("loop"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
                 runAfterPass(HasNameRegex("MockPassHandle"),
                              HasName("loop"), Ge(5)));
   }
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;
   PM.run(*M, AM);
TEST_F(CGSCCCallbacksTest, InstrumentedPasses) {
   EXPECT_CALL(PassHandle, run(HasName("(foo)"), _, _, _))
       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
 
   {
     testing::InSequence InstrumentationExpectationsSequenced;
     EXPECT_CALL(
         PassInstrumentationCallbacks,
         runBeforePass(HasNameRegex("MockPassHandle"), HasName("(foo)"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                  HasName("(foo)"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                 HasName("(foo)"), Ge(3)));
     EXPECT_CALL(
         PassInstrumentationCallbacks,
         runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)"), Ge(3)));
   }
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;