This is an archive of the discontinued LLVM Phabricator instance.

Differential D144462

[mlir][OpenACCToLLVM] Add pass option to emit opaque pointers
ClosedPublic

Authored by zero9178 on Feb 21 2023, 2:09 AM.

Details

Reviewers
clementval
ftynse
mehdi_amini
kiranchandramohan
schweitz
gysit
dcaballe
Commits
rGb068c87f182d: [mlir][OpenACCToLLVM] Add pass option to emit opaque pointers
Summary

Part of https://discourse.llvm.org/t/rfc-switching-the-llvm-dialect-and-dialect-lowerings-to-opaque-pointers/68179

This patch simply adds the pass option use-opaque-pointers to instruct the pass to use opaque-pointers instead of typed pointers during conversion.
The pass itself does not actually make use of any pointers or anything, so did not require any changes except simply setting the option in the type converter. The tests have also been converted to using opaque-pointers

Diff Detail

Event Timeline

zero9178 created this revision.Feb 21 2023, 2:09 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 21 2023, 2:09 AM
Herald added subscribers: Moerafaat, bzcheeseman, awarzynski and 20 others. · View Herald Transcript
zero9178 requested review of this revision.Feb 21 2023, 2:09 AM
Herald added a reviewer: dcaballe. · View Herald TranscriptFeb 21 2023, 2:09 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
gysit accepted this revision.Feb 21 2023, 2:30 AM

LGTM!

This revision is now accepted and ready to land.Feb 21 2023, 2:30 AM
clementval accepted this revision.Feb 21 2023, 2:33 AM

LGTM

Harbormaster completed remote builds in B214962: Diff 499088.Feb 21 2023, 3:15 AM
Closed by commit rGb068c87f182d: [mlir][OpenACCToLLVM] Add pass option to emit opaque pointers (authored by zero9178). · Explain WhyFeb 21 2023, 5:06 AM
This revision was automatically updated to reflect the committed changes.
zero9178 added a commit: rGb068c87f182d: [mlir][OpenACCToLLVM] Add pass option to emit opaque pointers.

Revision Contents

PathSize
mlir/
include/
mlir/
Conversion/
5 lines
lib/
Conversion/
OpenACCToLLVM/
4 lines
test/
Conversion/
OpenACCToLLVM/
76 lines

Diff 499117

mlir/include/mlir/Conversion/Passes.td

Show First 20 Lines • Show All 684 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// OpenACCToLLVM // OpenACCToLLVM
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertOpenACCToLLVMPass : Pass<"convert-openacc-to-llvm", "ModuleOp"> { def ConvertOpenACCToLLVMPass : Pass<"convert-openacc-to-llvm", "ModuleOp"> {
let summary = "Convert the OpenACC ops to LLVM dialect"; let summary = "Convert the OpenACC ops to LLVM dialect";
let dependentDialects = ["LLVM::LLVMDialect"]; let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"useOpaquePointers", "use-opaque-pointers", "bool",
/*default=*/"false", "Generate LLVM IR using opaque pointers "
"instead of typed pointers">,
];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// OpenMPToLLVM // OpenMPToLLVM
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertOpenMPToLLVMPass : Pass<"convert-openmp-to-llvm", "ModuleOp"> { def ConvertOpenMPToLLVMPass : Pass<"convert-openmp-to-llvm", "ModuleOp"> {
let summary = "Convert the OpenMP ops to OpenMP ops with LLVM dialect"; let summary = "Convert the OpenMP ops to OpenMP ops with LLVM dialect";
▲ Show 20 Lines • Show All 376 Lines • Show Last 20 Lines

mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void ConvertOpenACCToLLVMPass::runOnOperation() { void ConvertOpenACCToLLVMPass::runOnOperation() {
auto op = getOperation(); auto op = getOperation();
auto *context = op.getContext(); auto *context = op.getContext();
// Convert to OpenACC operations with LLVM IR dialect // Convert to OpenACC operations with LLVM IR dialect
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
LLVMTypeConverter converter(context); LowerToLLVMOptions options(context);
options.useOpaquePointers = useOpaquePointers;
LLVMTypeConverter converter(context, options);
populateOpenACCToLLVMConversionPatterns(converter, patterns); populateOpenACCToLLVMConversionPatterns(converter, patterns);
ConversionTarget target(*context); ConversionTarget target(*context);
target.addLegalDialect<LLVM::LLVMDialect>(); target.addLegalDialect<LLVM::LLVMDialect>();
target.addLegalOp<UnrealizedConversionCastOp>(); target.addLegalOp<UnrealizedConversionCastOp>();
auto allDataOperandsAreConverted = [](ValueRange operands) { auto allDataOperandsAreConverted = [](ValueRange operands) {
for (Value operand : operands) { for (Value operand : operands) {
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

mlir/test/Conversion/OpenACCToLLVM/convert-data-operands-to-llvmir.mlir

// RUN: mlir-opt -convert-openacc-to-llvm -split-input-file %s | FileCheck %s // RUN: mlir-opt -convert-openacc-to-llvm='use-opaque-pointers=1' -split-input-file %s | FileCheck %s
func.func @testenterdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testenterdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.enter_data copyin(%b : memref<10xf32>) create(%a : memref<10xf32>) acc.enter_data copyin(%b : memref<10xf32>) create(%a : memref<10xf32>)
return return
} }
// CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) create(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testenterdataop(%a: !llvm.ptr<f32>, %b: memref<10xf32>) -> () { func.func @testenterdataop(%a: !llvm.ptr, %b: memref<10xf32>) -> () {
acc.enter_data copyin(%b : memref<10xf32>) create(%a : !llvm.ptr<f32>) acc.enter_data copyin(%b : memref<10xf32>) create(%a : !llvm.ptr)
return return
} }
// CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) create(%{{.*}} : !llvm.ptr<f32>) // CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create(%{{.*}} : !llvm.ptr)
// ----- // -----
func.func @testenterdataop(%a: memref<10xi64>, %b: memref<10xf32>) -> () { func.func @testenterdataop(%a: memref<10xi64>, %b: memref<10xf32>) -> () {
acc.enter_data copyin(%b : memref<10xf32>) create_zero(%a : memref<10xi64>) attributes {async} acc.enter_data copyin(%b : memref<10xf32>) create_zero(%a : memref<10xi64>) attributes {async}
return return
} }
// CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) create_zero(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>, ptr<i64>, i64)>) attributes {async} // CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create_zero(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) attributes {async}
// ----- // -----
func.func @testenterdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testenterdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
%ifCond = arith.constant true %ifCond = arith.constant true
acc.enter_data if(%ifCond) copyin(%b : memref<10xf32>) create(%a : memref<10xf32>) acc.enter_data if(%ifCond) copyin(%b : memref<10xf32>) create(%a : memref<10xf32>)
return return
} }
// CHECK: acc.enter_data if(%{{.*}}) copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) create(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.enter_data if(%{{.*}}) copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testexitdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testexitdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.exit_data copyout(%b : memref<10xf32>) delete(%a : memref<10xf32>) acc.exit_data copyout(%b : memref<10xf32>) delete(%a : memref<10xf32>)
return return
} }
// CHECK: acc.exit_data copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) delete(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.exit_data copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) delete(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testexitdataop(%a: !llvm.ptr<f32>, %b: memref<10xf32>) -> () { func.func @testexitdataop(%a: !llvm.ptr, %b: memref<10xf32>) -> () {
acc.exit_data copyout(%b : memref<10xf32>) delete(%a : !llvm.ptr<f32>) acc.exit_data copyout(%b : memref<10xf32>) delete(%a : !llvm.ptr)
return return
} }
// CHECK: acc.exit_data copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) delete(%{{.*}} : !llvm.ptr<f32>) // CHECK: acc.exit_data copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) delete(%{{.*}} : !llvm.ptr)
// ----- // -----
func.func @testexitdataop(%a: memref<10xi64>, %b: memref<10xf32>) -> () { func.func @testexitdataop(%a: memref<10xi64>, %b: memref<10xf32>) -> () {
acc.exit_data copyout(%b : memref<10xf32>) delete(%a : memref<10xi64>) attributes {async} acc.exit_data copyout(%b : memref<10xf32>) delete(%a : memref<10xi64>) attributes {async}
return return
} }
// CHECK: acc.exit_data copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) delete(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>, ptr<i64>, i64)>) attributes {async} // CHECK: acc.exit_data copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) delete(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) attributes {async}
// ----- // -----
func.func @testexitdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testexitdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
%ifCond = arith.constant true %ifCond = arith.constant true
acc.exit_data if(%ifCond) copyout(%b : memref<10xf32>) delete(%a : memref<10xf32>) acc.exit_data if(%ifCond) copyout(%b : memref<10xf32>) delete(%a : memref<10xf32>)
return return
} }
// CHECK: acc.exit_data if(%{{.*}}) copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) delete(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.exit_data if(%{{.*}}) copyout(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) delete(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testupdateop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testupdateop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.update host(%b : memref<10xf32>) device(%a : memref<10xf32>) acc.update host(%b : memref<10xf32>) device(%a : memref<10xf32>)
return return
} }
// CHECK: acc.update host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) device(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.update host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) device(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testupdateop(%a: !llvm.ptr<f32>, %b: memref<10xf32>) -> () { func.func @testupdateop(%a: !llvm.ptr, %b: memref<10xf32>) -> () {
acc.update host(%b : memref<10xf32>) device(%a : !llvm.ptr<f32>) acc.update host(%b : memref<10xf32>) device(%a : !llvm.ptr)
return return
} }
// CHECK: acc.update host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) device(%{{.*}} : !llvm.ptr<f32>) // CHECK: acc.update host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) device(%{{.*}} : !llvm.ptr)
// ----- // -----
func.func @testupdateop(%a: memref<10xi64>, %b: memref<10xf32>) -> () { func.func @testupdateop(%a: memref<10xi64>, %b: memref<10xf32>) -> () {
acc.update host(%b : memref<10xf32>) device(%a : memref<10xi64>) attributes {async} acc.update host(%b : memref<10xf32>) device(%a : memref<10xi64>) attributes {async}
return return
} }
// CHECK: acc.update host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) device(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>, ptr<i64>, i64)>) attributes {async} // CHECK: acc.update host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) device(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) attributes {async}
// ----- // -----
func.func @testupdateop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testupdateop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
%ifCond = arith.constant true %ifCond = arith.constant true
acc.update if(%ifCond) host(%b : memref<10xf32>) device(%a : memref<10xf32>) acc.update if(%ifCond) host(%b : memref<10xf32>) device(%a : memref<10xf32>)
return return
} }
// CHECK: acc.update if(%{{.*}}) host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) device(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.update if(%{{.*}}) host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) device(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testdataregion(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testdataregion(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.data copy(%b : memref<10xf32>) copyout(%a : memref<10xf32>) { acc.data copy(%b : memref<10xf32>) copyout(%a : memref<10xf32>) {
} }
return return
} }
// CHECK: acc.data copy(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) copyout(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.data copy(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) copyout(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testdataregion(%a: !llvm.ptr<f32>, %b: memref<10xf32>, %c: !llvm.ptr<f32>) -> () { func.func @testdataregion(%a: !llvm.ptr, %b: memref<10xf32>, %c: !llvm.ptr) -> () {
acc.data copyin(%b : memref<10xf32>) deviceptr(%c: !llvm.ptr<f32>) attach(%a : !llvm.ptr<f32>) { acc.data copyin(%b : memref<10xf32>) deviceptr(%c: !llvm.ptr) attach(%a : !llvm.ptr) {
} }
return return
} }
// CHECK: acc.data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) deviceptr(%{{.*}} : !llvm.ptr<f32>) attach(%{{.*}} : !llvm.ptr<f32>) // CHECK: acc.data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) deviceptr(%{{.*}} : !llvm.ptr) attach(%{{.*}} : !llvm.ptr)
// ----- // -----
func.func @testdataregion(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testdataregion(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
%ifCond = arith.constant true %ifCond = arith.constant true
acc.data if(%ifCond) copyin_readonly(%b : memref<10xf32>) copyout_zero(%a : memref<10xf32>) { acc.data if(%ifCond) copyin_readonly(%b : memref<10xf32>) copyout_zero(%a : memref<10xf32>) {
} }
return return
} }
// CHECK: acc.data if(%{{.*}}) copyin_readonly(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) copyout_zero(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.data if(%{{.*}}) copyin_readonly(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) copyout_zero(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testdataregion(%a: !llvm.ptr<f32>, %b: memref<10xf32>, %c: !llvm.ptr<f32>) -> () { func.func @testdataregion(%a: !llvm.ptr, %b: memref<10xf32>, %c: !llvm.ptr) -> () {
acc.data create(%b : memref<10xf32>) create_zero(%c: !llvm.ptr<f32>) no_create(%a : !llvm.ptr<f32>) { acc.data create(%b : memref<10xf32>) create_zero(%c: !llvm.ptr) no_create(%a : !llvm.ptr) {
} }
return return
} }
// CHECK: acc.data create(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) create_zero(%{{.*}} : !llvm.ptr<f32>) no_create(%{{.*}} : !llvm.ptr<f32>) // CHECK: acc.data create(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create_zero(%{{.*}} : !llvm.ptr) no_create(%{{.*}} : !llvm.ptr)
// ----- // -----
func.func @testdataregion(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testdataregion(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.data present(%a, %b : memref<10xf32>, memref<10xf32>) { acc.data present(%a, %b : memref<10xf32>, memref<10xf32>) {
} }
return return
} }
// CHECK: acc.data present(%{{.*}}, %{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>, !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.data present(%{{.*}}, %{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>, !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.parallel copy(%b : memref<10xf32>) copyout(%a : memref<10xf32>) { acc.parallel copy(%b : memref<10xf32>) copyout(%a : memref<10xf32>) {
} }
return return
} }
// CHECK: acc.parallel copy(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) copyout(%{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.parallel copy(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) copyout(%{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testparallelop(%a: !llvm.ptr<f32>, %b: memref<10xf32>, %c: !llvm.ptr<f32>) -> () { func.func @testparallelop(%a: !llvm.ptr, %b: memref<10xf32>, %c: !llvm.ptr) -> () {
acc.parallel copyin(%b : memref<10xf32>) deviceptr(%c: !llvm.ptr<f32>) attach(%a : !llvm.ptr<f32>) { acc.parallel copyin(%b : memref<10xf32>) deviceptr(%c: !llvm.ptr) attach(%a : !llvm.ptr) {
} }
return return
} }
// CHECK: acc.parallel copyin(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) deviceptr(%{{.*}}: !llvm.ptr<f32>) attach(%{{.*}}: !llvm.ptr<f32>) // CHECK: acc.parallel copyin(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) deviceptr(%{{.*}}: !llvm.ptr) attach(%{{.*}}: !llvm.ptr)
// ----- // -----
func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
%ifCond = arith.constant true %ifCond = arith.constant true
acc.parallel if(%ifCond) copyin_readonly(%b : memref<10xf32>) copyout_zero(%a : memref<10xf32>) { acc.parallel if(%ifCond) copyin_readonly(%b : memref<10xf32>) copyout_zero(%a : memref<10xf32>) {
} }
return return
} }
// CHECK: acc.parallel if(%{{.*}}) copyin_readonly(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) copyout_zero(%{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.parallel if(%{{.*}}) copyin_readonly(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) copyout_zero(%{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testparallelop(%a: !llvm.ptr<f32>, %b: memref<10xf32>, %c: !llvm.ptr<f32>) -> () { func.func @testparallelop(%a: !llvm.ptr, %b: memref<10xf32>, %c: !llvm.ptr) -> () {
acc.parallel create(%b : memref<10xf32>) create_zero(%c: !llvm.ptr<f32>) no_create(%a : !llvm.ptr<f32>) { acc.parallel create(%b : memref<10xf32>) create_zero(%c: !llvm.ptr) no_create(%a : !llvm.ptr) {
} }
return return
} }
// CHECK: acc.parallel create(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) create_zero(%{{.*}}: !llvm.ptr<f32>) no_create(%{{.*}}: !llvm.ptr<f32>) // CHECK: acc.parallel create(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create_zero(%{{.*}}: !llvm.ptr) no_create(%{{.*}}: !llvm.ptr)
// ----- // -----
func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.parallel present(%a: memref<10xf32>, %b: memref<10xf32>) { acc.parallel present(%a: memref<10xf32>, %b: memref<10xf32>) {
} }
return return
} }
// CHECK: acc.parallel present(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>, %{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.parallel present(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>, %{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// ----- // -----
func.func @testparallelop(%i: i64, %a: memref<10xf32>, %b: memref<10xf32>) -> () { func.func @testparallelop(%i: i64, %a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.parallel num_gangs(%i: i64) present(%a: memref<10xf32>, %b: memref<10xf32>) { acc.parallel num_gangs(%i: i64) present(%a: memref<10xf32>, %b: memref<10xf32>) {
} attributes {async} } attributes {async}
return return
} }
// CHECK: acc.parallel num_gangs(%{{.*}}: i64) present(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>, %{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>) // CHECK: acc.parallel num_gangs(%{{.*}}: i64) present(%{{.*}}: !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>, %{{.*}}: !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
// CHECK-NEXT: } attributes {async} // CHECK-NEXT: } attributes {async}