[mlir][Linalg] Add ConvolutionOpInterface.

[mravishankar]

Summary

Add an interface for convolution ops. Currently does some basic
verification and returns a charecterization of the loop dimensions.

[mravishankar]

Some of the tests fail due to issue with verifier. I dont plan to submit before that is addressed in some way, but otherwise this is ready for review

[mehdi_amini]

Can you expand in the description on the motivation for all of this?

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

92

(Please fix before pushing this)

[mravishankar]

In D109793#3000705, @mehdi_amini wrote:

Can you expand in the description on the motivation for all of this?

I am waiting for other people to comment before I finish this up (making sure this is along the right lines). There are a whole bunch of convolution named ops defined. Having an interface will allow reasoning about the op during transformation without having to switch between all the different ops. Also if done right, any new ops that implement the interface would also be handled seemlessly. So far this is just doing verification of the op, and characterization of the loops in terms of convolutions.

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

92

Thanks. I forgot about this one.

[mravishankar]

Fix issue with verification order and address missing documentation.

[mravishankar]

This is now ready for review.

[nicolasvasilache]

Generally this looks good to me.

I'd drop the parts of the interface named after convnet terminology inthis CL and only focus on the verifier, which looks very nice to me.
The reason is that the interface should be geared towards enabling/simplifying transformations, in particular vectorization (like vector.contraction does) and I suspect those names will not pay for themselves.

We also need negative tests for the validation errors.

Accepting conditioned on the 2 points above.

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.h

30

I am unclear why these are needed immediately.
Can we split in a followup CL that also uses and tests them ?
This will also make this CL simpler to review.

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

116

One of the advantages of having an interface is to be able to increase the flexibility of the op definitions and be able to detect them from a linalg.generic (in particular to rewrite a generic as a named op for which we have a library call or a fast instruction, in the future).

How about adding a TODO that we want to detect the image operand in the future?

131

We don't need to assume there is only one?
We can return whatever the inference tells us from analysing the affine maps?

[antiagainst]

Thanks Mahesh! Overall LGTM, just a few nits/typos.

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.h

58

Depthwise dimension reads a bit strange to me. We talk about depthwise convolution op as a whole. But for the dimension, you mean Depth Multiplier dimension?

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

95

s/satisy/satisfy/

98

Nit: Could use code blocks to wrap these grammar definitions.

103

s/change/channel/

mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp

291

Would be nice to put the comment here in bullet points for better readability.

mlir/python/mlir/dialects/linalg/opdsl/lang/comprehension.py

487

This is duplicated?

[mehdi_amini]

In D109793#3004409, @mravishankar wrote:

In D109793#3000705, @mehdi_amini wrote:

Can you expand in the description on the motivation for all of this?

I am waiting for other people to comment before I finish this up (making sure this is along the right lines).

Still not done?

Also I think this is fairly important to have when sending for review initially!

[mravishankar]

In D109793#3006713, @mehdi_amini wrote:

In D109793#3004409, @mravishankar wrote:

In D109793#3000705, @mehdi_amini wrote:

Can you expand in the description on the motivation for all of this?

I am waiting for other people to comment before I finish this up (making sure this is along the right lines).

Still not done?

Also I think this is fairly important to have when sending for review initially!

Its done now. Wanted comments on it before I go finish it up since wasnt sure that it met what everyone was looking for. Anyway, added it now

[mravishankar]

• Add negative tests
• Split methods that return loop characterization into separate patch
• Add better description

[mravishankar]

Make tests less complex.

[mravishankar]

In D109793#3005982, @nicolasvasilache wrote:

Generally this looks good to me.

I'd drop the parts of the interface named after convnet terminology inthis CL and only focus on the verifier, which looks very nice to me.

Done.

The reason is that the interface should be geared towards enabling/simplifying transformations, in particular vectorization (like vector.contraction does) and I suspect those names will not pay for themselves.

We also need negative tests for the validation errors.

Where/how do I add these? I was looking for what is done for ContractionOpInterface and I didnt find any negative tests.

Accepting conditioned on the 2 points above.

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.h

58

Thanks I didnt know what it was called in general.

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

116

Ill make this the default implementation. Ops can override if they want to.

131

True, but all batches could be grouped into one "batch". I think we can expand that if we really need to, but I cant think of a case for it. Just starting with the minimum flexibility needed to support current ops. We can generalize later on.

mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp

291

It was. It got collapsed with Esc-q on emacs. Sorry.

mlir/python/mlir/dialects/linalg/opdsl/lang/comprehension.py

487

From what? The one above is the ContractionOpInterface. Is it duplicated somewhere else?

[nicolasvasilache]

you're right that the error messages in the contraction op interface are not tested .. what you have here looks great to me.
I'd just rename the test file to make invalid stand out.

mlir/test/Dialect/Linalg/conv_interface.mlir

1 ↗

(On Diff #373444)

s/conv_interface.mlir/invalid-conv-interface.mlir ?

[mravishankar]

Rename test file and rebase.

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.h

 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
 namespace mlir {
 namespace linalg {
 class LinalgOp;
 
 /// OpOperand vector that implicitly converts to a Value vector.
 struct OpOperandVector : public SmallVector<OpOperand *> {
   operator SmallVector<Value>();
 };
 
 /// Returns the values obtained by applying `map` to the list of values.
 SmallVector<Value, 4> applyMapToValues(OpBuilder &b, Location loc,
                                        AffineMap map, ValueRange values);
 
 /// Checks whether `linalgOp` conforms to ContractionOpInterface.
 // TODO: embed within `isa<ContractionOpInterface>` if possible / natural.
 bool isaContractionOpInterface(LinalgOp linalgOp);
 
 namespace detail {
 
 /// Verify that `op` conforms to ContractionOpInterface.
 LogicalResult verifyContractionInterface(Operation *op);
 
+/// Verify that `op` conforms to the ConvolutionOpInterface.
+LogicalResult verifyConvolutionInterface(Operation *op);
+
 /// Verify that `op` conforms to the invariants of StructuredOpInterface
 LogicalResult verifyStructuredOpInterface(Operation *op);
 
 } // namespace detail
 } // namespace linalg
 } // namespace mlir
 
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.h.inc"
 
 /// Include the generated interface declarations.
 #include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h.inc"
 
 #endif // MLIR_DIALECT_LINALG_IR_LINALGINTERFACES_H_

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

let methods = [
     /*methodName=*/"isRowMajorBatchMatmul",
     /*args=*/(ins),
     /*methodBody=*/[{
         return mlir::isRowMajorBatchMatmul($_op.indexing_maps());
     }]>,
   ];
 }
 
+def LinalgConvolutionOpInterface : OpInterface<"ConvolutionOpInterface"> {
+  let description = [{
+    A convolution is defined in general terms:
+    1. Has an `image` and a `filter` operand.
+    2. Has one `output` operand.
+    3. The indexing maps of the input have expressions that satisfy
+    ```
+       AffineExpr ::== AffineDimExpr | ConvolvedExpr
+       ConvolvedExpr ::== MulExpr (`+` MulExpr)+
+       MulExpr ::== AffineDimExpr (`*` (AffineConstantExpr | AffineSymbolExpr))?
+    ```
+    4. The filter and the output have projected permutation maps.
+    5. Each of the loops can be qualified as one of,
+       - Loop over batch dimension,
+       - Loop over output image dimensions,
+       - Loop over output channel dimensions,
+       - Loop over convolved filter dimensions,
+       - Loop over input channel dimension.
+  }];
+  let cppNamespace = "::mlir::linalg";
+  let verify = [{ return detail::verifyConvolutionInterface($_op); }];
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/"Return the image operand.",
+      /*retTy=*/"Value",
+      /*methodName=*/"image",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getOperation()->getOperand(0);
+      }]
+    >,
+    InterfaceMethod<
+      /*desc=*/"Return the filter operand.",
+      /*retTy=*/"Value",
+      /*methodName=*/"filter",
+      /*args=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return $_op.getOperation()->getOperand(1);
+      }]
+    >,
+  ];
+}
+
 // The 'LinalgStructuredInterface' provides access to the 'LinalgOp' interface.
 def LinalgStructuredInterface : OpInterface<"LinalgOp"> {
   let cppNamespace = "::mlir::linalg";
   let methods = [
     //===------------------------------------------------------------------===//
     // Loop types handling.
     //===------------------------------------------------------------------===//
     InterfaceMethod<

mlir/include/mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yaml

 metadata: !LinalgOpMetadata
   name: conv_1d
   cpp_class_name: Conv1DOp
   doc: |-
     Performs 1-D convolution with no channels.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1] -> (s0 + s1)>
   - !LinalgOperandDefConfig

 metadata: !LinalgOpMetadata
   name: conv_2d
   cpp_class_name: Conv2DOp
   doc: |-
     Performs 2-D convolution with no channels.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3] -> (s0 + s1, s2 + s3)>
   - !LinalgOperandDefConfig

 metadata: !LinalgOpMetadata
   name: conv_3d
   cpp_class_name: Conv3DOp
   doc: |-
     Performs 3-D convolution with no channels.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5] -> (s0 + s1, s2 + s3, s4 + s5)>
   - !LinalgOperandDefConfig

 metadata: !LinalgOpMetadata
   name: conv_1d_nwc_wcf
   cpp_class_name: Conv1DNwcWcfOp
   doc: |-
     Performs 1-D convolution.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6] -> (s0, s1 * s2 + s3 * s4,
       s5)>
doc: |-
     Performs 2-D convolution.
 
     Layout:
       * Input: NHWC.
       * Kernel: HWCF.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10] -> (s0,
       s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>
doc: |-
 
     Layout:
       * Input: NHWC.
       * Kernel: HWCF.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output. This includes the zero
     point offsets common to quantized operations.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10] -> (s0,
       s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>
doc: |-
     Performs 2-D convolution.
 
     Layout:
       * Input: NCHW.
       * Kernel: FCHW.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10] -> (s0,
       s1, s2 * s3 + s4 * s5, s6 * s7 + s8 * s9)>

 metadata: !LinalgOpMetadata
   name: conv_3d_ndhwc_dhwcf
   cpp_class_name: Conv3DNdhwcDhwcfOp
   doc: |-
     Performs 3-D convolution.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12,
       s13, s14] -> (s0, s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9 * s10 + s11 * s12,
metadata: !LinalgOpMetadata
   name: depthwise_conv2D_nhw
   cpp_class_name: DepthwiseConv2DNhwOp
   doc: |-
     Performs depth-wise 2-D convolution.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output. Multiplier is set to 1
     which is a special case for most dpethwise convolutions.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9] -> (s0, s1 *
       s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>

 metadata: !LinalgOpMetadata
   name: depthwise_conv2D_nhw_q
   cpp_class_name: DepthwiseConv2DNhwQOp
   doc: |-
     Performs depth-wise 2-D convolution.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9] -> (s0, s1 *
       s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>

 metadata: !LinalgOpMetadata
   name: depthwise_conv2D_nhwc
   cpp_class_name: DepthwiseConv2DNhwcOp
   doc: |-
     Performs depth-wise 2-D convolution.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10] -> (s0,
       s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>

 metadata: !LinalgOpMetadata
   name: depthwise_conv2D_nhwc_q
   cpp_class_name: DepthwiseConv2DNhwcQOp
   doc: |-
     Performs depth-wise 2-D convolution.
 
     Numeric casting is performed on the operands to the inner multiply, promoting
     them to the same data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10] -> (s0,
       s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>

 metadata: !LinalgOpMetadata
   name: pooling_nhwc_sum
   cpp_class_name: PoolingNhwcSumOp
   doc: |-
     Performs sum pooling.
 
     Numeric casting is performed on the input operand, promoting it to the same
     data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9] -> (s0, s1 *
       s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>

 metadata: !LinalgOpMetadata
   name: pooling_nhwc_max
   cpp_class_name: PoolingNhwcMaxOp
   doc: |-
     Performs max pooling.
 
     Numeric casting is performed on the input operand, promoting it to the same
     data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9] -> (s0, s1 *
       s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>

 metadata: !LinalgOpMetadata
   name: pooling_nchw_max
   cpp_class_name: PoolingNchwMaxOp
   doc: |-
     Performs max pooling.
 
     Numeric casting is performed on the input operand, promoting it to the same
     data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9] -> (s0, s1, s2
       * s3 + s4 * s5, s6 * s7 + s8 * s9)>

 metadata: !LinalgOpMetadata
   name: pooling_nhwc_min
   cpp_class_name: PoolingNhwcMinOp
   doc: |-
     Performs min pooling.
 
     Numeric casting is performed on the input operand, promoting it to the same
     data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9] -> (s0, s1 *
       s2 + s3 * s4, s5 * s6 + s7 * s8, s9)>

 metadata: !LinalgOpMetadata
   name: pooling_ndhwc_sum
   cpp_class_name: PoolingNdhwcSumOp
   doc: |-
     Performs 3D sum pooling.
 
     Numeric casting is performed on the input operand, promoting it to the same
     data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12,
       s13] -> (s0, s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9 * s10 + s11 * s12, s13)>

 metadata: !LinalgOpMetadata
   name: pooling_ndhwc_max
   cpp_class_name: PoolingNdhwcMaxOp
   doc: |-
     Performs 3D max pooling.
 
     Numeric casting is performed on the input operand, promoting it to the same
     data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12,
       s13] -> (s0, s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9 * s10 + s11 * s12, s13)>

 metadata: !LinalgOpMetadata
   name: pooling_ndhwc_min
   cpp_class_name: PoolingNdhwcMinOp
   doc: |-
     Performs 3D min pooling.
 
     Numeric casting is performed on the input operand, promoting it to the same
     data type as the accumulator/output.
+  implements:
+  - LinalgConvolutionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !LinalgOperandDefConfig
     name: I
     usage: InputOperand
     type_var: T1
     shape_map: affine_map<()[s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12,
       s13] -> (s0, s1 * s2 + s3 * s4, s5 * s6 + s7 * s8, s9 * s10 + s11 * s12, s13)>

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Base Tablegen class for Linalg ops.
 // Linalg ops that correspond to library calls operate on ShapedType as their
 // first operands. These may be optionally followed by non-view operands
 // depending on the specific Linalg op.
 class LinalgStructuredBase_Op<string mnemonic, list<OpTrait> props>
-  : Op<Linalg_Dialect, mnemonic, !listconcat(props, [
-       LinalgStructuredInterface, ReifyRankedShapedTypeOpInterface])> {
+  : Op<Linalg_Dialect, mnemonic, !listconcat([
+       LinalgStructuredInterface, ReifyRankedShapedTypeOpInterface], props)> {
   code structuredOpsBaseDecls = [{
     // Return whether the op accesses the iteration indices.
     bool hasIndexSemantics() {
       Operation *op = this->getOperation();
       if(op->getNumRegions() == 0 || op->getRegion(0).empty())
         return false;
       return !op->getRegion(0).front().getOps<IndexOp>().empty();
     }

mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp

static bool isAddMul(Block &block) {
   bool success = un(res, add);
   // One of the operands of add traces back to argC, the other to the mul.
   success |= (un(c1, argC) && un(c2, mul)) || ((un(c1, mul)) && un(c2, argC));
   // One of the operands of mul traces back to argA, the other to argB.
   success |= (un(a, argA) && un(b, argB)) || ((un(a, argB)) && un(b, argA));
   return success;
 }
 
-enum MatchContractionResult {
+enum class MatchContractionResult {
   Success = 0,
   NotLinalgOp,
   WrongNumOperands,
   NoReduction,
   NotProjectedPermutations,
   NotAddMul
 };
 static MatchContractionResult isContractionInterfaceImpl(Operation *op) {
LogicalResult mlir::linalg::detail::verifyContractionInterface(Operation *op) {
   if (res == MatchContractionResult::NotProjectedPermutations)
     return op->emitError("expected all indexings to be projected permutations");
   if (res == MatchContractionResult::NotAddMul)
     return op->emitError("(add, mul) operations not found");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// ConvolutionOpInterface implementation
+//===----------------------------------------------------------------------===//
+
+/// Of the given two expressions returns one that is of type T (`lhs` gets
+/// preference over `rhs`)
+template <typename T>
+static T getAffineExprOfType(AffineExpr lhs, AffineExpr rhs) {
+  return lhs.isa<T>() ? lhs.cast<T>()
+                      : (rhs.isa<T>() ? rhs.cast<T>() : nullptr);
+}
+
+namespace {
+/// Walk the indexing expressions for input of a convolution operation to verify
+/// its of the right form, either
+/// - AffineDimExpr
+/// - AffineDimExpr (`*` (AffineSymbolExpr | AffineConstantExpr))?
+///      (`+` AffineDimExpr (`*` (AffineSymbolExpr | AffineConstantExpr))?)*
+///
+/// classifies the AffineDimExpr as convolved dimensions or unconvolved
+/// dimensions and verifies each dimension occurs only once.
+struct ConvAccessExprWalker
+    : public AffineExprVisitor<ConvAccessExprWalker, LogicalResult> {
+  llvm::SmallDenseSet<unsigned> convolvedDims;
+  llvm::SmallDenseSet<unsigned> unConvolvedDims;
+
+  LogicalResult visitDimExpr(AffineDimExpr dimExpr) {
+    unsigned position = dimExpr.getPosition();
+    if (unConvolvedDims.count(position) || convolvedDims.count(position)) {
+      return failure();
+    }
+    unConvolvedDims.insert(position);
+    return success();
+  }
+
+  LogicalResult visitSymbolExpr(AffineSymbolExpr expr) { return failure(); }
+
+  LogicalResult visitConstantExpr(AffineConstantExpr expr) { return failure(); }
+
+  LogicalResult visitAffineBinaryOpExpr(AffineBinaryOpExpr binaryExpr) {
+    // In pre-order visit, top level op has to be an add op.
+    if (binaryExpr.getKind() != AffineExprKind::Add)
+      return failure();
+    return success(succeeded(isDimExprOrMulExpr(binaryExpr.getLHS())) &&
+                   succeeded(isDimExprOrMulExpr(binaryExpr.getRHS())));
+  }
+
+  LogicalResult isDimExprOrMulExpr(AffineExpr expr) {
+    if (auto dimExpr = expr.dyn_cast<AffineDimExpr>()) {
+      unsigned dim = dimExpr.getPosition();
+      if (convolvedDims.count(dim) || unConvolvedDims.count(dim))
+        return failure();
+      convolvedDims.insert(dim);
+      return success();
+    }
+    if (auto symbolMulExpr = expr.dyn_cast<AffineBinaryOpExpr>()) {
+      if (symbolMulExpr.getKind() != AffineExprKind::Mul)
+        return failure();
+      auto lhsExpr = symbolMulExpr.getLHS();
+      auto rhsExpr = symbolMulExpr.getRHS();
+      // Check for symbol expression.
+      AffineExpr mulExpr =
+          getAffineExprOfType<AffineSymbolExpr>(lhsExpr, rhsExpr);
+      // If there was no symbol expr, check for constant expression.
+      if (!mulExpr) {
+        mulExpr = getAffineExprOfType<AffineConstantExpr>(lhsExpr, rhsExpr);
+      }
+      auto dimExpr = getAffineExprOfType<AffineDimExpr>(lhsExpr, rhsExpr);
+      if (!mulExpr || !dimExpr)
+        return failure();
+      unsigned dim = dimExpr.getPosition();
+      if (convolvedDims.count(dim) || unConvolvedDims.count(dim))
+        return failure();
+      convolvedDims.insert(dim);
+      return success();
+    }
+    return failure();
+  }
+};
+} // namespace
+
+static llvm::SmallDenseSet<unsigned> getPreservedDims(AffineMap map) {
+  assert(map.isProjectedPermutation() &&
+         "expected map to have projected permutations");
+  llvm::SmallDenseSet<unsigned> preservedDims;
+  for (auto expr : map.getResults())
+    preservedDims.insert(expr.cast<AffineDimExpr>().getPosition());
+  return preservedDims;
+}
+
+enum class MatchConvolutionResult {
+  Success = 0,
+  NotLinalgOp,
+  WrongNumOperands,
+  WrongInputIndexingMap,
+  NotProjectedPermutations,
+  NonConvolutionLoop,
+  OutputDimsNotParallel,
+  NonOutputDimNotReduction
+};
+
+static MatchConvolutionResult isConvolutionInterfaceImpl(Operation *op) {
+  auto linalgOp = dyn_cast<linalg::LinalgOp>(op);
+  if (!linalgOp)
+    return MatchConvolutionResult::NotLinalgOp;
+  if (linalgOp.getNumInputs() < 2 || linalgOp.getNumOutputs() != 1)
+    return MatchConvolutionResult::WrongNumOperands;
+
+  auto indexingMaps = linalgOp.getIndexingMaps();
+
+  // Check the input indexing map has the right form.
+  ConvAccessExprWalker inputExprWalker;
+  if (llvm::any_of(indexingMaps[0].getResults(),
+                   [&inputExprWalker](AffineExpr expr) {
+                     return failed(inputExprWalker.visit(expr));
+                   })) {
+    return MatchConvolutionResult::WrongInputIndexingMap;
+  }
+
+  // Filter and output maps must be projected permutation.
+  if (!indexingMaps[1].isProjectedPermutation() ||
+      !indexingMaps.back().isProjectedPermutation())
+    return MatchConvolutionResult::NotProjectedPermutations;
+
+  auto iteratorTypesRange =
+      linalgOp.iterator_types().getAsValueRange<StringAttr>();
+
+  llvm::SmallDenseSet<unsigned> outputDims =
+      getPreservedDims(indexingMaps.back());
+  llvm::SmallDenseSet<unsigned> filterDims = getPreservedDims(indexingMaps[1]);
+  // Make sure all loops are charecterized as one of:
+  // - Batch loop : present in output, as non-convolved in input, not present in
+  //   filter.
+  // - Output image dimension : present in output, convolved dims in input, not
+  //   present in filter.
+  // - Output channel dimension : present in output, not present in input,
+  //   present in filter.
+  // - Filter loop dimension : present in filter, convolved in input, not
+  //   present in output.
+  // - Input channel dimension : unconvolved in input, not present in output,
+  //   present in filter.
+  // - Depth multiplier : unconvolved in input, present in output, present in
+  //   filter.
+  llvm::SmallDenseSet<unsigned> allLoopDims;
+  for (auto outputExpr : indexingMaps.back().getResults()) {
+    unsigned outputDim = outputExpr.cast<AffineDimExpr>().getPosition();
+    if (inputExprWalker.unConvolvedDims.count(outputDim) &&
+        !filterDims.count(outputDim)) {
+      // Batch dimension.
+      if (*std::next(iteratorTypesRange.begin(), outputDim) !=
+          getParallelIteratorTypeName())
+        return MatchConvolutionResult::OutputDimsNotParallel;
+      allLoopDims.insert(outputDim);
+      continue;
+    }
+    if (inputExprWalker.convolvedDims.count(outputDim) &&
+        !filterDims.count(outputDim)) {
+      // Output image Loop dimension.
+      if (*std::next(iteratorTypesRange.begin(), outputDim) !=
+          getParallelIteratorTypeName())
+        return MatchConvolutionResult::OutputDimsNotParallel;
+      allLoopDims.insert(outputDim);
+      continue;
+    }
+    if (!inputExprWalker.convolvedDims.count(outputDim) &&
+        !inputExprWalker.unConvolvedDims.count(outputDim) &&
+        filterDims.count(outputDim)) {
+      // Output channel dimension.
+      if (*std::next(iteratorTypesRange.begin(), outputDim) !=
+          getParallelIteratorTypeName())
+        return MatchConvolutionResult::OutputDimsNotParallel;
+      allLoopDims.insert(outputDim);
+      continue;
+    }
+    if (inputExprWalker.unConvolvedDims.count(outputDim) &&
+        filterDims.count(outputDim)) {
+      // Depth multiplier.
+      if (*std::next(iteratorTypesRange.begin(), outputDim) !=
+          getParallelIteratorTypeName())
+        return MatchConvolutionResult::OutputDimsNotParallel;
+      allLoopDims.insert(outputDim);
+      continue;
+    }
+    return MatchConvolutionResult::NonConvolutionLoop;
+  }
+  for (auto filterExpr : indexingMaps[1].getResults()) {
+    unsigned filterDim = filterExpr.cast<AffineDimExpr>().getPosition();
+    if (outputDims.count(filterDim) &&
+        !inputExprWalker.unConvolvedDims.count(filterDim) &&
+        !inputExprWalker.convolvedDims.count(filterDim)) {
+      // Output channel dimension. THis is already seen, continue;
+      continue;
+    }
+    if (inputExprWalker.convolvedDims.count(filterDim) &&
+        !outputDims.count(filterDim)) {
+      // Filter loop dimension.
+      if (*std::next(iteratorTypesRange.begin(), filterDim) !=
+          getReductionIteratorTypeName())
+        return MatchConvolutionResult::NonOutputDimNotReduction;
+      if (allLoopDims.count(filterDim))
+        return MatchConvolutionResult::NonConvolutionLoop;
+      allLoopDims.insert(filterDim);
+      continue;
+    }
+    if (inputExprWalker.unConvolvedDims.count(filterDim) &&
+        !outputDims.count(filterDim)) {
+      // Input channel dimension.
+      if (*std::next(iteratorTypesRange.begin(), filterDim) !=
+          getReductionIteratorTypeName())
+        return MatchConvolutionResult::NonOutputDimNotReduction;
+      if (allLoopDims.count(filterDim))
+        return MatchConvolutionResult::NonConvolutionLoop;
+      allLoopDims.insert(filterDim);
+      continue;
+    }
+    if (inputExprWalker.unConvolvedDims.count(filterDim) &&
+        outputDims.count(filterDim)) {
+      // Depthwise loop. Already seen.
+      continue;
+    }
+    return MatchConvolutionResult::NonConvolutionLoop;
+  }
+  // All loops must be covered now.
+  if (allLoopDims.size() != linalgOp.getNumLoops())
+    return MatchConvolutionResult::NonConvolutionLoop;
+
+  return MatchConvolutionResult::Success;
+}
+
+LogicalResult mlir::linalg::detail::verifyConvolutionInterface(Operation *op) {
+  auto res = isConvolutionInterfaceImpl(op);
+  if (res == MatchConvolutionResult::NotLinalgOp)
+    return op->emitError("expected a LinalgOp");
+  if (res == MatchConvolutionResult::WrongNumOperands)
+    return op->emitError("expected op with 2 inputs and 1 output");
+  if (res == MatchConvolutionResult::WrongInputIndexingMap)
+    return op->emitError("unexpected input index map for convolutions");
+  if (res == MatchConvolutionResult::NotProjectedPermutations) {
+    return op->emitError(
+        "expected output/filter indexing maps to be projected permutations");
+  }
+  if (res == MatchConvolutionResult::NonConvolutionLoop) {
+    return op->emitError("unexpected loop dimension for convolution op");
+  }
+  if (res == MatchConvolutionResult::OutputDimsNotParallel) {
+    return op->emitError(
+        "expected all iterators used to access outputs to be parallel");
+  }
+  if (res == MatchConvolutionResult::NonOutputDimNotReduction) {
+    return op->emitError(
+        "expected all iterators not used to access outputs to be reduction");
+  }
+  return success();
+}
+//===----------------------------------------------------------------------===//
 // StructuredOpInterface implementation
 //===----------------------------------------------------------------------===//
 
 OpOperandVector::operator SmallVector<Value>() {
   SmallVector<Value> result;
   result.reserve(this->size());
   llvm::transform(*this, std::back_inserter(result),
                   [](OpOperand *opOperand) { return opOperand->get(); });

mlir/python/mlir/dialects/linalg/opdsl/lang/comprehension.py

 class OpInterfaceDef:
   """An interface that an op implements."""
 
   def __init__(self, cpp_name: str):
     self.cpp_name = cpp_name
 
 
 ContractionOpInterface = OpInterfaceDef("LinalgContractionOpInterface")
-
+ConvolutionOpInterface = OpInterfaceDef("LinalgConvolutionOpInterface")
 
 class OpMetadataDef(YAMLObject):
   """Metadata about the op (generally not behavior impacting)."""
   yaml_tag = "!LinalgOpMetadata"
 
   def __init__(self, name: str, cpp_class_name: Optional[str],
                doc: Optional[str]):
     self.name = name

mlir/python/mlir/dialects/linalg/opdsl/ops/core_named_ops.py

def conv_1d(
     I=TensorDef(T1, S.OW + S.KW),
     K=TensorDef(T2, S.KW),
     O=TensorDef(U, S.OW, output=True)):
   """Performs 1-D convolution with no channels.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.ow, D.kw)
   O[D.ow] += cast(
       U, I[D.ow + D.kw]) * cast(U, K[D.kw])
 
 @linalg_structured_op
 def conv_2d(
     I=TensorDef(T1, S.OH + S.KH, S.OW + S.KW),
     K=TensorDef(T2, S.KH, S.KW),
     O=TensorDef(U, S.OH, S.OW, output=True)):
   """Performs 2-D convolution with no channels.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.oh, D.ow, D.kh, D.kw)
   O[D.oh, D.ow] += cast(
       U, I[D.oh + D.kh, D.ow + D.kw]) * cast(U, K[D.kh, D.kw])
 
 @linalg_structured_op
 def conv_3d(
     I=TensorDef(T1, S.OD + S.KD, S.OH + S.KH, S.OW + S.KW),
     K=TensorDef(T2, S.KD, S.KH, S.KW),
     O=TensorDef(U, S.OD, S.OH, S.OW, output=True)):
   """Performs 3-D convolution with no channels.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.od, D.oh, D.ow, D.kd, D.kh, D.kw)
   O[D.od, D.oh, D.ow] += cast(
       U, I[D.od + D.kd, D.oh + D.kh, D.ow + D.kw]) * cast(U, K[D.kd, D.kh, D.kw])
 
 @linalg_structured_op
 def conv_1d_nwc_wcf(
     I=TensorDef(T1, S.N, S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KW, S.C, S.F),
     O=TensorDef(U, S.N, S.OW, S.F, output=True),
     strides=AttributeDef(S.SW),
     dilations=AttributeDef(S.DW)):
   """Performs 1-D convolution.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.ow, D.f, D.kw, D.c)
   O[D.n, D.ow, D.f] += cast(
       U, I[D.n, D.ow * S.SW + D.kw * S.DW, D.c
            ]) * cast(U, K[D.kw, D.c, D.f])
 
 @linalg_structured_op
 def conv_2d_nhwc_hwcf(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KH, S.KW, S.C, S.F),
     O=TensorDef(U, S.N, S.OH, S.OW, S.F, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs 2-D convolution.
 
   Layout:
     * Input: NHWC.
     * Kernel: HWCF.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.f, D.kh, D.kw, D.c)
   O[D.n, D.oh, D.ow, D.f] += cast(
       U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW, D.c
            ]) * cast(U, K[D.kh, D.kw, D.c, D.f])
 
 @linalg_structured_op
 def conv_2d_nhwc_hwcf_q(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KH, S.KW, S.C, S.F),
     IZp=ScalarDef(I32),
     KZp=ScalarDef(I32),
     O=TensorDef(U, S.N, S.OH, S.OW, S.F, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs 2-D convolution with zero point offsets.
 
   Layout:
     * Input: NHWC.
     * Kernel: HWCF.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output. This includes the zero
   point offsets common to quantized operations.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.f, D.kh, D.kw, D.c)
   O[D.n, D.oh, D.ow, D.f] += (cast(
       U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW, D.c
            ]) - cast(U, IZp)) * (cast(U, K[D.kh, D.kw, D.c, D.f]) - cast(U, KZp))
 
 @linalg_structured_op
 def conv_2d_nchw_fchw(
     I=TensorDef(T1, S.N, S.C, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW),
     K=TensorDef(T2, S.F, S.C, S.KH, S.KW),
     O=TensorDef(U, S.N, S.F, S.OH, S.OW, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs 2-D convolution.
 
   Layout:
     * Input: NCHW.
     * Kernel: FCHW.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.f, D.oh, D.ow, D.c, D.kh, D.kw)
   O[D.n, D.f, D.oh, D.ow] += cast(
       U, I[D.n, D.c, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW
            ]) * cast(U, K[D.f, D.c, D.kh, D.kw])
 
 @linalg_structured_op
 def conv_3d_ndhwc_dhwcf(
     I=TensorDef(T1, S.N, S.OD * S.SD + S.KD * S.DD,
                 S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KD, S.KH, S.KW, S.C, S.F),
     O=TensorDef(U, S.N, S.OD, S.OH, S.OW, S.F, output=True),
     strides=AttributeDef(S.SD, S.SH, S.SW),
     dilations=AttributeDef(S.DD, S.DH, S.DW)):
   """Performs 3-D convolution.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.od, D.oh, D.ow, D.f, D.kd, D.kh, D.kw, D.c)
   O[D.n, D.od, D.oh, D.ow, D.f] += cast(
       U, I[D.n, D.od * S.SD + D.kd * S.DD, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW, D.c
            ]) * cast(U, K[D.kd, D.kh, D.kw, D.c, D.f])
 
 @linalg_structured_op
 def depthwise_conv2D_nhw(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.IC),
     K=TensorDef(T2, S.KH, S.KW, S.IC),
     O=TensorDef(U, S.N, S.OH, S.OW, S.IC, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs depth-wise 2-D convolution.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output. Multiplier is set to 1
   which is a special case for most dpethwise convolutions.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.ic, D.kh, D.kw)
   O[D.n, D.oh, D.ow, D.ic] += cast(
       U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW,
            D.ic]) * cast(U, K[D.kh, D.kw, D.ic])
 
 @linalg_structured_op
 def depthwise_conv2D_nhw_q(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.IC),
     K=TensorDef(T2, S.KH, S.KW, S.IC),
     IZp=ScalarDef(I32),
     KZp=ScalarDef(I32),
     O=TensorDef(U, S.N, S.OH, S.OW, S.IC, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs depth-wise 2-D convolution.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.ic, D.kh, D.kw)
   O[D.n, D.oh, D.ow, D.ic] += (
       (cast(U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW,
                  D.ic]) - cast(U, IZp)) *
       (cast(U, K[D.kh, D.kw, D.ic]) - cast(U, KZp)))
 
 @linalg_structured_op
 def depthwise_conv2D_nhwc(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.IC),
     K=TensorDef(T2, S.KH, S.KW, S.IC, S.CM),
     O=TensorDef(U, S.N, S.OH, S.OW, S.IC, S.CM, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs depth-wise 2-D convolution.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.ic, D.cm, D.kh, D.kw)
   O[D.n, D.oh, D.ow, D.ic, D.cm] += cast(
       U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW,
            D.ic]) * cast(U, K[D.kh, D.kw, D.ic, D.cm])
 
 @linalg_structured_op
 def depthwise_conv2D_nhwc_q(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.IC),
     K=TensorDef(T2, S.KH, S.KW, S.IC, S.CM),
     IZp=ScalarDef(I32),
     KZp=ScalarDef(I32),
     O=TensorDef(U, S.N, S.OH, S.OW, S.IC, S.CM, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs depth-wise 2-D convolution.
 
   Numeric casting is performed on the operands to the inner multiply, promoting
   them to the same data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.ic, D.cm, D.kh, D.kw)
   O[D.n, D.oh, D.ow, D.ic, D.cm] += (
       (cast(U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW,
                  D.ic]) - cast(U, IZp)) *
       (cast(U, K[D.kh, D.kw, D.ic, D.cm]) - cast(U, KZp)))
 
 
 @linalg_structured_op
 def pooling_nhwc_sum(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KH, S.KW, index_dims=[D.kh, D.kw]),
     O=TensorDef(U, S.N, S.OH, S.OW, S.C, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs sum pooling.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.kh, D.kw, D.c)
   O[D.n, D.oh, D.ow, D.c] += cast(
       U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW, D.c])
 
 
 @linalg_structured_op
 def pooling_nhwc_max(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KH, S.KW, index_dims=[D.kh, D.kw]),
     O=TensorDef(U, S.N, S.OH, S.OW, S.C, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs max pooling.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.kh, D.kw, D.c)
   O[D.n, D.oh, D.ow, D.c] = ReduceFn.max(D.kh, D.kw)(
       cast(U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW,
                 D.c]))
 
 @linalg_structured_op
 def pooling_nchw_max(
     I=TensorDef(T1, S.N, S.C, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW),
     K=TensorDef(T2, S.KH, S.KW, index_dims=[D.kh, D.kw]),
     O=TensorDef(U, S.N, S.C, S.OH, S.OW, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs max pooling.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.c, D.oh, D.ow, D.kh, D.kw)
   O[D.n, D.c, D.oh, D.ow] = ReduceFn.max(D.kh, D.kw)(
       cast(U, I[D.n, D.c, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW,
                 ]))
 
 @linalg_structured_op
 def pooling_nhwc_min(
     I=TensorDef(T1, S.N, S.OH * S.SH + S.KH * S.DH, S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KH, S.KW, index_dims=[D.kh, D.kw]),
     O=TensorDef(U, S.N, S.OH, S.OW, S.C, output=True),
     strides=AttributeDef(S.SH, S.SW),
     dilations=AttributeDef(S.DH, S.DW)):
   """Performs min pooling.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.oh, D.ow, D.kh, D.kw, D.c)
   O[D.n, D.oh, D.ow, D.c] = ReduceFn.min(D.kh, D.kw)(
       cast(U, I[D.n, D.oh * S.SH + D.kh * S.DH, D.ow * S.SW + D.kw * S.DW,
                 D.c]))
 
 
 @linalg_structured_op
 def pooling_ndhwc_sum(
     I=TensorDef(T1, S.N, S.OD * S.SD + S.KD * S.DD, S.OH * S.SH + S.KH * S.DH,
                 S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KD, S.KH, S.KW, index_dims=[D.kd, D.kh, D.kw]),
     O=TensorDef(U, S.N, S.OD, S.OH, S.OW, S.C, output=True),
     strides=AttributeDef(S.SD, S.SH, S.SW),
     dilations=AttributeDef(S.DD, S.DH, S.DW)):
   """Performs 3D sum pooling.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.od, D.oh, D.ow, D.kd, D.kh, D.kw, D.c)
   O[D.n, D.od, D.oh, D.ow, D.c] += cast(
       U, I[D.n, D.od * S.SD + D.kd * S.DD, D.oh * S.SH + D.kh * S.DH,
            D.ow * S.SW + D.kw * S.DW, D.c])
 
 
 @linalg_structured_op
 def pooling_ndhwc_max(
     I=TensorDef(T1, S.N, S.OD * S.SD + S.KD * S.DD, S.OH * S.SH + S.KH * S.DH,
                 S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KD, S.KH, S.KW, index_dims=[D.kd, D.kh, D.kw]),
     O=TensorDef(U, S.N, S.OD, S.OH, S.OW, S.C, output=True),
     strides=AttributeDef(S.SD, S.SH, S.SW),
     dilations=AttributeDef(S.DD, S.DH, S.DW)):
   """Performs 3D max pooling.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.od, D.oh, D.ow, D.kd, D.kh, D.kw, D.c)
   O[D.n, D.od, D.oh, D.ow, D.c] = ReduceFn.max(D.kd, D.kh, D.kw)(
       cast(
           U, I[D.n, D.od * S.SD + D.kd * S.DD, D.oh * S.SH + D.kh * S.DH,
                D.ow * S.SW + D.kw * S.DW, D.c]))
 
 
 @linalg_structured_op
 def pooling_ndhwc_min(
     I=TensorDef(T1, S.N, S.OD * S.SD + S.KD * S.DD, S.OH * S.SH + S.KH * S.DH,
                 S.OW * S.SW + S.KW * S.DW, S.C),
     K=TensorDef(T2, S.KD, S.KH, S.KW, index_dims=[D.kd, D.kh, D.kw]),
     O=TensorDef(U, S.N, S.OD, S.OH, S.OW, S.C, output=True),
     strides=AttributeDef(S.SD, S.SH, S.SW),
     dilations=AttributeDef(S.DD, S.DH, S.DW)):
   """Performs 3D min pooling.
 
   Numeric casting is performed on the input operand, promoting it to the same
   data type as the accumulator/output.
   """
+  implements(ConvolutionOpInterface)
   domain(D.n, D.od, D.oh, D.ow, D.kd, D.kh, D.kw, D.c)
   O[D.n, D.od, D.oh, D.ow, D.c] = ReduceFn.min(D.kd, D.kh, D.kw)(
       cast(
           U, I[D.n, D.od * S.SD + D.kd * S.DD, D.oh * S.SH + D.kh * S.DH,
                D.ow * S.SW + D.kw * S.DW, D.c]))
 
 
 @linalg_structured_op

mlir/test/Dialect/Linalg/conv-interface-invalid.mlir

+// RUN: mlir-opt -split-input-file -verify-diagnostics %s
+
+func @test_conv_op_not_linalg_op(%arg0 : tensor<?xf32>, %arg1 : tensor<?xf32>,
+    %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{expected a LinalgOp}}
+  %0 = "test.conv_op_not_linalg_op"(%arg0, %arg1, %arg2)
+      : (tensor<?xf32>, tensor<?xf32>, tensor<?xf32>) -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+// Check for number of operands being >= 2.
+#map = affine_map<(d0) -> (d0)>
+func @test_conv_op_wrong_num_operands(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{expected op with 2 inputs and 1 output}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [#map, #map],
+      iterator_types = ["parallel"]}
+      ins(%arg0 : tensor<?xf32>) outs(%arg1 : tensor<?xf32>) {
+      ^bb0(%arg2 : f32, %arg3 : f32):
+         linalg.yield  %arg3 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+func @test_conv_op_wrong_input_indexing_map1(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{unexpected input index map for convolution}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1) -> (d0 * 2)>,
+                       affine_map<(d0, d1) -> (d1)>,
+                       affine_map<(d0, d1) -> (d0)>],
+      iterator_types = ["parallel", "reduction"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+func @test_conv_op_wrong_input_indexing_map2(%arg0 : tensor<?x?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{unexpected input index map for convolution}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1) -> (d0 + d1, d0)>,
+                       affine_map<(d0, d1) -> (d1)>,
+                       affine_map<(d0, d1) -> (d0)>],
+      iterator_types = ["parallel", "reduction"]}
+      ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+func @test_conv_op_filter_index_map_not_projection(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{expected output/filter indexing maps to be projected permutations}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1) -> (d1)>,
+                       affine_map<(d0, d1) -> (d1 + d0)>,
+                       affine_map<(d0, d1) -> (d0)>],
+      iterator_types = ["parallel", "reduction"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+func @test_conv_op_output_index_map_not_projection(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{expected output/filter indexing maps to be projected permutations}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1) -> (d0)>,
+                       affine_map<(d0, d1) -> (d1)>,
+                       affine_map<(d0, d1) -> (d0 + d1)>],
+      iterator_types = ["parallel", "parallel"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+// Convolution op illegal if a loop dimension is used to access
+// output, filter and is convolved.
+func @test_conv_op_output_filter_convolved(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32> {
+  // expected-error @+1 {{unexpected loop dimension for convolution op}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1) -> (d0 + d1)>,
+                       affine_map<(d0, d1) -> (d1)>,
+                       affine_map<(d0, d1) -> (d0, d1)>],
+      iterator_types = ["parallel", "parallel"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?x?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?x?xf32>
+  return %0 : tensor<?x?xf32>
+}
+
+// -----
+
+// Convolution op illegal if a loop dimension is used only in the output.
+func @test_conv_op_output_only_dim(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32> {
+  // expected-error @+1 {{unexpected loop dimension for convolution op}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1, d2) -> (d0 + d1)>,
+                       affine_map<(d0, d1, d2) -> (d1)>,
+                       affine_map<(d0, d1, d2) -> (d0, d2)>],
+      iterator_types = ["parallel", "reduction", "parallel"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?x?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?x?xf32>
+  return %0 : tensor<?x?xf32>
+}
+
+// -----
+
+// Convolution op illegal if a loop dimension is used only in the filter.
+func @test_conv_op_filter_only_dim(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?x?xf32>, %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{unexpected loop dimension for convolution op}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1, d2) -> (d0 + d1)>,
+                       affine_map<(d0, d1, d2) -> (d1, d2)>,
+                       affine_map<(d0, d1, d2) -> (d0)>],
+      iterator_types = ["parallel", "reduction", "reduction"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?x?xf32>)
+      outs(%arg2 : tensor<?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+// Convolution op illegal if a loop dimension is used only in the input.
+func @test_conv_op_input_only_dim(%arg0 : tensor<?x?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{unexpected loop dimension for convolution op}}
+  %0 = test.linalg_conv_op {
+      indexing_maps = [affine_map<(d0, d1, d2) -> (d0 + d1, d2)>,
+                       affine_map<(d0, d1, d2) -> (d1)>,
+                       affine_map<(d0, d1, d2) -> (d0)>],
+      iterator_types = ["parallel", "reduction", "reduction"]}
+      ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}
+
+// -----
+
+// Convolution op illegal if a loop dimension accessing output is not parallel.
+func @test_conv_op_non_output_access_loop_parallel(%arg0 : tensor<?xf32>,
+    %arg1 : tensor<?xf32>, %arg2 : tensor<?xf32>) -> tensor<?xf32> {
+  // expected-error @+1 {{expected all iterators not used to access outputs to be reduction}}
+  %0 = test.linalg_conv_op  {
+      indexing_maps = [affine_map<(d0, d1) -> (d0 + d1)>,
+                       affine_map<(d0, d1) -> (d1)>,
+                       affine_map<(d0, d1) -> (d0)>],
+      iterator_types = ["parallel", "parallel"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+      outs(%arg2 : tensor<?xf32>) {
+      ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32):
+         linalg.yield %arg5 : f32
+      } -> tensor<?xf32>
+  return %0 : tensor<?xf32>
+}

mlir/test/Dialect/Linalg/invalid.mlir

 ////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////// Region tests /////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 // -----
 
 func @generic_empty_region(%arg0: memref<f32>) {
   %f0 = constant 0.0: f32
-  // expected-error @+1 {{op expects region #0 to have 0 or 1 blocks}}
+  // expected-error @+1 {{op expected 1 region with 1 block}}
   linalg.generic {
-    indexing_maps =  [ affine_map<() -> (0)> ],
+    indexing_maps =  [ affine_map<() -> ()>, affine_map<() -> ()> ],
     iterator_types = []}
       ins(%arg0 : memref<f32>)
      outs(%arg0 : memref<f32>) {
     ^bb1:
       linalg.yield %f0: f32
     ^bb2:
       linalg.yield %f0: f32
   }

 }
 
 // -----
 
 func @generic(%arg0: memref<?x?xi4>) {
   // expected-error @+2 {{op expects regions to end with 'linalg.yield', found 'std.addf'}}
   // expected-note @+1 {{in custom textual format, the absence of terminator implies 'linalg.yield'}}
   linalg.generic  {
-    indexing_maps = [ affine_map<(i) -> (i)> ],
-    iterator_types = ["parallel"]}
+    indexing_maps = [ affine_map<(i, j) -> (i, j)> ],
+    iterator_types = ["parallel", "parallel"]}
       outs(%arg0 : memref<?x?xi4>) {
     ^bb(%0: i4) :
       %1 = std.addf %0, %0: i4
   }
   return
 }
 
 // -----
^bb0(%arg4: index, %A_: memref<100xf32>):
       operand_segment_sizes = dense<[1, 1, 1, 0, 1]> : vector<5xi32>
     } : (index, index, index, memref<192xf32>) -> ()
   return
 }
 
 // -----
 
 #attrs = {
-  indexing_maps = [
-    affine_map<(i) -> (3 - i)>,
-    affine_map<(i) -> (i)>
-  ],
-  iterator_types = ["parallel"]
+        indexing_maps = [
+                affine_map<(i) -> (3 - i)>,
+                affine_map<(i) -> (i)>
+        ],
+        iterator_types = ["parallel"]
 }
 
 func @invalid_reverse(%A: memref<5xf32>, %B: memref<5xf32>) {
   // expected-error @+1 {{unexpected result less than 0 at expression #0 in}}
   linalg.generic #attrs ins(%A: memref<5xf32>) outs(%B: memref<5xf32>) {
-    ^bb0(%a: f32, %b: f32):
-    linalg.yield %a : f32
-  }
-  return
+                ^bb0(%a: f32, %b: f32):
+                linalg.yield %a : f32
+        }
+        return
 }

mlir/test/Dialect/Linalg/named-ops.mlir

 // CHECK-SAME:      ins(%{{.+}}, %{{.+}} : memref<1x4x4x4x1xf32>, memref<3x3x3xf32>)
 // CHECK-SAME:      outs(%{{.+}} : memref<1x2x2x2x1xf32>)
 func @pooling_ndhwc_min(%input: memref<1x4x4x4x1xf32>, %fake: memref<3x3x3xf32>, %output: memref<1x2x2x2x1xf32>) {
   linalg.pooling_ndhwc_min {dilations = dense<1> : tensor<3xi64>, strides = dense<1> : tensor<3xi64>}
     ins(%input, %fake: memref<1x4x4x4x1xf32>, memref<3x3x3xf32>)
     outs(%output: memref<1x2x2x2x1xf32>)
   return
 }
+
+// -----
+
+#map0 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1 * 2, d2 * 2 + d5, d6)>
+#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4, d5, d6, d3)>
+#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)>
+func @conv_interface_wrong_input_indexing_map(
+    %arg0 : tensor<?x?x?x?xf32>, %arg2 : tensor<?x?x?x?xf32>, %arg1 : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32> {
+  // expected-error @+1 {{unexpected input index map for convolutions}}
+  %0 = "linalg.conv_2d_nhwc_hwcf"(%arg0, %arg1, %arg2) ( {
+    ^bb0(%arg3: f32, %arg4: f32, %arg5 : f32):  // no predecessors
+      %1 = "std.mulf"(%arg3, %arg4) : (f32, f32) -> f32
+      %2 = "std.addf"(%arg5, %1) : (f32, f32) -> f32
+      "linalg.yield"(%2) : (f32) -> ()
+    }) {dilations = dense<1> : tensor<2xi64>, linalg.memoized_indexing_maps = [#map0, #map1, #map2], operand_segment_sizes = dense<[2, 1]> : vector<2xi32>, strides = dense<2> : tensor<2xi64>} : (tensor<?x?x?x?xf32>, tensor<?x?x?x?xf32>, tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32>
+  return %0 : tensor<?x?x?x?xf32>
+}
+
+// -----
+
+#map0 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1 + d4, d2 + d5, d6)>
+#map1 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4, d5, d6, d3, d5 + 1)>
+#map2 = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3)>
+func @conv_interface_wrong_num_operands(
+    %arg0 : tensor<?x?x?x?xf32>, %arg1 : tensor<?x?x?x?x?xf32>, %arg2 : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32> {
+  // expected-error @+1 {{expected output/filter indexing maps to be projected permutations}}
+  %0 = "linalg.conv_2d_nhwc_hwcf"(%arg0, %arg1, %arg2) ( {
+    ^bb0(%arg3: f32, %arg4: f32, %arg5 : f32):  // no predecessors
+      %1 = "std.mulf"(%arg3, %arg4) : (f32, f32) -> f32
+      %2 = "std.addf"(%arg5, %1) : (f32, f32) -> f32
+      "linalg.yield"(%2) : (f32) -> ()
+    }) {dilations = dense<1> : tensor<2xi64>, linalg.memoized_indexing_maps = [#map0, #map1, #map2], operand_segment_sizes = dense<[2, 1]> : vector<2xi32>, strides = dense<1> : tensor<2xi64>} : (tensor<?x?x?x?xf32>, tensor<?x?x?x?x?xf32>, tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32>
+  return %0 : tensor<?x?x?x?xf32>
+}

mlir/test/lib/Dialect/Test/CMakeLists.txt

add_mlir_library(MLIRTestDialect
   LINK_LIBS PUBLIC
   MLIRControlFlowInterfaces
   MLIRDataLayoutInterfaces
   MLIRDerivedAttributeOpInterface
   MLIRDialect
   MLIRDLTI
   MLIRIR
   MLIRInferTypeOpInterface
+  MLIRLinalg
   MLIRLinalgTransforms
   MLIRLLVMIR
   MLIRPass
   MLIRReduce
   MLIRStandard
   MLIRStandardOpsTransforms
   MLIRTensor
   MLIRTransformUtils
   MLIRTransforms
 )

mlir/test/lib/Dialect/Test/TestDialect.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TESTDIALECT_H
 #define MLIR_TESTDIALECT_H
 
 #include "TestInterfaces.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/Dialect/DLTI/Traits.h"
+#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Traits.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/RegionKindInterface.h"
 #include "mlir/IR/SymbolTable.h"

mlir/test/lib/Dialect/Test/TestOps.td

 include "mlir/IR/RegionKindInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/CopyOpInterface.td"
 include "mlir/Interfaces/DataLayoutInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
+include "mlir/Dialect/Linalg/IR/LinalgInterfaces.td"
 include "TestInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "::test";
   let hasCanonicalizer = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;

 }
 
 def OpCrashShort : TEST_Op<"op_crash_short"> {
   let results = (outs I32);
 }
 
 def : Pat<(OpCrashLong $_, $_, $_), (OpCrashShort)>;
 
+//===----------------------------------------------------------------------===//
+// Test LinalgConvolutionOpInterface.
+//===----------------------------------------------------------------------===//
+
+def TestLinalgConvOpNotLinalgOp : TEST_Op<"conv_op_not_linalg_op", [
+    LinalgConvolutionOpInterface]> {
+  let arguments = (ins
+    AnyType:$image, AnyType:$filter, AnyType:$output);
+  let results = (outs AnyRankedTensor:$result);
+}
+
+def TestLinalgConvOp :
+  TEST_Op<"linalg_conv_op", [AttrSizedOperandSegments,
+      LinalgStructuredInterface, LinalgConvolutionOpInterface]> {
+
+  let arguments = (ins Variadic<AnyType>:$inputs,
+    Variadic<AnyType>:$outputs);
+  let results = (outs Variadic<AnyType>:$results);
+  let regions = (region AnyRegion:$region);
+
+  let assemblyFormat = [{
+    attr-dict (`ins` `(` $inputs^ `:` type($inputs) `)`)?
+    `outs` `(` $outputs `:` type($outputs) `)`
+    $region (`->` type($results)^)?
+  }];
+
+  let extraClassDeclaration = [{
+    bool hasIndexSemantics() { return false; }
+
+    static void regionBuilder(mlir::ImplicitLocOpBuilder &b, mlir::Block &block) {
+      b.create<mlir::linalg::YieldOp>(block.getArguments().back());
+    }
+
+    static std::function<void(mlir::ImplicitLocOpBuilder &b, mlir::Block &block)>
+    getRegionBuilder() {
+      return &regionBuilder;
+    }
+
+    mlir::ArrayAttr iterator_types() {
+      return getOperation()->getAttrOfType<mlir::ArrayAttr>("iterator_types");
+    }
+
+    mlir::ArrayAttr indexing_maps() {
+      return getOperation()->getAttrOfType<mlir::ArrayAttr>("indexing_maps");
+    }
+
+    std::string getLibraryCallName() {
+      return "";
+    }
+  }];
+}
+
 #endif // TEST_OPS

utils/bazel/llvm-project-overlay/mlir/test/BUILD.bazel

td_library(
     srcs = glob(["lib/Dialect/Test/*.td"]),
     deps = [
         "//mlir:CallInterfacesTdFiles",
         "//mlir:ControlFlowInterfacesTdFiles",
         "//mlir:CopyOpInterfaceTdFiles",
         "//mlir:DLTIDialectTdFiles",
         "//mlir:DataLayoutInterfacesTdFiles",
         "//mlir:InferTypeOpInterfaceTdFiles",
+        "//mlir:LinalgStructuredOpsTdFiles",
         "//mlir:OpBaseTdFiles",
         "//mlir:SideEffectTdFiles",
     ],
 )
 
 gentbl_cc_library(
     name = "TestOpsIncGen",
     strip_include_prefix = "lib/Dialect/Test",
deps = [
         "//mlir:CopyOpInterface",
         "//mlir:DLTIDialect",
         "//mlir:DataLayoutInterfaces",
         "//mlir:DerivedAttributeOpInterface",
         "//mlir:Dialect",
         "//mlir:IR",
         "//mlir:InferTypeOpInterface",
         "//mlir:LLVMDialect",
+        "//mlir:LinalgInterfaces",
+        "//mlir:LinalgOps",
         "//mlir:Pass",
         "//mlir:Reducer",
         "//mlir:SideEffects",
         "//mlir:StandardOps",
         "//mlir:StandardOpsTransforms",
         "//mlir:TensorDialect",
         "//mlir:TransformUtils",
         "//mlir:Transforms",