TIFitis updated this revision to Diff 489515.
TIFitis added a comment.
Minor indentation changes.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D131915/new/
https://reviews.llvm.org/D131915
Files:
mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
mlir/test/Dialect/OpenMP/ops.mlir
Index: mlir/test/Dialect/OpenMP/ops.mlir
===================================================================
--- mlir/test/Dialect/OpenMP/ops.mlir
+++ mlir/test/Dialect/OpenMP/ops.mlir
@@ -451,6 +451,26 @@
return
}
+// CHECK-LABEL: omp_target_data
+func.func @omp_target_data (%if_cond : i1, %device : si32, %device_ptr: memref<i32>, %device_addr: memref<?xi32>, %map1: memref<?xi32>, %map2: memref<?xi32>) -> () {
+ // CHECK: omp.target_data if(%[[VAL_0:.*]] : i1) device(%[[VAL_1:.*]] : si32) map((6 : i64 -> always , from : %[[VAL_2:.*]] : memref<?xi32>))
+ omp.target_data if(%if_cond : i1) device(%device : si32) map((6 -> always , from : %map1 : memref<?xi32>)){}
+
+ // CHECK: omp.target_data use_device_ptr(%[[VAL_3:.*]] : memref<i32>) use_device_addr(%[[VAL_4:.*]] : memref<?xi32>) map((6 : i64 -> always , from : %[[VAL_2:.*]] : memref<?xi32>))
+ omp.target_data use_device_ptr(%device_ptr : memref<i32>) use_device_addr(%device_addr : memref<?xi32>) map((6 -> always , from : %map1 : memref<?xi32>)){}
+
+ // CHECK: omp.target_data map((6 : i64 -> always , from : %[[VAL_2]] : memref<?xi32>), (0 : i64 -> none , alloc : %[[VAL_5:.*]] : memref<?xi32>))
+ omp.target_data map((6 -> always , from : %map1 : memref<?xi32>), (0 -> none , alloc : %map2 : memref<?xi32>)){}
+
+ // CHECK: omp.target_enter_data if(%[[VAL_0]] : i1) device(%[[VAL_1]] : si32) nowait map((0 : i64 -> none , alloc : %[[VAL_2]] : memref<?xi32>))
+ omp.target_enter_data if(%if_cond : i1) device(%device : si32) nowait map((0 -> none , alloc : %map1 : memref<?xi32>))
+
+ // CHECK: omp.target_exit_data if(%[[VAL_0]] : i1) device(%[[VAL_1]] : si32) nowait map((0 : i64 -> none , release : %[[VAL_5]] : memref<?xi32>))
+ omp.target_exit_data if(%if_cond : i1) device(%device : si32) nowait map((0 -> none , release : %map2 : memref<?xi32>))
+
+ return
+}
+
// CHECK-LABEL: omp_target_pretty
func.func @omp_target_pretty(%if_cond : i1, %device : si32, %num_threads : i32) -> () {
// CHECK: omp.target if({{.*}}) device({{.*}})
Index: mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
===================================================================
--- mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -22,6 +22,7 @@
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
#include <cstddef>
#include "mlir/Dialect/OpenMP/OpenMPOpsDialect.cpp.inc"
@@ -536,6 +537,157 @@
return success();
}
+//===----------------------------------------------------------------------===//
+// Parser, printer and verifier for Target Data
+//===----------------------------------------------------------------------===//
+static ParseResult
+parseMapClause(OpAsmParser &parser,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &map_operands,
+ SmallVectorImpl<Type> &map_operand_types, ArrayAttr &map_types) {
+ StringRef mapTypeMod, mapType;
+ OpAsmParser::UnresolvedOperand arg1;
+ IntegerAttr arg2;
+ Type arg2Type;
+ SmallVector<IntegerAttr> mapTypesVec;
+
+ auto parseKeyword = [&]() -> ParseResult {
+ if (parser.parseLParen() || parser.parseAttribute(arg2) ||
+ parser.parseArrow() || parser.parseKeyword(&mapTypeMod) ||
+ parser.parseComma() || parser.parseKeyword(&mapType) ||
+ parser.parseColon() || parser.parseOperand(arg1) ||
+ parser.parseColon() || parser.parseType(arg2Type) ||
+ parser.parseRParen())
+ return failure();
+ map_operands.push_back(arg1);
+ map_operand_types.push_back(arg2Type);
+ mapTypesVec.push_back(arg2);
+ return success();
+ };
+
+ if (parser.parseCommaSeparatedList(parseKeyword))
+ return failure();
+
+ SmallVector<Attribute> mapTypesAttr(mapTypesVec.begin(), mapTypesVec.end());
+ map_types = ArrayAttr::get(parser.getContext(), mapTypesAttr);
+ return success();
+}
+
+static void printMapClause(OpAsmPrinter &p, Operation *op,
+ OperandRange map_operands,
+ TypeRange map_operand_types, ArrayAttr map_types) {
+
+ // Helper function to get bitwise AND of `value` and 'flag'
+ auto bitAnd = [](int64_t value,
+ llvm::omp::OpenMPOffloadMappingFlags flag) -> bool {
+ return value &
+ static_cast<
+ std::underlying_type_t<llvm::omp::OpenMPOffloadMappingFlags>>(
+ flag);
+ };
+
+ assert(map_operands.size() == map_types.size());
+
+ for (unsigned i = 0, e = map_operands.size(); i < e; i++) {
+ int64_t mapTypeBits = 0x00;
+ auto mapOp = map_operands[i];
+ auto mapTypeOp = map_types[i];
+
+ if (mapTypeOp.isa<mlir::IntegerAttr>())
+ mapTypeBits = mapTypeOp.cast<mlir::IntegerAttr>().getInt();
+
+ bool always = bitAnd(mapTypeBits,
+ llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_ALWAYS);
+ bool close = bitAnd(mapTypeBits,
+ llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_CLOSE);
+ bool present = bitAnd(
+ mapTypeBits, llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_PRESENT);
+
+ bool to =
+ bitAnd(mapTypeBits, llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_TO);
+ bool from =
+ bitAnd(mapTypeBits, llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_FROM);
+ bool del = bitAnd(mapTypeBits,
+ llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_DELETE);
+
+ std::string typeModStr, typeStr;
+ llvm::raw_string_ostream typeMod(typeModStr), type(typeStr);
+
+ if (always)
+ typeMod << "always ";
+ if (close)
+ typeMod << "close ";
+ if (present)
+ typeMod << "present ";
+ if (typeMod.str().empty())
+ typeMod << "none ";
+
+ if (to)
+ type << "to ";
+ if (from)
+ type << "from ";
+ if (del)
+ type << "delete ";
+ if (type.str().empty())
+ type << (isa<ExitDataOp>(op) ? "release " : "alloc ");
+
+ p << '(' << mapTypeOp << " -> " << typeMod.str() << ", " << type.str()
+ << ": " << mapOp << " : " << mapOp.getType() << ')';
+ if (mapOp != map_operands.back())
+ p << ", ";
+ }
+}
+
+static LogicalResult verifyMapClause(Operation *op, OperandRange map_operands,
+ ArrayAttr map_types) {
+ // Helper function to get bitwise AND of `value` and 'flag'
+ auto bitAnd = [](int64_t value,
+ llvm::omp::OpenMPOffloadMappingFlags flag) -> bool {
+ return value &
+ static_cast<
+ std::underlying_type_t<llvm::omp::OpenMPOffloadMappingFlags>>(
+ flag);
+ };
+ if (map_operands.size() != map_types.size())
+ return failure();
+
+ for (const auto &mapTypeOp : map_types) {
+ int64_t mapTypeBits = 0x00;
+
+ if (!mapTypeOp.isa<mlir::IntegerAttr>())
+ return failure();
+
+ mapTypeBits = mapTypeOp.cast<mlir::IntegerAttr>().getInt();
+
+ bool to =
+ bitAnd(mapTypeBits, llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_TO);
+ bool from =
+ bitAnd(mapTypeBits, llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_FROM);
+ bool del = bitAnd(mapTypeBits,
+ llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_DELETE);
+
+ if (isa<DataOp>(op) && del)
+ return failure();
+ if (isa<EnterDataOp>(op) && (from || del))
+ return failure();
+ if (isa<ExitDataOp>(op) && to)
+ return failure();
+ }
+
+ return success();
+}
+
+LogicalResult DataOp::verify() {
+ return verifyMapClause(*this, getMapOperands(), getMapTypes());
+}
+
+LogicalResult EnterDataOp::verify() {
+ return verifyMapClause(*this, getMapOperands(), getMapTypes());
+}
+
+LogicalResult ExitDataOp::verify() {
+ return verifyMapClause(*this, getMapOperands(), getMapTypes());
+}
+
//===----------------------------------------------------------------------===//
// ParallelOp
//===----------------------------------------------------------------------===//
Index: mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
===================================================================
--- mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
+++ mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
@@ -786,6 +786,157 @@
let assemblyFormat = "attr-dict";
}
+//===---------------------------------------------------------------------===//
+// 2.12.2 target data Construct
+//===---------------------------------------------------------------------===//
+
+def Target_DataOp: OpenMP_Op<"target_data", [AttrSizedOperandSegments]>{
+ let summary = "target data construct";
+ let description = [{
+ Map variables to a device data environment for the extent of the region.
+
+ The omp target data directive maps variables to a device data
+ environment, and defines the lexical scope of the data environment
+ that is created. The omp target data directive can reduce data copies
+ to and from the offloading device when multiple target regions are using
+ the same data.
+
+ The optional $if_expr parameter specifies a boolean result of a
+ conditional check. If this value is 1 or is not provided then the target
+ region runs on a device, if it is 0 then the target region is executed
+ on the host device.
+
+ The optional $device parameter specifies the device number for the target
+ region.
+
+ The optional $use_device_ptr specifies the device pointers to the
+ corresponding list items in the device data environment.
+
+ The optional $use_device_addr specifies the address of the objects in the
+ device data enviornment.
+
+ The $map_operands specifies operands in map clause along with it's type and modifiers.
+
+ The $map_operand_segments specifies the segment sizes for $map_operands.
+
+ TODO: depend clause and map_type_modifier values iterator and mapper.
+ }];
+
+ let arguments = (ins Optional<I1>:$if_expr,
+ Optional<AnyInteger>:$device,
+ Variadic<AnyType>:$use_device_ptr,
+ Variadic<AnyType>:$use_device_addr,
+ Variadic<AnyType>:$map_operands,
+ I64ArrayAttr:$map_types);
+
+ let regions = (region AnyRegion:$region);
+
+ let assemblyFormat = [{
+ oilist(`if` `(` $if_expr `:` type($if_expr) `)`
+ | `device` `(` $device `:` type($device) `)`
+ | `use_device_ptr` `(` $use_device_ptr `:` type($use_device_ptr) `)`
+ | `use_device_addr` `(` $use_device_addr `:` type($use_device_addr) `)`)
+ `map` `(` custom<MapClause>($map_operands, type($map_operands), $map_types) `)`
+ $region attr-dict
+ }];
+
+ let hasVerifier = 1;
+}
+
+//===---------------------------------------------------------------------===//
+// 2.12.3 target enter data Construct
+//===---------------------------------------------------------------------===//
+
+def Target_EnterDataOp: OpenMP_Op<"target_enter_data",
+ [AttrSizedOperandSegments]>{
+ let summary = "target enter data construct";
+ let description = [{
+ The target enter data directive specifies that variables are mapped to
+ a device data environment. The target enter data directive is a
+ stand-alone directive.
+
+ The optional $if_expr parameter specifies a boolean result of a
+ conditional check. If this value is 1 or is not provided then the target
+ region runs on a device, if it is 0 then the target region is executed on
+ the host device.
+
+ The optional $device parameter specifies the device number for the
+ target region.
+
+ The optional $nowait eliminates the implicit barrier so the parent task
+ can make progress even if the target task is not yet completed.
+
+ The $map_operands specifies operands in map clause along with it's type and modifiers.
+
+ The $map_operand_segments specifies the segment sizes for $map_operands.
+
+ TODO: depend clause and map_type_modifier values iterator and mapper.
+ }];
+
+ let arguments = (ins Optional<I1>:$if_expr,
+ Optional<AnyInteger>:$device,
+ UnitAttr:$nowait,
+ Variadic<AnyType>:$map_operands,
+ I64ArrayAttr:$map_types);
+
+ let assemblyFormat = [{
+ oilist(`if` `(` $if_expr `:` type($if_expr) `)`
+ | `device` `(` $device `:` type($device) `)`
+ | `nowait` $nowait)
+ `map` `(` custom<MapClause>($map_operands, type($map_operands), $map_types) `)`
+ attr-dict
+ }];
+
+ let hasVerifier = 1;
+}
+
+//===---------------------------------------------------------------------===//
+// 2.12.4 target exit data Construct
+//===---------------------------------------------------------------------===//
+
+def Target_ExitDataOp: OpenMP_Op<"target_exit_data",
+ [AttrSizedOperandSegments]>{
+ let summary = "target exit data construct";
+ let description = [{
+ The target exit data directive specifies that variables are mapped to a
+ device data environment. The target exit data directive is
+ a stand-alone directive.
+
+ The optional $if_expr parameter specifies a boolean result of a
+ conditional check. If this value is 1 or is not provided then the target
+ region runs on a device, if it is 0 then the target region is executed
+ on the host device.
+
+ The optional $device parameter specifies the device number for the
+ target region.
+
+ The optional $nowait eliminates the implicit barrier so the parent
+ task can make progress even if the target task is not yet completed.
+
+ The $map_operands specifies operands in map clause along with it's type and modifiers.
+
+ The $map_operand_segments specifies the segment sizes for $map_operands.
+
+ TODO: depend clause and map_type_modifier values iterator and mapper.
+ }];
+
+ let arguments = (ins Optional<I1>:$if_expr,
+ Optional<AnyInteger>:$device,
+ UnitAttr:$nowait,
+ Variadic<AnyType>:$map_operands,
+ I64ArrayAttr:$map_types);
+
+ let assemblyFormat = [{
+ oilist(`if` `(` $if_expr `:` type($if_expr) `)`
+ | `device` `(` $device `:` type($device) `)`
+ | `nowait` $nowait)
+ `map` `(` custom<MapClause>($map_operands, type($map_operands), $map_types) `)`
+ attr-dict
+ }];
+
+ let hasVerifier = 1;
+}
+
//===----------------------------------------------------------------------===//
// 2.13.7 flush Construct
//===----------------------------------------------------------------------===//
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
