[mlir][Vector] Add folding of vector transfers from/into tensor producing ops.

[nicolasvasilache]

Summary

Add a folder to rewrite a sequence such as:

%v = vector.transfer_read %t0[%c0...], {masked = [false...]} :
  tensor<static_sizesxf32>, vector<static_sizesxf32>
%t1 = side_effect_free_tensor_producing_op : tensor<static_sizesxf32>
%t2 = vector.transfer_write %v, %t1[%c0...] {masked = [false...]} :
  vector<static_sizesxf32>, tensor<static_sizesxf32>

into just t0.

[ftynse]

mlir/lib/Dialect/Vector/VectorOps.cpp

2609

Just drop the argument if it is not used

2618–2620

the doc says the producer is side-effect-free, but there's no check for this

[nicolasvasilache]

mlir/lib/Dialect/Vector/VectorOps.cpp

2618–2620

Is there a way to make a custom op that does not have side effects ?
The issue I have right now is that I don't want a cyclic dependence on tensor ops and I would prefer to not create a special interface for this immediately.

[ftynse]

mlir/lib/Dialect/Vector/VectorOps.cpp

2618–2620

If by "custom" you mean unregistered, then no. But you can put an op in the test dialect (or maybe there's already one).

[nicolasvasilache]

mlir/lib/Dialect/Vector/VectorOps.cpp

2618–2620

Thanks! Actually @gysit remarked offline that side effects are orthogonal here.
So is the fact that init is coming from an op at all..

[nicolasvasilache]

Address review.

mlir/lib/Dialect/Vector/VectorOps.cpp

if (failed(verifyTransferOp(op.getOperation(), shapedType, vectorType,
                               permutationMap,
                               op.masked() ? *op.masked() : ArrayAttr())))
     return failure();
 
   return verifyPermutationMap(permutationMap,
                               [&op](Twine t) { return op.emitOpError(t); });
 }
 
-LogicalResult TransferWriteOp::fold(ArrayRef<Attribute>,
-                                    SmallVectorImpl<OpFoldResult> &) {
+/// Fold:
+/// ```
+///    %v = vector.transfer_read %t0[%c0...], {masked = [false...]} :
+///      tensor<static_sizesxf32>, vector<static_sizesxf32>
+///    %t1 = side_effect_free_tensor_producing_op : tensor<static_sizesxf32>
+///    %t2 = vector.transfer_write %v, %t1[%c0...] {masked = [false...]} :
+///      vector<static_sizesxf32>, tensor<static_sizesxf32>
+/// ```
+/// into:
+/// ```
+///    %t0
+/// ```
+static LogicalResult foldReadInitWrite(TransferWriteOp write,
+                                       ArrayRef<Attribute>,
+                                       SmallVectorImpl<OpFoldResult> &results) {
+  auto rankedTensorType = write.source().getType().dyn_cast<RankedTensorType>();
+  // If not operating on tensors, bail.
+  if (!rankedTensorType)
+    return failure();
+  // Approximate linalg.init_tensor: single result, only index operands.
+  // TODO: OpInterface for a tensor creation op.
+  Operation *init = write.source().getDefiningOp();
+  if (!init || init->getNumResults() != 1 ||
+      llvm::any_of(init->getOperands(),
+                   [](Value v) { return !v.getType().isa<IndexType>(); }))
+    return failure();
+  // If no read, bail.
+  auto read = write.vector().getDefiningOp<vector::TransferReadOp>();
+  if (!read)
+    return failure();
+  // For now, only accept minor identity. Future: composition is minor identity.
+  if (!read.permutation_map().isMinorIdentity() ||
+      !write.permutation_map().isMinorIdentity())
+    return failure();
+  // Bail on mismatching ranks.
+  if (read.getTransferRank() != write.getTransferRank())
+    return failure();
+  // Bail on masked.
+  if (read.hasMaskedDim() || write.hasMaskedDim())
+    return failure();
+  // Tensor types must be the same.
+  if (read.source().getType() != rankedTensorType ||
+      init->getResult(0).getType() != rankedTensorType)
+    return failure();
+  // Vector types must be the same.
+  if (read.getVectorType() != write.getVectorType())
+    return failure();
+  // Vector and Tensor shapes must match.
+  if (read.getVectorType().getShape() != rankedTensorType.getShape())
+    return failure();
+  // If any index is nonzero.
+  auto isNotConstantZero = [](Value v) {
+    auto cstOp = v.getDefiningOp<ConstantIndexOp>();
+    return !cstOp || cstOp.getValue() != 0;
+  };
+  if (llvm::any_of(read.indices(), isNotConstantZero) ||
+      llvm::any_of(write.indices(), isNotConstantZero))
+    return failure();
+  // Success.
+  results.push_back(read.source());
+  return success();
+}
+
+LogicalResult TransferWriteOp::fold(ArrayRef<Attribute> operands,
+                                    SmallVectorImpl<OpFoldResult> &results) {
+  if (succeeded(foldReadInitWrite(*this, operands, results)))
+    return success();
   if (succeeded(foldTransferMaskAttribute(*this)))
     return success();
   return foldMemRefCast(*this);
 }
 
 Optional<SmallVector<int64_t, 4>> TransferWriteOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getVectorType().getShape());
 }

mlir/test/Dialect/Vector/canonicalize.mlir

-// RUN: mlir-opt %s -pass-pipeline='func(canonicalize)' -split-input-file | FileCheck %s
+// RUN: mlir-opt %s -pass-pipeline='func(canonicalize)' -split-input-file -allow-unregistered-dialect | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: create_vector_mask_to_constant_mask
 func @create_vector_mask_to_constant_mask() -> (vector<4x3xi1>) {
   %c2 = constant 2 : index
   %c3 = constant 3 : index
   // CHECK: vector.constant_mask [3, 2] : vector<4x3xi1>
%i8_0 = vector.contract #contraction_trait0 %a_i8, %b_i8, %vi8_0:
     vector<2x3xi8>, vector<3x4xi8> into vector<2x4xi8>
   // CHECK-NOT: addi
   %i8_1 = addi %i8_0, %c_i8: vector<2x4xi8>
 
   // CHECK: return %[[D]], %[[D_I8]]
   return %1, %i8_1: vector<2x4xf32>, vector<2x4xi8>
 }
 
+// -----
+
+// CHECK-LABEL: func @transfer_folding
+//  CHECK-SAME:   %[[T:[0-9a-zA-Z]+]]: tensor<2x3x4xf32>
+func @transfer_folding(%t0: tensor<2x3x4xf32>) -> (tensor<2x3x4xf32>) {
+  %c0 = constant 0 : index
+  %pad = constant 0.0 : f32
+  %v = vector.transfer_read %t0[%c0, %c0, %c0], %pad {masked = [false, false, false]} :
+    tensor<2x3x4xf32>, vector<2x3x4xf32>
+  %t1 = "side_effect_free_tensor_producing_op"() : () -> (tensor<2x3x4xf32>)
+  %t2 = vector.transfer_write %v, %t1[%c0, %c0, %c0] {masked = [false, false, false]} :
+    vector<2x3x4xf32>, tensor<2x3x4xf32>
+
+  // CHECK: return %[[T]]
+  return %t2: tensor<2x3x4xf32>
+}