[Mlir-commits] [mlir] [mlir][openacc] Update acc.loop to be a proper loop like operation (PR #67355)
Valentin Clement バレンタイン クレメン
llvmlistbot at llvm.org
Mon Nov 13 15:07:11 PST 2023
https://github.com/clementval updated https://github.com/llvm/llvm-project/pull/67355
>From 9be9fa48139e9c82edc397c7925136994ca5a63f Mon Sep 17 00:00:00 2001
From: Valentin Clement <clementval at gmail.com>
Date: Tue, 29 Aug 2023 14:48:49 -0700
Subject: [PATCH] [mlir][openacc] Update acc.loop to be a proper loop like
operation
The initial design of the `acc.loop` was to be an operation that encapsulates
a loop like operation. This was an early design and we now want to change it
so the `acc.loop` operation becomes a real loop-like operation by implementing
the LoopLikeInterface.
Differential Revision: https://reviews.llvm.org/D159229
---
mlir/include/mlir/Dialect/OpenACC/OpenACC.h | 1 +
.../mlir/Dialect/OpenACC/OpenACCOps.td | 77 ++---
mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp | 78 ++++-
mlir/test/Dialect/OpenACC/canonicalize.mlir | 10 +-
mlir/test/Dialect/OpenACC/invalid.mlir | 88 +++---
mlir/test/Dialect/OpenACC/ops.mlir | 278 ++++++++----------
6 files changed, 300 insertions(+), 232 deletions(-)
diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h
index 4dc94782c1c9b54..989b8ba3b78f334 100644
--- a/mlir/include/mlir/Dialect/OpenACC/OpenACC.h
+++ b/mlir/include/mlir/Dialect/OpenACC/OpenACC.h
@@ -25,6 +25,7 @@
#include "mlir/Dialect/OpenACC/OpenACCTypeInterfaces.h.inc"
#include "mlir/Dialect/OpenACCMPCommon/Interfaces/AtomicInterfaces.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/LoopLikeInterface.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#define GET_TYPEDEF_CLASSES
diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
index d0b52a0b4024172..d17125f01dd8801 100644
--- a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
+++ b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
@@ -14,6 +14,7 @@
#define OPENACC_OPS
include "mlir/Interfaces/ControlFlowInterfaces.td"
+include "mlir/Interfaces/LoopLikeInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td"
include "mlir/IR/BuiltinTypes.td"
include "mlir/IR/EnumAttr.td"
@@ -1161,47 +1162,53 @@ def OpenACC_HostDataOp : OpenACC_Op<"host_data", [AttrSizedOperandSegments]> {
//===----------------------------------------------------------------------===//
def OpenACC_LoopOp : OpenACC_Op<"loop",
- [AttrSizedOperandSegments, RecursiveMemoryEffects]> {
+ [AttrSizedOperandSegments, RecursiveMemoryEffects,
+ DeclareOpInterfaceMethods<LoopLikeOpInterface>]> {
let summary = "loop construct";
let description = [{
- The "acc.loop" operation represents the OpenACC loop construct.
+ The "acc.loop" operation represents the OpenACC loop construct. The lower
+ and upper bounds specify a half-open range: the range includes the lower
+ bound but does not include the upper bound. If the `inclusive` attribute is
+ set then the upper bound is included.
Example:
```mlir
- acc.loop gang vector {
- scf.for %arg3 = %c0 to %c10 step %c1 {
- scf.for %arg4 = %c0 to %c10 step %c1 {
- scf.for %arg5 = %c0 to %c10 step %c1 {
- // ... body
- }
- }
- }
+ acc.loop gang() vector() (%arg3 : index, %arg4 : index, %arg5 : index) =
+ (%c0, %c0, %c0 : index, index, index) to
+ (%c10, %c10, %c10 : index, index, index) step
+ (%c1, %c1, %c1 : index, index, index) {
+ // Loop body
acc.yield
} attributes { collapse = 3 }
```
}];
- let arguments = (ins OptionalAttr<I64Attr>:$collapse,
- Optional<IntOrIndex>:$gangNum,
- Optional<IntOrIndex>:$gangDim,
- Optional<IntOrIndex>:$gangStatic,
- Optional<IntOrIndex>:$workerNum,
- Optional<IntOrIndex>:$vectorLength,
- UnitAttr:$seq,
- UnitAttr:$independent,
- UnitAttr:$auto_,
- UnitAttr:$hasGang,
- UnitAttr:$hasWorker,
- UnitAttr:$hasVector,
- Variadic<IntOrIndex>:$tileOperands,
- Variadic<OpenACC_PointerLikeTypeInterface>:$cacheOperands,
- Variadic<OpenACC_PointerLikeTypeInterface>:$privateOperands,
- OptionalAttr<SymbolRefArrayAttr>:$privatizations,
- Variadic<AnyType>:$reductionOperands,
- OptionalAttr<SymbolRefArrayAttr>:$reductionRecipes
- );
+ let arguments = (ins
+ Variadic<IntOrIndex>:$lowerbound,
+ Variadic<IntOrIndex>:$upperbound,
+ Variadic<IntOrIndex>:$step,
+ OptionalAttr<DenseBoolArrayAttr>:$inclusiveUpperbound,
+ OptionalAttr<I64Attr>:$collapse,
+ Optional<IntOrIndex>:$gangNum,
+ Optional<IntOrIndex>:$gangDim,
+ Optional<IntOrIndex>:$gangStatic,
+ Optional<IntOrIndex>:$workerNum,
+ Optional<IntOrIndex>:$vectorLength,
+ UnitAttr:$seq,
+ UnitAttr:$independent,
+ UnitAttr:$auto_,
+ UnitAttr:$hasGang,
+ UnitAttr:$hasWorker,
+ UnitAttr:$hasVector,
+ Variadic<IntOrIndex>:$tileOperands,
+ Variadic<OpenACC_PointerLikeTypeInterface>:$cacheOperands,
+ Variadic<OpenACC_PointerLikeTypeInterface>:$privateOperands,
+ OptionalAttr<SymbolRefArrayAttr>:$privatizations,
+ Variadic<AnyType>:$reductionOperands,
+ OptionalAttr<SymbolRefArrayAttr>:$reductionRecipes
+ );
let results = (outs Variadic<AnyType>:$results);
@@ -1223,9 +1230,12 @@ def OpenACC_LoopOp : OpenACC_Op<"loop",
let hasCustomAssemblyFormat = 1;
let assemblyFormat = [{
oilist(
- `gang` `` custom<GangClause>($gangNum, type($gangNum), $gangDim, type($gangDim), $gangStatic, type($gangStatic), $hasGang)
- | `worker` `` custom<WorkerClause>($workerNum, type($workerNum), $hasWorker)
- | `vector` `` custom<VectorClause>($vectorLength, type($vectorLength), $hasVector)
+ `gang` `` custom<GangClause>($gangNum, type($gangNum), $gangDim,
+ type($gangDim), $gangStatic, type($gangStatic), $hasGang)
+ | `worker` ``
+ custom<WorkerClause>($workerNum, type($workerNum), $hasWorker)
+ | `vector` ``
+ custom<VectorClause>($vectorLength, type($vectorLength), $hasVector)
| `private` `(` custom<SymOperandList>(
$privateOperands, type($privateOperands), $privatizations)
`)`
@@ -1235,7 +1245,8 @@ def OpenACC_LoopOp : OpenACC_Op<"loop",
`)`
| `cache` `(` $cacheOperands `:` type($cacheOperands) `)`
)
- $region
+ custom<LoopControl>($region, $lowerbound, type($lowerbound), $upperbound,
+ type($upperbound), $step, type($step))
( `(` type($results)^ `)` )?
attr-dict-with-keyword
}];
diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
index 6e5df705fee05d8..df1ea13bef33f6c 100644
--- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
+++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
@@ -745,6 +745,9 @@ static ParseResult parseGangClause(
// optional gang operands
if (succeeded(parser.parseOptionalLParen())) {
+ // Allow empty parenthesis.
+ if (succeeded(parser.parseOptionalRParen()))
+ return success();
while (true) {
bool newValue = false;
bool needValue = false;
@@ -791,8 +794,8 @@ static ParseResult parseGangClause(
void printGangClause(OpAsmPrinter &p, Operation *op, Value gangNum,
Type gangNumType, Value gangDim, Type gangDimType,
Value gangStatic, Type gangStaticType, UnitAttr hasGang) {
+ p << "(";
if (gangNum || gangStatic || gangDim) {
- p << "(";
if (gangNum) {
p << LoopOp::getGangNumKeyword() << "=" << gangNum << " : "
<< gangNumType;
@@ -808,8 +811,8 @@ void printGangClause(OpAsmPrinter &p, Operation *op, Value gangNum,
if (gangStatic)
p << LoopOp::getGangStaticKeyword() << "=" << gangStatic << " : "
<< gangStaticType;
- p << ")";
}
+ p << ")";
}
static ParseResult
@@ -818,6 +821,9 @@ parseWorkerClause(OpAsmParser &parser,
Type &workerNumType, UnitAttr &hasWorker) {
hasWorker = UnitAttr::get(parser.getBuilder().getContext());
if (succeeded(parser.parseOptionalLParen())) {
+ // Allow empty parenthesis.
+ if (succeeded(parser.parseOptionalRParen()))
+ return success();
workerNum = OpAsmParser::UnresolvedOperand{};
if (parser.parseOperand(*workerNum) ||
parser.parseColonType(workerNumType) || parser.parseRParen())
@@ -828,8 +834,10 @@ parseWorkerClause(OpAsmParser &parser,
void printWorkerClause(OpAsmPrinter &p, Operation *op, Value workerNum,
Type workerNumType, UnitAttr hasWorker) {
+ p << "(";
if (workerNum)
- p << "(" << workerNum << " : " << workerNumType << ")";
+ p << workerNum << " : " << workerNumType;
+ p << ")";
}
static ParseResult
@@ -838,6 +846,9 @@ parseVectorClause(OpAsmParser &parser,
Type &vectorLengthType, UnitAttr &hasVector) {
hasVector = UnitAttr::get(parser.getBuilder().getContext());
if (succeeded(parser.parseOptionalLParen())) {
+ // Allow empty parenthesis.
+ if (succeeded(parser.parseOptionalRParen()))
+ return success();
vectorLength = OpAsmParser::UnresolvedOperand{};
if (parser.parseOperand(*vectorLength) ||
parser.parseColonType(vectorLengthType) || parser.parseRParen())
@@ -848,11 +859,18 @@ parseVectorClause(OpAsmParser &parser,
void printVectorClause(OpAsmPrinter &p, Operation *op, Value vectorLength,
Type vectorLengthType, UnitAttr hasVector) {
+ p << "(";
if (vectorLength)
- p << "(" << vectorLength << " : " << vectorLengthType << ")";
+ p << vectorLength << " : " << vectorLengthType;
+ p << ")";
}
LogicalResult acc::LoopOp::verify() {
+ if (!getUpperbound().empty() &&
+ (getUpperbound().size() != getInclusiveUpperbound()->size()))
+ return emitError() << "inclusiveUpperbound size is expected to be the same"
+ << " as upperbound size";
+
// auto, independent and seq attribute are mutually exclusive.
if ((getAuto_() && (getIndependent() || getSeq())) ||
(getIndependent() && getSeq())) {
@@ -898,6 +916,58 @@ Value LoopOp::getDataOperand(unsigned i) {
return getOperand(numOptional + i);
}
+llvm::SmallVector<mlir::Region *> acc::LoopOp::getLoopRegions() {
+ return {&getRegion()};
+}
+
+/// loop-control ::= `(` ssa-id-and-type-list `)` `=` `(` ssa-id-and-type-list
+/// `)` `to` `(` ssa-id-and-type-list `)` `step` `(` ssa-id-and-type-list `)`
+ParseResult
+parseLoopControl(OpAsmParser &parser, Region ®ion,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &lowerbound,
+ SmallVectorImpl<Type> &lowerboundType,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &upperbound,
+ SmallVectorImpl<Type> &upperboundType,
+ SmallVectorImpl<OpAsmParser::UnresolvedOperand> &step,
+ SmallVectorImpl<Type> &stepType) {
+
+ SmallVector<OpAsmParser::Argument> inductionVars;
+ if (succeeded(parser.parseOptionalLParen())) {
+ if (parser.parseArgumentList(inductionVars, OpAsmParser::Delimiter::None,
+ /*allowType=*/true) ||
+ parser.parseRParen() || parser.parseEqual() || parser.parseLParen() ||
+ parser.parseOperandList(lowerbound, inductionVars.size(),
+ OpAsmParser::Delimiter::None) ||
+ parser.parseColonTypeList(lowerboundType) || parser.parseRParen() ||
+ parser.parseKeyword("to") || parser.parseLParen() ||
+ parser.parseOperandList(upperbound, inductionVars.size(),
+ OpAsmParser::Delimiter::None) ||
+ parser.parseColonTypeList(upperboundType) || parser.parseRParen() ||
+ parser.parseKeyword("step") || parser.parseLParen() ||
+ parser.parseOperandList(step, inductionVars.size(),
+ OpAsmParser::Delimiter::None) ||
+ parser.parseColonTypeList(stepType) || parser.parseRParen())
+ return failure();
+ }
+ return parser.parseRegion(region, inductionVars);
+}
+
+void printLoopControl(OpAsmPrinter &p, Operation *op, Region ®ion,
+ ValueRange lowerbound, TypeRange lowerboundType,
+ ValueRange upperbound, TypeRange upperboundType,
+ ValueRange steps, TypeRange stepType) {
+ ValueRange regionArgs = region.front().getArguments();
+ if (!regionArgs.empty()) {
+ p << "(";
+ llvm::interleaveComma(regionArgs, p,
+ [&p](Value v) { p << v << " : " << v.getType(); });
+ p << ") = (" << lowerbound << " : " << lowerboundType << ") to ("
+ << upperbound << " : " << upperboundType << ") "
+ << " step (" << steps << " : " << stepType << ") ";
+ }
+ p.printRegion(region, /*printEntryBlockArgs=*/false);
+}
+
//===----------------------------------------------------------------------===//
// DataOp
//===----------------------------------------------------------------------===//
diff --git a/mlir/test/Dialect/OpenACC/canonicalize.mlir b/mlir/test/Dialect/OpenACC/canonicalize.mlir
index 6173ab6699c6c58..4522ffb252a62e3 100644
--- a/mlir/test/Dialect/OpenACC/canonicalize.mlir
+++ b/mlir/test/Dialect/OpenACC/canonicalize.mlir
@@ -110,14 +110,16 @@ func.func @testupdateop(%a: memref<f32>, %ifCond: i1) -> () {
func.func @testhostdataop(%a: memref<f32>, %ifCond: i1) -> () {
%0 = acc.use_device varPtr(%a : memref<f32>) -> memref<f32>
+ %1 = arith.constant 1 : i32
+ %2 = arith.constant 10 : i32
%false = arith.constant false
acc.host_data dataOperands(%0 : memref<f32>) if(%false) {
- acc.loop {
+ acc.loop (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
acc.yield
- }
- acc.loop {
+ } attributes { inclusiveUpperbound = array<i1: true> }
+ acc.loop (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
acc.yield
- }
+ } attributes { inclusiveUpperbound = array<i1: true> }
acc.terminator
}
return
diff --git a/mlir/test/Dialect/OpenACC/invalid.mlir b/mlir/test/Dialect/OpenACC/invalid.mlir
index b9ac68d0592c872..a6b99a54b4c142f 100644
--- a/mlir/test/Dialect/OpenACC/invalid.mlir
+++ b/mlir/test/Dialect/OpenACC/invalid.mlir
@@ -1,71 +1,81 @@
// RUN: mlir-opt -split-input-file -verify-diagnostics %s
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{gang, worker or vector cannot appear with the seq attr}}
-acc.loop gang {
+acc.loop gang() (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
-} attributes {seq}
+} attributes {seq, inclusiveUpperbound = array<i1: true>}
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{gang, worker or vector cannot appear with the seq attr}}
-acc.loop worker {
+acc.loop worker() (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
-} attributes {seq}
+} attributes {seq, inclusiveUpperbound = array<i1: true>}
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{gang, worker or vector cannot appear with the seq attr}}
-acc.loop vector {
+acc.loop vector() (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
-} attributes {seq}
+} attributes {seq, inclusiveUpperbound = array<i1: true>}
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{gang, worker or vector cannot appear with the seq attr}}
-acc.loop gang worker {
+acc.loop gang() worker() (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
-} attributes {seq}
+} attributes {seq, inclusiveUpperbound = array<i1: true>}
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{gang, worker or vector cannot appear with the seq attr}}
-acc.loop gang vector {
+acc.loop gang() vector() (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
-} attributes {seq}
+} attributes {seq, inclusiveUpperbound = array<i1: true>}
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{gang, worker or vector cannot appear with the seq attr}}
-acc.loop worker vector {
+acc.loop worker() vector() (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
-} attributes {seq}
+} attributes {seq, inclusiveUpperbound = array<i1: true>}
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{gang, worker or vector cannot appear with the seq attr}}
-acc.loop gang worker vector {
+acc.loop gang() worker() vector() (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
-} attributes {seq}
-
-// -----
-
-// expected-error at +1 {{expected non-empty body.}}
-acc.loop {
-}
+} attributes {seq, inclusiveUpperbound = array<i1: true>}
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{only one of "auto", "independent", "seq" can be present at the same time}}
-acc.loop {
+acc.loop (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
acc.yield
-} attributes {auto_, seq}
+} attributes {auto_, seq, inclusiveUpperbound = array<i1: true>}
// -----
@@ -133,11 +143,13 @@ acc.parallel {
// -----
-acc.loop {
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
+acc.loop (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32){
// expected-error at +1 {{'acc.init' op cannot be nested in a compute operation}}
acc.init
acc.yield
-}
+} attributes {inclusiveUpperbound = array<i1: true>}
// -----
@@ -149,21 +161,25 @@ acc.parallel {
// -----
-acc.loop {
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
+acc.loop (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
// expected-error at +1 {{'acc.shutdown' op cannot be nested in a compute operation}}
acc.shutdown
acc.yield
-}
+} attributes {inclusiveUpperbound = array<i1: true>}
// -----
-acc.loop {
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
+acc.loop (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() ({
// expected-error at +1 {{'acc.shutdown' op cannot be nested in a compute operation}}
acc.shutdown
}) : () -> ()
acc.yield
-}
+} attributes {inclusiveUpperbound = array<i1: true>}
// -----
@@ -367,8 +383,10 @@ acc.firstprivate.recipe @privatization_i32 : i32 init {
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{expected ')'}}
-acc.loop gang(static=%i64Value: i64, num=%i64Value: i64 {
+acc.loop gang(static=%i64Value: i64, num=%i64Value: i64 (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
}
@@ -436,8 +454,10 @@ acc.reduction.recipe @reduction_i64 : i64 reduction_operator<add> init {
// -----
+%1 = arith.constant 1 : i32
+%2 = arith.constant 10 : i32
// expected-error at +1 {{new value expected after comma}}
-acc.loop gang(static=%i64Value: i64, ) {
+acc.loop gang(static=%i64Value: i64, ) (%iv : i32) = (%1 : i32) to (%2 : i32) step (%1 : i32) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
}
@@ -453,14 +473,6 @@ func.func @fct1(%0 : !llvm.ptr) -> () {
// -----
-// expected-error at +1 {{expect at least one of num, dim or static values}}
-acc.loop gang() {
- "test.openacc_dummy_op"() : () -> ()
- acc.yield
-}
-
-// -----
-
%i64value = arith.constant 1 : i64
// expected-error at +1 {{num_gangs expects a maximum of 3 values}}
acc.parallel num_gangs(%i64value, %i64value, %i64value, %i64value : i64, i64, i64, i64) {
diff --git a/mlir/test/Dialect/OpenACC/ops.mlir b/mlir/test/Dialect/OpenACC/ops.mlir
index c06e5a596923f94..69d11f8bb2cce13 100644
--- a/mlir/test/Dialect/OpenACC/ops.mlir
+++ b/mlir/test/Dialect/OpenACC/ops.mlir
@@ -11,52 +11,40 @@ func.func @compute1(%A: memref<10x10xf32>, %B: memref<10x10xf32>, %C: memref<10x
%async = arith.constant 1 : i64
acc.parallel async(%async: i64) {
- acc.loop gang vector {
- scf.for %arg3 = %c0 to %c10 step %c1 {
- scf.for %arg4 = %c0 to %c10 step %c1 {
- scf.for %arg5 = %c0 to %c10 step %c1 {
- %a = memref.load %A[%arg3, %arg5] : memref<10x10xf32>
- %b = memref.load %B[%arg5, %arg4] : memref<10x10xf32>
- %cij = memref.load %C[%arg3, %arg4] : memref<10x10xf32>
- %p = arith.mulf %a, %b : f32
- %co = arith.addf %cij, %p : f32
- memref.store %co, %C[%arg3, %arg4] : memref<10x10xf32>
- }
- }
- }
+ acc.loop gang() vector() (%arg3 : index, %arg4 : index, %arg5 : index) = (%c0, %c0, %c0 : index, index, index) to (%c10, %c10, %c10 : index, index, index) step (%c1, %c1, %c1 : index, index, index) {
+ %a = memref.load %A[%arg3, %arg5] : memref<10x10xf32>
+ %b = memref.load %B[%arg5, %arg4] : memref<10x10xf32>
+ %cij = memref.load %C[%arg3, %arg4] : memref<10x10xf32>
+ %p = arith.mulf %a, %b : f32
+ %co = arith.addf %cij, %p : f32
+ memref.store %co, %C[%arg3, %arg4] : memref<10x10xf32>
acc.yield
- } attributes { collapse = 3 }
+ } attributes { collapse = 3, inclusiveUpperbound = array<i1: true, true, true> }
acc.yield
}
return %C : memref<10x10xf32>
}
-// CHECK-LABEL: func @compute1(
+// CHECK-LABEL: func @compute1
// CHECK-NEXT: %{{.*}} = arith.constant 0 : index
// CHECK-NEXT: %{{.*}} = arith.constant 10 : index
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: [[ASYNC:%.*]] = arith.constant 1 : i64
// CHECK-NEXT: acc.parallel async([[ASYNC]] : i64) {
-// CHECK-NEXT: acc.loop gang vector {
-// CHECK-NEXT: scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
-// CHECK-NEXT: scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
-// CHECK-NEXT: scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
-// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
-// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
-// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
-// CHECK-NEXT: %{{.*}} = arith.mulf %{{.*}}, %{{.*}} : f32
-// CHECK-NEXT: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : f32
-// CHECK-NEXT: memref.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
-// CHECK-NEXT: }
-// CHECK-NEXT: }
-// CHECK-NEXT: }
+// CHECK-NEXT: acc.loop gang() vector() (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) {
+// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
+// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
+// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
+// CHECK-NEXT: %{{.*}} = arith.mulf %{{.*}}, %{{.*}} : f32
+// CHECK-NEXT: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : f32
+// CHECK-NEXT: memref.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: } attributes {collapse = 3 : i64}
+// CHECK-NEXT: } attributes {collapse = 3 : i64, inclusiveUpperbound = array<i1: true, true, true>}
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
// CHECK-NEXT: return %{{.*}} : memref<10x10xf32>
-// CHECK-NEXT: }
+
// -----
@@ -66,21 +54,19 @@ func.func @compute2(%A: memref<10x10xf32>, %B: memref<10x10xf32>, %C: memref<10x
%c1 = arith.constant 1 : index
acc.parallel {
- acc.loop {
- scf.for %arg3 = %c0 to %c10 step %c1 {
- scf.for %arg4 = %c0 to %c10 step %c1 {
- scf.for %arg5 = %c0 to %c10 step %c1 {
- %a = memref.load %A[%arg3, %arg5] : memref<10x10xf32>
- %b = memref.load %B[%arg5, %arg4] : memref<10x10xf32>
- %cij = memref.load %C[%arg3, %arg4] : memref<10x10xf32>
- %p = arith.mulf %a, %b : f32
- %co = arith.addf %cij, %p : f32
- memref.store %co, %C[%arg3, %arg4] : memref<10x10xf32>
- }
+ acc.loop (%arg3 : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
+ scf.for %arg4 = %c0 to %c10 step %c1 {
+ scf.for %arg5 = %c0 to %c10 step %c1 {
+ %a = memref.load %A[%arg3, %arg5] : memref<10x10xf32>
+ %b = memref.load %B[%arg5, %arg4] : memref<10x10xf32>
+ %cij = memref.load %C[%arg3, %arg4] : memref<10x10xf32>
+ %p = arith.mulf %a, %b : f32
+ %co = arith.addf %cij, %p : f32
+ memref.store %co, %C[%arg3, %arg4] : memref<10x10xf32>
}
}
acc.yield
- } attributes {seq}
+ } attributes { seq, inclusiveUpperbound = array<i1: true> }
acc.yield
}
@@ -92,8 +78,7 @@ func.func @compute2(%A: memref<10x10xf32>, %B: memref<10x10xf32>, %C: memref<10x
// CHECK-NEXT: %{{.*}} = arith.constant 10 : index
// CHECK-NEXT: %{{.*}} = arith.constant 1 : index
// CHECK-NEXT: acc.parallel {
-// CHECK-NEXT: acc.loop {
-// CHECK-NEXT: scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
+// CHECK-NEXT: acc.loop (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
// CHECK-NEXT: scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK-NEXT: scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
@@ -104,9 +89,8 @@ func.func @compute2(%A: memref<10x10xf32>, %B: memref<10x10xf32>, %C: memref<10x
// CHECK-NEXT: memref.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
-// CHECK-NEXT: }
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: } attributes {seq}
+// CHECK-NEXT: } attributes {inclusiveUpperbound = array<i1: true>, seq}
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
// CHECK-NEXT: return %{{.*}} : memref<10x10xf32>
@@ -138,32 +122,25 @@ func.func @compute3(%a: memref<10x10xf32>, %b: memref<10x10xf32>, %c: memref<10x
acc.data dataOperands(%pa, %pb, %pc, %pd: memref<10x10xf32>, memref<10x10xf32>, memref<10xf32>, memref<10xf32>) {
%private = acc.private varPtr(%c : memref<10xf32>) -> memref<10xf32>
acc.parallel num_gangs(%numGangs: i64) num_workers(%numWorkers: i64) private(@privatization_memref_10_f32 -> %private : memref<10xf32>) {
- acc.loop gang {
- scf.for %x = %lb to %c10 step %st {
- acc.loop worker {
- scf.for %y = %lb to %c10 step %st {
- %axy = memref.load %a[%x, %y] : memref<10x10xf32>
- %bxy = memref.load %b[%x, %y] : memref<10x10xf32>
- %tmp = arith.addf %axy, %bxy : f32
- memref.store %tmp, %c[%y] : memref<10xf32>
- }
- acc.yield
- }
-
- acc.loop {
- // for i = 0 to 10 step 1
- // d[x] += c[i]
- scf.for %i = %lb to %c10 step %st {
- %ci = memref.load %c[%i] : memref<10xf32>
- %dx = memref.load %d[%x] : memref<10xf32>
- %z = arith.addf %ci, %dx : f32
- memref.store %z, %d[%x] : memref<10xf32>
- }
- acc.yield
- } attributes {seq}
- }
+ acc.loop gang() (%x : index) = (%lb : index) to (%c10 : index) step (%st : index) {
+ acc.loop worker() (%y : index) = (%lb : index) to (%c10 : index) step (%st : index) {
+ %axy = memref.load %a[%x, %y] : memref<10x10xf32>
+ %bxy = memref.load %b[%x, %y] : memref<10x10xf32>
+ %tmp = arith.addf %axy, %bxy : f32
+ memref.store %tmp, %c[%y] : memref<10xf32>
+ acc.yield
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop (%i : index) = (%lb : index) to (%c10 : index) step (%st : index) {
+ // for i = 0 to 10 step 1
+ // d[x] += c[i]
+ %ci = memref.load %c[%i] : memref<10xf32>
+ %dx = memref.load %d[%x] : memref<10xf32>
+ %z = arith.addf %ci, %dx : f32
+ memref.store %z, %d[%x] : memref<10xf32>
+ acc.yield
+ } attributes {seq, inclusiveUpperbound = array<i1: true>}
acc.yield
- }
+ } attributes {inclusiveUpperbound = array<i1: true>}
acc.yield
}
acc.terminator
@@ -181,27 +158,21 @@ func.func @compute3(%a: memref<10x10xf32>, %b: memref<10x10xf32>, %c: memref<10x
// CHECK: acc.data dataOperands(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : memref<10x10xf32>, memref<10x10xf32>, memref<10xf32>, memref<10xf32>) {
// CHECK-NEXT: %[[P_ARG2:.*]] = acc.private varPtr([[ARG2]] : memref<10xf32>) -> memref<10xf32>
// CHECK-NEXT: acc.parallel num_gangs([[NUMGANG]] : i64) num_workers([[NUMWORKERS]] : i64) private(@privatization_memref_10_f32 -> %[[P_ARG2]] : memref<10xf32>) {
-// CHECK-NEXT: acc.loop gang {
-// CHECK-NEXT: scf.for %{{.*}} = [[C0]] to [[C10]] step [[C1]] {
-// CHECK-NEXT: acc.loop worker {
-// CHECK-NEXT: scf.for %{{.*}} = [[C0]] to [[C10]] step [[C1]] {
+// CHECK-NEXT: acc.loop gang() (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
+// CHECK-NEXT: acc.loop worker() (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: memref.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
-// CHECK-NEXT: }
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
-// CHECK-NEXT: acc.loop {
-// CHECK-NEXT: scf.for %{{.*}} = [[C0]] to [[C10]] step [[C1]] {
+// CHECK-NEXT: acc.loop (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = memref.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = arith.addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: memref.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
-// CHECK-NEXT: }
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: } attributes {seq}
-// CHECK-NEXT: }
+// CHECK-NEXT: } attributes {inclusiveUpperbound = array<i1: true>, seq}
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
// CHECK-NEXT: acc.yield
@@ -217,68 +188,75 @@ func.func @testloopop(%a : memref<10xf32>) -> () {
%i64Value = arith.constant 1 : i64
%i32Value = arith.constant 128 : i32
%idxValue = arith.constant 8 : index
+ %c0 = arith.constant 0 : index
+ %c10 = arith.constant 10 : index
+ %c1 = arith.constant 1 : index
- acc.loop gang worker vector {
+ acc.loop gang() worker() vector() (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop gang(num=%i64Value: i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop gang(num=%i64Value: i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop gang(static=%i64Value: i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop gang(static=%i64Value: i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop worker(%i64Value: i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop worker(%i64Value: i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop worker(%i32Value: i32) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop worker(%i32Value: i32) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop worker(%idxValue: index) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop worker(%idxValue: index) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop vector(%i64Value: i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop vector(%i64Value: i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop vector(%i32Value: i32) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop vector(%i32Value: i32) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop vector(%idxValue: index) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop vector(%idxValue: index) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop gang(num=%i64Value: i64) worker vector {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop gang(num=%i64Value: i64) worker() vector() (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop gang(num=%i64Value: i64, static=%i64Value: i64) worker(%i64Value: i64) vector(%i64Value: i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop gang(num=%i64Value: i64, static=%i64Value: i64) worker(%i64Value: i64) vector(%i64Value: i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop gang(num=%i32Value: i32, static=%idxValue: index) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop gang(num=%i32Value: i32, static=%idxValue: index) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop tile(%i64Value, %i64Value : i64, i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop tile(%i64Value, %i64Value : i64, i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop tile(%i32Value, %i32Value : i32, i32) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop tile(%i32Value, %i32Value : i32, i32) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop gang(static=%i64Value: i64, num=%i64Value: i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop gang(static=%i64Value: i64, num=%i64Value: i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
"test.openacc_dummy_op"() : () -> ()
acc.yield
- }
- acc.loop gang(dim=%i64Value : i64, static=%i64Value: i64) {
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop gang(dim=%i64Value : i64, static=%i64Value: i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
+ "test.openacc_dummy_op"() : () -> ()
+ acc.yield
+ } attributes {inclusiveUpperbound = array<i1: true>}
+ acc.loop {
"test.openacc_dummy_op"() : () -> ()
acc.yield
}
@@ -293,67 +271,55 @@ func.func @testloopop(%a : memref<10xf32>) -> () {
// CHECK: [[I64VALUE:%.*]] = arith.constant 1 : i64
// CHECK-NEXT: [[I32VALUE:%.*]] = arith.constant 128 : i32
// CHECK-NEXT: [[IDXVALUE:%.*]] = arith.constant 8 : index
-// CHECK: acc.loop gang worker vector {
+// CHECK: acc.loop gang() worker() vector()
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop gang(num=[[I64VALUE]] : i64) {
+// CHECK: acc.loop gang(num=[[I64VALUE]] : i64)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop gang(static=[[I64VALUE]] : i64) {
+// CHECK: acc.loop gang(static=[[I64VALUE]] : i64)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop worker([[I64VALUE]] : i64) {
+// CHECK: acc.loop worker([[I64VALUE]] : i64)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop worker([[I32VALUE]] : i32) {
+// CHECK: acc.loop worker([[I32VALUE]] : i32)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop worker([[IDXVALUE]] : index) {
+// CHECK: acc.loop worker([[IDXVALUE]] : index)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop vector([[I64VALUE]] : i64) {
+// CHECK: acc.loop vector([[I64VALUE]] : i64)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop vector([[I32VALUE]] : i32) {
+// CHECK: acc.loop vector([[I32VALUE]] : i32)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop vector([[IDXVALUE]] : index) {
+// CHECK: acc.loop vector([[IDXVALUE]] : index)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop gang(num=[[I64VALUE]] : i64) worker vector {
+// CHECK: acc.loop gang(num=[[I64VALUE]] : i64) worker() vector()
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop gang(num=[[I64VALUE]] : i64, static=[[I64VALUE]] : i64) worker([[I64VALUE]] : i64) vector([[I64VALUE]] : i64) {
+// CHECK: acc.loop gang(num=[[I64VALUE]] : i64, static=[[I64VALUE]] : i64) worker([[I64VALUE]] : i64) vector([[I64VALUE]] : i64)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop gang(num=[[I32VALUE]] : i32, static=[[IDXVALUE]] : index) {
+// CHECK: acc.loop gang(num=[[I32VALUE]] : i32, static=[[IDXVALUE]] : index)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop tile([[I64VALUE]], [[I64VALUE]] : i64, i64) {
+// CHECK: acc.loop tile([[I64VALUE]], [[I64VALUE]] : i64, i64)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop tile([[I32VALUE]], [[I32VALUE]] : i32, i32) {
+// CHECK: acc.loop tile([[I32VALUE]], [[I32VALUE]] : i32, i32)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop gang(num=[[I64VALUE]] : i64, static=[[I64VALUE]] : i64) {
+// CHECK: acc.loop gang(num=[[I64VALUE]] : i64, static=[[I64VALUE]] : i64)
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
-// CHECK-NEXT: }
-// CHECK: acc.loop gang(dim=[[I64VALUE]] : i64, static=[[I64VALUE]] : i64) {
+// CHECK: acc.loop gang(dim=[[I64VALUE]] : i64, static=[[I64VALUE]] : i64)
+// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
+// CHECK-NEXT: acc.yield
+// CHECK: acc.loop {
// CHECK-NEXT: "test.openacc_dummy_op"() : () -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
@@ -366,22 +332,25 @@ func.func @testloopop(%a : memref<10xf32>) -> () {
// -----
func.func @acc_loop_multiple_block() {
+ %c0 = arith.constant 0 : index
+ %c10 = arith.constant 10 : index
+ %c1 = arith.constant 1 : index
acc.parallel {
- acc.loop {
- %c1 = arith.constant 1 : index
- cf.br ^bb1(%c1 : index)
+ acc.loop (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
+ %c1_1 = arith.constant 1 : index
+ cf.br ^bb1(%c1_1 : index)
^bb1(%9: index):
- %c0 = arith.constant 0 : index
- %12 = arith.cmpi sgt, %9, %c0 : index
+ %c0_1 = arith.constant 0 : index
+ %12 = arith.cmpi sgt, %9, %c0_1 : index
cf.cond_br %12, ^bb2, ^bb3
^bb2:
%c1_0 = arith.constant 1 : index
- %c10 = arith.constant 10 : index
- %22 = arith.subi %c10, %c1_0 : index
+ %c10_1 = arith.constant 10 : index
+ %22 = arith.subi %c10_1, %c1_0 : index
cf.br ^bb1(%22 : index)
^bb3:
acc.yield
- }
+ } attributes {inclusiveUpperbound = array<i1: true>}
acc.yield
}
return
@@ -1509,10 +1478,13 @@ acc.reduction.recipe @reduction_add_i64 : i64 reduction_operator<add> init {
// CHECK: }
func.func @acc_reduc_test(%a : i64) -> () {
+ %c0 = arith.constant 0 : index
+ %c10 = arith.constant 10 : index
+ %c1 = arith.constant 1 : index
acc.parallel reduction(@reduction_add_i64 -> %a : i64) {
- acc.loop reduction(@reduction_add_i64 -> %a : i64) {
+ acc.loop reduction(@reduction_add_i64 -> %a : i64) (%iv : index) = (%c0 : index) to (%c10 : index) step (%c1 : index) {
acc.yield
- }
+ } attributes { inclusiveUpperbound = array<i1: true> }
acc.yield
}
return
More information about the Mlir-commits
mailing list