[mlir][openacc] Introduce acc.exit_data operation

[clementval]

Summary

This patch introduces the acc.exit_data operation that represents an OpenACC Exit Data directive.
Operands and attributes are derived from clauses in the spec 2.6.6.

[kiranchandramohan]

LGTM.

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

252–254

#just-asking: Could the wait operand value be modelled as a type, so that we do not have to split it across three operands/attributes?

mlir/test/Dialect/OpenACC/invalid.mlir

182

Nit: No newline.

[clementval]

Add missing new line

[clementval]

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

252–254

I guess we could. Operands and the attribute are mutually exclusive. The attribute is there only when there is no value in the clause. I'll have a look a that but will probably put that in a separate patch if we can change that since other op already model the wait clause this way.

[clementval]

@kiranchandramohan Thanks for the review. IF you have 2 minutes can you have a look at D88941. It's pretty much the same op for enter_data.

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

def OpenACC_TerminatorOp : OpenACC_Op<"terminator", [Terminator]> {
   }];
 
   let verifier = ?;
 
   let assemblyFormat = "attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
+// 2.6.6 Exit Data Directive
+//===----------------------------------------------------------------------===//
+
+def OpenACC_ExitDataOp : OpenACC_Op<"exit_data", [AttrSizedOperandSegments]> {
+  let summary = "exit data operation";
+
+  let description = [{
+    The "acc.exit_data" operation represents the OpenACC exit data directive.
+
+    Example:
+
+    ```mlir
+    acc.exit_data delete(%d1 : memref<10xf32>) attributes {async}
+    ```
+  }];
+
+  let arguments = (ins Optional<I1>:$ifCond,
+                       Optional<IntOrIndex>:$asyncOperand,
+                       UnitAttr:$async,
+                       Optional<IntOrIndex>:$waitDevnum,
+                       Variadic<IntOrIndex>:$waitOperands,
+                       UnitAttr:$wait,
+                       Variadic<AnyType>:$copyoutOperands,
+                       Variadic<AnyType>:$deleteOperands,
+                       Variadic<AnyType>:$detachOperands,
+                       UnitAttr:$finalize);
+
+  let assemblyFormat = [{
+    ( `if` `(` $ifCond^ `)` )?
+    ( `async` `(` $asyncOperand^ `:` type($asyncOperand) `)` )?
+    ( `wait_devnum` `(` $waitDevnum^ `:` type($waitDevnum) `)` )?
+    ( `wait` `(` $waitOperands^ `:` type($waitOperands) `)` )?
+    ( `copyout` `(` $copyoutOperands^ `:` type($copyoutOperands) `)` )?
+    ( `delete` `(` $deleteOperands^ `:` type($deleteOperands) `)` )?
+    ( `detach` `(` $detachOperands^ `:` type($detachOperands) `)` )?
+    attr-dict-with-keyword
+  }];
+}
+
+//===----------------------------------------------------------------------===//
 // 2.9 loop Construct
 //===----------------------------------------------------------------------===//
 
 def OpenACC_LoopOp : OpenACC_Op<"loop",
       [AttrSizedOperandSegments,
        SingleBlockImplicitTerminator<"acc::YieldOp">]> {
   let summary = "loop construct";
 

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

static LogicalResult verify(acc::DataOp dataOp) {
   // attach, or default clause must appear on a data construct.
   if (dataOp.getOperands().size() == 0 && !dataOp.defaultAttr())
     return dataOp.emitError("at least one operand or the default attribute "
                             "must appear on the data operation");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// ExitDataOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(acc::ExitDataOp op) {
+  // 2.6.6. Data Exit Directive restriction
+  // At least one copyout, delete, or detach clause must appear on an exit data
+  // directive.
+  if (op.copyoutOperands().empty() && op.deleteOperands().empty() &&
+      op.detachOperands().empty())
+    return op.emitError(
+        "at least one operand in copyout, delete or detach must appear on the "
+        "exit data operation");
+
+  // The async attribute represent the async clause without value. Therefore the
+  // attribute and operand cannot appear at the same time.
+  if (op.asyncOperand() && op.async())
+    return op.emitError("async attribute cannot appear with asyncOperand");
+
+  // The wait attribute represent the wait clause without values. Therefore the
+  // attribute and operands cannot appear at the same time.
+  if (!op.waitOperands().empty() && op.wait())
+    return op.emitError("wait attribute cannot appear with waitOperands");
+
+  if (op.waitDevnum() && op.waitOperands().empty())
+    return op.emitError("wait_devnum cannot appear without waitOperands");
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // InitOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(acc::InitOp initOp) {
   Operation *currOp = initOp;
   while ((currOp = currOp->getParentOp())) {
     if (isComputeOperation(currOp))
       return initOp.emitOpError("cannot be nested in a compute operation");

mlir/test/Dialect/OpenACC/invalid.mlir

 
 acc.loop {
   "test.openacc_dummy_op"() ({
     // expected-error@+1 {{'acc.shutdown' op cannot be nested in a compute operation}}
     acc.shutdown
   }) : () -> ()
   acc.yield
 }
+
+// -----
+
+// expected-error@+1 {{at least one operand in copyout, delete or detach must appear on the exit data operation}}
+acc.exit_data attributes {async}
+
+// -----
+
+%cst = constant 1 : index
+%value = alloc() : memref<10xf32>
+// expected-error@+1 {{async attribute cannot appear with asyncOperand}}
+acc.exit_data async(%cst: index) delete(%value : memref<10xf32>) attributes {async}
+
+// -----
+
+%cst = constant 1 : index
+%value = alloc() : memref<10xf32>
+// expected-error@+1 {{wait attribute cannot appear with waitOperands}}
+acc.exit_data wait(%cst: index) delete(%value : memref<10xf32>) attributes {wait}
+
+// -----
+
+%cst = constant 1 : index
+%value = alloc() : memref<10xf32>
+// expected-error@+1 {{wait_devnum cannot appear without waitOperands}}
+acc.exit_data wait_devnum(%cst: index) delete(%value : memref<10xf32>)

mlir/test/Dialect/OpenACC/ops.mlir

 // CHECK: [[IFCOND:%.*]] = constant true
 // CHECK: acc.shutdown
 // CHECK: acc.shutdown device_type([[I32VALUE]] : i32)
 // CHECK: acc.shutdown device_type([[I32VALUE]], [[I32VALUE2]] : i32, i32)
 // CHECK: acc.shutdown device_num([[I64VALUE]] : i64)
 // CHECK: acc.shutdown device_num([[I32VALUE]] : i32)
 // CHECK: acc.shutdown device_num([[IDXVALUE]] : index)
 // CHECK: acc.shutdown if([[IFCOND]])
+
+// -----
+
+func @testexitdataop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) -> () {
+  %ifCond = constant true
+  %i64Value = constant 1 : i64
+  %i32Value = constant 1 : i32
+  %idxValue = constant 1 : index
+
+  acc.exit_data copyout(%a : memref<10xf32>)
+  acc.exit_data delete(%a : memref<10xf32>)
+  acc.exit_data delete(%a : memref<10xf32>) attributes {async,finalize}
+  acc.exit_data detach(%a : memref<10xf32>)
+  acc.exit_data copyout(%a : memref<10xf32>) attributes {async}
+  acc.exit_data delete(%a : memref<10xf32>) attributes {wait}
+  acc.exit_data async(%i64Value : i64) copyout(%a : memref<10xf32>)
+  acc.exit_data if(%ifCond) copyout(%a : memref<10xf32>)
+  acc.exit_data wait_devnum(%i64Value: i64) wait(%i32Value, %idxValue : i32, index) copyout(%a : memref<10xf32>)
+
+  return
+}
+
+// CHECK: func @testexitdataop([[ARGA:%.*]]: memref<10xf32>, [[ARGB:%.*]]: memref<10xf32>, [[ARGC:%.*]]: memref<10x10xf32>) {
+// CHECK: [[IFCOND1:%.*]] = constant true
+// CHECK: [[I64VALUE:%.*]] = constant 1 : i64
+// CHECK: [[I32VALUE:%.*]] = constant 1 : i32
+// CHECK: [[IDXVALUE:%.*]] = constant 1 : index
+// CHECK: acc.exit_data copyout([[ARGA]] : memref<10xf32>)
+// CHECK: acc.exit_data delete([[ARGA]] : memref<10xf32>)
+// CHECK: acc.exit_data delete([[ARGA]] : memref<10xf32>) attributes {async, finalize}
+// CHECK: acc.exit_data detach([[ARGA]] : memref<10xf32>)
+// CHECK: acc.exit_data copyout([[ARGA]] : memref<10xf32>) attributes {async}
+// CHECK: acc.exit_data delete([[ARGA]] : memref<10xf32>) attributes {wait}
+// CHECK: acc.exit_data async([[I64VALUE]] : i64) copyout([[ARGA]] : memref<10xf32>)
+// CHECK: acc.exit_data if([[IFCOND]]) copyout([[ARGA]] : memref<10xf32>)
+// CHECK: acc.exit_data wait_devnum([[I64VALUE]] : i64) wait([[I32VALUE]], [[IDXVALUE]] : i32, index) copyout([[ARGA]] : memref<10xf32>)