[mlir][openacc] Translate UpdateOp to LLVM IR

[clementval]

Summary

Add translation to LLVM IR for the UpdateOp with host and device operands.
Translation is done with call using the runtime. This is done in a similar way as
D101504 and D102381.

[clementval]

Simplify test case and update after D102381 updates.

[ftynse]

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

37

Naming nit, we tend to use the kGlobalConstantName style.

[clementval]

Rebase + address nit

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

 
 using OpenACCIRBuilder = llvm::OpenMPIRBuilder;
 
 //===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//
 
 /// 0 = alloc/create
-static constexpr uint64_t createFlag = 0;
-/// 1 = to/copyin
-static constexpr uint64_t copyinFlag = 1;
+static constexpr uint64_t kCreateFlag = 0;
+/// 1 = to/device/copyin
+static constexpr uint64_t kDeviceCopyinFlag = 1;
 /// 2 = from/copyout
-static constexpr uint64_t copyoutFlag = 2;
+static constexpr uint64_t kHostCopyoutFlag = 2;
 /// 8 = delete
-static constexpr uint64_t deleteFlag = 8;
+static constexpr uint64_t kDeleteFlag = 8;
 
 /// Default value for the device id
-static constexpr int64_t defaultDevice = -1;
+static constexpr int64_t kDefaultDevice = -1;
 
 /// Create a constant string location from the MLIR Location information.
 static llvm::Constant *createSourceLocStrFromLocation(Location loc,
                                                       OpenACCIRBuilder &builder,
                                                       StringRef name) {
   if (auto fileLoc = loc.dyn_cast<FileLineColLoc>()) {
     StringRef fileName = fileLoc.getFilename();
     unsigned lineNo = fileLoc.getLine();
static llvm::Function *getAssociatedFunction(OpenACCIRBuilder &builder,
   return llvm::TypeSwitch<Operation *, llvm::Function *>(op)
       .Case([&](acc::EnterDataOp) {
         return builder.getOrCreateRuntimeFunctionPtr(
             llvm::omp::OMPRTL___tgt_target_data_begin_mapper);
       })
       .Case([&](acc::ExitDataOp) {
         return builder.getOrCreateRuntimeFunctionPtr(
             llvm::omp::OMPRTL___tgt_target_data_end_mapper);
+      })
+      .Case([&](acc::UpdateOp) {
+        return builder.getOrCreateRuntimeFunctionPtr(
+            llvm::omp::OMPRTL___tgt_target_data_update_mapper);
       });
   llvm_unreachable("Unknown OpenACC operation");
 }
 
 /// Computes the size of type in bytes.
 static llvm::Value *getSizeInBytes(llvm::IRBuilderBase &builder,
                                    llvm::Value *basePtr) {
   llvm::LLVMContext &ctx = builder.getContext();
processDataOperands(llvm::IRBuilderBase &builder,
                     SmallVector<llvm::Constant *> &names, unsigned &index,
                     llvm::AllocaInst *argsBase, llvm::AllocaInst *args,
                     llvm::AllocaInst *argSizes) {
   // TODO add `create_zero` and `attach` operands
 
   // Create operands are handled as `alloc` call.
   if (failed(processOperands(builder, moduleTranslation, op,
                              op.createOperands(), op.getNumDataOperands(),
-                             createFlag, flags, names, index, argsBase, args,
+                             kCreateFlag, flags, names, index, argsBase, args,
                              argSizes)))
     return failure();
 
   // Copyin operands are handled as `to` call.
   if (failed(processOperands(builder, moduleTranslation, op,
                              op.copyinOperands(), op.getNumDataOperands(),
-                             copyinFlag, flags, names, index, argsBase, args,
-                             argSizes)))
+                             kDeviceCopyinFlag, flags, names, index, argsBase,
+                             args, argSizes)))
     return failure();
 
   return success();
 }
 
 /// Process data operands from acc::ExitDataOp
 static LogicalResult
 processDataOperands(llvm::IRBuilderBase &builder,
                     LLVM::ModuleTranslation &moduleTranslation,
                     acc::ExitDataOp op, SmallVector<uint64_t> &flags,
                     SmallVector<llvm::Constant *> &names, unsigned &index,
                     llvm::AllocaInst *argsBase, llvm::AllocaInst *args,
                     llvm::AllocaInst *argSizes) {
   // TODO add `detach` operands
 
   // Delete operands are handled as `delete` call.
   if (failed(processOperands(builder, moduleTranslation, op,
                              op.deleteOperands(), op.getNumDataOperands(),
-                             deleteFlag, flags, names, index, argsBase, args,
+                             kDeleteFlag, flags, names, index, argsBase, args,
                              argSizes)))
     return failure();
 
   // Copyout operands are handled as `from` call.
   if (failed(processOperands(builder, moduleTranslation, op,
                              op.copyoutOperands(), op.getNumDataOperands(),
-                             copyoutFlag, flags, names, index, argsBase, args,
-                             argSizes)))
+                             kHostCopyoutFlag, flags, names, index, argsBase,
+                             args, argSizes)))
+    return failure();
+
+  return success();
+}
+
+/// Process data operands from acc::UpdateOp
+static LogicalResult
+processDataOperands(llvm::IRBuilderBase &builder,
+                    LLVM::ModuleTranslation &moduleTranslation,
+                    acc::UpdateOp op, SmallVector<uint64_t> &flags,
+                    SmallVector<llvm::Constant *> &names, unsigned &index,
+                    llvm::AllocaInst *argsBase, llvm::AllocaInst *args,
+                    llvm::AllocaInst *argSizes) {
+
+  // Host operands are handled as `from` call.
+  if (failed(processOperands(builder, moduleTranslation, op, op.hostOperands(),
+                             op.getNumDataOperands(), kHostCopyoutFlag, flags,
+                             names, index, argsBase, args, argSizes)))
+    return failure();
+
+  // Device operands are handled as `to` call.
+  if (failed(processOperands(builder, moduleTranslation, op,
+                             op.deviceOperands(), op.getNumDataOperands(),
+                             kDeviceCopyinFlag, flags, names, index, argsBase,
+                             args, argSizes)))
     return failure();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Conversion functions
 //===----------------------------------------------------------------------===//
convertStandaloneDataOp(OpTy &op, llvm::IRBuilderBase &builder,
   llvm::Value *argsGEP = builder.CreateInBoundsGEP(
       arrI8PtrTy, args, {builder.getInt32(0), builder.getInt32(0)});
   llvm::Value *argSizesGEP = builder.CreateInBoundsGEP(
       arrI64Ty, argSizes, {builder.getInt32(0), builder.getInt32(0)});
   llvm::Value *nullPtr = llvm::Constant::getNullValue(
       llvm::Type::getInt8PtrTy(ctx)->getPointerTo());
 
   builder.CreateCall(mapperFunc,
-                     {srcLocInfo, builder.getInt64(defaultDevice),
+                     {srcLocInfo, builder.getInt64(kDefaultDevice),
                       builder.getInt32(totalNbOperand), argsBaseGEP, argsGEP,
                       argSizesGEP, maptypesArg, mapnamesArg, nullPtr});
 
   return success();
 }
 
 namespace {
 
return llvm::TypeSwitch<Operation *, LogicalResult>(op)
       .Case([&](acc::EnterDataOp enterDataOp) {
         return convertStandaloneDataOp<acc::EnterDataOp>(enterDataOp, builder,
                                                          moduleTranslation);
       })
       .Case([&](acc::ExitDataOp exitDataOp) {
         return convertStandaloneDataOp<acc::ExitDataOp>(exitDataOp, builder,
                                                         moduleTranslation);
       })
+      .Case([&](acc::UpdateOp updateOp) {
+        return convertStandaloneDataOp<acc::UpdateOp>(updateOp, builder,
+                                                      moduleTranslation);
+      })
       .Default([&](Operation *op) {
         return op->emitError("unsupported OpenACC operation: ")
                << op->getName();
       });
 }
 
 void mlir::registerOpenACCDialectTranslation(DialectRegistry &registry) {
   registry.insert<acc::OpenACCDialect>();

mlir/test/Target/LLVMIR/openacc-llvm.mlir

 
 // CHECK: [[ARGBASE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 0
 // CHECK: [[ARG_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 0
 // CHECK: [[SIZE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 0
 
 // CHECK: call void @__tgt_target_data_end_mapper(%struct.ident_t* [[LOCGLOBAL]], i64 -1, i32 2, i8** [[ARGBASE_ALLOCA_GEP]], i8** [[ARG_ALLOCA_GEP]], i64* [[SIZE_ALLOCA_GEP]], i64* getelementptr inbounds ([{{[0-9]*}} x i64], [{{[0-9]*}} x i64]* [[MAPTYPES]], i32 0, i32 0), i8** getelementptr inbounds ([{{[0-9]*}} x i8*], [{{[0-9]*}} x i8*]* [[MAPNAMES]], i32 0, i32 0), i8** null)
 
 // CHECK: declare void @__tgt_target_data_end_mapper(%struct.ident_t*, i64, i32, i8**, i8**, i64*, i64*, i8**, i8**) #0
+
+// -----
+
+llvm.func @testupdateop(%arg0: !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, %arg1: !llvm.ptr<f32>) {
+  %0 = llvm.mlir.constant(10 : index) : i64
+  %1 = llvm.mlir.null : !llvm.ptr<f32>
+  %2 = llvm.getelementptr %1[%0] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
+  %3 = llvm.ptrtoint %2 : !llvm.ptr<f32> to i64
+  %4 = llvm.extractvalue %arg0[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
+  %5 = llvm.mlir.undef : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %6 = llvm.insertvalue %arg0, %5[0] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %7 = llvm.insertvalue %4, %6[1] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  %8 = llvm.insertvalue %3, %7[2] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
+  acc.update host(%8 : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) device(%arg1 : !llvm.ptr<f32>)
+  llvm.return
+}
+
+// CHECK: %struct.ident_t = type { i32, i32, i32, i32, i8* }
+
+// CHECK: [[LOCSTR:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};testupdateop;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: [[LOCGLOBAL:@.*]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([{{[0-9]*}} x i8], [{{[0-9]*}} x i8]* [[LOCSTR]], i32 0, i32 0) }, align 8
+// CHECK: [[MAPNAME1:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: [[MAPNAME2:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: [[MAPTYPES:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i64] [i64 2, i64 1]
+// CHECK: [[MAPNAMES:@.*]] = private constant [{{[0-9]*}} x i8*] [i8* getelementptr inbounds ([{{[0-9]*}} x i8], [{{[0-9]*}} x i8]* [[MAPNAME1]], i32 0, i32 0), i8* getelementptr inbounds ([{{[0-9]*}} x i8], [{{[0-9]*}} x i8]* [[MAPNAME2]], i32 0, i32 0)]
+
+// CHECK: define void @testupdateop({ float*, float*, i64, [1 x i64], [1 x i64] } %{{.*}}, float* [[SIMPLEPTR:%.*]])
+// CHECK: [[ARGBASE_ALLOCA:%.*]] = alloca [{{[0-9]*}} x i8*], align 8
+// CHECK: [[ARG_ALLOCA:%.*]] = alloca [{{[0-9]*}} x i8*], align 8
+// CHECK: [[SIZE_ALLOCA:%.*]] = alloca [{{[0-9]*}} x i64], align 8
+
+// CHECK: [[ARGBASE:%.*]] = extractvalue %openacc_data %{{.*}}, 0
+// CHECK: [[ARG:%.*]] = extractvalue %openacc_data %{{.*}}, 1
+// CHECK: [[ARGSIZE:%.*]] = extractvalue %openacc_data %{{.*}}, 2
+// CHECK: [[ARGBASEGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 0
+// CHECK: [[ARGBASEGEPCAST:%.*]] = bitcast i8** [[ARGBASEGEP]] to { float*, float*, i64, [1 x i64], [1 x i64] }*
+// CHECK: store { float*, float*, i64, [1 x i64], [1 x i64] } [[ARGBASE]], { float*, float*, i64, [1 x i64], [1 x i64] }* [[ARGBASEGEPCAST]], align 8
+// CHECK: [[ARGGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 0
+// CHECK: [[ARGGEPCAST:%.*]] = bitcast i8** [[ARGGEP]] to float**
+// CHECK: store float* [[ARG]], float** [[ARGGEPCAST]], align 8
+// CHECK: [[SIZEGEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 0
+// CHECK: store i64 [[ARGSIZE]], i64* [[SIZEGEP]], align 4
+
+// CHECK: [[ARGBASEGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 1
+// CHECK: [[ARGBASEGEPCAST:%.*]] = bitcast i8** [[ARGBASEGEP]] to float**
+// CHECK: store float* [[SIMPLEPTR]], float** [[ARGBASEGEPCAST]], align 8
+// CHECK: [[ARGGEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 1
+// CHECK: [[ARGGEPCAST:%.*]] = bitcast i8** [[ARGGEP]] to float**
+// CHECK: store float* [[SIMPLEPTR]], float** [[ARGGEPCAST]], align 8
+// CHECK: [[SIZEGEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 1
+// CHECK: store i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64* [[SIZEGEP]], align 4
+
+// CHECK: [[ARGBASE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARGBASE_ALLOCA]], i32 0, i32 0
+// CHECK: [[ARG_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[ARG_ALLOCA]], i32 0, i32 0
+// CHECK: [[SIZE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i64], [2 x i64]* [[SIZE_ALLOCA]], i32 0, i32 0
+
+// CHECK: call void @__tgt_target_data_update_mapper(%struct.ident_t* [[LOCGLOBAL]], i64 -1, i32 2, i8** [[ARGBASE_ALLOCA_GEP]], i8** [[ARG_ALLOCA_GEP]], i64* [[SIZE_ALLOCA_GEP]], i64* getelementptr inbounds ([{{[0-9]*}} x i64], [{{[0-9]*}} x i64]* [[MAPTYPES]], i32 0, i32 0), i8** getelementptr inbounds ([{{[0-9]*}} x i8*], [{{[0-9]*}} x i8*]* [[MAPNAMES]], i32 0, i32 0), i8** null)
+
+// CHECK: declare void @__tgt_target_data_update_mapper(%struct.ident_t*, i64, i32, i8**, i8**, i64*, i64*, i8**, i8**) #0