This is an archive of the discontinued LLVM Phabricator instance.

Differential D75823

[MLIR] NFC: modernize affine loop fusion test cases
ClosedPublic

Authored by bondhugula on Mar 8 2020, 3:08 AM.

Details

Reviewers
dcaballe
andydavis1
rriddle
mehdi_amini
nicolasvasilache
Commits
rG5e080dff7564: [MLIR] NFC: modernize affine loop fusion test cases
Summary
  • update test case for readability, avoid unnecessary matches

Signed-off-by: Uday Bondhugula <uday@polymagelabs.com>

Diff Detail

Event Timeline

bondhugula created this revision.Mar 8 2020, 3:08 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 8 2020, 3:08 AM
Herald added subscribers: llvm-commits, Joonsoo, liufengdb and 9 others. · View Herald Transcript
bondhugula updated this revision to Diff 248990.Mar 8 2020, 3:14 AM

Remove another redundant check.

Harbormaster completed remote builds in B48486: Diff 248989.Mar 8 2020, 3:43 AM
Harbormaster completed remote builds in B48487: Diff 248990.Mar 8 2020, 4:15 AM
mehdi_amini accepted this revision.Mar 8 2020, 11:05 AM
This revision is now accepted and ready to land.Mar 8 2020, 11:05 AM
nicolasvasilache accepted this revision.Mar 8 2020, 11:57 AM

LG, thanks for the cleanup Uday!

bondhugula added a comment.Mar 8 2020, 8:10 PM

@nicolasvasilache can you please commit this for me?

Closed by commit rG5e080dff7564: [MLIR] NFC: modernize affine loop fusion test cases (authored by bondhugula, committed by • joker-eph-DISABLED). · Explain WhyMar 8 2020, 9:50 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
mlir/
test/
Transforms/
462 lines

Diff 249028

mlir/test/Transforms/loop-fusion.mlir

Show All 17 Linesfunc @should_fuse_raw_dep_for_locality() {
affine.for %i0 = 0 to 10 { affine.for %i0 = 0 to 10 {
affine.store %cf7, %m[%i0] : memref<10xf32> affine.store %cf7, %m[%i0] : memref<10xf32>
} }
affine.for %i1 = 0 to 10 { affine.for %i1 = 0 to 10 {
%v0 = affine.load %m[%i1] : memref<10xf32> %v0 = affine.load %m[%i1] : memref<10xf32>
} }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_reduction_to_pointwise() { // CHECK-LABEL: func @should_fuse_reduction_to_pointwise() {
Show All 16 Lines affine.for %i2 = 0 to 10 {
%v4 = affine.load %b[%i2] : memref<10xf32> %v4 = affine.load %b[%i2] : memref<10xf32>
affine.store %v4, %c[%i2] : memref<10xf32> affine.store %v4, %c[%i2] : memref<10xf32>
} }
// Should fuse in entire inner loop on %i1 from source loop nest, as %i1 // Should fuse in entire inner loop on %i1 from source loop nest, as %i1
// is not used in the access function of the store/load on %b. // is not used in the access function of the store/load on %b.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-DAG: [[MAP_SHIFT_MINUS_ONE_R1:#map[0-9]+]] = affine_map<(d0) -> (d0 - 1)> // CHECK-DAG: [[MAP_SHIFT_MINUS_ONE_R1:#map[0-9]+]] = affine_map<(d0) -> (d0 - 1)>
// CHECK-DAG: [[MAP_SHIFT_BY_ONE:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)> // CHECK-DAG: [[MAP_SHIFT_D0_BY_ONE:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 1)>
// CHECK-DAG: [[MAP_SHIFT_D1_BY_ONE:#map[0-9]+]] = affine_map<(d0, d1) -> (d1 + 1)>
// CHECK-LABEL: func @should_fuse_loop_nests_with_shifts() { // CHECK-LABEL: func @should_fuse_loop_nests_with_shifts() {
func @should_fuse_loop_nests_with_shifts() { func @should_fuse_loop_nests_with_shifts() {
%a = alloc() : memref<10x10xf32> %a = alloc() : memref<10x10xf32>
%cf7 = constant 7.0 : f32 %cf7 = constant 7.0 : f32
affine.for %i0 = 0 to 9 { affine.for %i0 = 0 to 9 {
affine.for %i1 = 0 to 9 { affine.for %i1 = 0 to 9 {
%idx = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0) affine.store %cf7, %a[%i0 + 1, %i1 + 1] : memref<10x10xf32>
%idy = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)
affine.store %cf7, %a[%idx, %idy] : memref<10x10xf32>
} }
} }
affine.for %i2 = 1 to 10 { affine.for %i2 = 1 to 10 {
affine.for %i3 = 1 to 10 { affine.for %i3 = 1 to 10 {
%v0 = affine.load %a[%i2, %i3] : memref<10x10xf32> %v0 = affine.load %a[%i2, %i3] : memref<10x10xf32>
} }
} }
// Source slice affine apply sequence: // Source slice affine apply sequence:
// *) First two affine apply's map from the dst to src iteration space. // *) First two affine apply's map from the dst to src iteration space.
// *) Third affine apply is access function around src store. // *) Third affine apply is access function around src store.
// *) Fourth affine apply shifts the stores access function by '-1', because // *) Fourth affine apply shifts the stores access function by '-1', because
// of the offset induced by reducing the memref shape from 10x10 to 9x9. // of the offset induced by reducing the memref shape from 10x10 to 9x9.
// *) Fifth affine apply shifts the loads access function by '-1', because // *) Fifth affine apply shifts the loads access function by '-1', because
// of the offset induced by reducing the memref shape from 10x10 to 9x9. // of the offset induced by reducing the memref shape from 10x10 to 9x9.
// NOTE: Should create a private memref with reduced shape 9x9xf32. // NOTE: Should create a private memref with reduced shape 9x9xf32.
// CHECK: affine.for %{{.*}} = 1 to 10 { // CHECK: affine.for %{{.*}} = 1 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 1 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 1 to 10 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_SHIFT_MINUS_ONE_R1]](%{{.*}}) // CHECK-NEXT: %[[I:.*]] = affine.apply [[MAP_SHIFT_MINUS_ONE_R1]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_SHIFT_MINUS_ONE_R1]](%{{.*}}) // CHECK-NEXT: %[[J:.*]] = affine.apply [[MAP_SHIFT_MINUS_ONE_R1]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_SHIFT_BY_ONE]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP_SHIFT_D0_BY_ONE]](%[[I]], %[[J]])
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_SHIFT_BY_ONE]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP_SHIFT_D1_BY_ONE]](%[[I]], %[[J]])
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 20 Lines affine.for %i4 = 0 to 10 {
} }
} }
// Expecting private memref for '%a' first, then private memref for '%b'. // Expecting private memref for '%a' first, then private memref for '%b'.
// CHECK-DAG: [[NEWA:%[0-9]+]] = alloc() : memref<1x1xf32> // CHECK-DAG: [[NEWA:%[0-9]+]] = alloc() : memref<1x1xf32>
// CHECK-DAG: [[NEWB:%[0-9]+]] = alloc() : memref<1x1xf32> // CHECK-DAG: [[NEWB:%[0-9]+]] = alloc() : memref<1x1xf32>
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, [[NEWA]][0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, [[NEWA]][0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load [[NEWA]][0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load [[NEWA]][0, 0] : memref<1x1xf32>
// CHECK-NEXT: affine.store %{{.*}}, [[NEWB]][0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, [[NEWB]][0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load [[NEWB]][0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load [[NEWB]][0, 0] : memref<1x1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 17 Linesfunc @should_fuse_across_intermediate_loop_with_no_deps() {
} }
// Should fuse first loop (past second loop with no dependences) into third. // Should fuse first loop (past second loop with no dependences) into third.
// Note that fusion creates a private memref '%2' for the fused loop nest. // Note that fusion creates a private memref '%2' for the fused loop nest.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_all_loops() { // CHECK-LABEL: func @should_fuse_all_loops() {
Show All 16 Linesfunc @should_fuse_all_loops() {
// Should fuse first and second loops into third. // Should fuse first and second loops into third.
// Expecting private memref for '%a' first, then private memref for '%b'. // Expecting private memref for '%a' first, then private memref for '%b'.
// CHECK-DAG: [[NEWA:%[0-9]+]] = alloc() : memref<1xf32> // CHECK-DAG: [[NEWA:%[0-9]+]] = alloc() : memref<1xf32>
// CHECK-DAG: [[NEWB:%[0-9]+]] = alloc() : memref<1xf32> // CHECK-DAG: [[NEWB:%[0-9]+]] = alloc() : memref<1xf32>
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, [[NEWA]][0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, [[NEWA]][0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, [[NEWB]][0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, [[NEWB]][0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load [[NEWA]][0] : memref<1xf32> // CHECK-NEXT: affine.load [[NEWA]][0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load [[NEWB]][0] : memref<1xf32> // CHECK-NEXT: affine.load [[NEWB]][0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_first_and_second_loops() { // CHECK-LABEL: func @should_fuse_first_and_second_loops() {
Show All 14 Linesfunc @should_fuse_first_and_second_loops() {
affine.for %i2 = 0 to 10 { affine.for %i2 = 0 to 10 {
%v1 = affine.load %c[%i2] : memref<10xf32> %v1 = affine.load %c[%i2] : memref<10xf32>
} }
// Should fuse first loop into the second (last loop should not be fused). // Should fuse first loop into the second (last loop should not be fused).
// Should create private memref '%2' for fused loop. // Should create private memref '%2' for fused loop.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 18 Lines affine.for %i1 = 0 to 10 {
%v1 = affine.load %c[%i1] : memref<10xf32> %v1 = affine.load %c[%i1] : memref<10xf32>
} }
affine.for %i2 = 0 to 10 { affine.for %i2 = 0 to 10 {
%v2 = affine.load %b[%i2] : memref<10xf32> %v2 = affine.load %b[%i2] : memref<10xf32>
affine.store %cf7, %c[%i2] : memref<10xf32> affine.store %cf7, %c[%i2] : memref<10xf32>
} }
// Should not fuse: fusing loop first loop into last would create a cycle. // Should not fuse: fusing loop first loop into last would create a cycle.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 10 Linesfunc @should_fuse_producer_consumer() {
} }
affine.for %i2 = 0 to 10 { affine.for %i2 = 0 to 10 {
%v1 = affine.load %m[%i2] : memref<10xf32> %v1 = affine.load %m[%i2] : memref<10xf32>
} }
// Fusing loop %i0 to %i2 would violate the WAW dependence between %i0 and // Fusing loop %i0 to %i2 would violate the WAW dependence between %i0 and
// %i1, but OK to fuse %i1 into %i2. // %i1, but OK to fuse %i1 into %i2.
// TODO(andydavis) When the fusion pass is run to a fixed-point, it should // TODO(andydavis) When the fusion pass is run to a fixed-point, it should
// fuse all three of these loop nests. // fuse all three of these loop nests.
// CHECK: %{{.*}} = alloc() : memref<1xf32> // CHECK: alloc() : memref<1xf32>
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_and_move_to_preserve_war_dep() { // CHECK-LABEL: func @should_fuse_and_move_to_preserve_war_dep() {
Show All 11 Linesfunc @should_fuse_and_move_to_preserve_war_dep() {
} }
affine.for %i2 = 0 to 10 { affine.for %i2 = 0 to 10 {
%v1 = affine.load %b[%i2] : memref<10xf32> %v1 = affine.load %b[%i2] : memref<10xf32>
} }
// Loops '%i1' and '%i2' have no dependences. We can fuse a slice of '%i0' // Loops '%i1' and '%i2' have no dependences. We can fuse a slice of '%i0'
// into '%i2' if we move the fused loop nest before '%i1', which preserves // into '%i2' if we move the fused loop nest before '%i1', which preserves
// the WAR dependence from load '%a' in '%i0' to the store '%a' in loop '%i1'. // the WAR dependence from load '%a' in '%i0' to the store '%a' in loop '%i1'.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
Show All 14 Linesfunc @should_fuse_with_private_memref_if_top_level_access() {
%c0 = constant 4 : index %c0 = constant 4 : index
%v1 = affine.load %m[%c0] : memref<10xf32> %v1 = affine.load %m[%c0] : memref<10xf32>
// Top-level load to '%{{.*}}' should prevent fusion. // Top-level load to '%{{.*}}' should prevent fusion.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_no_top_level_access() { // CHECK-LABEL: func @should_fuse_no_top_level_access() {
func @should_fuse_no_top_level_access() { func @should_fuse_no_top_level_access() {
%m = alloc() : memref<10xf32> %m = alloc() : memref<10xf32>
%cf7 = constant 7.0 : f32 %cf7 = constant 7.0 : f32
affine.for %i0 = 0 to 10 { affine.for %i0 = 0 to 10 {
affine.store %cf7, %m[%i0] : memref<10xf32> affine.store %cf7, %m[%i0] : memref<10xf32>
} }
affine.for %i1 = 0 to 10 { affine.for %i1 = 0 to 10 {
%v0 = affine.load %m[%i1] : memref<10xf32> %v0 = affine.load %m[%i1] : memref<10xf32>
} }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
#set0 = affine_set<(d0) : (1 == 0)> #set0 = affine_set<(d0) : (1 == 0)>
Show All 12 Linesfunc @should_not_fuse_if_inst_at_top_level() {
%c0 = constant 4 : index %c0 = constant 4 : index
affine.if #set0(%c0) { affine.if #set0(%c0) {
} }
// Top-level IfOp should prevent fusion. // Top-level IfOp should prevent fusion.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
// ----- // -----
#set0 = affine_set<(d0) : (1 == 0)> #set0 = affine_set<(d0) : (1 == 0)>
Show All 13 Linesfunc @should_not_fuse_if_inst_in_loop_nest() {
} }
// IfOp in ForInst should prevent fusion. // IfOp in ForInst should prevent fusion.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%{{.*}}) { // CHECK-NEXT: affine.if #set0(%{{.*}}) {
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
// ----- // -----
// CHECK-LABEL: func @permute_and_fuse() { // CHECK-LABEL: func @permute_and_fuse() {
func @permute_and_fuse() { func @permute_and_fuse() {
Show All 14 Lines affine.for %i4 = 0 to 10 {
"foo"(%v0) : (f32) -> () "foo"(%v0) : (f32) -> ()
} }
} }
} }
// CHECK: affine.for %{{.*}} = 0 to 30 { // CHECK: affine.for %{{.*}} = 0 to 30 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 20 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 20 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0, 0] : memref<1x1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0, 0] : memref<1x1x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0, 0] : memref<1x1x1xf32> // CHECK-NEXT: affine.load %{{.*}}[0, 0, 0] : memref<1x1x1xf32>
// CHECK-NEXT: "foo"(%{{.*}}) : (f32) -> () // CHECK-NEXT: "foo"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1)> // CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1)>
// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 4)> // CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 4)>
// CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 4)> // CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 4)>
// Reshape from a 64 x f32 to 16 x 4 x f32. // Reshape from a 64 x f32 to 16 x 4 x f32.
// CHECK-LABEL: func @fuse_reshape_64_16_4 // CHECK-LABEL: func @fuse_reshape_64_16_4
func @fuse_reshape_64_16_4(%in : memref<64xf32>) { func @fuse_reshape_64_16_4(%in : memref<64xf32>) {
%out = alloc() : memref<16x4xf32> %out = alloc() : memref<16x4xf32>
affine.for %i0 = 0 to 64 { affine.for %i0 = 0 to 64 {
%v = affine.load %in[%i0] : memref<64xf32> %v = affine.load %in[%i0] : memref<64xf32>
%idx = affine.apply affine_map<(d0) -> (d0 floordiv 4)> (%i0) affine.store %v, %out[%i0 floordiv 4, %i0 mod 4] : memref<16x4xf32>
%idy = affine.apply affine_map<(d0) -> (d0 mod 4)> (%i0)
affine.store %v, %out[%idx, %idy] : memref<16x4xf32>
} }
affine.for %i1 = 0 to 16 { affine.for %i1 = 0 to 16 {
affine.for %i2 = 0 to 4 { affine.for %i2 = 0 to 4 {
%w = affine.load %out[%i1, %i2] : memref<16x4xf32> %w = affine.load %out[%i1, %i2] : memref<16x4xf32>
"foo"(%w) : (f32) -> () "foo"(%w) : (f32) -> ()
} }
} }
Show All 15 Lines
// CHECK-LABEL: func @fuse_reshape_16_4_64 // CHECK-LABEL: func @fuse_reshape_16_4_64
func @fuse_reshape_16_4_64() { func @fuse_reshape_16_4_64() {
%in = alloc() : memref<16x4xf32> %in = alloc() : memref<16x4xf32>
%out = alloc() : memref<64xf32> %out = alloc() : memref<64xf32>
affine.for %i0 = 0 to 16 { affine.for %i0 = 0 to 16 {
affine.for %i1 = 0 to 4 { affine.for %i1 = 0 to 4 {
%v = affine.load %in[%i0, %i1] : memref<16x4xf32> %v = affine.load %in[%i0, %i1] : memref<16x4xf32>
%idx = affine.apply affine_map<(d0, d1) -> (4*d0 + d1)> (%i0, %i1) affine.store %v, %out[4*%i0 + %i1] : memref<64xf32>
affine.store %v, %out[%idx] : memref<64xf32>
} }
} }
affine.for %i2 = 0 to 64 { affine.for %i2 = 0 to 64 {
%w = affine.load %out[%i2] : memref<64xf32> %w = affine.load %out[%i2] : memref<64xf32>
"foo"(%w) : (f32) -> () "foo"(%w) : (f32) -> ()
} }
// CHECK: affine.for %{{.*}} = 0 to 64 { // CHECK: affine.for %{{.*}} = 0 to 64 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP0]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP0]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP1]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP1]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<16x4xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<16x4xf32>
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP2]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP2]](%{{.*}}, %{{.*}})
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: "foo"(%{{.*}}) : (f32) -> () // CHECK-NEXT: "foo"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
// CHECK-DAG: [[MAP13:#map[0-9]+]] = affine_map<(d0) -> ((d0 mod 288) floordiv 144)> // CHECK-DAG: [[MAP13:#map[0-9]+]] = affine_map<(d0) -> ((d0 mod 288) floordiv 144)>
// CHECK-DAG: [[MAP14:#map[0-9]+]] = affine_map<(d0) -> (((d0 mod 288) mod 144) floordiv 48)> // CHECK-DAG: [[MAP14:#map[0-9]+]] = affine_map<(d0) -> (((d0 mod 288) mod 144) floordiv 48)>
// CHECK-DAG: [[MAP15:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv 16)> // CHECK-DAG: [[MAP15:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv 16)>
// CHECK-DAG: [[MAP16:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)> // CHECK-DAG: [[MAP16:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)>
// CHECK-DAG: [[MAP17:#map[0-9]+]] = affine_map<(d0) -> (0)> // CHECK-DAG: [[MAP17:#map[0-9]+]] = affine_map<(d0) -> (0)>
// //
// CHECK-LABEL: func @R6_to_R2_reshape // CHECK-LABEL: func @R6_to_R2_reshape
// CHECK: %{{.*}} = alloc() : memref<1x2x3x3x16x1xi32> // CHECK: alloc() : memref<1x2x3x3x16x1xi32>
// CHECK: %{{.*}} = alloc() : memref<1x1xi32> // CHECK: alloc() : memref<1x1xi32>
// CHECK: %{{.*}} = alloc() : memref<64x9xi32> // CHECK: alloc() : memref<64x9xi32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 64 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 64 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 9 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 9 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP0]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP1]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP1]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP2]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP2]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP3]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP3]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP4]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP4]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = "foo"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index, index, index, index) -> i32 // CHECK-NEXT: "foo"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index, index, index, index) -> i32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, ((%{{.*}} * 9 + %{{.*}}) mod 288) floordiv 144, (((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) floordiv 48, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) floordiv 16, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) mod 16, 0] : memref<1x2x3x3x16x1xi32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, ((%{{.*}} * 9 + %{{.*}}) mod 288) floordiv 144, (((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) floordiv 48, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) floordiv 16, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) mod 16, 0] : memref<1x2x3x3x16x1xi32>
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP11]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP11]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP12]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP12]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP13]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP13]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP14]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP14]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP15]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP15]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP16]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP16]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP17]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP17]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, ((%{{.*}} * 9 + %{{.*}}) mod 288) floordiv 144, (((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) floordiv 48, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) floordiv 16, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) mod 16, 0] : memref<1x2x3x3x16x1xi32> // CHECK-NEXT: affine.load %{{.*}}[0, ((%{{.*}} * 9 + %{{.*}}) mod 288) floordiv 144, (((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) floordiv 48, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) floordiv 16, ((((%{{.*}} * 9 + %{{.*}}) mod 288) mod 144) mod 48) mod 16, 0] : memref<1x2x3x3x16x1xi32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xi32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xi32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0] : memref<1x1xi32> // CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xi32>
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : i32 // CHECK-NEXT: muli %{{.*}}, %{{.*}} : i32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<64x9xi32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<64x9xi32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return %{{.*}} : memref<64x9xi32> // CHECK-NEXT: return %{{.*}} : memref<64x9xi32>
// ----- // -----
// CHECK-LABEL: func @fuse_symbolic_bounds // CHECK-LABEL: func @fuse_symbolic_bounds
func @fuse_symbolic_bounds(%M : index, %N : index) { func @fuse_symbolic_bounds(%M : index, %N : index) {
%N_plus_5 = affine.apply affine_map<(d0) -> (d0 + 5)>(%N) %N_plus_5 = affine.apply affine_map<(d0) -> (d0 + 5)>(%N)
%m = alloc(%M, %N_plus_5) : memref<? x ? x f32> %m = alloc(%M, %N_plus_5) : memref<? x ? x f32>
%c0 = constant 0.0 : f32 %c0 = constant 0.0 : f32
%s = constant 5 : index %s = constant 5 : index
affine.for %i0 = 0 to %M { affine.for %i0 = 0 to %M {
affine.for %i1 = 0 to affine_map<(d0) -> (d0 + 5)> (%N) { affine.for %i1 = 0 to affine_map<(d0) -> (d0 + 5)> (%N) {
affine.store %c0, %m[%i0, %i1] : memref<? x ? x f32> affine.store %c0, %m[%i0, %i1] : memref<? x ? x f32>
} }
} }
affine.for %i2 = 0 to %M { affine.for %i2 = 0 to %M {
affine.for %i3 = 0 to %N { affine.for %i3 = 0 to %N {
%idy = affine.apply affine_map<(d0)[s0] -> (d0 + s0)> (%i3)[%s] %v = affine.load %m[%i2, %i3 + symbol(%s)] : memref<? x ? x f32>
%v = affine.load %m[%i2, %idy] : memref<? x ? x f32>
} }
} }
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_reduction_at_depth1 // CHECK-LABEL: func @should_fuse_reduction_at_depth_of_one
func @should_fuse_reduction_at_depth1() { func @should_fuse_reduction_at_depth_of_one() {
%a = alloc() : memref<10x100xf32> %a = alloc() : memref<10x100xf32>
%b = alloc() : memref<10xf32> %b = alloc() : memref<10xf32>
affine.for %i0 = 0 to 10 { affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 100 { affine.for %i1 = 0 to 100 {
%v0 = affine.load %b[%i0] : memref<10xf32> %v0 = affine.load %b[%i0] : memref<10xf32>
%v1 = affine.load %a[%i0, %i1] : memref<10x100xf32> %v1 = affine.load %a[%i0, %i1] : memref<10x100xf32>
%v2 = "maxf"(%v0, %v1) : (f32, f32) -> f32 %v2 = "maxf"(%v0, %v1) : (f32, f32) -> f32
Show All 9 Lines affine.for %i2 = 0 to 10 {
} }
} }
// This test should fuse the src reduction loop at depth 1 in the destination // This test should fuse the src reduction loop at depth 1 in the destination
// loop nest, which improves locality and enables subsequence passes to // loop nest, which improves locality and enables subsequence passes to
// decrease the reduction memref size and possibly place it in a faster // decrease the reduction memref size and possibly place it in a faster
// memory space. // memory space.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 100 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 100 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x100xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x100xf32>
// CHECK-NEXT: %{{.*}} = "maxf"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32 // CHECK-NEXT: "maxf"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 100 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 100 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x100xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x100xf32>
// CHECK-NEXT: %{{.*}} = subf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: subf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 22 Linesfunc @should_fuse_at_src_depth1_and_dst_depth1() {
} }
// We can slice iterations of the '%i0' and '%i1' loops in the source // We can slice iterations of the '%i0' and '%i1' loops in the source
// loop nest, but slicing at depth 2 and inserting the slice in the // loop nest, but slicing at depth 2 and inserting the slice in the
// destination loop nest at depth2 causes extra computation. Instead, // destination loop nest at depth2 causes extra computation. Instead,
// the fusion algorithm should detect that the source loop should be sliced // the fusion algorithm should detect that the source loop should be sliced
// at depth 1 and the slice should be inserted at depth 1. // at depth 1 and the slice should be inserted at depth 1.
// CHECK: affine.for %{{.*}} = 0 to 100 { // CHECK: affine.for %{{.*}} = 0 to 100 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x16xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x16xf32>
// CHECK-NEXT: "op0"(%{{.*}}) : (f32) -> () // CHECK-NEXT: "op0"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = "op1"() : () -> f32 // CHECK-NEXT: %{{.*}} = "op1"() : () -> f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, %{{.*}}] : memref<1x16xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, %{{.*}}] : memref<1x16xf32> // CHECK-NEXT: affine.load %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
// CHECK-NEXT: "op2"(%{{.*}}) : (f32) -> () // CHECK-NEXT: "op2"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 13 Lines affine.for %i2 = 0 to 10 {
%a0 = affine.apply affine_map<(d0, d1) -> (d0 * 10 + d1)> (%i1, %i2) %a0 = affine.apply affine_map<(d0, d1) -> (d0 * 10 + d1)> (%i1, %i2)
%v0 = affine.load %a[%a0] : memref<100xf32> %v0 = affine.load %a[%a0] : memref<100xf32>
} }
} }
// The source loop nest slice loop bound is a function of both destination // The source loop nest slice loop bound is a function of both destination
// loop IVs, so we should slice at depth 1 and insert the slice at depth 2. // loop IVs, so we should slice at depth 1 and insert the slice at depth 2.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP0]](%{{.*}}, %{{.*}})
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP0]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @fusion_at_depth0_not_currently_supported // CHECK-LABEL: func @fusion_at_depth0_not_currently_supported
func @fusion_at_depth0_not_currently_supported() { func @fusion_at_depth0_not_currently_supported() {
%0 = alloc() : memref<10xf32> %0 = alloc() : memref<10xf32>
%c0 = constant 0 : index %c0 = constant 0 : index
%cst = constant 0.000000e+00 : f32 %cst = constant 0.000000e+00 : f32
affine.for %i0 = 0 to 10 { affine.for %i0 = 0 to 10 {
affine.store %cst, %0[%i0] : memref<10xf32> affine.store %cst, %0[%i0] : memref<10xf32>
} }
affine.for %i1 = 0 to 10 { affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%c0] : memref<10xf32> %1 = affine.load %0[%c0] : memref<10xf32>
} }
// NOTE: Should shrink memref size to 1 element access by load in dst loop // NOTE: Should shrink memref size to 1 element access by load in dst loop
// nest, and make the store in the slice store to the same element. // nest, and make the store in the slice store to the same element.
// CHECK-DAG: %{{.*}} = alloc() : memref<1xf32> // CHECK-DAG: alloc() : memref<1xf32>
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_deep_loop_nests // CHECK-LABEL: func @should_fuse_deep_loop_nests
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines affine.for %i9 = 0 to 3 {
} }
} }
} }
} }
// The first four loops of the source loop nest can be sliced with iteration // The first four loops of the source loop nest can be sliced with iteration
// bounds which are a function of the first four loops of destination loop nest, // bounds which are a function of the first four loops of destination loop nest,
// where the destination loops nests have been interchanged. // where the destination loops nests have been interchanged.
// CHECK-DAG: %{{.*}} = alloc() : memref<1x1x1x1x16x10xf32, 2> // CHECK-DAG: alloc() : memref<1x1x1x1x16x10xf32, 2>
// CHECK: affine.for %{{.*}} = 0 to 3 { // CHECK: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 3 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 2 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 2 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 2 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 2 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 3 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 3 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : memref<2x2x3x3x16x10xf32, 2> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : memref<2x2x3x3x16x10xf32, 2>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0, 0, 0, %{{.*}}, %{{.*}}] : memref<1x1x1x1x16x10xf32, 2> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0, 0, 0, %{{.*}}, %{{.*}}] : memref<1x1x1x1x16x10xf32, 2>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 2 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 2 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 2 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 2 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : memref<2x2x3x3x16x10xf32, 2> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : memref<2x2x3x3x16x10xf32, 2>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0, 0, 0, %{{.*}}, %{{.*}}] : memref<1x1x1x1x16x10xf32, 2> // CHECK-NEXT: affine.load %{{.*}}[0, 0, 0, 0, %{{.*}}, %{{.*}}] : memref<1x1x1x1x16x10xf32, 2>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
Show All 31 Linesfunc @should_fuse_at_depth1_and_reduce_slice_trip_count() {
// for two reasons: // for two reasons:
// 1) Inserting the unsliceable src loop %i1 to a higher depth removes // 1) Inserting the unsliceable src loop %i1 to a higher depth removes
// redundant computation and reduces costs. // redundant computation and reduces costs.
// 2) Inserting the sliceable src loop %i2 at depth 1, we can still reduce // 2) Inserting the sliceable src loop %i2 at depth 1, we can still reduce
// its trip count to 16 (from 256) reducing costs. // its trip count to 16 (from 256) reducing costs.
// NOTE: the size of the private memref created for the fused loop nest // NOTE: the size of the private memref created for the fused loop nest
// is reduced from the original shape from 4x256 to 4x16 because of the // is reduced from the original shape from 4x256 to 4x16 because of the
// data accessed by the load. // data accessed by the load.
// CHECK-DAG: %{{.*}} = alloc() : memref<1x16xf32> // CHECK-DAG: alloc() : memref<1x16xf32>
// CHECK: affine.for %{{.*}} = 0 to 4 { // CHECK: affine.for %{{.*}} = 0 to 4 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 256 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4x256xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4x256xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, %{{.*}}] : memref<1x16xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, %{{.*}}] : memref<1x16xf32> // CHECK-NEXT: affine.load %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 13 Lines affine.for %i1 = 0 to 5 {
} }
affine.for %i3 = 0 to 10 { affine.for %i3 = 0 to 10 {
affine.for %i4 = 0 to 20 { affine.for %i4 = 0 to 20 {
%v1 = affine.load %a[%i4]: memref<100xf32> %v1 = affine.load %a[%i4]: memref<100xf32>
} }
} }
} }
// NOTE: The size of the private memref created for fusion is shrunk to 20xf32 // NOTE: The size of the private memref created for fusion is shrunk to 20xf32
// CHECK-DAG: %{{.*}} = alloc() : memref<20xf32> // CHECK-DAG: alloc() : memref<20xf32>
// CHECK: affine.for %{{.*}} = 0 to 5 { // CHECK: affine.for %{{.*}} = 0 to 5 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 20 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 20 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<20xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<20xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<20xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<20xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 20 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 20 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<20xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<20xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 14 Lines affine.for %i1 = 0 to 5 {
} }
affine.for %i3 = 0 to 10 { affine.for %i3 = 0 to 10 {
affine.for %i4 = 0 to 10 { affine.for %i4 = 0 to 10 {
%v1 = affine.load %a[%i4]: memref<100xf32> %v1 = affine.load %a[%i4]: memref<100xf32>
} }
} }
} }
// NOTE: The size of the private memref created for fusion is shrunk to 19xf32 // NOTE: The size of the private memref created for fusion is shrunk to 19xf32
// CHECK-DAG: %{{.*}} = alloc() : memref<19xf32> // CHECK-DAG: alloc() : memref<19xf32>
// CHECK: affine.for %{{.*}} = 0 to 5 { // CHECK: affine.for %{{.*}} = 0 to 5 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 19 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 19 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<19xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<19xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 19 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 19 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<19xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<19xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<19xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<19xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
Show All 10 Linesfunc @should_fuse_with_private_memrefs_with_diff_shapes() {
affine.for %i1 = 0 to 17 { affine.for %i1 = 0 to 17 {
%v0 = affine.load %m[%i1] : memref<100xf32> %v0 = affine.load %m[%i1] : memref<100xf32>
} }
affine.for %i2 = 0 to 82 { affine.for %i2 = 0 to 82 {
%v1 = affine.load %m[%i2] : memref<100xf32> %v1 = affine.load %m[%i2] : memref<100xf32>
} }
// Should create two new private memrefs customized to the shapes accessed // Should create two new private memrefs customized to the shapes accessed
// by loops %{{.*}} and %{{.*}}. // by loops %{{.*}} and %{{.*}}.
// CHECK-DAG: %{{.*}} = alloc() : memref<1xf32> // CHECK-DAG: alloc() : memref<1xf32>
// CHECK-DAG: %{{.*}} = alloc() : memref<1xf32> // CHECK-DAG: alloc() : memref<1xf32>
// CHECK: affine.for %{{.*}} = 0 to 17 { // CHECK: affine.for %{{.*}} = 0 to 17 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 82 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 82 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_not_fuse_live_out_arg(%{{.*}}: memref<10xf32>) { // CHECK-LABEL: func @should_not_fuse_live_out_arg(%{{.*}}: memref<10xf32>) {
Show All 10 Linesfunc @should_not_fuse_live_out_arg(%arg0: memref<10xf32>) {
// because it writes to memref argument '%arg0', and its read region // because it writes to memref argument '%arg0', and its read region
// does not cover its write region (so fusion would shrink the write region // does not cover its write region (so fusion would shrink the write region
// in the fused loop nest, so complete live out data region would not // in the fused loop nest, so complete live out data region would not
// be written). // be written).
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 9 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 9 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_fuse_live_out_arg(%{{.*}}: memref<10xf32>) { // CHECK-LABEL: func @should_fuse_live_out_arg(%{{.*}}: memref<10xf32>) {
func @should_fuse_live_out_arg(%arg0: memref<10xf32>) { func @should_fuse_live_out_arg(%arg0: memref<10xf32>) {
%cf7 = constant 7.0 : f32 %cf7 = constant 7.0 : f32
affine.for %i0 = 0 to 10 { affine.for %i0 = 0 to 10 {
affine.store %cf7, %arg0[%i0] : memref<10xf32> affine.store %cf7, %arg0[%i0] : memref<10xf32>
} }
affine.for %i1 = 0 to 10 { affine.for %i1 = 0 to 10 {
%v0 = affine.load %arg0[%i1] : memref<10xf32> %v0 = affine.load %arg0[%i1] : memref<10xf32>
} }
// The read/write regions for memref '%{{.*}}' are the same for both // The read/write regions for memref '%{{.*}}' are the same for both
// loops, so they should fuse. // loops, so they should fuse.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @should_not_fuse_escaping_memref() -> memref<10xf32> // CHECK-LABEL: func @should_not_fuse_escaping_memref() -> memref<10xf32>
func @should_not_fuse_escaping_memref() -> memref<10xf32> { func @should_not_fuse_escaping_memref() -> memref<10xf32> {
%cf7 = constant 7.0 : f32 %cf7 = constant 7.0 : f32
%m = alloc() : memref<10xf32> %m = alloc() : memref<10xf32>
affine.for %i0 = 0 to 10 { affine.for %i0 = 0 to 10 {
affine.store %cf7, %m[%i0] : memref<10xf32> affine.store %cf7, %m[%i0] : memref<10xf32>
} }
affine.for %i1 = 0 to 9 { affine.for %i1 = 0 to 9 {
%v0 = affine.load %m[%i1] : memref<10xf32> %v0 = affine.load %m[%i1] : memref<10xf32>
} }
// This tests that the loop nest '%{{.*}}' should not be removed after fusion // This tests that the loop nest '%{{.*}}' should not be removed after fusion
// because it writes to memref '%{{.*}}' which is returned by the function. // because it writes to memref '%{{.*}}' which is returned by the function.
// CHECK-DAG: %{{.*}} = alloc() : memref<10xf32> // CHECK-DAG: alloc() : memref<10xf32>
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 9 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 9 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return %{{.*}} : memref<10xf32> // CHECK-NEXT: return %{{.*}} : memref<10xf32>
return %m : memref<10xf32> return %m : memref<10xf32>
} }
// ----- // -----
// This should fuse with the %in becoming a 1x1x1. // This should fuse with the %in becoming a 1x1x1.
Show All 21 Linesfunc @R3_to_R2_reshape() {
} }
return return
} }
// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 3 + d1) floordiv 48)> // CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 3 + d1) floordiv 48)>
// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 3 + d1)> // CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 3 + d1)>
// CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 48)> // CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 48)>
// CHECK-LABEL: func @R3_to_R2_reshape() // CHECK-LABEL: func @R3_to_R2_reshape()
// CHECK-DAG: %{{.*}} = alloc() : memref<1x1x1xi32> // CHECK-DAG: alloc() : memref<1x1x1xi32>
// CHECK: affine.for %{{.*}} = 0 to 32 { // CHECK: affine.for %{{.*}} = 0 to 32 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 3 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP0]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> i32 // CHECK-NEXT: "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> i32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0, 0] : memref<1x1x1xi32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0, 0] : memref<1x1x1xi32>
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP1]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply [[MAP1]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP2]](%{{.*}}) // CHECK-NEXT: affine.apply [[MAP2]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0, 0] : memref<1x1x1xi32> // CHECK-NEXT: affine.load %{{.*}}[0, 0, 0] : memref<1x1x1xi32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
// ----- // -----
func @should_not_fuse_multi_output_producer() { func @should_not_fuse_multi_output_producer() {
%a = alloc() : memref<10xf32> %a = alloc() : memref<10xf32>
Show All 10 Lines affine.for %i1 = 0 to 10 {
%v1 = affine.load %b[%i1] : memref<10xf32> %v1 = affine.load %b[%i1] : memref<10xf32>
} }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK-LABEL: func @fusion_preventing_deps_on_middle_loop() { // CHECK-LABEL: func @fusion_preventing_deps_on_middle_loop() {
Show All 15 Linesfunc @fusion_preventing_deps_on_middle_loop() {
affine.for %i2 = 0 to 10 { affine.for %i2 = 0 to 10 {
%v2 = affine.load %b[%i2] : memref<10xf32> %v2 = affine.load %b[%i2] : memref<10xf32>
affine.store %v2, %c[%i2] : memref<10xf32> affine.store %v2, %c[%i2] : memref<10xf32>
} }
// Loops '%i0' and '%i2' cannot fuse along producer/consumer edge on memref // Loops '%i0' and '%i2' cannot fuse along producer/consumer edge on memref
// '%b', because of the WAR dep from '%i0' to '%i1' on memref '%a' and // '%b', because of the WAR dep from '%i0' to '%i1' on memref '%a' and
// because of the WAR dep from '%i1' to '%i2' on memref '%c'. // because of the WAR dep from '%i1' to '%i2' on memref '%c'.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 28 Linesfunc @should_fuse_and_move_to_preserve_war_dep() {
// | | | // | | |
// %c | %i2 <-- | // %c | %i2 <-- |
// | | // | |
// --> %i3 <-------- // --> %i3 <--------
// //
// It is possible to fuse loop '%i0' into '%i3' and preserve dependences // It is possible to fuse loop '%i0' into '%i3' and preserve dependences
// if the fused loop nest is inserted between loops '%i1' and '%i2'. // if the fused loop nest is inserted between loops '%i1' and '%i2'.
// CHECK-DAG: %{{.*}} = alloc() : memref<1xf32> // CHECK-DAG: alloc() : memref<1xf32>
// CHECK: affine.for %{{.*}} = 0 to 3 { // CHECK: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 5 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 5 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
Show All 19 Linesfunc @fusion_preventing_dep_on_constant() {
affine.for %i2 = 0 to 10 { affine.for %i2 = 0 to 10 {
%v2 = affine.load %a[%i2] : memref<10xf32> %v2 = affine.load %a[%i2] : memref<10xf32>
affine.store %cf11, %c[%i2] : memref<10xf32> affine.store %cf11, %c[%i2] : memref<10xf32>
} }
// Loops '%i0' and '%i2' cannot fuse along producer/consumer edge on memref // Loops '%i0' and '%i2' cannot fuse along producer/consumer edge on memref
// '%a', because of the WAR dep from '%i0' to '%i1' on memref '%b' and // '%a', because of the WAR dep from '%i0' to '%i1' on memref '%b' and
// because of the SSA value dep from '%cf11' def to use in '%i2'. // because of the SSA value dep from '%cf11' def to use in '%i2'.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: %{{.*}} = constant 1.100000e+01 : f32 // CHECK-NEXT: %{{.*}} = constant 1.100000e+01 : f32
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 16 Lines affine.for %i2 = 0 to 10 {
%v2 = affine.load %a[%i2] : memref<10xf32> %v2 = affine.load %a[%i2] : memref<10xf32>
affine.store %cf11, %c[%i2] : memref<10xf32> affine.store %cf11, %c[%i2] : memref<10xf32>
} }
// Loops '%i0' and '%i2' can fuse along producer/consumer edge on memref // Loops '%i0' and '%i2' can fuse along producer/consumer edge on memref
// '%a', and preserve the WAR dep from '%i0' to '%i1' on memref '%b', and // '%a', and preserve the WAR dep from '%i0' to '%i1' on memref '%b', and
// the SSA value dep from '%cf11' def to use in '%i2'. // the SSA value dep from '%cf11' def to use in '%i2'.
// CHECK: %{{.*}} = constant 1.100000e+01 : f32 // CHECK: constant 1.100000e+01 : f32
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
// CHECK: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>
// CHECK: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)>
// CHECK-LABEL: func @should_fuse_at_depth_above_loop_carried_dependence(%{{.*}}: memref<64x4xf32>, %{{.*}}: memref<64x4xf32>) { // CHECK-LABEL: func @should_fuse_at_depth_above_loop_carried_dependence(%{{.*}}: memref<64x4xf32>, %{{.*}}: memref<64x4xf32>) {
func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>, %arg1: memref<64x4xf32>) { func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>, %arg1: memref<64x4xf32>) {
%out = alloc() : memref<64x4xf32> %out = alloc() : memref<64x4xf32>
%0 = constant 0.0 : f32 %0 = constant 0.0 : f32
affine.for %i0 = 0 to 64 { affine.for %i0 = 0 to 64 {
affine.for %i1 = 0 to 4 { affine.for %i1 = 0 to 4 {
affine.store %0, %out[%i0, %i1] : memref<64x4xf32> affine.store %0, %out[%i0, %i1] : memref<64x4xf32>
} }
} }
affine.for %i2 = 0 to 4 { affine.for %i2 = 0 to 4 {
affine.for %i3 = 0 to 4 { affine.for %i3 = 0 to 4 {
affine.for %i4 = 0 to 16 { affine.for %i4 = 0 to 16 {
%1 = affine.apply affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>(%i3, %i4) %v = affine.load %arg1[16 * %i3 - %i4 + 15, %i2] : memref<64x4xf32>
%2 = affine.load %arg1[%1, %i2] : memref<64x4xf32> "op0"(%v) : (f32) -> ()
"op0"(%2) : (f32) -> ()
} }
affine.for %i5 = 0 to 4 { affine.for %i5 = 0 to 4 {
affine.for %i6 = 0 to 16 { affine.for %i6 = 0 to 16 {
%3 = affine.apply affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>(%i5, %i6) %v = affine.load %arg0[16 * %i5 - %i6 + 15, %i3] : memref<64x4xf32>
%4 = affine.load %arg0[%3, %i3] : memref<64x4xf32> "op1"(%v) : (f32) -> ()
"op1"(%4) : (f32) -> ()
} }
affine.for %i7 = 0 to 16 { affine.for %i7 = 0 to 16 {
%5 = "op2"() : () -> (f32) %r = "op2"() : () -> (f32)
%6 = affine.apply affine_map<(d0, d1) -> (d0 * 16 + d1)>(%i5, %i7) %v = affine.load %out[16 * %i5 + %i7, %i2] : memref<64x4xf32>
%7 = affine.load %out[%6, %i2] : memref<64x4xf32> %s = addf %v, %r : f32
%8 = addf %7, %5 : f32 affine.store %s, %out[16 * %i5 + %i7, %i2] : memref<64x4xf32>
affine.store %8, %out[%6, %i2] : memref<64x4xf32>
} }
} }
} }
} }
// We can fuse source loop nest '%i0' into dst loop nest '%i2', but the // We can fuse source loop nest '%i0' into dst loop nest '%i2', but the
// depth at which we can insert the src loop nest slice into the dst loop // depth at which we can insert the src loop nest slice into the dst loop
// lest must be decreased because of a loop carried dependence on loop '%i3'. // lest must be decreased because of a loop carried dependence on loop '%i3'.
// As a result, the source loop nest is inserted at dst loop nest depth 1, // As a result, the source loop nest is inserted at dst loop nest depth 1,
// just above the loop with the carried dependence. In addition, the source // just above the loop with the carried dependence. In addition, the source
// loop nest iteration bounds on its loop '%i1' are reduced to 1, so the // loop nest iteration bounds on its loop '%i1' are reduced to 1, so the
// memref size can be reduced to 128x1xf32. // memref size can be reduced to 128x1xf32.
// CHECK: %{{.*}} = alloc() : memref<64x1xf32> // CHECK: alloc() : memref<64x1xf32>
// CHECK: affine.for %{{.*}} = 0 to 4 { // CHECK: affine.for %{{.*}} = 0 to 4 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 64 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 64 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, 0] : memref<64x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, 0] : memref<64x1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 4 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 4 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP2]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.load %{{.*}}[%{{.*}} * 16 - %{{.*}} + 15, %{{.*}}] : memref<64x4xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<64x4xf32>
// CHECK-NEXT: "op0"(%{{.*}}) : (f32) -> () // CHECK-NEXT: "op0"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 4 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 4 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP2]](%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.load %{{.*}}[%{{.*}} * 16 - %{{.*}} + 15, %{{.*}}] : memref<64x4xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<64x4xf32>
// CHECK-NEXT: "op1"(%{{.*}}) : (f32) -> () // CHECK-NEXT: "op1"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = "op2"() : () -> f32 // CHECK-NEXT: %{{.*}} = "op2"() : () -> f32
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP3]](%{{.*}}, %{{.*}}) // CHECK: affine.load %{{.*}}[%{{.*}} * 16 + %{{.*}}, 0] : memref<64x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} * 16 + %{{.*}}, 0] : memref<64x1xf32> // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} * 16 + %{{.*}}, 0] : memref<64x1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} * 16 + %{{.*}}, 0] : memref<64x1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
Show All 21 Linesfunc @should_fuse_after_private_memref_creation() {
// On the first visit to '%i2', the fusion algorithm can not fuse loop nest // On the first visit to '%i2', the fusion algorithm can not fuse loop nest
// '%i0' into '%i2' because of the dependences '%i0' and '%i2' each have on // '%i0' into '%i2' because of the dependences '%i0' and '%i2' each have on
// '%i1'. However, once the loop nest '%i0' is fused into '%i1' with a // '%i1'. However, once the loop nest '%i0' is fused into '%i1' with a
// private memref, the dependence between '%i0' and '%i1' on memref '%a' no // private memref, the dependence between '%i0' and '%i1' on memref '%a' no
// longer exists, so '%i0' can now be fused into '%i2'. // longer exists, so '%i0' can now be fused into '%i2'.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 17 Linesfunc @should_fuse_after_one_loop_interchange() {
// cannot be fused with loop '%i0' without violating this dependence. // cannot be fused with loop '%i0' without violating this dependence.
// Once loops '%i1' and %i2' are interchanged, loop '%i0' can be fused // Once loops '%i1' and %i2' are interchanged, loop '%i0' can be fused
// at loop depth 1, because the loop carrying the dependence has been // at loop depth 1, because the loop carrying the dependence has been
// interchanged and is now at depth 2. // interchanged and is now at depth 2.
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 5 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 5 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 28 Linesfunc @should_fuse_after_two_loop_interchanges() {
// '%i5', then loop '%i0' can be fused at loop depth 2, because the loop // '%i5', then loop '%i0' can be fused at loop depth 2, because the loop
// carrying the dependences have been interchanged with loops at depth > 2. // carrying the dependences have been interchanged with loops at depth > 2.
// CHECK: affine.for %{{.*}} = 0 to 6 { // CHECK: affine.for %{{.*}} = 0 to 6 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 8 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 8 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 4 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 4 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 2 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 2 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
Show All 9 Lines affine.for %i1 = 0 to 10 {
%1 = affine.load %arg0[%i1] : memref<10xf32> %1 = affine.load %arg0[%i1] : memref<10xf32>
affine.store %1, %arg0[%i1] : memref<10xf32> affine.store %1, %arg0[%i1] : memref<10xf32>
} }
return %arg0 : memref<10xf32> return %arg0 : memref<10xf32>
// CHECK: %{{.*}} = constant 0.000000e+00 : f32 // CHECK: %{{.*}} = constant 0.000000e+00 : f32
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return %{{.*}} : memref<10xf32> // CHECK-NEXT: return %{{.*}} : memref<10xf32>
} }
// ----- // -----
// The fused slice has 16 iterations from along %i0. // The fused slice has 16 iterations from along %i0.
// CHECK-DAG: [[MAP_LB:#map[0-9]+]] = affine_map<(d0) -> (d0 * 16)> // CHECK-DAG: [[MAP_LB:#map[0-9]+]] = affine_map<(d0) -> (d0 * 16)>
// CHECK-DAG: [[MAP_UB:#map[0-9]+]] = affine_map<(d0) -> (d0 * 16 + 16)> // CHECK-DAG: [[MAP_UB:#map[0-9]+]] = affine_map<(d0) -> (d0 * 16 + 16)>
#map = affine_map<(d0, d1) -> (d0 * 16 + d1)>
// CHECK-LABEL: slice_tile // CHECK-LABEL: slice_tile
func @slice_tile(%arg0: memref<128x8xf32>, %arg1: memref<32x8xf32>, %0 : f32) -> memref<32x8xf32> { func @slice_tile(%arg0: memref<128x8xf32>, %arg1: memref<32x8xf32>, %0 : f32) -> memref<32x8xf32> {
affine.for %i0 = 0 to 32 { affine.for %i0 = 0 to 32 {
affine.for %i1 = 0 to 8 { affine.for %i1 = 0 to 8 {
affine.store %0, %arg1[%i0, %i1] : memref<32x8xf32> affine.store %0, %arg1[%i0, %i1] : memref<32x8xf32>
} }
} }
affine.for %i = 0 to 2 { affine.for %i = 0 to 2 {
affine.for %j = 0 to 8 { affine.for %j = 0 to 8 {
affine.for %k = 0 to 8 { affine.for %k = 0 to 8 {
affine.for %kk = 0 to 16 { affine.for %kk = 0 to 16 {
%1 = affine.apply #map(%k, %kk) %v = affine.load %arg0[16 * %k + %kk, %j] : memref<128x8xf32>
%2 = affine.load %arg0[%1, %j] : memref<128x8xf32> %r = "foo"(%v) : (f32) -> f32
%3 = "foo"(%2) : (f32) -> f32
} }
affine.for %ii = 0 to 16 { affine.for %ii = 0 to 16 {
%6 = affine.apply #map(%i, %ii) %v = affine.load %arg1[16 * %i + %ii, %j] : memref<32x8xf32>
%7 = affine.load %arg1[%6, %j] : memref<32x8xf32> %s = addf %v, %v : f32
%8 = addf %7, %7 : f32 affine.store %s, %arg1[16 * %i + %ii, %j] : memref<32x8xf32>
affine.store %8, %arg1[%6, %j] : memref<32x8xf32>
} }
} }
} }
} }
return %arg1 : memref<32x8xf32> return %arg1 : memref<32x8xf32>
} }
// CHECK: affine.for %{{.*}} = 0 to 2 { // CHECK: affine.for %{{.*}} = 0 to 2 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 8 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 8 {
// CHECK-NEXT: affine.for %{{.*}} = [[MAP_LB]](%{{.*}}) to [[MAP_UB]](%{{.*}}) { // CHECK-NEXT: affine.for %{{.*}} = [[MAP_LB]](%{{.*}}) to [[MAP_UB]](%{{.*}}) {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<32x8xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<32x8xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 8 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 8 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.load %{{.*}}[%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<128x8xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<128x8xf32> // CHECK-NEXT: "foo"(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: %{{.*}} = "foo"(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.load %{{.*}}[%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<32x8xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<32x8xf32> // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<32x8xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<32x8xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return %{{.*}} : memref<32x8xf32> // CHECK-NEXT: return %{{.*}} : memref<32x8xf32>
// CHECK-NEXT:} // CHECK-NEXT:}
// ----- // -----
Show All 21 Lines affine.for %i4 = 0 to 10 {
%v0 = affine.load %a[%c0] : memref<10xf32> %v0 = affine.load %a[%c0] : memref<10xf32>
} }
} }
} }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.apply #map0(%{{.*}}) // CHECK-NEXT: affine.apply #map0(%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply #map0(%{{.*}}) // CHECK-NEXT: affine.apply #map0(%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply #map1(%{{.*}}, %{{.*}}) // CHECK-NEXT: affine.apply #map1(%{{.*}}, %{{.*}})
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesfunc @should_fuse_init_loops_siblings_then_shared_producer(%arg0: memref<10x10xf32>, %arg1: memref<10x10xf32>) {
// Pass 3: should fuse single-use producer loop nest '%i0' into '%i8'. Note // Pass 3: should fuse single-use producer loop nest '%i0' into '%i8'. Note
// that loop nest '%i0' now has a single user after Pass 2 fused its // that loop nest '%i0' now has a single user after Pass 2 fused its
// two users together). // two users together).
// CHECK: affine.for %{{.*}} = 0 to 3 { // CHECK: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 3 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 3 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
Show All 36 Lines affine.for %i4 = 0 to 10 {
} }
} }
// CHECK: affine.for %{{.*}} = 0 to 10 { // CHECK: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, 0] : memref<10x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, 0] : memref<10x1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, 0] : memref<10x1xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, 0] : memref<10x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, 0] : memref<10x1xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, 0] : memref<10x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 15 Linesfunc @should_not_slice_past_slice_barrier() {
// The 'slice_fusion_barrier' attribute on '%i1' prevents slicing the // The 'slice_fusion_barrier' attribute on '%i1' prevents slicing the
// iteration space of '%i1' and any enclosing loop nests. // iteration space of '%i1' and any enclosing loop nests.
// CHECK: affine.for %{{.*}} = 0 to 100 { // CHECK: affine.for %{{.*}} = 0 to 100 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = "op1"() : () -> f32 // CHECK-NEXT: %{{.*}} = "op1"() : () -> f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, %{{.*}}] : memref<1x16xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
// CHECK-NEXT: } {slice_fusion_barrier = true} // CHECK-NEXT: } {slice_fusion_barrier = true}
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0, %{{.*}}] : memref<1x16xf32> // CHECK-NEXT: affine.load %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
// CHECK-NEXT: "op2"(%{{.*}}) : (f32) -> () // CHECK-NEXT: "op2"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
// ----- // -----
Show All 18 Lines affine.for %i7 = 0 to 9 {
} }
} }
} }
} }
return return
} }
// MAXIMAL: #map0 = affine_map<(d0, d1) -> (d0 * 16 + d1)> // MAXIMAL: #map0 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
// MAXIMAL-LABEL: func @fuse_across_dim_mismatch // MAXIMAL-LABEL: func @fuse_across_dim_mismatch
// MAXIMAL: %{{.*}} = alloc() : memref<1x1xf32> // MAXIMAL: alloc() : memref<1x1xf32>
// MAXIMAL: affine.for %{{.*}} = 0 to 9 { // MAXIMAL: affine.for %{{.*}} = 0 to 9 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 9 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 9 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 4 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 4 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 {
// MAXIMAL-NEXT: %{{.*}} = affine.apply #map0(%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply #map0(%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32> // MAXIMAL-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// MAXIMAL-NEXT: %{{.*}} = affine.apply #map0(%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply #map0(%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.load %{{.*}}[0, 0] : memref<1x1xf32> // MAXIMAL-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// ----- // -----
#map3 = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304)> #map3 = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304)>
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
// MAXIMAL-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304)> // MAXIMAL-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304)>
// MAXIMAL-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (((d0 * 72 + d1) mod 2304) floordiv 1152)> // MAXIMAL-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (((d0 * 72 + d1) mod 2304) floordiv 1152)>
// MAXIMAL-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)> // MAXIMAL-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)>
// MAXIMAL-DAG: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)> // MAXIMAL-DAG: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)>
// MAXIMAL-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)> // MAXIMAL-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)>
// MAXIMAL-DAG: [[MAP7:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)> // MAXIMAL-DAG: [[MAP7:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)>
// MAXIMAL-DAG: [[MAP8:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)> // MAXIMAL-DAG: [[MAP8:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>
// MAXIMAL-LABEL: func @fuse_across_varying_dims_complex // MAXIMAL-LABEL: func @fuse_across_varying_dims_complex
// MAXIMAL-NEXT: %{{.*}} = alloc() : memref<64x1xf32> // MAXIMAL-NEXT: alloc() : memref<64x1xf32>
// MAXIMAL-NEXT: %{{.*}} = constant 0 : index // MAXIMAL-NEXT: constant 0 : index
// MAXIMAL-NEXT: %{{.*}} = alloc() : memref<2x2x3x3x16x1xf32> // MAXIMAL-NEXT: alloc() : memref<2x2x3x3x16x1xf32>
// MAXIMAL-NEXT: %{{.*}} = alloc() : memref<144x4xf32> // MAXIMAL-NEXT: alloc() : memref<144x4xf32>
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 9 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 9 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 9 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 9 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 4 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 4 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 64 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 64 {
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP0]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP1]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP1]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP2]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP2]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP3]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP3]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP4]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP4]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : memref<2x2x3x3x16x1xf32> // MAXIMAL-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : memref<2x2x3x3x16x1xf32>
// MAXIMAL-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, 0] : memref<64x1xf32> // MAXIMAL-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, 0] : memref<64x1xf32>
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 4 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 4 {
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 {
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP7]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP7]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} * 16 + %{{.*}}, 0] : memref<64x1xf32> // MAXIMAL-NEXT: affine.load %{{.*}}[%{{.*}} * 16 + %{{.*}}, 0] : memref<64x1xf32>
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 { // MAXIMAL-NEXT: affine.for %{{.*}} = 0 to 16 {
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP7]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP7]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<144x4xf32> // MAXIMAL-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<144x4xf32>
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: %{{.*}} = affine.apply [[MAP8]](%{{.*}}, %{{.*}}) // MAXIMAL-NEXT: affine.apply [[MAP8]](%{{.*}}, %{{.*}})
// MAXIMAL-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} * 16 - %{{.*}} + 15, 0] : memref<64x1xf32> // MAXIMAL-NEXT: affine.load %{{.*}}[%{{.*}} * 16 - %{{.*}} + 15, 0] : memref<64x1xf32>
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// MAXIMAL-NEXT: } // MAXIMAL-NEXT: }
// ----- // -----
func @should_fuse_with_slice_union() { func @should_fuse_with_slice_union() {
Show All 15 Linesfunc @should_fuse_with_slice_union() {
// the loads) is computed and used in the fusion cost calculation, index // the loads) is computed and used in the fusion cost calculation, index
// remapping, and private memref size. The result is that the temporary // remapping, and private memref size. The result is that the temporary
// memref is reduced from 100xf32 to 15xf32 and properly indexed by // memref is reduced from 100xf32 to 15xf32 and properly indexed by
// the fused loops based on the union calculation. // the fused loops based on the union calculation.
// CHECK: affine.for %{{.*}} = 10 to 20 { // CHECK: affine.for %{{.*}} = 10 to 20 {
// CHECK-NEXT: affine.for %{{.*}} = 10 to 25 { // CHECK-NEXT: affine.for %{{.*}} = 10 to 25 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} - 10] : memref<15xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} - 10] : memref<15xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} - 10] : memref<15xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}} - 10] : memref<15xf32>
// CHECK-NEXT: affine.for %{{.*}} = 15 to 25 { // CHECK-NEXT: affine.for %{{.*}} = 15 to 25 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} - 10] : memref<15xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}} - 10] : memref<15xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
Show All 17 Lines affine.for %i5 = 0 to 1024 {
affine.store %7, %arg2[%i4, %i5] : memref<1024x1024xf32> affine.store %7, %arg2[%i4, %i5] : memref<1024x1024xf32>
} }
} }
} }
// Should fuse elementwise add loop at loop depth 2, above loop-carried // Should fuse elementwise add loop at loop depth 2, above loop-carried
// dependence between load/store on '%arg2', carried on reduction loop %i6. // dependence between load/store on '%arg2', carried on reduction loop %i6.
// CHECK: affine.for %{{.*}} = 0 to 1024 { // CHECK: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
// ----- // -----
Show All 37 Linesfunc @affine_2mm_fused(%arg0: memref<1024x1024xf32>, %arg1: memref<1024x1024xf32>, %arg2: memref<1024x1024xf32>, %arg3: memref<1024x1024xf32>, %arg4: memref<1024x1024xf32>) {
// Should fuse MM initialization loops into their consumers, then fuse the // Should fuse MM initialization loops into their consumers, then fuse the
// two matmul loops together for input reuse on '%arg0/%arg1'. // two matmul loops together for input reuse on '%arg0/%arg1'.
// CHECK: affine.for %{{.*}} = 0 to 1024 { // CHECK: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
Show All 23 Lines affine.for %i4 = 0 to 1024 {
affine.store %9, %arg4[%i3, %i4] : memref<1024x1024xf32> affine.store %9, %arg4[%i3, %i4] : memref<1024x1024xf32>
} }
} }
} }
// CHECK: affine.for %{{.*}} = 0 to 1024 { // CHECK: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 { // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines affine.for %arg4 = 0 to 3 {
} }
} }
// CHECK: affine.for %[[i0:.*]] = 0 to 3 { // CHECK: affine.for %[[i0:.*]] = 0 to 3 {
// CHECK-NEXT: affine.for %[[i1:.*]] = 0 to 3 { // CHECK-NEXT: affine.for %[[i1:.*]] = 0 to 3 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: affine.for %[[i2:.*]] = 0 to 4 { // CHECK-NEXT: affine.for %[[i2:.*]] = 0 to 4 {
// CHECK-NEXT: affine.load %{{.*}}[%[[i2]], %[[i1]]] : memref<4x3xf32> // CHECK-NEXT: affine.load %{{.*}}[%[[i2]], %[[i1]]] : memref<4x3xf32>
// CHECK-NEXT: affine.load %{{.*}}[%[[i0]], %[[i2]]] : memref<3x4xf32> // CHECK-NEXT: affine.load %{{.*}}[%[[i0]], %[[i2]]] : memref<3x4xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: affine.load %{{.*}}[%[[i0]], %[[i1]]] : memref<3x3xf32> // CHECK-NEXT: affine.load %{{.*}}[%[[i0]], %[[i1]]] : memref<3x3xf32>
// CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32> // CHECK-NEXT: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32 // CHECK-NEXT: addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%[[i0]], %[[i1]]] : memref<3x3xf32> // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%[[i0]], %[[i1]]] : memref<3x3xf32>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: return // CHECK-NEXT: return
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines