forked from OSchip/llvm-project
[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
This commit is contained in:
Pierre Oechsel
Alex Zinenko
parent
32c0561e0c
commit
49202476e6
|
|
@ -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]]>
|
||||
|
|
|
|||
Loading…
Reference in New Issue