tests/data_dependent.scop

   1 start: 274
   2 end: 498
   3 indent: "\t"
   4 context: '[N, M] -> {  : 10 <= N <= 1000 and 10 <= M <= 1000 }'
   5 schedule: '{ domain: "[N, M] -> { S_6[i] : 0 <= i < N; S_8[]; S_12[]; S_7[]; S_10[i]
   6   : 0 <= i <= -3 + N; S_16[]; S_13[]; S_3[i, j] : 0 <= i < N and 0 <= j < M; S_9[i]
   7   : 0 <= i <= -3 + N; S_0[]; S_1[i] : 0 <= i < N; S_5[i] : 0 <= i < N; S_14[]; S_4[i,
   8   j] : 0 <= i < N and 0 <= j < M; S_2[i] : 0 <= i < N; S_11[]; S_15[] }", child: {
   9   sequence: [ { filter: "[N, M] -> { S_0[] }" }, { filter: "[N, M] -> { S_6[i]; S_3[i,
  10   j]; S_1[i]; S_5[i]; S_4[i, j]; S_2[i] }", child: { schedule: "[N, M] -> L_0[{ S_6[i]
  11   -> [(i)]; S_3[i, j] -> [(i)]; S_1[i] -> [(i)]; S_5[i] -> [(i)]; S_4[i, j] -> [(i)];
  12   S_2[i] -> [(i)] }]", child: { sequence: [ { filter: "[N, M] -> { S_1[i] }" }, {
  13   filter: "[N, M] -> { S_2[i] }" }, { filter: "[N, M] -> { S_3[i, j]; S_4[i, j] }",
  14   child: { schedule: "[N, M] -> L_1[{ S_3[i, j] -> [(j)]; S_4[i, j] -> [(j)] }]",
  15   child: { sequence: [ { filter: "[N, M] -> { S_3[i, j] }" }, { filter: "[N, M] ->
  16   { S_4[i, j] }" } ] } } }, { filter: "[N, M] -> { S_5[i] }" }, { filter: "[N, M]
  17   -> { S_6[i] }" } ] } } }, { filter: "[N, M] -> { S_7[] }" }, { filter: "[N, M] ->
  18   { S_8[] }" }, { filter: "[N, M] -> { S_10[i]; S_9[i] }", child: { schedule: "[N]
  19   -> L_2[{ S_10[i] -> [(i)]; S_9[i] -> [(i)] }]", child: { sequence: [ { filter: "[N]
  20   -> { S_9[i] }" }, { filter: "[N] -> { S_10[i] }" } ] } } }, { filter: "[N, M] ->
  21   { S_12[]; S_16[]; S_13[]; S_14[]; S_11[]; S_15[] }", child: { set: [ { filter: "{
  22   S_11[] }" }, { filter: "{ S_12[] }" }, { filter: "{ S_13[] }" }, { filter: "{ S_14[]
  23   }" }, { filter: "{ S_15[] }" }, { filter: "{ S_16[] }" } ] } } ] } }'
  24 arrays:
  25 - context: '[N] -> {  : N >= 0 }'
  26   extent: '[N, M] -> { A[i0, i1] : 0 <= i0 < N and 0 <= i1 <= 9 }'
  27   element_type: int
  28   element_size: 4
  29 - context: '[N] -> {  : N >= 0 }'
  30   extent: '[N, M] -> { C[i0] : 0 <= i0 < N }'
  31   element_type: int
  32   element_size: 4
  33 - context: '{  :  }'
  34   extent: '[N, M] -> { i[] }'
  35   element_type: int
  36   element_size: 4
  37 - context: '[M, N] -> {  : M >= 0 and N >= 0 }'
  38   extent: '[N, M] -> { in1[i0, i1] : 0 <= i0 < N and 0 <= i1 < M }'
  39   element_type: int
  40   element_size: 4
  41 - context: '[N] -> {  : N >= 0 }'
  42   extent: '[N, M] -> { in2[i0] : 0 <= i0 < N }'
  43   value_bounds: '{ [i0] : -1 <= i0 <= 1 }'
  44   element_type: int
  45   element_size: 4
  46 - context: '{  :  }'
  47   extent: '[N, M] -> { j[] }'
  48   element_type: int
  49   element_size: 4
  50 - context: '{  :  }'
  51   extent: '[N, M] -> { m[] }'
  52   element_type: int
  53   element_size: 4
  54 statements:
  55 - line: 22
  56   domain: '[N, M] -> { S_0[] }'
  57   body:
  58     type: expression
  59     expr:
  60       type: op
  61       operation: =
  62       arguments:
  63       - type: access
  64         index: '[N, M] -> { S_0[] -> i[] }'
  65         reference: __pet_ref_0
  66         read: 0
  67         write: 1
  68       - type: int
  69         value: 0
  70 - line: 23
  71   domain: '[N, M] -> { S_1[i] : 0 <= i < N }'
  72   body:
  73     type: expression
  74     expr:
  75       type: op
  76       operation: =
  77       arguments:
  78       - type: access
  79         index: '[N, M] -> { S_1[i] -> m[] }'
  80         reference: __pet_ref_1
  81         read: 0
  82         write: 1
  83       - type: access
  84         index: '[N, M] -> { S_1[i] -> [(1 + i)] }'
  85         reference: __pet_ref_2
  86         read: 1
  87         write: 0
  88 - line: 24
  89   domain: '[N, M] -> { S_2[i] : 0 <= i < N }'
  90   body:
  91     type: expression
  92     expr:
  93       type: op
  94       operation: =
  95       arguments:
  96       - type: access
  97         index: '[N, M] -> { S_2[i] -> j[] }'
  98         reference: __pet_ref_3
  99         read: 0
 100         write: 1
 101       - type: int
 102         value: 0
 103 - line: 25
 104   domain: '[N, M] -> { S_3[i, j] : 0 <= i < N and 0 <= j < M }'
 105   body:
 106     type: expression
 107     expr:
 108       type: op
 109       operation: =
 110       arguments:
 111       - type: access
 112         index: '[N, M] -> { S_3[i, j] -> m[] }'
 113         reference: __pet_ref_4
 114         read: 0
 115         write: 1
 116       - type: call
 117         name: g
 118         arguments:
 119         - type: call
 120           name: h
 121           arguments:
 122           - type: access
 123             index: '[N, M] -> { S_3[i, j] -> m[] }'
 124             reference: __pet_ref_5
 125             read: 1
 126             write: 0
 127         - type: access
 128           index: '[N, M] -> { S_3[i, j] -> in1[(i), (j)] }'
 129           reference: __pet_ref_6
 130           read: 1
 131           write: 0
 132 - line: 24
 133   domain: '[N, M] -> { S_4[i, j] : 0 <= i < N and 0 <= j < M }'
 134   body:
 135     type: expression
 136     expr:
 137       type: op
 138       operation: =
 139       arguments:
 140       - type: access
 141         index: '[N, M] -> { S_4[i, j] -> j[] }'
 142         reference: __pet_ref_7
 143         read: 0
 144         write: 1
 145       - type: access
 146         index: '[N, M] -> { S_4[i, j] -> [(1 + j)] }'
 147         reference: __pet_ref_8
 148         read: 1
 149         write: 0
 150 - line: 26
 151   domain: '[N, M] -> { S_5[i] : 0 <= i < N }'
 152   body:
 153     type: expression
 154     expr:
 155       type: call
 156       name: compute_row
 157       arguments:
 158       - type: call
 159         name: h
 160         arguments:
 161         - type: access
 162           index: '[N, M] -> { S_5[i] -> m[] }'
 163           reference: __pet_ref_9
 164           read: 1
 165           write: 0
 166       - type: access
 167         may_read: '[N, M] -> { S_5[i] -> A[i, o1] }'
 168         may_write: '[N, M] -> { S_5[i] -> A[i, o1] }'
 169         must_write: '[N, M] -> {  }'
 170         index: '[N, M] -> { S_5[i] -> A[(i)] }'
 171         depth: 2
 172         reference: __pet_ref_10
 173         read: 1
 174         write: 1
 175 - line: 22
 176   domain: '[N, M] -> { S_6[i] : 0 <= i < N }'
 177   body:
 178     type: expression
 179     expr:
 180       type: op
 181       operation: =
 182       arguments:
 183       - type: access
 184         index: '[N, M] -> { S_6[i] -> i[] }'
 185         reference: __pet_ref_11
 186         read: 0
 187         write: 1
 188       - type: access
 189         index: '[N, M] -> { S_6[i] -> [(1 + i)] }'
 190         reference: __pet_ref_12
 191         read: 1
 192         write: 0
 193 - line: 28
 194   domain: '[N, M] -> { S_7[] }'
 195   body:
 196     type: expression
 197     expr:
 198       type: op
 199       operation: =
 200       arguments:
 201       - type: access
 202         index: '[N, M] -> { S_7[] -> A[(5), (6)] }'
 203         reference: __pet_ref_13
 204         read: 0
 205         write: 1
 206       - type: int
 207         value: 0
 208 - line: 29
 209   domain: '[N, M] -> { S_8[] }'
 210   body:
 211     type: expression
 212     expr:
 213       type: op
 214       operation: =
 215       arguments:
 216       - type: access
 217         index: '[N, M] -> { S_8[] -> i[] }'
 218         reference: __pet_ref_14
 219         read: 0
 220         write: 1
 221       - type: int
 222         value: 0
 223 - line: 30
 224   domain: '[N, M] -> { S_9[i] : 0 <= i <= -3 + N }'
 225   body:
 226     type: expression
 227     expr:
 228       type: op
 229       operation: =
 230       arguments:
 231       - type: access
 232         index: '[N, M] -> { S_9[i] -> C[(i)] }'
 233         reference: __pet_ref_15
 234         read: 0
 235         write: 1
 236       - type: call
 237         name: f
 238         arguments:
 239         - type: access
 240           index: '[N, M] -> { [S_9[i] -> [i1]] -> A[(1 + i + i1)] }'
 241           depth: 2
 242           reference: __pet_ref_17
 243           read: 1
 244           write: 0
 245           arguments:
 246           - type: access
 247             index: '[N, M] -> { S_9[i] -> in2[(i)] }'
 248             reference: __pet_ref_16
 249             read: 1
 250             write: 0
 251 - line: 29
 252   domain: '[N, M] -> { S_10[i] : 0 <= i <= -3 + N }'
 253   body:
 254     type: expression
 255     expr:
 256       type: op
 257       operation: =
 258       arguments:
 259       - type: access
 260         index: '[N, M] -> { S_10[i] -> i[] }'
 261         reference: __pet_ref_18
 262         read: 0
 263         write: 1
 264       - type: access
 265         index: '[N, M] -> { S_10[i] -> [(1 + i)] }'
 266         reference: __pet_ref_19
 267         read: 1
 268         write: 0
 269 - line: -1
 270   domain: '[N, M] -> { S_11[] }'
 271   body:
 272     type: expression
 273     expr:
 274       type: op
 275       operation: kill
 276       arguments:
 277       - type: access
 278         killed: '[N, M] -> { S_11[] -> i[] }'
 279         index: '[N, M] -> { S_11[] -> i[] }'
 280         reference: __pet_ref_20
 281         kill: 1
 282 - line: -1
 283   domain: '[N, M] -> { S_12[] }'
 284   body:
 285     type: expression
 286     expr:
 287       type: op
 288       operation: kill
 289       arguments:
 290       - type: access
 291         killed: '[N, M] -> { S_12[] -> j[] }'
 292         index: '[N, M] -> { S_12[] -> j[] }'
 293         reference: __pet_ref_21
 294         kill: 1
 295 - line: -1
 296   domain: '[N, M] -> { S_13[] }'
 297   body:
 298     type: expression
 299     expr:
 300       type: op
 301       operation: kill
 302       arguments:
 303       - type: access
 304         killed: '[N, M] -> { S_13[] -> in1[o0, o1] : 0 <= o0 < N and 0 <= o1 < M }'
 305         index: '[N, M] -> { S_13[] -> in1[] }'
 306         depth: 2
 307         reference: __pet_ref_22
 308         kill: 1
 309 - line: -1
 310   domain: '[N, M] -> { S_14[] }'
 311   body:
 312     type: expression
 313     expr:
 314       type: op
 315       operation: kill
 316       arguments:
 317       - type: access
 318         killed: '[N, M] -> { S_14[] -> in2[o0] : 0 <= o0 < N }'
 319         index: '[N, M] -> { S_14[] -> in2[] }'
 320         depth: 1
 321         reference: __pet_ref_23
 322         kill: 1
 323 - line: -1
 324   domain: '[N, M] -> { S_15[] }'
 325   body:
 326     type: expression
 327     expr:
 328       type: op
 329       operation: kill
 330       arguments:
 331       - type: access
 332         killed: '[N, M] -> { S_15[] -> C[o0] : 0 <= o0 < N }'
 333         index: '[N, M] -> { S_15[] -> C[] }'
 334         depth: 1
 335         reference: __pet_ref_24
 336         kill: 1
 337 - line: -1
 338   domain: '[N, M] -> { S_16[] }'
 339   body:
 340     type: expression
 341     expr:
 342       type: op
 343       operation: kill
 344       arguments:
 345       - type: access
 346         killed: '[N, M] -> { S_16[] -> m[] }'
 347         index: '[N, M] -> { S_16[] -> m[] }'
 348         reference: __pet_ref_25
 349         kill: 1