tests/data_dependent.scop

   1 start: 274
   2 end: 498
   3 indent: "\t"
   4 context: '[N, M] -> {  : N <= 1000 and N >= 10 and M >= 10 and M <= 1000 }'
   5 arrays:
   6 - context: '[N] -> {  : N >= 0 }'
   7   extent: '[N, M] -> { A[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <=
   8     9 }'
   9   element_type: int
  10   element_size: 4
  11 - context: '[N] -> {  : N >= 0 }'
  12   extent: '[N, M] -> { C[i0] : i0 <= -1 + N and i0 >= 0 }'
  13   element_type: int
  14   element_size: 4
  15 - context: '[M, N] -> {  : N >= 0 and M >= 0 }'
  16   extent: '[N, M] -> { in1[i0, i1] : i1 <= -1 + M and i1 >= 0 and i0 <= -1 + N and
  17     i0 >= 0 }'
  18   element_type: int
  19   element_size: 4
  20 - context: '[N] -> {  : N >= 0 }'
  21   extent: '[N, M] -> { in2[i0] : i0 <= -1 + N and i0 >= 0 }'
  22   value_bounds: '{ [i0] : i0 >= -1 and i0 <= 1 }'
  23   element_type: int
  24   element_size: 4
  25 - context: '{  :  }'
  26   extent: '[N, M] -> { m[] }'
  27   element_type: int
  28   element_size: 4
  29 statements:
  30 - line: 23
  31   domain: '[N, M] -> { S_0[i] : i <= -1 + N and i >= 0 }'
  32   schedule: '[N] -> { S_0[i] -> [0, i, 0] }'
  33   body:
  34     type: expression
  35     expr:
  36       type: op
  37       operation: =
  38       arguments:
  39       - type: access
  40         index: '[N, M] -> { S_0[i] -> m[] }'
  41         reference: __pet_ref_0
  42         read: 0
  43         write: 1
  44       - type: op
  45         operation: +
  46         arguments:
  47         - type: access
  48           index: '[N, M] -> { S_0[i] -> [(i)] }'
  49           reference: __pet_ref_1
  50           read: 1
  51           write: 0
  52         - type: int
  53           value: 1
  54 - line: 25
  55   domain: '[N, M] -> { S_1[i, j] : j <= -1 + M and j >= 0 and i <= -1 + N and i >=
  56     0 }'
  57   schedule: '[N, M] -> { S_1[i, j] -> [0, i, 1, j] }'
  58   body:
  59     type: expression
  60     expr:
  61       type: op
  62       operation: =
  63       arguments:
  64       - type: access
  65         index: '[N, M] -> { S_1[i, j] -> m[] }'
  66         reference: __pet_ref_2
  67         read: 0
  68         write: 1
  69       - type: call
  70         name: g
  71         arguments:
  72         - type: call
  73           name: h
  74           arguments:
  75           - type: access
  76             index: '[N, M] -> { S_1[i, j] -> m[] }'
  77             reference: __pet_ref_3
  78             read: 1
  79             write: 0
  80         - type: access
  81           index: '[N, M] -> { S_1[i, j] -> in1[(i), (j)] }'
  82           reference: __pet_ref_4
  83           read: 1
  84           write: 0
  85 - line: 26
  86   domain: '[N, M] -> { S_2[i] : i <= -1 + N and i >= 0 }'
  87   schedule: '[N] -> { S_2[i] -> [0, i, 2] }'
  88   body:
  89     type: expression
  90     expr:
  91       type: call
  92       name: compute_row
  93       arguments:
  94       - type: call
  95         name: h
  96         arguments:
  97         - type: access
  98           index: '[N, M] -> { S_2[i] -> m[] }'
  99           reference: __pet_ref_5
 100           read: 1
 101           write: 0
 102       - type: access
 103         index: '[N, M] -> { S_2[i] -> A[(i)] }'
 104         depth: 2
 105         reference: __pet_ref_6
 106         read: 0
 107         write: 1
 108 - line: 28
 109   domain: '[N, M] -> { S_3[] }'
 110   schedule: '{ S_3[] -> [1] }'
 111   body:
 112     type: expression
 113     expr:
 114       type: op
 115       operation: =
 116       arguments:
 117       - type: access
 118         index: '[N, M] -> { S_3[] -> A[(5), (6)] }'
 119         reference: __pet_ref_7
 120         read: 0
 121         write: 1
 122       - type: int
 123         value: 0
 124 - line: 30
 125   domain: '[N, M] -> { S_4[i] : i <= -3 + N and i >= 0 }'
 126   schedule: '[N] -> { S_4[i] -> [2, i] }'
 127   body:
 128     type: expression
 129     expr:
 130       type: op
 131       operation: =
 132       arguments:
 133       - type: access
 134         index: '[N, M] -> { S_4[i] -> C[(i)] }'
 135         reference: __pet_ref_8
 136         read: 0
 137         write: 1
 138       - type: call
 139         name: f
 140         arguments:
 141         - type: access
 142           index: '[N, M] -> { [S_4[i] -> [i1]] -> A[(1 + i + i1)] }'
 143           depth: 2
 144           reference: __pet_ref_10
 145           read: 1
 146           write: 0
 147           arguments:
 148           - type: access
 149             index: '[N, M] -> { S_4[i] -> in2[(i)] }'
 150             reference: __pet_ref_9
 151             read: 1
 152             write: 0