[Mlir-commits] [mlir] 4920247 - [mlir] [linalg] Fix transform-patterns test.
Alex Zinenko
llvmlistbot at llvm.org
Tue Apr 21 03:53:52 PDT 2020
Author: Pierre Oechsel
Date: 2020-04-21T12:53:45+02:00
New Revision: 49202476e6d3b8b3bb1029859329afa22981e5b9
URL: https://github.com/llvm/llvm-project/commit/49202476e6d3b8b3bb1029859329afa22981e5b9
DIFF: https://github.com/llvm/llvm-project/commit/49202476e6d3b8b3bb1029859329afa22981e5b9.diff
LOG: [mlir] [linalg] Fix transform-patterns test.
Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored.
Differential Revision: https://reviews.llvm.org/D78548
Added:
Modified:
mlir/test/Dialect/Linalg/transform-patterns.mlir
Removed:
################################################################################
diff --git a/mlir/test/Dialect/Linalg/transform-patterns.mlir b/mlir/test/Dialect/Linalg/transform-patterns.mlir
index 3e8230c494c8..e4320d803fcb 100644
--- a/mlir/test/Dialect/Linalg/transform-patterns.mlir
+++ b/mlir/test/Dialect/Linalg/transform-patterns.mlir
@@ -1,7 +1,10 @@
// RUN: mlir-opt %s -test-linalg-transform-patterns | FileCheck %s
-// CHECK-DAG: #[[STRIDED_1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
-// CHECK-DAG: #[[STRIDED_2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// CHECK-DAG: #[[STRIDED_1D:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
+// Map corresponding to a 2D memory access where the stride along the last dim is known to be 1.
+// CHECK-DAG: #[[STRIDED_2D_u_1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// Map corresponding to a 2D memory access where the stride along all dims are unknown.
+// CHECK-DAG: #[[STRIDED_2D:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
// CHECK-DAG: #[[mk:.*]] = affine_map<(d0, d1, d2) -> (d0, d2)>
// CHECK-DAG: #[[kn:.*]] = affine_map<(d0, d1, d2) -> (d2, d1)>
// CHECK-DAG: #[[mn:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)>
@@ -17,18 +20,19 @@ func @dot(%x: memref<?xf32, offset: ?, strides: [1]>,
return
}
// CHECK-LABEL: func @dot
-// CHECK-DAG : %[[c0:.*]] = constant 0 : index
-// CHECK-DAG : %[[c8:.*]] = constant 8 : index
-// CHECK-DAG : %[[c8000:.*]] = constant 8000 : index
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c1]] {
-// CHECK : load
-// CHECK : load
-// CHECK : mulf
-// CHECK : load
-// CHECK : addf
-// CHECK : store
+// CHECK-DAG: %[[c0:.*]] = constant 0 : index
+// CHECK-DAG: %[[c1:.*]] = constant 1 : index
+// CHECK-DAG: %[[c8:.*]] = constant 8 : index
+// CHECK-DAG: %[[c8000:.*]] = constant 8000 : index
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c1]] {
+// CHECK: load
+// CHECK: load
+// CHECK: mulf
+// CHECK: load
+// CHECK: addf
+// CHECK: store
func @matvec(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%x: memref<?xf32, offset: ?, strides: [1]>,
@@ -39,12 +43,12 @@ func @matvec(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
return
}
// CHECK-LABEL: func @matvec
-// CHECK-DAG : %[[c0:.*]] = constant 0 : index
-// CHECK-DAG : %[[c5:.*]] = constant 5 : index
-// CHECK-DAG : %[[c6:.*]] = constant 6 : index
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c5]]
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c6]]
-// CHECK : linalg.matvec({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?xf32, #[[STRIDED_1D]]>, memref<?xf32, #[[STRIDED_1D]]>
+// CHECK-DAG: %[[c0:.*]] = constant 0 : index
+// CHECK-DAG: %[[c5:.*]] = constant 5 : index
+// CHECK-DAG: %[[c6:.*]] = constant 6 : index
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c5]]
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c6]]
+// CHECK: linalg.matvec({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?xf32, #[[STRIDED_1D]]>, memref<?xf32, #[[STRIDED_1D]]>
func @matmul(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%B: memref<?x?xf32, offset: ?, strides: [?, 1]>,
@@ -55,32 +59,32 @@ func @matmul(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
return
}
// CHECK-LABEL: func @matmul
-// CHECK-DAG : %[[c0:.*]] = constant 0 : index
-// CHECK-DAG : %[[c2:.*]] = constant 2 : index
-// CHECK-DAG : %[[c3:.*]] = constant 3 : index
-// CHECK-DAG : %[[c4:.*]] = constant 4 : index
-// CHECK-DAG : %[[c20:.*]] = constant 20 : index
-// CHECK-DAG : %[[c30:.*]] = constant 30 : index
-// CHECK-DAG : %[[c40:.*]] = constant 40 : index
-// CHECK-DAG : %[[c200:.*]] = constant 200 : index
-// CHECK-DAG : %[[c300:.*]] = constant 300 : index
-// CHECK-DAG : %[[c400:.*]] = constant 400 : index
-// CHECK-DAG : %[[c2000:.*]] = constant 2000 : index
-// CHECK-DAG : %[[c3000:.*]] = constant 3000 : index
-// CHECK-DAG : %[[c4000:.*]] = constant 4000 : index
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4]] {
-// CHECK : linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK-DAG: %[[c0:.*]] = constant 0 : index
+// CHECK-DAG: %[[c2:.*]] = constant 2 : index
+// CHECK-DAG: %[[c3:.*]] = constant 3 : index
+// CHECK-DAG: %[[c4:.*]] = constant 4 : index
+// CHECK-DAG: %[[c20:.*]] = constant 20 : index
+// CHECK-DAG: %[[c30:.*]] = constant 30 : index
+// CHECK-DAG: %[[c40:.*]] = constant 40 : index
+// CHECK-DAG: %[[c200:.*]] = constant 200 : index
+// CHECK-DAG: %[[c300:.*]] = constant 300 : index
+// CHECK-DAG: %[[c400:.*]] = constant 400 : index
+// CHECK-DAG: %[[c2000:.*]] = constant 2000 : index
+// CHECK-DAG: %[[c3000:.*]] = constant 3000 : index
+// CHECK-DAG: %[[c4000:.*]] = constant 4000 : index
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4]] {
+// CHECK: linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
#some_generic_trait = {
args_in = 1,
@@ -122,47 +126,47 @@ func @fusion_test(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
return
}
// CHECK-LABEL: func @fusion_test
-// CHECK-DAG : %[[c0:.*]] = constant 0 : index
-// CHECK-DAG : %[[c2:.*]] = constant 2 : index
-// CHECK-DAG : %[[c3:.*]] = constant 3 : index
-// CHECK-DAG : %[[c4:.*]] = constant 4 : index
-// CHECK-DAG : %[[c20:.*]] = constant 20 : index
-// CHECK-DAG : %[[c30:.*]] = constant 30 : index
-// CHECK-DAG : %[[c40:.*]] = constant 40 : index
-// CHECK-DAG : %[[c100:.*]] = constant 100 : index
-// CHECK-DAG : %[[c150:.*]] = constant 150 : index
-// CHECK-DAG : %[[c200:.*]] = constant 200 : index
-// CHECK-DAG : %[[c300:.*]] = constant 300 : index
-// CHECK-DAG : %[[c400:.*]] = constant 400 : index
-// CHECK-DAG : %[[c2000:.*]] = constant 2000 : index
-// CHECK-DAG : %[[c3000:.*]] = constant 3000 : index
-// CHECK-DAG : %[[c4000:.*]] = constant 4000 : index
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4]] {
-// CHECK : linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK-DAG: %[[c0:.*]] = constant 0 : index
+// CHECK-DAG: %[[c2:.*]] = constant 2 : index
+// CHECK-DAG: %[[c3:.*]] = constant 3 : index
+// CHECK-DAG: %[[c4:.*]] = constant 4 : index
+// CHECK-DAG: %[[c20:.*]] = constant 20 : index
+// CHECK-DAG: %[[c30:.*]] = constant 30 : index
+// CHECK-DAG: %[[c40:.*]] = constant 40 : index
+// CHECK-DAG: %[[c100:.*]] = constant 100 : index
+// CHECK-DAG: %[[c150:.*]] = constant 150 : index
+// CHECK-DAG: %[[c200:.*]] = constant 200 : index
+// CHECK-DAG: %[[c300:.*]] = constant 300 : index
+// CHECK-DAG: %[[c400:.*]] = constant 400 : index
+// CHECK-DAG: %[[c2000:.*]] = constant 2000 : index
+// CHECK-DAG: %[[c3000:.*]] = constant 3000 : index
+// CHECK-DAG: %[[c4000:.*]] = constant 4000 : index
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4]] {
+// CHECK: linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
//
-// CHECK : linalg.generic
+// CHECK: linalg.generic
//
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c100]] {
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c150]] {
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c2]] {
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c3]] {
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c4]] {
-// CHECK : linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c2]] {
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c3]] {
-// CHECK : loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c4]] {
-// CHECK : linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c100]] {
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c150]] {
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c2]] {
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c3]] {
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c4]] {
+// CHECK: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c2]] {
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c3]] {
+// CHECK: loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c4]] {
+// CHECK: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
#matmul_trait = {
args_in = 2,
@@ -237,15 +241,14 @@ func @permute_generic(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>
return
}
-// CHECK-LABEL : func @fma
-// CHECK-LABEL : func @permute_generic
-// CHECK : linalg.generic {args_in = 2, args_out = 1,
-// CHECK-SAME : indexing_maps = [#[[kn]], #[[nm]], #[[km]]],
-// CHECK-SAME : iterator_types = ["parallel", "reduction", "parallel"],
-// CHECK-SAME : library_call = "linalg_matmul"} %{{.*}}, %{{.*}}, %{{.*}}
-// CHECK : memref<?x?xf32, #[[STRIDED_2D]]>,
-// CHECK-SAME : memref<?x?xf32, #[[STRIDED_2D]]>,
-// CHECK-SAME : memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK-LABEL: func @permute_generic
+// CHECK: linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
+// CHECK-SAME: indexing_maps = [#[[kn]], #[[nm]], #[[km]]],
+// CHECK-SAME: iterator_types = ["parallel", "reduction", "parallel"],
+// CHECK-SAME: library_call = "linalg_matmul"} %{{.*}}, %{{.*}}, %{{.*}}
+// CHECK: memref<?x?xf32, #[[STRIDED_2D_u_1]]>,
+// CHECK-SAME: memref<?x?xf32, #[[STRIDED_2D_u_1]]>,
+// CHECK-SAME: memref<?x?xf32, #[[STRIDED_2D_u_1]]>
#indexed_matmul_trait = {
args_in = 2,
@@ -268,15 +271,14 @@ func @permute_generic_indexed(
memref<?x?xf32, offset: ?, strides: [?, 1]>
return
}
-// CHECK-LABEL : func @fma_indexed
-// CHECK-LABEL : func @permute_generic_indexed
-// CHECK : linalg.indexed_generic {args_in = 2, args_out = 1,
-// CHECK-SAME : indexing_maps = [#[[kn]], #[[nm]], #[[km]]],
-// CHECK-SAME : iterator_types = ["parallel", "reduction", "parallel"],
-// CHECK-SAME : library_call = "linalg_matmul_indexed"} %{{.*}}, %{{.*}}, %{{.*}} :
-// CHECK : memref<?x?xf32, #[[STRIDED_2D]]>,
-// CHECK-SAME : memref<?x?xf32, #[[STRIDED_2D]]>,
-// CHECK-SAME : memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK-LABEL: func @permute_generic_indexed
+// CHECK: linalg.indexed_generic {args_in = 2 : i64, args_out = 1 : i64,
+// CHECK-SAME: indexing_maps = [#[[kn]], #[[nm]], #[[km]]],
+// CHECK-SAME: iterator_types = ["parallel", "reduction", "parallel"],
+// CHECK-SAME: library_call = "linalg_matmul_indexed"} %{{.*}}, %{{.*}}, %{{.*}}
+// CHECK: memref<?x?xf32, #[[STRIDED_2D_u_1]]>,
+// CHECK-SAME: memref<?x?xf32, #[[STRIDED_2D_u_1]]>,
+// CHECK-SAME: memref<?x?xf32, #[[STRIDED_2D_u_1]]>
func @dot_perm(%x: memref<?xf32, offset: ?, strides: [1]>,
%y: memref<?xf32, offset: ?, strides: [1]>,
@@ -288,12 +290,12 @@ func @dot_perm(%x: memref<?xf32, offset: ?, strides: [1]>,
return
}
// CHECK-LABEL: func @dot_perm
-// CHECK-DAG : %[[c0:.*]] = constant 0 : index
-// CHECK-DAG : %[[c8:.*]] = constant 8 : index
-// CHECK-DAG : %[[c8000:.*]] = constant 8000 : index
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8]] {
-// CHECK : linalg.dot({{.*}}, {{.*}}, {{.*}}) : memref<?xf32, #[[STRIDED_1D]]>, memref<?xf32, #[[STRIDED_1D]]>, memref<f32>
+// CHECK-DAG: %[[c0:.*]] = constant 0 : index
+// CHECK-DAG: %[[c8:.*]] = constant 8 : index
+// CHECK-DAG: %[[c8000:.*]] = constant 8000 : index
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c8]] {
+// CHECK: linalg.dot({{.*}}, {{.*}}, {{.*}}) : memref<?xf32, #[[STRIDED_1D]]>, memref<?xf32, #[[STRIDED_1D]]>, memref<f32>
func @matvec_perm(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%x: memref<?xf32, offset: ?, strides: [1]>,
@@ -305,12 +307,12 @@ func @matvec_perm(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
return
}
// CHECK-LABEL: func @matvec_perm
-// CHECK-DAG : %[[c0:.*]] = constant 0 : index
-// CHECK-DAG : %[[c5:.*]] = constant 5 : index
-// CHECK-DAG : %[[c6:.*]] = constant 6 : index
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c6]]
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c5]]
-// CHECK : linalg.matvec({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?xf32, #[[STRIDED_1D]]>, memref<?xf32, #[[STRIDED_1D]]>
+// CHECK-DAG: %[[c0:.*]] = constant 0 : index
+// CHECK-DAG: %[[c5:.*]] = constant 5 : index
+// CHECK-DAG: %[[c6:.*]] = constant 6 : index
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c6]]
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c5]]
+// CHECK: linalg.matvec({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?xf32, #[[STRIDED_1D]]>, memref<?xf32, #[[STRIDED_1D]]>
func @matmul_perm(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%B: memref<?x?xf32, offset: ?, strides: [?, 1]>,
@@ -322,29 +324,26 @@ func @matmul_perm(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
return
}
// CHECK-LABEL: func @matmul_perm
-// CHECK-DAG : %[[c0:.*]] = constant 0 : index
-// CHECK-DAG : %[[c2:.*]] = constant 2 : index
-// CHECK-DAG : %[[c3:.*]] = constant 3 : index
-// CHECK-DAG : %[[c4:.*]] = constant 4 : index
-// CHECK-DAG : %[[c20:.*]] = constant 20 : index
-// CHECK-DAG : %[[c30:.*]] = constant 30 : index
-// CHECK-DAG : %[[c40:.*]] = constant 40 : index
-// CHECK-DAG : %[[c200:.*]] = constant 200 : index
-// CHECK-DAG : %[[c300:.*]] = constant 300 : index
-// CHECK-DAG : %[[c400:.*]] = constant 400 : index
-// CHECK-DAG : %[[c2000:.*]] = constant 2000 : index
-// CHECK-DAG : %[[c3000:.*]] = constant 3000 : index
-// CHECK-DAG : %[[c4000:.*]] = constant 4000 : index
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
-// CHECK : linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK-DAG: %[[c0:.*]] = constant 0 : index
+// CHECK-DAG: %[[c20:.*]] = constant 20 : index
+// CHECK-DAG: %[[c30:.*]] = constant 30 : index
+// CHECK-DAG: %[[c40:.*]] = constant 40 : index
+// CHECK-DAG: %[[c200:.*]] = constant 200 : index
+// CHECK-DAG: %[[c300:.*]] = constant 300 : index
+// CHECK-DAG: %[[c400:.*]] = constant 400 : index
+// CHECK-DAG: %[[c2000:.*]] = constant 2000 : index
+// CHECK-DAG: %[[c3000:.*]] = constant 3000 : index
+// CHECK-DAG: %[[c4000:.*]] = constant 4000 : index
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
+// CHECK: linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
func @promote_subview_matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>,
@@ -360,11 +359,11 @@ func @promote_subview_matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>,
loop.for %arg3 = %c0 to %0 step %c2000 {
loop.for %arg4 = %c0 to %2 step %c3000 {
loop.for %arg5 = %c0 to %1 step %c4000 {
- %3 = std.subview %arg0[%arg3, %arg5][%c2000, %c4000][%c1, %c1] :
+ %3 = subview %arg0[%arg3, %arg5][%c2000, %c4000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
- %4 = std.subview %arg1[%arg5, %arg4][%c4000, %c3000][%c1, %c1] :
+ %4 = subview %arg1[%arg5, %arg4][%c4000, %c3000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
- %5 = std.subview %arg2[%arg3, %arg4][%c2000, %c3000][%c1, %c1] :
+ %5 = subview %arg2[%arg3, %arg4][%c2000, %c3000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
linalg.matmul(%3, %4, %5) {__internal_linalg_transform__ = "_promote_views_"} :
memref<?x?xf32, offset: ?, strides: [?, ?]>,
@@ -376,25 +375,25 @@ func @promote_subview_matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>,
return
}
// CHECK-LABEL: func @promote_subview_matmul
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
-// CHECK : loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
-// CHECK : %[[s0:.*]] = std.subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
-// CHECK : %[[s1:.*]] = std.subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
-// CHECK : %[[s2:.*]] = std.subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
-// CHECK : %[[a0:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK : %[[v0:.*]] = std.view %[[a0]][][{{%.*}}, {{%.*}}]: memref<?xi8> to memref<?x?xf32>
-// CHECK : %[[l0:.*]] = linalg.slice %[[v0]][{{%.*}}, {{%.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, memref<?x?xf32, #map{{.*}}>
-// CHECK : %[[a1:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK : %[[v1:.*]] = std.view %[[a1]][][{{%.*}}, {{%.*}}]: memref<?xi8> to memref<?x?xf32>
-// CHECK : %[[l1:.*]] = linalg.slice %[[v1]][{{%.*}}, {{%.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, memref<?x?xf32, #map{{.*}}>
-// CHECK : %[[a2:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK : %[[v2:.*]] = std.view %[[a2]][][{{%.*}}, {{%.*}}]: memref<?xi8> to memref<?x?xf32>
-// CHECK : %[[l2:.*]] = linalg.slice %[[v2]][{{%.*}}, {{%.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, memref<?x?xf32, #map{{.*}}>
-// CHECK : linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
-// CHECK : linalg.copy(%[[s1]], %[[l1]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
-// CHECK : linalg.copy(%[[s2]], %[[l2]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
-// CHECK : linalg.matmul(%[[v0]], %[[v1]], %[[v2]]) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
+// CHECK: %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
+// CHECK: %[[s1:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
+// CHECK: %[[s2:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
+// CHECK: %[[a0:.*]] = alloc({{%.*}}) : memref<?xi8>
+// CHECK: %[[v0:.*]] = std.view %[[a0]][][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK: %[[l0:.*]] = subview %[[v0]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK: %[[a1:.*]] = alloc({{%.*}}) : memref<?xi8>
+// CHECK: %[[v1:.*]] = std.view %[[a1]][][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK: %[[l1:.*]] = subview %[[v1]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK: %[[a2:.*]] = alloc({{%.*}}) : memref<?xi8>
+// CHECK: %[[v2:.*]] = std.view %[[a2]][][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK: %[[l2:.*]] = subview %[[v2]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[STRIDED_2D]]>
+// CHECK: linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
+// CHECK: linalg.copy(%[[s1]], %[[l1]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
+// CHECK: linalg.copy(%[[s2]], %[[l2]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
+// CHECK: linalg.matmul(%[[v0]], %[[v1]], %[[v2]]) : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>
func @promote_first_subview_matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>,
@@ -426,22 +425,22 @@ func @promote_first_subview_matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?
return
}
// CHECK-LABEL: func @promote_first_subview_matmul
-// CHECK: loop.for {{.*}} = %c0 to {{.*}} step %c2000 {
-// CHECK: loop.for {{.*}} = %c0 to {{.*}} step %c3000 {
-// CHECK: loop.for {{.*}} = %c0 to {{.*}} step %c4000 {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
+// CHECK: loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
// CHECK: %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[s1:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[s2:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[a0:.*]] = alloc({{%.*}}) : memref<?xi8>
// CHECK: %[[v0:.*]] = std.view %[[a0]][][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
-// CHECK: %[[l0:.*]] = subview %[[v0]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[map:.*]]>
+// CHECK: %[[l0:.*]] = subview %[[v0]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[STRIDED_2D]]>
// CHECK-NOT: %[[a1:.*]] = alloc({{%.*}}) : memref<?xi8>
// CHECK-NOT: %[[v1:.*]] = std.view %[[a1]][][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
-// CHECK-NOT: %[[l0:.*]] = subview %[[v1]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[map]]>
+// CHECK-NOT: %[[l0:.*]] = subview %[[v1]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[STRIDED_2D]]>
// CHECK-NOT: %[[a2:.*]] = alloc({{%.*}}) : memref<?xi8>
// CHECK-NOT: %[[v2:.*]] = std.view %[[a2]][][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
-// CHECK-NOT: %[[l0:.*]] = subview %[[v2]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[map]]>
+// CHECK-NOT: %[[l0:.*]] = subview %[[v2]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[STRIDED_2D]]>
// CHECK: linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK-NOT: linalg.copy(%[[s1]], %[[l1]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK-NOT: linalg.copy(%[[s2]], %[[l2]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>^
-// CHECK: linalg.matmul(%[[v0]], %[[s1]], %[[s2]]) : memref<?x?xf32>, memref<?x?xf32, #[[map]]>, memref<?x?xf32, #[[map]]>
+// CHECK: linalg.matmul(%[[v0]], %[[s1]], %[[s2]]) : memref<?x?xf32>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
More information about the Mlir-commits
mailing list