[PPCGCodeGen] Differentiate kernels based on their parent Scop

[singam-sanjay]

Summary

Add a sequence number that identifies a ptx_kernel's parent Scop within a function to it's name to differentiate it from other kernels produced from the same function, yet different Scops.

Kernels produced from different Scops can end up having the same name. Consider a function with 2 Scops and each Scop being able to produce just one kernel. Both of these kernels have the name "kernel_0". This can lead to the wrong kernel being launched when the runtime picks a kernel from its cache based on the name alone. This patch supplements D33985, by differentiating kernels across Scops as well.

Previously (even before D33985) while profiling kernels generated through JIT e.g. Julia, kernels associated with different functions, and even different SCoPs within a function, would be grouped together due to the common name. This patch prevents this grouping and the kernels are reported separately.

[singam-sanjay]

@grosser I tried what you suggessted,

   Value *KernelString = Builder.CreateGlobalStringPtr(ASMString, Name);
-  Value *NameString = Builder.CreateGlobalStringPtr(Name, Name + "_name");
+  Value *NameString = Builder.CreateGlobalStringPtr(KernelString->getName(),
+                                                    Name + "_name");
   Value *GPUKernel = createCallGetKernel(KernelString, NameString);

KernelString->getName() evaluated to "" and KernelString->hasName() returns false. I think this is because the IR has still not been code-generated. Please correct me if I'm wrong.

Also, even if KernelString->getName() were to return its unique name in IR,

1. The ptx_kernel in ASMString might still clash with other kernels since its name was set before KernelString's.
2. The name given to polly_getKernel might look like "kernel_0.1" whereas the name of the kernel's actually "kernel_0"

[grosser]

LGTM. Thanks for this patch!

unittests/ScopPassManager/PassManagerTest.cpp

6

Please update clang to the latest version. Then this formatting difference should go away.

[grosser]

And I forgot. Please run -instnamer of the test case first, such that the instructions in the test case are named.

[singam-sanjay]

1. Instructions and basic blocks of new test case have been named.
2. Removed format error with unittests/ScopPassManager/PassManagerTest.cpp

include/polly/ScopInfo.h

private:
   ScalarEvolution *SE;
 
   /// The underlying Region.
   Region &R;
 
   /// The name of the SCoP (identical to the regions name)
   std::string name;
 
+  /// The ID to be assigned to the next Scop in a function
+  static int NextScopID;
+
+  /// The name of the function currently under consideration
+  static std::string CurrentFunc;
+
   // Access functions of the SCoP.
   //
   // This owns all the MemoryAccess objects of the Scop created in this pass.
   AccFuncVector AccessFunctions;
 
   /// Flag to indicate that the scheduler actually optimized the SCoP.
   bool IsOptimized;
 
private:
   InvariantEquivClassesTy InvariantEquivClasses;
 
   /// The smallest array index not yet assigned.
   long ArrayIdx = 0;
 
   /// The smallest statement index not yet assigned.
   long StmtIdx = 0;
 
+  /// A number that uniquely represents a Scop within its function
+  const int ID;
+
+  /// Return the ID for a new Scop within a function
+  static int getNextID(std::string ParentFunc);
+
   /// Scop constructor; invoked from ScopBuilder::buildScop.
   Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI,
        ScopDetection::DetectionContext &DC);
 
   //@}
 
   /// Initialize this ScopBuilder.
   void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
public:
   bool isOptimized() const { return IsOptimized; }
 
   /// Mark the SCoP to be skipped by ScopPass passes.
   void markAsToBeSkipped() { SkipScop = true; }
 
   /// Check if the SCoP is to be skipped by ScopPass passes.
   bool isToBeSkipped() const { return SkipScop; }
 
+  /// Return the ID of the Scop
+  int getID() const { return ID; }
+
   /// Get the name of the entry and exit blocks of this Scop.
   ///
   /// These along with the function name can uniquely identify a Scop.
   ///
   /// @return std::pair whose first element is the entry name & second element
   ///         is the exit name.
   std::pair<std::string, std::string> getEntryExitStr() const;
 

lib/Analysis/ScopInfo.cpp

while (L) {
     if (AllContained)
       break;
     L = L->getParentLoop();
   }
 
   return L ? (S.contains(L) ? L->getParentLoop() : L) : nullptr;
 }
 
+int Scop::NextScopID = 0;
+
+std::string Scop::CurrentFunc = "";
+
+int Scop::getNextID(std::string ParentFunc) {
+  if (ParentFunc != CurrentFunc) {
+    CurrentFunc = ParentFunc;
+    NextScopID = 0;
+  }
+  return NextScopID++;
+}
+
 Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, LoopInfo &LI,
            ScopDetection::DetectionContext &DC)
     : SE(&ScalarEvolution), R(R), name(R.getNameStr()), IsOptimized(false),
       HasSingleExitEdge(R.getExitingBlock()), HasErrorBlock(false),
       MaxLoopDepth(0), CopyStmtsNum(0), SkipScop(false), DC(DC),
       IslCtx(isl_ctx_alloc(), isl_ctx_free), Context(nullptr),
       Affinator(this, LI), AssumedContext(nullptr), InvalidContext(nullptr),
-      Schedule(nullptr) {
+      Schedule(nullptr),
+      ID(getNextID((*R.getEntry()->getParent()).getName().str())) {
   if (IslOnErrorAbort)
     isl_options_set_on_error(getIslCtx(), ISL_ON_ERROR_ABORT);
   buildContext();
 }
 
 void Scop::foldSizeConstantsToRight() {
   isl_union_set *Accessed = isl_union_map_range(getAccesses());
 

lib/CodeGen/PPCGCodeGeneration.cpp

private:
   ///                   the parameter values passed for each kernel argument.
   void createCallLaunchKernel(Value *GPUKernel, Value *GridDimX,
                               Value *GridDimY, Value *BlockDimX,
                               Value *BlockDimY, Value *BlockDimZ,
                               Value *Parameters);
 };
 
 std::string GPUNodeBuilder::getKernelFuncName(int Kernel_id) {
-  return "FUNC_" + S.getFunction().getName().str() + "_KERNEL_" +
-         std::to_string(Kernel_id);
+  return "FUNC_" + S.getFunction().getName().str() + "_SCOP_" +
+         std::to_string(S.getID()) + "_KERNEL_" + std::to_string(Kernel_id);
 }
 
 void GPUNodeBuilder::initializeAfterRTH() {
   BasicBlock *NewBB = SplitBlock(Builder.GetInsertBlock(),
                                  &*Builder.GetInsertPoint(), &DT, &LI);
   NewBB->setName("polly.acc.initialize");
   Builder.SetInsertPoint(&NewBB->front());
 

test/GPGPU/cuda-annotations.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck -check-prefix=KERNEL %s
 
 ; REQUIRES: pollyacc
 
-; KERNEL: define ptx_kernel void @FUNC_foo_KERNEL_0(i8 addrspace(1)* %MemRef_A, i64 %n) #0 {
+; KERNEL: define ptx_kernel void @FUNC_foo_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef_A, i64 %n) #0 {
 
 ; KERNEL: !nvvm.annotations = !{!0}
 
-; KERNEL: !0 = !{void (i8 addrspace(1)*, i64)* @FUNC_foo_KERNEL_0, !"maxntidx", i32 32, !"maxntidy", i32 1, !"maxntidz", i32 1}
+; KERNEL: !0 = !{void (i8 addrspace(1)*, i64)* @FUNC_foo_SCOP_0_KERNEL_0, !"maxntidx", i32 32, !"maxntidy", i32 1, !"maxntidz", i32 1}
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo(i64* %A, i64 %n) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb6, %bb

test/GPGPU/cuda-managed-memory-simple.ll

 ; CHECK-NEXT:  store i32 4, i32* %polly_launch_0_param_size_0
 ; CHECK-NEXT:  %20 = getelementptr [4 x i8*], [4 x i8*]* %polly_launch_0_params, i64 0, i64 2
 ; CHECK-NEXT:  %21 = bitcast i32* %polly_launch_0_param_size_0 to i8*
 ; CHECK-NEXT:  store i8* %21, i8** %20
 ; CHECK-NEXT:  store i32 4, i32* %polly_launch_0_param_size_1
 ; CHECK-NEXT:  %22 = getelementptr [4 x i8*], [4 x i8*]* %polly_launch_0_params, i64 0, i64 3
 ; CHECK-NEXT:  %23 = bitcast i32* %polly_launch_0_param_size_1 to i8*
 ; CHECK-NEXT:  store i8* %23, i8** %22
-; CHECK-NEXT:  %24 = call i8* @polly_getKernel(i8* getelementptr inbounds ([810 x i8], [810 x i8]* @FUNC_copy_KERNEL_0, i32 0, i32 0), i8* getelementptr inbounds ([19 x i8], [19 x i8]* @FUNC_copy_KERNEL_0_name, i32 0, i32 0))
+; CHECK-NEXT:  %24 = call i8* @polly_getKernel(i8* getelementptr inbounds ([852 x i8], [852 x i8]* @FUNC_copy_SCOP_0_KERNEL_0, i32 0, i32 0), i8* getelementptr inbounds ([26 x i8], [26 x i8]* @FUNC_copy_SCOP_0_KERNEL_0_name, i32 0, i32 0))
 ; CHECK-NEXT:  call void @polly_launchKernel(i8* %24, i32 2, i32 1, i32 32, i32 1, i32 1, i8* %polly_launch_0_params_i8ptr)
 ; CHECK-NEXT:  call void @polly_freeKernel(i8* %24)
 ; CHECK-NEXT:  call void @polly_synchronizeDevice()
 ; CHECK-NEXT:  call void @polly_freeContext(i8* %13)
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @copy(i32* %R, i32* %A) {

test/GPGPU/host-control-flow.ll

 ; IR-NEXT:  store i8* [[REGB]], i8** [[REGA]]
 ; IR: call i8* @polly_getKernel
 ; ...
 ; IR: call void @polly_freeKernel
 ; IR-NEXT:   %polly.indvar_next = add nsw i64 %polly.indvar, 1
 ; IR-NEXT:   %polly.loop_cond = icmp sle i64 %polly.indvar_next, 99
 ; IR-NEXT:   br i1 %polly.loop_cond, label %polly.loop_header, label %polly.loop_exit
 
-; KERNEL-IR: define ptx_kernel void @FUNC_foo_KERNEL_0(i8 addrspace(1)* %MemRef_A, i64 %c0)
+; KERNEL-IR: define ptx_kernel void @FUNC_foo_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef_A, i64 %c0)
 ; KERNEL-IR-LABEL: entry:
 ; KERNEL-IR-NEXT:   %0 = call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
 ; KERNEL-IR-NEXT:   %b0 = zext i32 %0 to i64
 ; KERNEL-IR-NEXT:   %1 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
 ; KERNEL-IR-NEXT:   %t0 = zext i32 %1 to i64
 ; KERNEL-IR-NEXT:   br label %polly.cond
 
 ; KERNEL-IR-LABEL: polly.cond:                                       ; preds = %entry

test/GPGPU/invariant-load-hoisting.ll

 ; SCOP-NEXT:          ReadAccess := [Reduction Type: NONE] [Scalar: 0]
 ; SCOP-NEXT:              [n, tmp12] -> { Stmt_for_body6[i0, i1, i2] -> MemRef_invariant[0] };
 ; SCOP-NEXT:          Execution Context: [n, tmp12] -> {  : n > 0 }
 ; SCOP-NEXT:  }
 ;
 ; HOST-IR:      call void @polly_launchKernel(i8* %215, i32 %221, i32 1, i32 32, i32 1, i32 1, i8* %polly_launch_0_params_i8ptr)
 ; HOST-IR-NEXT: call void @polly_freeKernel(i8* %215)
 ;
-; KERNEL-IR: define ptx_kernel void @FUNC_f_KERNEL_0(i8 addrspace(1)* %MemRef_B, i8 addrspace(1)* %MemRef_A, i32 %n, i32 %tmp12) #0 {
+; KERNEL-IR: define ptx_kernel void @FUNC_f_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef_B, i8 addrspace(1)* %MemRef_A, i32 %n, i32 %tmp12) #0 {
 ;
 ; Check that we generate correct GPU code in case of invariant load hoisting.
 ;
 ;
 ;    static const int N = 3000;
 ;
 ;    void f(int A[N][N], int *invariant, int B[N][N], int n) {
 ;      for (int i = 0; i < n; i++) {

test/GPGPU/kernel-params-only-some-arrays.ll

 ;    void kernel_params_only_some_arrays(float A[], float B[]) {
 ;      for (long i = 0; i < 32; i++)
 ;        A[i] += 42;
 ;
 ;      for (long i = 0; i < 32; i++)
 ;        B[i] += 42;
 ;    }
 
-; KERNEL: ; ModuleID = 'FUNC_kernel_params_only_some_arrays_KERNEL_0'
-; KERNEL-NEXT: source_filename = "FUNC_kernel_params_only_some_arrays_KERNEL_0"
+; KERNEL: ; ModuleID = 'FUNC_kernel_params_only_some_arrays_SCOP_0_KERNEL_0'
+; KERNEL-NEXT: source_filename = "FUNC_kernel_params_only_some_arrays_SCOP_0_KERNEL_0"
 ; KERNEL-NEXT: target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64"
 ; KERNEL-NEXT: target triple = "nvptx64-nvidia-cuda"
 
-; KERNEL: define ptx_kernel void @FUNC_kernel_params_only_some_arrays_KERNEL_0(i8 addrspace(1)* %MemRef_A)
+; KERNEL: define ptx_kernel void @FUNC_kernel_params_only_some_arrays_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef_A)
 ; KERNEL-NEXT:   entry:
 ; KERNEL-NEXT:     %0 = call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
 ; KERNEL-NEXT:     %b0 = zext i32 %0 to i64
 ; KERNEL-NEXT:     %1 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
 ; KERNEL-NEXT:     %t0 = zext i32 %1 to i64
 
 ; KERNEL:     ret void
 ; KERNEL-NEXT: }
 
-; KERNEL: ; ModuleID = 'FUNC_kernel_params_only_some_arrays_KERNEL_1'
-; KERNEL-NEXT: source_filename = "FUNC_kernel_params_only_some_arrays_KERNEL_1"
+; KERNEL: ; ModuleID = 'FUNC_kernel_params_only_some_arrays_SCOP_0_KERNEL_1'
+; KERNEL-NEXT: source_filename = "FUNC_kernel_params_only_some_arrays_SCOP_0_KERNEL_1"
 ; KERNEL-NEXT: target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64"
 ; KERNEL-NEXT: target triple = "nvptx64-nvidia-cuda"
 
-; KERNEL: define ptx_kernel void @FUNC_kernel_params_only_some_arrays_KERNEL_1(i8 addrspace(1)* %MemRef_B)
+; KERNEL: define ptx_kernel void @FUNC_kernel_params_only_some_arrays_SCOP_0_KERNEL_1(i8 addrspace(1)* %MemRef_B)
 ; KERNEL-NEXT:   entry:
 ; KERNEL-NEXT:     %0 = call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
 ; KERNEL-NEXT:     %b0 = zext i32 %0 to i64
 ; KERNEL-NEXT:     %1 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
 ; KERNEL-NEXT:     %t0 = zext i32 %1 to i64
 
 ; KERNEL:     ret void
 ; KERNEL-NEXT: }

test/GPGPU/kernel-params-scop-parameter.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck -check-prefix=KERNEL-IR %s
 
 ; REQUIRES: pollyacc
 
 ;    void kernel_params_scop_parameter(float A[], long n) {
 ;      for (long i = 0; i < n; i++)
 ;        A[i] += 42;
 ;    }
 
-; KERNEL-IR: define ptx_kernel void @FUNC_kernel_params_scop_parameter_KERNEL_0(i8 addrspace(1)* %MemRef_A, i64 %n)
+; KERNEL-IR: define ptx_kernel void @FUNC_kernel_params_scop_parameter_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef_A, i64 %n)
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @kernel_params_scop_parameter(float* %A, i64 %n) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb6, %bb

test/GPGPU/kernels-names-across-scops-funcs.ll

+; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen-ppcg \
+; RUN: -polly-acc-dump-kernel-ir -disable-output < %s | FileCheck -check-prefix=KERNEL %s
+
+; REQUIRES: pollyacc
+
+; KERNEL: define ptx_kernel void @FUNC_foo_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef0, i32 %p_0) #0 {
+; KERNER-NEXT: define ptx_kernel void @FUNC_foo_SCOP_1_KERNEL_0(i8 addrspace(1)* %MemRef0, i32 %p_0) #0 {
+; KERNER-NEXT: define ptx_kernel void @FUNC_foo2_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef0, i32 %p_0) #0 {
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+; Function Attrs: nounwind uwtable
+define void @foo(i32, i32*) #0 {
+  br label %3
+
+; <label>:3:                                      ; preds = %2
+  %4 = icmp sgt i32 %0, 0
+  br i1 %4, label %5, label %15
+
+; <label>:5:                                      ; preds = %3
+  br label %6
+
+; <label>:6:                                      ; preds = %5, %6
+  %7 = phi i64 [ 0, %5 ], [ %11, %6 ]
+  %8 = getelementptr inbounds i32, i32* %1, i64 %7
+  %9 = load i32, i32* %8, align 4, !tbaa !2
+  %10 = add nsw i32 %9, 1
+  store i32 %10, i32* %8, align 4, !tbaa !2
+  %11 = add nuw nsw i64 %7, 1
+  %12 = zext i32 %0 to i64
+  %13 = icmp ne i64 %11, %12
+  br i1 %13, label %6, label %14
+
+; <label>:14:                                     ; preds = %6
+  br label %15
+
+; <label>:15:                                     ; preds = %14, %3
+  %16 = tail call i64 @clock() #3
+  %17 = icmp eq i64 %16, 0
+  br i1 %17, label %18, label %31
+
+; <label>:18:                                     ; preds = %15
+  %19 = icmp sgt i32 %0, 0
+  br i1 %19, label %20, label %30
+
+; <label>:20:                                     ; preds = %18
+  br label %21
+
+; <label>:21:                                     ; preds = %20, %21
+  %22 = phi i64 [ 0, %20 ], [ %26, %21 ]
+  %23 = getelementptr inbounds i32, i32* %1, i64 %22
+  %24 = load i32, i32* %23, align 4, !tbaa !2
+  %25 = add nsw i32 %24, 1
+  store i32 %25, i32* %23, align 4, !tbaa !2
+  %26 = add nuw nsw i64 %22, 1
+  %27 = zext i32 %0 to i64
+  %28 = icmp ne i64 %26, %27
+  br i1 %28, label %21, label %29
+
+; <label>:29:                                     ; preds = %21
+  br label %30
+
+; <label>:30:                                     ; preds = %29, %18
+  br label %31
+
+; <label>:31:                                     ; preds = %30, %15
+  ret void
+}
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
+
+; Function Attrs: nounwind
+declare i64 @clock() #2
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
+
+; Function Attrs: nounwind uwtable
+define void @foo2(i32, i32*) #0 {
+  br label %3
+
+; <label>:3:                                      ; preds = %2
+  %4 = icmp sgt i32 %0, 0
+  br i1 %4, label %5, label %15
+
+; <label>:5:                                      ; preds = %3
+  br label %6
+
+; <label>:6:                                      ; preds = %5, %6
+  %7 = phi i64 [ 0, %5 ], [ %11, %6 ]
+  %8 = getelementptr inbounds i32, i32* %1, i64 %7
+  %9 = load i32, i32* %8, align 4, !tbaa !2
+  %10 = add nsw i32 %9, 1
+  store i32 %10, i32* %8, align 4, !tbaa !2
+  %11 = add nuw nsw i64 %7, 1
+  %12 = zext i32 %0 to i64
+  %13 = icmp ne i64 %11, %12
+  br i1 %13, label %6, label %14
+
+; <label>:14:                                     ; preds = %6
+  br label %15
+
+; <label>:15:                                     ; preds = %14, %3
+  ret void
+}
+
+attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { argmemonly nounwind }
+attributes #2 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #3 = { nounwind }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 5.0.0 (http://llvm.org/git/clang 98cf823022d1d71065c71e9338226ebf8bfa36ba) (http://llvm.org/git/llvm.git 4efa61f12928015bad233274ffa2e60c918e9a10)"}
+!2 = !{!3, !3, i64 0}
+!3 = !{!"int", !4, i64 0}
+!4 = !{!"omnipotent char", !5, i64 0}
+!5 = !{!"Simple C/C++ TBAA"}

unittests/ScopPassManager/PassManagerTest.cpp

-#include "llvm/IR/PassManager.h"
 #include "polly/CodeGen/IslAst.h"
 #include "polly/DependenceInfo.h"
 #include "polly/ScopPass.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include "gtest/gtest.h"
 
 using namespace polly;
 using namespace llvm;
 
 namespace {