From 8ff2c969bbccf8fb60ac039844b6696a60ec4e5a Mon Sep 17 00:00:00 2001 From: Andrzej Warzynski Date: Sun, 16 Jun 2024 13:44:12 +0100 Subject: [PATCH 1/4] [mlir][vector] Refactor vector-transfer-flatten.mlir (nfc) (3/n) The main goal of this and subsequent PRs is to unify and categorize tests in: * vector-transfer-flatten.mlir This should make it easier to identify the edge cases being tested (and how they differ), remove duplicates and to add tests for scalable vectors. The main contributions of this PR: 1. Refactor `@transfer_read_flattenable_with_dynamic_dims_and_indices`, i.e. move it near other tests for xfer_read, unify variable names to match other xfer_read tests, highlight what makes this a positive test to better contrast it with `@transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim` 2. Similar changes for `@transfer_write_flattenable_with_dynamic_dims_and_indices`. Depends on https://github.com/llvm/llvm-project/pull/95743 and https://github.com/llvm/llvm-project/pull/95744 **Only review the top top commit** --- .../Vector/vector-transfer-flatten.mlir | 124 ++++++++++-------- 1 file changed, 70 insertions(+), 54 deletions(-) diff --git a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir index 303f841e8a828..3ffc189b097ba 100644 --- a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir +++ b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir @@ -131,10 +131,42 @@ func.func @transfer_read_dims_mismatch_non_contiguous_non_zero_indices( // ----- +/// The leading dynamic shapes don't affect whether this example is flattenable +/// or not as those dynamic shapes are not candidates for flattening anyway. + +func.func @transfer_read_leading_dynamic_dims( + %arg : memref>, + %idx_1 : index, + %idx_2 : index) -> vector<8x4xi8> { + + %c0_i8 = arith.constant 0 : i8 + %c0 = arith.constant 0 : index + %result = vector.transfer_read %arg[%idx_1, %idx_2, %c0, %c0], %c0_i8 {in_bounds = [true, true]} : memref>, vector<8x4xi8> + return %result : vector<8x4xi8> +} + +// CHECK-LABEL: func @transfer_read_leading_dynamic_dims +// CHECK-SAME: %[[ARG0:.+]]: memref, %[[ARG1:.+]]: index, %[[ARG2:.+]]: index +// CHECK: %[[C0_I8:.+]] = arith.constant 0 : i8 +// CHECK: %[[C0:.+]] = arith.constant 0 : index +// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG0]] {{\[}}[0], [1], [2, 3]{{\]}} +// CHECK-SAME: : memref into memref +// CHECK: %[[VEC1D:.+]] = vector.transfer_read %[[COLLAPSED]] +// CHECK-SAME: [%[[ARG1]], %[[ARG2]], %[[C0]]], %[[C0_I8]] +// CHECK-SAME: {in_bounds = [true]} +// CHECK-SAME: : memref, vector<32xi8> +// CHECK: %[[VEC2D:.+]] = vector.shape_cast %[[VEC1D]] : vector<32xi8> to vector<8x4xi8> +// CHECK: return %[[VEC2D]] : vector<8x4xi8> + +// CHECK-128B-LABEL: func @transfer_read_leading_dynamic_dims +// CHECK-128B: memref.collapse_shape + +// ----- + // The input memref has a dynamic trailing shape and hence is not flattened. // TODO: This case could be supported via memref.dim -func.func @transfer_read_dims_mismatch_non_zero_indices_dynamic_shapes( +func.func @transfer_read_dims_mismatch_non_zero_indices_trailing_dynamic_dim( %idx_1: index, %idx_2: index, %m_in: memref<1x?x4x6xi32>) -> vector<1x2x6xi32> { @@ -146,11 +178,11 @@ func.func @transfer_read_dims_mismatch_non_zero_indices_dynamic_shapes( return %v : vector<1x2x6xi32> } -// CHECK-LABEL: func.func @transfer_read_dims_mismatch_non_zero_indices_dynamic_shapes( +// CHECK-LABEL: func.func @transfer_read_dims_mismatch_non_zero_indices_trailing_dynamic_dim // CHECK-NOT: memref.collapse_shape // CHECK-NOT: vector.shape_cast -// CHECK-128B-LABEL: func @transfer_read_dims_mismatch_non_zero_indices_dynamic_shapes( +// CHECK-128B-LABEL: func @transfer_read_dims_mismatch_non_zero_indices_trailing_dynamic_dim // CHECK-128B-NOT: memref.collapse_shape // ----- @@ -345,10 +377,40 @@ func.func @transfer_write_dims_mismatch_non_contiguous_non_zero_indices( // ----- +// The leading dynamic shapes don't affect whether this example is flattenable +// or not as those dynamic shapes are not candidates for flattening anyway. + +func.func @transfer_write_leading_dynamic_dims( + %vec : vector<8x4xi8>, + %arg : memref>, + %idx_1 : index, + %idx_2 : index) { + + %c0 = arith.constant 0 : index + vector.transfer_write %vec, %arg[%idx_1, %idx_2, %c0, %c0] {in_bounds = [true, true]} : vector<8x4xi8>, memref> + return +} + +// CHECK-LABEL: func @transfer_write_leading_dynamic_dims +// CHECK-SAME: %[[ARG0:.+]]: vector<8x4xi8>, %[[ARG1:.+]]: memref, %[[ARG2:.+]]: index, %[[ARG3:.+]]: index +// CHECK: %[[C0:.+]] = arith.constant 0 : index +// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG1]] {{\[}}[0], [1], [2, 3]{{\]}} +// CHECK-SAME: : memref into memref +// CHECK: %[[VEC1D:.+]] = vector.shape_cast %[[ARG0]] : vector<8x4xi8> to vector<32xi8> +// CHECK: vector.transfer_write %[[VEC1D]], %[[COLLAPSED]] +// CHECK-SAME: [%[[ARG2]], %[[ARG3]], %[[C0]]] +// CHECK-SAME: {in_bounds = [true]} +// CHECK-SAME: : vector<32xi8>, memref + +// CHECK-128B-LABEL: func @transfer_write_leading_dynamic_dims +// CHECK-128B: memref.collapse_shape + +// ----- + // The input memref has a dynamic trailing shape and hence is not flattened. // TODO: This case could be supported via memref.dim -func.func @transfer_write_dims_mismatch_non_zero_indices_dynamic_shapes( +func.func @transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim( %idx_1: index, %idx_2: index, %vec : vector<1x2x6xi32>, @@ -361,11 +423,11 @@ func.func @transfer_write_dims_mismatch_non_zero_indices_dynamic_shapes( return } -// CHECK-LABEL: func.func @transfer_write_dims_mismatch_non_zero_indices_dynamic_shapes( +// CHECK-LABEL: func.func @transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim( // CHECK-NOT: memref.collapse_shape // CHECK-NOT: vector.shape_cast -// CHECK-128B-LABEL: func @transfer_write_dims_mismatch_non_zero_indices_dynamic_shapes( +// CHECK-128B-LABEL: func @transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim( // CHECK-128B-NOT: memref.collapse_shape // ----- @@ -434,56 +496,10 @@ func.func @transfer_write_non_contiguous_src( // ----- ///---------------------------------------------------------------------------------------- -/// TODO: Categorize + re-format +/// [Pattern: DropUnitDimFromElementwiseOps] +/// TODO: Move to a dedicated file - there's no "flattening" in the following tests ///---------------------------------------------------------------------------------------- -func.func @transfer_read_flattenable_with_dynamic_dims_and_indices(%arg0 : memref>, %arg1 : index, %arg2 : index) -> vector<8x4xi8> { - %c0_i8 = arith.constant 0 : i8 - %c0 = arith.constant 0 : index - %result = vector.transfer_read %arg0[%arg1, %arg2, %c0, %c0], %c0_i8 {in_bounds = [true, true]} : memref>, vector<8x4xi8> - return %result : vector<8x4xi8> -} - -// CHECK-LABEL: func @transfer_read_flattenable_with_dynamic_dims_and_indices -// CHECK-SAME: %[[ARG0:.+]]: memref, %[[ARG1:.+]]: index, %[[ARG2:.+]]: index -// CHECK: %[[C0_I8:.+]] = arith.constant 0 : i8 -// CHECK: %[[C0:.+]] = arith.constant 0 : index -// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG0]] {{\[}}[0], [1], [2, 3]{{\]}} -// CHECK-SAME: : memref into memref -// CHECK: %[[VEC1D:.+]] = vector.transfer_read %[[COLLAPSED]] -// CHECK-SAME: [%[[ARG1]], %[[ARG2]], %[[C0]]], %[[C0_I8]] -// CHECK-SAME: {in_bounds = [true]} -// CHECK-SAME: : memref, vector<32xi8> -// CHECK: %[[VEC2D:.+]] = vector.shape_cast %[[VEC1D]] : vector<32xi8> to vector<8x4xi8> -// CHECK: return %[[VEC2D]] : vector<8x4xi8> - -// CHECK-128B-LABEL: func @transfer_read_flattenable_with_dynamic_dims_and_indices( -// CHECK-128B: memref.collapse_shape - -// ----- - -func.func @transfer_write_flattenable_with_dynamic_dims_and_indices(%vec : vector<8x4xi8>, %dst : memref>, %arg1 : index, %arg2 : index) { - %c0 = arith.constant 0 : index - vector.transfer_write %vec, %dst[%arg1, %arg2, %c0, %c0] {in_bounds = [true, true]} : vector<8x4xi8>, memref> - return -} - -// CHECK-LABEL: func @transfer_write_flattenable_with_dynamic_dims_and_indices -// CHECK-SAME: %[[ARG0:.+]]: vector<8x4xi8>, %[[ARG1:.+]]: memref, %[[ARG2:.+]]: index, %[[ARG3:.+]]: index -// CHECK: %[[C0:.+]] = arith.constant 0 : index -// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG1]] {{\[}}[0], [1], [2, 3]{{\]}} -// CHECK-SAME: : memref into memref -// CHECK: %[[VEC1D:.+]] = vector.shape_cast %[[ARG0]] : vector<8x4xi8> to vector<32xi8> -// CHECK: vector.transfer_write %[[VEC1D]], %[[COLLAPSED]] -// CHECK-SAME: [%[[ARG2]], %[[ARG3]], %[[C0]]] -// CHECK-SAME: {in_bounds = [true]} -// CHECK-SAME: : vector<32xi8>, memref - -// CHECK-128B-LABEL: func @transfer_write_flattenable_with_dynamic_dims_and_indices( -// CHECK-128B: memref.collapse_shape - -// ----- - func.func @fold_unit_dim_add_basic(%arg0 : vector<1x8xi32>) -> vector<1x8xi32> { %add = arith.addi %arg0, %arg0 : vector<1x8xi32> return %add : vector<1x8xi32> From dc73f1a5c904848370f1cbd3e71c1947f93a121c Mon Sep 17 00:00:00 2001 From: Andrzej Warzynski Date: Fri, 21 Jun 2024 13:04:00 +0100 Subject: [PATCH 2/4] fixup! [mlir][vector] Refactor vector-transfer-flatten.mlir (nfc) (3/n) Minor updates - addressing PR comments --- .../Dialect/Vector/vector-transfer-flatten.mlir | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir index 3ffc189b097ba..a0a1fc39fcaca 100644 --- a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir +++ b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir @@ -110,12 +110,12 @@ func.func @transfer_read_dims_mismatch_non_zero_indices( func.func @transfer_read_dims_mismatch_non_contiguous_non_zero_indices( %arg : memref<1x3x3x2xf32, strided<[40, 10, 2, 1], offset: ?>>, - %idx0 : index, - %idx1 : index) -> vector<2x2xf32> { + %idx_1 : index, + %idx_2 : index) -> vector<2x2xf32> { %c0 = arith.constant 0 : index %cst_1 = arith.constant 0.000000e+00 : f32 - %8 = vector.transfer_read %arg[%c0, %idx0, %idx1, %c0], %cst_1 {in_bounds = [true, true]} : + %8 = vector.transfer_read %arg[%c0, %idx_1, %idx_2, %c0], %cst_1 {in_bounds = [true, true]} : memref<1x3x3x2xf32, strided<[40, 10, 2, 1], offset: ?>>, vector<2x2xf32> return %8 : vector<2x2xf32> } @@ -358,11 +358,11 @@ func.func @transfer_write_dims_mismatch_non_zero_indices( func.func @transfer_write_dims_mismatch_non_contiguous_non_zero_indices( %value : vector<2x2xf32>, %subview : memref<1x3x3x2xf32, strided<[40, 10, 2, 1], offset: ?>>, - %idx0 : index, - %idx1 : index) { + %idx_1 : index, + %idx_2 : index) { %c0 = arith.constant 0 : index - vector.transfer_write %value, %subview[%c0, %idx0, %idx1, %c0] {in_bounds = [true, true]} : vector<2x2xf32>, memref<1x3x3x2xf32, strided<[40, 10, 2, 1], offset: ?>> + vector.transfer_write %value, %subview[%c0, %idx_1, %idx_2, %c0] {in_bounds = [true, true]} : vector<2x2xf32>, memref<1x3x3x2xf32, strided<[40, 10, 2, 1], offset: ?>> return } @@ -392,7 +392,7 @@ func.func @transfer_write_leading_dynamic_dims( } // CHECK-LABEL: func @transfer_write_leading_dynamic_dims -// CHECK-SAME: %[[ARG0:.+]]: vector<8x4xi8>, %[[ARG1:.+]]: memref, %[[ARG2:.+]]: index, %[[ARG3:.+]]: index +// CHECK-SAME: %[[ARG0:.+]]: vector<8x4xi8>, %[[ARG1:.+]]: memref, %[[ARG2:.+]]: index, %[[ARG3:.+]]: index // CHECK: %[[C0:.+]] = arith.constant 0 : index // CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG1]] {{\[}}[0], [1], [2, 3]{{\]}} // CHECK-SAME: : memref into memref From fa6e7d34e3b865bf27d74b240c1ae484c3f12eeb Mon Sep 17 00:00:00 2001 From: Andrzej Warzynski Date: Sun, 21 Jul 2024 13:22:53 +0100 Subject: [PATCH 3/4] fixup! [mlir][vector] Refactor vector-transfer-flatten.mlir (nfc) (3/n) Improve comments --- .../Vector/vector-transfer-flatten.mlir | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir index a0a1fc39fcaca..109430189f7f8 100644 --- a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir +++ b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir @@ -132,7 +132,7 @@ func.func @transfer_read_dims_mismatch_non_contiguous_non_zero_indices( // ----- /// The leading dynamic shapes don't affect whether this example is flattenable -/// or not as those dynamic shapes are not candidates for flattening anyway. +/// or not. Indeed, those dynamic shapes are not candidates for flattening anyway. func.func @transfer_read_leading_dynamic_dims( %arg : memref>, @@ -141,7 +141,8 @@ func.func @transfer_read_leading_dynamic_dims( %c0_i8 = arith.constant 0 : i8 %c0 = arith.constant 0 : index - %result = vector.transfer_read %arg[%idx_1, %idx_2, %c0, %c0], %c0_i8 {in_bounds = [true, true]} : memref>, vector<8x4xi8> + %result = vector.transfer_read %arg[%idx_1, %idx_2, %c0, %c0], %c0_i8 {in_bounds = [true, true]} : + memref>, vector<8x4xi8> return %result : vector<8x4xi8> } @@ -163,10 +164,9 @@ func.func @transfer_read_leading_dynamic_dims( // ----- -// The input memref has a dynamic trailing shape and hence is not flattened. -// TODO: This case could be supported via memref.dim +// One of the dims to be flattened is dynamic - not supported ATM. -func.func @transfer_read_dims_mismatch_non_zero_indices_trailing_dynamic_dim( +func.func @negative_transfer_read_dynamic_dim_to_flatten( %idx_1: index, %idx_2: index, %m_in: memref<1x?x4x6xi32>) -> vector<1x2x6xi32> { @@ -178,11 +178,11 @@ func.func @transfer_read_dims_mismatch_non_zero_indices_trailing_dynamic_dim( return %v : vector<1x2x6xi32> } -// CHECK-LABEL: func.func @transfer_read_dims_mismatch_non_zero_indices_trailing_dynamic_dim +// CHECK-LABEL: func.func @negative_transfer_read_dynamic_dim_to_flatten // CHECK-NOT: memref.collapse_shape // CHECK-NOT: vector.shape_cast -// CHECK-128B-LABEL: func @transfer_read_dims_mismatch_non_zero_indices_trailing_dynamic_dim +// CHECK-128B-LABEL: func @negative_transfer_read_dynamic_dim_to_flatten // CHECK-128B-NOT: memref.collapse_shape // ----- @@ -377,8 +377,8 @@ func.func @transfer_write_dims_mismatch_non_contiguous_non_zero_indices( // ----- -// The leading dynamic shapes don't affect whether this example is flattenable -// or not as those dynamic shapes are not candidates for flattening anyway. +/// The leading dynamic shapes don't affect whether this example is flattenable +/// or not. Indeed, those dynamic shapes are not candidates for flattening anyway. func.func @transfer_write_leading_dynamic_dims( %vec : vector<8x4xi8>, @@ -387,7 +387,8 @@ func.func @transfer_write_leading_dynamic_dims( %idx_2 : index) { %c0 = arith.constant 0 : index - vector.transfer_write %vec, %arg[%idx_1, %idx_2, %c0, %c0] {in_bounds = [true, true]} : vector<8x4xi8>, memref> + vector.transfer_write %vec, %arg[%idx_1, %idx_2, %c0, %c0] {in_bounds = [true, true]} : + vector<8x4xi8>, memref> return } @@ -407,10 +408,9 @@ func.func @transfer_write_leading_dynamic_dims( // ----- -// The input memref has a dynamic trailing shape and hence is not flattened. -// TODO: This case could be supported via memref.dim +// One of the dims to be flattened is dynamic - not supported ATM. -func.func @transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim( +func.func @negative_transfer_write_dynamic_to_flatten( %idx_1: index, %idx_2: index, %vec : vector<1x2x6xi32>, @@ -423,11 +423,11 @@ func.func @transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim( return } -// CHECK-LABEL: func.func @transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim( +// CHECK-LABEL: func.func @negative_transfer_write_dynamic_to_flatten // CHECK-NOT: memref.collapse_shape // CHECK-NOT: vector.shape_cast -// CHECK-128B-LABEL: func @transfer_write_dims_mismatch_non_zero_indices_trailing_dynamic_dim( +// CHECK-128B-LABEL: func @negative_transfer_write_dynamic_to_flatten // CHECK-128B-NOT: memref.collapse_shape // ----- From 1d942de0252ef83a3520e64de637e7848eafa6a1 Mon Sep 17 00:00:00 2001 From: Andrzej Warzynski Date: Mon, 22 Jul 2024 09:26:13 +0100 Subject: [PATCH 4/4] fixup! fixup! [mlir][vector] Refactor vector-transfer-flatten.mlir (nfc) (3/n) Replace /// with //, improve indentation --- .../Vector/vector-transfer-flatten.mlir | 45 ++++++++++--------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir index 109430189f7f8..621baef82319f 100644 --- a/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir +++ b/mlir/test/Dialect/Vector/vector-transfer-flatten.mlir @@ -123,7 +123,8 @@ func.func @transfer_read_dims_mismatch_non_contiguous_non_zero_indices( // CHECK: #[[$MAP:.+]] = affine_map<()[s0] -> (s0 * 2)> // CHECK-LABEL: func.func @transfer_read_dims_mismatch_non_contiguous_non_zero_indices( -// CHECK: %[[COLLAPSE:.+]] = memref.collapse_shape %{{.*}} {{\[}}[0], [1], [2, 3]] : memref<1x3x3x2xf32, strided<[40, 10, 2, 1], offset: ?>> into memref<1x3x6xf32, strided<[40, 10, 1], offset: ?>> +// CHECK: %[[COLLAPSE:.+]] = memref.collapse_shape %{{.*}} {{\[}}[0], [1], [2, 3]] +// CHECK-SAME: : memref<1x3x3x2xf32, strided<[40, 10, 2, 1], offset: ?>> into memref<1x3x6xf32, strided<[40, 10, 1], offset: ?>> // CHECK: %[[APPLY:.*]] = affine.apply #[[$MAP]]() // CHECK-128B-LABEL: func @transfer_read_dims_mismatch_non_contiguous_non_zero_indices( @@ -131,8 +132,8 @@ func.func @transfer_read_dims_mismatch_non_contiguous_non_zero_indices( // ----- -/// The leading dynamic shapes don't affect whether this example is flattenable -/// or not. Indeed, those dynamic shapes are not candidates for flattening anyway. +// The leading dynamic shapes don't affect whether this example is flattenable +// or not. Indeed, those dynamic shapes are not candidates for flattening anyway. func.func @transfer_read_leading_dynamic_dims( %arg : memref>, @@ -148,16 +149,16 @@ func.func @transfer_read_leading_dynamic_dims( // CHECK-LABEL: func @transfer_read_leading_dynamic_dims // CHECK-SAME: %[[ARG0:.+]]: memref, %[[ARG1:.+]]: index, %[[ARG2:.+]]: index -// CHECK: %[[C0_I8:.+]] = arith.constant 0 : i8 -// CHECK: %[[C0:.+]] = arith.constant 0 : index -// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG0]] {{\[}}[0], [1], [2, 3]{{\]}} -// CHECK-SAME: : memref into memref -// CHECK: %[[VEC1D:.+]] = vector.transfer_read %[[COLLAPSED]] +// CHECK: %[[C0_I8:.+]] = arith.constant 0 : i8 +// CHECK: %[[C0:.+]] = arith.constant 0 : index +// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG0]] {{\[}}[0], [1], [2, 3]{{\]}} +// CHECK-SAME: : memref into memref +// CHECK: %[[VEC1D:.+]] = vector.transfer_read %[[COLLAPSED]] // CHECK-SAME: [%[[ARG1]], %[[ARG2]], %[[C0]]], %[[C0_I8]] // CHECK-SAME: {in_bounds = [true]} -// CHECK-SAME: : memref, vector<32xi8> -// CHECK: %[[VEC2D:.+]] = vector.shape_cast %[[VEC1D]] : vector<32xi8> to vector<8x4xi8> -// CHECK: return %[[VEC2D]] : vector<8x4xi8> +// CHECK-SAME: : memref, vector<32xi8> +// CHECK: %[[VEC2D:.+]] = vector.shape_cast %[[VEC1D]] : vector<32xi8> to vector<8x4xi8> +// CHECK: return %[[VEC2D]] : vector<8x4xi8> // CHECK-128B-LABEL: func @transfer_read_leading_dynamic_dims // CHECK-128B: memref.collapse_shape @@ -377,8 +378,8 @@ func.func @transfer_write_dims_mismatch_non_contiguous_non_zero_indices( // ----- -/// The leading dynamic shapes don't affect whether this example is flattenable -/// or not. Indeed, those dynamic shapes are not candidates for flattening anyway. +// The leading dynamic shapes don't affect whether this example is flattenable +// or not. Indeed, those dynamic shapes are not candidates for flattening anyway. func.func @transfer_write_leading_dynamic_dims( %vec : vector<8x4xi8>, @@ -393,15 +394,15 @@ func.func @transfer_write_leading_dynamic_dims( } // CHECK-LABEL: func @transfer_write_leading_dynamic_dims -// CHECK-SAME: %[[ARG0:.+]]: vector<8x4xi8>, %[[ARG1:.+]]: memref, %[[ARG2:.+]]: index, %[[ARG3:.+]]: index -// CHECK: %[[C0:.+]] = arith.constant 0 : index -// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG1]] {{\[}}[0], [1], [2, 3]{{\]}} -// CHECK-SAME: : memref into memref -// CHECK: %[[VEC1D:.+]] = vector.shape_cast %[[ARG0]] : vector<8x4xi8> to vector<32xi8> -// CHECK: vector.transfer_write %[[VEC1D]], %[[COLLAPSED]] -// CHECK-SAME: [%[[ARG2]], %[[ARG3]], %[[C0]]] -// CHECK-SAME: {in_bounds = [true]} -// CHECK-SAME: : vector<32xi8>, memref +// CHECK-SAME: %[[ARG0:.+]]: vector<8x4xi8>, %[[ARG1:.+]]: memref, %[[ARG2:.+]]: index, %[[ARG3:.+]]: index +// CHECK: %[[C0:.+]] = arith.constant 0 : index +// CHECK: %[[COLLAPSED:.+]] = memref.collapse_shape %[[ARG1]] {{\[}}[0], [1], [2, 3]{{\]}} +// CHECK-SAME: : memref into memref +// CHECK: %[[VEC1D:.+]] = vector.shape_cast %[[ARG0]] : vector<8x4xi8> to vector<32xi8> +// CHECK: vector.transfer_write %[[VEC1D]], %[[COLLAPSED]] +// CHECK-SAME: [%[[ARG2]], %[[ARG3]], %[[C0]]] +// CHECK-SAME: {in_bounds = [true]} +// CHECK-SAME: : vector<32xi8>, memref // CHECK-128B-LABEL: func @transfer_write_leading_dynamic_dims // CHECK-128B: memref.collapse_shape