From 6aa9f0db3a39a877a87245206c7562ed27f77657 Mon Sep 17 00:00:00 2001 From: Sam Date: Wed, 1 May 2024 12:20:02 -0500 Subject: [PATCH 01/18] Add support for transform.param values in `PadOp`s pad_to_multiple_of --- .../Linalg/TransformOps/LinalgTransformOps.td | 17 ++- .../TransformOps/LinalgTransformOps.cpp | 112 ++++++++++++++++-- .../mlir/dialects/transform/structured.py | 20 +++- .../test/Dialect/Linalg/transform-op-pad.mlir | 3 +- .../dialects/transform_structured_ext.py | 5 +- 5 files changed, 140 insertions(+), 17 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index d0ad4ccdf031d..16fb8f4fcc946 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -1011,7 +1011,9 @@ def PadOp : Op:$padding_values, DefaultValuedAttr:$padding_dimensions, - OptionalAttr:$pad_to_multiple_of, + Variadic:$pad_to_multiple_of, + DefaultValuedOptionalAttr: + $static_pad_to_multiple_of, DefaultValuedAttr:$pack_paddings, DefaultValuedAttr< TypedArrayAttrBase, @@ -1021,8 +1023,7 @@ def PadOp : Op":$paddingDimensions, - CArg<"ArrayRef", "{}">:$padToMultipleOf, + CArg<"ArrayRef", "{}">:$staticPadToMultipleOf, + CArg<"ArrayRef", "{}">:$packPaddings, + CArg<"ArrayRef", "{}">:$transposePaddings, + CArg<"StringRef", "::mlir::bufferization::MaterializeInDestinationOp::getOperationName()">:$copyBackOp)>, + OpBuilder<(ins "Value":$target, + "ArrayRef":$paddingDimensions, + "ArrayRef":$mixedPadToMultipleOf, CArg<"ArrayRef", "{}">:$packPaddings, CArg<"ArrayRef", "{}">:$transposePaddings, CArg<"StringRef", "::mlir::bufferization::MaterializeInDestinationOp::getOperationName()">:$copyBackOp)> @@ -1043,6 +1050,8 @@ def PadOp : Op getMixedPadToMultipleOf(); + ::mlir::DiagnosedSilenceableFailure applyToOne( ::mlir::transform::TransformRewriter &rewriter, ::mlir::linalg::LinalgOp target, diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index 156784f0e6740..dc060f4c0641c 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -1664,6 +1664,8 @@ transform::PackTransposeOp::apply(transform::TransformRewriter &rewriter, // PadOp //===---------------------------------------------------------------------===// +static const StringLiteral kPadToMultipleOfKeyword = "pad_to_multiple_of"; + void transform::PadOp::build(OpBuilder &b, OperationState &result, Value target, ArrayRef paddingDimensions, ArrayRef padToMultipleOf, @@ -1677,14 +1679,111 @@ void transform::PadOp::build(OpBuilder &b, OperationState &result, Value target, /*target=*/target, /*paddingValues=*/ArrayAttr(), // let inference handle this /*paddingDimensions=*/b.getI64ArrayAttr(paddingDimensions), + /*padToMultipleOf=*/ValueRange{}, /*padToMultipleOf=*/ - (padToMultipleOf.empty() ? ArrayAttr() - : b.getI64ArrayAttr(padToMultipleOf)), + (padToMultipleOf.empty() + ? DenseI64ArrayAttr() + : b.getDenseI64ArrayAttr(padToMultipleOf)), + /*packPaddings=*/b.getI64ArrayAttr(packPaddings), + /*transposePaddings=*/b.getArrayAttr(transposePaddings), + /*copyBackOp=*/b.getStringAttr(copyBackOp)); +} + +void transform::PadOp::build(OpBuilder &b, OperationState &result, Value target, + ArrayRef paddingDimensions, + ArrayRef mixedPadToMultipleOf, + ArrayRef packPaddings, + ArrayRef transposePaddings, + StringRef copyBackOp) { + auto resultType = transform::AnyOpType::get(b.getContext()); + SmallVector staticPadToMultipleOf; + SmallVector dynamicPadToMultipleOf; + dispatchIndexOpFoldResults(mixedPadToMultipleOf, dynamicPadToMultipleOf, + staticPadToMultipleOf); + return build(/*builder=*/b, + /*result=*/result, + /*types=*/TypeRange{resultType, resultType}, + /*target=*/target, + /*paddingValues=*/ArrayAttr(), // let inference handle this + /*paddingDimensions=*/b.getI64ArrayAttr(paddingDimensions), + /*padToMultipleOf=*/dynamicPadToMultipleOf, + /*padToMultipleOf=*/staticPadToMultipleOf, /*packPaddings=*/b.getI64ArrayAttr(packPaddings), /*transposePaddings=*/b.getArrayAttr(transposePaddings), /*copyBackOp=*/b.getStringAttr(copyBackOp)); } +SmallVector PadOp::getMixedPadToMultipleOf() { + OpBuilder b(getContext()); + return getMixedValues(getStaticPadToMultipleOf(), getPadToMultipleOf(), b); +} + +ParseResult transform::PadOp::parse(OpAsmParser &parser, + OperationState &result) { + OpAsmParser::UnresolvedOperand target; + SmallVector dynamicPadToMultipleOf; + DenseI64ArrayAttr padToMultipleOf; + FunctionType functionalType; + llvm::SMLoc operandLoc; + + if (parser.parseOperand(target) || parser.getCurrentLocation(&operandLoc)) + return ParseResult::failure(); + + if (succeeded(parser.parseOptionalKeyword(kPadToMultipleOfKeyword))) { + if (failed(parseDynamicIndexList(parser, dynamicPadToMultipleOf, + padToMultipleOf))) + return ParseResult::failure(); + } + + if (parser.parseOptionalAttrDict(result.attributes) || + parser.parseColonType(functionalType) || + parser.resolveOperand(target, functionalType.getInputs().front(), + result.operands) || + parser.resolveOperands(dynamicPadToMultipleOf, + functionalType.getInputs().drop_front(), + operandLoc, result.operands)) + return ParseResult::failure(); + + if (padToMultipleOf) + result.addAttribute(getStaticPadToMultipleOfAttrName(result.name), + padToMultipleOf); + + result.addTypes(functionalType.getResults()); + + return success(); +} + +void transform::PadOp::print(OpAsmPrinter &p) { + p << ' ' << getTarget() << ' '; + if (!getMixedPadToMultipleOf().empty()) { + p << kPadToMultipleOfKeyword << ' '; + printDynamicIndexList(p, getOperation(), getPadToMultipleOf(), + getStaticPadToMultipleOfAttr(), + /*valueTypes=*/{}, + /*scalables=*/{}, OpAsmParser::Delimiter::Square); + } + + OpBuilder builder((*this)->getContext()); + SmallVector elidedAttrs({getStaticPadToMultipleOfAttrName()}); + if (getCopyBackOpAttr() == + builder.getStringAttr( + bufferization::MaterializeInDestinationOp::getOperationName())) + elidedAttrs.push_back(getCopyBackOpAttrName()); + if (getPackPaddingsAttr() == builder.getI64ArrayAttr({})) + elidedAttrs.push_back(getPackPaddingsAttrName()); + if (getTransposePaddingsAttr() == builder.getI64ArrayAttr({})) + elidedAttrs.push_back(getTransposePaddingsAttrName()); + if (getPaddingDimensionsAttr() == builder.getI64ArrayAttr({})) + elidedAttrs.push_back(getPaddingDimensionsAttrName()); + if (getPaddingValuesAttr() == builder.getArrayAttr({})) + elidedAttrs.push_back(getPaddingValuesAttrName()); + + p.printOptionalAttrDict((*this)->getAttrs(), + /*elidedAttrs=*/elidedAttrs); + p << " : "; + p.printFunctionalType(getOperands().getTypes(), getResults().getTypes()); +} + DiagnosedSilenceableFailure transform::PadOp::apply(transform::TransformRewriter &rewriter, transform::TransformResults &results, @@ -1750,9 +1849,8 @@ transform::PadOp::apply(transform::TransformRewriter &rewriter, options.paddingDimensions = extractFromIntegerArrayAttr(getPaddingDimensions()); SmallVector padToMultipleOf(options.paddingDimensions.size(), 1); - if (getPadToMultipleOf().has_value()) - padToMultipleOf = - extractFromIntegerArrayAttr(*getPadToMultipleOf()); + if (!getStaticPadToMultipleOf().empty()) + padToMultipleOf = llvm::to_vector(getStaticPadToMultipleOf()); options.padToMultipleOf = padToMultipleOf; options.paddingValues = paddingValues; options.packPaddings = packPaddings; @@ -1819,8 +1917,8 @@ LogicalResult transform::PadOp::verify() { "integers, found " << getPaddingDimensions(); } - if (getPadToMultipleOf().has_value()) { - if (getPadToMultipleOf()->size() != paddingDimensions.size()) { + if (!getMixedPadToMultipleOf().empty()) { + if (getMixedPadToMultipleOf().size() != paddingDimensions.size()) { return emitOpError() << "expects as many multiples as padding_dimensions"; } } diff --git a/mlir/python/mlir/dialects/transform/structured.py b/mlir/python/mlir/dialects/transform/structured.py index d7b41c0bd2207..81bbd6ffb3d40 100644 --- a/mlir/python/mlir/dialects/transform/structured.py +++ b/mlir/python/mlir/dialects/transform/structured.py @@ -373,10 +373,11 @@ class PadOp(PadOp): def __init__( self, target: Union[Operation, OpView, Value], + pad_to_multiple_of: Optional[Union[DynamicIndexList, ArrayAttr]] = None, *, padding_values: Optional[Union[ArrayAttr, Sequence[Attribute]]] = None, padding_dimensions: OptionalIntList = None, - pad_to_multiple_of: OptionalIntList = None, + static_pad_to_multiple_of: OptionalIntList = None, pack_paddings: OptionalIntList = None, transpose_paddings: Optional[ Union[ArrayAttr, Sequence[Union[ArrayAttr, IntOrAttrList]]] @@ -385,6 +386,20 @@ def __init__( loc=None, ip=None, ): + if ( + static_pad_to_multiple_of is None + and pad_to_multiple_of is None + ): + dynamic_pad_to_multiple_of = [] + elif static_pad_to_multiple_of is None: + ( + dynamic_pad_to_multiple_of, + static_pad_to_multiple_of, + _, + ) = _dispatch_dynamic_index_list(pad_to_multiple_of) + else: + dynamic_pad_to_multiple_of = pad_to_multiple_of + transpose_paddings = _get_int_array_array_attr(transpose_paddings) any_op_type = transform.AnyOpType.get() @@ -393,9 +408,10 @@ def __init__( any_op_type, any_op_type, target, + pad_to_multiple_of=dynamic_pad_to_multiple_of, padding_values=padding_values, padding_dimensions=padding_dimensions, - pad_to_multiple_of=pad_to_multiple_of, + static_pad_to_multiple_of=static_pad_to_multiple_of, pack_paddings=pack_paddings, transpose_paddings=transpose_paddings, copy_back_op=copy_back_op, diff --git a/mlir/test/Dialect/Linalg/transform-op-pad.mlir b/mlir/test/Dialect/Linalg/transform-op-pad.mlir index d27276cda49dc..f82d4500090c5 100644 --- a/mlir/test/Dialect/Linalg/transform-op-pad.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-pad.mlir @@ -73,10 +73,9 @@ func.func @pad_to_multiple(%arg0: tensor<24x12xf32>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %padded, %pad, %copy_back = transform.structured.pad %0 { + %padded, %pad, %copy_back = transform.structured.pad %0 pad_to_multiple_of [2, 2, 1] { padding_values=[0.0 : f32, 0.0 : f32, 0.0 : f32], padding_dimensions=[0, 1, 2], - pad_to_multiple_of=[2, 2, 1], pack_paddings=[1, 1, 0] } : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield diff --git a/mlir/test/python/dialects/transform_structured_ext.py b/mlir/test/python/dialects/transform_structured_ext.py index 91ecd0fc38e17..418b1216df053 100644 --- a/mlir/test/python/dialects/transform_structured_ext.py +++ b/mlir/test/python/dialects/transform_structured_ext.py @@ -315,9 +315,10 @@ def testPadOpNoArgs(target): def testPadOpArgs(target): structured.PadOp( target, + [], padding_values=[FloatAttr.get_f32(42.0), StringAttr.get("0")], padding_dimensions=Attribute.parse("[1]"), - pad_to_multiple_of=[128], + static_pad_to_multiple_of=[128], pack_paddings=[0], transpose_paddings=[[1, Attribute.parse("0")], Attribute.parse("[0, 1]")], copy_back_op="linalg.copy", @@ -325,9 +326,9 @@ def testPadOpArgs(target): # CHECK-LABEL: TEST: testPadOpArgs # CHECK: transform.sequence # CHECK: transform.structured.pad + # CHECK-DAG: pad_to_multiple_of [128] # CHECK-DAG: copy_back_op = "linalg.copy" # CHECK-DAG: pack_paddings = [0] - # CHECK-DAG: pad_to_multiple_of = [128] # CHECK-DAG: padding_dimensions = [1] # CHECK-DAG: padding_values = [4.200000e+01 : f32, "0"] # CHECK-DAG: transpose_paddings = {{\[}}[1, 0], [0, 1]] From a1a7b170cff06461421b98d08b0942b60694351f Mon Sep 17 00:00:00 2001 From: Sam Date: Wed, 1 May 2024 13:57:34 -0500 Subject: [PATCH 02/18] fix for param pad_to_multiple_of --- .../Linalg/TransformOps/LinalgTransformOps.td | 13 ++-- .../TransformOps/LinalgTransformOps.cpp | 62 ++++++++++++++++++- .../test/Dialect/Linalg/transform-op-pad.mlir | 36 +++++++++++ 3 files changed, 101 insertions(+), 10 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index 16fb8f4fcc946..ada7f7666d5f6 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -978,8 +978,8 @@ def PackTransposeOp : Op, + [FunctionalStyleTransformOpTrait, DeclareOpInterfaceMethods, + TransformOpInterface, ReportTrackingListenerFailuresOpTrait]> { let description = [{ Pads the operations pointed to by the target handle using the options @@ -1052,11 +1052,10 @@ def PadOp : Op getMixedPadToMultipleOf(); - ::mlir::DiagnosedSilenceableFailure applyToOne( - ::mlir::transform::TransformRewriter &rewriter, - ::mlir::linalg::LinalgOp target, - ::mlir::transform::ApplyToEachResultList &results, - ::mlir::transform::TransformState &state); + ::mlir::DiagnosedSilenceableFailure apply( + ::mlir::transform::TransformRewriter &rewriter, + ::mlir::transform::TransformResults &results, + ::mlir::transform::TransformState &state); }]; } diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index dc060f4c0641c..c68bc4c1f025a 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -1713,6 +1713,16 @@ void transform::PadOp::build(OpBuilder &b, OperationState &result, Value target, /*copyBackOp=*/b.getStringAttr(copyBackOp)); } +void PadOp::getEffects( + SmallVectorImpl &effects) { + consumesHandle(getTarget(), effects); + onlyReadsHandle(getPadToMultipleOf(), effects); + producesHandle(getPadded(), effects); + producesHandle(getPad(), effects); + producesHandle(getCopy(), effects); + modifiesPayload(effects); +} + SmallVector PadOp::getMixedPadToMultipleOf() { OpBuilder b(getContext()); return getMixedValues(getStaticPadToMultipleOf(), getPadToMultipleOf(), b); @@ -1848,9 +1858,55 @@ transform::PadOp::apply(transform::TransformRewriter &rewriter, LinalgPaddingOptions options; options.paddingDimensions = extractFromIntegerArrayAttr(getPaddingDimensions()); - SmallVector padToMultipleOf(options.paddingDimensions.size(), 1); - if (!getStaticPadToMultipleOf().empty()) - padToMultipleOf = llvm::to_vector(getStaticPadToMultipleOf()); + + SmallVector padToMultipleOf; + for (OpFoldResult sz : getMixedPadToMultipleOf()) { + if (sz.is()) { + auto attr = sz.get(); + padToMultipleOf.push_back(cast(attr).getInt()); + continue; + } else if (sz.is() && isa(sz.get().getType())) { + ArrayRef params = state.getParams(sz.get()); + if (params.size() != 1) + return emitSilenceableFailure(getLoc()) << "expected a single param"; + padToMultipleOf.push_back( + cast(params.front()).getValue().getSExtValue()); + continue; + } + + auto szPayloads = state.getPayloadOps(sz.get()); + if (!llvm::hasSingleElement(szPayloads)) { + auto diag = this->emitOpError("requires pad_to_multiple_of handle that " + "is mapped to 1 payload op"); + diag.attachNote(sz.get().getLoc()) + << "mapped to " << llvm::range_size(szPayloads) << " payload ops"; + return DiagnosedSilenceableFailure::definiteFailure(); + } + + Operation *szPayloadOp = *szPayloads.begin(); + if (szPayloadOp->getNumResults() != 1 || + !szPayloadOp->getResult(0).getType().isIndex()) { + auto diag = this->emitOpError( + "requires vector pad_to_multiple_of op with 1 index result"); + diag.attachNote(szPayloadOp->getLoc()) + << "pad_to_multiple_of payload op"; + return DiagnosedSilenceableFailure::definiteFailure(); + } + + IntegerAttr attr; + if (!matchPattern(szPayloadOp->getResult(0), m_Constant(&attr))) { + auto diag = this->emitOpError("requires constant pad_to_multiple_of"); + diag.attachNote(szPayloadOp->getLoc()) + << "pad_to_multiple_of payload op"; + return DiagnosedSilenceableFailure::definiteFailure(); + } + + padToMultipleOf.push_back(attr.getInt()); + } + if (padToMultipleOf.empty()) + padToMultipleOf = + SmallVector(options.paddingDimensions.size(), 1); + options.padToMultipleOf = padToMultipleOf; options.paddingValues = paddingValues; options.packPaddings = packPaddings; diff --git a/mlir/test/Dialect/Linalg/transform-op-pad.mlir b/mlir/test/Dialect/Linalg/transform-op-pad.mlir index f82d4500090c5..47bb5ddf4afc3 100644 --- a/mlir/test/Dialect/Linalg/transform-op-pad.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-pad.mlir @@ -86,6 +86,42 @@ module attributes {transform.with_named_sequence} { #map = affine_map<()[s0] -> (-s0 + 12, 7)> +// CHECK-LABEL: @parametrized_pad_to_multiple +func.func @parametrized_pad_to_multiple(%arg0: tensor<24x12xf32>, + %arg1: tensor<12x25xf32>, + %arg2: tensor<24x25xf32>, + %iv0 : index, %iv1 : index, %iv2 : index) -> tensor<24x25xf32> { + %0 = affine.min #map()[%iv2] + %1 = tensor.extract_slice %arg0[%iv0, %iv2] [4, %0] [1, 1] : tensor<24x12xf32> to tensor<4x?xf32> + %2 = tensor.extract_slice %arg1[%iv2, %iv1] [%0, 5] [1, 1] : tensor<12x25xf32> to tensor + %3 = tensor.extract_slice %arg2[%iv0, %iv1] [4, 5] [1, 1] : tensor<24x25xf32> to tensor<4x5xf32> + + // CHECK: linalg.matmul + // CHECK-SAME: ins(%{{.*}}, %{{.*}} : tensor<4x7xf32>, tensor<7x6xf32>) + // CHECK-SAME: outs(%{{.*}} : tensor<4x6xf32>) + %4 = linalg.matmul ins(%1, %2 : tensor<4x?xf32>, tensor) outs(%3 : tensor<4x5xf32>) -> tensor<4x5xf32> + %5 = tensor.insert_slice %4 into %arg2[%iv0, %iv1] [4, 5] [1, 1] : tensor<4x5xf32> into tensor<24x25xf32> + func.return %5 : tensor<24x25xf32> +} + + +module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { + %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op + %c2 = transform.param.constant 2 : i64 -> !transform.param + %padded, %pad, %copy_back = transform.structured.pad %0 pad_to_multiple_of [%c2, 2, 1] { + padding_values=[0.0 : f32, 0.0 : f32, 0.0 : f32], + padding_dimensions=[0, 1, 2], + pack_paddings=[1, 1, 0] + } : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op, !transform.any_op) + transform.yield + } +} + +// ----- + +#map = affine_map<()[s0] -> (-s0 + 12, 7)> + // CHECK-LABEL: @static_sizes_output_divisible_on_empty_op func.func @static_sizes_output_divisible_on_empty_op(%arg0: tensor<24x12xf32>, %arg1: tensor<12x25xf32>, %arg2: tensor<24x25xf32>, %iv0: index, From 5159eeb464c0e6858056cb877194d2293af8c81c Mon Sep 17 00:00:00 2001 From: Sam Date: Wed, 1 May 2024 13:58:54 -0500 Subject: [PATCH 03/18] format --- mlir/python/mlir/dialects/transform/structured.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/mlir/python/mlir/dialects/transform/structured.py b/mlir/python/mlir/dialects/transform/structured.py index 81bbd6ffb3d40..4f4a0e598df7d 100644 --- a/mlir/python/mlir/dialects/transform/structured.py +++ b/mlir/python/mlir/dialects/transform/structured.py @@ -386,10 +386,7 @@ def __init__( loc=None, ip=None, ): - if ( - static_pad_to_multiple_of is None - and pad_to_multiple_of is None - ): + if static_pad_to_multiple_of is None and pad_to_multiple_of is None: dynamic_pad_to_multiple_of = [] elif static_pad_to_multiple_of is None: ( From 23ef22ab40f4494aa93d6034f4c38714a9ec4a05 Mon Sep 17 00:00:00 2001 From: Sam Date: Wed, 1 May 2024 14:11:43 -0500 Subject: [PATCH 04/18] cleanup diagnostic messages --- .../Linalg/TransformOps/LinalgTransformOps.cpp | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index c68bc4c1f025a..c3963aee82856 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -1860,6 +1860,7 @@ transform::PadOp::apply(transform::TransformRewriter &rewriter, extractFromIntegerArrayAttr(getPaddingDimensions()); SmallVector padToMultipleOf; + // TODO: This should probably be a common utility function. for (OpFoldResult sz : getMixedPadToMultipleOf()) { if (sz.is()) { auto attr = sz.get(); @@ -1876,8 +1877,9 @@ transform::PadOp::apply(transform::TransformRewriter &rewriter, auto szPayloads = state.getPayloadOps(sz.get()); if (!llvm::hasSingleElement(szPayloads)) { - auto diag = this->emitOpError("requires pad_to_multiple_of handle that " - "is mapped to 1 payload op"); + auto diag = this->emitOpError() + << "requires " << kPadToMultipleOfKeyword + << " handle that is mapped to 1 payload op"; diag.attachNote(sz.get().getLoc()) << "mapped to " << llvm::range_size(szPayloads) << " payload ops"; return DiagnosedSilenceableFailure::definiteFailure(); @@ -1886,18 +1888,20 @@ transform::PadOp::apply(transform::TransformRewriter &rewriter, Operation *szPayloadOp = *szPayloads.begin(); if (szPayloadOp->getNumResults() != 1 || !szPayloadOp->getResult(0).getType().isIndex()) { - auto diag = this->emitOpError( - "requires vector pad_to_multiple_of op with 1 index result"); + auto diag = this->emitOpError() + << "requires " << kPadToMultipleOfKeyword + << " to be result of op with 1 index result"; diag.attachNote(szPayloadOp->getLoc()) - << "pad_to_multiple_of payload op"; + << kPadToMultipleOfKeyword << " payload op"; return DiagnosedSilenceableFailure::definiteFailure(); } IntegerAttr attr; if (!matchPattern(szPayloadOp->getResult(0), m_Constant(&attr))) { - auto diag = this->emitOpError("requires constant pad_to_multiple_of"); + auto diag = this->emitOpError() + << "requires constant " << kPadToMultipleOfKeyword; diag.attachNote(szPayloadOp->getLoc()) - << "pad_to_multiple_of payload op"; + << kPadToMultipleOfKeyword << " payload op"; return DiagnosedSilenceableFailure::definiteFailure(); } From 2dade05508512e565feccac381b185e749b3f735 Mon Sep 17 00:00:00 2001 From: Sam Date: Wed, 1 May 2024 19:36:40 -0500 Subject: [PATCH 05/18] refactor paramhandle reification --- .../TransformOps/LinalgTransformOps.cpp | 143 +++++++----------- 1 file changed, 54 insertions(+), 89 deletions(-) diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index c3963aee82856..01d4d2a033830 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -171,6 +171,50 @@ static DiagnosedSilenceableFailure unpackSingleIndexResultPayloadOperations( return DiagnosedSilenceableFailure::success(); } +static DiagnosedSilenceableFailure reifyMixedParamAndHandleResults( + TransformState &state, TransformOpInterface &transformOp, + const SmallVectorImpl &mixedResults, + SmallVectorImpl &reified) { + for (OpFoldResult paramOrHandle : mixedResults) { + if (isa(paramOrHandle)) { + reified.push_back( + cast(paramOrHandle.get()).getInt()); + continue; + } else if (isa(paramOrHandle) && + isa(paramOrHandle.get().getType())) { + ArrayRef params = state.getParams(paramOrHandle.get()); + if (params.size() != 1) + return transformOp.emitDefiniteFailure() << "expected a single param"; + reified.push_back( + cast(params.front()).getValue().getSExtValue()); + continue; + } + + auto paramOrHandlePayloads = + state.getPayloadOps(paramOrHandle.get()); + if (!llvm::hasSingleElement(paramOrHandlePayloads)) + return transformOp.emitDefiniteFailure() + << "requires param or handle that is mapped to 1 payload op"; + + Operation *paramOrHandlePayloadOp = *paramOrHandlePayloads.begin(); + if (paramOrHandlePayloadOp->getNumResults() != 1 || + !paramOrHandlePayloadOp->getResult(0).getType().isIndex()) { + return transformOp.emitDefiniteFailure() + << "requires param or handle to be result of op with 1 index " + "result"; + } + + IntegerAttr attr; + if (!matchPattern(paramOrHandlePayloadOp->getResult(0), m_Constant(&attr))) + return transformOp.emitDefiniteFailure() + << "requires param or handle to be the result of a constant like " + "op"; + + reified.push_back(attr.getInt()); + } + return DiagnosedSilenceableFailure::success(); +} + //===----------------------------------------------------------------------===// // Apply...PatternsOp //===----------------------------------------------------------------------===// @@ -1798,6 +1842,7 @@ DiagnosedSilenceableFailure transform::PadOp::apply(transform::TransformRewriter &rewriter, transform::TransformResults &results, transform::TransformState &state) { + auto transformOp = cast(getOperation()); SmallVector paddedOps, padOps, copyBackOps; for (Operation *target : state.getPayloadOps(getTarget())) { @@ -1860,53 +1905,10 @@ transform::PadOp::apply(transform::TransformRewriter &rewriter, extractFromIntegerArrayAttr(getPaddingDimensions()); SmallVector padToMultipleOf; - // TODO: This should probably be a common utility function. - for (OpFoldResult sz : getMixedPadToMultipleOf()) { - if (sz.is()) { - auto attr = sz.get(); - padToMultipleOf.push_back(cast(attr).getInt()); - continue; - } else if (sz.is() && isa(sz.get().getType())) { - ArrayRef params = state.getParams(sz.get()); - if (params.size() != 1) - return emitSilenceableFailure(getLoc()) << "expected a single param"; - padToMultipleOf.push_back( - cast(params.front()).getValue().getSExtValue()); - continue; - } - - auto szPayloads = state.getPayloadOps(sz.get()); - if (!llvm::hasSingleElement(szPayloads)) { - auto diag = this->emitOpError() - << "requires " << kPadToMultipleOfKeyword - << " handle that is mapped to 1 payload op"; - diag.attachNote(sz.get().getLoc()) - << "mapped to " << llvm::range_size(szPayloads) << " payload ops"; - return DiagnosedSilenceableFailure::definiteFailure(); - } - - Operation *szPayloadOp = *szPayloads.begin(); - if (szPayloadOp->getNumResults() != 1 || - !szPayloadOp->getResult(0).getType().isIndex()) { - auto diag = this->emitOpError() - << "requires " << kPadToMultipleOfKeyword - << " to be result of op with 1 index result"; - diag.attachNote(szPayloadOp->getLoc()) - << kPadToMultipleOfKeyword << " payload op"; - return DiagnosedSilenceableFailure::definiteFailure(); - } - - IntegerAttr attr; - if (!matchPattern(szPayloadOp->getResult(0), m_Constant(&attr))) { - auto diag = this->emitOpError() - << "requires constant " << kPadToMultipleOfKeyword; - diag.attachNote(szPayloadOp->getLoc()) - << kPadToMultipleOfKeyword << " payload op"; - return DiagnosedSilenceableFailure::definiteFailure(); - } - - padToMultipleOf.push_back(attr.getInt()); - } + DiagnosedSilenceableFailure status = reifyMixedParamAndHandleResults( + state, transformOp, getMixedPadToMultipleOf(), padToMultipleOf); + if (!status.succeeded()) + return status; if (padToMultipleOf.empty()) padToMultipleOf = SmallVector(options.paddingDimensions.size(), 1); @@ -3362,49 +3364,12 @@ DiagnosedSilenceableFailure transform::VectorizeOp::apply( auto targets = state.getPayloadOps(getTarget()); if (std::empty(targets)) return DiagnosedSilenceableFailure::success(); - + auto transformOp = cast(getOperation()); SmallVector vectorSizes; - for (OpFoldResult sz : getMixedVectorSizes()) { - if (sz.is()) { - auto attr = sz.get(); - vectorSizes.push_back(cast(attr).getInt()); - continue; - } else if (sz.is() && isa(sz.get().getType())) { - ArrayRef params = state.getParams(sz.get()); - if (params.size() != 1) - return emitSilenceableFailure(getLoc()) << "expected a single param"; - vectorSizes.push_back( - cast(params.front()).getValue().getSExtValue()); - continue; - } - - auto szPayloads = state.getPayloadOps(sz.get()); - if (!llvm::hasSingleElement(szPayloads)) { - auto diag = this->emitOpError( - "requires vector size handle that is mapped to 1 payload op"); - diag.attachNote(sz.get().getLoc()) - << "mapped to " << llvm::range_size(szPayloads) << " payload ops"; - return DiagnosedSilenceableFailure::definiteFailure(); - } - - Operation *szPayloadOp = *szPayloads.begin(); - if (szPayloadOp->getNumResults() != 1 || - !szPayloadOp->getResult(0).getType().isIndex()) { - auto diag = this->emitOpError( - "requires vector size payload op with 1 index result"); - diag.attachNote(szPayloadOp->getLoc()) << "vector size payload op"; - return DiagnosedSilenceableFailure::definiteFailure(); - } - - IntegerAttr attr; - if (!matchPattern(szPayloadOp->getResult(0), m_Constant(&attr))) { - auto diag = this->emitOpError("requires constant vector size"); - diag.attachNote(szPayloadOp->getLoc()) << "vector size payload op"; - return DiagnosedSilenceableFailure::definiteFailure(); - } - - vectorSizes.push_back(attr.getInt()); - } + DiagnosedSilenceableFailure status = reifyMixedParamAndHandleResults( + state, transformOp, getMixedVectorSizes(), vectorSizes); + if (!status.succeeded()) + return status; // TODO: Check that the correct number of vectorSizes was provided. for (Operation *target : targets) { From 124957b0c21964f09add3d07761a2ff34737f6ad Mon Sep 17 00:00:00 2001 From: Sam Date: Wed, 1 May 2024 23:57:16 -0500 Subject: [PATCH 06/18] Add python test for new functionality --- .../python/dialects/transform_structured_ext.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/mlir/test/python/dialects/transform_structured_ext.py b/mlir/test/python/dialects/transform_structured_ext.py index 418b1216df053..0667a2ce86e92 100644 --- a/mlir/test/python/dialects/transform_structured_ext.py +++ b/mlir/test/python/dialects/transform_structured_ext.py @@ -8,6 +8,7 @@ from mlir.dialects import pdl from mlir.dialects.transform import structured from mlir.dialects.transform import pdl as transform_pdl +from mlir.dialects.transform.extras import constant_param def run(f): @@ -334,6 +335,22 @@ def testPadOpArgs(target): # CHECK-DAG: transpose_paddings = {{\[}}[1, 0], [0, 1]] +@run +@create_sequence +def testPadOpArgsParam(target): + structured.PadOp( + target, + [constant_param(128), Attribute.parse("2")], + padding_dimensions=Attribute.parse("[0, 1]"), + ) + # CHECK-LABEL: TEST: testPadOpArgsParam + # CHECK: transform.sequence + # CHECK-DAG: %[[P:.*]] = transform.param.constant 128 + # CHECK: transform.structured.pad + # CHECK-DAG: pad_to_multiple_of [%[[P]], 2] + # CHECK-DAG: padding_dimensions = [1] + + @run @create_sequence def testScalarize(target): From f69f052762b71ca7c3a14921751db85d794ef94e Mon Sep 17 00:00:00 2001 From: Sam Date: Thu, 2 May 2024 00:01:55 -0500 Subject: [PATCH 07/18] fix typo --- mlir/test/python/dialects/transform_structured_ext.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlir/test/python/dialects/transform_structured_ext.py b/mlir/test/python/dialects/transform_structured_ext.py index 0667a2ce86e92..8deca33de6d99 100644 --- a/mlir/test/python/dialects/transform_structured_ext.py +++ b/mlir/test/python/dialects/transform_structured_ext.py @@ -348,7 +348,7 @@ def testPadOpArgsParam(target): # CHECK-DAG: %[[P:.*]] = transform.param.constant 128 # CHECK: transform.structured.pad # CHECK-DAG: pad_to_multiple_of [%[[P]], 2] - # CHECK-DAG: padding_dimensions = [1] + # CHECK-DAG: padding_dimensions = [0, 1] @run From a9c511e00e3cd98fab61c1667b4492967e1023af Mon Sep 17 00:00:00 2001 From: Sam Date: Thu, 2 May 2024 09:26:28 -0500 Subject: [PATCH 08/18] use tablegen assembly format --- .../Linalg/TransformOps/LinalgTransformOps.td | 8 ++- .../TransformOps/LinalgTransformOps.cpp | 66 ------------------- 2 files changed, 7 insertions(+), 67 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index ada7f7666d5f6..8ae9b3f7121b7 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -1023,7 +1023,13 @@ def PadOp : Op($pad_to_multiple_of, $static_pad_to_multiple_of)) + attr-dict + `:` functional-type(operands, results) + }]; + let hasVerifier = 1; let builders = [ diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index 01d4d2a033830..87b49accd340a 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -1772,72 +1772,6 @@ SmallVector PadOp::getMixedPadToMultipleOf() { return getMixedValues(getStaticPadToMultipleOf(), getPadToMultipleOf(), b); } -ParseResult transform::PadOp::parse(OpAsmParser &parser, - OperationState &result) { - OpAsmParser::UnresolvedOperand target; - SmallVector dynamicPadToMultipleOf; - DenseI64ArrayAttr padToMultipleOf; - FunctionType functionalType; - llvm::SMLoc operandLoc; - - if (parser.parseOperand(target) || parser.getCurrentLocation(&operandLoc)) - return ParseResult::failure(); - - if (succeeded(parser.parseOptionalKeyword(kPadToMultipleOfKeyword))) { - if (failed(parseDynamicIndexList(parser, dynamicPadToMultipleOf, - padToMultipleOf))) - return ParseResult::failure(); - } - - if (parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(functionalType) || - parser.resolveOperand(target, functionalType.getInputs().front(), - result.operands) || - parser.resolveOperands(dynamicPadToMultipleOf, - functionalType.getInputs().drop_front(), - operandLoc, result.operands)) - return ParseResult::failure(); - - if (padToMultipleOf) - result.addAttribute(getStaticPadToMultipleOfAttrName(result.name), - padToMultipleOf); - - result.addTypes(functionalType.getResults()); - - return success(); -} - -void transform::PadOp::print(OpAsmPrinter &p) { - p << ' ' << getTarget() << ' '; - if (!getMixedPadToMultipleOf().empty()) { - p << kPadToMultipleOfKeyword << ' '; - printDynamicIndexList(p, getOperation(), getPadToMultipleOf(), - getStaticPadToMultipleOfAttr(), - /*valueTypes=*/{}, - /*scalables=*/{}, OpAsmParser::Delimiter::Square); - } - - OpBuilder builder((*this)->getContext()); - SmallVector elidedAttrs({getStaticPadToMultipleOfAttrName()}); - if (getCopyBackOpAttr() == - builder.getStringAttr( - bufferization::MaterializeInDestinationOp::getOperationName())) - elidedAttrs.push_back(getCopyBackOpAttrName()); - if (getPackPaddingsAttr() == builder.getI64ArrayAttr({})) - elidedAttrs.push_back(getPackPaddingsAttrName()); - if (getTransposePaddingsAttr() == builder.getI64ArrayAttr({})) - elidedAttrs.push_back(getTransposePaddingsAttrName()); - if (getPaddingDimensionsAttr() == builder.getI64ArrayAttr({})) - elidedAttrs.push_back(getPaddingDimensionsAttrName()); - if (getPaddingValuesAttr() == builder.getArrayAttr({})) - elidedAttrs.push_back(getPaddingValuesAttrName()); - - p.printOptionalAttrDict((*this)->getAttrs(), - /*elidedAttrs=*/elidedAttrs); - p << " : "; - p.printFunctionalType(getOperands().getTypes(), getResults().getTypes()); -} - DiagnosedSilenceableFailure transform::PadOp::apply(transform::TransformRewriter &rewriter, transform::TransformResults &results, From 3008e5de723514345390a55151f8ab9d9d58c3ba Mon Sep 17 00:00:00 2001 From: Sam Date: Thu, 2 May 2024 10:19:43 -0500 Subject: [PATCH 09/18] address some comments --- .../Linalg/TransformOps/LinalgTransformOps.td | 1 + .../TransformOps/LinalgTransformOps.cpp | 27 ++++++++++--------- 2 files changed, 15 insertions(+), 13 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index 8ae9b3f7121b7..f23c65d827d16 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -1056,6 +1056,7 @@ def PadOp : Op getMixedPadToMultipleOf(); ::mlir::DiagnosedSilenceableFailure apply( diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index 87b49accd340a..8752e90bc7cad 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -171,42 +171,43 @@ static DiagnosedSilenceableFailure unpackSingleIndexResultPayloadOperations( return DiagnosedSilenceableFailure::success(); } +/// When possible, converts each `OpFoldResult` in `mixedResult` to +/// an integer if the value can be statically inferred. If a result +/// is a `Value` then it must be either a `ParamType` or a handle +/// to an a constant like op. static DiagnosedSilenceableFailure reifyMixedParamAndHandleResults( TransformState &state, TransformOpInterface &transformOp, - const SmallVectorImpl &mixedResults, - SmallVectorImpl &reified) { + ArrayRef mixedResults, SmallVectorImpl &reified) { for (OpFoldResult paramOrHandle : mixedResults) { if (isa(paramOrHandle)) { reified.push_back( cast(paramOrHandle.get()).getInt()); continue; - } else if (isa(paramOrHandle) && - isa(paramOrHandle.get().getType())) { + } else if (isa(paramOrHandle.get().getType())) { ArrayRef params = state.getParams(paramOrHandle.get()); if (params.size() != 1) - return transformOp.emitDefiniteFailure() << "expected a single param"; + return transformOp.emitSilenceableError() << "expected a single param"; reified.push_back( cast(params.front()).getValue().getSExtValue()); continue; } - auto paramOrHandlePayloads = - state.getPayloadOps(paramOrHandle.get()); - if (!llvm::hasSingleElement(paramOrHandlePayloads)) - return transformOp.emitDefiniteFailure() + auto payload = state.getPayloadOps(paramOrHandle.get()); + if (!llvm::hasSingleElement(payload)) + return transformOp.emitSilenceableError() << "requires param or handle that is mapped to 1 payload op"; - Operation *paramOrHandlePayloadOp = *paramOrHandlePayloads.begin(); + Operation *paramOrHandlePayloadOp = *payload.begin(); if (paramOrHandlePayloadOp->getNumResults() != 1 || !paramOrHandlePayloadOp->getResult(0).getType().isIndex()) { - return transformOp.emitDefiniteFailure() + return transformOp.emitSilenceableError() << "requires param or handle to be result of op with 1 index " "result"; } IntegerAttr attr; if (!matchPattern(paramOrHandlePayloadOp->getResult(0), m_Constant(&attr))) - return transformOp.emitDefiniteFailure() + return transformOp.emitSilenceableError() << "requires param or handle to be the result of a constant like " "op"; @@ -1768,7 +1769,7 @@ void PadOp::getEffects( } SmallVector PadOp::getMixedPadToMultipleOf() { - OpBuilder b(getContext()); + Builder b(getContext()); return getMixedValues(getStaticPadToMultipleOf(), getPadToMultipleOf(), b); } From 6549268239ef9999716d9812e075a95a6944e94f Mon Sep 17 00:00:00 2001 From: Sam Date: Thu, 2 May 2024 13:34:35 -0500 Subject: [PATCH 10/18] make transform ops with param/handle inputs have consistent assembly --- .../Linalg/TransformOps/LinalgTransformOps.td | 23 ++- .../mlir/Interfaces/ViewLikeInterface.h | 11 +- .../TransformOps/LinalgTransformOps.cpp | 156 ------------------ mlir/lib/Interfaces/ViewLikeInterface.cpp | 2 +- mlir/test/Dialect/LLVM/transform-e2e.mlir | 2 +- .../Linalg/generalize-tensor-pack-tile.mlir | 6 +- .../Linalg/generalize-tensor-unpack-tile.mlir | 6 +- .../Linalg/matmul-shared-memory-padding.mlir | 4 +- .../Dialect/Linalg/multisize-tiling-full.mlir | 16 +- mlir/test/Dialect/Linalg/promote.mlir | 4 +- .../Dialect/Linalg/promotion_options.mlir | 2 +- mlir/test/Dialect/Linalg/tile-conv.mlir | 2 +- mlir/test/Dialect/Linalg/tile-indexed.mlir | 4 +- mlir/test/Dialect/Linalg/tile-softmax.mlir | 4 +- mlir/test/Dialect/Linalg/tile-tensors.mlir | 8 +- ...compose-masked-vectorize-and-cleanups.mlir | 4 +- .../Dialect/Linalg/transform-op-fuse.mlir | 2 +- ...-op-hoist-pad-build-packing-loop-nest.mlir | 10 +- .../Linalg/transform-op-hoist-pad.mlir | 10 +- .../Linalg/transform-op-mmt4d-to-fma.mlir | 4 +- .../transform-op-peel-and-vectorize-conv.mlir | 4 +- .../transform-op-peel-and-vectorize.mlir | 2 +- .../Linalg/transform-op-scalarize.mlir | 2 +- .../Dialect/Linalg/transform-op-tile.mlir | 14 +- .../Dialect/Linalg/transform-ops-invalid.mlir | 2 +- mlir/test/Dialect/Linalg/transform-ops.mlir | 6 +- .../Dialect/Linalg/transform-patterns.mlir | 20 +-- .../vectorize-tensor-extract-masked.mlir | 12 +- mlir/test/Dialect/Tensor/tiling.mlir | 34 ++-- mlir/test/Dialect/Transform/ops.mlir | 8 +- .../Transform/selective-targeting.mlir | 2 +- .../test/Dialect/Vector/transform-vector.mlir | 2 +- .../Linalg/CPU/ArmSME/matmul-transpose-a.mlir | 2 +- .../Dialect/Linalg/CPU/ArmSME/matmul.mlir | 2 +- .../ArmSME/multi-tile-matmul-mixed-types.mlir | 2 +- .../Linalg/CPU/ArmSME/multi-tile-matmul.mlir | 2 +- .../Dialect/Linalg/CPU/ArmSVE/matmul.mlir | 2 +- .../Integration/Dialect/Linalg/CPU/mmt4d.mlir | 4 +- .../Dialect/Linalg/CPU/pack-unpack-mmt4d.mlir | 4 +- .../Dialect/Linalg/CPU/test-conv-1d-call.mlir | 2 +- .../Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir | 2 +- .../Dialect/Linalg/CPU/test-conv-2d-call.mlir | 2 +- .../CPU/test-conv-2d-nhwc-hwcf-call.mlir | 2 +- .../Dialect/Linalg/CPU/test-conv-3d-call.mlir | 2 +- .../CPU/test-conv-3d-ndhwc-dhwcf-call.mlir | 2 +- .../Linalg/CPU/test-tensor-matmul.mlir | 2 +- .../tile-pad-using-interface.mlir | 12 +- .../TilingInterface/tile-using-interface.mlir | 18 +- 48 files changed, 160 insertions(+), 290 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index f23c65d827d16..a411d209de590 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -1899,7 +1899,17 @@ def TileUsingForOp : Op, ]; - let hasCustomAssemblyFormat = 1; + let assemblyFormat = [{ + $target oilist( + `tile_sizes` custom( + $dynamic_sizes, + $static_sizes, + $scalable_sizes)) + (`interchange` `=` $interchange^)? + attr-dict + `:` functional-type(operands, results) + }]; + let hasVerifier = 1; let extraClassDeclaration = [{ @@ -2162,7 +2172,16 @@ def VectorizeOp : Op( + $vector_sizes, + $static_vector_sizes, + $scalable_sizes)) + attr-dict + `:` type($target)(`,`type($vector_sizes)^)? + }]; + let hasVerifier = 1; let extraClassDeclaration = [{ diff --git a/mlir/include/mlir/Interfaces/ViewLikeInterface.h b/mlir/include/mlir/Interfaces/ViewLikeInterface.h index 931309b0c5962..d6479143a0a50 100644 --- a/mlir/include/mlir/Interfaces/ViewLikeInterface.h +++ b/mlir/include/mlir/Interfaces/ViewLikeInterface.h @@ -106,9 +106,16 @@ class OpWithOffsetSizesAndStridesConstantArgumentFolder final /// empty then assume that all indices are non-scalable. void printDynamicIndexList( OpAsmPrinter &printer, Operation *op, OperandRange values, - ArrayRef integers, TypeRange valueTypes = TypeRange(), - ArrayRef scalables = {}, + ArrayRef integers, ArrayRef scalables, + TypeRange valueTypes = TypeRange(), AsmParser::Delimiter delimiter = AsmParser::Delimiter::Square); +inline void printDynamicIndexList( + OpAsmPrinter &printer, Operation *op, OperandRange values, + ArrayRef integers, TypeRange valueTypes = TypeRange(), + AsmParser::Delimiter delimiter = AsmParser::Delimiter::Square) { + return printDynamicIndexList(printer, op, values, integers, {}, valueTypes, + delimiter); +} /// Parser hook for custom directive in assemblyFormat. /// diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index 8752e90bc7cad..d5a262057ff0f 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -1709,8 +1709,6 @@ transform::PackTransposeOp::apply(transform::TransformRewriter &rewriter, // PadOp //===---------------------------------------------------------------------===// -static const StringLiteral kPadToMultipleOfKeyword = "pad_to_multiple_of"; - void transform::PadOp::build(OpBuilder &b, OperationState &result, Value target, ArrayRef paddingDimensions, ArrayRef padToMultipleOf, @@ -2822,86 +2820,6 @@ SmallVector transform::TileUsingForOp::getMixedSizes() { return results; } -// We want to parse `DenseI64ArrayAttr` using the short form without the -// `array` prefix to be consistent in the IR with `parseDynamicIndexList`. -ParseResult parseOptionalInterchange(OpAsmParser &parser, - OperationState &result) { - if (failed(parser.parseOptionalKeyword("interchange"))) - return success(); - if (failed(parser.parseEqual())) - return failure(); - result.addAttribute( - transform::TileUsingForOp::getInterchangeAttrName(result.name), - DenseI64ArrayAttr::parse(parser, Type{})); - return success(); -} - -void printOptionalInterchange(OpAsmPrinter &p, - ArrayRef interchangeVals) { - if (!interchangeVals.empty()) { - p << " interchange = ["; - llvm::interleaveComma(interchangeVals, p, - [&](int64_t integer) { p << integer; }); - p << "]"; - } -} - -ParseResult transform::TileUsingForOp::parse(OpAsmParser &parser, - OperationState &result) { - OpAsmParser::UnresolvedOperand target; - SmallVector dynamicSizes; - DenseI64ArrayAttr staticSizes; - FunctionType functionalType; - llvm::SMLoc operandLoc; - DenseBoolArrayAttr scalableVals; - - if (parser.parseOperand(target) || parser.getCurrentLocation(&operandLoc) || - parseDynamicIndexList(parser, dynamicSizes, staticSizes, scalableVals) || - parseOptionalInterchange(parser, result) || - parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(functionalType)) - return ParseResult::failure(); - - size_t numExpectedLoops = - staticSizes.size() - llvm::count(staticSizes.asArrayRef(), 0); - if (functionalType.getNumResults() != numExpectedLoops + 1) { - return parser.emitError(parser.getNameLoc()) - << "expected " << (numExpectedLoops + 1) << " result type(s)"; - } - if (functionalType.getNumInputs() != dynamicSizes.size() + 1) { - return parser.emitError(operandLoc) - << "expected " << dynamicSizes.size() + 1 << " operand type(s)"; - } - if (parser.resolveOperand(target, functionalType.getInputs().front(), - result.operands) || - parser.resolveOperands(dynamicSizes, - functionalType.getInputs().drop_front(), - operandLoc, result.operands)) { - return failure(); - } - - result.addAttribute(getScalableSizesAttrName(result.name), scalableVals); - - result.addAttribute(getStaticSizesAttrName(result.name), staticSizes); - result.addTypes(functionalType.getResults()); - return success(); -} - -void TileUsingForOp::print(OpAsmPrinter &p) { - p << ' ' << getTarget(); - printDynamicIndexList(p, getOperation(), getDynamicSizes(), getStaticSizes(), - /*valueTypes=*/{}, getScalableSizesAttr(), - OpAsmParser::Delimiter::Square); - printOptionalInterchange(p, getInterchange()); - p.printOptionalAttrDict( - (*this)->getAttrs(), - /*elidedAttrs=*/{getInterchangeAttrName(getOperation()->getName()), - getScalableSizesAttrName(getOperation()->getName()), - getStaticSizesAttrName(getOperation()->getName())}); - p << " : "; - p.printFunctionalType(getOperands().getTypes(), getResults().getTypes()); -} - void transform::TileUsingForOp::getEffects( SmallVectorImpl &effects) { consumesHandle(getTarget(), effects); @@ -3218,80 +3136,6 @@ transform::VectorizeChildrenAndApplyPatternsOp::applyToOne( // VectorizeOp //===----------------------------------------------------------------------===// -static const StringLiteral kVectorSizesKeyword = "vector_sizes"; - -ParseResult transform::VectorizeOp::parse(OpAsmParser &parser, - OperationState &result) { - OpAsmParser::UnresolvedOperand target; - SmallVector dynamicSizes; - DenseI64ArrayAttr staticSizes; - SmallVector operandTypes; - llvm::SMLoc operandLoc; - DenseBoolArrayAttr scalableVals; - - if (parser.parseOperand(target) || parser.getCurrentLocation(&operandLoc)) - return ParseResult::failure(); - - if (succeeded(parser.parseOptionalKeyword(kVectorSizesKeyword))) { - if (failed(parseDynamicIndexList(parser, dynamicSizes, staticSizes, - scalableVals))) - return ParseResult::failure(); - } - - if (succeeded(parser.parseOptionalKeyword( - getVectorizeNdExtractAttrName(result.name)))) - result.addAttribute(getVectorizeNdExtractAttrName(result.name), - parser.getBuilder().getUnitAttr()); - - if (parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonTypeList(operandTypes)) - return ParseResult::failure(); - - if (operandTypes.size() != dynamicSizes.size() + 1) { - return parser.emitError(operandLoc) - << "expected " << dynamicSizes.size() + 1 << " operand type(s)"; - } - if (parser.resolveOperand(target, operandTypes.front(), result.operands) || - parser.resolveOperands(dynamicSizes, ArrayRef(operandTypes).drop_front(), - operandLoc, result.operands)) { - return failure(); - } - - if (scalableVals) - result.addAttribute(getScalableSizesAttrName(result.name), scalableVals); - if (staticSizes) - result.addAttribute(getStaticVectorSizesAttrName(result.name), staticSizes); - - return success(); -} - -void transform::VectorizeOp::print(OpAsmPrinter &p) { - p << ' ' << getTarget() << ' '; - if (!getMixedVectorSizes().empty()) { - p << kVectorSizesKeyword << ' '; - printDynamicIndexList(p, getOperation(), getVectorSizes(), - getStaticVectorSizesAttr(), - /*valueTypes=*/{}, getScalableSizesAttr(), - OpAsmParser::Delimiter::Square); - } - - if (getVectorizeNdExtract()) - p << getVectorizeNdExtractAttrName() << ' '; - - p.printOptionalAttrDict( - (*this)->getAttrs(), - /*elidedAttrs=*/{ - getScalableSizesAttrName(getOperation()->getName()), - getStaticVectorSizesAttrName(getOperation()->getName())}); - p << " : "; - p << getTarget().getType(); - if (!getVectorSizes().empty()) { - p << ", "; - llvm::interleaveComma(getVectorSizes(), p, - [&](Value operand) { p << operand.getType(); }); - } -} - DiagnosedSilenceableFailure transform::VectorizeOp::apply( transform::TransformRewriter &rewriter, mlir::transform::TransformResults &transformResults, diff --git a/mlir/lib/Interfaces/ViewLikeInterface.cpp b/mlir/lib/Interfaces/ViewLikeInterface.cpp index 6d1ff03756ace..ca33636336bf0 100644 --- a/mlir/lib/Interfaces/ViewLikeInterface.cpp +++ b/mlir/lib/Interfaces/ViewLikeInterface.cpp @@ -113,7 +113,7 @@ static char getRightDelimiter(AsmParser::Delimiter delimiter) { void mlir::printDynamicIndexList(OpAsmPrinter &printer, Operation *op, OperandRange values, ArrayRef integers, - TypeRange valueTypes, ArrayRef scalables, + ArrayRef scalables, TypeRange valueTypes, AsmParser::Delimiter delimiter) { char leftDelimiter = getLeftDelimiter(delimiter); char rightDelimiter = getRightDelimiter(delimiter); diff --git a/mlir/test/Dialect/LLVM/transform-e2e.mlir b/mlir/test/Dialect/LLVM/transform-e2e.mlir index adbbbba32a40f..c00b47fb936e9 100644 --- a/mlir/test/Dialect/LLVM/transform-e2e.mlir +++ b/mlir/test/Dialect/LLVM/transform-e2e.mlir @@ -15,7 +15,7 @@ func.func @matmul_tensors( module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%module_op: !transform.any_op {transform.consumed}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %module_op : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [2, 2, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [2, 2, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) %2 = transform.get_parent_op %1 {isolated_from_above} : (!transform.any_op) -> !transform.any_op transform.structured.vectorize_children_and_apply_patterns %2 : (!transform.any_op) -> !transform.any_op %b = transform.bufferization.one_shot_bufferize layout{IdentityLayoutMap} diff --git a/mlir/test/Dialect/Linalg/generalize-tensor-pack-tile.mlir b/mlir/test/Dialect/Linalg/generalize-tensor-pack-tile.mlir index 0a197a0ee9fa6..d0c53ae468001 100644 --- a/mlir/test/Dialect/Linalg/generalize-tensor-pack-tile.mlir +++ b/mlir/test/Dialect/Linalg/generalize-tensor-pack-tile.mlir @@ -27,7 +27,7 @@ func.func @KCRS_to_KCRSsr(%arg0: tensor<1x1x128x64xf32>, %arg1: tensor<1x1x4x8x8 module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:4 = transform.structured.tile_using_for %0 [1, 1, 1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:4 = transform.structured.tile_using_for %0 tile_sizes [1, 1, 1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -54,7 +54,7 @@ func.func @pad_and_pack(%arg0: tensor<13x15xf32>, %arg1: tensor<2x8x8x2xf32>, %a module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -85,7 +85,7 @@ func.func @KC_to_CKkc(%arg0: tensor<128x256xf32>, %arg1: tensor<32x4x32x8xf32>) module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/generalize-tensor-unpack-tile.mlir b/mlir/test/Dialect/Linalg/generalize-tensor-unpack-tile.mlir index 7d64331c98784..c15859d898ec1 100644 --- a/mlir/test/Dialect/Linalg/generalize-tensor-unpack-tile.mlir +++ b/mlir/test/Dialect/Linalg/generalize-tensor-unpack-tile.mlir @@ -8,7 +8,7 @@ func.func @KCRSsr_to_KCRS(%arg0: tensor<1x1x4x8x8x32xf32>, %arg1: tensor<1x1x128 module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:4 = transform.structured.tile_using_for %0 [1, 1, 32, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:4 = transform.structured.tile_using_for %0 tile_sizes [1, 1, 32, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -68,7 +68,7 @@ func.func @unpack_and_extract_slice(%arg0: tensor<2x8x8x2xf32>, %arg1: tensor<13 module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [8, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [8, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -100,7 +100,7 @@ func.func @CKkc_to_KC(%arg0: tensor<32x4x32x8xf32>, %arg1: tensor<128x256xf32>) module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [32, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [32, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/matmul-shared-memory-padding.mlir b/mlir/test/Dialect/Linalg/matmul-shared-memory-padding.mlir index c3ac69f65b7c6..3f8d2ea06641e 100644 --- a/mlir/test/Dialect/Linalg/matmul-shared-memory-padding.mlir +++ b/mlir/test/Dialect/Linalg/matmul-shared-memory-padding.mlir @@ -52,7 +52,7 @@ module attributes {transform.with_named_sequence} { : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) // Tile linalg.matmul a second time. - %tiled_linalg_op, %loops = transform.structured.tile_using_for %tiled_matmul_op[0, 0, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %tiled_linalg_op, %loops = transform.structured.tile_using_for %tiled_matmul_op tile_sizes [0, 0, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) // Pad linalg.matmul. %padded, %pad, %copy_back = transform.structured.pad %tiled_linalg_op @@ -171,7 +171,7 @@ module attributes {transform.with_named_sequence} { : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) // Tile linalg.matmul a second time. - %tiled_linalg_op, %loops = transform.structured.tile_using_for %tiled_matmul_op[0, 0, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %tiled_linalg_op, %loops = transform.structured.tile_using_for %tiled_matmul_op tile_sizes [0, 0, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) // Pad linalg.matmul. %padded, %pad, %copy_back = transform.structured.pad %tiled_linalg_op diff --git a/mlir/test/Dialect/Linalg/multisize-tiling-full.mlir b/mlir/test/Dialect/Linalg/multisize-tiling-full.mlir index 592eb781cd4ff..15b24b56608e3 100644 --- a/mlir/test/Dialect/Linalg/multisize-tiling-full.mlir +++ b/mlir/test/Dialect/Linalg/multisize-tiling-full.mlir @@ -8,13 +8,13 @@ module attributes {transform.with_named_sequence} { %1:3 = transform.structured.multitile_sizes %0 { dimension = 0, target_size = 3} : (!transform.any_op) -> !transform.any_op %t:3 = transform.structured.multitile_sizes %0 { dimension = 1, target_size = 10} : (!transform.any_op) -> !transform.any_op %2:2 = transform.structured.split %0 after %1#2 { dimension = 0 } : !transform.any_op, !transform.any_op - %3:2 = transform.structured.tile_using_for %2#0 [%1#0] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) - %4:2 = transform.structured.tile_using_for %2#1 [%1#1] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) + %3:2 = transform.structured.tile_using_for %2#0 tile_sizes [%1#0] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) + %4:2 = transform.structured.tile_using_for %2#1 tile_sizes [%1#1] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) %5 = transform.merge_handles %3#0, %4#0 : !transform.any_op %tt:3 = transform.replicate num(%5) %t#0, %t#1, %t#2 : !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op %6:2 = transform.structured.split %5 after %tt#2 { dimension = 1 } : !transform.any_op, !transform.any_op - transform.structured.tile_using_for %6#0 [0, %tt#0] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) - transform.structured.tile_using_for %6#1 [0, %tt#1] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) + transform.structured.tile_using_for %6#0 tile_sizes [0, %tt#0] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) + transform.structured.tile_using_for %6#1 tile_sizes [0, %tt#1] : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -110,13 +110,13 @@ module attributes {transform.with_named_sequence} { %1:3 = transform.structured.multitile_sizes %0 { dimension = 0, target_size = 3} : (!transform.any_op) -> !transform.param %t:3 = transform.structured.multitile_sizes %0 { dimension = 1, target_size = 10} : (!transform.any_op) -> !transform.param %2:2 = transform.structured.split %0 after %1#2 { dimension = 0 } : !transform.any_op, !transform.param - %3:2 = transform.structured.tile_using_for %2#0 [%1#0] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) - %4:2 = transform.structured.tile_using_for %2#1 [%1#1] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) + %3:2 = transform.structured.tile_using_for %2#0 tile_sizes [%1#0] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) + %4:2 = transform.structured.tile_using_for %2#1 tile_sizes [%1#1] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) %5 = transform.merge_handles %3#0, %4#0 : !transform.any_op %tt:3 = transform.replicate num(%5) %t#0, %t#1, %t#2 : !transform.any_op, !transform.param, !transform.param, !transform.param %6:2 = transform.structured.split %5 after %tt#2 { dimension = 1 } : !transform.any_op, !transform.param - transform.structured.tile_using_for %6#0 [0, %tt#0] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) - transform.structured.tile_using_for %6#1 [0, %tt#1] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) + transform.structured.tile_using_for %6#0 tile_sizes [0, %tt#0] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) + transform.structured.tile_using_for %6#1 tile_sizes [0, %tt#1] : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/promote.mlir b/mlir/test/Dialect/Linalg/promote.mlir index fb5f357f3faa8..2d640057df340 100644 --- a/mlir/test/Dialect/Linalg/promote.mlir +++ b/mlir/test/Dialect/Linalg/promote.mlir @@ -183,7 +183,7 @@ func.func @gemm_shared(%a : memref, %b : memref, %c : memref !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [16, 16, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [16, 16, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) %2 = transform.structured.promote %1 { operands_to_promote = [0, 1], mapping = [#gpu.memory_space] } : (!transform.any_op) -> !transform.any_op transform.yield } @@ -227,7 +227,7 @@ func.func @gemm_private(%a : memref, %b : memref, %c : memref< module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [16, 16, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [16, 16, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) %2 = transform.structured.promote %1 { operands_to_promote = [0, 1], mapping = [#gpu.memory_space] } : (!transform.any_op) -> !transform.any_op transform.yield } diff --git a/mlir/test/Dialect/Linalg/promotion_options.mlir b/mlir/test/Dialect/Linalg/promotion_options.mlir index 3bf74b708cb82..caa72ba24316f 100644 --- a/mlir/test/Dialect/Linalg/promotion_options.mlir +++ b/mlir/test/Dialect/Linalg/promotion_options.mlir @@ -37,7 +37,7 @@ func.func @gemm(%a : memref, %b : memref, %c : memref module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [16, 16, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [16, 16, 16] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) %2 = transform.structured.promote %1 { operands_to_promote = [0, 2], force_full_tiles = [false, false], use_full_tiles_by_default } : (!transform.any_op) -> !transform.any_op transform.yield } diff --git a/mlir/test/Dialect/Linalg/tile-conv.mlir b/mlir/test/Dialect/Linalg/tile-conv.mlir index c42bdbe982c4f..f674996e42f33 100644 --- a/mlir/test/Dialect/Linalg/tile-conv.mlir +++ b/mlir/test/Dialect/Linalg/tile-conv.mlir @@ -12,7 +12,7 @@ func.func @conv(%arg0 : memref, %arg1 : memref, %arg2 : memref module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.conv_2d"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop:2 = transform.structured.tile_using_for %0 [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loop:2 = transform.structured.tile_using_for %0 tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/tile-indexed.mlir b/mlir/test/Dialect/Linalg/tile-indexed.mlir index c176dc19c7e9e..b4aa0a33bc592 100644 --- a/mlir/test/Dialect/Linalg/tile-indexed.mlir +++ b/mlir/test/Dialect/Linalg/tile-indexed.mlir @@ -14,7 +14,7 @@ func.func @indexed_vector(%arg0: memref<50xindex>) { module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop = transform.structured.tile_using_for %0 [10] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loop = transform.structured.tile_using_for %0 tile_sizes [10] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -46,7 +46,7 @@ func.func @indexed_matrix(%arg0: memref<50x50xindex>) { module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop:2 = transform.structured.tile_using_for %0 [10, 25] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loop:2 = transform.structured.tile_using_for %0 tile_sizes [10, 25] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/tile-softmax.mlir b/mlir/test/Dialect/Linalg/tile-softmax.mlir index ec848e2deb74e..7d201b58a8c3d 100644 --- a/mlir/test/Dialect/Linalg/tile-softmax.mlir +++ b/mlir/test/Dialect/Linalg/tile-softmax.mlir @@ -39,7 +39,7 @@ func.func @softmax(%arg0: tensor<16x64x256xf32>) -> tensor<16x64x256xf32> { module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.softmax"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop:2 = transform.structured.tile_using_for %0 [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loop:2 = transform.structured.tile_using_for %0 tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -149,7 +149,7 @@ func.func @softmax_memref(%arg0: memref<16x64x256xf32>, %arg1: memref<16x64x256x module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.softmax"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop:2 = transform.structured.tile_using_for %0 [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loop:2 = transform.structured.tile_using_for %0 tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/tile-tensors.mlir b/mlir/test/Dialect/Linalg/tile-tensors.mlir index cdef71ded8b2c..89183813c080b 100644 --- a/mlir/test/Dialect/Linalg/tile-tensors.mlir +++ b/mlir/test/Dialect/Linalg/tile-tensors.mlir @@ -30,7 +30,7 @@ func.func @matmul_tensors( module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -57,7 +57,7 @@ func.func @matmul_tensors_with_size_zeros( module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1 = transform.structured.tile_using_for %0 [0, 0, 0] : (!transform.any_op) -> (!transform.any_op) + %1 = transform.structured.tile_using_for %0 tile_sizes [0, 0, 0] : (!transform.any_op) -> (!transform.any_op) transform.yield } } @@ -90,7 +90,7 @@ func.func @generic_op_tensors( module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -163,7 +163,7 @@ func.func @fold_extract_slice( module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/transform-op-compose-masked-vectorize-and-cleanups.mlir b/mlir/test/Dialect/Linalg/transform-op-compose-masked-vectorize-and-cleanups.mlir index 477261882421c..61fe3da34e1d5 100644 --- a/mlir/test/Dialect/Linalg/transform-op-compose-masked-vectorize-and-cleanups.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-compose-masked-vectorize-and-cleanups.mlir @@ -22,9 +22,9 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%module: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %module : (!transform.any_op) -> !transform.any_op - %tiled_linalg_op, %loops:3 = transform.structured.tile_using_for %0[64, 128, 256] + %tiled_linalg_op, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [64, 128, 256] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) - %tiled_linalg_op_0, %loops_1:3 = transform.structured.tile_using_for %tiled_linalg_op[8, 8, 8] + %tiled_linalg_op_0, %loops_1:3 = transform.structured.tile_using_for %tiled_linalg_op tile_sizes [8, 8, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.structured.vectorize %tiled_linalg_op_0 vector_sizes [8, 8, 8] : !transform.any_op diff --git a/mlir/test/Dialect/Linalg/transform-op-fuse.mlir b/mlir/test/Dialect/Linalg/transform-op-fuse.mlir index 69daf8c80a16d..3a023deb1132f 100644 --- a/mlir/test/Dialect/Linalg/transform-op-fuse.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-fuse.mlir @@ -95,7 +95,7 @@ module attributes {transform.with_named_sequence} { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op %1, %loops:2 = transform.structured.fuse %0 {tile_sizes = [5, 0, 7], tile_interchange = [0, 2, 1]} : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) - %2, %loops_2 = transform.structured.tile_using_for %1 [0, 4] + %2, %loops_2 = transform.structured.tile_using_for %1 tile_sizes [0, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } diff --git a/mlir/test/Dialect/Linalg/transform-op-hoist-pad-build-packing-loop-nest.mlir b/mlir/test/Dialect/Linalg/transform-op-hoist-pad-build-packing-loop-nest.mlir index 1be5bf098c334..ae63ed5f1a410 100644 --- a/mlir/test/Dialect/Linalg/transform-op-hoist-pad-build-packing-loop-nest.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-hoist-pad-build-packing-loop-nest.mlir @@ -15,7 +15,7 @@ module attributes {transform.with_named_sequence} { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -49,7 +49,7 @@ module attributes {transform.with_named_sequence} { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -89,7 +89,7 @@ module attributes {transform.with_named_sequence} { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -129,7 +129,7 @@ module attributes {transform.with_named_sequence} { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -167,7 +167,7 @@ module attributes {transform.with_named_sequence} { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1:2 = transform.structured.tile_using_for %matmul [5, 0, 7] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1:2 = transform.structured.tile_using_for %matmul tile_sizes [5, 0, 7] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], diff --git a/mlir/test/Dialect/Linalg/transform-op-hoist-pad.mlir b/mlir/test/Dialect/Linalg/transform-op-hoist-pad.mlir index 37cb9b2376fb4..499d9904c06b9 100644 --- a/mlir/test/Dialect/Linalg/transform-op-hoist-pad.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-hoist-pad.mlir @@ -15,7 +15,7 @@ module attributes {transform.with_named_sequence} { : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -53,7 +53,7 @@ module attributes {transform.with_named_sequence} { : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -98,7 +98,7 @@ module attributes {transform.with_named_sequence} { : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -145,7 +145,7 @@ module attributes {transform.with_named_sequence} { : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1 = transform.structured.tile_using_for %matmul tile_sizes [5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], @@ -191,7 +191,7 @@ module attributes {transform.with_named_sequence} { : (!transform.any_op) -> !transform.any_op - %matmul_l1, %loops_l1:2 = transform.structured.tile_using_for %matmul [5, 0, 7] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %matmul_l1, %loops_l1:2 = transform.structured.tile_using_for %matmul tile_sizes [5, 0, 7] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) %matmul_padded, %0, %copy_back = transform.structured.pad %matmul_l1 { padding_values=[0.0: f32, 0.0 : f32, 0.0 : f32], diff --git a/mlir/test/Dialect/Linalg/transform-op-mmt4d-to-fma.mlir b/mlir/test/Dialect/Linalg/transform-op-mmt4d-to-fma.mlir index 6aba2b3bb368e..b5c6e610f58f9 100644 --- a/mlir/test/Dialect/Linalg/transform-op-mmt4d-to-fma.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-mmt4d-to-fma.mlir @@ -20,10 +20,10 @@ module attributes {transform.with_named_sequence} { // Step 1: Tile // Tile parallel dims - %tiled_linalg_op_p, %loops:4 = transform.structured.tile_using_for %mmt4d[1, 1, 0, 8, 8, 0] + %tiled_linalg_op_p, %loops:4 = transform.structured.tile_using_for %mmt4d tile_sizes [1, 1, 0, 8, 8, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) // Tile reduction dims - %tiled_linalg_op_r, %loops2:2 = transform.structured.tile_using_for %tiled_linalg_op_p[0, 0, 1, 0, 0, 1] + %tiled_linalg_op_r, %loops2:2 = transform.structured.tile_using_for %tiled_linalg_op_p tile_sizes [0, 0, 1, 0, 0, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) // Step 2: Vectorize diff --git a/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize-conv.mlir b/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize-conv.mlir index 7f3997633a307..4bb40bef9fba2 100644 --- a/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize-conv.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize-conv.mlir @@ -61,11 +61,11 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%root: !transform.any_op {transform.consume}) { // 1. Tile parallel dims %1 = transform.structured.match ops{["linalg.depthwise_conv_2d_nhwc_hwc"]} in %root : (!transform.any_op) -> !transform.any_op - %tiled_linalg_op_0, %loops_1:4 = transform.structured.tile_using_for %1[1, 1, 4, [4], 0, 0] : (!transform.any_op) -> (!transform.any_op, !transform.op<"scf.for">, !transform.op<"scf.for">, !transform.op<"scf.for">, !transform.op<"scf.for">) + %tiled_linalg_op_0, %loops_1:4 = transform.structured.tile_using_for %1 tile_sizes [1, 1, 4, [4], 0, 0] : (!transform.any_op) -> (!transform.any_op, !transform.op<"scf.for">, !transform.op<"scf.for">, !transform.op<"scf.for">, !transform.op<"scf.for">) // 2. Tile reduction dims %2 = transform.structured.match ops{["linalg.depthwise_conv_2d_nhwc_hwc"]} in %loops_1#3 : (!transform.op<"scf.for">) -> !transform.any_op - %tiled_linalg_op_1, %loops_2:2 = transform.structured.tile_using_for %2[0, 0, 0, 0, 1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %tiled_linalg_op_1, %loops_2:2 = transform.structured.tile_using_for %2 tile_sizes [0, 0, 0, 0, 1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) // 3. Decompose 2D conv into 2 x 1D conv %3 = transform.structured.match ops{["linalg.depthwise_conv_2d_nhwc_hwc"]} in %loops_1#3 : (!transform.op<"scf.for">) -> !transform.any_op diff --git a/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir b/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir index b7e316f8925d3..05a032b1ece06 100644 --- a/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir @@ -67,7 +67,7 @@ module attributes {transform.with_named_sequence} { %matmul = transform.structured.match ops{["linalg.matmul"]} in %root : (!transform.any_op) -> !transform.any_op // 1. Scalable tiling %_, %loop_1, %loop_2, %loop_3 = - transform.structured.tile_using_for %matmul [8, [16], 1] : (!transform.any_op) + transform.structured.tile_using_for %matmul tile_sizes [8, [16], 1] : (!transform.any_op) -> (!transform.any_op, !transform.op<"scf.for">, !transform.op<"scf.for">,!transform.op<"scf.for">) // 2. Loop peeling (only the middle dimension) diff --git a/mlir/test/Dialect/Linalg/transform-op-scalarize.mlir b/mlir/test/Dialect/Linalg/transform-op-scalarize.mlir index 7d642c8995f05..91949f58931a9 100644 --- a/mlir/test/Dialect/Linalg/transform-op-scalarize.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-scalarize.mlir @@ -21,7 +21,7 @@ func.func @scalarize(%arg0: tensor<24x12xf32>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops = transform.structured.tile_using_for %0 [10, 0, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loops = transform.structured.tile_using_for %0 tile_sizes [10, 0, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) %2 = transform.structured.scalarize %1 : (!transform.any_op) -> !transform.any_op transform.yield } diff --git a/mlir/test/Dialect/Linalg/transform-op-tile.mlir b/mlir/test/Dialect/Linalg/transform-op-tile.mlir index ea8c5e6124796..d244670f73754 100644 --- a/mlir/test/Dialect/Linalg/transform-op-tile.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-tile.mlir @@ -3,7 +3,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [4, 4, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [4, 4, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -42,7 +42,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op %1 = transform.structured.match ops{["func.call"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %2, %loops:3 = transform.structured.tile_using_for %0 [%1, %1, 4] : (!transform.any_op, !transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %2, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [%1, %1, 4] : (!transform.any_op, !transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -86,7 +86,7 @@ module attributes {transform.with_named_sequence} { // expected-note @below {{for this parameter}} %1 = transform.test_produce_param (0 : i64) : !transform.param // expected-error @below {{expected as many parameter values (0) as target ops (2)}} - transform.structured.tile_using_for %0 [%1, %1, %1] + transform.structured.tile_using_for %0 tile_sizes [%1, %1, %1] : (!transform.any_op, !transform.param, !transform.param, !transform.param) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield @@ -113,7 +113,7 @@ module attributes {transform.with_named_sequence} { // expected-note @below {{for this handle}} %1 = transform.structured.match ops{["arith.constant"]} in %arg1 : (!transform.any_op) -> !transform.any_op // expected-error @below {{expected as many dynamic size-producing operations (0) as target ops (2)}} - transform.structured.tile_using_for %0 [%1, %1, 1] + transform.structured.tile_using_for %0 tile_sizes [%1, %1, 1] : (!transform.any_op, !transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield @@ -194,7 +194,7 @@ module { module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop = transform.structured.tile_using_for %0 [[4]] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loop = transform.structured.tile_using_for %0 tile_sizes [[4]] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -230,7 +230,7 @@ func.func @scalable_and_fixed_length_tile( module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [4, 4, [4]] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [4, 4, [4]] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -249,7 +249,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op // expected-error @below {{too many tiles provided, expected at most 3 found 4}} - %1, %loops = transform.structured.tile_using_for %0 [1, 0, 0, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loops = transform.structured.tile_using_for %0 tile_sizes [1, 0, 0, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/transform-ops-invalid.mlir b/mlir/test/Dialect/Linalg/transform-ops-invalid.mlir index e7d9815ab222b..e86d4962530a9 100644 --- a/mlir/test/Dialect/Linalg/transform-ops-invalid.mlir +++ b/mlir/test/Dialect/Linalg/transform-ops-invalid.mlir @@ -77,7 +77,7 @@ transform.sequence failures(propagate) { transform.sequence failures(propagate) { ^bb0(%arg0: !transform.any_op): %0 = transform.param.constant 2 : i64 -> !transform.param - // expected-error@below {{custom op 'transform.structured.vectorize' expected 2 operand type(s)}} + // expected-error@below {{custom op 'transform.structured.vectorize' 1 operands present, but expected 2}} transform.structured.vectorize %arg0 vector_sizes [%0, 2] : !transform.any_op, !transform.param, !transform.param } diff --git a/mlir/test/Dialect/Linalg/transform-ops.mlir b/mlir/test/Dialect/Linalg/transform-ops.mlir index 8f6274fd22c21..733f305f850c6 100644 --- a/mlir/test/Dialect/Linalg/transform-ops.mlir +++ b/mlir/test/Dialect/Linalg/transform-ops.mlir @@ -3,7 +3,7 @@ transform.sequence failures(propagate) { ^bb1(%arg0: !transform.any_op): // CHECK %{{.*}}, %{{.*}}:2 = transform.structured.tile - %0, %1:2 = transform.structured.tile_using_for %arg0 [2, 0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %0, %1:2 = transform.structured.tile_using_for %arg0 tile_sizes [2, 0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) } // check that the Attributes of `tile_using_for` are preserved through printing @@ -11,9 +11,9 @@ transform.sequence failures(propagate) { transform.sequence failures(propagate) { ^bb1(%arg0: !transform.any_op): // CHECK %{{.*}}, %{{.*}}:2 = transform.structured.tile %arg0 [2, 0, 3] interchange = [2, 1] {test_attr1 = 1 : i64, test_attr2} - %0, %1:2 = transform.structured.tile_using_for %arg0 [2, 0, 3] interchange = [2, 1] {test_attr1 = 1 : i64, test_attr2}: (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %0, %1:2 = transform.structured.tile_using_for %arg0 tile_sizes [2, 0, 3] interchange = [2, 1] {test_attr1 = 1 : i64, test_attr2}: (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) // CHECK %{{.*}}, %{{.*}}:2 = transform.structured.tile %arg0 [4, 5, 3] {test_attr3 = 1 : i64, test_attr4} - %2, %3:2 = transform.structured.tile_using_for %0 [0, 5, 3] {test_attr3 = 1 : i64, test_attr4}: (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %2, %3:2 = transform.structured.tile_using_for %0 tile_sizes [0, 5, 3] {test_attr3 = 1 : i64, test_attr4}: (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) } transform.sequence failures(propagate) { diff --git a/mlir/test/Dialect/Linalg/transform-patterns.mlir b/mlir/test/Dialect/Linalg/transform-patterns.mlir index 5a9b490c07ff2..87b7664198dae 100644 --- a/mlir/test/Dialect/Linalg/transform-patterns.mlir +++ b/mlir/test/Dialect/Linalg/transform-patterns.mlir @@ -12,7 +12,7 @@ func.func @dot(%x: memref>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.dot"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop = transform.structured.tile_using_for %0 [8000] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loop = transform.structured.tile_using_for %0 tile_sizes [8000] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -38,7 +38,7 @@ func.func @matvec(%A: memref>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matvec"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [5, 6] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [5, 6] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -67,10 +67,10 @@ func.func @matmul(%A: memref>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [2000, 3000, 4000] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) - %2, %loops_2:3 = transform.structured.tile_using_for %1 [200, 300, 400] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) - %3, %loops_3:3 = transform.structured.tile_using_for %2 [20, 30, 40] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) - %4, %loops_4:3 = transform.structured.tile_using_for %3 [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [2000, 3000, 4000] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %2, %loops_2:3 = transform.structured.tile_using_for %1 tile_sizes [200, 300, 400] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %3, %loops_3:3 = transform.structured.tile_using_for %2 tile_sizes [20, 30, 40] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %4, %loops_4:3 = transform.structured.tile_using_for %3 tile_sizes [2, 3, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -170,7 +170,7 @@ func.func @matvec_perm(%A: memref>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matvec"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [5, 6] interchange = [1, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [5, 6] interchange = [1, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -199,9 +199,9 @@ func.func @matmul_perm(%A: memref>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [2000, 3000, 4000] interchange = [1, 2, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) - %2, %loops_2:3 = transform.structured.tile_using_for %1 [200, 300, 400] interchange = [1, 0, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) - %3, %loops_3:3 = transform.structured.tile_using_for %2 [20, 30, 40] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [2000, 3000, 4000] interchange = [1, 2, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %2, %loops_2:3 = transform.structured.tile_using_for %1 tile_sizes [200, 300, 400] interchange = [1, 0, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %3, %loops_3:3 = transform.structured.tile_using_for %2 tile_sizes [20, 30, 40] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Linalg/vectorize-tensor-extract-masked.mlir b/mlir/test/Dialect/Linalg/vectorize-tensor-extract-masked.mlir index edc38b42f5cdb..e68d297dc41f2 100644 --- a/mlir/test/Dialect/Linalg/vectorize-tensor-extract-masked.mlir +++ b/mlir/test/Dialect/Linalg/vectorize-tensor-extract-masked.mlir @@ -28,7 +28,7 @@ func.func @masked_static_vectorize_nd_tensor_extract_with_affine_apply_contiguou module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.vectorize %0 vector_sizes [1, 4] vectorize_nd_extract : !transform.any_op + transform.structured.vectorize %0 vector_sizes [1, 4] {vectorize_nd_extract} : !transform.any_op transform.yield } } @@ -85,7 +85,7 @@ func.func @masked_dynamic_vectorize_nd_tensor_extract_with_affine_apply_contiguo module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.vectorize %0 vector_sizes [1, 4] vectorize_nd_extract : !transform.any_op + transform.structured.vectorize %0 vector_sizes [1, 4] {vectorize_nd_extract} : !transform.any_op transform.yield } } @@ -125,7 +125,7 @@ func.func @masked_vectorize_nd_tensor_extract_with_affine_apply_gather(%6: tenso module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.vectorize %0 vector_sizes [1, 4] vectorize_nd_extract : !transform.any_op + transform.structured.vectorize %0 vector_sizes [1, 4] {vectorize_nd_extract} : !transform.any_op transform.yield } } @@ -182,7 +182,7 @@ func.func @masked_dynamic_vectorize_nd_tensor_extract_with_affine_apply_gather(% module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.vectorize %0 vector_sizes [1, 4] vectorize_nd_extract : !transform.any_op + transform.structured.vectorize %0 vector_sizes [1, 4] {vectorize_nd_extract} : !transform.any_op transform.yield } } @@ -234,7 +234,7 @@ func.func @extract_masked_vectorize(%arg0: tensor, %arg1: tensor !transform.any_op - transform.structured.vectorize %0 vector_sizes [3, 3] vectorize_nd_extract : !transform.any_op + transform.structured.vectorize %0 vector_sizes [3, 3] {vectorize_nd_extract} : !transform.any_op transform.yield } } @@ -279,7 +279,7 @@ func.func @tensor_extract_dynamic_shape(%arg1: tensor<123x321xf32>, %arg2: tenso module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.vectorize %0 vector_sizes [1, 3, 8] vectorize_nd_extract : !transform.any_op + transform.structured.vectorize %0 vector_sizes [1, 3, 8] {vectorize_nd_extract} : !transform.any_op transform.yield } } diff --git a/mlir/test/Dialect/Tensor/tiling.mlir b/mlir/test/Dialect/Tensor/tiling.mlir index 1afbd3d0504f7..e02ab06a9d533 100644 --- a/mlir/test/Dialect/Tensor/tiling.mlir +++ b/mlir/test/Dialect/Tensor/tiling.mlir @@ -34,7 +34,7 @@ func.func @dynamic_pad_tensor_3_4(%input_tensor: tensor, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -73,7 +73,7 @@ func.func @dynamic_pad_tensor_0_3(%input_tensor: tensor, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop = transform.structured.tile_using_for %0 [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loop = transform.structured.tile_using_for %0 tile_sizes [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -109,7 +109,7 @@ func.func @static_pad_tensor_3_4(%input_tensor: tensor<7x9xf32>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -142,7 +142,7 @@ func.func @static_pad_tensor_0_3(%input_tensor: tensor<7x9xf32>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop = transform.structured.tile_using_for %0 [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loop = transform.structured.tile_using_for %0 tile_sizes [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -179,7 +179,7 @@ func.func @static_pad_tile_evenly_0_3(%input_tensor: tensor<7x9xf32>, module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loop = transform.structured.tile_using_for %0 [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loop = transform.structured.tile_using_for %0 tile_sizes [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -217,7 +217,7 @@ func.func @NC_to_NCnc(%arg0: tensor<128x256xf32>, %arg1: tensor<4x8x32x32xf32>) module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -247,7 +247,7 @@ func.func @KC_to_CKkc(%arg0: tensor<128x256xf32>, %arg1: tensor<32x4x32x8xf32>) module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -284,7 +284,7 @@ func.func @pad_and_pack_static(%input: tensor<13x15xf32>, %output: tensor<2x8x8x module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -335,7 +335,7 @@ func.func @pad_and_pack_partially_dynamic(%input: tensor, %output: tens module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -391,7 +391,7 @@ func.func @pad_and_pack_fully_dynamic(%source: tensor, %dest: tensor !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -440,7 +440,7 @@ func.func @NCnc_to_NC(%source: tensor<8x8x32x16xf32>, %dest: tensor<256x128xf32> module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -488,7 +488,7 @@ func.func @CKkc_to_KC(%source: tensor<32x4x32x8xf32>, %dest: tensor<128x256xf32> module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -526,7 +526,7 @@ func.func @perfect_CKkc_to_KC(%source: tensor<32x4x2x4xf32>, %dest: tensor<8x128 module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -570,7 +570,7 @@ func.func @dynamic_perfect_CKkc_to_KC(%source: tensor, %dest: tenso module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -607,7 +607,7 @@ func.func @perfect_NKPQk_to_NPQK(%source: tensor<1x4x6x6x2xf32>, %dest: tensor<1 module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.unpack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:4 = transform.structured.tile_using_for %0 [1, 1, 1, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:4 = transform.structured.tile_using_for %0 tile_sizes [1, 1, 1, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -635,7 +635,7 @@ func.func @fully_dynamic_unpack(%source: tensor, %dest: tensor !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [4, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [4, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } @@ -671,7 +671,7 @@ func.func @perfect_NPQK_to_NKPQk(%source: tensor<1x6x6x8xf32>, %dest: tensor<1x4 module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["tensor.pack"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:4 = transform.structured.tile_using_for %0 [1, 1, 1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:4 = transform.structured.tile_using_for %0 tile_sizes [1, 1, 1, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Dialect/Transform/ops.mlir b/mlir/test/Dialect/Transform/ops.mlir index ecef7e181e903..b03a9f4d760d2 100644 --- a/mlir/test/Dialect/Transform/ops.mlir +++ b/mlir/test/Dialect/Transform/ops.mlir @@ -101,19 +101,19 @@ transform.sequence failures(propagate) { } // CHECK: transform.sequence -// CHECK: transform.structured.tile_using_for %0[4, 4, [4]] +// CHECK: transform.structured.tile_using_for %0 tile_sizes [4, 4, [4]] transform.sequence failures(propagate) { ^bb0(%arg1: !transform.any_op): %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.tile_using_for %0 [4, 4, [4]] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + transform.structured.tile_using_for %0 tile_sizes [4, 4, [4]] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) } // CHECK: transform.sequence -// CHECK: transform.structured.tile_using_for %0{{\[}}[2], 4, 8] +// CHECK: transform.structured.tile_using_for %0 tile_sizes {{\[}}[2], 4, 8] transform.sequence failures(propagate) { ^bb0(%arg1: !transform.any_op): %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.tile_using_for %0 [[2], 4, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + transform.structured.tile_using_for %0 tile_sizes [[2], 4, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) } // CHECK: transform.sequence diff --git a/mlir/test/Dialect/Transform/selective-targeting.mlir b/mlir/test/Dialect/Transform/selective-targeting.mlir index e88104315649a..69342100935c7 100644 --- a/mlir/test/Dialect/Transform/selective-targeting.mlir +++ b/mlir/test/Dialect/Transform/selective-targeting.mlir @@ -79,7 +79,7 @@ module attributes {transform.with_named_sequence} { transform.sequence %arg0 : !transform.any_op failures(propagate) { ^bb1(%arg1: !transform.any_op): %0 = pdl_match @pdl_target_attrA in %arg1 : (!transform.any_op) -> !transform.any_op - transform.structured.tile_using_for %0 [4, 4, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + transform.structured.tile_using_for %0 tile_sizes [4, 4, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) %1 = pdl_match @pdl_target_attrC in %arg1 : (!transform.any_op) -> !transform.any_op %2 = get_parent_op %1 {isolated_from_above} : (!transform.any_op) -> !transform.any_op transform.structured.vectorize_children_and_apply_patterns %2 : (!transform.any_op) -> !transform.any_op diff --git a/mlir/test/Dialect/Vector/transform-vector.mlir b/mlir/test/Dialect/Vector/transform-vector.mlir index a0ca8c2fa9b6a..75b29e22b4d2c 100644 --- a/mlir/test/Dialect/Vector/transform-vector.mlir +++ b/mlir/test/Dialect/Vector/transform-vector.mlir @@ -16,7 +16,7 @@ func.func @matmul_tensors( module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%module_op: !transform.any_op {transform.consumed}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %module_op : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [8, 4, 2] + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [8, 4, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) %2 = transform.get_parent_op %1 {isolated_from_above} : (!transform.any_op) -> !transform.any_op transform.structured.vectorize_children_and_apply_patterns %2 : (!transform.any_op) -> !transform.any_op diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul-transpose-a.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul-transpose-a.mlir index 34c5351c8703d..a8b6457d64bec 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul-transpose-a.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul-transpose-a.mlir @@ -61,7 +61,7 @@ module attributes {transform.with_named_sequence} { // Step 1: Tile for size [4] x [4], which corresponds to SVLs x SVLs, where // SVLs is the number of 32-bit elements in a vector of SVL bits. - %tiled_linalg_op, %loops:3 = transform.structured.tile_using_for %matmul_transpose_a[[4], [4], 1] + %tiled_linalg_op, %loops:3 = transform.structured.tile_using_for %matmul_transpose_a tile_sizes [[4], [4], 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) // Step 2: Vectorize. diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul.mlir index 2bfdaa8e8a2be..091665223188f 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/matmul.mlir @@ -59,7 +59,7 @@ module attributes {transform.with_named_sequence} { // Step 1: Tile for size [4] x [4], which corresponds to SVLs x SVLs, where // SVLs is the number of 32-bit elements in a vector of SVL bits. - %tiled_linalg_op, %loops:3 = transform.structured.tile_using_for %matmul[[4], [4], 1] + %tiled_linalg_op, %loops:3 = transform.structured.tile_using_for %matmul tile_sizes [[4], [4], 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) // Step 2: Vectorize. diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul-mixed-types.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul-mixed-types.mlir index 9f06226a4f651..10ffed2688178 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul-mixed-types.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul-mixed-types.mlir @@ -84,7 +84,7 @@ module attributes {transform.with_named_sequence} { // Step 1: Tile for size [8] x [8] (unrolled by 4), which corresponds to // (2 x SVLs) x (2 x SVLs), where SVLs is the number of 32-bit elements in a // vector of SVL bits. This uses all four 32-bit SME virtual tiles. - %tiled_linalg_op, %loop_i, %loop_j, %loop_k = transform.structured.tile_using_for %matmul[[8], [8], 4] + %tiled_linalg_op, %loop_i, %loop_j, %loop_k = transform.structured.tile_using_for %matmul tile_sizes [[8], [8], 4] : (!transform.any_op) -> (!transform.any_op, !transform.op<"scf.for">, !transform.op<"scf.for">, !transform.op<"scf.for">) // Step 2: Vectorize. diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul.mlir index e376bdde24a15..ada744b322fe9 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul.mlir @@ -72,7 +72,7 @@ module attributes {transform.with_named_sequence} { // Step 1: Tile for size [8] x [8] (unrolled by 4), which corresponds to // (2 x SVLs) x (2 x SVLs), where SVLs is the number of 32-bit elements in a // vector of SVL bits. This uses all four 32-bit SME virtual tiles. - %tiled_linalg_op, %loop_i, %loop_j, %loop_k = transform.structured.tile_using_for %matmul[[8], [8], 4] + %tiled_linalg_op, %loop_i, %loop_j, %loop_k = transform.structured.tile_using_for %matmul tile_sizes [[8], [8], 4] : (!transform.any_op) -> (!transform.any_op, !transform.op<"scf.for">, !transform.op<"scf.for">, !transform.op<"scf.for">) // Step 2: Vectorize. diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSVE/matmul.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSVE/matmul.mlir index 68e474fe5cefe..edb9de922808c 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/ArmSVE/matmul.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/ArmSVE/matmul.mlir @@ -96,7 +96,7 @@ module attributes {transform.with_named_sequence} { : (!transform.op<"func.func">) -> !transform.any_op // Step 1: Tile - %tiled_matmul, %loops:3 = transform.structured.tile_using_for %matmul [2, [4], 1] + %tiled_matmul, %loops:3 = transform.structured.tile_using_for %matmul tile_sizes [2, [4], 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) // Step 2: Vectorize diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/mmt4d.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/mmt4d.mlir index 92c7039c84960..183625f9748c2 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/mmt4d.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/mmt4d.mlir @@ -70,10 +70,10 @@ module @transforms attributes { transform.with_named_sequence } { // Step 1: Tile // Tile parallel dims - %tiled_linalg_op_p, %loops:4 = transform.structured.tile_using_for %mmt4d[1, 1, 0, 3, 3, 0] + %tiled_linalg_op_p, %loops:4 = transform.structured.tile_using_for %mmt4d tile_sizes [1, 1, 0, 3, 3, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) // Tile reduction dims - %tiled_linalg_op_r, %loops2:2 = transform.structured.tile_using_for %tiled_linalg_op_p[0, 0, 1, 0, 0, 1] + %tiled_linalg_op_r, %loops2:2 = transform.structured.tile_using_for %tiled_linalg_op_p tile_sizes [0, 0, 1, 0, 0, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) // Step 2: Vectorize diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/pack-unpack-mmt4d.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/pack-unpack-mmt4d.mlir index 5680882dccb1e..10b29dd70177b 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/pack-unpack-mmt4d.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/pack-unpack-mmt4d.mlir @@ -107,10 +107,10 @@ module @transforms attributes { transform.with_named_sequence } { // Step 1: Tile // Tile parallel dims - %tiled_linalg_op_p, %loops:4 = transform.structured.tile_using_for %mmt4d[1, 1, 0, 8, 8, 0] + %tiled_linalg_op_p, %loops:4 = transform.structured.tile_using_for %mmt4d tile_sizes [1, 1, 0, 8, 8, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) // Tile reduction dims - %tiled_linalg_op_r, %loops2:2 = transform.structured.tile_using_for %tiled_linalg_op_p[0, 0, 1, 0, 0, 1] + %tiled_linalg_op_r, %loops2:2 = transform.structured.tile_using_for %tiled_linalg_op_p tile_sizes [0, 0, 1, 0, 0, 1] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) // Step 2: Vectorize diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-call.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-call.mlir index 443963fb8c590..9b46056918b56 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-call.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-call.mlir @@ -27,7 +27,7 @@ func.func @conv_1d(%arg0: memref, %arg1: memref, %arg2: memref !transform.any_op - %1, %loop = transform.structured.tile_using_for %0 [4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1, %loop = transform.structured.tile_using_for %0 tile_sizes [4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir index f652d707de05e..d6726fe1a6b42 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir @@ -29,7 +29,7 @@ func.func @conv_1d_nwc_wcf(%arg0: memref, %arg1: memref, % module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.conv_1d_nwc_wcf"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 4] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir index 2eaba8233d69e..bb77d5eb9b8d8 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir @@ -27,7 +27,7 @@ func.func @conv_2d(%arg0: memref, %arg1: memref, %arg2: memref module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.conv_2d"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:2 = transform.structured.tile_using_for %0 [2, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:2 = transform.structured.tile_using_for %0 tile_sizes [2, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-hwcf-call.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-hwcf-call.mlir index eac8d8a6ea437..39415dff1cbb9 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-hwcf-call.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-hwcf-call.mlir @@ -29,7 +29,7 @@ func.func @conv_2d_nhwc_hwcf(%arg0: memref, %arg1: memref !transform.any_op - %1, %loops:4 = transform.structured.tile_using_for %0 [2, 3, 3, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:4 = transform.structured.tile_using_for %0 tile_sizes [2, 3, 3, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir index d5584cd67702c..ece054ac71765 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir @@ -27,7 +27,7 @@ func.func @conv_3d(%arg0: memref, %arg1: memref, %arg2: me module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.conv_3d"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [2, 2, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [2, 2, 2] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-dhwcf-call.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-dhwcf-call.mlir index 7dca793345656..ce169ee470c3f 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-dhwcf-call.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-dhwcf-call.mlir @@ -29,7 +29,7 @@ func.func @conv_3d_ndhwc_dhwcf(%arg0: memref, %arg1: memref !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [0, 5, 5, 5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [0, 5, 5, 5] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir b/mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir index fda7ffb0c753c..41296cdfcb2d5 100644 --- a/mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir +++ b/mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir @@ -39,7 +39,7 @@ func.func @main() { module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1, %loops:3 = transform.structured.tile_using_for %0 [1, 2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) + %1, %loops:3 = transform.structured.tile_using_for %0 tile_sizes [1, 2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/Interfaces/TilingInterface/tile-pad-using-interface.mlir b/mlir/test/Interfaces/TilingInterface/tile-pad-using-interface.mlir index ba56206f03d76..7d247aefcf6b1 100644 --- a/mlir/test/Interfaces/TilingInterface/tile-pad-using-interface.mlir +++ b/mlir/test/Interfaces/TilingInterface/tile-pad-using-interface.mlir @@ -14,7 +14,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %pad = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c = transform.structured.tile_using_for %pad [2, 3] + %a, %b, %c = transform.structured.tile_using_for %pad tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -57,7 +57,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %pad = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b = transform.structured.tile_using_for %pad [0, 3] + %a, %b = transform.structured.tile_using_for %pad tile_sizes [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } @@ -97,7 +97,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %pad = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c = transform.structured.tile_using_for %pad [2, 3] + %a, %b, %c = transform.structured.tile_using_for %pad tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -134,7 +134,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %pad = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b = transform.structured.tile_using_for %pad [0, 3] + %a, %b = transform.structured.tile_using_for %pad tile_sizes [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } @@ -170,7 +170,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %pad = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c = transform.structured.tile_using_for %pad [2, 3] + %a, %b, %c = transform.structured.tile_using_for %pad tile_sizes [2, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -192,7 +192,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %pad = transform.structured.match ops{["tensor.pad"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b = transform.structured.tile_using_for %pad [0, 3] + %a, %b = transform.structured.tile_using_for %pad tile_sizes [0, 3] : (!transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } diff --git a/mlir/test/Interfaces/TilingInterface/tile-using-interface.mlir b/mlir/test/Interfaces/TilingInterface/tile-using-interface.mlir index 607836faafb71..488a52e8e3e91 100644 --- a/mlir/test/Interfaces/TilingInterface/tile-using-interface.mlir +++ b/mlir/test/Interfaces/TilingInterface/tile-using-interface.mlir @@ -11,7 +11,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c = transform.structured.tile_using_for %matmul [10, 20] + %a, %b, %c = transform.structured.tile_using_for %matmul tile_sizes [10, 20] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -63,7 +63,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c, %d = transform.structured.tile_using_for %matmul [10, 20, 30] + %a, %b, %c, %d = transform.structured.tile_using_for %matmul tile_sizes [10, 20, 30] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -122,7 +122,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %generic = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c = transform.structured.tile_using_for %generic [10, 0, 20] + %a, %b, %c = transform.structured.tile_using_for %generic tile_sizes [10, 0, 20] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -175,7 +175,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %conv = transform.structured.match ops{["linalg.conv_2d_nhwc_hwcf"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c, %d = transform.structured.tile_using_for %conv [0, 0, 0, 0, 10, 20, 30] + %a, %b, %c, %d = transform.structured.tile_using_for %conv tile_sizes [0, 0, 0, 0, 10, 20, 30] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -254,7 +254,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %generic = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c = transform.structured.tile_using_for %generic [10, 20] + %a, %b, %c = transform.structured.tile_using_for %generic tile_sizes [10, 20] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -282,7 +282,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %matmul = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c, %d = transform.structured.tile_using_for %matmul [10, 20, 30] interchange = [1, 2, 0] + %a, %b, %c, %d = transform.structured.tile_using_for %matmul tile_sizes [10, 20, 30] interchange = [1, 2, 0] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -338,7 +338,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %copy = transform.structured.match ops{["linalg.copy"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a, %b, %c = transform.structured.tile_using_for %copy [10, 20] + %a, %b, %c = transform.structured.tile_using_for %copy tile_sizes [10, 20] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op) transform.yield } @@ -369,7 +369,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %generic = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a = transform.structured.tile_using_for %generic [] + %a = transform.structured.tile_using_for %generic tile_sizes [] : (!transform.any_op) -> (!transform.any_op) transform.yield } @@ -396,7 +396,7 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1 : !transform.any_op {transform.readonly}) { %generic = transform.structured.match ops{["linalg.generic"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %a = transform.structured.tile_using_for %generic [] + %a = transform.structured.tile_using_for %generic tile_sizes [] : (!transform.any_op) -> (!transform.any_op) transform.yield } From ce17605d8ac813a7e184035ca06da22576670970 Mon Sep 17 00:00:00 2001 From: Sam Date: Fri, 3 May 2024 09:58:23 -0500 Subject: [PATCH 11/18] address review comments --- .../Dialect/Linalg/TransformOps/LinalgTransformOps.td | 4 ++-- mlir/python/mlir/dialects/transform/structured.py | 10 ++++------ mlir/test/python/dialects/transform_structured_ext.py | 11 +++++------ 3 files changed, 11 insertions(+), 14 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index a411d209de590..a105165a4009b 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -1024,8 +1024,8 @@ def PadOp : Op($pad_to_multiple_of, $static_pad_to_multiple_of)) + $target + (`pad_to_multiple_of` custom($pad_to_multiple_of, $static_pad_to_multiple_of)^)? attr-dict `:` functional-type(operands, results) }]; diff --git a/mlir/python/mlir/dialects/transform/structured.py b/mlir/python/mlir/dialects/transform/structured.py index 4f4a0e598df7d..2c49ef0960c75 100644 --- a/mlir/python/mlir/dialects/transform/structured.py +++ b/mlir/python/mlir/dialects/transform/structured.py @@ -373,11 +373,10 @@ class PadOp(PadOp): def __init__( self, target: Union[Operation, OpView, Value], - pad_to_multiple_of: Optional[Union[DynamicIndexList, ArrayAttr]] = None, *, + pad_to_multiple_of: Optional[Union[DynamicIndexList, ArrayAttr]] = None, padding_values: Optional[Union[ArrayAttr, Sequence[Attribute]]] = None, padding_dimensions: OptionalIntList = None, - static_pad_to_multiple_of: OptionalIntList = None, pack_paddings: OptionalIntList = None, transpose_paddings: Optional[ Union[ArrayAttr, Sequence[Union[ArrayAttr, IntOrAttrList]]] @@ -386,16 +385,15 @@ def __init__( loc=None, ip=None, ): - if static_pad_to_multiple_of is None and pad_to_multiple_of is None: + if pad_to_multiple_of is None: dynamic_pad_to_multiple_of = [] - elif static_pad_to_multiple_of is None: + static_pad_to_multiple_of = None + else: ( dynamic_pad_to_multiple_of, static_pad_to_multiple_of, _, ) = _dispatch_dynamic_index_list(pad_to_multiple_of) - else: - dynamic_pad_to_multiple_of = pad_to_multiple_of transpose_paddings = _get_int_array_array_attr(transpose_paddings) diff --git a/mlir/test/python/dialects/transform_structured_ext.py b/mlir/test/python/dialects/transform_structured_ext.py index 8deca33de6d99..f4c092ba9ee98 100644 --- a/mlir/test/python/dialects/transform_structured_ext.py +++ b/mlir/test/python/dialects/transform_structured_ext.py @@ -316,10 +316,9 @@ def testPadOpNoArgs(target): def testPadOpArgs(target): structured.PadOp( target, - [], + pad_to_multiple_of=[128], padding_values=[FloatAttr.get_f32(42.0), StringAttr.get("0")], padding_dimensions=Attribute.parse("[1]"), - static_pad_to_multiple_of=[128], pack_paddings=[0], transpose_paddings=[[1, Attribute.parse("0")], Attribute.parse("[0, 1]")], copy_back_op="linalg.copy", @@ -340,15 +339,15 @@ def testPadOpArgs(target): def testPadOpArgsParam(target): structured.PadOp( target, - [constant_param(128), Attribute.parse("2")], - padding_dimensions=Attribute.parse("[0, 1]"), + pad_to_multiple_of=[constant_param(128), Attribute.parse("2"), 10], + padding_dimensions=Attribute.parse("[0, 1, 2]"), ) # CHECK-LABEL: TEST: testPadOpArgsParam # CHECK: transform.sequence # CHECK-DAG: %[[P:.*]] = transform.param.constant 128 # CHECK: transform.structured.pad - # CHECK-DAG: pad_to_multiple_of [%[[P]], 2] - # CHECK-DAG: padding_dimensions = [0, 1] + # CHECK-DAG: pad_to_multiple_of [%[[P]], 2, 10] + # CHECK-DAG: padding_dimensions = [0, 1, 2] @run From f65cc751df750da7940c76895cd3de9f9277ff89 Mon Sep 17 00:00:00 2001 From: Sam Date: Fri, 3 May 2024 09:58:23 -0500 Subject: [PATCH 12/18] address review comments --- .../Dialect/Linalg/TransformOps/LinalgTransformOps.td | 4 ++-- mlir/python/mlir/dialects/transform/structured.py | 10 ++++------ mlir/test/python/dialects/transform_structured_ext.py | 11 +++++------ 3 files changed, 11 insertions(+), 14 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index f23c65d827d16..55d82fd5825bf 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -1024,8 +1024,8 @@ def PadOp : Op($pad_to_multiple_of, $static_pad_to_multiple_of)) + $target + (`pad_to_multiple_of` custom($pad_to_multiple_of, $static_pad_to_multiple_of)^)? attr-dict `:` functional-type(operands, results) }]; diff --git a/mlir/python/mlir/dialects/transform/structured.py b/mlir/python/mlir/dialects/transform/structured.py index 4f4a0e598df7d..2c49ef0960c75 100644 --- a/mlir/python/mlir/dialects/transform/structured.py +++ b/mlir/python/mlir/dialects/transform/structured.py @@ -373,11 +373,10 @@ class PadOp(PadOp): def __init__( self, target: Union[Operation, OpView, Value], - pad_to_multiple_of: Optional[Union[DynamicIndexList, ArrayAttr]] = None, *, + pad_to_multiple_of: Optional[Union[DynamicIndexList, ArrayAttr]] = None, padding_values: Optional[Union[ArrayAttr, Sequence[Attribute]]] = None, padding_dimensions: OptionalIntList = None, - static_pad_to_multiple_of: OptionalIntList = None, pack_paddings: OptionalIntList = None, transpose_paddings: Optional[ Union[ArrayAttr, Sequence[Union[ArrayAttr, IntOrAttrList]]] @@ -386,16 +385,15 @@ def __init__( loc=None, ip=None, ): - if static_pad_to_multiple_of is None and pad_to_multiple_of is None: + if pad_to_multiple_of is None: dynamic_pad_to_multiple_of = [] - elif static_pad_to_multiple_of is None: + static_pad_to_multiple_of = None + else: ( dynamic_pad_to_multiple_of, static_pad_to_multiple_of, _, ) = _dispatch_dynamic_index_list(pad_to_multiple_of) - else: - dynamic_pad_to_multiple_of = pad_to_multiple_of transpose_paddings = _get_int_array_array_attr(transpose_paddings) diff --git a/mlir/test/python/dialects/transform_structured_ext.py b/mlir/test/python/dialects/transform_structured_ext.py index 8deca33de6d99..f4c092ba9ee98 100644 --- a/mlir/test/python/dialects/transform_structured_ext.py +++ b/mlir/test/python/dialects/transform_structured_ext.py @@ -316,10 +316,9 @@ def testPadOpNoArgs(target): def testPadOpArgs(target): structured.PadOp( target, - [], + pad_to_multiple_of=[128], padding_values=[FloatAttr.get_f32(42.0), StringAttr.get("0")], padding_dimensions=Attribute.parse("[1]"), - static_pad_to_multiple_of=[128], pack_paddings=[0], transpose_paddings=[[1, Attribute.parse("0")], Attribute.parse("[0, 1]")], copy_back_op="linalg.copy", @@ -340,15 +339,15 @@ def testPadOpArgs(target): def testPadOpArgsParam(target): structured.PadOp( target, - [constant_param(128), Attribute.parse("2")], - padding_dimensions=Attribute.parse("[0, 1]"), + pad_to_multiple_of=[constant_param(128), Attribute.parse("2"), 10], + padding_dimensions=Attribute.parse("[0, 1, 2]"), ) # CHECK-LABEL: TEST: testPadOpArgsParam # CHECK: transform.sequence # CHECK-DAG: %[[P:.*]] = transform.param.constant 128 # CHECK: transform.structured.pad - # CHECK-DAG: pad_to_multiple_of [%[[P]], 2] - # CHECK-DAG: padding_dimensions = [0, 1] + # CHECK-DAG: pad_to_multiple_of [%[[P]], 2, 10] + # CHECK-DAG: padding_dimensions = [0, 1, 2] @run From d45b1b0b78bc021934b544a3e8ed18f15de50b1a Mon Sep 17 00:00:00 2001 From: Sam Date: Fri, 3 May 2024 13:23:17 -0500 Subject: [PATCH 13/18] modify PackedOrDyanmicList and change assembly for tile_using_forall --- .../Linalg/TransformOps/LinalgTransformOps.td | 6 +---- .../mlir/Dialect/Transform/Utils/Utils.h | 16 ++++++++++++- mlir/lib/Dialect/Transform/Utils/Utils.cpp | 19 +++++++++------ mlir/test/Dialect/Linalg/tile-to-forall.mlir | 24 +++++++++---------- .../dialects/transform_structured_ext.py | 4 ++-- 5 files changed, 42 insertions(+), 27 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index a105165a4009b..7ce1883a61988 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -2027,17 +2027,13 @@ def TileUsingForallOp : let assemblyFormat = [{ $target oilist( `num_threads` custom($packed_num_threads, - type($packed_num_threads), $num_threads, - type($num_threads), $static_num_threads) | `tile_sizes` custom($packed_tile_sizes, - type($packed_tile_sizes), $tile_sizes, - type($tile_sizes), $static_tile_sizes)) (`(` `mapping` `=` $mapping^ `)`)? attr-dict - `:` functional-type($target, results) + `:` functional-type(operands, results) }]; let hasVerifier = 1; diff --git a/mlir/include/mlir/Dialect/Transform/Utils/Utils.h b/mlir/include/mlir/Dialect/Transform/Utils/Utils.h index 868054e5e2aef..be31f5beea8cb 100644 --- a/mlir/include/mlir/Dialect/Transform/Utils/Utils.h +++ b/mlir/include/mlir/Dialect/Transform/Utils/Utils.h @@ -37,6 +37,12 @@ void printPackedOrDynamicIndexList(OpAsmPrinter &printer, Operation *op, Value packed, Type packedType, OperandRange values, TypeRange valueTypes, DenseI64ArrayAttr integers); +inline void printPackedOrDynamicIndexList(OpAsmPrinter &printer, Operation *op, + Value packed, OperandRange values, + DenseI64ArrayAttr integers) { + printPackedOrDynamicIndexList(printer, op, packed, Type(), values, + TypeRange{}, integers); +} /// Parser hook for custom directive in assemblyFormat. /// @@ -47,7 +53,15 @@ void printPackedOrDynamicIndexList(OpAsmPrinter &printer, Operation *op, ParseResult parsePackedOrDynamicIndexList( OpAsmParser &parser, std::optional &packed, Type &packedType, SmallVectorImpl &values, - SmallVectorImpl &valueTypes, DenseI64ArrayAttr &integers); + SmallVectorImpl *valueTypes, DenseI64ArrayAttr &integers); +inline ParseResult parsePackedOrDynamicIndexList( + OpAsmParser &parser, std::optional &packed, + SmallVectorImpl &values, + DenseI64ArrayAttr &integers) { + Type packedType; + return parsePackedOrDynamicIndexList(parser, packed, packedType, values, + nullptr, integers); +} } // namespace transform } // namespace mlir diff --git a/mlir/lib/Dialect/Transform/Utils/Utils.cpp b/mlir/lib/Dialect/Transform/Utils/Utils.cpp index 08068d285b4c2..2ce21fe8a9c12 100644 --- a/mlir/lib/Dialect/Transform/Utils/Utils.cpp +++ b/mlir/lib/Dialect/Transform/Utils/Utils.cpp @@ -20,7 +20,11 @@ void mlir::transform::printPackedOrDynamicIndexList( if (packed) { assert(values.empty() && (!integers || integers.empty()) && "expected no values/integers"); - printer << "*(" << packed << " : " << packedType << ")"; + printer << "*(" << packed; + if (packedType) { + printer << " : " << packedType; + } + printer << ")"; return; } printDynamicIndexList(printer, op, values, integers, valueTypes); @@ -29,19 +33,20 @@ void mlir::transform::printPackedOrDynamicIndexList( ParseResult mlir::transform::parsePackedOrDynamicIndexList( OpAsmParser &parser, std::optional &packed, Type &packedType, SmallVectorImpl &values, - SmallVectorImpl &valueTypes, DenseI64ArrayAttr &integers) { + SmallVectorImpl *valueTypes, DenseI64ArrayAttr &integers) { OpAsmParser::UnresolvedOperand packedOperand; if (parser.parseOptionalStar().succeeded()) { if (parser.parseLParen().failed() || - parser.parseOperand(packedOperand).failed() || - parser.parseColonType(packedType).failed() || - parser.parseRParen().failed()) { + parser.parseOperand(packedOperand).failed()) + return failure(); + if (packedType && (parser.parseColonType(packedType).failed())) + return failure(); + if (parser.parseRParen().failed()) return failure(); - } packed.emplace(packedOperand); integers = parser.getBuilder().getDenseI64ArrayAttr({}); return success(); } - return parseDynamicIndexList(parser, values, integers, &valueTypes); + return parseDynamicIndexList(parser, values, integers, valueTypes); } diff --git a/mlir/test/Dialect/Linalg/tile-to-forall.mlir b/mlir/test/Dialect/Linalg/tile-to-forall.mlir index 12e2dea5530b5..8545dfd25eccf 100644 --- a/mlir/test/Dialect/Linalg/tile-to-forall.mlir +++ b/mlir/test/Dialect/Linalg/tile-to-forall.mlir @@ -130,8 +130,8 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op %sz = transform.structured.match ops{["test.dummy"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1:2 = transform.structured.tile_using_forall %0 tile_sizes *(%sz : !transform.any_op) - : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1:2 = transform.structured.tile_using_forall %0 tile_sizes *(%sz) + : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -333,8 +333,8 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op %sz = transform.structured.match ops{["test.dummy"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1:2 = transform.structured.tile_using_forall %0 tile_sizes [%sz : !transform.any_op, 20] - : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1:2 = transform.structured.tile_using_forall %0 tile_sizes [%sz, 20] + : (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -492,8 +492,8 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op %sz = transform.param.constant 10 : i64 -> !transform.param - %1:2 = transform.structured.tile_using_forall %0 tile_sizes [%sz : !transform.param, 20] - : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1:2 = transform.structured.tile_using_forall %0 tile_sizes [%sz, 20] + : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -513,8 +513,8 @@ module attributes {transform.with_named_sequence} { %c20 = transform.param.constant 20 : i64 -> !transform.param %sz = transform.merge_handles %c10, %c20 : !transform.param // expected-error @below {{requires exactly one parameter associated}} - %1:2 = transform.structured.tile_using_forall %0 tile_sizes [%sz : !transform.param, 20] - : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1:2 = transform.structured.tile_using_forall %0 tile_sizes [%sz, 20] + : (!transform.any_op, !transform.param) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -562,8 +562,8 @@ module attributes {transform.with_named_sequence} { %c10 = transform.param.constant 10 : i64 -> !transform.any_param %c20 = transform.param.constant 20 : i64 -> !transform.any_param %sz = transform.merge_handles %c10, %c20 : !transform.any_param - %1:2 = transform.structured.tile_using_forall %0 tile_sizes *(%sz : !transform.any_param) - : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1:2 = transform.structured.tile_using_forall %0 tile_sizes *(%sz) + : (!transform.any_op, !transform.any_param) -> (!transform.any_op, !transform.any_op) transform.yield } } @@ -581,8 +581,8 @@ module attributes {transform.with_named_sequence} { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op %sz = transform.param.constant "[10 : i64, 20 : i64]" -> !transform.any_param // expected-error @below {{expected the parameter to be associated with an integer attribute}} - %1:2 = transform.structured.tile_using_forall %0 tile_sizes *(%sz : !transform.any_param) - : (!transform.any_op) -> (!transform.any_op, !transform.any_op) + %1:2 = transform.structured.tile_using_forall %0 tile_sizes *(%sz) + : (!transform.any_op, !transform.any_param) -> (!transform.any_op, !transform.any_op) transform.yield } } diff --git a/mlir/test/python/dialects/transform_structured_ext.py b/mlir/test/python/dialects/transform_structured_ext.py index f4c092ba9ee98..ce996914bd5ad 100644 --- a/mlir/test/python/dialects/transform_structured_ext.py +++ b/mlir/test/python/dialects/transform_structured_ext.py @@ -501,7 +501,7 @@ def testTileToForallMixedDynamic(target): structured.TileUsingForallOp(target, num_threads=[n, 3, 4]) # CHECK-LABEL: TEST: testTileToForallMixedDynamic # CHECK: = transform.structured.tile_using_forall - # CHECK-SAME: num_threads [%{{.*}} : !transform.any_op, 3, 4] + # CHECK-SAME: num_threads [%{{.*}}, 3, 4] : (!transform.any_op, !transform.any_op) @run @@ -511,7 +511,7 @@ def testTileToForallPackedDynamic(target): structured.TileUsingForallOp(target, num_threads=n) # CHECK-LABEL: TEST: testTileToForallPackedDynamic # CHECK: = transform.structured.tile_using_forall - # CHECK-SAME: num_threads *(%0 : !transform.any_op) + # CHECK-SAME: num_threads *(%0) : (!transform.any_op, !transform.any_op) @run From bc5fd5a7d354caa2bf40543f381bbec21051216d Mon Sep 17 00:00:00 2001 From: Sam Date: Fri, 3 May 2024 13:29:15 -0500 Subject: [PATCH 14/18] fix formatting --- mlir/test/python/dialects/transform_structured_ext.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlir/test/python/dialects/transform_structured_ext.py b/mlir/test/python/dialects/transform_structured_ext.py index ce996914bd5ad..935534edba7a6 100644 --- a/mlir/test/python/dialects/transform_structured_ext.py +++ b/mlir/test/python/dialects/transform_structured_ext.py @@ -511,7 +511,7 @@ def testTileToForallPackedDynamic(target): structured.TileUsingForallOp(target, num_threads=n) # CHECK-LABEL: TEST: testTileToForallPackedDynamic # CHECK: = transform.structured.tile_using_forall - # CHECK-SAME: num_threads *(%0) : (!transform.any_op, !transform.any_op) + # CHECK-SAME: num_threads *(%0) : (!transform.any_op, !transform.any_op) @run From eaf0e38fd69f336181ff943c4d3c1d556de54fd8 Mon Sep 17 00:00:00 2001 From: srcarroll <50210727+srcarroll@users.noreply.github.com> Date: Sat, 4 May 2024 16:15:46 -0500 Subject: [PATCH 15/18] Update mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp Co-authored-by: Oleksandr "Alex" Zinenko --- mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index 8752e90bc7cad..c5b2ce197f62d 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -192,7 +192,10 @@ static DiagnosedSilenceableFailure reifyMixedParamAndHandleResults( continue; } - auto payload = state.getPayloadOps(paramOrHandle.get()); + Value handle = paramOrHandle.get(); + if (!isa(handle.getType()) + return transformOp.emitSilenceableError() << "unexpected value handle"; + auto payload = state.getPayloadOps(handle); if (!llvm::hasSingleElement(payload)) return transformOp.emitSilenceableError() << "requires param or handle that is mapped to 1 payload op"; From 66f9d4dfef2662adba5a8271e459de8d27321b5b Mon Sep 17 00:00:00 2001 From: Sam Date: Sat, 4 May 2024 16:50:22 -0500 Subject: [PATCH 16/18] fix typo --- mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp index c5b2ce197f62d..eadd819bee740 100644 --- a/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp +++ b/mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp @@ -193,7 +193,7 @@ static DiagnosedSilenceableFailure reifyMixedParamAndHandleResults( } Value handle = paramOrHandle.get(); - if (!isa(handle.getType()) + if (!isa(handle.getType())) return transformOp.emitSilenceableError() << "unexpected value handle"; auto payload = state.getPayloadOps(handle); if (!llvm::hasSingleElement(payload)) From 12b2194bb954d2163c09feaef0b40da5927e7cf2 Mon Sep 17 00:00:00 2001 From: Sam Date: Sat, 4 May 2024 17:52:53 -0500 Subject: [PATCH 17/18] change pack and pack_greedily --- .../Dialect/Linalg/TransformOps/LinalgTransformOps.td | 10 ++++------ mlir/test/Dialect/Linalg/transform-op-pack.mlir | 4 ++-- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index 7ce1883a61988..4229adcd8fb16 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -783,10 +783,9 @@ def PackOp : Op($packed_sizes, - $static_packed_sizes, - type($packed_sizes)) + $static_packed_sizes) attr-dict - `:` functional-type($target, results) + `:` functional-type(operands, results) }]; let builders = [ @@ -890,14 +889,13 @@ def PackGreedilyOp : Op($matmul_packed_sizes, - $static_matmul_packed_sizes, - type($matmul_packed_sizes)) + $static_matmul_packed_sizes) (`matmul_padded_sizes_next_multiple_of` `=` $matmul_padded_sizes_next_multiple_of^)? `matmul_inner_dims_order` `=` $matmul_inner_dims_order ) attr-dict - `:` functional-type($target, results) + `:` functional-type(operands, results) }]; let hasVerifier = 1; diff --git a/mlir/test/Dialect/Linalg/transform-op-pack.mlir b/mlir/test/Dialect/Linalg/transform-op-pack.mlir index cf6339ce3de82..6c26ebd0a5b84 100644 --- a/mlir/test/Dialect/Linalg/transform-op-pack.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-pack.mlir @@ -372,8 +372,8 @@ module attributes {transform.with_named_sequence} { transform.named_sequence @__transform_main(%arg1: !transform.any_op {transform.readonly}) { %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op %sz = transform.structured.match ops{["some_tile_size"]} in %arg1 : (!transform.any_op) -> !transform.any_op - %1 = transform.structured.pack %0 packed_sizes = [0, %sz : !transform.any_op, %sz : !transform.any_op] - : (!transform.any_op) -> (!transform.op<"linalg.generic">) + %1 = transform.structured.pack %0 packed_sizes = [0, %sz, %sz] + : (!transform.any_op, !transform.any_op, !transform.any_op) -> (!transform.op<"linalg.generic">) transform.yield } } From df455ee4624196791dc8603ca82b7f3e30d08799 Mon Sep 17 00:00:00 2001 From: Sam Date: Wed, 8 May 2024 08:43:33 -0500 Subject: [PATCH 18/18] address review comments --- .../mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td index 4229adcd8fb16..5585ba27fdad8 100644 --- a/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td +++ b/mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td @@ -1898,11 +1898,11 @@ def TileUsingForOp : Op( $dynamic_sizes, $static_sizes, - $scalable_sizes)) + $scalable_sizes) (`interchange` `=` $interchange^)? attr-dict `:` functional-type(operands, results) @@ -2166,6 +2166,8 @@ def VectorizeOp : Op(