[NewPM] Add PipelineTuningOption to eagerly invalidate analyses

[aeubanks]

Summary

This trades off more compile time for less peak memory usage. Right now
it invalidates all function analyses after a module->function or
cgscc->function adaptor.

https://llvm-compile-time-tracker.com/compare.php?from=1fb24fe85a19ae71b00875ff6c96ef1831dcf7e3&to=cb28ddb063c87f0d5df89812ab2de9a69dd276db&stat=instructions
https://llvm-compile-time-tracker.com/compare.php?from=1fb24fe85a19ae71b00875ff6c96ef1831dcf7e3&to=cb28ddb063c87f0d5df89812ab2de9a69dd276db&stat=max-rss

For now this is just experimental.

See comments on why this may affect optimizations.

[aeubanks]

update

[asbirlea]

Can you also include the direct link to the memory comparison in the description?
(https://llvm-compile-time-tracker.com/compare.php?from=1fb24fe85a19ae71b00875ff6c96ef1831dcf7e3&to=f1604149f211f2fa2f5609ccdebb96491e961b7f&stat=max-rss)

[nikic]

llvm/include/llvm/Passes/PassBuilder.h

80

I think this could be more precise about what "invalidate more analyses" means. From the implementation, my understanding is that analyses will be invalidated after a function pass manager finishes processing a function.

Makes me wonder if we shouldn't be handling this in the Function to CGSCC/Module pass manager adaptors.

[nikic]

llvm/tools/opt/NewPMDriver.cpp

155

Can we please move this option from opt into LLVM? I'd like it to be testable via -mllvm equivalents without explicit frontend support.

[aeubanks]

make this affect all cgscc/module->function adaptors
just to simplify this change, now the flag isn't in PTO, it's just a global cl flag

[nikic]

LG

[nikic]

Here are the results for this change with rust's compile-time tracking infrastructure:

Compile-time: https://perf.rust-lang.org/compare.html?start=5dab47dcd8267b8769421b46532414ec36d625e3&end=cfe9eecdf01985dff182ce388fe843987d1da888 (disable the filtering to see fairly consistent minor impact)
Max-rss: https://perf.rust-lang.org/compare.html?start=5dab47dcd8267b8769421b46532414ec36d625e3&end=cfe9eecdf01985dff182ce388fe843987d1da888&stat=max-rss

This looks like a pretty good tradeoff to me.

[aeubanks]

In D111575#3072134, @nikic wrote:

Here are the results for this change with rust's compile-time tracking infrastructure:

Compile-time: https://perf.rust-lang.org/compare.html?start=5dab47dcd8267b8769421b46532414ec36d625e3&end=cfe9eecdf01985dff182ce388fe843987d1da888 (disable the filtering to see fairly consistent minor impact)
Max-rss: https://perf.rust-lang.org/compare.html?start=5dab47dcd8267b8769421b46532414ec36d625e3&end=cfe9eecdf01985dff182ce388fe843987d1da888&stat=max-rss

This looks like a pretty good tradeoff to me.

interesting, it doesn't match the Clang numbers

llvm/include/llvm/Passes/PassBuilder.h

public:
 
   /// Tuning option to enable/disable call graph profile. Its default value is
   /// that of the flag: `-enable-npm-call-graph-profile`.
   bool CallGraphProfile;
 
   /// Tuning option to enable/disable function merging. Its default value is
   /// false.
   bool MergeFunctions;
+
+  /// Eagerly invalidate more analyses. This has the potential to decrease max
+  /// memory usage in exchange for more compile time. This may affect codegen
+  /// due to either passes using analyses only when cached, or invalidating and
+  /// recalculating an analysis that was stale/imprecise but still valid.
+  bool EagerlyInvalidateAnalyses;
 };
 
 /// This class provides access to building LLVM's passes.
 ///
 /// Its members provide the baseline state available to passes during their
 /// construction. The \c PassRegistry.def file specifies how to construct all
 /// of the built-in passes, and those may reference these members during
 /// construction.

llvm/lib/Passes/PassBuilderPipelines.cpp

PipelineTuningOptions::PipelineTuningOptions() {
   LoopVectorization = true;
   SLPVectorization = false;
   LoopUnrolling = true;
   ForgetAllSCEVInLoopUnroll = ForgetSCEVInLoopUnroll;
   LicmMssaOptCap = SetLicmMssaOptCap;
   LicmMssaNoAccForPromotionCap = SetLicmMssaNoAccForPromotionCap;
   CallGraphProfile = true;
   MergeFunctions = false;
+  EagerlyInvalidateAnalyses = false;
 }
 
 namespace llvm {
 
 extern cl::opt<unsigned> MaxDevirtIterations;
 extern cl::opt<bool> EnableConstraintElimination;
 extern cl::opt<bool> EnableFunctionSpecialization;
 extern cl::opt<bool> EnableGVNHoist;
PassBuilder::buildInlinerPipeline(OptimizationLevel Level,
   if (Level == OptimizationLevel::O2 || Level == OptimizationLevel::O3)
     MainCGPipeline.addPass(OpenMPOptCGSCCPass());
 
   for (auto &C : CGSCCOptimizerLateEPCallbacks)
     C(MainCGPipeline, Level);
 
   // Lastly, add the core function simplification pipeline nested inside the
   // CGSCC walk.
-  MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
-      buildFunctionSimplificationPipeline(Level, Phase)));
+  FunctionPassManager FPM = buildFunctionSimplificationPipeline(Level, Phase);
+  if (PTO.EagerlyInvalidateAnalyses)
+    FPM.addPass(InvalidateAllAnalysesPass());
+  MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
 
   MainCGPipeline.addPass(CoroSplitPass(Level != OptimizationLevel::O0));
 
   return MIWP;
 }
 
 ModulePassManager
 PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
   // In SamplePGO ThinLTO backend, we need instcombine before profile annotation
   // to convert bitcast to direct calls so that they can be inlined during the
   // profile annotation prepration step.
   // More details about SamplePGO design can be found in:
   // https://research.google.com/pubs/pub45290.html
   // FIXME: revisit how SampleProfileLoad/Inliner/ICP is structured.
   if (LoadSampleProfile)
     EarlyFPM.addPass(InstCombinePass());
+  if (PTO.EagerlyInvalidateAnalyses)
+    EarlyFPM.addPass(InvalidateAllAnalysesPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(EarlyFPM)));
 
   if (LoadSampleProfile) {
     // Annotate sample profile right after early FPM to ensure freshness of
     // the debug info.
     MPM.addPass(SampleProfileLoaderPass(PGOOpt->ProfileFile,
                                         PGOOpt->ProfileRemappingFile, Phase));
     // Cache ProfileSummaryAnalysis once to avoid the potential need to insert
PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
 
   // Create a small function pass pipeline to cleanup after all the global
   // optimizations.
   FunctionPassManager GlobalCleanupPM;
   GlobalCleanupPM.addPass(InstCombinePass());
   invokePeepholeEPCallbacks(GlobalCleanupPM, Level);
 
   GlobalCleanupPM.addPass(SimplifyCFGPass());
+  if (PTO.EagerlyInvalidateAnalyses)
+    GlobalCleanupPM.addPass(InvalidateAllAnalysesPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(GlobalCleanupPM)));
 
   // Add all the requested passes for instrumentation PGO, if requested.
   if (PGOOpt && Phase != ThinOrFullLTOPhase::ThinLTOPostLink &&
       (PGOOpt->Action == PGOOptions::IRInstr ||
        PGOOpt->Action == PGOOptions::IRUse)) {
     addPGOInstrPasses(MPM, Level,
                       /* RunProfileGen */ PGOOpt->Action == PGOOptions::IRInstr,
PassBuilder::buildModuleOptimizationPipeline(OptimizationLevel Level,
   OptimizePM.addPass(DivRemPairsPass());
 
   // LoopSink (and other loop passes since the last simplifyCFG) might have
   // resulted in single-entry-single-exit or empty blocks. Clean up the CFG.
   OptimizePM.addPass(SimplifyCFGPass());
 
   OptimizePM.addPass(CoroCleanupPass());
 
+  if (PTO.EagerlyInvalidateAnalyses)
+    OptimizePM.addPass(InvalidateAllAnalysesPass());
+
   // Add the core optimizing pipeline.
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(OptimizePM)));
 
   for (auto &C : OptimizerLastEPCallbacks)
     C(MPM, Level);
 
   if (PTO.CallGraphProfile)
     MPM.addPass(CGProfilePass());

llvm/test/Other/new-pm-eager-invalidate.ll

+; RUN: opt -disable-verify -verify-cfg-preserved=0 -debug-pass-manager -passes='default<O3>' -S -eagerly-invalidate-analyses %s 2>&1 | FileCheck %s
+
+; CHECK: Running pass: InvalidateAllAnalysesPass on foo
+; CHECK: Running pass: InvalidateAllAnalysesPass on foo
+; CHECK: Running pass: InvalidateAllAnalysesPass on foo
+; CHECK: Running pass: InvalidateAllAnalysesPass on foo
+
+declare void @bar() local_unnamed_addr
+
+define void @foo(i32 %n) local_unnamed_addr {
+entry:
+  br label %loop
+loop:
+  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
+  %iv.next = add i32 %iv, 1
+  tail call void @bar()
+  %cmp = icmp eq i32 %iv, %n
+  br i1 %cmp, label %exit, label %loop
+exit:
+  ret void
+}

llvm/tools/opt/NewPMDriver.cpp

ProfileRemappingFile("profile-remapping-file",
                          cl::desc("Path to the profile remapping file."),
                          cl::Hidden);
 static cl::opt<bool> DebugInfoForProfiling(
     "new-pm-debug-info-for-profiling", cl::init(false), cl::Hidden,
     cl::desc("Emit special debug info to enable PGO profile generation."));
 static cl::opt<bool> PseudoProbeForProfiling(
     "new-pm-pseudo-probe-for-profiling", cl::init(false), cl::Hidden,
     cl::desc("Emit pseudo probes to enable PGO profile generation."));
+static cl::opt<bool> EagerlyInvalidateAnalyses(
+    "eagerly-invalidate-analyses", cl::init(false), cl::Hidden,
+    cl::desc("Eagerly invalidate more analyses in default pipelines"));
 /// @}}
 
 template <typename PassManagerT>
 bool tryParsePipelineText(PassBuilder &PB,
                           const cl::opt<std::string> &PipelineOpt) {
   if (PipelineOpt.empty())
     return false;
 
bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
   if (DebugifyEach)
     Debugify.registerCallbacks(PIC);
 
   PipelineTuningOptions PTO;
   // LoopUnrolling defaults on to true and DisableLoopUnrolling is initialized
   // to false above so we shouldn't necessarily need to check whether or not the
   // option has been enabled.
   PTO.LoopUnrolling = !DisableLoopUnrolling;
+  PTO.EagerlyInvalidateAnalyses = EagerlyInvalidateAnalyses;
   PassBuilder PB(TM, PTO, P, &PIC);
   registerEPCallbacks(PB);
 
   // Load requested pass plugins and let them register pass builder callbacks
   for (auto &PluginFN : PassPlugins) {
     auto PassPlugin = PassPlugin::Load(PluginFN);
     if (!PassPlugin) {
       errs() << "Failed to load passes from '" << PluginFN