[mlir] Enable fusion on conv op if it is a consumer.

[hanchung]

Summary

The fuse method will tile the producer based on the subview of the operand in
the consumer. Thus, we don't really care if the consumer has padding or not. It
only breaks if the conv op is a producer (and has padding).

Add a comment for fuse method as well.

[bondhugula]

Could you add a test case?

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

140

Doc comment ///

154

You've also removed this TODO comment - check if it's still applicable.

[mravishankar]

I am not convinced that this is right. The issue with the padding is that you cannot have a subview with padding which can correctly represent the padding in the interior as well as the boundaries. Without going into details, the conv op on subviews is the padded version along the edges, and is the unpadded version in the interior.
The best you can do here is that you can check that the subview is not a result of tiling along the "x" loops of the output, i.e. the size of the subview matches the size of the tensor. You can still tile and fuse along the batch dimension.

[nicolasvasilache]

As Mahesh says, this has incorrect assumptions.
Even just tiling of a conv. op along padded dimensions is not a closed operation and cannot be represented with a single op + attribute.

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

 //===- Fusion.cpp - Implementation of linalg Fusion -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (auto en2 : llvm::enumerate(map.getResults())) {
         LLVM_DEBUG(dbgs() << "getViewDefiningLoopRange view: " << view << "\n");
         return ViewDimension{view, static_cast<unsigned>(en2.index())};
       }
     }
   }
   llvm_unreachable("Expect to be able to extract a view defining loop range");
 }
 
+// Fuse the `producer` into `consumer`. The `producer` will be tiled base on
+// the subview of the operand in consumer.
 static LinalgOp fuse(Value producedView, LinalgOp producer, LinalgOp consumer,
                      unsigned consumerIdx, unsigned producerIdx,
                      OperationFolder *folder) {
   assert(producer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   assert(consumer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
 
   if (auto convOp = dyn_cast<linalg::ConvOp>(producer.getOperation())) {
     // TODO(ntv): add a level of indirection to linalg.generic.
     if (convOp.padding())
       llvm_unreachable("Unexpected conv with padding");
   }
-  if (auto convOp = dyn_cast<linalg::ConvOp>(consumer.getOperation())) {
-    // TODO(ntv): add a level of indirection to linalg.generic.
-    if (convOp.padding())
-      llvm_unreachable("Unexpected conv with padding");
-  }
 
   auto subView = dyn_cast_or_null<SubViewOp>(
       consumer.getBuffer(consumerIdx).getDefiningOp());
   auto slice = dyn_cast_or_null<SliceOp>(
       consumer.getBuffer(consumerIdx).getDefiningOp());
   assert(subView || slice);
   (void)subView;
   (void)slice;