[Mlir-commits] [mlir] [Linalg] Rename `isaConvolutionOpOfType` to `matchConvolutionOpOfType` along with few more updates (PR #174722)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Wed Jan 7 01:29:44 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir
Author: Abhishek Varma (Abhishek-Varma)
<details>
<summary>Changes</summary>
-- This commit involves the following updates to `isaConvolutionOpOfType` API :-
1. Instead of a bool return value, the API will now return optional dilations/strides for the corresponding convolution op.
2. Because of the previous point, we update the name of the API to instead be `matchConvolutionOpOfType`.
3. Dilations/strides of named convolution op are also populated (missed adding it in the previous PRs).
4. [Max/Min]UnsignedPool ops' body matcher now only matches unsigned int ops (refer: https://github.com/llvm/llvm-project/pull/166070)
Signed-off-by: Abhishek Varma <abhvarma@<!-- -->amd.com>
---
Patch is 92.35 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/174722.diff
3 Files Affected:
- (modified) mlir/include/mlir/Dialect/Linalg/Utils/Utils.h (+10-5)
- (modified) mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp (+4-4)
- (modified) mlir/lib/Dialect/Linalg/Utils/Utils.cpp (+956-617)
``````````diff
diff --git a/mlir/include/mlir/Dialect/Linalg/Utils/Utils.h b/mlir/include/mlir/Dialect/Linalg/Utils/Utils.h
index 9da01f30b52d2..684829c2ccd2a 100644
--- a/mlir/include/mlir/Dialect/Linalg/Utils/Utils.h
+++ b/mlir/include/mlir/Dialect/Linalg/Utils/Utils.h
@@ -106,12 +106,17 @@ getReassociationMapForFoldingUnitDims(ArrayRef<OpFoldResult> mixedSizes);
// Convolution matcher utility
//===----------------------------------------------------------------------===//
-/// Given a linalg `op` this function returns true if it is a convolution op of
-/// type `ConvOpTy` and populates `dilations` and `strides` with values inferred
-/// from the indexing maps.
+/// A struct containing dilations and strides inferred from convolution ops.
+struct DilationsAndStrides {
+ SmallVector<int64_t> dilations;
+ SmallVector<int64_t> strides;
+};
+
+/// Given a linalg `op` this function returns DilationsAndStrides if it is a
+/// convolution op of type `ConvOpTy`, otherwise returns std::nullopt. The
+/// dilations and strides are inferred from the indexing maps.
template <typename ConvOpTy>
-bool isaConvolutionOpOfType(LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides);
+std::optional<DilationsAndStrides> matchConvolutionOpOfType(LinalgOp op);
//===----------------------------------------------------------------------===//
// Fusion / Tiling utilities
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp b/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp
index 0c7b998ffcab9..da062152f61ad 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp
@@ -267,11 +267,11 @@ specializeToConvOp(RewriterBase &rewriter, GenericOp genericOp,
/// Converts linalg.generic to named linalg.*conv/pooling* where possible.
static FailureOr<LinalgOp> specializeLinalgConvolutions(RewriterBase &rewriter,
GenericOp genericOp) {
- SmallVector<int64_t> dilations, strides;
#define CONV_OP_SPECIALIZER(ConvOpTy) \
- if (isaConvolutionOpOfType<ConvOpTy>(genericOp, &dilations, &strides)) \
- return specializeToConvOp<ConvOpTy>(rewriter, genericOp, dilations, \
- strides); \
+ if (std::optional<DilationsAndStrides> convParams = \
+ matchConvolutionOpOfType<ConvOpTy>(genericOp)) \
+ return specializeToConvOp<ConvOpTy>( \
+ rewriter, genericOp, convParams->dilations, convParams->strides); \
// -----------------------------
// Convolution ops.
// -----------------------------
diff --git a/mlir/lib/Dialect/Linalg/Utils/Utils.cpp b/mlir/lib/Dialect/Linalg/Utils/Utils.cpp
index 2718124251c18..4e1731ddcfd45 100644
--- a/mlir/lib/Dialect/Linalg/Utils/Utils.cpp
+++ b/mlir/lib/Dialect/Linalg/Utils/Utils.cpp
@@ -373,11 +373,8 @@ static bool bodyMatcherForMaxSignedPoolOps(Value yieldVal, Block *body) {
body);
}
-// max_unsigned ops should not allow float data type.
-// TODO(#164800): Retire OPDSL logic.
static bool bodyMatcherForMaxUnsignedPoolOps(Value yieldVal, Block *body) {
- return bodyMatcherForPoolOps<arith::MaximumFOp, arith::MaxUIOp>(yieldVal,
- body);
+ return bodyMatcherForPoolOps<arith::MaxUIOp>(yieldVal, body);
}
static bool bodyMatcherForMinSignedPoolOps(Value yieldVal, Block *body) {
@@ -385,11 +382,8 @@ static bool bodyMatcherForMinSignedPoolOps(Value yieldVal, Block *body) {
body);
}
-// min_unsigned ops should not allow float data type.
-// TODO(#164800): Retire OPDSL logic.
static bool bodyMatcherForMinUnsignedPoolOps(Value yieldVal, Block *body) {
- return bodyMatcherForPoolOps<arith::MinimumFOp, arith::MinUIOp>(yieldVal,
- body);
+ return bodyMatcherForPoolOps<arith::MinUIOp>(yieldVal, body);
}
static bool bodyMatcherForSumPoolOps(Value yieldVal, Block *body) {
@@ -598,109 +592,142 @@ class ConvMatcherBuilder {
//===----------------------------------------------------------------------===//
template <>
-bool isaConvolutionOpOfType<linalg::Conv1DOp>(LinalgOp op,
- SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv1DOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv1DOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (isa<linalg::Conv1DOp>(op)) {
+ // Conv1DOp has no strides/dilations attributes, default to 1.
+ result.dilations = SmallVector<int64_t>(1, 1);
+ result.strides = SmallVector<int64_t>(1, 1);
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/1, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/1, &result.dilations,
+ &result.strides);
AffineExpr W = m.dim(0);
AffineExpr w = m.dim(1);
- return m.matchStride(/*iDim=*/0, /*fDim=*/0, /*oDim=*/0, /*idx=*/0)
- .matchMaps({/*inputMap=*/{m.strided(W, w, 0)},
- /*filterMap=*/{w},
- /*outputMap=*/{W}})
- .matchBody();
+ if (m.matchStride(/*iDim=*/0, /*fDim=*/0, /*oDim=*/0, /*idx=*/0)
+ .matchMaps({/*inputMap=*/{m.strided(W, w, 0)},
+ /*filterMap=*/{w},
+ /*outputMap=*/{W}})
+ .matchBody())
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv1DNwcWcfOp>(
- LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv1DNwcWcfOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv1DNwcWcfOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (auto convOp = dyn_cast<linalg::Conv1DNwcWcfOp>(op.getOperation())) {
+ result.dilations =
+ llvm::to_vector(convOp.getDilations().getValues<int64_t>());
+ result.strides = llvm::to_vector(convOp.getStrides().getValues<int64_t>());
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/1, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/1, &result.dilations,
+ &result.strides);
AffineExpr N = m.dim(0);
AffineExpr W = m.dim(1);
AffineExpr F = m.dim(2);
AffineExpr w = m.dim(3);
AffineExpr c = m.dim(4);
- return m.matchStride(/*iDim=*/1, /*fDim=*/0, /*oDim=*/1, /*idx=*/0)
- .matchMaps({/*inputMap=*/{N, m.strided(W, w, 0), c},
- /*filterMap=*/{w, c, F},
- /*outputMap=*/{N, W, F}})
- .matchBody();
+ if (m.matchStride(/*iDim=*/1, /*fDim=*/0, /*oDim=*/1, /*idx=*/0)
+ .matchMaps({/*inputMap=*/{N, m.strided(W, w, 0), c},
+ /*filterMap=*/{w, c, F},
+ /*outputMap=*/{N, W, F}})
+ .matchBody())
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv1DNcwFcwOp>(
- LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv1DNcwFcwOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv1DNcwFcwOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (auto convOp = dyn_cast<linalg::Conv1DNcwFcwOp>(op.getOperation())) {
+ result.dilations =
+ llvm::to_vector(convOp.getDilations().getValues<int64_t>());
+ result.strides = llvm::to_vector(convOp.getStrides().getValues<int64_t>());
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/1, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/1, &result.dilations,
+ &result.strides);
AffineExpr N = m.dim(0);
AffineExpr F = m.dim(1);
AffineExpr W = m.dim(2);
AffineExpr c = m.dim(3);
AffineExpr w = m.dim(4);
- return m.matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/0)
- .matchMaps({/*inputMap=*/{N, c, m.strided(W, w, 0)},
- /*filterMap=*/{F, c, w},
- /*outputMap=*/{N, F, W}})
- .matchBody();
+ if (m.matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/0)
+ .matchMaps({/*inputMap=*/{N, c, m.strided(W, w, 0)},
+ /*filterMap=*/{F, c, w},
+ /*outputMap=*/{N, F, W}})
+ .matchBody())
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv2DOp>(LinalgOp op,
- SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv2DOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv2DOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (isa<linalg::Conv2DOp>(op)) {
+ // Conv2DOp has no strides/dilations attributes, default to 1.
+ result.dilations = SmallVector<int64_t>(2, 1);
+ result.strides = SmallVector<int64_t>(2, 1);
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/2, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/2, &result.dilations,
+ &result.strides);
AffineExpr H = m.dim(0);
AffineExpr W = m.dim(1);
AffineExpr h = m.dim(2);
AffineExpr w = m.dim(3);
- return m.matchStride(/*iDim=*/0, /*fDim=*/0, /*oDim=*/0, /*idx=*/0)
- .matchStride(/*iDim=*/1, /*fDim=*/1, /*oDim=*/1, /*idx=*/1)
- .matchMaps({/*inputMap=*/{m.strided(H, h, 0), m.strided(W, w, 1)},
- /*filterMap=*/{h, w},
- /*outputMap=*/{H, W}})
- .matchBody();
+ if (m.matchStride(/*iDim=*/0, /*fDim=*/0, /*oDim=*/0, /*idx=*/0)
+ .matchStride(/*iDim=*/1, /*fDim=*/1, /*oDim=*/1, /*idx=*/1)
+ .matchMaps({/*inputMap=*/{m.strided(H, h, 0), m.strided(W, w, 1)},
+ /*filterMap=*/{h, w},
+ /*outputMap=*/{H, W}})
+ .matchBody())
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv2DNhwcHwcfOp>(
- LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv2DNhwcHwcfOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv2DNhwcHwcfOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (auto convOp = dyn_cast<linalg::Conv2DNhwcHwcfOp>(op.getOperation())) {
+ result.dilations =
+ llvm::to_vector(convOp.getDilations().getValues<int64_t>());
+ result.strides = llvm::to_vector(convOp.getStrides().getValues<int64_t>());
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/2, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/2, &result.dilations,
+ &result.strides);
AffineExpr N = m.dim(0);
AffineExpr H = m.dim(1);
AffineExpr W = m.dim(2);
@@ -709,25 +736,33 @@ bool isaConvolutionOpOfType<linalg::Conv2DNhwcHwcfOp>(
AffineExpr w = m.dim(5);
AffineExpr c = m.dim(6);
- return m.matchStride(/*iDim=*/1, /*fDim=*/0, /*oDim=*/1, /*idx=*/0)
- .matchStride(/*iDim=*/2, /*fDim=*/1, /*oDim=*/2, /*idx=*/1)
- .matchMaps({/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
- /*filterMap=*/{h, w, c, F},
- /*outputMap=*/{N, H, W, F}})
- .matchBody();
+ if (m.matchStride(/*iDim=*/1, /*fDim=*/0, /*oDim=*/1, /*idx=*/0)
+ .matchStride(/*iDim=*/2, /*fDim=*/1, /*oDim=*/2, /*idx=*/1)
+ .matchMaps(
+ {/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
+ /*filterMap=*/{h, w, c, F},
+ /*outputMap=*/{N, H, W, F}})
+ .matchBody())
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv2DNhwcHwcfQOp>(
- LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv2DNhwcHwcfQOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv2DNhwcHwcfQOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (auto convOp = dyn_cast<linalg::Conv2DNhwcHwcfQOp>(op.getOperation())) {
+ result.dilations =
+ llvm::to_vector(convOp.getDilations().getValues<int64_t>());
+ result.strides = llvm::to_vector(convOp.getStrides().getValues<int64_t>());
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/2, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/2, &result.dilations,
+ &result.strides);
AffineExpr N = m.dim(0);
AffineExpr H = m.dim(1);
AffineExpr W = m.dim(2);
@@ -736,27 +771,35 @@ bool isaConvolutionOpOfType<linalg::Conv2DNhwcHwcfQOp>(
AffineExpr w = m.dim(5);
AffineExpr c = m.dim(6);
- return m.matchStride(/*iDim=*/1, /*fDim=*/0, /*oDim=*/1, /*idx=*/0)
- .matchStride(/*iDim=*/2, /*fDim=*/1, /*oDim=*/2, /*idx=*/1)
- .matchMaps({/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
- /*filterMap=*/{h, w, c, F},
- /*scalarMap=*/{},
- /*scalarMap=*/{},
- /*outputMap=*/{N, H, W, F}})
- .matchBody(/*containsZeroPointOffset=*/true);
+ if (m.matchStride(/*iDim=*/1, /*fDim=*/0, /*oDim=*/1, /*idx=*/0)
+ .matchStride(/*iDim=*/2, /*fDim=*/1, /*oDim=*/2, /*idx=*/1)
+ .matchMaps(
+ {/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
+ /*filterMap=*/{h, w, c, F},
+ /*scalarMap=*/{},
+ /*scalarMap=*/{},
+ /*outputMap=*/{N, H, W, F}})
+ .matchBody(/*containsZeroPointOffset=*/true))
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv2DNhwcFhwcOp>(
- LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv2DNhwcFhwcOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv2DNhwcFhwcOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (auto convOp = dyn_cast<linalg::Conv2DNhwcFhwcOp>(op.getOperation())) {
+ result.dilations =
+ llvm::to_vector(convOp.getDilations().getValues<int64_t>());
+ result.strides = llvm::to_vector(convOp.getStrides().getValues<int64_t>());
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/2, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/2, &result.dilations,
+ &result.strides);
AffineExpr N = m.dim(0);
AffineExpr H = m.dim(1);
AffineExpr W = m.dim(2);
@@ -765,25 +808,33 @@ bool isaConvolutionOpOfType<linalg::Conv2DNhwcFhwcOp>(
AffineExpr w = m.dim(5);
AffineExpr c = m.dim(6);
- return m.matchStride(/*iDim=*/1, /*fDim=*/1, /*oDim=*/1, /*idx=*/0)
- .matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/1)
- .matchMaps({/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
- /*filterMap=*/{F, h, w, c},
- /*outputMap=*/{N, H, W, F}})
- .matchBody();
+ if (m.matchStride(/*iDim=*/1, /*fDim=*/1, /*oDim=*/1, /*idx=*/0)
+ .matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/1)
+ .matchMaps(
+ {/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
+ /*filterMap=*/{F, h, w, c},
+ /*outputMap=*/{N, H, W, F}})
+ .matchBody())
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv2DNhwcFhwcQOp>(
- LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv2DNhwcFhwcQOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv2DNhwcFhwcQOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (auto convOp = dyn_cast<linalg::Conv2DNhwcFhwcQOp>(op.getOperation())) {
+ result.dilations =
+ llvm::to_vector(convOp.getDilations().getValues<int64_t>());
+ result.strides = llvm::to_vector(convOp.getStrides().getValues<int64_t>());
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/2, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/2, &result.dilations,
+ &result.strides);
AffineExpr N = m.dim(0);
AffineExpr H = m.dim(1);
AffineExpr W = m.dim(2);
@@ -792,27 +843,35 @@ bool isaConvolutionOpOfType<linalg::Conv2DNhwcFhwcQOp>(
AffineExpr w = m.dim(5);
AffineExpr c = m.dim(6);
- return m.matchStride(/*iDim=*/1, /*fDim=*/1, /*oDim=*/1, /*idx=*/0)
- .matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/1)
- .matchMaps({/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
- /*filterMap=*/{F, h, w, c},
- /*scalarMap=*/{},
- /*scalarMap=*/{},
- /*outputMap=*/{N, H, W, F}})
- .matchBody(/*containsZeroPointOffset=*/true);
+ if (m.matchStride(/*iDim=*/1, /*fDim=*/1, /*oDim=*/1, /*idx=*/0)
+ .matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/1)
+ .matchMaps(
+ {/*inputMap=*/{N, m.strided(H, h, 0), m.strided(W, w, 1), c},
+ /*filterMap=*/{F, h, w, c},
+ /*scalarMap=*/{},
+ /*scalarMap=*/{},
+ /*outputMap=*/{N, H, W, F}})
+ .matchBody(/*containsZeroPointOffset=*/true))
+ return result;
+ return std::nullopt;
}
template <>
-bool isaConvolutionOpOfType<linalg::Conv2DNchwFchwOp>(
- LinalgOp op, SmallVector<int64_t> *dilations,
- SmallVector<int64_t> *strides) {
- if (isa<linalg::Conv2DNchwFchwOp>(op))
- return true;
+std::optional<DilationsAndStrides>
+matchConvolutionOpOfType<linalg::Conv2DNchwFchwOp>(LinalgOp op) {
+ DilationsAndStrides result;
+ if (auto convOp = dyn_cast<linalg::Conv2DNchwFchwOp>(op.getOperation())) {
+ result.dilations =
+ llvm::to_vector(convOp.getDilations().getValues<int64_t>());
+ result.strides = llvm::to_vector(convOp.getStrides().getValues<int64_t>());
+ return result;
+ }
assert(isaConvolutionOpInterface(op) &&
"expected op to implement ConvolutionOpInterface");
- ConvMatcherBuilder m(op, /*spatialRank=*/2, dilations, strides);
+ ConvMatcherBuilder m(op, /*spatialRank=*/2, &result.dilations,
+ &result.strides);
AffineExpr N = m.dim(0);
AffineExpr F = m.dim(1);
AffineExpr H = m.dim(2);
@@ -821,25 +880,33 @@ bool isaConvolutionOpOfType<linalg::Conv2DNchwFchwOp>(
AffineExpr h = m.dim(5);
AffineExpr w = m.dim(6);
- return m.matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/0)
- .matchStride(/*iDim=*/3, /*fDim=*/3, /*oDim=*/3, /*idx=*/1)
- .matchMaps({/*inputMap=*/{N, c, m.strided(H, h, 0), m.strided(W, w, 1)},
- /*filterMap=*/{F, c, h, w},
- /*outputMap=*/{N, F, H, W}})
- .matchBody();
+ if (m.matchStride(/*iDim=*/2, /*fDim=*/2, /*oDim=*/2, /*idx=*/0)
+ .matchStride(/*iDim=*/3, /*fDim=*/3, /*oDim=*/3, /*idx=*/1)
+ .matchMaps(
+ {/*inputMap=*/{N, c, m.strided(H, h, 0), m.strided(W, w, 1)},
+ ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/174722
More information about the Mlir-commits
mailing list