[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

 /// The GPU Architecture to target.
 enum GPUArch { NVPTX64, SPIR32, SPIR64 };
 
 /// The GPU Runtime implementation to use.
 enum GPURuntime { CUDA, OpenCL };
 
 namespace polly {
 extern bool PollyManagedMemory;
-}
+
+/// Check whether we use the right GPU architecture and runtime to generate
+/// CUDA managed memory
+bool useManagedMemory(GPUArch Arch, GPURuntime Runtime);
+} // namespace polly
 
 #endif // POLLY_PPCGCODEGENERATION_H

lib/CodeGen/PPCGCodeGeneration.cpp

 static cl::opt<bool> SharedMemory("polly-acc-use-shared",
                                   cl::desc("Use shared memory"), cl::Hidden,
                                   cl::init(false), cl::ZeroOrMore,
                                   cl::cat(PollyCategory));
 static cl::opt<bool> PrivateMemory("polly-acc-use-private",
                                    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",
                    cl::desc("Generate Host kernel code assuming"
                             " that all memory has been"
                             " declared as managed memory"),
                    cl::location(PollyManagedMemory), cl::Hidden,
                    cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));

 
 /// Return  a unique name for a Scop, which is the scop region with the
 /// function name.
 std::string getUniqueScopName(const Scop *S) {
   return "Scop Region: " + S->getNameStr() +
          " | Function: " + std::string(S->getFunction().getName());
 }
 
+/// Check whether the GPU architecture and runtime are correct to use
+/// CUDA managed memory
+bool polly::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.
 ///
 /// @see computeLiveRangeReordering
 /// @see GPUNodeBuilder::createPPCGScop
 /// @see GPUNodeBuilder::createPPCGProg
 struct MustKillsInfo {
   /// Collection of all kill statements that will be sequenced at the end of

 void GPUNodeBuilder::initializeAfterRTH() {
   BasicBlock *NewBB = SplitBlock(Builder.GetInsertBlock(),
                                  &*Builder.GetInsertPoint(), &DT, &LI);
   NewBB->setName("polly.acc.initialize");
   Builder.SetInsertPoint(&NewBB->front());
 
   GPUContext = createCallInitContext();
 
-  if (!PollyManagedMemory)
+  if (!useManagedMemory(Arch, Runtime))
     allocateDeviceArrays();
   else
     prepareManagedDeviceArrays();
 }
 
 void GPUNodeBuilder::finalize() {
-  if (!PollyManagedMemory)
+  if (!useManagedMemory(Arch, Runtime))
     freeDeviceArrays();
 
   createCallFreeContext(GPUContext);
   IslNodeBuilder::finalize();
 }
 
 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());
 
   for (int i = 0; i < Prog->n_array; ++i) {
     gpu_array_info *Array = &Prog->array[i];
     auto *ScopArray = (ScopArrayInfo *)Array->user;
     std::string DevArrayName("p_dev_array_");
for (int i = 0; i < Prog->n_array; ++i) {
     DevArray->setName(DevArrayName);
     DeviceAllocations[ScopArray] = DevArray;
   }
 
   isl_ast_build_free(Build);
 }
 
 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];
     ScopArrayInfo *ScopArray = (ScopArrayInfo *)Array->user;
     Value *HostPtr;
 
     if (gpu_array_is_scalar(Array))
       HostPtr = BlockGen.getOrCreateAlloca(ScopArray);
Metadata *Elements[] = {
         ValueAsMetadata::get(V[2]),
     };
     MDNode *Node = MDNode::get(M->getContext(), Elements);
     AnnotationNode->addOperand(Node);
   }
 }
 
 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);
 }
 
 Value *GPUNodeBuilder::createCallGetKernel(Value *Buffer, Value *Entry) {
   const char *Name = "polly_getKernel";
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);
if (!F) {
     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Args, false);
     F = Function::Create(Ty, Linkage, Name, M);
   }
 
   Builder.CreateCall(F, {GPUKernel});
 }
 
 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";
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);
 
   // If F is not available, declare it.
   if (!F) {
     GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
     std::vector<Type *> Args;
     Args.push_back(Builder.getInt8PtrTy());
     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Args, false);
     F = Function::Create(Ty, Linkage, Name, M);
   }
 
   Builder.CreateCall(F, {Array});
 }
 
 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";
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);
 
   // If F is not available, declare it.
   if (!F) {
     GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
     std::vector<Type *> Args;
     Args.push_back(Builder.getInt64Ty());
     FunctionType *Ty = FunctionType::get(Builder.getInt8PtrTy(), Args, false);
     F = Function::Create(Ty, Linkage, Name, M);
   }
 
   return Builder.CreateCall(F, {Size});
 }
 
 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";
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);
 
   // If F is not available, declare it.
   if (!F) {
     GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
     std::vector<Type *> Args;
     Args.push_back(Builder.getInt8PtrTy());
     Args.push_back(Builder.getInt8PtrTy());
     Args.push_back(Builder.getInt64Ty());
     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Args, false);
     F = Function::Create(Ty, Linkage, Name, M);
   }
 
   Builder.CreateCall(F, {HostData, DeviceData, Size});
 }
 
 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";
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);
 
   // If F is not available, declare it.
   if (!F) {
     GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
     std::vector<Type *> Args;
     Args.push_back(Builder.getInt8PtrTy());
     Args.push_back(Builder.getInt8PtrTy());
     Args.push_back(Builder.getInt64Ty());
     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Args, false);
     F = Function::Create(Ty, Linkage, Name, M);
   }
 
   Builder.CreateCall(F, {DeviceData, HostData, Size});
 }
 
 void GPUNodeBuilder::createCallSynchronizeDevice() {
-  assert(PollyManagedMemory && "explicit synchronization is only necessary for "
-                               "managed memory");
+  assert(useManagedMemory(Arch, Runtime) &&
+         "explicit synchronization is only necessary for "
   const char *Name = "polly_synchronizeDevice";
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
   Function *F = M->getFunction(Name);
 
   // If F is not available, declare it.
   if (!F) {
     GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), false);
for (long i = 0, n = Min.dim(isl::dim::set); i < n; i++) {
     Result = Result.add(MExpr);
   }
 
   return ExprBuilder.create(Result.release());
 }
 
 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 "
   std::map<ScopArrayInfo *, Value *>::iterator it;
   it = DeviceAllocations.find(ArrayInfo);
   assert(it != DeviceAllocations.end() &&
          "Device array expected to be available");
   return it->second;
 }
 
 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);
   auto Array = (gpu_array_info *)isl_id_get_user(Id);
   auto ScopArray = (ScopArrayInfo *)(Array->user);
 
   Value *Size = getArraySize(Array);
   Value *Offset = getArrayOffset(Array);
void GPUNodeBuilder::createUser(__isl_take isl_ast_node *UserStmt) {
   isl_ast_expr *StmtExpr = isl_ast_expr_get_op_arg(Expr, 0);
   isl_id *Id = isl_ast_expr_get_id(StmtExpr);
   isl_id_free(Id);
   isl_ast_expr_free(StmtExpr);
 
   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;
   }
   if (!strcmp(Str, "init_device")) {
     initializeAfterRTH();
     isl_ast_node_free(UserStmt);
     isl_ast_expr_free(Expr);
     return;
   }
   if (!strcmp(Str, "clear_device")) {
     finalize();
     isl_ast_node_free(UserStmt);
     isl_ast_expr_free(Expr);
     return;
   }
   if (isPrefix(Str, "to_device")) {
-    if (!PollyManagedMemory)
+    if (!useManagedMemory(Arch, Runtime))
       createDataTransfer(UserStmt, HOST_TO_DEVICE);
     else
       isl_ast_node_free(UserStmt);
 
     isl_ast_expr_free(Expr);
     return;
   }
 
   if (isPrefix(Str, "from_device")) {
-    if (!PollyManagedMemory) {
+    if (!useManagedMemory(Arch, Runtime)) {
       createDataTransfer(UserStmt, DEVICE_TO_HOST);
     } else {
       isl_ast_node_free(UserStmt);
     }
     isl_ast_expr_free(Expr);
     return;
   }
 
for (long i = 0; i < Prog->n_array; i++) {
 
     isl_id *Id = isl_space_get_tuple_id(Prog->array[i].space, isl_dim_set);
     const ScopArrayInfo *SAI = ScopArrayInfo::getFromId(isl::manage(Id));
 
     if (Runtime == GPURuntime::OpenCL)
       ArgSizes[Index] = SAI->getElemSizeInBytes();
 
     Value *DevArray = nullptr;
-    if (PollyManagedMemory) {
+    if (useManagedMemory(Arch, Runtime)) {
       DevArray = getManagedDeviceArray(&Prog->array[i],
                                        const_cast<ScopArrayInfo *>(SAI));
     } else {
       DevArray = DeviceAllocations[const_cast<ScopArrayInfo *>(SAI)];
       DevArray = createCallGetDevicePtr(DevArray);
     }
     assert(DevArray != nullptr && "Array to be offloaded to device not "
                                   "initialized");
     Value *Offset = getArrayOffset(&Prog->array[i]);
 
     if (Offset) {
       DevArray = Builder.CreatePointerCast(
           DevArray, SAI->getElementType()->getPointerTo());
       DevArray = Builder.CreateGEP(DevArray, Builder.CreateNeg(Offset));
       DevArray = Builder.CreatePointerCast(DevArray, Builder.getInt8PtrTy());
     }
     Value *Slot = Builder.CreateGEP(
         Parameters, {Builder.getInt64(0), Builder.getInt64(Index)});
 
     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);
 
       assert(ValPtr != nullptr && "ValPtr that should point to a valid object"
                                   " to be stored into Parameters");
       Value *ValPtrCast =
           Builder.CreatePointerCast(ValPtr, Builder.getInt8PtrTy());
gpu_gen *generateGPU(ppcg_scop *PPCGScop, gpu_prog *PPCGProg) {
     Schedule =
         isl_schedule_align_params(Schedule, S->getFullParamSpace().release());
 
     if (!has_permutable || has_permutable < 0) {
       Schedule = isl_schedule_free(Schedule);
       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));
     }
 
     if (DumpSchedule) {
       isl_printer *P = isl_printer_to_str(S->getIslCtx().get());
       P = isl_printer_set_yaml_style(P, ISL_YAML_STYLE_BLOCK);
       P = isl_printer_print_str(P, "Schedule\n");
if (!NodeBuilder.BuildSuccessful)
       CondBr->setOperand(0, Builder.getFalse());
   }
 
   bool runOnScop(Scop &CurrentScop) override {
     S = &CurrentScop;
     LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
     DL = &S->getRegion().getEntry()->getModule()->getDataLayout();
     RI = &getAnalysis<RegionInfoPass>().getRegionInfo();
 
     LLVM_DEBUG(dbgs() << "PPCGCodeGen running on : " << getUniqueScopName(S)
                       << " | loop depth: " << S->getMaxLoopDepth() << "\n");
 
     // We currently do not support functions other than intrinsics inside
     // kernels, as code generation will need to offload function calls to the
     // kernel. This may lead to a kernel trying to call a function on the host.

lib/Support/RegisterPasses.cpp

EnableSimplify("polly-enable-simplify",
                    cl::init(true), cl::cat(PollyCategory));
 
 static cl::opt<bool> EnablePruneUnprofitable(
     "polly-enable-prune-unprofitable",
     cl::desc("Bail out on unprofitable SCoPs before rescheduling"), cl::Hidden,
     cl::init(true), cl::cat(PollyCategory));
 
 namespace polly {
 void initializePollyPasses(PassRegistry &Registry) {
   initializeCodeGenerationPass(Registry);
 
 #ifdef GPU_CODEGEN
   initializePPCGCodeGenerationPass(Registry);
   initializeManagedMemoryRewritePassPass(Registry);
   LLVMInitializeNVPTXTarget();
   LLVMInitializeNVPTXTargetInfo();
   LLVMInitializeNVPTXTargetMC();
void registerPollyPasses(llvm::legacy::PassManagerBase &PM) {
 
   if (EnablePruneUnprofitable)
     PM.add(polly::createPruneUnprofitablePass());
 
 #ifdef GPU_CODEGEN
   if (Target == TARGET_HYBRID) {
     PM.add(
         polly::createPPCGCodeGenerationPass(GPUArchChoice, GPURuntimeChoice));
+    if (useManagedMemory(GPUArchChoice, GPURuntimeChoice))
       PM.add(polly::createManagedMemoryRewritePassPass(GPUArchChoice,
                                                        GPURuntimeChoice));
   }
 #endif
   if (Target == TARGET_CPU || Target == TARGET_HYBRID)
     switch (Optimizer) {
     case OPTIMIZER_NONE:
       break; /* Do nothing */
 
     case OPTIMIZER_ISL:
case CODEGEN_FULL:
       break;
     case CODEGEN_NONE:
       break;
     }
 #ifdef GPU_CODEGEN
   else {
     PM.add(
         polly::createPPCGCodeGenerationPass(GPUArchChoice, GPURuntimeChoice));
+    if (useManagedMemory(GPUArchChoice, GPURuntimeChoice))
       PM.add(polly::createManagedMemoryRewritePassPass());
   }
 #endif
 
   // FIXME: This dummy ModulePass keeps some programs from miscompiling,
   // probably some not correctly preserved analyses. It acts as a barrier to
   // force all analysis results to be recomputed.
   PM.add(createBarrierNoopPass());