1149 lines · plain
1// RUN: mlir-opt %s -test-memref-dependence-check -split-input-file -verify-diagnostics | FileCheck %s2 3// -----4 5#set0 = affine_set<(d0) : (1 == 0)>6 7// CHECK-LABEL: func @store_may_execute_before_load() {8func.func @store_may_execute_before_load() {9 %m = memref.alloc() : memref<10xf32>10 %cf7 = arith.constant 7.0 : f3211 %c0 = arith.constant 4 : index12 // There is no dependence from store 0 to load 1 at depth if we take into account13 // the constraint introduced by the following `affine.if`, which indicates that14 // the store 0 will never be executed.15 affine.if #set0(%c0) {16 affine.for %i0 = 0 to 10 {17 affine.store %cf7, %m[%i0] : memref<10xf32>18 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}19 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}20 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}21 }22 }23 affine.for %i1 = 0 to 10 {24 %v0 = affine.load %m[%i1] : memref<10xf32>25 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}26 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}27 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}28 }29 return30}31 32// -----33 34// CHECK-LABEL: func @dependent_loops() {35func.func @dependent_loops() {36 %0 = memref.alloc() : memref<10xf32>37 %cst = arith.constant 7.000000e+00 : f3238 // There is a dependence from 0 to 1 at depth 1 (common surrounding loops 0)39 // because the first loop with the store dominates the second scf.40 affine.for %i0 = 0 to 10 {41 affine.store %cst, %0[%i0] : memref<10xf32>42 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}43 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}44 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}45 }46 affine.for %i1 = 0 to 10 {47 %1 = affine.load %0[%i1] : memref<10xf32>48 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}49 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}50 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}51 }52 return53}54 55// -----56// CHECK-LABEL: func @different_memrefs() {57func.func @different_memrefs() {58 %m.a = memref.alloc() : memref<100xf32>59 %m.b = memref.alloc() : memref<100xf32>60 %c0 = arith.constant 0 : index61 %c1 = arith.constant 1.0 : f3262 affine.store %c1, %m.a[%c0] : memref<100xf32>63 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}64 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}65 %v0 = affine.load %m.b[%c0] : memref<100xf32>66 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}67 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}68 return69}70 71// -----72// CHECK-LABEL: func @store_load_different_elements() {73func.func @store_load_different_elements() {74 %m = memref.alloc() : memref<100xf32>75 %c0 = arith.constant 0 : index76 %c1 = arith.constant 1 : index77 %c7 = arith.constant 7.0 : f3278 affine.store %c7, %m[%c0] : memref<100xf32>79 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}80 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}81 %v0 = affine.load %m[%c1] : memref<100xf32>82 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}83 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}84 return85}86 87// -----88// CHECK-LABEL: func @load_store_different_elements() {89func.func @load_store_different_elements() {90 %m = memref.alloc() : memref<100xf32>91 %c0 = arith.constant 0 : index92 %c1 = arith.constant 1 : index93 %c7 = arith.constant 7.0 : f3294 %v0 = affine.load %m[%c1] : memref<100xf32>95 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}96 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}97 affine.store %c7, %m[%c0] : memref<100xf32>98 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}99 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}100 return101}102 103// -----104// CHECK-LABEL: func @store_load_same_element() {105func.func @store_load_same_element() {106 %m = memref.alloc() : memref<100xf32>107 %c11 = arith.constant 11 : index108 %c7 = arith.constant 7.0 : f32109 affine.store %c7, %m[%c11] : memref<100xf32>110 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}111 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}112 %v0 = affine.load %m[%c11] : memref<100xf32>113 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}114 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}115 return116}117 118// -----119// CHECK-LABEL: func @load_load_same_element() {120func.func @load_load_same_element() {121 %m = memref.alloc() : memref<100xf32>122 %c11 = arith.constant 11 : index123 %c7 = arith.constant 7.0 : f32124 %v0 = affine.load %m[%c11] : memref<100xf32>125 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}126 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}127 %v1 = affine.load %m[%c11] : memref<100xf32>128 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}129 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}130 return131}132 133// -----134// CHECK-LABEL: func @store_load_same_symbol(%arg0: index) {135func.func @store_load_same_symbol(%arg0: index) {136 %m = memref.alloc() : memref<100xf32>137 %c7 = arith.constant 7.0 : f32138 affine.store %c7, %m[%arg0] : memref<100xf32>139 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}140 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}141 %v0 = affine.load %m[%arg0] : memref<100xf32>142 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}143 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}144 return145}146 147// -----148// CHECK-LABEL: func @store_load_different_symbols(%arg0: index, %arg1: index) {149func.func @store_load_different_symbols(%arg0: index, %arg1: index) {150 %m = memref.alloc() : memref<100xf32>151 %c7 = arith.constant 7.0 : f32152 affine.store %c7, %m[%arg0] : memref<100xf32>153 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}154 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}155 %v0 = affine.load %m[%arg1] : memref<100xf32>156 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}157 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}158 return159}160 161// -----162// CHECK-LABEL: func @store_load_diff_element_affine_apply_const() {163func.func @store_load_diff_element_affine_apply_const() {164 %m = memref.alloc() : memref<100xf32>165 %c1 = arith.constant 1 : index166 %c8 = arith.constant 8.0 : f32167 %a0 = affine.apply affine_map<(d0) -> (d0)> (%c1)168 affine.store %c8, %m[%a0] : memref<100xf32>169 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}170 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}171 %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c1)172 %v0 = affine.load %m[%a1] : memref<100xf32>173 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}174 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}175 return176}177 178// -----179// CHECK-LABEL: func @store_load_same_element_affine_apply_const() {180func.func @store_load_same_element_affine_apply_const() {181 %m = memref.alloc() : memref<100xf32>182 %c7 = arith.constant 7.0 : f32183 %c9 = arith.constant 9 : index184 %c11 = arith.constant 11 : index185 %a0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c9)186 affine.store %c7, %m[%a0] : memref<100xf32>187 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}188 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}189 %a1 = affine.apply affine_map<(d0) -> (d0 - 1)> (%c11)190 %v0 = affine.load %m[%a1] : memref<100xf32>191 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}192 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}193 return194}195 196// -----197// CHECK-LABEL: func @store_load_affine_apply_symbol(%arg0: index) {198func.func @store_load_affine_apply_symbol(%arg0: index) {199 %m = memref.alloc() : memref<100xf32>200 %c7 = arith.constant 7.0 : f32201 %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)202 affine.store %c7, %m[%a0] : memref<100xf32>203 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}204 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}205 %a1 = affine.apply affine_map<(d0) -> (d0)> (%arg0)206 %v0 = affine.load %m[%a1] : memref<100xf32>207 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}208 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}209 return210}211 212// -----213// CHECK-LABEL: func @store_load_affine_apply_symbol_offset(%arg0: index) {214func.func @store_load_affine_apply_symbol_offset(%arg0: index) {215 %m = memref.alloc() : memref<100xf32>216 %c7 = arith.constant 7.0 : f32217 %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)218 affine.store %c7, %m[%a0] : memref<100xf32>219 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}220 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}221 %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%arg0)222 %v0 = affine.load %m[%a1] : memref<100xf32>223 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}224 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}225 return226}227 228// -----229// CHECK-LABEL: func @store_range_load_after_range() {230func.func @store_range_load_after_range() {231 %m = memref.alloc() : memref<100xf32>232 %c7 = arith.constant 7.0 : f32233 %c10 = arith.constant 10 : index234 affine.for %i0 = 0 to 10 {235 %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)236 affine.store %c7, %m[%a0] : memref<100xf32>237 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}238 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}239 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}240 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}241 %a1 = affine.apply affine_map<(d0) -> (d0)> (%c10)242 %v0 = affine.load %m[%a1] : memref<100xf32>243 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}244 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}245 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}246 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}247 }248 return249}250 251// -----252// CHECK-LABEL: func @store_load_func_symbol(%arg0: index, %arg1: index) {253func.func @store_load_func_symbol(%arg0: index, %arg1: index) {254 %m = memref.alloc() : memref<100xf32>255 %c7 = arith.constant 7.0 : f32256 %c10 = arith.constant 10 : index257 affine.for %i0 = 0 to %arg1 {258 %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)259 affine.store %c7, %m[%a0] : memref<100xf32>260 // expected-remark@above {{dependence from 0 to 0 at depth 1 = [1, +inf]}}261 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}262 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, +inf]}}263 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}264 %a1 = affine.apply affine_map<(d0) -> (d0)> (%arg0)265 %v0 = affine.load %m[%a1] : memref<100xf32>266 // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, +inf]}}267 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}268 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}269 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}270 }271 return272}273 274// -----275// CHECK-LABEL: func @store_range_load_last_in_range() {276func.func @store_range_load_last_in_range() {277 %m = memref.alloc() : memref<100xf32>278 %c7 = arith.constant 7.0 : f32279 %c10 = arith.constant 10 : index280 affine.for %i0 = 0 to 10 {281 %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)282 // For dependence from 0 to 1, we do not have a loop carried dependence283 // because only the final write in the loop accesses the same element as the284 // load, so this dependence appears only at depth 2 (loop independent).285 affine.store %c7, %m[%a0] : memref<100xf32>286 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}287 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}288 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}289 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}290 %a1 = affine.apply affine_map<(d0) -> (d0 - 1)> (%c10)291 // For dependence from 1 to 0, we have write-after-read (WAR) dependences292 // for all loads in the loop to the store on the last iteration.293 %v0 = affine.load %m[%a1] : memref<100xf32>294 // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 9]}}295 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}296 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}297 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}298 }299 return300}301 302// -----303// CHECK-LABEL: func @store_range_load_before_range() {304func.func @store_range_load_before_range() {305 %m = memref.alloc() : memref<100xf32>306 %c7 = arith.constant 7.0 : f32307 %c0 = arith.constant 0 : index308 affine.for %i0 = 1 to 11 {309 %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)310 affine.store %c7, %m[%a0] : memref<100xf32>311 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}312 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}313 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}314 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}315 %a1 = affine.apply affine_map<(d0) -> (d0)> (%c0)316 %v0 = affine.load %m[%a1] : memref<100xf32>317 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}318 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}319 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}320 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}321 }322 return323}324 325// -----326// CHECK-LABEL: func @store_range_load_first_in_range() {327func.func @store_range_load_first_in_range() {328 %m = memref.alloc() : memref<100xf32>329 %c7 = arith.constant 7.0 : f32330 %c0 = arith.constant 0 : index331 affine.for %i0 = 1 to 11 {332 %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)333 // Dependence from 0 to 1 at depth 1 is a range because all loads at334 // constant index zero are reads after first store at index zero during335 // first iteration of the scf.336 affine.store %c7, %m[%a0] : memref<100xf32>337 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}338 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}339 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, 9]}}340 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}341 %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c0)342 %v0 = affine.load %m[%a1] : memref<100xf32>343 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}344 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}345 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}346 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}347 }348 return349}350 351// -----352// CHECK-LABEL: func @store_plus_3() {353func.func @store_plus_3() {354 %m = memref.alloc() : memref<100xf32>355 %c7 = arith.constant 7.0 : f32356 affine.for %i0 = 1 to 11 {357 %a0 = affine.apply affine_map<(d0) -> (d0 + 3)> (%i0)358 affine.store %c7, %m[%a0] : memref<100xf32>359 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}360 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}361 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [3, 3]}}362 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}363 %a1 = affine.apply affine_map<(d0) -> (d0)> (%i0)364 %v0 = affine.load %m[%a1] : memref<100xf32>365 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}366 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}367 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}368 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}369 }370 return371}372 373// -----374// CHECK-LABEL: func @load_minus_2() {375func.func @load_minus_2() {376 %m = memref.alloc() : memref<100xf32>377 %c7 = arith.constant 7.0 : f32378 affine.for %i0 = 2 to 11 {379 %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)380 affine.store %c7, %m[%a0] : memref<100xf32>381 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}382 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}383 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2]}}384 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}385 %a1 = affine.apply affine_map<(d0) -> (d0 - 2)> (%i0)386 %v0 = affine.load %m[%a1] : memref<100xf32>387 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}388 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}389 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}390 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}391 }392 return393}394 395// -----396// CHECK-LABEL: func @perfectly_nested_loops_loop_independent() {397func.func @perfectly_nested_loops_loop_independent() {398 %m = memref.alloc() : memref<10x10xf32>399 %c7 = arith.constant 7.0 : f32400 affine.for %i0 = 0 to 11 {401 affine.for %i1 = 0 to 11 {402 // Dependence from access 0 to 1 is loop independent at depth = 3.403 %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)404 %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)405 affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>406 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}407 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}408 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}409 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}410 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}411 // expected-remark@above {{dependence from 0 to 1 at depth 3 = true}}412 %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)413 %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)414 %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>415 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}416 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}417 // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}418 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}419 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}420 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}421 }422 }423 return424}425 426// -----427// CHECK-LABEL: func @perfectly_nested_loops_loop_carried_at_depth1() {428func.func @perfectly_nested_loops_loop_carried_at_depth1() {429 %m = memref.alloc() : memref<10x10xf32>430 %c7 = arith.constant 7.0 : f32431 affine.for %i0 = 0 to 9 {432 affine.for %i1 = 0 to 9 {433 // Dependence from access 0 to 1 is loop carried at depth 1.434 %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)435 %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)436 affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>437 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}438 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}439 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}440 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2][0, 0]}}441 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}442 // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}443 %a10 = affine.apply affine_map<(d0, d1) -> (d0 - 2)> (%i0, %i1)444 %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)445 %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>446 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}447 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}448 // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}449 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}450 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}451 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}452 }453 }454 return455}456 457// -----458// CHECK-LABEL: func @perfectly_nested_loops_loop_carried_at_depth2() {459func.func @perfectly_nested_loops_loop_carried_at_depth2() {460 %m = memref.alloc() : memref<10x10xf32>461 %c7 = arith.constant 7.0 : f32462 affine.for %i0 = 0 to 10 {463 affine.for %i1 = 0 to 10 {464 // Dependence from access 0 to 1 is loop carried at depth 2.465 %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)466 %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)467 affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>468 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}469 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}470 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}471 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}472 // expected-remark@above {{dependence from 0 to 1 at depth 2 = [0, 0][3, 3]}}473 // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}474 %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)475 %a11 = affine.apply affine_map<(d0, d1) -> (d1 - 3)> (%i0, %i1)476 %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>477 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}478 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}479 // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}480 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}481 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}482 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}483 }484 }485 return486}487 488// -----489// CHECK-LABEL: func @one_common_loop() {490func.func @one_common_loop() {491 %m = memref.alloc() : memref<10x10xf32>492 %c7 = arith.constant 7.0 : f32493 // There is a loop-independent dependence from access 0 to 1 at depth 2.494 affine.for %i0 = 0 to 10 {495 affine.for %i1 = 0 to 10 {496 %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)497 %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)498 affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>499 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}500 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}501 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}502 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}503 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}504 }505 affine.for %i2 = 0 to 9 {506 %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i2)507 %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i2)508 %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>509 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}510 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}511 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}512 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}513 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}514 }515 }516 return517}518 519// -----520// CHECK-LABEL: func @dependence_cycle() {521func.func @dependence_cycle() {522 %m.a = memref.alloc() : memref<100xf32>523 %m.b = memref.alloc() : memref<100xf32>524 525 // Dependences:526 // *) loop-independent dependence from access 1 to 2 at depth 2.527 // *) loop-carried dependence from access 3 to 0 at depth 1.528 affine.for %i0 = 0 to 9 {529 %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)530 %v0 = affine.load %m.a[%a0] : memref<100xf32>531 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}532 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}533 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}534 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}535 // expected-remark@above {{dependence from 0 to 2 at depth 1 = false}}536 // expected-remark@above {{dependence from 0 to 2 at depth 2 = false}}537 // expected-remark@above {{dependence from 0 to 3 at depth 1 = false}}538 // expected-remark@above {{dependence from 0 to 3 at depth 2 = false}}539 %a1 = affine.apply affine_map<(d0) -> (d0)> (%i0)540 affine.store %v0, %m.b[%a1] : memref<100xf32>541 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}542 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}543 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}544 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}545 // expected-remark@above {{dependence from 1 to 2 at depth 1 = false}}546 // expected-remark@above {{dependence from 1 to 2 at depth 2 = true}}547 // expected-remark@above {{dependence from 1 to 3 at depth 1 = false}}548 // expected-remark@above {{dependence from 1 to 3 at depth 2 = false}}549 %a2 = affine.apply affine_map<(d0) -> (d0)> (%i0)550 %v1 = affine.load %m.b[%a2] : memref<100xf32>551 // expected-remark@above {{dependence from 2 to 0 at depth 1 = false}}552 // expected-remark@above {{dependence from 2 to 0 at depth 2 = false}}553 // expected-remark@above {{dependence from 2 to 1 at depth 1 = false}}554 // expected-remark@above {{dependence from 2 to 1 at depth 2 = false}}555 // expected-remark@above {{dependence from 2 to 2 at depth 1 = false}}556 // expected-remark@above {{dependence from 2 to 2 at depth 2 = false}}557 // expected-remark@above {{dependence from 2 to 3 at depth 1 = false}}558 // expected-remark@above {{dependence from 2 to 3 at depth 2 = false}}559 %a3 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)560 affine.store %v1, %m.a[%a3] : memref<100xf32>561 // expected-remark@above {{dependence from 3 to 0 at depth 1 = [1, 1]}}562 // expected-remark@above {{dependence from 3 to 0 at depth 2 = false}}563 // expected-remark@above {{dependence from 3 to 1 at depth 1 = false}}564 // expected-remark@above {{dependence from 3 to 1 at depth 2 = false}}565 // expected-remark@above {{dependence from 3 to 2 at depth 1 = false}}566 // expected-remark@above {{dependence from 3 to 2 at depth 2 = false}}567 // expected-remark@above {{dependence from 3 to 3 at depth 1 = false}}568 // expected-remark@above {{dependence from 3 to 3 at depth 2 = false}}569 }570 return571}572 573// -----574// CHECK-LABEL: func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {575func.func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {576 %m = memref.alloc() : memref<10x10xf32>577 %c7 = arith.constant 7.0 : f32578 affine.for %i0 = 0 to %arg0 {579 affine.for %i1 = 0 to %arg1 {580 %a00 = affine.apply affine_map<(d0, d1) -> (d0 - 1)> (%i0, %i1)581 %a01 = affine.apply affine_map<(d0, d1) -> (d1 + 1)> (%i0, %i1)582 %v0 = affine.load %m[%a00, %a01] : memref<10x10xf32>583 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}584 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}585 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}586 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}587 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}588 // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}589 %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)590 %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)591 affine.store %c7, %m[%a10, %a11] : memref<10x10xf32>592 // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 1][-1, -1]}}593 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}594 // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}595 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}596 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}597 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}598 }599 }600 return601}602 603// -----604// CHECK-LABEL: func @war_raw_waw_deps() {605func.func @war_raw_waw_deps() {606 %m = memref.alloc() : memref<100xf32>607 %c7 = arith.constant 7.0 : f32608 affine.for %i0 = 0 to 10 {609 affine.for %i1 = 0 to 10 {610 %a0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)611 %v0 = affine.load %m[%a0] : memref<100xf32>612 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}613 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}614 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}615 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, 9][1, 1]}}616 // expected-remark@above {{dependence from 0 to 1 at depth 2 = [0, 0][1, 1]}}617 // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}618 %a1 = affine.apply affine_map<(d0) -> (d0)> (%i1)619 affine.store %c7, %m[%a1] : memref<100xf32>620 // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 9][-1, -1]}}621 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}622 // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}623 // expected-remark@above {{dependence from 1 to 1 at depth 1 = [1, 9][0, 0]}}624 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}625 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}626 }627 }628 return629}630 631// -----632// CHECK-LABEL: func @mod_deps() {633func.func @mod_deps() {634 %m = memref.alloc() : memref<100xf32>635 %c7 = arith.constant 7.0 : f32636 affine.for %i0 = 0 to 10 {637 %a0 = affine.apply affine_map<(d0) -> (d0 mod 2)> (%i0)638 // Results are conservative here since we currently don't have a way to639 // represent strided sets in FlatAffineValueConstraints.640 %v0 = affine.load %m[%a0] : memref<100xf32>641 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}642 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}643 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, 9]}}644 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}645 %a1 = affine.apply affine_map<(d0) -> ( (d0 + 1) mod 2)> (%i0)646 affine.store %c7, %m[%a1] : memref<100xf32>647 // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 9]}}648 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}649 // expected-remark@above {{dependence from 1 to 1 at depth 1 = [2, 9]}}650 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}651 }652 return653}654 655// -----656// CHECK-LABEL: func @loop_nest_depth() {657func.func @loop_nest_depth() {658 %0 = memref.alloc() : memref<100x100xf32>659 %c7 = arith.constant 7.0 : f32660 661 affine.for %i0 = 0 to 128 {662 affine.for %i1 = 0 to 8 {663 affine.store %c7, %0[%i0, %i1] : memref<100x100xf32>664 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}665 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}666 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}667 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}668 }669 }670 affine.for %i2 = 0 to 8 {671 affine.for %i3 = 0 to 8 {672 affine.for %i4 = 0 to 8 {673 affine.for %i5 = 0 to 16 {674 %8 = affine.apply affine_map<(d0, d1) -> (d0 * 16 + d1)>(%i4, %i5)675 %9 = affine.load %0[%8, %i3] : memref<100x100xf32>676 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}677 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}678 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}679 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}680 // expected-remark@above {{dependence from 1 to 1 at depth 4 = false}}681 // expected-remark@above {{dependence from 1 to 1 at depth 5 = false}}682 }683 }684 }685 }686 return687}688 689// -----690// Test case to exercise sanity when flattening multiple expressions involving691// mod/div's successively.692// CHECK-LABEL: func @mod_div_3d() {693func.func @mod_div_3d() {694 %M = memref.alloc() : memref<2x2x2xi32>695 %c0 = arith.constant 0 : i32696 affine.for %i0 = 0 to 8 {697 affine.for %i1 = 0 to 8 {698 affine.for %i2 = 0 to 8 {699 %idx0 = affine.apply affine_map<(d0, d1, d2) -> (d0 floordiv 4)> (%i0, %i1, %i2)700 %idx1 = affine.apply affine_map<(d0, d1, d2) -> (d1 mod 2)> (%i0, %i1, %i2)701 %idx2 = affine.apply affine_map<(d0, d1, d2) -> (d2 floordiv 4)> (%i0, %i1, %i2)702 affine.store %c0, %M[%idx0, %idx1, %idx2] : memref<2 x 2 x 2 x i32>703 // expected-remark@above {{dependence from 0 to 0 at depth 1 = [1, 3][-7, 7][-3, 3]}}704 // expected-remark@above {{dependence from 0 to 0 at depth 2 = [0, 0][2, 7][-3, 3]}}705 // expected-remark@above {{dependence from 0 to 0 at depth 3 = [0, 0][0, 0][1, 3]}}706 // expected-remark@above {{dependence from 0 to 0 at depth 4 = false}}707 }708 }709 }710 return711}712 713// -----714// This test case arises in the context of a 6-d to 2-d reshape.715// CHECK-LABEL: func @delinearize_mod_floordiv716func.func @delinearize_mod_floordiv() {717 %c0 = arith.constant 0 : index718 %val = arith.constant 0 : i32719 %in = memref.alloc() : memref<2x2x3x3x16x1xi32>720 %out = memref.alloc() : memref<64x9xi32>721 722 affine.for %i0 = 0 to 2 {723 affine.for %i1 = 0 to 2 {724 affine.for %i2 = 0 to 3 {725 affine.for %i3 = 0 to 3 {726 affine.for %i4 = 0 to 16 {727 affine.for %i5 = 0 to 1 {728 affine.store %val, %in[%i0, %i1, %i2, %i3, %i4, %i5] : memref<2x2x3x3x16x1xi32>729// expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}730// expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}731// expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}732// expected-remark@above {{dependence from 0 to 0 at depth 4 = false}}733// expected-remark@above {{dependence from 0 to 0 at depth 5 = false}}734// expected-remark@above {{dependence from 0 to 0 at depth 6 = false}}735// expected-remark@above {{dependence from 0 to 0 at depth 7 = false}}736// expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}737// expected-remark@above {{dependence from 0 to 2 at depth 1 = false}}738 }739 }740 }741 }742 }743 }744 745 affine.for %ii = 0 to 64 {746 affine.for %jj = 0 to 9 {747 %a0 = affine.apply affine_map<(d0, d1) -> (d0 * (9 * 1024) + d1 * 128)> (%ii, %jj)748 %a10 = affine.apply affine_map<(d0) ->749 (d0 floordiv (2 * 3 * 3 * 128 * 128))> (%a0)750 %a11 = affine.apply affine_map<(d0) ->751 ((d0 mod 294912) floordiv (3 * 3 * 128 * 128))> (%a0)752 %a12 = affine.apply affine_map<(d0) ->753 ((((d0 mod 294912) mod 147456) floordiv 1152) floordiv 8)> (%a0)754 %a13 = affine.apply affine_map<(d0) ->755 ((((d0 mod 294912) mod 147456) mod 1152) floordiv 384)> (%a0)756 %a14 = affine.apply affine_map<(d0) ->757 (((((d0 mod 294912) mod 147456) mod 1152) mod 384) floordiv 128)> (%a0)758 %a15 = affine.apply affine_map<(d0) ->759 ((((((d0 mod 294912) mod 147456) mod 1152) mod 384) mod 128)760 floordiv 128)> (%a0)761 %v0 = affine.load %in[%a10, %a11, %a13, %a14, %a12, %a15] : memref<2x2x3x3x16x1xi32>762// expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}763// expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}764// expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}765// expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}766// expected-remark@above {{dependence from 1 to 2 at depth 1 = false}}767// expected-remark@above {{dependence from 1 to 2 at depth 2 = false}}768// expected-remark@above {{dependence from 1 to 2 at depth 3 = false}}769// TODO: the dep tester shouldn't be printing out these messages770// below; they are redundant.771 affine.store %v0, %out[%ii, %jj] : memref<64x9xi32>772// expected-remark@above {{dependence from 2 to 0 at depth 1 = false}}773// expected-remark@above {{dependence from 2 to 1 at depth 1 = false}}774// expected-remark@above {{dependence from 2 to 1 at depth 2 = false}}775// expected-remark@above {{dependence from 2 to 1 at depth 3 = false}}776// expected-remark@above {{dependence from 2 to 2 at depth 1 = false}}777// expected-remark@above {{dependence from 2 to 2 at depth 2 = false}}778// expected-remark@above {{dependence from 2 to 2 at depth 3 = false}}779 }780 }781 return782}783 784// TODO: add more test cases involving mod's/div's.785 786// -----787 788// Load and store ops access the same elements in strided scf.789// CHECK-LABEL: func @strided_loop_with_dependence_at_depth2790func.func @strided_loop_with_dependence_at_depth2() {791 %0 = memref.alloc() : memref<10xf32>792 %cf0 = arith.constant 0.0 : f32793 affine.for %i0 = 0 to 8 step 2 {794 affine.store %cf0, %0[%i0] : memref<10xf32>795 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}796 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}797 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}798 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}799 %v0 = affine.load %0[%i0] : memref<10xf32>800 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}801 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}802 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}803 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}804 }805 return806}807 808// -----809 810// Load and store ops access alternating memref elements: no dependence.811// CHECK-LABEL: func @strided_loop_with_no_dependence812func.func @strided_loop_with_no_dependence() {813 %0 = memref.alloc() : memref<10xf32>814 %cf0 = arith.constant 0.0 : f32815 affine.for %i0 = 0 to 8 step 2 {816 %a0 = affine.apply affine_map<(d0) -> (d0 + 1)>(%i0)817 affine.store %cf0, %0[%a0] : memref<10xf32>818 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}819 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}820 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}821 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}822 %v0 = affine.load %0[%i0] : memref<10xf32>823 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}824 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}825 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}826 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}827 }828 return829}830 831// -----832 833// Affine.Store op accesses memref elements at offset causing loop-carried dependence.834// CHECK-LABEL: func @strided_loop_with_loop_carried_dependence_at_depth1835func.func @strided_loop_with_loop_carried_dependence_at_depth1() {836 %0 = memref.alloc() : memref<10xf32>837 %cf0 = arith.constant 0.0 : f32838 affine.for %i0 = 0 to 8 step 2 {839 %a0 = affine.apply affine_map<(d0) -> (d0 + 4)>(%i0)840 affine.store %cf0, %0[%a0] : memref<10xf32>841 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}842 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}843 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [4, 4]}}844 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}845 %v0 = affine.load %0[%i0] : memref<10xf32>846 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}847 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}848 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}849 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}850 }851 return852}853 854// -----855 856// Test that the loop carried dependence from load to store on '%i0' is857// properly computed when the load and store are at different loop depths.858// CHECK-LABEL: func @test_dep_store_depth1_load_depth2859func.func @test_dep_store_depth1_load_depth2() {860 %0 = memref.alloc() : memref<100xf32>861 %cst = arith.constant 7.000000e+00 : f32862 affine.for %i0 = 0 to 10 {863 %a0 = affine.apply affine_map<(d0) -> (d0 - 1)>(%i0)864 affine.store %cst, %0[%a0] : memref<100xf32>865 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}866 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}867 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}868 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}869 affine.for %i1 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 1)>(%i0) {870 %1 = affine.load %0[%i1] : memref<100xf32>871 // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 1]}}872 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}873 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}874 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}875 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}876 }877 }878 return879}880 881// -----882 883// Test that the loop carried dependence from store to load on '%i0' is884// properly computed when the load and store are at different loop depths.885// CHECK-LABEL: func @test_dep_store_depth2_load_depth1886func.func @test_dep_store_depth2_load_depth1() {887 %0 = memref.alloc() : memref<100xf32>888 %cst = arith.constant 7.000000e+00 : f32889 affine.for %i0 = 0 to 10 {890 affine.for %i1 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 1)>(%i0) {891 affine.store %cst, %0[%i1] : memref<100xf32>892 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}893 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}894 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}895 // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2]}}896 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}897 }898 %a0 = affine.apply affine_map<(d0) -> (d0 - 2)>(%i0)899 %1 = affine.load %0[%a0] : memref<100xf32>900 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}901 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}902 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}903 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}904 }905 return906}907 908// -----909 910// Test the case that `affine.if` changes the domain for both load/store simultaneously.911#set = affine_set<(d0): (d0 - 50 >= 0)>912 913// CHECK-LABEL: func @test_affine_for_if_same_block() {914func.func @test_affine_for_if_same_block() {915 %0 = memref.alloc() : memref<100xf32>916 %cf7 = arith.constant 7.0 : f32917 918 affine.for %i0 = 0 to 100 {919 affine.if #set(%i0) {920 %1 = affine.load %0[%i0] : memref<100xf32>921 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}922 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}923 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}924 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}925 affine.store %cf7, %0[%i0] : memref<100xf32>926 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}927 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}928 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}929 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}930 }931 }932 933 return934}935 936// -----937 938// Test the case that the domain that load/store access is completedly separated by `affine.if`.939#set = affine_set<(d0): (d0 - 50 >= 0)>940 941// CHECK-LABEL: func @test_affine_for_if_separated() {942func.func @test_affine_for_if_separated() {943 %0 = memref.alloc() : memref<100xf32>944 %cf7 = arith.constant 7.0 : f32945 946 affine.for %i0 = 0 to 10 {947 affine.if #set(%i0) {948 %1 = affine.load %0[%i0] : memref<100xf32>949 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}950 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}951 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}952 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}953 } else {954 affine.store %cf7, %0[%i0] : memref<100xf32>955 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}956 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}957 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}958 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}959 }960 }961 962 return963}964 965// -----966 967// Test the case that the domain that load/store access has non-empty union set.968#set1 = affine_set<(d0): ( d0 - 25 >= 0)>969#set2 = affine_set<(d0): (- d0 + 75 >= 0)>970 971// CHECK-LABEL: func @test_affine_for_if_partially_joined() {972func.func @test_affine_for_if_partially_joined() {973 %0 = memref.alloc() : memref<100xf32>974 %cf7 = arith.constant 7.0 : f32975 976 affine.for %i0 = 0 to 100 {977 affine.if #set1(%i0) {978 %1 = affine.load %0[%i0] : memref<100xf32>979 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}980 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}981 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}982 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}983 }984 affine.if #set2(%i0) {985 affine.store %cf7, %0[%i0] : memref<100xf32>986 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}987 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}988 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}989 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}990 }991 }992 993 return994}995 996// -----997 998// Test whether interleaved affine.for/affine.if can be properly handled.999#set1 = affine_set<(d0): (d0 - 50 >= 0)>1000#set2 = affine_set<(d0, d1): (d0 - 75 >= 0, d1 - 50 >= 0)>1001 1002// CHECK-LABEL: func @test_interleaved_affine_for_if() {1003func.func @test_interleaved_affine_for_if() {1004 %0 = memref.alloc() : memref<100x100xf32>1005 %cf7 = arith.constant 7.0 : f321006 1007 affine.for %i0 = 0 to 100 {1008 affine.if #set1(%i0) {1009 affine.for %i1 = 0 to 100 {1010 %1 = affine.load %0[%i0, %i1] : memref<100x100xf32>1011 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}1012 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}1013 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}1014 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}1015 // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}1016 // expected-remark@above {{dependence from 0 to 1 at depth 3 = true}}1017 1018 affine.if #set2(%i0, %i1) {1019 affine.store %cf7, %0[%i0, %i1] : memref<100x100xf32>1020 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}1021 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}1022 // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}1023 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}1024 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}1025 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}1026 }1027 }1028 }1029 }1030 1031 return1032}1033 1034// -----1035 1036// Test whether symbols can be handled .1037#set1 = affine_set<(d0)[s0]: ( d0 - s0 floordiv 2 >= 0)>1038#set2 = affine_set<(d0): (- d0 + 51 >= 0)>1039 1040// CHECK-LABEL: func @test_interleaved_affine_for_if() {1041func.func @test_interleaved_affine_for_if() {1042 %0 = memref.alloc() : memref<101xf32>1043 %c0 = arith.constant 0 : index1044 %N = memref.dim %0, %c0 : memref<101xf32>1045 %cf7 = arith.constant 7.0 : f321046 1047 affine.for %i0 = 0 to 101 {1048 affine.if #set1(%i0)[%N] {1049 %1 = affine.load %0[%i0] : memref<101xf32>1050 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}1051 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}1052 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}1053 // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}1054 }1055 1056 affine.if #set2(%i0) {1057 affine.store %cf7, %0[%i0] : memref<101xf32>1058 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}1059 // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}1060 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}1061 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}1062 }1063 }1064 1065 return1066}1067 1068// -----1069// CHECK-LABEL: func @dependent_parallel() {1070func.func @dependent_parallel() {1071 %0 = memref.alloc() : memref<10xf32>1072 %cst = arith.constant 7.000000e+00 : f321073 affine.parallel (%i0) = (0) to (10) {1074 affine.store %cst, %0[%i0] : memref<10xf32>1075 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}1076 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}1077 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}1078 }1079 affine.parallel (%i1) = (0) to (10) {1080 %1 = affine.load %0[%i1] : memref<10xf32>1081 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}1082 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}1083 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}1084 }1085 return1086}1087 1088// -----1089 1090func.func @affine_if_no_dependence() {1091 %c1 = arith.constant 1 : index1092 %alloc = memref.alloc() : memref<15xi1>1093 %true = arith.constant true1094 affine.store %true, %alloc[%c1] : memref<15xi1>1095 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}1096 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}1097 // This set is empty.1098 affine.if affine_set<(d0, d1, d2, d3) : ((d0 + 1) mod 8 >= 0, d0 * -8 >= 0)>(%c1, %c1, %c1, %c1){1099 %265 = affine.load %alloc[%c1] : memref<15xi1>1100 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}1101 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}1102 }1103 return1104}1105 1106// -----1107 1108func.func @affine_parallel_dep_check_1() {1109 %memref_23 = memref.alloc() : memref<1x130xf32>1110 %memref_25 = memref.alloc() : memref<1x130x130xf32>1111 %cst = arith.constant 0.0 : f321112 affine.parallel (%arg4, %arg5) = (0, 0) to (1, 130) {1113 affine.store %cst, %memref_25[%arg4, %arg5, 129] : memref<1x130x130xf32>1114 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}1115 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}1116 // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}1117 // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}1118 }1119 %memref_27 = memref.alloc() : memref<1x128x128xf32>1120 affine.parallel (%arg4) = (0) to (130) {1121 affine.parallel (%arg5, %arg6) = (0, 0) to (1, 130) {1122 affine.load %memref_25[0, %arg4 + %arg5, %arg6] : memref<1x130x130xf32>1123 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}1124 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}1125 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}1126 // expected-remark@above {{dependence from 1 to 1 at depth 4 = false}}1127 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}1128 }1129 }1130 return1131}1132 1133// -----1134 1135func.func @affine_parallel_dep_check_2() {1136 %m = memref.alloc() : memref<128xf32>1137 %cst = arith.constant 0.0 : f321138 affine.parallel (%arg4) = (0) to (127) {1139 affine.store %cst, %m[%arg4] : memref<128xf32>1140 // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}1141 // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}1142 // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}1143 }1144 affine.load %m[127]: memref<128xf32>1145 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}1146 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}1147 return1148}1149