[Polly-ACC] disallow managed memory code generation for OpenCL

[alaindenzler]

Summary

This patch disables the ManagedMemoryRewrite pass if we are not generating CUDA code. The pass was enabled by default when generating GPU code, which resulted in a failed compilation when only OpenCL was present. Additionally it attempted to rewrite alloc() and free() calls even when the command line flag was set to false, because the cli option did not guard the pass correctly.

Using this patch, the ManagedMemoryRewrite pass is only enabled if both the command line option is set and we are generating ptx code.

[philip.pfaffe]

I don't like that this messes with global state. This destroys local reasoning and makes refactoring unnecessarily harder in the future.

How about instead wrapping accesses to the flag in a helper function like useManagedMemory() that performs this check?

lib/CodeGen/PPCGCodeGeneration.cpp

3569

This modifies global state.

[alaindenzler]

Checking the flag using its own function now. Is this the right place to define it?

[philip.pfaffe]

I'd prefer putting it into PPCGCodeGeneration.cpp/PPCGCodeGeneration.h.

[alaindenzler]

Placed the useManagedMemory() function inside PPCGCodeGeneration.

[philip.pfaffe]

Thank, only nits left!

Please upload future patches with the full context: diff -U999999 <ref-base>, or use the arcanist tool. Otherwise you can't browse it with phabricator.

include/polly/CodeGen/PPCGCodeGeneration.h

30

Is this outside the namespace?

lib/CodeGen/PPCGCodeGeneration.cpp

93

This change is unrelated.

lib/Support/RegisterPasses.cpp

245

Unrelated change.

[alaindenzler]

Thanks, now using polly namespace.

[philip.pfaffe]

Thanks! LGTM.

include/polly/CodeGen/PPCGCodeGeneration.h

 extern bool PollyManagedMemory;
 }
 
+/// Check whether we use the right GPU architecure and runtime to generate
+/// CUDA managed memory
+bool useManagedMemory(GPUArch Arch, GPURuntime Runtime);
+
 #endif // POLLY_PPCGCODEGENERATION_H

lib/CodeGen/PPCGCodeGeneration.cpp

                                    cl::desc("Use private memory"), cl::Hidden,
                                    cl::init(false), cl::ZeroOrMore,
                                    cl::cat(PollyCategory));
-
 bool polly::PollyManagedMemory;
 static cl::opt<bool, true>
     XManagedMemory("polly-acc-codegen-managed-memory",

          " | Function: " + std::string(S->getFunction().getName());
 }
 
+/// Check whether the GPU architecture and runtime are correct to use
+/// CUDA managed memory
+bool useManagedMemory(GPUArch Arch, GPURuntime Runtime) {
+  return (PollyManagedMemory && (Runtime == GPURuntime::CUDA) &&
+          (Arch == GPUArch::NVPTX64));
+}
+
 /// Used to store information PPCG wants for kills. This information is
 /// used by live range reordering.
 ///

 
   GPUContext = createCallInitContext();
 
-  if (!PollyManagedMemory)
+  if (!useManagedMemory(Arch, Runtime))
     allocateDeviceArrays();
   else
     prepareManagedDeviceArrays();
 }
 
 void GPUNodeBuilder::finalize() {
-  if (!PollyManagedMemory)
+  if (!useManagedMemory(Arch, Runtime))
     freeDeviceArrays();
 
   createCallFreeContext(GPUContext);

 }
 
 void GPUNodeBuilder::allocateDeviceArrays() {
-  assert(!PollyManagedMemory &&
+  assert(!useManagedMemory(Arch, Runtime) &&
          "Managed memory will directly send host pointers "
          "to the kernel. There is no need for device arrays");
   isl_ast_build *Build = isl_ast_build_from_context(S.getContext().release());

 }
 
 void GPUNodeBuilder::prepareManagedDeviceArrays() {
-  assert(PollyManagedMemory &&
+  assert(useManagedMemory(Arch, Runtime) &&
          "Device array most only be prepared in managed-memory mode");
   for (int i = 0; i < Prog->n_array; ++i) {
     gpu_array_info *Array = &Prog->array[i];

 }
 
 void GPUNodeBuilder::freeDeviceArrays() {
-  assert(!PollyManagedMemory && "Managed memory does not use device arrays");
+  assert(!useManagedMemory(Arch, Runtime) &&
+         "Managed memory does not use device arrays");
   for (auto &Array : DeviceAllocations)
     createCallFreeDeviceMemory(Array.second);
 }

 }
 
 void GPUNodeBuilder::createCallFreeDeviceMemory(Value *Array) {
-  assert(!PollyManagedMemory &&
+  assert(!useManagedMemory(Arch, Runtime) &&
          "Managed memory does not allocate or free memory "
          "for device");
   const char *Name = "polly_freeDeviceMemory";

 }
 
 Value *GPUNodeBuilder::createCallAllocateMemoryForDevice(Value *Size) {
-  assert(!PollyManagedMemory &&
+  assert(!useManagedMemory(Arch, Runtime) &&
          "Managed memory does not allocate or free memory "
          "for device");
   const char *Name = "polly_allocateMemoryForDevice";

 void GPUNodeBuilder::createCallCopyFromHostToDevice(Value *HostData,
                                                     Value *DeviceData,
                                                     Value *Size) {
-  assert(!PollyManagedMemory &&
+  assert(!useManagedMemory(Arch, Runtime) &&
          "Managed memory does not transfer memory between "
          "device and host");
   const char *Name = "polly_copyFromHostToDevice";

 void GPUNodeBuilder::createCallCopyFromDeviceToHost(Value *DeviceData,
                                                     Value *HostData,
                                                     Value *Size) {
-  assert(!PollyManagedMemory &&
+  assert(!useManagedMemory(Arch, Runtime) &&
          "Managed memory does not transfer memory between "
          "device and host");
   const char *Name = "polly_copyFromDeviceToHost";

 }
 
 void GPUNodeBuilder::createCallSynchronizeDevice() {
-  assert(PollyManagedMemory && "explicit synchronization is only necessary for "
-                               "managed memory");
+  assert(useManagedMemory(Arch, Runtime) &&
+         "explicit synchronization is only necessary for "
+         "managed memory");
   const char *Name = "polly_synchronizeDevice";
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);

 
 Value *GPUNodeBuilder::getManagedDeviceArray(gpu_array_info *Array,
                                              ScopArrayInfo *ArrayInfo) {
-  assert(PollyManagedMemory && "Only used when you wish to get a host "
-                               "pointer for sending data to the kernel, "
-                               "with managed memory");
+  assert(useManagedMemory(Arch, Runtime) &&
+         "Only used when you wish to get a host "
+         "pointer for sending data to the kernel, "
+         "with managed memory");
   std::map<ScopArrayInfo *, Value *>::iterator it;
   it = DeviceAllocations.find(ArrayInfo);
   assert(it != DeviceAllocations.end() &&

 
 void GPUNodeBuilder::createDataTransfer(__isl_take isl_ast_node *TransferStmt,
                                         enum DataDirection Direction) {
-  assert(!PollyManagedMemory && "Managed memory needs no data transfers");
+  assert(!useManagedMemory(Arch, Runtime) &&
+         "Managed memory needs no data transfers");
   isl_ast_expr *Expr = isl_ast_node_user_get_expr(TransferStmt);
   isl_ast_expr *Arg = isl_ast_expr_get_op_arg(Expr, 0);
   isl_id *Id = isl_ast_expr_get_id(Arg);

   const char *Str = isl_id_get_name(Id);
   if (!strcmp(Str, "kernel")) {
     createKernel(UserStmt);
-    if (PollyManagedMemory)
+    if (useManagedMemory(Arch, Runtime))
       createCallSynchronizeDevice();
     isl_ast_expr_free(Expr);
     return;

     return;
   }
   if (isPrefix(Str, "to_device")) {
-    if (!PollyManagedMemory)
+    if (!useManagedMemory(Arch, Runtime))
       createDataTransfer(UserStmt, HOST_TO_DEVICE);
     else
       isl_ast_node_free(UserStmt);

   }
 
   if (isPrefix(Str, "from_device")) {
-    if (!PollyManagedMemory) {
+    if (!useManagedMemory(Arch, Runtime)) {
       createDataTransfer(UserStmt, DEVICE_TO_HOST);
     } else {
       isl_ast_node_free(UserStmt);

       ArgSizes[Index] = SAI->getElemSizeInBytes();
 
     Value *DevArray = nullptr;
-    if (PollyManagedMemory) {
+    if (useManagedMemory(Arch, Runtime)) {
       DevArray = getManagedDeviceArray(&Prog->array[i],
                                        const_cast<ScopArrayInfo *>(SAI));
     } else {

 
     if (gpu_array_is_read_only_scalar(&Prog->array[i])) {
       Value *ValPtr = nullptr;
-      if (PollyManagedMemory)
+      if (useManagedMemory(Arch, Runtime))
         ValPtr = DevArray;
       else
         ValPtr = BlockGen.getOrCreateAlloca(SAI);

       LLVM_DEBUG(dbgs() << getUniqueScopName(S)
                         << " does not have permutable bands. Bailing out\n";);
     } else {
-      const bool CreateTransferToFromDevice = !PollyManagedMemory;
+      const bool CreateTransferToFromDevice =
+          (!useManagedMemory(Architecture, Runtime));
       Schedule = map_to_device(PPCGGen, Schedule, CreateTransferToFromDevice);
       PPCGGen->tree = generate_code(PPCGGen, isl_schedule_copy(Schedule));
     }

lib/Support/RegisterPasses.cpp

     cl::init(true), cl::cat(PollyCategory));
 
 namespace polly {
+
 void initializePollyPasses(PassRegistry &Registry) {
   initializeCodeGenerationPass(Registry);
 

   if (Target == TARGET_HYBRID) {
     PM.add(
         polly::createPPCGCodeGenerationPass(GPUArchChoice, GPURuntimeChoice));
-    PM.add(polly::createManagedMemoryRewritePassPass(GPUArchChoice,
-                                                     GPURuntimeChoice));
+    if (useManagedMemory(GPUArchChoice, GPURuntimeChoice))
+      PM.add(polly::createManagedMemoryRewritePassPass(GPUArchChoice,
+                                                       GPURuntimeChoice));
   }
 #endif
   if (Target == TARGET_CPU || Target == TARGET_HYBRID)

   else {
     PM.add(
         polly::createPPCGCodeGenerationPass(GPUArchChoice, GPURuntimeChoice));
-    PM.add(polly::createManagedMemoryRewritePassPass());
+    if (useManagedMemory(GPUArchChoice, GPURuntimeChoice))
+      PM.add(polly::createManagedMemoryRewritePassPass());
   }
 #endif