[mlir][Linalg] NFC: Verify tiling on linalg.generic operation on tensors.

[mravishankar]

Summary

With the recent changes to linalg on tensor semantics, the tiling
operations works out-of-the-box for generic operations. Add a test to
verify that and some minor refactoring.

[nicolasvasilache]

It's nice that we actually don't need to change op semantics to support "init_tensor form" and that all semantics can be dealt with just in tiling.
However we need a better abstraction and documentation to avoid leaking the op + init or result tensor implementation detail into the tiling implementation.

A simple

struct {
  LinalgOp op;
  Value result; // only if op has no init_tensor
};

with a proper API and assertions should be enough to separate these concerns.

The harder part will prob. be finding good names for this :)

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

47

initialization

48

Now that I see you don't need to specify dims because the op must fold away before bufferization,
I am not worried about "the assumption that entire tensor is overwritten", this is the semantics of linalg ops and this is preserved by tiling.
So I would drop the "Proceed with caution" sentence and instead emphasize that this is an op that must fold away before bufferization.

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

68

This seems fishy to me because it changes the semantics of all ops.

Shouldn't we instead drop the extra dimensions from the getShapesToLoopsMap as discussed in https://reviews.llvm.org/D93076 ?
As I mentioned there, this was written in the context of buffers where the output buffers are part of the shaped operands.
So this needs a little adjustment but I would claim in the other direction.

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

382

Please isolate in a helper function and document it:
"tiling on tensors requires tensors to write form"
"don't change the op semantics to become init_tensors but instead but create result tensors when needed"
"this op must fold away and does not require size operands even in the dynamic case"
etc

428

This doc assumed we would evolve the op semantics to allow all ops to convert to an "init_tensor form".
The direction you are pushing avoids that change and it need to be clearly documented.

436

this would benefit from a helper function + documentation that mentions the 2 cases:

1. op with init tensor
2. op without init tensor but with a companion result tensor for the purpose of tiling.

447

This is now harder to follow and we will trip over in the future.

I suggest a helper struct that captures the op and potentially the result tensor.
That struct hides the implementation detail for the purpose of tiling and would be queried as if the op was in init_tensor form.
With proper documentation it will make it much easier to understand in 3 months.

[mravishankar]

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

48

There are still issues with this op definition I am not entirely clear about. I sent this out for review to start conversion about this. Here are issues that i think need to be solved

1. If it is upto bufferization to make sure that the init_tensor -> scf.for pattern should result in the "init_tensor being folded away" then I would expect it would be better to make sure there is one init_tensor for every tiling loop generated, i.e. init_tensor ops are not CSEed if there are multiple tiling loops. In that case we probably want to add some dummy side-effect for init_tensor
2. I actually dont think having an initial value here is doing anything. Should we drop the "initialization value" above. The reason why I had this was because leaving it undef is a whole other can of worms, but that seems to actually match what is needed here. The proceed with caution was to say that the initialization value is not load-bearing at all. It is overwritten after tiling loops are executed.

My preference right now is to

• make this a side-effecting operation that cannot be CSE-ed.
• drop the initialization value
• Assume that the bufferization is going to fold the op away

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

68

Agreed. WIll send out a different patch for that.

[mravishankar]

Address comments and rebase

[mravishankar]

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

68

Moved the code to https://reviews.llvm.org/D93180 .

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

382

Good Idea. Made a helper struct TiledOp that encompasses all the logic. It does make things cleaner.

[hanchung]

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

1731–1735

nit: drop braces.

https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

E.g.,

// This should also omit braces.  The `for` loop contains only a single statement,
// so it shouldn't have braces.  The `if` also only contains a single simple
// statement (the for loop), so it also should omit braces.
if (isa<FunctionDecl>(D))
  for (auto *A : D.attrs())

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

318

s/a/an

321

s/a/an

324–346

I would add braces between methods and vars because it helps readability. E.g.,

struct TiledOp {
  TiledOp(OpBuilder &b, LinalgOp op) : op(op) {
     ...
   }

  SmallVector<Value, 4> getTiledOperands() {
     ...
   }

  LinalgOp op;
  SmallVector<Value, 1> initTensors;
};

mlir/test/Dialect/Linalg/roundtrip.mlir

722–727

We typically put this to invalid.mlir, lets move to there and remove adding -verify-diagnostics to this file.

mlir/test/Dialect/Linalg/tile-tensors.mlir

46

remove the blank line?

[mravishankar]

Updating this to use init_tensor operation, but this doesnt work. It
creates a use-after-def issue. This should be resolved when
https://llvm.discourse.group/t/linalg-and-shapes/2421 is addressed.

[mravishankar]

Rebase over recent changes to linalg on tensors

[mravishankar]

Rebase

[hanchung]

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

613

Since you also add IndexedGenericOp, could we add a test for it?

[nicolasvasilache]

+1 for the extra test.

[mravishankar]

Rebase and add extra test

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

class Linalg_Op<string mnemonic, list<OpTrait> traits = []> :
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
+def InitTensorOp : Linalg_Op<"init_tensor", [NoSideEffect]> {
+  let summary = "operation to define a tensor of particular value";
+
+  let description = [{
+    `linalg.init_tensor` is an operation that materializes a tensor of
+    the given scalar value.
+
+    For now it is only used in the context of tiling to materialize a
+    tensor that the tile loop body updates the tiled results into
+    (using destructive updates). In reality, it would be better to
+    leave this tensor uninitialized, but that opens up issues of how
+    to handle "undef" values correctly. To side-step that for now, an
+    initialiazation value is specified, with the assumption that
+    entire tensor is overwritten during tiling. Proceed with caution
+    when using this operation.
+  }];
+
+  let arguments =
+    (ins AnyTypeOf<[AnyFloat, AnySignlessInteger, AnyVector]>:$value);
+
+  let results = (outs AnyTensor:$result);
+
+  let assemblyFormat = [{
+    $value attr-dict `:` type($value) `into` type($result)
+  }];
+
+  let verifier = [{ return ::verify(*this); }];
+}
+
 def Linalg_RangeOp :
     Linalg_Op<"range", [NoSideEffect]>,
     Arguments<(ins Index:$min, Index:$max, Index:$step)>,
     Results<(outs Range)> {
   let summary = "Create a `range` type value, used to create `view`s";
   let description = [{
     The `linalg.range` op creates a `!linalg.range` from 3 values of type
     `index` that represent the min, max and step values of the `range`. This

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

 SmallVector<Value, 4> LinalgOp::createFlatListOfOperandDims(OpBuilder &b,
                                                             Location loc) {
   SmallVector<Value, 4> res;
   for (Value v : getShapedOperands()) {
     ShapedType t = v.getType().template cast<ShapedType>();
     for (unsigned i = 0, e = t.getRank(); i < e; ++i)
       res.push_back(b.create<DimOp>(loc, v, i));
   }
+  OpBuilder::InsertionGuard guard(b);
+  b.setInsertionPointAfter(getOperation());
+  if (getNumInitTensors() == 0) {
+    for (Value v : getOperation()->getResults()) {
+      ShapedType t = v.getType().template cast<ShapedType>();
+      for (unsigned i = 0, e = t.getRank(); i < e; ++i)
+        res.push_back(b.create<DimOp>(loc, v, i));
+    }
+  }
   return res;
 }
 
 SmallVector<Range, 4> LinalgOp::createLoopRanges(OpBuilder &b, Location loc) {
   AffineMap map = getLoopsToShapesMap();
   unsigned numDims = map.getNumDims(), numRes = map.getNumResults();
   auto viewSizes = createFlatListOfOperandDims(b, loc);
   SmallVector<Range, 4> res(numDims);

 }
 
 ///////////////////// Operations defined with Tablegen /////////////////////////
 // For such operations that do not correspond to library calls (i.e. defined in
 // LinalgOps.td), we define an overloaded `print` function and a
 // parse`className` function.
 
 //===----------------------------------------------------------------------===//
+// InitTensorOp
+//===----------------------------------------------------------------------===//
+static LogicalResult verify(InitTensorOp op) {
+  if (op.value().getType() !=
+      op.result().getType().cast<ShapedType>().getElementType()) {
+    return op.emitError(
+        "mismatch in value type and element type of the result tensor");
+  }
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // GenericOps
 //===----------------------------------------------------------------------===//
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, TypeRange resultTensorTypes,
     ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors,
     ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes,
     StringRef doc, StringRef libraryCall,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild) {
newOperands.append(linalgOp.getOutputBuffers().begin(),
                        linalgOp.getOutputBuffers().end());
     // Init tensors may fold, in which case the resultType must also change.
     for (Value v : linalgOp.getInitTensors()) {
       auto tensorCastOp = v.getDefiningOp<TensorCastOp>();
       bool fold = canFoldIntoConsumerOp(tensorCastOp);
       newOperands.push_back(fold ? tensorCastOp.getOperand() : v);
       newResultTypes.push_back(newOperands.back().getType());
     }
+    if (linalgOp.getNumInitTensors() == 0) {
+      for (Value v : linalgOp.getOperation()->getResults()) {
+        newResultTypes.push_back(v.getType());
+      }
+    }
     auto extraOperands = linalgOp.getAssumedNonShapedOperands();
     newOperands.append(extraOperands.begin(), extraOperands.end());
     // Clone op.
     Operation *newOp =
         linalgOp.clone(rewriter, op->getLoc(), newResultTypes, newOperands);
     rewriter.replaceOp(op, newOp->getResults());
 
     return success();

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

 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/FoldedIntrinsics.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/SCF/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 #include "llvm/Support/CommandLine.h"
 
static bool isTiled(AffineMap map, ValueRange tileSizes) {
   for (unsigned r = 0; r < map.getNumResults(); ++r)
     if (isTiled(map.getResult(r), tileSizes))
       return true;
   return false;
 }
 
 static SmallVector<Value, 4>
 makeTiledShapes(OpBuilder &b, Location loc, LinalgOp linalgOp,
-                ValueRange operands, AffineMap map, ValueRange ivs,
-                ValueRange tileSizes, ValueRange allShapeSizes) {
-  assert(operands.size() == linalgOp.getShapedOperands().size());
+                ValueRange operands, ValueRange nonInitResultTensors,
+                AffineMap map, ValueRange ivs, ValueRange tileSizes,
+                ValueRange allShapeSizes) {
   assert(ivs.size() == static_cast<size_t>(llvm::count_if(
                            llvm::make_range(tileSizes.begin(), tileSizes.end()),
                            [](Value v) { return !isZero(v); })) &&
          "expected as many ivs as non-zero sizes");
 
   using namespace edsc::op;
 
   auto shapeSizes = applyMapToValues(b, loc, map, allShapeSizes);
   // Construct (potentially temporary) mins and maxes on which to apply maps
   // that define tile subshapes.
   SmallVector<Value, 8> lbs, subShapeSizes;
   for (unsigned idx = 0, idxIvs = 0, e = tileSizes.size(); idx < e; ++idx) {
     bool isTiled = !isZero(tileSizes[idx]);
     lbs.push_back(isTiled ? ivs[idxIvs++] : (Value)std_constant_index(0));
     // Before composing, we need to make range a closed interval.
     Value size = isTiled ? tileSizes[idx] : shapeSizes[idx];
     subShapeSizes.push_back(size - std_constant_index(1));
   }
 
-  auto *op = linalgOp.getOperation();
-
   SmallVector<Value, 4> res;
-  res.reserve(op->getNumOperands());
-  for (auto en : llvm::enumerate(operands)) {
+  res.reserve(operands.size() + nonInitResultTensors.size());
+  SmallVector<Value, 4> tiledOperands(operands.begin(), operands.end());
+  tiledOperands.append(nonInitResultTensors.begin(),
+                       nonInitResultTensors.end());
+  for (auto en : llvm::enumerate(tiledOperands)) {
     Value shapedOp = en.value();
     ShapedType shapedType = shapedOp.getType().cast<ShapedType>();
     unsigned rank = shapedType.getRank();
     AffineMap map = linalgOp.getIndexingMap(en.index());
     // If the shape is not tiled, we can use it as is.
     if (!isTiled(map, tileSizes)) {
       res.push_back(shapedOp);
       continue;
for (auto en : llvm::enumerate(tiledOperands)) {
     else
       res.push_back(
           b.create<SubTensorOp>(loc, shapedOp, offsets, sizes, strides));
   }
 
   return res;
 }
 
 template <typename LoopTy>
 static Optional<TiledLinalgOp>
 tileLinalgOpImpl(OpBuilder &b, LinalgOp op, ValueRange tileSizes,
                  const LinalgTilingOptions &options) {
   auto nLoops = op.getNumLoops();
   // Initial tile sizes may be too big, only take the first nLoops.
   tileSizes = tileSizes.take_front(nLoops);
 
   if (llvm::all_of(tileSizes, isZero))
     return llvm::None;
 
   if (auto convOp = dyn_cast<linalg::ConvOp>(op.getOperation())) {
     // For conv op only support tiling along batch dimension (which is the first
     // loop).
     if (convOp.padding() && !llvm::all_of(tileSizes.drop_front(), isZero))
       return llvm::None;
   }
 
   // 1. Build the tiled loop ranges.
   auto allShapeSizes = op.createFlatListOfOperandDims(b, op.getLoc());
   AffineMap shapeSizesToLoopsMap = op.getShapesToLoopsMap();
   if (!shapeSizesToLoopsMap)
     return llvm::None;
 
   SmallVector<Range, 4> loopRanges;
   LoopIndexToRangeIndexMap loopIndexToRangeIndex;
   std::tie(loopRanges, loopIndexToRangeIndex) = makeTiledLoopRanges(
       b, op.getLoc(), shapeSizesToLoopsMap, allShapeSizes, tileSizes);
+
   SmallVector<Attribute, 4> iteratorTypes;
   for (auto attr :
        enumerate(op.iterator_types().cast<ArrayAttr>().getValue())) {
     if (loopIndexToRangeIndex.count(attr.index()))
       iteratorTypes.push_back(attr.value());
   }
   // If interchangeVector is empty, use the identity. Build the permutation map
   // otherwise.
if (!options.interchangeVector.empty()) {
     assert(invPermutationMap);
     applyPermutationToVector(loopRanges, interchangeVector);
     applyPermutationToVector(iteratorTypes, interchangeVector);
   }
 
   // 2. Create the tiled loops.
   LinalgOp res = op;
   SmallVector<Value, 4> ivs, tensorResults;
-  auto initTensors = op.getInitTensors();
+  SmallVector<Value, 1> loopArgs = llvm::to_vector<1>(op.getInitTensors());
+  SmallVector<Value, 1> nonInitResultTensors;
+  if (op.getOperation()->getNumResults() != 0 && op.getNumInitTensors() == 0) {
+    for (ShapedType resultType : op.getOutputTensorTypes()) {
+      Attribute zeroAttr = b.getZeroAttr(resultType.getElementType());
+      Value zeroValue = b.create<ConstantOp>(op.getLoc(), zeroAttr);
+      Value zeroTensor =
+          b.create<InitTensorOp>(op.getLoc(), resultType, zeroValue);
+      nonInitResultTensors.push_back(zeroTensor);
+    }
+  }
+  loopArgs.append(nonInitResultTensors.begin(), nonInitResultTensors.end());
   GenerateLoopNest<LoopTy>::doit(
-      loopRanges, /*iterArgInitValues*/ initTensors, iteratorTypes,
+      loopRanges, /*iterArgInitValues*/ loopArgs, iteratorTypes,
       [&](ValueRange localIvs, ValueRange iterArgs) -> scf::ValueVector {
         auto &b = ScopedContext::getBuilderRef();
         auto loc = ScopedContext::getLocation();
         ivs.assign(localIvs.begin(), localIvs.end());
 
         // When an `interchangeVector` is present, it has been applied to the
         // loop ranges and the iterator types. Apply its inverse to the
         // resulting loop `ivs` to match the op definition.
         SmallVector<Value, 4> interchangedIvs;
         if (!options.interchangeVector.empty())
           interchangedIvs = applyMapToValues(b, loc, invPermutationMap, ivs);
         else
           interchangedIvs.assign(ivs.begin(), ivs.end());
 
-        assert(op.getNumInitTensors() == iterArgs.size() &&
+        assert((op.getNumInitTensors() + nonInitResultTensors.size() ==
+                iterArgs.size()) &&
                "num init tensors must match number of loop iter arguments");
         // This uses knowledge about position of the init tensor in the list
         // of operands.
         auto operands = llvm::to_vector<4>(op.getShapedOperands());
+        if (op.getNumInitTensors()) {
           std::copy(iterArgs.begin(), iterArgs.end(),
                     operands.begin() + op.getNumInputsAndOutputBuffers());
+        }
+        SmallVector<Value, 4> localNonInitResultTensors = {};
+        if (!nonInitResultTensors.empty()) {
+          localNonInitResultTensors.append(
+              iterArgs.begin() + op.getNumInitTensors(), iterArgs.end());
+        }
 
-        SmallVector<Value, 4> tiledOperands =
-            makeTiledShapes(b, loc, op, operands, shapeSizesToLoopsMap,
-                            interchangedIvs, tileSizes, allShapeSizes);
-        auto nonShapedOperands = op.getAssumedNonShapedOperands();
-        tiledOperands.append(nonShapedOperands.begin(),
-                             nonShapedOperands.end());
+        SmallVector<Value, 4> tiledValues = makeTiledShapes(
+            b, loc, op, operands, localNonInitResultTensors,
+            shapeSizesToLoopsMap, interchangedIvs, tileSizes, allShapeSizes);
 
         // If LinalgOp has results, they must all be tied to init tensors.
         // We enforce this to ensure all tiled ops have been rewritten in
         // "init tensor" form. This ensures tiling has anchor values into which
         // to subtensor / subtensor_insert. Otherwise tiling would need to
         // allocate which is not acceptable.
         // This would not be the case with a special terminator op that
         // generates the whole tensor (instead of inserting a subtensor). But
         // the generator-based abstraction has other issues.
-        assert(op.getNumInitTensors() == op->getNumResults() &&
-               "expected same number of init tensors as number of results");
+        assert((op.getNumInitTensors() == 0 ||
+                op.getNumInitTensors() == op->getNumResults()) &&
+               "expected number of init tensors to be zero or same as number "
+               "of results");
 
         // Handle init tensor operands.
         // This uses knowledge about position of the init tensor in the list
         // of operands.
         // TODO: InterfaceAdaptor ?
         SmallVector<Type, 4> resultTensorTypes;
-        for (auto idx : llvm::seq<unsigned>(0, op.getNumInitTensors()))
+        for (auto idx :
+             llvm::seq<unsigned>(0, op.getOperation()->getNumResults()))
           resultTensorTypes.push_back(
-              tiledOperands[op.getNumInputsAndOutputBuffers() + idx].getType());
+              tiledValues[op.getNumInputsAndOutputBuffers() + idx].getType());
 
-        res = op.clone(b, loc, resultTensorTypes, tiledOperands);
+        SmallVector<Value, 4> clonedOpOperands = llvm::to_vector<4>(
+            ArrayRef<Value>(tiledValues).take_front(op.getNumShapedOperands()));
+        auto nonShapedOperands = op.getAssumedNonShapedOperands();
+        clonedOpOperands.append(nonShapedOperands.begin(),
+                                nonShapedOperands.end());
+        res = op.clone(b, loc, resultTensorTypes, clonedOpOperands);
 
         // Insert a subtensor_insert for each init subtensor.
-        for (unsigned idx = 0, e = op.getNumInitTensors(); idx != e; ++idx) {
+        for (unsigned idx = 0,
+                      e = op.getNumInitTensors() + nonInitResultTensors.size();
+             idx != e; ++idx) {
           Value initTensor =
-              tiledOperands[op.getNumInputsAndOutputBuffers() + idx];
+              tiledValues[op.getNumInputsAndOutputBuffers() + idx];
           if (auto subtensor = initTensor.getDefiningOp<SubTensorOp>()) {
             tensorResults.push_back(b.create<SubTensorInsertOp>(
                 loc, subtensor.source().getType(), res->getResult(idx),
                 subtensor.source(), subtensor.offsets(), subtensor.sizes(),
                 subtensor.strides(), subtensor.static_offsets(),
                 subtensor.static_sizes(), subtensor.static_strides()));
           } else {
             tensorResults.push_back(res->getResult(idx));

 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
       >::insert(patterns, ctx);
 }
 
 /// Populate the given list with patterns that apply Linalg tiling.
 static void insertTilingPatterns(OwningRewritePatternList &patterns,
                                  const LinalgTilingOptions &options,
                                  MLIRContext *ctx) {
-  RewritePatternList<
+  RewritePatternList<GenericOp, IndexedGenericOp,
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
                      >::insert(patterns, options, ctx);
 }
 
 static void applyTilingToLoopPatterns(LinalgTilingLoopType loopType,
                                       FuncOp funcOp,
                                       ArrayRef<int64_t> tileSizes) {
   auto options =
       LinalgTilingOptions().setTileSizes(tileSizes).setLoopType(loopType);
   MLIRContext *ctx = funcOp.getContext();

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

LogicalResult mlir::linalg::LinalgBaseTilingPattern::matchAndRewriteBase(
     Operation *op, PatternRewriter &rewriter,
     SmallVectorImpl<Value> &tensorResults) const {
   LinalgOp linalgOp = dyn_cast<LinalgOp>(op);
   if (!linalgOp)
     return failure();
   if (failed(marker.checkAndNotify(rewriter, linalgOp)))
     return failure();
 
-  // If LinalgOp has results, they must all be tied to init tensors.
-  // We enforce this to ensure all tiled ops have been rewritten in
-  // "init tensor" form. This ensures tiling has anchor values into which to
-  // subtensor / subtensor_insert. Otherwise tiling would need to allocate which
-  // is not acceptable.
-  // This would not be the case with a special terminator op that generates the
-  // whole tensor (instead of inserting a subtensor). But the generator-based
-  // abstraction has other issues.
-  if (linalgOp.getNumInitTensors() != linalgOp->getNumResults())
+  if (linalgOp.getNumInitTensors() != 0 &&
+      linalgOp.getNumInitTensors() != linalgOp->getNumResults())
     return failure();
 
   Optional<TiledLinalgOp> res = tileLinalgOp(rewriter, linalgOp, options);
 
   if (!res)
     return failure();
 
   // Return relevant information to derived pattern.

mlir/test/Dialect/Linalg/roundtrip.mlir

-// RUN: mlir-opt -split-input-file %s | FileCheck %s
-// | mlir-opt | FileCheck %s
+// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // TODO: Re-enable LLVM lowering test after IndexedGenericOp is lowered.
 //
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // DISABLED: mlir-opt %s --convert-linalg-to-llvm -o=/dev/null 2>&1
 
 func @range(%arg0: index, %arg1: index, %arg2: index) {
   %0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range

 {
   %0 = linalg.reshape %arg0 [] : memref<1x1xf32> into memref<f32>
   %1 = linalg.reshape %0 [] : memref<f32> into memref<1x1xf32>
   return %0, %1 : memref<f32>, memref<1x1xf32>
 }
 // CHECK-LABEL: func @memref_reshape_zero_dim
 //       CHECK:   linalg.reshape %{{.*}} [] : memref<1x1xf32> into memref<f32>
 //       CHECK:   linalg.reshape %{{.*}} [] : memref<f32> into memref<1x1xf32>
+
+// -----
+
+func @fill_tensor(%arg0 : f32, %arg1 : i32, %arg2 : vector<2x3xf32>)
+{
+  %0 = linalg.init_tensor %arg0 : f32 into tensor<?x?x?xf32>
+  %1 = linalg.init_tensor %arg0 : f32 into tensor<?x4xf32>
+  %2 = linalg.init_tensor %arg0 : f32 into tensor<42x21xf32>
+  %3 = linalg.init_tensor %arg1 : i32 into tensor<?x?xi32>
+  %4 = linalg.init_tensor %arg2 :
+    vector<2x3xf32> into tensor<?x?xvector<2x3xf32>>
+  return
+}
+// CHECK-LABEL: func @fill_tensor
+//       CHECK:   linalg.init_tensor %{{.+}} : f32 into tensor<?x?x?xf32>
+//       CHECK:   linalg.init_tensor %{{.+}} : f32 into tensor<?x4xf32>
+//       CHECK:   linalg.init_tensor %{{.+}} : f32 into tensor<42x21xf32>
+//       CHECK:   linalg.init_tensor %{{.+}} : i32 into tensor<?x?xi32>
+//       CHECK:   linalg.init_tensor %{{.+}} : vector<2x3xf32> into tensor<?x?xvector<2x3xf32>>
+
+// -----
+
+func @fill_tensor_mismatch(%arg0 : f32)
+{
+  // expected-error @+1 {{mismatch in value type and element type of the result tensor}}
+  %0 = linalg.init_tensor %arg0 : f32 into tensor<?x?xi32>
+  return
+}

mlir/test/Dialect/Linalg/tile-tensors.mlir

-// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,4" -mlir-disable-threading=true | FileCheck %s
+// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,4" -split-input-file | FileCheck %s
 
 // CHECK-LABEL: func @matmul_tensors(
 // CHECK-SAME:    %[[TA:[0-9a-z]+]]: tensor<?x?xf32>
 // CHECK-SAME:    %[[TB:[0-9a-z]+]]: tensor<?x?xf32>
 // CHECK-SAME:    %[[TC:[0-9a-z]+]]: tensor<?x?xf32>) -> tensor<?x?xf32> {
 func @matmul_tensors(
   %arg0: tensor<?x?xf32>, %arg1: tensor<?x?xf32>, %arg2: tensor<?x?xf32>)
     -> tensor<?x?xf32> {

 //      CHECK:   scf.yield %[[TD1]] : tensor<?x?xf32>
   %0 = linalg.matmul  ins(%arg0, %arg1: tensor<?x?xf32>, tensor<?x?xf32>)
                      init(%arg2: tensor<?x?xf32>)
     -> tensor<?x?xf32>
 
 //      CHECK: return %[[TD0]] : tensor<?x?xf32>
   return %0 : tensor<?x?xf32>
 }
+
+// -----
+
+func @generic_op_tensors(
+  %arg0 : tensor<?x?x?xf32>, %arg1 : tensor<?x?x?xf32>) -> tensor<?x?x?xf32> {
+  %0 = linalg.generic
+    {indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d1, d2)>,
+                      affine_map<(d0, d1, d2) -> (d0, d2, d1)>,
+          affine_map<(d0, d1, d2) -> (d2, d1, d0)>],
+     iterator_types = ["parallel", "parallel", "parallel"]}
+    ins(%arg0, %arg1 : tensor<?x?x?xf32>, tensor<?x?x?xf32>) {
+    ^bb0(%arg2 : f32, %arg3: f32):
+      %1 = addf %arg2, %arg3 : f32
+      linalg.yield %1 : f32
+    } -> tensor<?x?x?xf32>
+  return %0 : tensor<?x?x?xf32>
+}
+
+// CHECK-LABEL: func @generic_op_tensors
+//  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]+]]: tensor<?x?x?xf32>
+//  CHECK-SAME:   %[[ARG1:[a-zA-Z0-9_]+]]: tensor<?x?x?xf32>
+//       CHECK:   %[[INIT:.+]] = linalg.init_tensor
+//       CHECK:   %[[TD0:.+]] = scf.for %{{.+}} to %{{.+}} step %{{.+}} iter_args(%[[TC0:.+]] = %[[INIT]]) -> (tensor<?x?x?xf32>) {
+//       CHECK:     %[[TD1:.+]] = scf.for %{{.+}} to %{{.+}} step %{{.+}} iter_args(%[[TC1:.+]] = %[[TC0]]) -> (tensor<?x?x?xf32>) {
+//       CHECK:       %[[TD2:.+]] = scf.for %{{.+}} to %{{.+}} step %{{.+}} iter_args(%[[TC2:.+]] = %[[TC1]]) -> (tensor<?x?x?xf32>) {
+//       CHECK:       %[[STARG0:.+]] = subtensor %[[ARG0]][{{.+}}] : tensor<?x?x?xf32> to tensor<?x?x?xf32>
+//       CHECK:       %[[STARG1:.+]] = subtensor %[[ARG1]][{{.+}}] : tensor<?x?x?xf32> to tensor<?x?x?xf32>
+//       CHECK:       %[[STRETURN:.+]] = linalg.generic
+//  CHECK-SAME:         ins(%[[STARG0]], %[[STARG1]] : tensor<?x?x?xf32>, tensor<?x?x?xf32>)
+//       CHECK:       %[[TD:.+]] = subtensor_insert %[[STRETURN]] into %[[TC2]]
+//       CHECK:       scf.yield %[[TD]]
+//       CHECK:     }
+//       CHECK:     scf.yield %[[TD2]]
+//       CHECK:   }
+//       CHECK:   scf.yield %[[TD1]]
+//       CHECK: }
+//       CHECK: return %[[TD0]]