mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-02-02 07:06:33 +00:00
Update tests using affine maps to not rely on specific map numbers in the output IR. This is necessary to remove the dependency on ForInst not numbering the AffineMap bounds it has custom formatting for.
PiperOrigin-RevId: 231634812
This commit is contained in:
River Riddle
jpienaar
parent
44064d5b3b
commit
a642bb1779
@ -160,7 +160,7 @@ func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
|
||||
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
|
||||
// CHECK-NEXT: {{.*}} = cmpi "slt", %[[I2]], %[[C0]] : index
|
||||
// CHECK-NEXT: {{.*}} = cmpi "slt", %[[I2]], %3 : index
|
||||
// CHECK-NEXT: {{.*}} = affine_apply #map1(%3, %[[C1]])
|
||||
// CHECK-NEXT: {{.*}} = affine_apply #map{{.*}}(%3, %[[C1]])
|
||||
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[I2]], {{.*}} : index
|
||||
// CHECK-NEXT: {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
|
||||
// CHECK-NEXT: {{.*}} = affine_apply #[[ADD]](%[[I3]], %[[I6]])
|
||||
|
||||
@ -1,35 +1,35 @@
|
||||
// RUN: mlir-opt %s -compose-affine-maps | FileCheck %s
|
||||
|
||||
// Affine maps for test case: compose_affine_maps_1dto2d_no_symbols
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0) -> (d0 - 1)
|
||||
// CHECK: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 1)
|
||||
// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 - 1)
|
||||
// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 1)
|
||||
|
||||
// Affine maps for test case: compose_affine_maps_1dto2d_with_symbols
|
||||
// CHECK: [[MAP4:#map[0-9]+]] = (d0)[s0] -> (d0 - s0)
|
||||
// CHECK: [[MAP6:#map[0-9]+]] = (d0)[s0] -> (d0 * 2 - s0 + 1)
|
||||
// CHECK: [[MAP7:#map[0-9]+]] = (d0)[s0, s1] -> (d0 * 2 + s0 - s1)
|
||||
// CHECK-DAG: [[MAP4:#map[0-9]+]] = (d0)[s0] -> (d0 - s0)
|
||||
// CHECK-DAG: [[MAP6:#map[0-9]+]] = (d0)[s0] -> (d0 * 2 - s0 + 1)
|
||||
// CHECK-DAG: [[MAP7:#map[0-9]+]] = (d0)[s0, s1] -> (d0 * 2 + s0 - s1)
|
||||
|
||||
// Affine map for test case: compose_affine_maps_d2_tile
|
||||
// CHECK: [[MAP8:#map[0-9]+]] = (d0, d1)[s0] -> ((d0 ceildiv s0) * s0 + d1 mod s0)
|
||||
// CHECK-DAG: [[MAP8:#map[0-9]+]] = (d0, d1)[s0] -> ((d0 ceildiv s0) * s0 + d1 mod s0)
|
||||
|
||||
// Affine maps for test case: compose_affine_maps_dependent_loads
|
||||
// CHECK: [[MAP9:#map[0-9]+]] = (d0)[s0] -> (d0 + s0)
|
||||
// CHECK: [[MAP10:#map[0-9]+]] = (d0)[s0] -> (d0 * s0)
|
||||
// CHECK: [[MAP12A:#map[0-9]+]] = (d0)[s0, s1] -> ((d0 - s1) * s0)
|
||||
// CHECK: [[MAP12B:#map[0-9]+]] = (d0)[s0, s1] -> ((d0 + s1) ceildiv s0)
|
||||
// CHECK-DAG: [[MAP9:#map[0-9]+]] = (d0)[s0] -> (d0 + s0)
|
||||
// CHECK-DAG: [[MAP10:#map[0-9]+]] = (d0)[s0] -> (d0 * s0)
|
||||
// CHECK-DAG: [[MAP12A:#map[0-9]+]] = (d0)[s0, s1] -> ((d0 - s1) * s0)
|
||||
// CHECK-DAG: [[MAP12B:#map[0-9]+]] = (d0)[s0, s1] -> ((d0 + s1) ceildiv s0)
|
||||
|
||||
// Affine maps for test case: compose_affine_maps_diamond_dependency
|
||||
// CHECK: [[MAP13A:#map[0-9]+]] = (d0) -> ((d0 + 6) ceildiv 8)
|
||||
// CHECK: [[MAP13B:#map[0-9]+]] = (d0) -> ((d0 * 4 - 4) floordiv 3)
|
||||
// CHECK-DAG: [[MAP13A:#map[0-9]+]] = (d0) -> ((d0 + 6) ceildiv 8)
|
||||
// CHECK-DAG: [[MAP13B:#map[0-9]+]] = (d0) -> ((d0 * 4 - 4) floordiv 3)
|
||||
|
||||
// Affine maps for test case: arg_used_as_dim_and_symbol
|
||||
// CHECK: [[MAP14:#map[0-9]+]] = (d0, d1, d2)[s0, s1] -> (-d0 - d1 + d2 + s0 + s1)
|
||||
// CHECK-DAG: [[MAP14:#map[0-9]+]] = (d0, d1, d2)[s0, s1] -> (-d0 - d1 + d2 + s0 + s1)
|
||||
|
||||
// Affine maps for test case: zero_map
|
||||
// CHECK: [[MAP15:#map[0-9]+]] = ()[s0] -> (s0)
|
||||
// CHECK-DAG: [[MAP15:#map[0-9]+]] = ()[s0] -> (s0)
|
||||
|
||||
// Affine maps for test case: zero_map
|
||||
// CHECK: [[MAP16:#map[0-9]+]] = () -> (0)
|
||||
// CHECK-DAG: [[MAP16:#map[0-9]+]] = () -> (0)
|
||||
|
||||
// CHECK-LABEL: func @compose_affine_maps_1dto2d_no_symbols() {
|
||||
func @compose_affine_maps_1dto2d_no_symbols() {
|
||||
@ -110,7 +110,7 @@ func @compose_affine_maps_1dto2d_with_symbols() {
|
||||
%y3 = affine_apply (d0, d1) -> (d0 + d1) (%x2, %x0)
|
||||
// CHECK: [[I3:%[0-9]+]] = affine_apply [[MAP7]](%i0)[%c5, %c4]
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I3]], [[I3]]{{\]}}
|
||||
%v3 = load %0[%y3, %y3] : memref<4x4xf32>
|
||||
%v3 = load %0[%y3, %y3] : memref<4x4xf32>
|
||||
}
|
||||
return
|
||||
}
|
||||
@ -139,12 +139,12 @@ func @compose_affine_maps_2d_tile() {
|
||||
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP8]](%i0, %i2)[%c4]
|
||||
// CHECK: [[I1:%[0-9]+]] = affine_apply [[MAP8]](%i1, %i3)[%c8]
|
||||
// CHECK-NEXT: [[L0:%[0-9]+]] = load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
|
||||
%v0 = load %0[%x40, %x41] : memref<16x32xf32>
|
||||
%v0 = load %0[%x40, %x41] : memref<16x32xf32>
|
||||
|
||||
// CHECK-NEXT: store [[L0]], %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
|
||||
store %v0, %1[%x40, %x41] : memref<16x32xf32>
|
||||
store %v0, %1[%x40, %x41] : memref<16x32xf32>
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
@ -168,18 +168,18 @@ func @compose_affine_maps_dependent_loads() {
|
||||
%x02 = affine_apply (d0, d1, d2)[s0, s1] -> (d2 * s0)
|
||||
(%i0, %i1, %i2)[%c3, %c7]
|
||||
|
||||
// CHECK: [[I0:%[0-9]+]] = affine_apply #map6(%i0)[%c3]
|
||||
// CHECK: [[I1:%[0-9]+]] = affine_apply #map2(%i1)[%c7]
|
||||
// CHECK: [[I2:%[0-9]+]] = affine_apply #map7(%i2)[%c3]
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
|
||||
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP9]](%i0)[%c3]
|
||||
// CHECK: [[I1:%[0-9]+]] = affine_apply [[MAP4]](%i1)[%c7]
|
||||
// CHECK: [[I2:%[0-9]+]] = affine_apply [[MAP10]](%i2)[%c3]
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
|
||||
%v0 = load %0[%x00, %x01] : memref<16x32xf32>
|
||||
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I2]]{{\]}}
|
||||
%v1 = load %0[%x00, %x02] : memref<16x32xf32>
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I2]]{{\]}}
|
||||
%v1 = load %0[%x00, %x02] : memref<16x32xf32>
|
||||
|
||||
// Swizzle %i0, %i1
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I1]], [[I0]]{{\]}}
|
||||
%v2 = load %0[%x01, %x00] : memref<16x32xf32>
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I1]], [[I0]]{{\]}}
|
||||
%v2 = load %0[%x01, %x00] : memref<16x32xf32>
|
||||
|
||||
// Swizzle %x00, %x01 and %c3, %c7
|
||||
%x10 = affine_apply (d0, d1)[s0, s1] -> (d0 * s1)
|
||||
@ -187,10 +187,10 @@ func @compose_affine_maps_dependent_loads() {
|
||||
%x11 = affine_apply (d0, d1)[s0, s1] -> (d1 ceildiv s0)
|
||||
(%x01, %x00)[%c7, %c3]
|
||||
|
||||
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine_apply #map8(%i1)[%c3, %c7]
|
||||
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine_apply #map9(%i0)[%c7, %c3]
|
||||
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine_apply [[MAP12A]](%i1)[%c3, %c7]
|
||||
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine_apply [[MAP12B]](%i0)[%c7, %c3]
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I2A]], [[I2B]]{{\]}}
|
||||
%v3 = load %0[%x10, %x11] : memref<16x32xf32>
|
||||
%v3 = load %0[%x10, %x11] : memref<16x32xf32>
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -207,8 +207,8 @@ func @compose_affine_maps_diamond_dependency() {
|
||||
%c = affine_apply (d0) -> (d0 * 4) (%a)
|
||||
%d0 = affine_apply (d0, d1) -> (d0 ceildiv 8) (%b, %c)
|
||||
%d1 = affine_apply (d0, d1) -> (d1 floordiv 3) (%b, %c)
|
||||
// CHECK: [[I0:%[0-9]+]] = affine_apply #map10(%i0)
|
||||
// CHECK: [[I1:%[0-9]+]] = affine_apply #map11(%i0)
|
||||
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP13A]](%i0)
|
||||
// CHECK: [[I1:%[0-9]+]] = affine_apply [[MAP13B]](%i0)
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
|
||||
%v = load %0[%d0, %d1] : memref<4x4xf32>
|
||||
}
|
||||
@ -227,7 +227,7 @@ func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index) {
|
||||
(%i0, %i1)[%arg1, %c9]
|
||||
%4 = affine_apply (d0, d1, d3) -> (d3 - (d0 + d1))
|
||||
(%arg1, %c9, %3)
|
||||
// CHECK: [[I0:%[0-9]+]] = affine_apply #map12(%arg1, %c9, %i1)[%arg1, %c9]
|
||||
// CHECK: [[I0:%[0-9]+]] = affine_apply [[MAP14]](%arg1, %c9, %i1)[%arg1, %c9]
|
||||
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], %arg1{{\]}}
|
||||
%5 = load %1[%4, %arg1] : memref<100x100xf32, 1>
|
||||
}
|
||||
|
||||
@ -291,12 +291,12 @@ func @dma_memref_3d(%arg0: memref<1024x1024x1024xf32>) {
|
||||
|
||||
// -----
|
||||
|
||||
// CHECK: #map0 = (d0) -> (d0 + 64)
|
||||
// CHECK-NEXT: #map1 = (d0) -> (d0 + 128)
|
||||
// CHECK-NEXT: #map2 = (d0) -> (d0 + 2)
|
||||
// CHECK-NEXT: #map3 = (d0, d1) -> (d0 - 2)
|
||||
// CHECK-NEXT: #map4 = (d0, d1) -> (d1 - 2)
|
||||
// CHECK-NEXT: #map5 = (d0) -> (d0 + 192)
|
||||
// CHECK-DAG: [[MAP_PLUS_64:#map[0-9]+]] = (d0) -> (d0 + 64)
|
||||
// CHECK-DAG: [[MAP_PLUS_128:#map[0-9]+]] = (d0) -> (d0 + 128)
|
||||
// CHECK-DAG: [[MAP_PLUS_2:#map[0-9]+]] = (d0) -> (d0 + 2)
|
||||
// CHECK-DAG: [[MAP_D0_MINUS_2:#map[0-9]+]] = (d0, d1) -> (d0 - 2)
|
||||
// CHECK-DAG: [[MAP_D1_MINUS_2:#map[0-9]+]] = (d0, d1) -> (d1 - 2)
|
||||
// CHECK-DAG: [[MAP_PLUS_192:#map[0-9]+]] = (d0) -> (d0 + 192)
|
||||
|
||||
// The first load accesses ([2,258), [128,384))
|
||||
// The second load accesses ([64,320), [2,258))
|
||||
@ -335,23 +335,23 @@ func @multi_load_store_union() {
|
||||
// CHECK-NEXT: %3 = alloc() : memref<1xi32>
|
||||
// CHECK-NEXT: for %i0 = 0 to 256 {
|
||||
// CHECK-NEXT: for %i1 = 0 to 256 {
|
||||
// CHECK-NEXT: %4 = affine_apply #map0(%i0)
|
||||
// CHECK-NEXT: %5 = affine_apply #map1(%i1)
|
||||
// CHECK-NEXT: %6 = affine_apply #map2(%i0)
|
||||
// CHECK-NEXT: %7 = affine_apply #map2(%i1)
|
||||
// CHECK-NEXT: %8 = affine_apply #map3(%6, %5)
|
||||
// CHECK-NEXT: %9 = affine_apply #map4(%6, %5)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP_PLUS_64]](%i0)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP_PLUS_128]](%i1)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP_PLUS_2]](%i0)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP_PLUS_2]](%i1)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MAP_D0_MINUS_2]](%6, %5)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP_D1_MINUS_2]](%6, %5)
|
||||
// CHECK-NEXT: %10 = load %1[%8, %9] : memref<382x446xf32, 1>
|
||||
// CHECK-NEXT: %11 = affine_apply #map3(%4, %7)
|
||||
// CHECK-NEXT: %12 = affine_apply #map4(%4, %7)
|
||||
// CHECK-NEXT: %11 = affine_apply [[MAP_D0_MINUS_2]](%4, %7)
|
||||
// CHECK-NEXT: %12 = affine_apply [[MAP_D1_MINUS_2]](%4, %7)
|
||||
// CHECK-NEXT: %13 = load %1[%11, %12] : memref<382x446xf32, 1>
|
||||
// CHECK-NEXT: %14 = affine_apply #map1(%i0)
|
||||
// CHECK-NEXT: %15 = affine_apply #map5(%i1)
|
||||
// CHECK-NEXT: %16 = affine_apply #map3(%6, %15)
|
||||
// CHECK-NEXT: %17 = affine_apply #map4(%6, %15)
|
||||
// CHECK-NEXT: %14 = affine_apply [[MAP_PLUS_128]](%i0)
|
||||
// CHECK-NEXT: %15 = affine_apply [[MAP_PLUS_192]](%i1)
|
||||
// CHECK-NEXT: %16 = affine_apply [[MAP_D0_MINUS_2]](%6, %15)
|
||||
// CHECK-NEXT: %17 = affine_apply [[MAP_D1_MINUS_2]](%6, %15)
|
||||
// CHECK-NEXT: store %10, %1[%16, %17] : memref<382x446xf32, 1>
|
||||
// CHECK-NEXT: %18 = affine_apply #map3(%14, %7)
|
||||
// CHECK-NEXT: %19 = affine_apply #map4(%14, %7)
|
||||
// CHECK-NEXT: %18 = affine_apply [[MAP_D0_MINUS_2]](%14, %7)
|
||||
// CHECK-NEXT: %19 = affine_apply [[MAP_D1_MINUS_2]](%14, %7)
|
||||
// CHECK-NEXT: store %13, %1[%18, %19] : memref<382x446xf32, 1>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
|
||||
@ -364,9 +364,9 @@ func @should_fuse_across_waw_dep_with_private_memref() {
|
||||
// CHECK-NEXT: store %cst, %1[%i1] : memref<10xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK: for %i2 = 0 to 10 {
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%i2, %i2)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i2, %i2)
|
||||
// CHECK-NEXT: store %cst, %0[%2] : memref<1xf32>
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%i2, %i2)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i2, %i2)
|
||||
// CHECK-NEXT: %4 = load %0[%3] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: return
|
||||
@ -375,6 +375,8 @@ func @should_fuse_across_waw_dep_with_private_memref() {
|
||||
|
||||
// -----
|
||||
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (-d0 + d1)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_and_move_to_preserve_war_dep() {
|
||||
func @should_fuse_and_move_to_preserve_war_dep() {
|
||||
%a = alloc() : memref<10xf32>
|
||||
@ -396,9 +398,9 @@ func @should_fuse_and_move_to_preserve_war_dep() {
|
||||
// the WAR dependence from load '%a' in '%i0' to the store '%a' in loop '%i1'.
|
||||
// CHECK: for %i0 = 0 to 10 {
|
||||
// CHECK-NEXT: %2 = load %1[%i0] : memref<10xf32>
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: store %2, %0[%3] : memref<1xf32>
|
||||
// CHECK-NEXT: %4 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: %5 = load %0[%4] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i1 = 0 to 10 {
|
||||
@ -410,6 +412,8 @@ func @should_fuse_and_move_to_preserve_war_dep() {
|
||||
|
||||
// -----
|
||||
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (-d0 + d1)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_with_private_memref_if_top_level_access() {
|
||||
func @should_fuse_with_private_memref_if_top_level_access() {
|
||||
%m = alloc() : memref<10xf32>
|
||||
@ -429,9 +433,9 @@ func @should_fuse_with_private_memref_if_top_level_access() {
|
||||
// CHECK-NEXT: store %cst, %1[%i0] : memref<10xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i1 = 0 to 10 {
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%i1, %i1)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i1, %i1)
|
||||
// CHECK-NEXT: store %cst, %0[%2] : memref<1xf32>
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%i1, %i1)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i1, %i1)
|
||||
// CHECK-NEXT: %4 = load %0[%3] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
return
|
||||
@ -453,9 +457,9 @@ func @should_fuse_no_top_level_access() {
|
||||
%v0 = load %m[%i1] : memref<10xf32>
|
||||
}
|
||||
// CHECK: for %i0 = 0 to 10 {
|
||||
// CHECK-NEXT: %1 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: store %cst, %0[%1] : memref<1xf32>
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: %3 = load %0[%2] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: return
|
||||
@ -569,9 +573,9 @@ func @permute_and_fuse() {
|
||||
|
||||
// -----
|
||||
|
||||
// CHECK-DAG: #map0 = (d0, d1) -> (d0 * 4 + d1)
|
||||
// CHECK-DAG: #map1 = (d0) -> (d0 floordiv 4)
|
||||
// CHECK-DAG: #map2 = (d0) -> (d0 mod 4)
|
||||
// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0 * 4 + d1)
|
||||
// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 floordiv 4)
|
||||
// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0) -> (d0 mod 4)
|
||||
|
||||
// Reshape from a 64 x f32 to 16 x 4 x f32.
|
||||
// CHECK-LABEL: func @fuse_reshape_64_16_4
|
||||
@ -601,8 +605,8 @@ func @fuse_reshape_64_16_4(%in : memref<64xf32>) {
|
||||
}
|
||||
|
||||
// -----
|
||||
// CHECK-DAG: #map0 = (d0) -> (d0 floordiv 4)
|
||||
// CHECK-DAG: #map1 = (d0) -> (d0 mod 4)
|
||||
// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 floordiv 4)
|
||||
// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 mod 4)
|
||||
// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0, d1) -> (d0 * 4 + d1)
|
||||
// CHECK-DAG: [[MAP3:#map[0-9]+]] = (d0, d1) -> (-d0 + d1)
|
||||
|
||||
@ -625,8 +629,8 @@ func @fuse_reshape_16_4_64() {
|
||||
"foo"(%w) : (f32) -> ()
|
||||
}
|
||||
// CHECK: for %i0 = 0 to 64 {
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%i0)
|
||||
// CHECK-NEXT: %3 = affine_apply #map1(%i0)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP1]](%i0)
|
||||
// CHECK-NEXT: %4 = load %1[%2, %3] : memref<16x4xf32>
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP2]](%2, %3)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP3]](%i0, %5)
|
||||
@ -644,7 +648,6 @@ func @fuse_reshape_16_4_64() {
|
||||
|
||||
// All three loop nests below (6-d one, 2-d one, 2-d one is fused into a single
|
||||
// 2-d loop nest).
|
||||
// CHECK-LABEL: func @R6_to_R2_reshape
|
||||
func @R6_to_R2_reshape_square() -> memref<64x9xi32> {
|
||||
%in = alloc() : memref<2x2x3x3x16x1xi32>
|
||||
%out = alloc() : memref<64x9xi32>
|
||||
@ -693,43 +696,65 @@ func @R6_to_R2_reshape_square() -> memref<64x9xi32> {
|
||||
// Everything above is fused to a single 2-d loop nest, and the 6-d tensor %in
|
||||
// is eliminated if -memref-dataflow-opt is also supplied.
|
||||
//
|
||||
// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> ((d0 * 9 + d1) floordiv 288)
|
||||
// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0, d1) -> (((d0 * 9 + d1) mod 288) floordiv 144)
|
||||
// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0, d1) -> ((((d0 * 9 + d1) mod 288) mod 144) floordiv 48)
|
||||
// CHECK-DAG: [[MAP3:#map[0-9]+]] = (d0, d1) -> (((((d0 * 9 + d1) mod 288) mod 144) mod 48) floordiv 16)
|
||||
// CHECK-DAG: [[MAP4:#map[0-9]+]] = (d0, d1) -> (((((d0 * 9 + d1) mod 288) mod 144) mod 48) mod 16)
|
||||
// CHECK-DAG: [[MAP5:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7) -> (d2 - (d0 * 37 + d1 * 36) floordiv 36)
|
||||
// CHECK-DAG: [[MAP6:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7) -> (d3)
|
||||
// CHECK-DAG: [[MAP7:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7) -> (d4)
|
||||
// CHECK-DAG: [[MAP8:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7) -> (d5)
|
||||
// CHECK-DAG: [[MAP9:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7) -> (d6)
|
||||
// CHECK-DAG: [[MAP10:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7) -> (d7)
|
||||
// CHECK-DAG: [[MAP11:#map[0-9]+]] = (d0, d1) -> (d0 * 9 + d1)
|
||||
// CHECK-DAG: [[MAP12:#map[0-9]+]] = (d0) -> (d0 floordiv 288)
|
||||
// CHECK-DAG: [[MAP13:#map[0-9]+]] = (d0) -> ((d0 mod 288) floordiv 144)
|
||||
// CHECK-DAG: [[MAP14:#map[0-9]+]] = (d0) -> (((d0 mod 288) mod 144) floordiv 48)
|
||||
// CHECK-DAG: [[MAP15:#map[0-9]+]] = (d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv 16)
|
||||
// CHECK-DAG: [[MAP16:#map[0-9]+]] = (d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)
|
||||
// CHECK-DAG: [[MAP17:#map[0-9]+]] = (d0) -> (0)
|
||||
// CHECK-DAG: [[MAP18:#map[0-9]+]] = (d0, d1, d2, d3) -> (-d0 + d2)
|
||||
// CHECK-DAG: [[MAP19:#map[0-9]+]] = (d0, d1, d2, d3) -> (-d1 + d3)
|
||||
//
|
||||
// CHECK-LABEL: func @R6_to_R2_reshape
|
||||
// CHECK: %0 = alloc() : memref<1x2x3x3x16x1xi32>
|
||||
// CHECK: %1 = alloc() : memref<1x1xi32>
|
||||
// CHECK: %2 = alloc() : memref<64x9xi32>
|
||||
// CHECK-NEXT: for %i0 = 0 to 64 {
|
||||
// CHECK-NEXT: for %i1 = 0 to 9 {
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%i0, %i1)
|
||||
// CHECK-NEXT: %4 = affine_apply #map1(%i0, %i1)
|
||||
// CHECK-NEXT: %5 = affine_apply #map2(%i0, %i1)
|
||||
// CHECK-NEXT: %6 = affine_apply #map3(%i0, %i1)
|
||||
// CHECK-NEXT: %7 = affine_apply #map4(%i0, %i1)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i1)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP1]](%i0, %i1)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP2]](%i0, %i1)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP3]](%i0, %i1)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP4]](%i0, %i1)
|
||||
// CHECK-NEXT: %8 = "foo"(%3, %4, %5, %6, %7, %c0) : (index, index, index, index, index, index) -> i32
|
||||
// CHECK-NEXT: %9 = affine_apply #map5(%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %10 = affine_apply #map6(%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %11 = affine_apply #map7(%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %12 = affine_apply #map8(%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %13 = affine_apply #map9(%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %14 = affine_apply #map10(%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP5]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %10 = affine_apply [[MAP6]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %11 = affine_apply [[MAP7]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %12 = affine_apply [[MAP8]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %13 = affine_apply [[MAP9]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: %14 = affine_apply [[MAP10]](%i0, %i1, %3, %4, %5, %6, %7, %c0)
|
||||
// CHECK-NEXT: store %8, %0[%9, %10, %11, %12, %13, %14] : memref<1x2x3x3x16x1xi32>
|
||||
// CHECK-NEXT: %15 = affine_apply #map11(%i0, %i1)
|
||||
// CHECK-NEXT: %16 = affine_apply #map12(%15)
|
||||
// CHECK-NEXT: %17 = affine_apply #map13(%15)
|
||||
// CHECK-NEXT: %18 = affine_apply #map14(%15)
|
||||
// CHECK-NEXT: %19 = affine_apply #map15(%15)
|
||||
// CHECK-NEXT: %20 = affine_apply #map16(%15)
|
||||
// CHECK-NEXT: %21 = affine_apply #map17(%15)
|
||||
// CHECK-NEXT: %22 = affine_apply #map5(%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %23 = affine_apply #map6(%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %24 = affine_apply #map7(%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %25 = affine_apply #map8(%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %26 = affine_apply #map9(%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %27 = affine_apply #map10(%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %15 = affine_apply [[MAP11]](%i0, %i1)
|
||||
// CHECK-NEXT: %16 = affine_apply [[MAP12]](%15)
|
||||
// CHECK-NEXT: %17 = affine_apply [[MAP13]](%15)
|
||||
// CHECK-NEXT: %18 = affine_apply [[MAP14]](%15)
|
||||
// CHECK-NEXT: %19 = affine_apply [[MAP15]](%15)
|
||||
// CHECK-NEXT: %20 = affine_apply [[MAP16]](%15)
|
||||
// CHECK-NEXT: %21 = affine_apply [[MAP17]](%15)
|
||||
// CHECK-NEXT: %22 = affine_apply [[MAP5]](%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %23 = affine_apply [[MAP6]](%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %24 = affine_apply [[MAP7]](%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %25 = affine_apply [[MAP8]](%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %26 = affine_apply [[MAP9]](%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %27 = affine_apply [[MAP10]](%i0, %i1, %16, %17, %18, %19, %20, %21)
|
||||
// CHECK-NEXT: %28 = load %0[%22, %23, %24, %25, %26, %27] : memref<1x2x3x3x16x1xi32>
|
||||
// CHECK-NEXT: %29 = affine_apply #map18(%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: %30 = affine_apply #map19(%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: %29 = affine_apply [[MAP18]](%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: %30 = affine_apply [[MAP19]](%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: store %28, %1[%29, %30] : memref<1x1xi32>
|
||||
// CHECK-NEXT: %31 = affine_apply #map18(%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: %32 = affine_apply #map19(%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: %31 = affine_apply [[MAP18]](%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: %32 = affine_apply [[MAP19]](%i0, %i1, %i0, %i1)
|
||||
// CHECK-NEXT: %33 = load %1[%31, %32] : memref<1x1xi32>
|
||||
// CHECK-NEXT: %34 = muli %33, %33 : i32
|
||||
// CHECK-NEXT: store %34, %2[%i0, %i1] : memref<64x9xi32>
|
||||
@ -764,7 +789,7 @@ func @fuse_symbolic_bounds(%M : index, %N : index) {
|
||||
}
|
||||
|
||||
// -----
|
||||
// CHECK-DAG: #map0 = (d0, d1) -> (-d0 + d1)
|
||||
// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> (-d0 + d1)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_reduction_at_depth1
|
||||
func @should_fuse_reduction_at_depth1() {
|
||||
@ -793,19 +818,19 @@ func @should_fuse_reduction_at_depth1() {
|
||||
// memory space.
|
||||
// CHECK: for %i0 = 0 to 10 {
|
||||
// CHECK-NEXT: for %i1 = 0 to 100 {
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: %3 = load %0[%2] : memref<1xf32>
|
||||
// CHECK-NEXT: %4 = load %1[%i0, %i1] : memref<10x100xf32>
|
||||
// CHECK-NEXT: %5 = "maxf"(%3, %4) : (f32, f32) -> f32
|
||||
// CHECK-NEXT: %6 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: store %5, %0[%6] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i2 = 0 to 100 {
|
||||
// CHECK-NEXT: %7 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: %8 = load %0[%7] : memref<1xf32>
|
||||
// CHECK-NEXT: %9 = load %1[%i0, %i2] : memref<10x100xf32>
|
||||
// CHECK-NEXT: %10 = subf %9, %8 : f32
|
||||
// CHECK-NEXT: %11 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %11 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: store %10, %0[%11] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
@ -814,8 +839,8 @@ func @should_fuse_reduction_at_depth1() {
|
||||
}
|
||||
|
||||
// -----
|
||||
// CHECK: #map0 = (d0, d1, d2) -> (-d0 + d1)
|
||||
// CHECK: #map1 = (d0, d1, d2) -> (d2)
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2) -> (-d0 + d1)
|
||||
// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1, d2) -> (d2)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_at_src_depth1_and_dst_depth1
|
||||
func @should_fuse_at_src_depth1_and_dst_depth1() {
|
||||
@ -851,13 +876,13 @@ func @should_fuse_at_src_depth1_and_dst_depth1() {
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i2 = 0 to 16 {
|
||||
// CHECK-NEXT: %3 = "op1"() : () -> f32
|
||||
// CHECK-NEXT: %4 = affine_apply #map0(%i0, %i0, %i2)
|
||||
// CHECK-NEXT: %5 = affine_apply #map1(%i0, %i0, %i2)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0, %i2)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP1]](%i0, %i0, %i2)
|
||||
// CHECK-NEXT: store %3, %0[%4, %5] : memref<1x16xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i3 = 0 to 16 {
|
||||
// CHECK-NEXT: %6 = affine_apply #map0(%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %7 = affine_apply #map1(%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP1]](%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %8 = load %0[%6, %7] : memref<1x16xf32>
|
||||
// CHECK-NEXT: "op2"(%8) : (f32) -> ()
|
||||
// CHECK-NEXT: }
|
||||
@ -867,8 +892,8 @@ func @should_fuse_at_src_depth1_and_dst_depth1() {
|
||||
}
|
||||
|
||||
// -----
|
||||
// CHECK: #map0 = (d0, d1) -> (d0 * 10 + d1)
|
||||
// CHECK: #map1 = (d0, d1, d2) -> (d0 * -10 - d1 + d2)
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0 * 10 + d1)
|
||||
// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1, d2) -> (d0 * -10 - d1 + d2)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_src_depth1_at_dst_depth2
|
||||
func @should_fuse_src_depth1_at_dst_depth2() {
|
||||
@ -889,11 +914,11 @@ func @should_fuse_src_depth1_at_dst_depth2() {
|
||||
// loop IVs, so we should slice at depth 1 and insert the slice at depth 2.
|
||||
// CHECK: for %i0 = 0 to 10 {
|
||||
// CHECK-NEXT: for %i1 = 0 to 10 {
|
||||
// CHECK-NEXT: %1 = affine_apply #map0(%i0, %i1)
|
||||
// CHECK-NEXT: %2 = affine_apply #map1(%i0, %i1, %1)
|
||||
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i1)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%i0, %i1, %1)
|
||||
// CHECK-NEXT: store %cst, %0[%2] : memref<1xf32>
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%i0, %i1)
|
||||
// CHECK-NEXT: %4 = affine_apply #map1(%i0, %i1, %3)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i1)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP1]](%i0, %i1, %3)
|
||||
// CHECK-NEXT: %5 = load %0[%4] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
@ -902,7 +927,7 @@ func @should_fuse_src_depth1_at_dst_depth2() {
|
||||
}
|
||||
|
||||
// -----
|
||||
// CHECK: #map0 = ()[s0] -> (s0)
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = ()[s0] -> (s0)
|
||||
|
||||
// CHECK-LABEL: func @fusion_at_depth0_not_currently_supported
|
||||
func @fusion_at_depth0_not_currently_supported() {
|
||||
@ -919,7 +944,7 @@ func @fusion_at_depth0_not_currently_supported() {
|
||||
// nest, and make the store in the slice store to the same element.
|
||||
// CHECK-DAG: %0 = alloc() : memref<1xf32>
|
||||
// CHECK: for %i0 = 0 to 10 {
|
||||
// CHECK-NEXT: %1 = affine_apply #map0()[%c0]
|
||||
// CHECK-NEXT: %1 = affine_apply [[MAP0]]()[%c0]
|
||||
// CHECK-NEXT: store %cst, %0[%1] : memref<1xf32>
|
||||
// CHECK-NEXT: %2 = load %0[%c0] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
@ -929,12 +954,12 @@ func @fusion_at_depth0_not_currently_supported() {
|
||||
|
||||
// -----
|
||||
|
||||
// CHECK: #map0 = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d0 + d4)
|
||||
// CHECK: #map1 = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d1 + d5)
|
||||
// CHECK: #map2 = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d2 + d6)
|
||||
// CHECK: #map3 = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d3 + d7)
|
||||
// CHECK: #map4 = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (d8)
|
||||
// CHECK: #map5 = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (d9)
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d0 + d4)
|
||||
// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d1 + d5)
|
||||
// CHECK: [[MAP2:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d2 + d6)
|
||||
// CHECK: [[MAP3:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (-d3 + d7)
|
||||
// CHECK: [[MAP4:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (d8)
|
||||
// CHECK: [[MAP5:#map[0-9]+]] = (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) -> (d9)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_deep_loop_nests
|
||||
func @should_fuse_deep_loop_nests() {
|
||||
@ -1011,12 +1036,12 @@ func @should_fuse_deep_loop_nests() {
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i8 = 0 to 16 {
|
||||
// CHECK-NEXT: for %i9 = 0 to 10 {
|
||||
// CHECK-NEXT: %4 = affine_apply #map0(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %5 = affine_apply #map1(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %6 = affine_apply #map2(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %7 = affine_apply #map3(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %8 = affine_apply #map4(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %9 = affine_apply #map5(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP1]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP2]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP3]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MAP4]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP5]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i8, %i9)
|
||||
// CHECK-NEXT: store %cst, %0[%4, %5, %6, %7, %8, %9] : memref<1x1x1x1x16x10xf32, 2>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
@ -1029,12 +1054,12 @@ func @should_fuse_deep_loop_nests() {
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i14 = 0 to 16 {
|
||||
// CHECK-NEXT: for %i15 = 0 to 10 {
|
||||
// CHECK-NEXT: %11 = affine_apply #map0(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %12 = affine_apply #map1(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %13 = affine_apply #map2(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %14 = affine_apply #map3(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %15 = affine_apply #map4(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %16 = affine_apply #map5(%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %11 = affine_apply [[MAP0]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %12 = affine_apply [[MAP1]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %13 = affine_apply [[MAP2]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %14 = affine_apply [[MAP3]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %15 = affine_apply [[MAP4]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %16 = affine_apply [[MAP5]](%i2, %i3, %i0, %i1, %i2, %i3, %i0, %i1, %i14, %i15)
|
||||
// CHECK-NEXT: %17 = load %0[%11, %12, %13, %14, %15, %16] : memref<1x1x1x1x16x10xf32, 2>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
@ -1051,8 +1076,8 @@ func @should_fuse_deep_loop_nests() {
|
||||
}
|
||||
|
||||
// -----
|
||||
// CHECK: #map0 = (d0, d1, d2) -> (-d0 + d1)
|
||||
// CHECK: #map1 = (d0, d1, d2) -> (d2)
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2) -> (-d0 + d1)
|
||||
// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1, d2) -> (d2)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_at_depth1_and_reduce_slice_trip_count
|
||||
func @should_fuse_at_depth1_and_reduce_slice_trip_count() {
|
||||
@ -1091,13 +1116,13 @@ func @should_fuse_at_depth1_and_reduce_slice_trip_count() {
|
||||
// CHECK-NEXT: %2 = load %1[%i0, %i1] : memref<4x256xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i2 = 0 to 16 {
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%i0, %i0, %i2)
|
||||
// CHECK-NEXT: %4 = affine_apply #map1(%i0, %i0, %i2)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0, %i2)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP1]](%i0, %i0, %i2)
|
||||
// CHECK-NEXT: store %cst, %0[%3, %4] : memref<1x16xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i3 = 0 to 16 {
|
||||
// CHECK-NEXT: %5 = affine_apply #map0(%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %6 = affine_apply #map1(%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP1]](%i0, %i0, %i3)
|
||||
// CHECK-NEXT: %7 = load %0[%5, %6] : memref<1x16xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
@ -1210,15 +1235,15 @@ func @should_fuse_with_private_memrefs_with_diff_shapes() {
|
||||
// CHECK-DAG: %0 = alloc() : memref<1xf32>
|
||||
// CHECK-DAG: %1 = alloc() : memref<1xf32>
|
||||
// CHECK: for %i0 = 0 to 17 {
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: store %cst, %0[%2] : memref<1xf32>
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: %4 = load %0[%3] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i1 = 0 to 82 {
|
||||
// CHECK-NEXT: %5 = affine_apply #map0(%i1, %i1)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i1, %i1)
|
||||
// CHECK-NEXT: store %cst, %1[%5] : memref<1xf32>
|
||||
// CHECK-NEXT: %6 = affine_apply #map0(%i1, %i1)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i1, %i1)
|
||||
// CHECK-NEXT: %7 = load %1[%6] : memref<1xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: return
|
||||
@ -1312,30 +1337,30 @@ func @R3_to_R2_reshape() {
|
||||
}
|
||||
return
|
||||
}
|
||||
// CHECK: #map0 = (d0, d1) -> ((d0 * 3 + d1) floordiv 48)
|
||||
// CHECK-NEXT: #map1 = ()[s0] -> (s0)
|
||||
// CHECK-NEXT: #map2 = (d0, d1, d2, d3, d4) -> (d2 - (d0 * 25 + d1 * 24) floordiv 24)
|
||||
// CHECK-NEXT: #map3 = (d0, d1, d2, d3, d4) -> (-d1 + d3)
|
||||
// CHECK-NEXT: #map4 = (d0, d1, d2, d3, d4) -> (d4)
|
||||
// CHECK-NEXT: #map5 = (d0, d1) -> (d0 * 3 + d1)
|
||||
// CHECK-NEXT: #map6 = (d0) -> (d0 floordiv 48)
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> ((d0 * 3 + d1) floordiv 48)
|
||||
// CHECK-NEXT: [[MAP1:#map[0-9]+]] = ()[s0] -> (s0)
|
||||
// CHECK-NEXT: [[MAP2:#map[0-9]+]] = (d0, d1, d2, d3, d4) -> (d2 - (d0 * 25 + d1 * 24) floordiv 24)
|
||||
// CHECK-NEXT: [[MAP3:#map[0-9]+]] = (d0, d1, d2, d3, d4) -> (-d1 + d3)
|
||||
// CHECK-NEXT: [[MAP4:#map[0-9]+]] = (d0, d1, d2, d3, d4) -> (d4)
|
||||
// CHECK-NEXT: [[MAP5:#map[0-9]+]] = (d0, d1) -> (d0 * 3 + d1)
|
||||
// CHECK-NEXT: [[MAP6:#map[0-9]+]] = (d0) -> (d0 floordiv 48)
|
||||
|
||||
// CHECK-LABEL: func @R3_to_R2_reshape()
|
||||
// CHECK-DAG: %0 = alloc() : memref<1x1x1xi32>
|
||||
// CHECK: for %i0 = 0 to 32 {
|
||||
// CHECK-NEXT: for %i1 = 0 to 3 {
|
||||
// CHECK-NEXT: %1 = affine_apply #map0(%i0, %i1)
|
||||
// CHECK-NEXT: %2 = affine_apply #map1()[%c0]
|
||||
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i1)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP1]]()[%c0]
|
||||
// CHECK-NEXT: %3 = "foo"(%1, %i1, %2) : (index, index, index) -> i32
|
||||
// CHECK-NEXT: %4 = affine_apply #map2(%i0, %i1, %1, %i1, %2)
|
||||
// CHECK-NEXT: %5 = affine_apply #map3(%i0, %i1, %1, %i1, %2)
|
||||
// CHECK-NEXT: %6 = affine_apply #map4(%i0, %i1, %1, %i1, %2)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP2]](%i0, %i1, %1, %i1, %2)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP3]](%i0, %i1, %1, %i1, %2)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP4]](%i0, %i1, %1, %i1, %2)
|
||||
// CHECK-NEXT: store %3, %0[%4, %5, %6] : memref<1x1x1xi32>
|
||||
// CHECK-NEXT: %7 = affine_apply #map5(%i0, %i1)
|
||||
// CHECK-NEXT: %8 = affine_apply #map6(%7)
|
||||
// CHECK-NEXT: %9 = affine_apply #map2(%i0, %i1, %8, %i1, %c0)
|
||||
// CHECK-NEXT: %10 = affine_apply #map3(%i0, %i1, %8, %i1, %c0)
|
||||
// CHECK-NEXT: %11 = affine_apply #map4(%i0, %i1, %8, %i1, %c0)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP5]](%i0, %i1)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MAP6]](%7)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP2]](%i0, %i1, %8, %i1, %c0)
|
||||
// CHECK-NEXT: %10 = affine_apply [[MAP3]](%i0, %i1, %8, %i1, %c0)
|
||||
// CHECK-NEXT: %11 = affine_apply [[MAP4]](%i0, %i1, %8, %i1, %c0)
|
||||
// CHECK-NEXT: %12 = load %0[%9, %10, %11] : memref<1x1x1xi32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
@ -1412,6 +1437,8 @@ func @fusion_preventing_deps_on_middle_loop() {
|
||||
|
||||
// -----
|
||||
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (-d0 + d1)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_and_move_to_preserve_war_dep() {
|
||||
func @should_fuse_and_move_to_preserve_war_dep() {
|
||||
%a = alloc() : memref<10xf32>
|
||||
@ -1454,9 +1481,9 @@ func @should_fuse_and_move_to_preserve_war_dep() {
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i1 = 0 to 10 {
|
||||
// CHECK-NEXT: %4 = load %1[%i1] : memref<10xf32>
|
||||
// CHECK-NEXT: %5 = affine_apply #map0(%i1, %i1)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i1, %i1)
|
||||
// CHECK-NEXT: store %4, %0[%5] : memref<1xf32>
|
||||
// CHECK-NEXT: %6 = affine_apply #map0(%i1, %i1)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%i1, %i1)
|
||||
// CHECK-NEXT: %7 = load %0[%6] : memref<1xf32>
|
||||
// CHECK-NEXT: store %cst, %2[%i1] : memref<10xf32>
|
||||
// CHECK-NEXT: }
|
||||
@ -1510,6 +1537,8 @@ func @fusion_preventing_dep_on_constant() {
|
||||
|
||||
// -----
|
||||
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (-d0 + d1)
|
||||
|
||||
// CHECK-LABEL: func @should_fuse_and_preserve_dep_on_constant() {
|
||||
func @should_fuse_and_preserve_dep_on_constant() {
|
||||
%a = alloc() : memref<10xf32>
|
||||
@ -1537,9 +1566,9 @@ func @should_fuse_and_preserve_dep_on_constant() {
|
||||
// CHECK: %cst_0 = constant 1.100000e+01 : f32
|
||||
// CHECK-NEXT: for %i0 = 0 to 10 {
|
||||
// CHECK-NEXT: %3 = load %1[%i0] : memref<10xf32>
|
||||
// CHECK-NEXT: %4 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: store %cst, %0[%4] : memref<1xf32>
|
||||
// CHECK-NEXT: %5 = affine_apply #map0(%i0, %i0)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%i0, %i0)
|
||||
// CHECK-NEXT: %6 = load %0[%5] : memref<1xf32>
|
||||
// CHECK-NEXT: store %cst_0, %2[%i0] : memref<10xf32>
|
||||
// CHECK-NEXT: }
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
// RUN: mlir-opt %s -loop-tile -tile-size=32 | FileCheck %s
|
||||
|
||||
// CHECK-DAG: #map0 = (d0) -> (d0 + 32)
|
||||
// CHECK-DAG: #map1 = (d0) -> (d0 + 32, 50)
|
||||
// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 32)
|
||||
// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 32, 50)
|
||||
// CHECK-DAG: [[IDENTITY:#map[0-9]+]] = (d0) -> (d0)
|
||||
// CHECK-DAG: [[LB:#map[0-9]+]] = ()[s0] -> (0, s0)
|
||||
// CHECK-DAG: [[UB:#map[0-9]+]] = ()[s0, s1] -> (s0, 4096 floordiv s1)
|
||||
@ -11,9 +11,9 @@
|
||||
// CHECK-NEXT: for %i0 = 0 to 256 step 32 {
|
||||
// CHECK-NEXT: for %i1 = 0 to 512 step 32 {
|
||||
// CHECK-NEXT: for %i2 = 0 to 1024 step 32 {
|
||||
// CHECK-NEXT: for %i3 = [[IDENTITY]](%i0) to #map0(%i0) {
|
||||
// CHECK-NEXT: for %i4 = [[IDENTITY]](%i1) to #map0(%i1) {
|
||||
// CHECK-NEXT: for %i5 = [[IDENTITY]](%i2) to #map0(%i2) {
|
||||
// CHECK-NEXT: for %i3 = [[IDENTITY]](%i0) to [[MAP0]](%i0) {
|
||||
// CHECK-NEXT: for %i4 = [[IDENTITY]](%i1) to [[MAP0]](%i1) {
|
||||
// CHECK-NEXT: for %i5 = [[IDENTITY]](%i2) to [[MAP0]](%i2) {
|
||||
// CHECK-NEXT: "foo"(%i3, %i4, %i5) : (index, index, index) -> ()
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
@ -22,7 +22,7 @@
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: for %i6 = 0 to 50 step 32 {
|
||||
// CHECK-NEXT: for %i7 = [[IDENTITY]](%i6) to min #map1(%i6) {
|
||||
// CHECK-NEXT: for %i7 = [[IDENTITY]](%i6) to min [[MAP1]](%i6) {
|
||||
// CHECK-NEXT: "bar"(%i7, %i7) : (index, index) -> ()
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
|
||||
@ -1,5 +1,11 @@
|
||||
// RUN: mlir-opt %s -memref-dataflow-opt -verify | FileCheck %s
|
||||
|
||||
// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d1 + 1)
|
||||
// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0, d1) -> (d0)
|
||||
// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0, d1) -> (d1)
|
||||
// CHECK-DAG: [[MAP3:#map[0-9]+]] = (d0, d1) -> (d0 - 1)
|
||||
// CHECK-DAG: [[MAP4:#map[0-9]+]] = (d0) -> (d0 + 1)
|
||||
|
||||
// CHECK-LABEL: func @simple_store_load() {
|
||||
func @simple_store_load() {
|
||||
%cf7 = constant 7.0 : f32
|
||||
@ -71,10 +77,10 @@ func @store_load_affine_apply() -> memref<10x10xf32> {
|
||||
// CHECK-NEXT: %0 = alloc() : memref<10x10xf32>
|
||||
// CHECK-NEXT: for %i0 = 0 to 10 {
|
||||
// CHECK-NEXT: for %i1 = 0 to 10 {
|
||||
// CHECK-NEXT: %1 = affine_apply #map0(%i0, %i1)
|
||||
// CHECK-NEXT: %2 = affine_apply #map1(%i0, %i1)
|
||||
// CHECK-NEXT: %3 = affine_apply #map2(%1, %2)
|
||||
// CHECK-NEXT: %4 = affine_apply #map3(%1, %2)
|
||||
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%i0, %i1)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%i0, %i1)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP2]](%1, %2)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP3]](%1, %2)
|
||||
// CHECK-NEXT: store %cst, %0[%3, %4] : memref<10x10xf32>
|
||||
// CHECK-NEXT: %5 = addf %cst, %cst : f32
|
||||
// CHECK-NEXT: }
|
||||
@ -234,7 +240,7 @@ func @store_load_store_nested_fwd(%N : index) -> f32 {
|
||||
// CHECK-NEXT: store %cst, %0[%i0] : memref<10xf32>
|
||||
// CHECK-NEXT: for %i1 = 0 to %arg0 {
|
||||
// CHECK-NEXT: %1 = addf %cst, %cst : f32
|
||||
// CHECK-NEXT: %2 = affine_apply #map4(%i0)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP4]](%i0)
|
||||
// CHECK-NEXT: store %cst_0, %0[%2] : memref<10xf32>
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
// CHECK-DAG: [[MOD_2:#map[0-9]+]] = (d0) -> (d0 mod 2)
|
||||
// CHECK-DAG: [[FLOOR_MOD_2:#map[0-9]+]] = (d0) -> ((d0 floordiv 4) mod 2)
|
||||
// CHECK-DAG: [[REMAP_SHIFT_MINUS_4:#map[0-9]+]] = (d0) -> (d0 - 4)
|
||||
// CHECK-DAG: [[MAP_MINUS_1:#map[0-9]+]] = (d0) -> (d0 - 1)
|
||||
|
||||
// CHECK-LABEL: func @loop_nest_dma() {
|
||||
func @loop_nest_dma() {
|
||||
@ -37,7 +38,7 @@ func @loop_nest_dma() {
|
||||
// CHECK-NEXT: %5 = affine_apply [[MOD_2]](%i0)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MOD_2]](%i0)
|
||||
// CHECK-NEXT: dma_start %0[%i0], %1[%5, %i0], %c128, %2[%6, %c0_0] : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
|
||||
// CHECK-NEXT: %7 = affine_apply #map1(%i0)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP_MINUS_1]](%i0)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MOD_2]](%7)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MOD_2]](%7)
|
||||
// CHECK-NEXT: dma_wait %2[%8, %c0_0], %c128 : memref<2x1xf32>
|
||||
@ -48,7 +49,7 @@ func @loop_nest_dma() {
|
||||
// CHECK-NEXT: "do_more_compute"(%7, %i1) : (index, index) -> ()
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: }
|
||||
// CHECK-NEXT: %12 = affine_apply #map1(%c8)
|
||||
// CHECK-NEXT: %12 = affine_apply [[MAP_MINUS_1]](%c8)
|
||||
// CHECK-NEXT: %13 = affine_apply [[MOD_2]](%12)
|
||||
// CHECK-NEXT: %14 = affine_apply [[MOD_2]](%12)
|
||||
// CHECK-NEXT: dma_wait %2[%13, %c0_0], %c128 : memref<2x1xf32>
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// RUN: mlir-opt %s -loop-unroll-jam -unroll-jam-factor=2 | FileCheck %s
|
||||
|
||||
// CHECK: #map0 = (d0) -> (d0 + 1)
|
||||
// CHECK: [[MAP_PLUS_1:#map[0-9]+]] = (d0) -> (d0 + 1)
|
||||
// This should be matched to M1, but M1 is defined later.
|
||||
// CHECK: {{#map[0-9]+}} = ()[s0] -> (s0 + 8)
|
||||
|
||||
@ -10,20 +10,20 @@ func @unroll_jam_imperfect_nest() {
|
||||
// CHECK-NEXT: for %i0 = 0 to 99 step 2 {
|
||||
for %i = 0 to 101 {
|
||||
// CHECK: %0 = "addi32"(%i0, %i0) : (index, index) -> i32
|
||||
// CHECK-NEXT: %1 = affine_apply #map0(%i0)
|
||||
// CHECK-NEXT: %1 = affine_apply [[MAP_PLUS_1]](%i0)
|
||||
// CHECK-NEXT: %2 = "addi32"(%1, %1) : (index, index) -> i32
|
||||
%x = "addi32"(%i, %i) : (index, index) -> i32
|
||||
for %j = 0 to 17 {
|
||||
// CHECK: %3 = "addi32"(%i0, %i0) : (index, index) -> i32
|
||||
// CHECK-NEXT: %4 = "addi32"(%3, %3) : (i32, i32) -> i32
|
||||
// CHECK-NEXT: %5 = affine_apply #map0(%i0)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP_PLUS_1]](%i0)
|
||||
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
|
||||
// CHECK-NEXT: %7 = "addi32"(%6, %6) : (i32, i32) -> i32
|
||||
%y = "addi32"(%i, %i) : (index, index) -> i32
|
||||
%z = "addi32"(%y, %y) : (i32, i32) -> i32
|
||||
}
|
||||
// CHECK: %8 = "addi32"(%i0, %i0) : (index, index) -> i32
|
||||
// CHECK-NEXT: %9 = affine_apply #map0(%i0)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP_PLUS_1]](%i0)
|
||||
// CHECK-NEXT: %10 = "addi32"(%9, %9) : (index, index) -> i32
|
||||
%w = "addi32"(%i, %i) : (index, index) -> i32
|
||||
} // CHECK }
|
||||
|
||||
@ -3,43 +3,43 @@
|
||||
// RUN: mlir-opt %s -loop-unroll -unroll-factor=4 | FileCheck %s --check-prefix UNROLL-BY-4
|
||||
// RUN: mlir-opt %s -loop-unroll -unroll-factor=1 | FileCheck %s --check-prefix UNROLL-BY-1
|
||||
|
||||
// CHECK: #map0 = (d0) -> (d0 + 1)
|
||||
// CHECK: #map1 = (d0) -> (d0 + 2)
|
||||
// CHECK: #map2 = (d0) -> (d0 + 3)
|
||||
// CHECK: #map3 = (d0) -> (d0 + 4)
|
||||
// CHECK: #map4 = (d0, d1) -> (d0 + 1)
|
||||
// CHECK: #map5 = (d0, d1) -> (d0 + 3)
|
||||
// CHECK: #map6 = (d0)[s0] -> (d0 + s0 + 1)
|
||||
// CHECK: #map7 = (d0) -> (d0 + 5)
|
||||
// CHECK: #map8 = (d0) -> (d0 + 6)
|
||||
// CHECK: #map9 = (d0) -> (d0 + 7)
|
||||
// CHECK: #map10 = (d0, d1) -> (d0 * 16 + d1)
|
||||
// CHECK: #map11 = (d0) -> (d0 + 8)
|
||||
// CHECK: #map12 = (d0) -> (d0 + 9)
|
||||
// CHECK: #map13 = (d0) -> (d0 + 10)
|
||||
// CHECK: #map14 = (d0) -> (d0 + 15)
|
||||
// CHECK: #map15 = (d0) -> (d0 + 20)
|
||||
// CHECK: #map16 = (d0) -> (d0 + 25)
|
||||
// CHECK: #map17 = (d0) -> (d0 + 30)
|
||||
// CHECK: #map18 = (d0) -> (d0 + 35)
|
||||
// CHECK: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 1)
|
||||
// CHECK: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 2)
|
||||
// CHECK: [[MAP2:#map[0-9]+]] = (d0) -> (d0 + 3)
|
||||
// CHECK: [[MAP3:#map[0-9]+]] = (d0) -> (d0 + 4)
|
||||
// CHECK: [[MAP4:#map[0-9]+]] = (d0, d1) -> (d0 + 1)
|
||||
// CHECK: [[MAP5:#map[0-9]+]] = (d0, d1) -> (d0 + 3)
|
||||
// CHECK: [[MAP6:#map[0-9]+]] = (d0)[s0] -> (d0 + s0 + 1)
|
||||
// CHECK: [[MAP7:#map[0-9]+]] = (d0) -> (d0 + 5)
|
||||
// CHECK: [[MAP8:#map[0-9]+]] = (d0) -> (d0 + 6)
|
||||
// CHECK: [[MAP9:#map[0-9]+]] = (d0) -> (d0 + 7)
|
||||
// CHECK: [[MAP10:#map[0-9]+]] = (d0, d1) -> (d0 * 16 + d1)
|
||||
// CHECK: [[MAP11:#map[0-9]+]] = (d0) -> (d0 + 8)
|
||||
// CHECK: [[MAP12:#map[0-9]+]] = (d0) -> (d0 + 9)
|
||||
// CHECK: [[MAP13:#map[0-9]+]] = (d0) -> (d0 + 10)
|
||||
// CHECK: [[MAP14:#map[0-9]+]] = (d0) -> (d0 + 15)
|
||||
// CHECK: [[MAP15:#map[0-9]+]] = (d0) -> (d0 + 20)
|
||||
// CHECK: [[MAP16:#map[0-9]+]] = (d0) -> (d0 + 25)
|
||||
// CHECK: [[MAP17:#map[0-9]+]] = (d0) -> (d0 + 30)
|
||||
// CHECK: [[MAP18:#map[0-9]+]] = (d0) -> (d0 + 35)
|
||||
|
||||
// SHORT: #map0 = (d0) -> (d0 + 1)
|
||||
// SHORT: #map1 = (d0) -> (d0 + 2)
|
||||
// SHORT: #map2 = (d0, d1) -> (d0 + 1)
|
||||
// SHORT: #map3 = (d0, d1) -> (d0 + 3)
|
||||
// SHORT: #map4 = (d0)[s0] -> (d0 + s0 + 1)
|
||||
// SHORT: #map5 = (d0, d1) -> (d0 * 16 + d1)
|
||||
// SHORT: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 1)
|
||||
// SHORT: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 2)
|
||||
// SHORT: [[MAP2:#map[0-9]+]] = (d0, d1) -> (d0 + 1)
|
||||
// SHORT: [[MAP3:#map[0-9]+]] = (d0, d1) -> (d0 + 3)
|
||||
// SHORT: [[MAP4:#map[0-9]+]] = (d0)[s0] -> (d0 + s0 + 1)
|
||||
// SHORT: [[MAP5:#map[0-9]+]] = (d0, d1) -> (d0 * 16 + d1)
|
||||
|
||||
// UNROLL-BY-4: #map0 = (d0) -> (d0 + 1)
|
||||
// UNROLL-BY-4: #map1 = (d0) -> (d0 + 2)
|
||||
// UNROLL-BY-4: #map2 = (d0) -> (d0 + 3)
|
||||
// UNROLL-BY-4: #map3 = (d0, d1) -> (d0 + 1)
|
||||
// UNROLL-BY-4: #map4 = (d0, d1) -> (d0 + 3)
|
||||
// UNROLL-BY-4: #map5 = (d0)[s0] -> (d0 + s0 + 1)
|
||||
// UNROLL-BY-4: #map6 = (d0, d1) -> (d0 * 16 + d1)
|
||||
// UNROLL-BY-4: #map7 = (d0) -> (d0 + 5)
|
||||
// UNROLL-BY-4: #map8 = (d0) -> (d0 + 10)
|
||||
// UNROLL-BY-4: #map9 = (d0) -> (d0 + 15)
|
||||
// UNROLL-BY-4: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 1)
|
||||
// UNROLL-BY-4: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 2)
|
||||
// UNROLL-BY-4: [[MAP2:#map[0-9]+]] = (d0) -> (d0 + 3)
|
||||
// UNROLL-BY-4: [[MAP3:#map[0-9]+]] = (d0, d1) -> (d0 + 1)
|
||||
// UNROLL-BY-4: [[MAP4:#map[0-9]+]] = (d0, d1) -> (d0 + 3)
|
||||
// UNROLL-BY-4: [[MAP5:#map[0-9]+]] = (d0)[s0] -> (d0 + s0 + 1)
|
||||
// UNROLL-BY-4: [[MAP6:#map[0-9]+]] = (d0, d1) -> (d0 * 16 + d1)
|
||||
// UNROLL-BY-4: [[MAP7:#map[0-9]+]] = (d0) -> (d0 + 5)
|
||||
// UNROLL-BY-4: [[MAP8:#map[0-9]+]] = (d0) -> (d0 + 10)
|
||||
// UNROLL-BY-4: [[MAP9:#map[0-9]+]] = (d0) -> (d0 + 15)
|
||||
|
||||
// CHECK-LABEL: func @loop_nest_simplest() {
|
||||
func @loop_nest_simplest() {
|
||||
@ -62,11 +62,11 @@ func @loop_nest_simple_iv_use() {
|
||||
// CHECK-NEXT: for %i0 = 0 to 100 step 2 {
|
||||
for %i = 0 to 100 step 2 {
|
||||
// CHECK: %0 = "addi32"(%c0, %c0) : (index, index) -> i32
|
||||
// CHECK: %1 = affine_apply #map0(%c0)
|
||||
// CHECK: %1 = affine_apply [[MAP0]](%c0)
|
||||
// CHECK-NEXT: %2 = "addi32"(%1, %1) : (index, index) -> i32
|
||||
// CHECK: %3 = affine_apply #map1(%c0)
|
||||
// CHECK: %3 = affine_apply [[MAP1]](%c0)
|
||||
// CHECK-NEXT: %4 = "addi32"(%3, %3) : (index, index) -> i32
|
||||
// CHECK: %5 = affine_apply #map2(%c0)
|
||||
// CHECK: %5 = affine_apply [[MAP2]](%c0)
|
||||
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
|
||||
for %j = 0 to 4 {
|
||||
%x = "addi32"(%j, %j) : (index, index) -> i32
|
||||
@ -83,16 +83,16 @@ func @loop_nest_body_def_use() {
|
||||
for %i = 0 to 100 step 2 {
|
||||
// CHECK: %c0_0 = constant 0 : index
|
||||
%c0 = constant 0 : index
|
||||
// CHECK: %0 = affine_apply #map0(%c0)
|
||||
// CHECK: %0 = affine_apply [[MAP0]](%c0)
|
||||
// CHECK-NEXT: %1 = "addi32"(%0, %c0_0) : (index, index) -> index
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%c0)
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%2)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%c0)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%2)
|
||||
// CHECK-NEXT: %4 = "addi32"(%3, %c0_0) : (index, index) -> index
|
||||
// CHECK-NEXT: %5 = affine_apply #map1(%c0)
|
||||
// CHECK-NEXT: %6 = affine_apply #map0(%5)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP1]](%c0)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%5)
|
||||
// CHECK-NEXT: %7 = "addi32"(%6, %c0_0) : (index, index) -> index
|
||||
// CHECK-NEXT: %8 = affine_apply #map2(%c0)
|
||||
// CHECK-NEXT: %9 = affine_apply #map0(%8)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MAP2]](%c0)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP0]](%8)
|
||||
// CHECK-NEXT: %10 = "addi32"(%9, %c0_0) : (index, index) -> index
|
||||
for %j = 0 to 4 {
|
||||
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
|
||||
@ -109,23 +109,23 @@ func @loop_nest_strided() {
|
||||
// CHECK-NEXT: %c2_0 = constant 2 : index
|
||||
// CHECK-NEXT: for %i0 = 0 to 100 {
|
||||
for %i = 0 to 100 {
|
||||
// CHECK: %0 = affine_apply #map0(%c2_0)
|
||||
// CHECK: %0 = affine_apply [[MAP0]](%c2_0)
|
||||
// CHECK-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
|
||||
// CHECK-NEXT: %2 = affine_apply #map1(%c2_0)
|
||||
// CHECK-NEXT: %3 = affine_apply #map0(%2)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP1]](%c2_0)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP0]](%2)
|
||||
// CHECK-NEXT: %4 = "addi32"(%3, %3) : (index, index) -> index
|
||||
for %j = 2 to 6 step 2 {
|
||||
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
|
||||
(index) -> (index)
|
||||
%y = "addi32"(%x, %x) : (index, index) -> index
|
||||
}
|
||||
// CHECK: %5 = affine_apply #map0(%c2)
|
||||
// CHECK: %5 = affine_apply [[MAP0]](%c2)
|
||||
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> index
|
||||
// CHECK-NEXT: %7 = affine_apply #map1(%c2)
|
||||
// CHECK-NEXT: %8 = affine_apply #map0(%7)
|
||||
// CHECK-NEXT: %7 = affine_apply [[MAP1]](%c2)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MAP0]](%7)
|
||||
// CHECK-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> index
|
||||
// CHECK-NEXT: %10 = affine_apply #map3(%c2)
|
||||
// CHECK-NEXT: %11 = affine_apply #map0(%10)
|
||||
// CHECK-NEXT: %10 = affine_apply [[MAP3]](%c2)
|
||||
// CHECK-NEXT: %11 = affine_apply [[MAP0]](%10)
|
||||
// CHECK-NEXT: %12 = "addi32"(%11, %11) : (index, index) -> index
|
||||
for %k = 2 to 7 step 2 {
|
||||
%z = "affine_apply" (%k) { map: (d0) -> (d0 + 1) } :
|
||||
@ -141,7 +141,7 @@ func @loop_nest_multiple_results() {
|
||||
// CHECK: %c0 = constant 0 : index
|
||||
// CHECK-NEXT: for %i0 = 0 to 100 {
|
||||
for %i = 0 to 100 {
|
||||
// CHECK: %0 = affine_apply #map4(%i0, %c0)
|
||||
// CHECK: %0 = affine_apply [[MAP4]](%i0, %c0)
|
||||
// CHECK-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
|
||||
// CHECK-NEXT: %2 = affine_apply #map{{.*}}(%i0, %c0)
|
||||
// CHECK-NEXT: %3 = "fma"(%2, %0, %0) : (index, index, index) -> (index, index)
|
||||
@ -171,19 +171,19 @@ func @loop_nest_seq_imperfect(%a : memref<128x128xf32>) {
|
||||
for %i = 0 to 100 {
|
||||
// CHECK: %0 = "vld"(%i0) : (index) -> i32
|
||||
%ld = "vld"(%i) : (index) -> i32
|
||||
// CHECK: %1 = affine_apply #map0(%c0)
|
||||
// CHECK: %1 = affine_apply [[MAP0]](%c0)
|
||||
// CHECK-NEXT: %2 = "vmulf"(%c0, %1) : (index, index) -> index
|
||||
// CHECK-NEXT: %3 = "vaddf"(%2, %2) : (index, index) -> index
|
||||
// CHECK-NEXT: %4 = affine_apply #map0(%c0)
|
||||
// CHECK-NEXT: %5 = affine_apply #map0(%4)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%c0)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP0]](%4)
|
||||
// CHECK-NEXT: %6 = "vmulf"(%4, %5) : (index, index) -> index
|
||||
// CHECK-NEXT: %7 = "vaddf"(%6, %6) : (index, index) -> index
|
||||
// CHECK-NEXT: %8 = affine_apply #map1(%c0)
|
||||
// CHECK-NEXT: %9 = affine_apply #map0(%8)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MAP1]](%c0)
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP0]](%8)
|
||||
// CHECK-NEXT: %10 = "vmulf"(%8, %9) : (index, index) -> index
|
||||
// CHECK-NEXT: %11 = "vaddf"(%10, %10) : (index, index) -> index
|
||||
// CHECK-NEXT: %12 = affine_apply #map2(%c0)
|
||||
// CHECK-NEXT: %13 = affine_apply #map0(%12)
|
||||
// CHECK-NEXT: %12 = affine_apply [[MAP2]](%c0)
|
||||
// CHECK-NEXT: %13 = affine_apply [[MAP0]](%12)
|
||||
// CHECK-NEXT: %14 = "vmulf"(%12, %13) : (index, index) -> index
|
||||
// CHECK-NEXT: %15 = "vaddf"(%14, %14) : (index, index) -> index
|
||||
for %j = 0 to 4 {
|
||||
@ -204,16 +204,16 @@ func @loop_nest_seq_imperfect(%a : memref<128x128xf32>) {
|
||||
func @loop_nest_seq_multiple() {
|
||||
// CHECK: c0 = constant 0 : index
|
||||
// CHECK-NEXT: %c0_0 = constant 0 : index
|
||||
// CHECK-NEXT: %0 = affine_apply #map0(%c0_0)
|
||||
// CHECK-NEXT: %0 = affine_apply [[MAP0]](%c0_0)
|
||||
// CHECK-NEXT: "mul"(%0, %0) : (index, index) -> ()
|
||||
// CHECK-NEXT: %1 = affine_apply #map0(%c0_0)
|
||||
// CHECK-NEXT: %2 = affine_apply #map0(%1)
|
||||
// CHECK-NEXT: %1 = affine_apply [[MAP0]](%c0_0)
|
||||
// CHECK-NEXT: %2 = affine_apply [[MAP0]](%1)
|
||||
// CHECK-NEXT: "mul"(%2, %2) : (index, index) -> ()
|
||||
// CHECK-NEXT: %3 = affine_apply #map1(%c0_0)
|
||||
// CHECK-NEXT: %4 = affine_apply #map0(%3)
|
||||
// CHECK-NEXT: %3 = affine_apply [[MAP1]](%c0_0)
|
||||
// CHECK-NEXT: %4 = affine_apply [[MAP0]](%3)
|
||||
// CHECK-NEXT: "mul"(%4, %4) : (index, index) -> ()
|
||||
// CHECK-NEXT: %5 = affine_apply #map2(%c0_0)
|
||||
// CHECK-NEXT: %6 = affine_apply #map0(%5)
|
||||
// CHECK-NEXT: %5 = affine_apply [[MAP2]](%c0_0)
|
||||
// CHECK-NEXT: %6 = affine_apply [[MAP0]](%5)
|
||||
// CHECK-NEXT: "mul"(%6, %6) : (index, index) -> ()
|
||||
for %j = 0 to 4 {
|
||||
%x = "affine_apply" (%j) { map: (d0) -> (d0 + 1) } :
|
||||
@ -225,17 +225,17 @@ func @loop_nest_seq_multiple() {
|
||||
%k = "constant"(){value: 99} : () -> index
|
||||
// CHECK: for %i0 = 0 to 100 step 2 {
|
||||
for %m = 0 to 100 step 2 {
|
||||
// CHECK: %7 = affine_apply #map0(%c0)
|
||||
// CHECK-NEXT: %8 = affine_apply #map6(%c0)[%c99]
|
||||
// CHECK-NEXT: %9 = affine_apply #map0(%c0)
|
||||
// CHECK-NEXT: %10 = affine_apply #map0(%9)
|
||||
// CHECK-NEXT: %11 = affine_apply #map6(%9)[%c99]
|
||||
// CHECK-NEXT: %12 = affine_apply #map1(%c0)
|
||||
// CHECK-NEXT: %13 = affine_apply #map0(%12)
|
||||
// CHECK-NEXT: %14 = affine_apply #map6(%12)[%c99]
|
||||
// CHECK-NEXT: %15 = affine_apply #map2(%c0)
|
||||
// CHECK-NEXT: %16 = affine_apply #map0(%15)
|
||||
// CHECK-NEXT: %17 = affine_apply #map6(%15)[%c99]
|
||||
// CHECK: %7 = affine_apply [[MAP0]](%c0)
|
||||
// CHECK-NEXT: %8 = affine_apply [[MAP6]](%c0)[%c99]
|
||||
// CHECK-NEXT: %9 = affine_apply [[MAP0]](%c0)
|
||||
// CHECK-NEXT: %10 = affine_apply [[MAP0]](%9)
|
||||
// CHECK-NEXT: %11 = affine_apply [[MAP6]](%9)[%c99]
|
||||
// CHECK-NEXT: %12 = affine_apply [[MAP1]](%c0)
|
||||
// CHECK-NEXT: %13 = affine_apply [[MAP0]](%12)
|
||||
// CHECK-NEXT: %14 = affine_apply [[MAP6]](%12)[%c99]
|
||||
// CHECK-NEXT: %15 = affine_apply [[MAP2]](%c0)
|
||||
// CHECK-NEXT: %16 = affine_apply [[MAP0]](%15)
|
||||
// CHECK-NEXT: %17 = affine_apply [[MAP6]](%15)[%c99]
|
||||
for %n = 0 to 4 {
|
||||
%y = "affine_apply" (%n) { map: (d0) -> (d0 + 1) } :
|
||||
(index) -> (index)
|
||||
@ -249,11 +249,11 @@ func @loop_nest_seq_multiple() {
|
||||
// SHORT-LABEL: func @loop_nest_outer_unroll() {
|
||||
func @loop_nest_outer_unroll() {
|
||||
// SHORT: for %i0 = 0 to 4 {
|
||||
// SHORT-NEXT: %0 = affine_apply #map0(%i0)
|
||||
// SHORT-NEXT: %0 = affine_apply [[MAP0]](%i0)
|
||||
// SHORT-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
|
||||
// SHORT-NEXT: }
|
||||
// SHORT-NEXT: for %i1 = 0 to 4 {
|
||||
// SHORT-NEXT: %2 = affine_apply #map0(%i1)
|
||||
// SHORT-NEXT: %2 = affine_apply [[MAP0]](%i1)
|
||||
// SHORT-NEXT: %3 = "addi32"(%2, %2) : (index, index) -> index
|
||||
// SHORT-NEXT: }
|
||||
for %i = 0 to 2 {
|
||||
@ -411,11 +411,11 @@ func @loop_nest_single_iteration_after_unroll(%N: index) {
|
||||
// UNROLL-BY-4: for %i0 = 0 to %arg0 {
|
||||
for %i = 0 to %N {
|
||||
// UNROLL-BY-4: %0 = "addi32"(%c0, %c0) : (index, index) -> i32
|
||||
// UNROLL-BY-4-NEXT: %1 = affine_apply #map0(%c0)
|
||||
// UNROLL-BY-4-NEXT: %1 = affine_apply [[MAP0]](%c0)
|
||||
// UNROLL-BY-4-NEXT: %2 = "addi32"(%1, %1) : (index, index) -> i32
|
||||
// UNROLL-BY-4-NEXT: %3 = affine_apply #map1(%c0)
|
||||
// UNROLL-BY-4-NEXT: %3 = affine_apply [[MAP1]](%c0)
|
||||
// UNROLL-BY-4-NEXT: %4 = "addi32"(%3, %3) : (index, index) -> i32
|
||||
// UNROLL-BY-4-NEXT: %5 = affine_apply #map2(%c0)
|
||||
// UNROLL-BY-4-NEXT: %5 = affine_apply [[MAP2]](%c0)
|
||||
// UNROLL-BY-4-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
|
||||
// UNROLL-BY-4-NEXT: %7 = "addi32"(%c4, %c4) : (index, index) -> i32
|
||||
// UNROLL-BY-4-NOT: for
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user