[MLIR][Affine] Add affine.parallel op

[flaub]

Summary

As discussed in https://llvm.discourse.group/t/rfc-add-affine-parallel/350, this is the first in a series of patches to bring in support for the affine.parallel operation.

This first patch adds the IR representation along with custom printer/parser implementations.

[flaub]

Rebase

[earhart]

LGTM

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

288

This sentence seems slightly awkward -- maybe something like,

Calling AffineParallelOp::build will automatically create the required region and block, and insert the required terminator.  Parsing will also create the required region, block, and terminator, even when they are missing from the textual representation.

? (Or maybe it's better to keep as-is, for consistency with AffineForOp...?)

[jbruestle]

Looks good.

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

298

Why use square brackets rather than parens? In general, tuples are usually parens.

mlir/lib/Dialect/AffineOps/AffineOps.cpp

140–141

I suspect this may mean that certain analysis/transforms may now fail (possibly via an assert?) if AffineParallelOp is used, but I think that probably can be fixed in later commits since nothing currently introduces AffineParallelOp yet.

[flaub]

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

298

This stems from the usage of parseAffineMapOfSSAIds, it apparently assumes square bracket delimiters.

@rriddle Would it break things if we allowed parseAffineMapOfSSAIds to take a delimiter so that we could group these ids in parens? I'm worried that this might cause ambiguity in the parser.

[herhut]

Some small comments. With changes syntax this looks great.

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

298

I would prefer () here, as well. I do not see an issue with changing the bracket style. Affine expressions should have matching opening/closing brackets, so the parser should not get confused by an extra closing bracket.

307

You could use SameVariadicOperandSize trait and then split the mapOperands into upper and lower bound here instead of implementing explicitly.

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2290–2299

Maybe if (llvm::any_of(steps(), ...)) {

2342

Maybe if (failed(parser... to make it more obvious that the first one is the failure case?

2347–2363

Could this code just parse a list of constant integers directly?

[flaub]

• Review feedback

[flaub]

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

288

Re-worded, thanks.

298

I extended the Parser to support specifying the delimiter to use with parseAffineMapOfSSAIds, and this works!

307

Great, TIL :)

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2290–2299

In order to print an array wrapped with parens, I needed to collect the elements of the array anyways. But I'm glad I learned about more LLVM functional helpers.

2342

SGTM

2347–2363

The only other Parser method available that I could find suitable was parseAttribute into an ArrayAttr, however this expects square brackets.

Should we extend the Parser to support this or perhaps save it for another (NFC) day?

[flaub]

• Improve error msg

[rriddle]

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

335

Drop all of the llvm:: and mlir::

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2168

nit: I would restructure this given that all of the lb elements are the same.

SmallVector<AffineExpr, 8> ubExprs;
for (int64_t range : ranges)
  ubExprs.push_back(builder->getAffineConstantExpr(range));

SmallVector<AffineExpr, 8> lbExprs(ubExprs.size(), builder->getAffineConstantExpr(0));

2176

nit: Can you change all of these comments to be complete sentences?

2200

Missing punctuation on each of these. Also please make them complete sentences.

2210

Remove the trivial braces.

2214

This is unnecessary.

2242

Remove trivial braces.

2242

Can you change this to early exit instead?

2254

Remove all of the mlir:: and llvm::.

2285

Remove trivial braces. Also, you can just do something like:

elideSteps &= (step == 1);

2315

nit: This is flowing to the next line, so just split it off and repeat the type.

[jbruestle]

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

307

I don't see any reason that both maps would always take the same number of operands. For example, if one wanted do:

affine.parallel (%i, %j) = (0,0) to (sym(N), sym(M)) {
  ...
}

which seems like a common enough use case, then lowerBoundOperands would be empty and upperBoundOperands would have 2 symbols. I think the use of SameVariadicOperandSize should be reverted.

[flaub]

• Review updates

[flaub]

Thanks, more changes incoming.

[flaub]

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2208

ensureTermniator is unnecessary, or just the redundant comment line?

[nicolasvasilache]

Thanks for pushing on this, LGTM!

[flaub]

@rriddle Are you OK with the latest changes? Thanks :)

[rriddle]

Looks great, thanks!

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

287

nit: Can you move Calling AffineParallelOp::... down to a Note: section?

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2208

The comment, sorry for the confusion.

2214

nit: you could do getOperands().take_front(lowerBoundsMap().getNumInputs())

2218

nit: Similarly here, but with drop_front.

2274

nit: Can you stream the arguments?

2371

nit: Remove the newline here.

[bondhugula]

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2180

Nit: dims -> dim or numDims

2193

Nit: -> Verify that the dimensionality of the maps matches the number of steps.

2238

out.reserve(rangesValueMap.getNumResults());

2257

Nit: message please - && "fewer/too many steps"

2262

Nit: dims -> numDims / nDims / dim ?

[bondhugula]

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2267

If you'd like to have all the canonicalizations surrounding affine operations and extend some of the affine analysis routines to this, you'll need to call verifyDimAndSymbolIdentifiers on the map operands. I don't think any of your current test cases will break, but you'll have to add a couple of invalid test cases where one of your map operands isn't a symbol - for eg. a value loaded right inside an outer loop.

[flaub]

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2267

Thanks! Done.

2274

Looks like no because getArguments() returns a MutableArrayRef<Value> and currently it appears that ValueRange isn't constructible from this.

[flaub]

• - Review updates

[rriddle]

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2274

It should be possible as of this morning.

[flaub]

Rebase

[flaub]

mlir/lib/Dialect/AffineOps/AffineOps.cpp

2274

Right you are :) done.

[flaub]

• stream

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

let description = [{
     affine map.
 
     Example:
 
        %0 = affine.max (d0) -> (1000, d0 + 512) (%i0) : index
   }];
 }
 
+def AffineParallelOp : Affine_Op<"parallel", [ImplicitAffineTerminator]> {
+  let summary = "multi-index parallel band operation";
+  let description = [{
+    The "affine.parallel" operation represents a hyper-rectangular affine
+    parallel band, defining multiple SSA values for its induction variables. It
+    has one region capturing the parallel band body. The induction variables are
+    represented as arguments of this region. These SSA values always have type
+    index, which is the size of the machine word. The strides, represented by
+    steps, are positive constant integers which defaults to "1" if not present.
+    The lower and upper bounds specify a half-open range: the range includes the
+    lower bound but does not include the upper bound. The body region must
+    contain exactly one block that terminates with "affine.terminator".
+
+    The lower and upper bounds of a parallel operation are represented as an
+    application of an affine mapping to a list of SSA values passed to the map.
+    The same restrictions hold for these SSA values as for all bindings of SSA
+    values to dimensions and symbols.
+
+    Note: Calling AffineParallelOp::build will create the required region and
+    block, and insert the required terminator. Parsing will also create the
+    required region, block, and terminator, even when they are missing from the
+    textual representation.
+
+    Example:
+
+    ```mlir
+      affine.parallel (%i, %j) = (0, 0) to (10, 10) step (1, 1) {
+        ...
+      }
+    ```
+  }];
+
+  let arguments = (ins
+     AffineMapAttr:$lowerBoundsMap,
+     AffineMapAttr:$upperBoundsMap,
+     I64ArrayAttr:$steps,
+     Variadic<Index>:$mapOperands);
+  let regions = (region SizedRegion<1>:$region);
+
+  let builders = [
+    OpBuilder<"Builder* builder, OperationState& result,"
+              "ArrayRef<int64_t> ranges">,
+    OpBuilder<"Builder* builder, OperationState& result, AffineMap lbMap,"
+              "ValueRange lbArgs, AffineMap ubMap, ValueRange ubArgs">,
+    OpBuilder<"Builder* builder, OperationState& result, AffineMap lbMap,"
+              "ValueRange lbArgs, AffineMap ubMap, ValueRange ubArgs,"
+              "ArrayRef<int64_t> steps">
+  ];
+
+  let extraClassDeclaration = [{
+    /// Get the number of dimensions.
+    unsigned getNumDims();
+
+    operand_range getLowerBoundsOperands();
+    operand_range getUpperBoundsOperands();
+
+    AffineValueMap getLowerBoundsValueMap();
+    AffineValueMap getUpperBoundsValueMap();
+    AffineValueMap getRangesValueMap();
+
+    /// Get ranges as constants, may fail in dynamic case.
+    Optional<SmallVector<int64_t, 8>> getConstantRanges();
+    
+    Block *getBody();
+    OpBuilder getBodyBuilder();
+    void setSteps(ArrayRef<int64_t> newSteps);
+
+    static StringRef getLowerBoundsMapAttrName() { return "lowerBoundsMap"; }
+    static StringRef getUpperBoundsMapAttrName() { return "upperBoundsMap"; }
+    static StringRef getStepsAttrName() { return "steps"; }
+  }];
+}
+
 def AffinePrefetchOp : Affine_Op<"prefetch"> {
   let summary = "affine prefetch operation";
   let description = [{
     The "affine.prefetch" op prefetches data from a memref location described
     with an affine subscript similar to affine.load, and has three attributes:
     a read/write specifier, a locality hint, and a cache type specifier as shown
     below:
 

mlir/include/mlir/IR/OpImplementation.h

virtual void printAffineMapOfSSAIds(AffineMapAttr mapAttr,
                                       ValueRange operands) = 0;
 
   /// Print an optional arrow followed by a type list.
   template <typename TypeRange>
   void printOptionalArrowTypeList(TypeRange &&types) {
     if (types.begin() != types.end())
       printArrowTypeList(types);
   }
-  template <typename TypeRange> void printArrowTypeList(TypeRange &&types) {
+  template <typename TypeRange>
+  void printArrowTypeList(TypeRange &&types) {
     auto &os = getStream() << " -> ";
 
     bool wrapped = !has_single_element(types) ||
                    (*types.begin()).template isa<FunctionType>();
     if (wrapped)
       os << '(';
     interleaveComma(types, *this);
     if (wrapped)
public:
   }
 
   /// Parses an affine map attribute where dims and symbols are SSA operands.
   /// Operand values must come from single-result sources, and be valid
   /// dimensions/symbol identifiers according to mlir::isValidDim/Symbol.
   virtual ParseResult
   parseAffineMapOfSSAIds(SmallVectorImpl<OperandType> &operands, Attribute &map,
                          StringRef attrName,
-                         SmallVectorImpl<NamedAttribute> &attrs) = 0;
+                         SmallVectorImpl<NamedAttribute> &attrs,
+                         Delimiter delimiter = Delimiter::Square) = 0;
 
   //===--------------------------------------------------------------------===//
   // Region Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parses a region. Any parsed blocks are appended to "region" and must be
   /// moved to the op regions after the op is created. The first block of the
   /// region takes "arguments" of types "argTypes". If "enableNameShadowing" is
public:
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   virtual ParseResult parseType(Type &result) = 0;
 
   /// Parse a type of a specific type.
-  template <typename TypeT> ParseResult parseType(TypeT &result) {
+  template <typename TypeT>
+  ParseResult parseType(TypeT &result) {
     llvm::SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseType(type))
       return failure();
 
     // Check for the right kind of attribute.
public:
   /// Parse an optional arrow followed by a type list.
   virtual ParseResult
   parseOptionalArrowTypeList(SmallVectorImpl<Type> &result) = 0;
 
   /// Parse a colon followed by a type.
   virtual ParseResult parseColonType(Type &result) = 0;
 
   /// Parse a colon followed by a type of a specific kind, e.g. a FunctionType.
-  template <typename TypeType> ParseResult parseColonType(TypeType &result) {
+  template <typename TypeType>
+  ParseResult parseColonType(TypeType &result) {
     llvm::SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseColonType(type))
       return failure();
 
     // Check for the right kind of attribute.

mlir/lib/Dialect/AffineOps/AffineOps.cpp

if (auto *op = value.getDefiningOp()) {
     if (auto applyOp = dyn_cast<AffineApplyOp>(op))
       return applyOp.isValidDim();
     // The dim op is okay if its operand memref/tensor is defined at the top
     // level.
     if (auto dimOp = dyn_cast<DimOp>(op))
       return isTopLevelValue(dimOp.getOperand());
     return false;
   }
-  // This value has to be a block argument for a FuncOp or an affine.for.
+  // This value has to be a block argument of a FuncOp, an 'affine.for', or an
+  // 'affine.parallel'.
   auto *parentOp = value.cast<BlockArgument>().getOwner()->getParentOp();
-  return isa<FuncOp>(parentOp) || isa<AffineForOp>(parentOp);
+  return isa<FuncOp>(parentOp) || isa<AffineForOp>(parentOp) ||
+         isa<AffineParallelOp>(parentOp);
 }
 
 /// Returns true if the 'index' dimension of the `memref` defined by
 /// `memrefDefOp` is a statically  shaped one or defined using a valid symbol.
 template <typename AnyMemRefDefOp>
 static bool isMemRefSizeValidSymbol(AnyMemRefDefOp memrefDefOp,
                                     unsigned index) {
   auto memRefType = memrefDefOp.getType();

 
 LogicalResult AffinePrefetchOp::fold(ArrayRef<Attribute> cstOperands,
                                      SmallVectorImpl<OpFoldResult> &results) {
   /// prefetch(memrefcast) -> prefetch
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
+// AffineParallelOp
+//===----------------------------------------------------------------------===//
+
+void AffineParallelOp::build(Builder *builder, OperationState &result,
+                             ArrayRef<int64_t> ranges) {
+  // Default initalize empty maps.
+  auto lbMap = AffineMap::get(builder->getContext());
+  auto ubMap = AffineMap::get(builder->getContext());
+  // If there are ranges, set each to [0, N).
+  if (ranges.size()) {
+    SmallVector<AffineExpr, 8> lbExprs(ranges.size(),
+                                       builder->getAffineConstantExpr(0));
+    lbMap = AffineMap::get(0, 0, lbExprs);
+    SmallVector<AffineExpr, 8> ubExprs;
+    for (int64_t range : ranges)
+      ubExprs.push_back(builder->getAffineConstantExpr(range));
+    ubMap = AffineMap::get(0, 0, ubExprs);
+  }
+  build(builder, result, lbMap, {}, ubMap, {});
+}
+
+void AffineParallelOp::build(Builder *builder, OperationState &result,
+                             AffineMap lbMap, ValueRange lbArgs,
+                             AffineMap ubMap, ValueRange ubArgs) {
+  auto numDims = lbMap.getNumResults();
+  // Verify that the dimensionality of both maps are the same.
+  assert(numDims == ubMap.getNumResults() &&
+         "num dims and num results mismatch");
+  // Make default step sizes of 1.
+  SmallVector<int64_t, 8> steps(numDims, 1);
+  build(builder, result, lbMap, lbArgs, ubMap, ubArgs, steps);
+}
+
+void AffineParallelOp::build(Builder *builder, OperationState &result,
+                             AffineMap lbMap, ValueRange lbArgs,
+                             AffineMap ubMap, ValueRange ubArgs,
+                             ArrayRef<int64_t> steps) {
+  auto numDims = lbMap.getNumResults();
+  // Verify that the dimensionality of the maps matches the number of steps.
+  assert(numDims == ubMap.getNumResults() &&
+         "num dims and num results mismatch");
+  assert(numDims == steps.size() && "num dims and num steps mismatch");
+  result.addAttribute(getLowerBoundsMapAttrName(), AffineMapAttr::get(lbMap));
+  result.addAttribute(getUpperBoundsMapAttrName(), AffineMapAttr::get(ubMap));
+  result.addAttribute(getStepsAttrName(), builder->getI64ArrayAttr(steps));
+  result.addOperands(lbArgs);
+  result.addOperands(ubArgs);
+  // Create a region and a block for the body.
+  auto bodyRegion = result.addRegion();
+  auto body = new Block();
+  // Add all the block arguments.
+  for (unsigned i = 0; i < numDims; ++i)
+    body->addArgument(IndexType::get(builder->getContext()));
+  bodyRegion->push_back(body);
+  ensureTerminator(*bodyRegion, *builder, result.location);
+}
+
+unsigned AffineParallelOp::getNumDims() { return steps().size(); }
+
+AffineParallelOp::operand_range AffineParallelOp::getLowerBoundsOperands() {
+  return getOperands().take_front(lowerBoundsMap().getNumInputs());
+}
+
+AffineParallelOp::operand_range AffineParallelOp::getUpperBoundsOperands() {
+  return getOperands().drop_front(lowerBoundsMap().getNumInputs());
+}
+
+AffineValueMap AffineParallelOp::getLowerBoundsValueMap() {
+  return AffineValueMap(lowerBoundsMap(), getLowerBoundsOperands());
+}
+
+AffineValueMap AffineParallelOp::getUpperBoundsValueMap() {
+  return AffineValueMap(upperBoundsMap(), getUpperBoundsOperands());
+}
+
+AffineValueMap AffineParallelOp::getRangesValueMap() {
+  AffineValueMap out;
+  AffineValueMap::difference(getUpperBoundsValueMap(), getLowerBoundsValueMap(),
+                             &out);
+  return out;
+}
+
+Optional<SmallVector<int64_t, 8>> AffineParallelOp::getConstantRanges() {
+  // Try to convert all the ranges to constant expressions.
+  SmallVector<int64_t, 8> out;
+  AffineValueMap rangesValueMap = getRangesValueMap();
+  out.reserve(rangesValueMap.getNumResults());
+  for (unsigned i = 0, e = rangesValueMap.getNumResults(); i < e; ++i) {
+    auto expr = rangesValueMap.getResult(i);
+    auto cst = expr.dyn_cast<AffineConstantExpr>();
+    if (!cst)
+      return llvm::None;
+    out.push_back(cst.getValue());
+  }
+  return out;
+}
+
+Block *AffineParallelOp::getBody() { return &region().front(); }
+
+OpBuilder AffineParallelOp::getBodyBuilder() {
+  return OpBuilder(getBody(), std::prev(getBody()->end()));
+}
+
+void AffineParallelOp::setSteps(ArrayRef<int64_t> newSteps) {
+  assert(newSteps.size() == getNumDims() && "steps & num dims mismatch");
+  setAttr(getStepsAttrName(), getBodyBuilder().getI64ArrayAttr(newSteps));
+}
+
+static LogicalResult verify(AffineParallelOp op) {
+  auto numDims = op.getNumDims();
+  if (op.lowerBoundsMap().getNumResults() != numDims ||
+      op.upperBoundsMap().getNumResults() != numDims ||
+      op.steps().size() != numDims ||
+      op.getBody()->getNumArguments() != numDims) {
+    return op.emitOpError("region argument count and num results of upper "
+                          "bounds, lower bounds, and steps must all match");
+  }
+  // Verify that the bound operands are valid dimension/symbols.
+  /// Lower bounds.
+  if (failed(verifyDimAndSymbolIdentifiers(op, op.getLowerBoundsOperands(),
+                                           op.lowerBoundsMap().getNumDims())))
+    return failure();
+  /// Upper bounds.
+  if (failed(verifyDimAndSymbolIdentifiers(op, op.getUpperBoundsOperands(),
+                                           op.upperBoundsMap().getNumDims())))
+    return failure();
+  return success();
+}
+
+static void print(OpAsmPrinter &p, AffineParallelOp op) {
+  p << op.getOperationName() << " (" << op.getBody()->getArguments() << ") = (";
+  p.printAffineMapOfSSAIds(op.lowerBoundsMapAttr(),
+                           op.getLowerBoundsOperands());
+  p << ") to (";
+  p.printAffineMapOfSSAIds(op.upperBoundsMapAttr(),
+                           op.getUpperBoundsOperands());
+  p << ')';
+  SmallVector<int64_t, 4> steps;
+  bool elideSteps = true;
+  for (auto attr : op.steps()) {
+    auto step = attr.cast<IntegerAttr>().getInt();
+    elideSteps &= (step == 1);
+    steps.push_back(step);
+  }
+  if (!elideSteps) {
+    p << " step (";
+    interleaveComma(steps, p);
+    p << ')';
+  }
+  p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
+                /*printBlockTerminators=*/false);
+  p.printOptionalAttrDict(
+      op.getAttrs(),
+      /*elidedAttrs=*/{AffineParallelOp::getLowerBoundsMapAttrName(),
+                       AffineParallelOp::getUpperBoundsMapAttrName(),
+                       AffineParallelOp::getStepsAttrName()});
+}
+
+//
+// operation ::= `affine.parallel` `(` ssa-ids `)` `=` `(` map-of-ssa-ids `)`
+//               `to` `(` map-of-ssa-ids `)` steps? region attr-dict?
+// steps     ::= `steps` `(` integer-literals `)`
+//
+static ParseResult parseAffineParallelOp(OpAsmParser &parser,
+                                         OperationState &result) {
+  auto &builder = parser.getBuilder();
+  auto indexType = builder.getIndexType();
+  AffineMapAttr lowerBoundsAttr, upperBoundsAttr;
+  SmallVector<OpAsmParser::OperandType, 4> ivs;
+  SmallVector<OpAsmParser::OperandType, 4> lowerBoundsMapOperands;
+  SmallVector<OpAsmParser::OperandType, 4> upperBoundsMapOperands;
+  if (parser.parseRegionArgumentList(ivs, /*requiredOperandCount=*/-1,
+                                     OpAsmParser::Delimiter::Paren) ||
+      parser.parseEqual() ||
+      parser.parseAffineMapOfSSAIds(
+          lowerBoundsMapOperands, lowerBoundsAttr,
+          AffineParallelOp::getLowerBoundsMapAttrName(), result.attributes,
+          OpAsmParser::Delimiter::Paren) ||
+      parser.resolveOperands(lowerBoundsMapOperands, indexType,
+                             result.operands) ||
+      parser.parseKeyword("to") ||
+      parser.parseAffineMapOfSSAIds(
+          upperBoundsMapOperands, upperBoundsAttr,
+          AffineParallelOp::getUpperBoundsMapAttrName(), result.attributes,
+          OpAsmParser::Delimiter::Paren) ||
+      parser.resolveOperands(upperBoundsMapOperands, indexType,
+                             result.operands))
+    return failure();
+
+  AffineMapAttr stepsMapAttr;
+  SmallVector<NamedAttribute, 1> stepsAttrs;
+  SmallVector<OpAsmParser::OperandType, 4> stepsMapOperands;
+  if (failed(parser.parseOptionalKeyword("step"))) {
+    SmallVector<int64_t, 4> steps(ivs.size(), 1);
+    result.addAttribute(AffineParallelOp::getStepsAttrName(),
+                        builder.getI64ArrayAttr(steps));
+  } else {
+    if (parser.parseAffineMapOfSSAIds(stepsMapOperands, stepsMapAttr,
+                                      AffineParallelOp::getStepsAttrName(),
+                                      stepsAttrs,
+                                      OpAsmParser::Delimiter::Paren))
+      return failure();
+
+    // Convert steps from an AffineMap into an I64ArrayAttr.
+    SmallVector<int64_t, 4> steps;
+    auto stepsMap = stepsMapAttr.getValue();
+    for (const auto &result : stepsMap.getResults()) {
+      auto constExpr = result.dyn_cast<AffineConstantExpr>();
+      if (!constExpr)
+        return parser.emitError(parser.getNameLoc(),
+                                "steps must be constant integers");
+      steps.push_back(constExpr.getValue());
+    }
+    result.addAttribute(AffineParallelOp::getStepsAttrName(),
+                        builder.getI64ArrayAttr(steps));
+  }
+
+  // Now parse the body.
+  Region *body = result.addRegion();
+  SmallVector<Type, 4> types(ivs.size(), indexType);
+  if (parser.parseRegion(*body, ivs, types) ||
+      parser.parseOptionalAttrDict(result.attributes))
+    return failure();
+
+  // Add a terminator if none was parsed.
+  AffineParallelOp::ensureTerminator(*body, builder, result.location);
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/AffineOps/AffineOps.cpp.inc"

mlir/lib/Parser/Parser.cpp

public:
   ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map,
                                                   IntegerSet &set);
   ParseResult parseAffineMapReference(AffineMap &map);
   ParseResult parseIntegerSetReference(IntegerSet &set);
 
   /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
   ParseResult
   parseAffineMapOfSSAIds(AffineMap &map,
-                         function_ref<ParseResult(bool)> parseElement);
+                         function_ref<ParseResult(bool)> parseElement,
+                         OpAsmParser::Delimiter delimiter);
 
 private:
   /// The Parser is subclassed and reinstantiated.  Do not add additional
   /// non-trivial state here, add it to the ParserState class.
   ParserState &state;
 };
 } // end anonymous namespace
 
public:
   AffineParser(ParserState &state, bool allowParsingSSAIds = false,
                function_ref<ParseResult(bool)> parseElement = nullptr)
       : Parser(state), allowParsingSSAIds(allowParsingSSAIds),
         parseElement(parseElement), numDimOperands(0), numSymbolOperands(0) {}
 
   AffineMap parseAffineMapRange(unsigned numDims, unsigned numSymbols);
   ParseResult parseAffineMapOrIntegerSetInline(AffineMap &map, IntegerSet &set);
   IntegerSet parseIntegerSetConstraints(unsigned numDims, unsigned numSymbols);
-  ParseResult parseAffineMapOfSSAIds(AffineMap &map);
+  ParseResult parseAffineMapOfSSAIds(AffineMap &map,
+                                     OpAsmParser::Delimiter delimiter);
   void getDimsAndSymbolSSAIds(SmallVectorImpl<StringRef> &dimAndSymbolSSAIds,
                               unsigned &numDims);
 
 private:
   // Binary affine op parsing.
   AffineLowPrecOp consumeIfLowPrecOp();
   AffineHighPrecOp consumeIfHighPrecOp();
 
ParseResult AffineParser::parseAffineMapOrIntegerSetInline(AffineMap &map,
 
   if ((set = parseIntegerSetConstraints(numDims, numSymbols)))
     return success();
 
   return failure();
 }
 
 /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
-ParseResult AffineParser::parseAffineMapOfSSAIds(AffineMap &map) {
+ParseResult
+AffineParser::parseAffineMapOfSSAIds(AffineMap &map,
+                                     OpAsmParser::Delimiter delimiter) {
+  Token::Kind rightToken;
+  switch (delimiter) {
+  case OpAsmParser::Delimiter::Square:
     if (parseToken(Token::l_square, "expected '['"))
       return failure();
+    rightToken = Token::r_square;
+    break;
+  case OpAsmParser::Delimiter::Paren:
+    if (parseToken(Token::l_paren, "expected '('"))
+      return failure();
+    rightToken = Token::r_paren;
+    break;
+  default:
+    return emitError("unexpected delimiter");
+  }
 
   SmallVector<AffineExpr, 4> exprs;
   auto parseElt = [&]() -> ParseResult {
     auto elt = parseAffineExpr();
     exprs.push_back(elt);
     return elt ? success() : failure();
   };
 
   // Parse a multi-dimensional affine expression (a comma-separated list of
   // 1-d affine expressions); the list cannot be empty. Grammar:
   // multi-dim-affine-expr ::= `(` affine-expr (`,` affine-expr)* `)
-  if (parseCommaSeparatedListUntil(Token::r_square, parseElt,
+  if (parseCommaSeparatedListUntil(rightToken, parseElt,
                                    /*allowEmptyList=*/true))
     return failure();
   // Parsed a valid affine map.
   if (exprs.empty())
     map = AffineMap::get(getContext());
   else
     map = AffineMap::get(numDimOperands, dimsAndSymbols.size() - numDimOperands,
                          exprs);
if (map)
     return emitError(curLoc, "expected IntegerSet, but got AffineMap");
   return success();
 }
 
 /// Parse an AffineMap of SSA ids. The callback 'parseElement' is used to
 /// parse SSA value uses encountered while parsing affine expressions.
 ParseResult
 Parser::parseAffineMapOfSSAIds(AffineMap &map,
-                               function_ref<ParseResult(bool)> parseElement) {
+                               function_ref<ParseResult(bool)> parseElement,
+                               OpAsmParser::Delimiter delimiter) {
   return AffineParser(state, /*allowParsingSSAIds=*/true, parseElement)
-      .parseAffineMapOfSSAIds(map);
+      .parseAffineMapOfSSAIds(map, delimiter);
 }
 
 //===----------------------------------------------------------------------===//
 // OperationParser
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class provides support for parsing operations and regions of
ParseResult resolveOperand(const OperandType &operand, Type type,
     if (auto value = parser.resolveSSAUse(operandInfo, type)) {
       result.push_back(value);
       return success();
     }
     return failure();
   }
 
   /// Parse an AffineMap of SSA ids.
-  ParseResult
-  parseAffineMapOfSSAIds(SmallVectorImpl<OperandType> &operands,
+  ParseResult parseAffineMapOfSSAIds(SmallVectorImpl<OperandType> &operands,
                                      Attribute &mapAttr, StringRef attrName,
-                         SmallVectorImpl<NamedAttribute> &attrs) override {
+                                     SmallVectorImpl<NamedAttribute> &attrs,
+                                     Delimiter delimiter) override {
     SmallVector<OperandType, 2> dimOperands;
     SmallVector<OperandType, 1> symOperands;
 
     auto parseElement = [&](bool isSymbol) -> ParseResult {
       OperandType operand;
       if (parseOperand(operand))
         return failure();
       if (isSymbol)
         symOperands.push_back(operand);
       else
         dimOperands.push_back(operand);
       return success();
     };
 
     AffineMap map;
-    if (parser.parseAffineMapOfSSAIds(map, parseElement))
+    if (parser.parseAffineMapOfSSAIds(map, parseElement, delimiter))
       return failure();
     // Add AffineMap attribute.
     if (map) {
       mapAttr = AffineMapAttr::get(map);
       attrs.push_back(parser.builder.getNamedAttr(attrName, mapAttr));
     }
 
     // Add dim operands before symbol operands in 'operands'.

mlir/test/AffineOps/invalid.mlir

 // -----
 
 // CHECK-LABEL: @affine_max
 func @affine_max(%arg0 : index, %arg1 : index, %arg2 : index) {
   // expected-error@+1 {{operand count and affine map dimension and symbol count must match}}
   %0 = affine.max affine_map<(d0) -> (d0)> ()
 
   return
-}
+}
+
+// -----
+
+// CHECK-LABEL: @affine_parallel
+func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
+  // expected-error@+1 {{region argument count and num results of upper bounds, lower bounds, and steps must all match}}
+  affine.parallel (%i) = (0, 0) to (100, 100) step (10, 10) {
+  }
+}
+
+// -----
+
+// CHECK-LABEL: @affine_parallel
+func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
+  // expected-error@+1 {{region argument count and num results of upper bounds, lower bounds, and steps must all match}}
+  affine.parallel (%i, %j) = (0) to (100, 100) step (10, 10) {
+  }
+}
+
+// -----
+
+// CHECK-LABEL: @affine_parallel
+func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
+  // expected-error@+1 {{region argument count and num results of upper bounds, lower bounds, and steps must all match}}
+  affine.parallel (%i, %j) = (0, 0) to (100) step (10, 10) {
+  }
+}
+
+// -----
+
+// CHECK-LABEL: @affine_parallel
+func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
+  // expected-error@+1 {{region argument count and num results of upper bounds, lower bounds, and steps must all match}}
+  affine.parallel (%i, %j) = (0, 0) to (100, 100) step (10) {
+  }
+}
+
+// -----
+
+// CHECK-LABEL: @affine_parallel
+
+func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
+  affine.for %x = 0 to 7 {
+    %y = addi %x, %x : index
+    // expected-error@+1 {{operand cannot be used as a dimension id}}
+    affine.parallel (%i, %j) = (0, 0) to (%y, 100) step (10, 10) {
+    }
+  }
+  return
+}
+
+// -----
+
+// CHECK-LABEL: @affine_parallel
+
+func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
+  affine.for %x = 0 to 7 {
+    %y = addi %x, %x : index
+    // expected-error@+1 {{operand cannot be used as a symbol}}
+    affine.parallel (%i, %j) = (0, 0) to (symbol(%y), 100) step (10, 10) {
+    }
+  }
+  return
+}

mlir/test/AffineOps/ops.mlir

affine.for %arg4 = 0 to %13 step 264 {
       %24 = dim %20, 0 : memref<?x?xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>>
       affine.for %arg5 = 0 to %24 step 768 {
         "foo"() : () -> ()
       }
     }
   }
   return
 }
+
+// -----
+
+// CHECK-LABEL: @parallel
+// CHECK-SAME: (%[[N:.*]]: index)
+func @parallel(%N : index) {
+  // CHECK: affine.parallel (%[[I0:.*]], %[[J0:.*]]) = (0, 0) to (symbol(%[[N]]), 100) step (10, 10)
+  affine.parallel (%i0, %j0) = (0, 0) to (symbol(%N), 100) step (10, 10) {
+    // CHECK-NEXT: affine.parallel (%{{.*}}, %{{.*}}) = (%[[I0]], %[[J0]]) to (%[[I0]] + 10, %[[J0]] + 10)
+    affine.parallel (%i1, %j1) = (%i0, %j0) to (%i0 + 10, %j0 + 10) {
+    }
+  }
+  return
+}