diff --git a/mlir/include/mlir/IR/BuiltinTypes.h b/mlir/include/mlir/IR/BuiltinTypes.h --- a/mlir/include/mlir/IR/BuiltinTypes.h +++ b/mlir/include/mlir/IR/BuiltinTypes.h @@ -432,10 +432,6 @@ /// `t` with simplified layout. MemRefType canonicalizeStridedLayout(MemRefType t); -/// Return a version of `t` with a layout that has all dynamic offset and -/// strides. This is used to erase the static layout. -MemRefType eraseStridedLayout(MemRefType t); - /// Given MemRef `sizes` that are either static or dynamic, returns the /// canonical "contiguous" strides AffineExpr. Strides are multiplicative and /// once a dynamic dimension is encountered, all canonical strides become @@ -462,10 +458,6 @@ /// Return true if the layout for `t` is compatible with strided semantics. bool isStrided(MemRefType t); -/// Return the layout map in strided linear layout AffineMap form. -/// Return null if the layout is not compatible with a strided layout. -AffineMap getStridedLinearLayoutMap(MemRefType t); - } // namespace mlir #endif // MLIR_IR_BUILTINTYPES_H diff --git a/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp b/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp --- a/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp +++ b/mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp @@ -25,6 +25,13 @@ using namespace mlir; using namespace mlir::linalg; +static MemRefType makeStridedLayoutDynamic(MemRefType type) { + return MemRefType::Builder(type).setLayout(StridedLayoutAttr::get( + type.getContext(), ShapedType::kDynamicStrideOrOffset, + SmallVector(type.getRank(), + ShapedType::kDynamicStrideOrOffset))); +} + /// Helper function to extract the operand types that are passed to the /// generated CallOp. MemRefTypes have their layout canonicalized since the /// information is not used in signature generation. @@ -37,7 +44,7 @@ // information. Canonicalizing the type at the level of std when going into // a library call avoids needing to introduce DialectCastOp. if (auto memrefType = type.dyn_cast()) - result.push_back(eraseStridedLayout(memrefType)); + result.push_back(makeStridedLayoutDynamic(memrefType)); else result.push_back(type); } @@ -95,7 +102,7 @@ continue; } Value cast = - b.create(loc, eraseStridedLayout(memrefType), op); + b.create(loc, makeStridedLayoutDynamic(memrefType), op); res.push_back(cast); } return res; diff --git a/mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp b/mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp --- a/mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp +++ b/mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp @@ -758,8 +758,8 @@ int64_t dynamicOffset = ShapedType::kDynamicStrideOrOffset; SmallVector dynamicStrides(rankedTensorType.getRank(), ShapedType::kDynamicStrideOrOffset); - AffineMap stridedLayout = makeStridedLinearLayoutMap( - dynamicStrides, dynamicOffset, rankedTensorType.getContext()); + auto stridedLayout = StridedLayoutAttr::get(tensorType.getContext(), + dynamicOffset, dynamicStrides); return MemRefType::get(rankedTensorType.getShape(), rankedTensorType.getElementType(), stridedLayout, memorySpaceAttr); diff --git a/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp b/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp --- a/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp +++ b/mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp @@ -179,7 +179,7 @@ (aOffset == bOffset) ? aOffset : ShapedType::kDynamicStrideOrOffset; return MemRefType::get( resShape, aT.getElementType(), - makeStridedLinearLayoutMap(resStrides, resOffset, aT.getContext())); + StridedLayoutAttr::get(aT.getContext(), resOffset, resStrides)); } /// Operates under a scoped context to build the intersection between the diff --git a/mlir/lib/IR/BuiltinTypes.cpp b/mlir/lib/IR/BuiltinTypes.cpp --- a/mlir/lib/IR/BuiltinTypes.cpp +++ b/mlir/lib/IR/BuiltinTypes.cpp @@ -992,15 +992,6 @@ return simplifyAffineExpr(expr, numDims, nSymbols); } -/// Return a version of `t` with a layout that has all dynamic offset and -/// strides. This is used to erase the static layout. -MemRefType mlir::eraseStridedLayout(MemRefType t) { - auto val = ShapedType::kDynamicStrideOrOffset; - return MemRefType::Builder(t).setLayout( - AffineMapAttr::get(makeStridedLinearLayoutMap( - SmallVector(t.getRank(), val), val, t.getContext()))); -} - AffineExpr mlir::makeCanonicalStridedLayoutExpr(ArrayRef sizes, MLIRContext *context) { SmallVector exprs; @@ -1017,13 +1008,3 @@ auto res = getStridesAndOffset(t, strides, offset); return succeeded(res); } - -/// Return the layout map in strided linear layout AffineMap form. -/// Return null if the layout is not compatible with a strided layout. -AffineMap mlir::getStridedLinearLayoutMap(MemRefType t) { - int64_t offset; - SmallVector strides; - if (failed(getStridesAndOffset(t, strides, offset))) - return AffineMap(); - return makeStridedLinearLayoutMap(strides, offset, t.getContext()); -} diff --git a/mlir/test/Dialect/Arithmetic/one-shot-bufferize.mlir b/mlir/test/Dialect/Arithmetic/one-shot-bufferize.mlir --- a/mlir/test/Dialect/Arithmetic/one-shot-bufferize.mlir +++ b/mlir/test/Dialect/Arithmetic/one-shot-bufferize.mlir @@ -9,7 +9,7 @@ // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs unknown-type-conversion=identity-layout-map function-boundary-type-conversion=identity-layout-map bufferize-function-boundaries" -split-input-file -o /dev/null // CHECK-LABEL: func @write_to_select_op_source -// CHECK-SAME: %[[t1:.*]]: memref, %[[t2:.*]]: memref +// CHECK-SAME: %[[t1:.*]]: memref, %[[t2:.*]]: memref func.func @write_to_select_op_source( %t1 : tensor {bufferization.writable = true}, %t2 : tensor {bufferization.writable = true}, @@ -34,7 +34,7 @@ // maps are passed to arith.select. A cast must be inserted. // CHECK-LABEL: func @write_after_select_read_one -// CHECK-SAME: %[[t1:.*]]: memref, %[[t2:.*]]: memref +// CHECK-SAME: %[[t1:.*]]: memref, %[[t2:.*]]: memref func.func @write_after_select_read_one( %t1 : tensor {bufferization.writable = true}, %t2 : tensor {bufferization.writable = true}, diff --git a/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-alloc-tensor-elimination.mlir b/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-alloc-tensor-elimination.mlir --- a/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-alloc-tensor-elimination.mlir +++ b/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-alloc-tensor-elimination.mlir @@ -63,7 +63,7 @@ // ----- // CHECK: func @insertion_point_inside_loop( -// CHECK-SAME: %[[t:.*]]: memref, %[[sz:.*]]: index) +// CHECK-SAME: %[[t:.*]]: memref, %[[sz:.*]]: index) func.func @insertion_point_inside_loop(%t : tensor, %sz : index) -> (tensor) { %c0 = arith.constant 0 : index %c1 = arith.constant 1 : index @@ -92,7 +92,7 @@ // ----- // CHECK: func @insertion_point_outside_loop( -// CHECK-SAME: %[[t:.*]]: memref, %[[sz:.*]]: index, %[[idx:.*]]: index) +// CHECK-SAME: %[[t:.*]]: memref, %[[sz:.*]]: index, %[[idx:.*]]: index) func.func @insertion_point_outside_loop(%t : tensor, %sz : index, %idx : index) -> (tensor) { %c0 = arith.constant 0 : index diff --git a/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-partial.mlir b/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-partial.mlir --- a/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-partial.mlir +++ b/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-partial.mlir @@ -11,8 +11,6 @@ // RUN: mlir-opt %s -allow-unregistered-dialect -one-shot-bufferize="dialect-filter=tensor,bufferization allow-unknown-ops allow-return-allocs" -canonicalize -split-input-file | FileCheck %s --check-prefix=CHECK-TENSOR // RUN: mlir-opt %s -allow-unregistered-dialect -one-shot-bufferize="dialect-filter=scf,bufferization allow-unknown-ops allow-return-allocs" -canonicalize -split-input-file | FileCheck %s --check-prefix=CHECK-SCF -// CHECK: #[[$MAP:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @use_of_unknown_op_1( // CHECK-SAME: %[[t1:.*]]: tensor // CHECK-NO-LAYOUT-MAP-LABEL: func @use_of_unknown_op_1( @@ -27,8 +25,8 @@ %idx = arith.constant 0 : index %cst = arith.constant 0.0 : f32 - // CHECK: %[[dummy_memref:.*]] = bufferization.to_memref %[[dummy]] : memref - // CHECK: vector.transfer_read %[[dummy_memref]][%{{.*}}], %{{.*}} : memref + // CHECK: %[[dummy_memref:.*]] = bufferization.to_memref %[[dummy]] : memref> + // CHECK: vector.transfer_read %[[dummy_memref]][%{{.*}}], %{{.*}} : memref> // CHECK-NO-LAYOUT-MAP: %[[dummy_memref:.*]] = bufferization.to_memref %[[dummy]] : memref // CHECK-NO-LAYOUT-MAP: vector.transfer_read %[[dummy_memref]][%{{.*}}], %{{.*}} : memref %1 = vector.transfer_read %0[%idx], %cst : tensor, vector<5xf32> @@ -51,8 +49,6 @@ // ----- -// CHECK: #[[$MAP2:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @use_of_unknown_op_3( // CHECK-SAME: %[[t1:.*]]: tensor func.func @use_of_unknown_op_3(%t1: tensor) @@ -65,7 +61,7 @@ // CHECK: %[[dummy:.*]] = "test.dummy_op"(%[[t1]]) %0 = "test.dummy_op"(%t1) : (tensor) -> tensor - // CHECK: %[[dummy_memref:.*]] = bufferization.to_memref %[[dummy]] : memref + // CHECK: %[[dummy_memref:.*]] = bufferization.to_memref %[[dummy]] : memref> // CHECK: %[[v2:.*]] = vector.transfer_read %[[dummy_memref]] %2 = vector.transfer_read %0[%idx], %cst : tensor, vector<5xf32> @@ -207,7 +203,7 @@ func.func @simple_scf_if(%t1: tensor {bufferization.writable = true}, %c: i1, %pos: index, %f: f32) -> (tensor, index) { // CHECK-SCF: %[[t1_memref:.*]] = bufferization.to_memref %[[t1]] - // CHECK-SCF: %[[r:.*]] = scf.if %[[c]] -> (memref) { + // CHECK-SCF: %[[r:.*]] = scf.if %[[c]] -> (memref) { %r1, %r2 = scf.if %c -> (tensor, index) { // CHECK-SCF: scf.yield %[[t1_memref]] scf.yield %t1, %pos : tensor, index diff --git a/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize.mlir b/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize.mlir --- a/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize.mlir +++ b/mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize.mlir @@ -134,12 +134,12 @@ // CHECK-LABEL: func @select_different_tensors( // CHECK-SAME: %[[t:.*]]: tensor func.func @select_different_tensors(%t: tensor, %sz: index, %c: i1) -> tensor { - // CHECK-DAG: %[[m:.*]] = bufferization.to_memref %[[t]] : memref + // CHECK-DAG: %[[m:.*]] = bufferization.to_memref %[[t]] : memref // CHECK-DAG: %[[alloc:.*]] = memref.alloc(%{{.*}}) {{.*}} : memref %0 = bufferization.alloc_tensor(%sz) : tensor // A cast must be inserted because %t and %0 have different memref types. - // CHECK: %[[casted:.*]] = memref.cast %[[alloc]] : memref to memref + // CHECK: %[[casted:.*]] = memref.cast %[[alloc]] : memref to memref // CHECK: arith.select %{{.*}}, %[[casted]], %[[m]] %1 = arith.select %c, %0, %t : tensor return %1 : tensor diff --git a/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-out-params.mlir b/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-out-params.mlir --- a/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-out-params.mlir +++ b/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-out-params.mlir @@ -7,10 +7,9 @@ // Note: This bufferization is not very efficient yet, but it works. -// CHECK: #[[$map1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> // CHECK-LABEL: func @callee( -// CHECK-SAME: %[[arg0:.*]]: memref<5xf32, #[[$map1]]>, -// CHECK-SAME: %[[arg1:.*]]: memref<5xf32, #[[$map1]]>) { +// CHECK-SAME: %[[arg0:.*]]: memref<5xf32, strided<[?], offset: ?>>, +// CHECK-SAME: %[[arg1:.*]]: memref<5xf32, strided<[?], offset: ?>>) { // This alloc is not needed, but it is inserted due to the out-of-place // bufferization of the tensor.insert. With a better layering of the out param // promotion pass, this alloc could be avoided. @@ -32,9 +31,8 @@ // CHECK-NO-LAYOUT: memref.copy %[[alloc]], %[[arg1]] // CHECK-NO-LAYOUT: memref.dealloc %[[alloc]] -// CHECK-BASELINE: #[[$map1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> // CHECK-BASELINE-LABEL: func @callee( -// CHECK-BASELINE-SAME: %[[arg0:.*]]: memref<5xf32, #[[$map1]]>) -> memref<5xf32> { +// CHECK-BASELINE-SAME: %[[arg0:.*]]: memref<5xf32, strided<[?], offset: ?>>) -> memref<5xf32> { // CHECK-BASELINE: %[[alloc:.*]] = memref.alloc() {{.*}} : memref<5xf32> // CHECK-BASELINE: memref.copy %[[arg0]], %[[alloc]] // CHECK-BASELINE: memref.store {{.*}}, %[[alloc]] @@ -49,9 +47,9 @@ return %t, %1 : tensor<5xf32>, tensor<5xf32> } -// CHECK: func @main(%[[arg0:.*]]: memref<5xf32, #[[$map1]]>) -> (f32, f32) { +// CHECK: func @main(%[[arg0:.*]]: memref<5xf32, strided<[?], offset: ?>>) -> (f32, f32) { // CHECK: %[[alloc:.*]] = memref.alloc() : memref<5xf32> -// CHECK: %[[casted:.*]] = memref.cast %[[alloc]] : memref<5xf32> to memref<5xf32, #[[$map1]]> +// CHECK: %[[casted:.*]] = memref.cast %[[alloc]] : memref<5xf32> to memref<5xf32, strided<[?], offset: ?>> // CHECK: call @callee(%[[arg0]], %[[casted]]) // CHECK: %[[l1:.*]] = memref.load %[[arg0]] // CHECK: %[[l2:.*]] = memref.load %[[casted]] @@ -73,10 +71,9 @@ // ----- -// CHECK: #[[$map2a:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> // CHECK-LABEL: func @callee( // CHECK-SAME: %{{.*}}: index, -// CHECK-SAME: %[[r:.*]]: memref<2x5xf32, #[[$map2a]]>) { +// CHECK-SAME: %[[r:.*]]: memref<2x5xf32, strided<[?, ?], offset: ?>>) { // CHECK: %[[alloc:.*]] = memref.alloc() {{.*}} : memref<10x20xf32> // CHECK: %[[subview:.*]] = memref.subview %[[alloc]]{{.*}} : memref<10x20xf32> to memref<2x5xf32, strided<[20, 1], offset: ?>> // CHECK: %[[casted:.*]] = memref.cast %[[subview]] @@ -110,7 +107,7 @@ // CHECK: func @main( // CHECK: %[[alloc:.*]] = memref.alloc() : memref<2x5xf32> -// CHECK: %[[casted:.*]] = memref.cast %[[alloc]] : memref<2x5xf32> to memref<2x5xf32, #[[$map2a]]> +// CHECK: %[[casted:.*]] = memref.cast %[[alloc]] : memref<2x5xf32> to memref<2x5xf32, strided<[?, ?], offset: ?>> // CHECK: call @callee(%{{.*}}, %[[casted]]) // CHECK: memref.load %[[casted]] // CHECK: memref.dealloc %[[alloc]] diff --git a/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize.mlir b/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize.mlir --- a/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize.mlir +++ b/mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize.mlir @@ -15,15 +15,11 @@ // Bufferization of bodiless function with no tensor return value. -// CHECK: #[[$map0:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> -// CHECK: #[[$map1:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> -// CHECK-LABEL: func private @private_func(memref) +// CHECK-LABEL: func private @private_func(memref> // CHECK-NO-LAYOUT-MAP-LABEL: func private @private_func(memref) func.func private @private_func(tensor) -> () -// CHECK-LABEL: func private @private_func_2d(memref) +// CHECK-LABEL: func private @private_func_2d(memref> // CHECK-NO-LAYOUT-MAP-LABEL: func private @private_func_2d(memref) func.func private @private_func_2d(tensor) -> () @@ -38,10 +34,9 @@ // A bodiless function that returns something that is not a tensor. -// CHECK: func private @external_func_with_return_val(memref<4xi32, #{{.*}}>) -> f32 -// CHECK-FULLY-DYNAMIC-LAYOUT-MAP: #[[$map1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> +// CHECK: func private @external_func_with_return_val(memref<4xi32, strided{{.*}}>) -> f32 // CHECK-FULLY-DYNAMIC-LAYOUT-MAP-LABEL: func private @external_func_with_return_val(memref<4xi32, -// CHECK-FULLY-DYNAMIC-LAYOUT-MAP-SAME: #[[$map1]]> +// CHECK-FULLY-DYNAMIC-LAYOUT-MAP-SAME: strided<[?], offset: ?>> func.func private @external_func_with_return_val(tensor<4xi32>) -> f32 // ----- @@ -61,9 +56,8 @@ // CHECK-NO-LAYOUT-MAP: memref.dealloc %[[alloc]] // CHECK-NO-LAYOUT-MAP: return %[[alloc_no_layout]] -// CHECK-FULLY-DYNAMIC-LAYOUT-MAP: #[[$map2a:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> // CHECK-FULLY-DYNAMIC-LAYOUT-MAP-LABEL: func @return_extract_slice(%{{.*}}) -> memref<2x?xf32, -// CHECK-FULLY-DYNAMIC-LAYOUT-MAP-SAME: #[[$map2a]]> { +// CHECK-FULLY-DYNAMIC-LAYOUT-MAP-SAME: strided<[?, ?], offset: ?>> { func.func @return_extract_slice(%idx: index, %sz: index) -> (tensor<2x?xf32>) { %t = bufferization.alloc_tensor() : tensor<20x10xf32> @@ -270,10 +264,8 @@ // Alloc and copy must be inserted because the arith.constant is read-only. -// CHECK: #[[$DYN_1D_MAP:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK: memref.global "private" constant @__constant_4xi32 : memref<4xi32> = dense<[1, 2, 3, 4]> -// CHECK: func private @some_external_func(memref<4xi32, #[[$DYN_1D_MAP]]>) +// CHECK: func private @some_external_func(memref<4xi32, strided<[?], offset: ?>>) func.func private @some_external_func(tensor<4xi32>) // CHECK: func @main() @@ -282,9 +274,9 @@ %A = arith.constant dense<[1, 2, 3, 4]> : tensor<4xi32> // CHECK-DAG: %[[alloc:.*]] = memref.alloc -// CHECK-DAG: %[[B:.*]] = memref.cast %[[alloc]] : memref<4xi32> to memref<4xi32, #[[$DYN_1D_MAP]]> +// CHECK-DAG: %[[B:.*]] = memref.cast %[[alloc]] : memref<4xi32> to memref<4xi32, strided<[?], offset: ?>> // CHECK-DAG: memref.copy %[[A]], %[[alloc]] -// CHECK: call @some_external_func(%[[B]]) : (memref<4xi32, #[[$DYN_1D_MAP]]>) -> () +// CHECK: call @some_external_func(%[[B]]) : (memref<4xi32, strided<[?], offset: ?>>) -> () call @some_external_func(%A) : (tensor<4xi32>) -> () // CHECK: memref.dealloc %[[alloc]] @@ -296,10 +288,8 @@ // Alloc and copy must be inserted because the arith.constant is read-only. The // function call is inside of an scf.execute_region. -// CHECK: #[[$DYN_1D_MAP:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK: memref.global "private" constant @__constant_4xi32 : memref<4xi32> = dense<[1, 2, 3, 4]> -// CHECK: func private @some_external_func_within_scf_execute(memref<4xi32, #[[$DYN_1D_MAP]]>) +// CHECK: func private @some_external_func_within_scf_execute(memref<4xi32, strided<[?], offset: ?>>) func.func private @some_external_func_within_scf_execute(tensor<4xi32>) // CHECK: func @main() @@ -310,9 +300,9 @@ // Note: The scf.execute_region canonicalizes away. // CHECK-DAG: %[[alloc:.*]] = memref.alloc -// CHECK-DAG: %[[B:.*]] = memref.cast %[[alloc]] : memref<4xi32> to memref<4xi32, #[[$DYN_1D_MAP]]> +// CHECK-DAG: %[[B:.*]] = memref.cast %[[alloc]] : memref<4xi32> to memref<4xi32, strided<[?], offset: ?>> // CHECK-DAG: memref.copy %[[A]], %[[alloc]] -// CHECK: call @some_external_func_within_scf_execute(%[[B]]) : (memref<4xi32, #[[$DYN_1D_MAP]]>) -> () +// CHECK: call @some_external_func_within_scf_execute(%[[B]]) : (memref<4xi32, strided<[?], offset: ?>>) -> () scf.execute_region { func.call @some_external_func_within_scf_execute(%A) : (tensor<4xi32>) -> () scf.yield @@ -352,15 +342,13 @@ // ----- -// CHECK: #[[$DYN_1D_MAP:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - -// CHECK: func private @some_external_func(memref) +// CHECK: func private @some_external_func(memref>) func.func private @some_external_func(tensor) // CHECK: func @scf_for_with_tensor_insert_slice( -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref<4xf32, #[[$DYN_1D_MAP]]> +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>> func.func @scf_for_with_tensor_insert_slice( %A : tensor, %B : tensor, %C : tensor<4xf32>, %lb : index, %ub : index, %step : index) @@ -371,11 +359,11 @@ -> (tensor, tensor) { // CHECK-NEXT: %[[SVA:.*]] = memref.subview %[[A]] - // CHECK-NEXT: memref.copy %[[C]], %[[SVA]] : memref<4xf32, #[[$DYN_1D_MAP]]> to memref<4xf32, strided<[?], offset: ?>> + // CHECK-NEXT: memref.copy %[[C]], %[[SVA]] : memref<4xf32, strided<[?], offset: ?>> to memref<4xf32, strided<[?], offset: ?>> %ttA = tensor.insert_slice %C into %tA[%i][4][1] : tensor<4xf32> into tensor // CHECK-NEXT: %[[SVB:.*]] = memref.subview %[[B]] - // CHECK-NEXT: memref.copy %[[C]], %[[SVB]] : memref<4xf32, #[[$DYN_1D_MAP]]> to memref<4xf32, strided<[?], offset: ?>> + // CHECK-NEXT: memref.copy %[[C]], %[[SVB]] : memref<4xf32, strided<[?], offset: ?>> to memref<4xf32, strided<[?], offset: ?>> %ttB = tensor.insert_slice %C into %tB[%i][4][1] : tensor<4xf32> into tensor // scf.yield is empty and is elided @@ -388,9 +376,9 @@ } // CHECK: func @bar( -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref<4xf32, #[[$DYN_1D_MAP]]> +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>> func.func @bar( %A : tensor {bufferization.writable = true}, %B : tensor {bufferization.writable = true}, @@ -407,7 +395,7 @@ // CHECK-DAG: %[[alloc:.*]] = memref.alloc // CHECK-DAG: %[[casted:.*]] = memref.cast %[[alloc]] // CHECK-DAG: memref.copy %[[B]], %[[alloc]] -// CHECK-NEXT: call @some_external_func(%[[casted]]) : (memref) -> () +// CHECK-NEXT: call @some_external_func(%[[casted]]) : (memref>) -> () call @some_external_func(%r0#0) : (tensor) -> () // CHECK: return @@ -416,21 +404,18 @@ // ----- -// CHECK-DAG: #[[$DYN_0D_MAP:.*]] = affine_map<()[s0] -> (s0)> -// CHECK-DAG: #[[$DYN_1D_MAP:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK: func @init_and_dot( -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref<64xf32, #[[$DYN_1D_MAP]]> -// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref<64xf32, #[[$DYN_1D_MAP]]> -// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref<64xf32, strided<[?], offset: ?>> +// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref<64xf32, strided<[?], offset: ?>> +// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref> func.func @init_and_dot(%a: tensor<64xf32>, %b: tensor<64xf32>, %c: tensor) -> tensor { // CHECK-NEXT: %[[C0:.*]] = arith.constant 0{{.*}} : f32 %v0 = arith.constant 0.0 : f32 - // CHECK-NEXT: linalg.fill ins(%[[C0]] : f32) outs(%[[C]] : memref) + // CHECK-NEXT: linalg.fill ins(%[[C0]] : f32) outs(%[[C]] : memref>) %d = linalg.fill ins(%v0 : f32) outs(%c : tensor) -> tensor - // CHECK-NEXT: linalg.dot ins(%[[A]], %[[B]] : memref<64xf32, #[[$DYN_1D_MAP]]>, memref<64xf32, #[[$DYN_1D_MAP]]>) outs(%[[C]] : memref) + // CHECK-NEXT: linalg.dot ins(%[[A]], %[[B]] : memref<64xf32, strided<[?], offset: ?>>, memref<64xf32, strided<[?], offset: ?>>) outs(%[[C]] : memref>) %e = linalg.dot ins(%a, %b : tensor<64xf32>,tensor<64xf32>) outs(%d: tensor) -> tensor @@ -450,9 +435,9 @@ // CHECK-NEXT: %[[A:.*]] = memref.alloc() {alignment = 128 : i64} : memref<64xf32> // CHECK-NEXT: %[[B:.*]] = memref.alloc() {alignment = 128 : i64} : memref<64xf32> // CHECK-NEXT: %[[C:.*]] = memref.alloc() {alignment = 128 : i64} : memref - // CHECK-DAG: %[[cA:.*]] = memref.cast %[[A]] : memref<64xf32> to memref<64xf32, #[[$DYN_1D_MAP]]> - // CHECK-DAG: %[[cB:.*]] = memref.cast %[[B]] : memref<64xf32> to memref<64xf32, #[[$DYN_1D_MAP]]> - // CHECK-DAG: %[[cC:.*]] = memref.cast %[[C]] : memref to memref + // CHECK-DAG: %[[cA:.*]] = memref.cast %[[A]] : memref<64xf32> to memref<64xf32, strided<[?], offset: ?>> + // CHECK-DAG: %[[cB:.*]] = memref.cast %[[B]] : memref<64xf32> to memref<64xf32, strided<[?], offset: ?>> + // CHECK-DAG: %[[cC:.*]] = memref.cast %[[C]] : memref to memref> %A = bufferization.alloc_tensor() : tensor<64xf32> %B = bufferization.alloc_tensor() : tensor<64xf32> %C = bufferization.alloc_tensor() : tensor @@ -486,27 +471,25 @@ // ----- -// CHECK: #[[$DYNAMIC:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - -// CHECK: func private @external_func(memref) +// CHECK: func private @external_func(memref>) func.func private @external_func(tensor) // CHECK: func @callee( // CHECK-SAME: %[[A:[0-9a-zA-Z]*]]: memref -// CHECK-SAME: %[[B:[0-9a-zA-Z]*]]: memref -// CHECK-SAME: %[[C:[0-9a-zA-Z]*]]: memref +// CHECK-SAME: %[[B:[0-9a-zA-Z]*]]: memref> +// CHECK-SAME: %[[C:[0-9a-zA-Z]*]]: memref> func.func @callee( %A : tensor {bufferization.buffer_layout = affine_map<(i)[s0, s1] -> (i)>}, %B : tensor, %C : tensor) { -// CHECK-NEXT: %[[CASTED:.*]] = memref.cast %[[A]] : memref to memref -// CHECK-NEXT: call @external_func(%[[CASTED]]) : (memref) -> () +// CHECK-NEXT: %[[CASTED:.*]] = memref.cast %[[A]] : memref to memref> +// CHECK-NEXT: call @external_func(%[[CASTED]]) : (memref>) -> () call @external_func(%A) : (tensor) -> () -// CHECK-NEXT: call @external_func(%[[B]]) : (memref) -> () +// CHECK-NEXT: call @external_func(%[[B]]) : (memref>) -> () call @external_func(%B) : (tensor) -> () -// CHECK-NEXT: call @external_func(%[[C]]) : (memref) -> () +// CHECK-NEXT: call @external_func(%[[C]]) : (memref>) -> () call @external_func(%C) : (tensor) -> () return @@ -515,7 +498,7 @@ // CHECK: func @entry( // CHECK-SAME: %[[A:[0-9a-zA-Z]*]]: memref // CHECK-SAME: %[[B:[0-9a-zA-Z]*]]: memref -// CHECK-SAME: %[[C:[0-9a-zA-Z]*]]: memref +// CHECK-SAME: %[[C:[0-9a-zA-Z]*]]: memref> func.func @entry(%A : tensor {bufferization.buffer_layout = affine_map<(i)[s0, s1] -> (i)>, bufferization.writable = false}, %B : tensor {bufferization.buffer_layout = affine_map<(i)[s0, s1] -> (i)>, bufferization.writable = false}, %C : tensor {bufferization.writable = false}) { @@ -605,7 +588,7 @@ // Bufferize without fully dynamic layout maps. -// CHECK-LABEL: func @transfer_read(%{{.*}}: memref) -> vector<4xf32> { +// CHECK-LABEL: func @transfer_read(%{{.*}}: memref) -> vector<4xf32> { // CHECK-NO-LAYOUT-MAP-LABEL: func @transfer_read(%{{.*}}: memref) -> vector<4xf32> func.func @transfer_read( %A : tensor {bufferization.writable = false}) @@ -614,7 +597,7 @@ %c0 = arith.constant 0 : index %f0 = arith.constant 0.0 : f32 -// CHECK: %[[RES:.*]] = vector.transfer_read {{.*}} : memref, vector<4xf32> +// CHECK: %[[RES:.*]] = vector.transfer_read {{.*}} : memref, vector<4xf32> %0 = vector.transfer_read %A[%c0], %f0 : tensor, vector<4xf32> // CHECK: return %[[RES]] : vector<4xf32> diff --git a/mlir/test/Dialect/Linalg/one-shot-bufferize.mlir b/mlir/test/Dialect/Linalg/one-shot-bufferize.mlir --- a/mlir/test/Dialect/Linalg/one-shot-bufferize.mlir +++ b/mlir/test/Dialect/Linalg/one-shot-bufferize.mlir @@ -10,10 +10,8 @@ // TODO: Some test cases from this file should be moved to other dialects. -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @fill_inplace( -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> // CHECK-NO-LAYOUT-MAP-LABEL: func @fill_inplace(%{{.*}}: memref) { func.func @fill_inplace( %A : tensor {bufferization.writable = true}) @@ -24,7 +22,7 @@ /// Inplaceable, no alloc // CHECK-NOT: alloc - // CHECK: linalg.fill ins(%[[F0]] : f32) outs(%[[A]] : memref) + // CHECK: linalg.fill ins(%[[F0]] : f32) outs(%[[A]] : memref>) %r = linalg.fill ins(%f0 : f32) outs(%A : tensor) -> tensor // CHECK: return @@ -34,11 +32,9 @@ // ----- -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - /// No bufferization.writable flag, must allocate. // CHECK-LABEL: func @not_inplace( -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref) -> memref { +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref>) -> memref { // CHECK-NO-LAYOUT-MAP-LABEL: func @not_inplace(%{{.*}}: memref) -> memref func.func @not_inplace( %A : tensor {bufferization.writable = false}) @@ -47,7 +43,7 @@ // CHECK: %[[F0:.*]] = arith.constant 0.000000e+00 : f32 %f0 = arith.constant 0.0 : f32 - // CHECK: %[[D0:.*]] = memref.dim %[[A]], {{.*}} : memref + // CHECK: %[[D0:.*]] = memref.dim %[[A]], {{.*}} : memref> // CHECK: %[[ALLOC:.*]] = memref.alloc(%[[D0]]) {alignment = 128 : i64} : memref // CHECK: linalg.fill ins(%[[F0]] : f32) outs(%[[ALLOC]] : memref) %r = linalg.fill ins(%f0 : f32) outs(%A : tensor) -> tensor @@ -59,10 +55,9 @@ // ----- -// CHECK-DAG: #[[$map_2d_dyn:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> // CHECK-LABEL: func @not_inplace -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref) { +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref>) { // CHECK-NO-LAYOUT-MAP-LABEL: func @not_inplace(%{{.*}}: memref) { func.func @not_inplace( %A : tensor {bufferization.writable = true}) @@ -120,10 +115,8 @@ // ----- -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @vec_not_inplace -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> func.func @vec_not_inplace( %A : tensor {bufferization.writable = true}, %vec : vector<4xf32>) -> (tensor, tensor) @@ -280,7 +273,7 @@ // ----- // CHECK-LABEL: func @linalg_op_bufferizes_inplace_with_input -// CHECK-SAME: %[[t1:.*]]: memref, %[[t2:.*]]: memref, %[[t3:.*]]: memref +// CHECK-SAME: %[[t1:.*]]: memref, %[[t2:.*]]: memref, %[[t3:.*]]: memref func.func @linalg_op_bufferizes_inplace_with_input( %t1: tensor {bufferization.writable = true}, %t2: tensor {bufferization.writable = true}, diff --git a/mlir/test/Dialect/Linalg/standard.mlir b/mlir/test/Dialect/Linalg/standard.mlir --- a/mlir/test/Dialect/Linalg/standard.mlir +++ b/mlir/test/Dialect/Linalg/standard.mlir @@ -1,8 +1,5 @@ // RUN: mlir-opt %s -convert-linalg-to-std | FileCheck %s -// CHECK-DAG: #[[$map6:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> -// CHECK-DAG: #[[$map7:.*]] = affine_map<()[s0] -> (s0)> - func.func @dot(%arg0: memref>, %arg1: memref>, %arg2: memref) { @@ -16,14 +13,14 @@ // CHECK-SAME: %[[arg1:[a-zA-z0-9]*]]: memref>, // CHECK-SAME: %[[arg2:[a-zA-z0-9]*]]: memref) { // CHECK: %[[o0:.*]] = memref.cast %[[arg0]] : -// CHECK-SAME: memref> to memref +// CHECK-SAME: memref> to memref> // CHECK: %[[o1:.*]] = memref.cast %[[arg1]] : -// CHECK-SAME: memref> to memref +// CHECK-SAME: memref> to memref> // CHECK: %[[o2:.*]] = memref.cast %[[arg2]] : -// CHECK-SAME: memref to memref +// CHECK-SAME: memref to memref> // CHECK: call @linalg_dot_viewsxf32_viewsxf32_viewf32( // CHECK-SAME: %[[o0]], %[[o1]], %[[o2]]) : -// CHECK-SAME: memref, memref, memref +// CHECK-SAME: memref>, memref>, memref> #matmul_accesses = [ affine_map<(m, n, k) -> (m, k)>, diff --git a/mlir/test/Dialect/SCF/one-shot-bufferize.mlir b/mlir/test/Dialect/SCF/one-shot-bufferize.mlir --- a/mlir/test/Dialect/SCF/one-shot-bufferize.mlir +++ b/mlir/test/Dialect/SCF/one-shot-bufferize.mlir @@ -8,11 +8,9 @@ // Test bufferization using memref types that have no layout map. // RUN: mlir-opt %s -allow-unregistered-dialect -one-shot-bufferize="allow-return-allocs unknown-type-conversion=identity-layout-map function-boundary-type-conversion=identity-layout-map bufferize-function-boundaries" -buffer-deallocation -split-input-file -o /dev/null -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @scf_for_yield_only( -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref, -// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref>, +// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref> // CHECK-SAME: ) -> memref { func.func @scf_for_yield_only( %A : tensor {bufferization.writable = false}, @@ -62,12 +60,10 @@ // ----- -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @scf_for_with_tensor.insert_slice -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref<4xf32, #[[$map_1d_dyn]]> +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[B:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[C:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>> func.func @scf_for_with_tensor.insert_slice( %A : tensor {bufferization.writable = false}, %B : tensor {bufferization.writable = true}, @@ -292,7 +288,7 @@ // 2 allocs and 2 copies). // CHECK-LABEL: func @scf_for_swapping_yields( -// CHECK-SAME: %[[A:.*]]: memref, %[[B:.*]]: memref +// CHECK-SAME: %[[A:.*]]: memref, %[[B:.*]]: memref func.func @scf_for_swapping_yields( %A : tensor, %B : tensor {bufferization.writable = true}, %C : tensor<4xf32>, %lb : index, %ub : index, %step : index) @@ -341,7 +337,7 @@ // ----- // CHECK-LABEL: func @scf_while( -// CHECK-SAME: %[[arg0:.*]]: memref +// CHECK-SAME: %[[arg0:.*]]: memref func.func @scf_while(%arg0: tensor, %idx: index) -> tensor { // CHECK: scf.while : () -> () { %res:2 = scf.while (%arg1 = %arg0, %i = %idx) : @@ -371,7 +367,7 @@ // The loop condition yields non-equivalent buffers. // CHECK-LABEL: func @scf_while_non_equiv_condition( -// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}> +// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, strided{{.*}}>, %[[arg1:.*]]: memref<5xi1, strided{{.*}}> func.func @scf_while_non_equiv_condition(%arg0: tensor<5xi1>, %arg1: tensor<5xi1>, %idx: index) @@ -401,8 +397,8 @@ // CHECK: } do { // CHECK: ^bb0(%[[b0:.*]]: memref<5xi1>, %[[b1:.*]]: memref<5xi1>): // CHECK: memref.store %{{.*}}, %[[b0]] - // CHECK: %[[casted0:.*]] = memref.cast %[[b0]] : memref<5xi1> to memref<5xi1, #{{.*}}> - // CHECK: %[[casted1:.*]] = memref.cast %[[b1]] : memref<5xi1> to memref<5xi1, #{{.*}}> + // CHECK: %[[casted0:.*]] = memref.cast %[[b0]] : memref<5xi1> to memref<5xi1, strided{{.*}}> + // CHECK: %[[casted1:.*]] = memref.cast %[[b1]] : memref<5xi1> to memref<5xi1, strided{{.*}}> // CHECK: %[[cloned2:.*]] = bufferization.clone %[[casted1]] // CHECK: memref.dealloc %[[b1]] // CHECK: %[[cloned3:.*]] = bufferization.clone %[[casted0]] @@ -424,7 +420,7 @@ // Both the loop condition and the loop buffer yield non-equivalent buffers. // CHECK-LABEL: func @scf_while_non_equiv_condition_and_body( -// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}> +// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, strided{{.*}}>, %[[arg1:.*]]: memref<5xi1, strided{{.*}}> func.func @scf_while_non_equiv_condition_and_body(%arg0: tensor<5xi1>, %arg1: tensor<5xi1>, %idx: index) @@ -475,9 +471,9 @@ // ----- // CHECK-LABEL: func @scf_while_iter_arg_result_mismatch( -// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}> +// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, strided{{.*}}>, %[[arg1:.*]]: memref<5xi1, strided{{.*}}> // CHECK: %[[clone:.*]] = bufferization.clone %[[arg1]] -// CHECK: scf.while (%[[arg3:.*]] = %[[clone]]) : (memref<5xi1, #{{.*}}) -> () { +// CHECK: scf.while (%[[arg3:.*]] = %[[clone]]) : (memref<5xi1, strided{{.*}}) -> () { // CHECK-DAG: memref.dealloc %[[arg3]] // CHECK-DAG: %[[load:.*]] = memref.load %[[arg0]] // CHECK: scf.condition(%[[load]]) @@ -485,7 +481,7 @@ // CHECK: %[[alloc2:.*]] = memref.alloc() {{.*}} : memref<5xi1> // CHECK: memref.copy %[[arg0]], %[[alloc2]] // CHECK: memref.store %{{.*}}, %[[alloc2]] -// CHECK: %[[casted:.*]] = memref.cast %[[alloc2]] : memref<5xi1> to memref<5xi1, #{{.*}}> +// CHECK: %[[casted:.*]] = memref.cast %[[alloc2]] : memref<5xi1> to memref<5xi1, strided{{.*}}> // CHECK: %[[cloned:.*]] = bufferization.clone %[[casted]] // CHECK: memref.dealloc %[[alloc2]] // CHECK: scf.yield %[[cloned]] @@ -509,8 +505,8 @@ // CHECK-LABEL: func.func @parallel_insert_slice_no_conflict( // CHECK-SAME: %[[idx:.*]]: index, %[[idx2:.*]]: index, -// CHECK-SAME: %[[arg1:.*]]: memref, -// CHECK-SAME: %[[arg2:.*]]: memref +// CHECK-SAME: %[[arg1:.*]]: memref, +// CHECK-SAME: %[[arg2:.*]]: memref func.func @parallel_insert_slice_no_conflict( %idx: index, %idx2: index, @@ -549,8 +545,8 @@ // CHECK-LABEL: func.func @parallel_insert_slice_with_conflict( // CHECK-SAME: %[[idx:.*]]: index, %[[idx2:.*]]: index, -// CHECK-SAME: %[[arg1:.*]]: memref, -// CHECK-SAME: %[[arg2:.*]]: memref +// CHECK-SAME: %[[arg1:.*]]: memref, +// CHECK-SAME: %[[arg2:.*]]: memref func.func @parallel_insert_slice_with_conflict( %idx: index, %idx2: index, diff --git a/mlir/test/Dialect/Tensor/one-shot-bufferize.mlir b/mlir/test/Dialect/Tensor/one-shot-bufferize.mlir --- a/mlir/test/Dialect/Tensor/one-shot-bufferize.mlir +++ b/mlir/test/Dialect/Tensor/one-shot-bufferize.mlir @@ -8,13 +8,11 @@ // Test bufferization using memref types that have no layout map. // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs unknown-type-conversion=identity-layout-map bufferize-function-boundaries" -split-input-file -o /dev/null -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @insert_slice_fun -// CHECK-SAME: %[[A0:[a-zA-Z0-9]*]]: memref, -// CHECK-SAME: %[[A1:[a-zA-Z0-9]*]]: memref, -// CHECK-SAME: %[[t0:[a-zA-Z0-9]*]]: memref<4xf32, #[[$map_1d_dyn]]>, -// CHECK-SAME: %[[t1:[a-zA-Z0-9]*]]: memref<4xf32, #[[$map_1d_dyn]]> +// CHECK-SAME: %[[A0:[a-zA-Z0-9]*]]: memref>, +// CHECK-SAME: %[[A1:[a-zA-Z0-9]*]]: memref>, +// CHECK-SAME: %[[t0:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>>, +// CHECK-SAME: %[[t1:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>> func.func @insert_slice_fun( %A0 : tensor {bufferization.writable = false}, %A1 : tensor {bufferization.writable = true}, @@ -56,11 +54,9 @@ // ----- -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @insert_slice_fun -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref<4xf32, #[[$map_1d_dyn]]> +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>> func.func @insert_slice_fun( %A : tensor {bufferization.writable = true}, %t : tensor<4xf32> {bufferization.writable = false}) @@ -84,11 +80,9 @@ // ----- -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @insert_slice_fun -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref<4xf32, #[[$map_1d_dyn]]> +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>> func.func @insert_slice_fun( %A : tensor {bufferization.writable = true}, %t : tensor<4xf32> {bufferization.writable = false}) @@ -112,11 +106,9 @@ // ----- -// CHECK-DAG: #[[$map_1d_dyn:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> - // CHECK-LABEL: func @insert_slice_fun_not_inplace -// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref -// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref<4xf32, #[[$map_1d_dyn]]> +// CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref> +// CHECK-SAME: %[[t:[a-zA-Z0-9]*]]: memref<4xf32, strided<[?], offset: ?>> func.func @insert_slice_fun_not_inplace( %A : tensor {bufferization.writable = false}, %t : tensor<4xf32> {bufferization.writable = false}) @@ -125,7 +117,7 @@ // CHECK: %[[ALLOC:.*]] = memref.alloc(%{{.*}}) {alignment = 128 : i64} : memref // CHECK: memref.copy %[[A]], %[[ALLOC]] : memref // CHECK: %[[SV:.*]] = memref.subview %[[ALLOC]][0] [4] [1] : memref to memref<4xf32, strided<[1]>> - // CHECK: memref.copy %[[t]], %[[SV]] : memref<4xf32, #map> to memref<4xf32, strided<[1]>> + // CHECK: memref.copy %[[t]], %[[SV]] : memref<4xf32, strided{{.*}}> to memref<4xf32, strided<[1]>> %r0 = tensor.insert_slice %t into %A[0][4][1] : tensor<4xf32> into tensor // CHECK: return %{{.*}} : memref @@ -196,9 +188,6 @@ // ----- -// CHECK: #[[$MAP0:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)> -// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)> - // CHECK-LABEL: func.func @rank_reducing_parallel_insert_slice func.func @rank_reducing_parallel_insert_slice(%in: tensor<100xf32>, %out: tensor<200x100xf32>) { %c1 = arith.constant 1 : index @@ -208,8 +197,8 @@ %result = scf.foreach_thread (%thread_idx) in (%num_threads) shared_outs (%o = %out) -> tensor<200x100xf32> { %1 = tensor.extract_slice %in[%thread_idx][1][1] : tensor<100xf32> to tensor<1xf32> scf.foreach_thread.perform_concurrently { - // CHECK: memref.subview %{{.*}}[%{{.*}}] [1] [1] : memref<100xf32, #[[$MAP0]]> to memref<1xf32, strided<[?], offset: ?>> - // CHECK: memref.subview %{{.*}}[1, %{{.*}}] [1, 1] [1, 1] : memref<200x100xf32, #[[$MAP1]]> to memref<1xf32, strided<[?], offset: ?>> + // CHECK: memref.subview %{{.*}}[%{{.*}}] [1] [1] : memref<100xf32, strided<[?], offset: ?>> to memref<1xf32, strided<[?], offset: ?>> + // CHECK: memref.subview %{{.*}}[1, %{{.*}}] [1, 1] [1, 1] : memref<200x100xf32, strided<[?, ?], offset: ?>> to memref<1xf32, strided<[?], offset: ?>> tensor.parallel_insert_slice %1 into %o[1, %thread_idx][1, 1][1, 1] : tensor<1xf32> into tensor<200x100xf32> } diff --git a/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir b/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir --- a/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir +++ b/mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir @@ -3,11 +3,9 @@ // CHECK-DAG: #[[$map_p4:.*]] = affine_map<()[s0] -> (s0 + 4)> // CHECK-DAG: #[[$map_p8:.*]] = affine_map<()[s0] -> (s0 + 8)> -// CHECK-DAG: #[[$map_2d_stride_1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> // LINALG-DAG: #[[$map_p4:.*]] = affine_map<()[s0] -> (s0 + 4)> // LINALG-DAG: #[[$map_p8:.*]] = affine_map<()[s0] -> (s0 + 8)> -// LINALG-DAG: #[[$map_2d_stride_1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> // LINALG-DAG: #[[$bounds_map_4:.*]] = affine_map<(d0, d1, d2) -> (d0 - d1, 4)> // LINALG-DAG: #[[$bounds_map_8:.*]] = affine_map<(d0, d1, d2) -> (d0 - d1, 8)> @@ -123,12 +121,12 @@ // CHECK: %[[cmp1:.*]] = arith.cmpi sle, %[[idx1]], %[[c8]] : index // are both conds true // CHECK: %[[cond:.*]] = arith.andi %[[cmp0]], %[[cmp1]] : i1 - // CHECK: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref, index, index) { + // CHECK: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref>, index, index) { // inBounds but not cast-compatible: yield a memref_casted form of %A // CHECK: %[[casted:.*]] = memref.cast %arg0 : - // CHECK-SAME: memref<7x8xf32, strided<[?, 1], offset: ?>> to memref + // CHECK-SAME: memref<7x8xf32, strided<[?, 1], offset: ?>> to memref> // CHECK: scf.yield %[[casted]], %[[i]], %[[j]] : - // CHECK-SAME: memref, index, index + // CHECK-SAME: memref>, index, index // CHECK: } else { // slow path, fill tmp alloc and yield a memref_casted version of it // CHECK: %[[slow:.*]] = vector.transfer_read %[[A]][%[[i]], %[[j]]], %cst : @@ -138,12 +136,12 @@ // CHECK: store %[[slow]], %[[cast_alloc]][] : // CHECK-SAME: memref> // CHECK: %[[yielded:.*]] = memref.cast %[[alloc]] : - // CHECK-SAME: memref<4x8xf32> to memref + // CHECK-SAME: memref<4x8xf32> to memref> // CHECK: scf.yield %[[yielded]], %[[c0]], %[[c0]] : - // CHECK-SAME: memref, index, index + // CHECK-SAME: memref>, index, index // CHECK: } // CHECK: %[[res:.*]] = vector.transfer_read {{.*}} {in_bounds = [true, true]} : - // CHECK-SAME: memref, vector<4x8xf32> + // CHECK-SAME: memref>, vector<4x8xf32> // LINALG-DAG: %[[c0:.*]] = arith.constant 0 : index // LINALG-DAG: %[[c4:.*]] = arith.constant 4 : index @@ -159,12 +157,12 @@ // LINALG: %[[cmp1:.*]] = arith.cmpi sle, %[[idx1]], %[[c8]] : index // are both conds true // LINALG: %[[cond:.*]] = arith.andi %[[cmp0]], %[[cmp1]] : i1 - // LINALG: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref, index, index) { + // LINALG: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref>, index, index) { // inBounds but not cast-compatible: yield a memref_casted form of %A // LINALG: %[[casted:.*]] = memref.cast %arg0 : - // LINALG-SAME: memref<7x8xf32, strided<[?, 1], offset: ?>> to memref + // LINALG-SAME: memref<7x8xf32, strided<[?, 1], offset: ?>> to memref> // LINALG: scf.yield %[[casted]], %[[i]], %[[j]] : - // LINALG-SAME: memref, index, index + // LINALG-SAME: memref>, index, index // LINALG: } else { // slow path, fill tmp alloc and yield a memref_casted version of it // LINALG: linalg.fill ins(%cst : f32) outs(%[[alloc]] : memref<4x8xf32>) @@ -175,12 +173,12 @@ // LINALG: %[[alloc_view:.*]] = memref.subview %[[alloc]][0, 0] [%[[sv0]], %[[sv1]]] [1, 1] // LINALG: memref.copy %[[sv]], %[[alloc_view]] : memref> to memref // LINALG: %[[yielded:.*]] = memref.cast %[[alloc]] : - // LINALG-SAME: memref<4x8xf32> to memref + // LINALG-SAME: memref<4x8xf32> to memref> // LINALG: scf.yield %[[yielded]], %[[c0]], %[[c0]] : - // LINALG-SAME: memref, index, index + // LINALG-SAME: memref>, index, index // LINALG: } // LINALG: %[[res:.*]] = vector.transfer_read {{.*}} {in_bounds = [true, true]} : - // LINALG-SAME: memref, vector<4x8xf32> + // LINALG-SAME: memref>, vector<4x8xf32> %1 = vector.transfer_read %A[%i, %j], %f0 : memref<7x8xf32, strided<[?, 1], offset: ?>>, vector<4x8xf32> @@ -293,7 +291,6 @@ return } -// CHECK-DAG: #[[MAP0:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> // CHECK-DAG: #[[MAP1:.*]] = affine_map<()[s0] -> (s0 + 4)> // CHECK-DAG: #[[MAP2:.*]] = affine_map<()[s0] -> (s0 + 8)> // CHECK: func @split_vector_transfer_write_strided_2d( @@ -312,21 +309,21 @@ // CHECK: %[[DIM1_IN:.*]] = arith.cmpi sle, %[[DIM1]], %[[C8]] : index // CHECK: %[[IN_BOUNDS:.*]] = arith.andi %[[DIM0_IN]], %[[DIM1_IN]] : i1 // CHECK: %[[IN_BOUND_DEST:.*]]:3 = scf.if %[[IN_BOUNDS]] -// CHECK-SAME: -> (memref, index, index) { +// CHECK-SAME: -> (memref>, index, index) { // CHECK: %[[VAL_15:.*]] = memref.cast %[[DEST]] -// CHECK-SAME: : memref<7x8xf32, strided<[?, 1], offset: ?>> to memref +// CHECK-SAME: : memref<7x8xf32, strided<[?, 1], offset: ?>> to memref> // CHECK: scf.yield %[[VAL_15]], %[[I]], %[[J]] -// CHECK-SAME: : memref, index, index +// CHECK-SAME: : memref>, index, index // CHECK: } else { // CHECK: %[[VAL_16:.*]] = memref.cast %[[TEMP]] -// CHECK-SAME: : memref<4x8xf32> to memref +// CHECK-SAME: : memref<4x8xf32> to memref> // CHECK: scf.yield %[[VAL_16]], %[[C0]], %[[C0]] -// CHECK-SAME: : memref, index, index +// CHECK-SAME: : memref>, index, index // CHECK: } // CHECK: vector.transfer_write %[[VEC]], // CHECK-SAME: %[[IN_BOUND_DEST:.*]]#0 // CHECK-SAME: [%[[IN_BOUND_DEST]]#1, %[[IN_BOUND_DEST]]#2] -// CHECK-SAME: {in_bounds = [true, true]} : vector<4x8xf32>, memref +// CHECK-SAME: {in_bounds = [true, true]} : vector<4x8xf32>, memref> // CHECK: %[[OUT_BOUNDS:.*]] = arith.xori %[[IN_BOUNDS]], %[[CT]] : i1 // CHECK: scf.if %[[OUT_BOUNDS]] { // CHECK: %[[VAL_19:.*]] = vector.type_cast %[[TEMP]] @@ -339,7 +336,6 @@ // CHECK: return // CHECK: } -// LINALG-DAG: #[[MAP0:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> // LINALG-DAG: #[[MAP1:.*]] = affine_map<()[s0] -> (s0 + 4)> // LINALG-DAG: #[[MAP2:.*]] = affine_map<()[s0] -> (s0 + 8)> // LINALG-DAG: #[[MAP3:.*]] = affine_map<(d0, d1, d2) -> (d0 - d1, 4)> @@ -361,22 +357,22 @@ // LINALG: %[[DIM1_IN:.*]] = arith.cmpi sle, %[[DIM1]], %[[C8]] : index // LINALG: %[[IN_BOUNDS:.*]] = arith.andi %[[DIM0_IN]], %[[DIM1_IN]] : i1 // LINALG: %[[IN_BOUND_DEST:.*]]:3 = scf.if %[[IN_BOUNDS]] -// LINALG-SAME: -> (memref, index, index) { +// LINALG-SAME: -> (memref>, index, index) { // LINALG: %[[VAL_16:.*]] = memref.cast %[[DEST]] -// LINALG-SAME: : memref<7x8xf32, strided<[?, 1], offset: ?>> to memref +// LINALG-SAME: : memref<7x8xf32, strided<[?, 1], offset: ?>> to memref> // LINALG: scf.yield %[[VAL_16]], %[[I]], %[[J]] -// LINALG-SAME: : memref, index, index +// LINALG-SAME: : memref>, index, index // LINALG: } else { // LINALG: %[[VAL_17:.*]] = memref.cast %[[TEMP]] -// LINALG-SAME: : memref<4x8xf32> to memref +// LINALG-SAME: : memref<4x8xf32> to memref> // LINALG: scf.yield %[[VAL_17]], %[[C0]], %[[C0]] -// LINALG-SAME: : memref, index, index +// LINALG-SAME: : memref>, index, index // LINALG: } // LINALG: vector.transfer_write %[[VEC]], // LINALG-SAME: %[[IN_BOUND_DEST:.*]]#0 // LINALG-SAME: [%[[IN_BOUND_DEST]]#1, %[[IN_BOUND_DEST]]#2] // LINALG-SAME: {in_bounds = [true, true]} -// LINALG-SAME: : vector<4x8xf32>, memref +// LINALG-SAME: : vector<4x8xf32>, memref> // LINALG: %[[OUT_BOUNDS:.*]] = arith.xori %[[IN_BOUNDS]], %[[CT]] : i1 // LINALG: scf.if %[[OUT_BOUNDS]] { // LINALG-DAG: %[[VAL_20:.*]] = affine.min #[[MAP3]](%[[C7]], %[[I]], %[[C4]])