[Coroutines][new pass manager] Move CoroElide pass to right position

[junparser]

Summary

When test coroutines under new pass manager, we find that it is less powerful than legacy in coroutine frame elision.
That's because CoroElide executed right after CoroSplit instead of after series of optimization passes.

This patch move CoroElide same position as legacy

TestPlan: check-llvm, cppcoro check-clang

[modocache]

Nice catch, thanks!

[wenlei]

Thanks for the patch, @junparser! Curious how did you notice this - was it causing performance regression for your workload?

[junparser]

In D75345#1899012, @wenlei wrote:

Thanks for the patch, @junparser! Curious how did you notice this - was it causing performance regression for your workload?

yep, Since the coroutine flow of our wrokloads are to sensitive to time and memory usage, we have a statistical system

[junparser]

Update clang testcase to avoid check-clang failure

clang/test/CodeGenCoroutines/coro-newpm-pipeline.cpp

 // Tests that coroutine passes are added to and run by the new pass manager
 // pipeline, at -O0 and above.
 
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm-bc -o /dev/null \
 // RUN:   -fexperimental-new-pass-manager -fdebug-pass-manager -fcoroutines-ts \
 // RUN:   -O0 %s 2>&1 | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm-bc -o /dev/null \
 // RUN:   -fexperimental-new-pass-manager -fdebug-pass-manager -fcoroutines-ts \
 // RUN:   -O1 %s 2>&1 | FileCheck %s
 //
 // CHECK: Starting llvm::Module pass manager run.
 // CHECK: Running pass:{{.*}}CoroEarlyPass
 //
 // The first coro-split pass enqueues a second run of the entire CGSCC pipeline.
 // CHECK: Starting CGSCC pass manager run.
 // CHECK: Running pass: CoroSplitPass on (_Z3foov)
-// CHECK: Running pass:{{.*}}CoroElidePass{{.*}} on (_Z3foov)
+// CHECK: Running pass:{{.*}}CoroElidePass{{.*}} on {{.*}}_Z3foov{{.*}}
 // CHECK: Finished CGSCC pass manager run.
 //
 // The second coro-split pass splits coroutine 'foo' into funclets
 // 'foo.resume', 'foo.destroy', and 'foo.cleanup'.
 // CHECK: Starting CGSCC pass manager run.
 // CHECK: Running pass: CoroSplitPass on (_Z3foov)
-// CHECK: Running pass:{{.*}}CoroElidePass{{.*}} on (_Z3foov)
+// CHECK: Running pass:{{.*}}CoroElidePass{{.*}} on {{.*}}_Z3foov{{.*}}
 // CHECK: Finished CGSCC pass manager run.
 //
 // CHECK: Running pass:{{.*}}CoroCleanupPass
 // CHECK: Finished llvm::Module pass manager run.
 
 namespace std {
 namespace experimental {
 

llvm/lib/Passes/PassBuilder.cpp

if (Level.getSpeedupLevel() > 1) {
     FPM.addPass(JumpThreadingPass());
     FPM.addPass(CorrelatedValuePropagationPass());
     FPM.addPass(DSEPass());
     FPM.addPass(createFunctionToLoopPassAdaptor(
         LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap),
         EnableMSSALoopDependency, DebugLogging));
   }
 
+  if (PTO.Coroutines)
+    FPM.addPass(CoroElidePass());
+
   for (auto &C : ScalarOptimizerLateEPCallbacks)
     C(FPM, Level);
 
   // Finally, do an expensive DCE pass to catch all the dead code exposed by
   // the simplifications and basic cleanup after all the simplifications.
   // TODO: Investigate if this is too expensive.
   FPM.addPass(ADCEPass());
   FPM.addPass(SimplifyCFGPass());
PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
   InlineParams IP = getInlineParamsFromOptLevel(Level);
   if (Phase == ThinLTOPhase::PreLink && PGOOpt &&
       PGOOpt->Action == PGOOptions::SampleUse)
     IP.HotCallSiteThreshold = 0;
   MainCGPipeline.addPass(InlinerPass(IP));
 
   MainCGPipeline.addPass(AttributorCGSCCPass());
 
-  if (PTO.Coroutines) {
+  if (PTO.Coroutines)
     MainCGPipeline.addPass(CoroSplitPass());
-    MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(CoroElidePass()));
-  }
 
   // Now deduce any function attributes based in the current code.
   MainCGPipeline.addPass(PostOrderFunctionAttrsPass());
 
   // When at O3 add argument promotion to the pass pipeline.
   // FIXME: It isn't at all clear why this should be limited to O3.
   if (Level == OptimizationLevel::O3)
     MainCGPipeline.addPass(ArgumentPromotionPass());

llvm/test/Transforms/Coroutines/ex2.ll

 }
 
 ; CHECK-LABEL: @main
 define i32 @main() {
 entry:
   %hdl = call i8* @f(i32 4)
   call void @llvm.coro.resume(i8* %hdl)
   call void @llvm.coro.resume(i8* %hdl)
+  %to = icmp eq i8* %hdl, null
+  br i1 %to, label %return, label %destroy
+destroy:
   call void @llvm.coro.destroy(i8* %hdl)
+  br label %return
+return:
   ret i32 0
+; CHECK-NOT:  call i8* @CustomAlloc
 ; CHECK:      call void @print(i32 4)
 ; CHECK-NEXT: call void @print(i32 5)
 ; CHECK-NEXT: call void @print(i32 6)
 ; CHECK-NEXT: ret i32 0
 }
 
 declare i8* @CustomAlloc(i32)
 declare void @CustomFree(i8*)

llvm/test/Transforms/Coroutines/ex3.ll

 ; Third example from Doc/Coroutines.rst (two suspend points)
 ; RUN: opt < %s -O2 -enable-coroutines -S | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='default<O2>' -enable-coroutines -S | FileCheck %s
 
 define i8* @f(i32 %n) {
 entry:
   %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
   %size = call i32 @llvm.coro.size.i32()
+  %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
+  br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
+dyn.alloc:
   %alloc = call i8* @malloc(i32 %size)
-  %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %alloc)
+  br label %coro.begin
+coro.begin:
+  %phi = phi i8* [ null, %entry ], [ %alloc, %dyn.alloc ]
+  %hdl = call noalias i8* @llvm.coro.begin(token %id, i8* %phi)
   br label %loop
 loop:
-  %n.val = phi i32 [ %n, %entry ], [ %inc, %loop.resume ]
+  %n.val = phi i32 [ %n, %coro.begin ], [ %inc, %loop.resume ]
   call void @print(i32 %n.val) #4
   %0 = call i8 @llvm.coro.suspend(token none, i1 false)
   switch i8 %0, label %suspend [i8 0, label %loop.resume
                                 i8 1, label %cleanup]
 loop.resume:
   %inc = add nsw i32 %n.val, 1
   %sub = xor i32 %n.val, -1
   call void @print(i32 %sub)

 }
 
 ; CHECK-LABEL: @main
 define i32 @main() {
 entry:
   %hdl = call i8* @f(i32 4)
   call void @llvm.coro.resume(i8* %hdl)
   call void @llvm.coro.resume(i8* %hdl)
+  %c = ptrtoint i8* %hdl to i64
+  %to = icmp eq i64 %c, 0
+  br i1 %to, label %return, label %destroy
+destroy:
   call void @llvm.coro.destroy(i8* %hdl)
+  br label %return
+return:
   ret i32 0
+; CHECK-NOT:  i8* @malloc
 ; CHECK:      call void @print(i32 4)
 ; CHECK-NEXT: call void @print(i32 -5)
 ; CHECK-NEXT: call void @print(i32 5)
 ; CHECK:      ret i32 0
 }
 
 declare i8* @malloc(i32)
 declare void @free(i8*)