flang/test/Lower/OpenACC/acc-loop.f90

   1 ! This test checks lowering of OpenACC loop directive.
   2
   3 ! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
   4 ! RUN: bbc -fopenacc -emit-hlfir %s -o - | FileCheck %s
   5
   6 ! CHECK-LABEL: acc.private.recipe @privatization_ref_10x10xf32 : !fir.ref<!fir.array<10x10xf32>> init {
   7 ! CHECK: ^bb0(%{{.*}}: !fir.ref<!fir.array<10x10xf32>>):
   8 ! CHECK: acc.yield %{{.*}} : !fir.ref<!fir.array<10x10xf32>>
   9 ! CHECK: }
  10
  11 program acc_loop
  12
  13   integer :: i, j
  14   integer, parameter :: n = 10
  15   real, dimension(n) :: a, b
  16   real, dimension(n, n) :: c, d
  17   integer :: gangNum = 8
  18   integer :: gangDim = 1
  19   integer :: gangStatic = 8
  20   integer :: vectorLength = 128
  21   integer, parameter :: tileSize = 2
  22   integer :: reduction_i
  23   real :: reduction_r
  24
  25
  26   !$acc loop
  27   DO i = 1, n
  28     a(i) = b(i)
  29   END DO
  30
  31 !CHECK:      acc.loop {
  32 !CHECK:        fir.do_loop
  33 !CHECK:        acc.yield
  34 !CHECK-NEXT: }{{$}}
  35
  36  !$acc loop seq
  37   DO i = 1, n
  38     a(i) = b(i)
  39   END DO
  40
  41 !CHECK:      acc.loop {
  42 !CHECK:        fir.do_loop
  43 !CHECK:        acc.yield
  44 !CHECK-NEXT: } attributes {seq}
  45
  46   !$acc loop auto
  47   DO i = 1, n
  48     a(i) = b(i)
  49   END DO
  50
  51 !CHECK:      acc.loop {
  52 !CHECK:        fir.do_loop
  53 !CHECK:        acc.yield
  54 !CHECK-NEXT: } attributes {auto}
  55
  56   !$acc loop independent
  57   DO i = 1, n
  58     a(i) = b(i)
  59   END DO
  60
  61 !CHECK:      acc.loop {
  62 !CHECK:        fir.do_loop
  63 !CHECK:        acc.yield
  64 !CHECK-NEXT: } attributes {independent}
  65
  66   !$acc loop gang
  67   DO i = 1, n
  68     a(i) = b(i)
  69   END DO
  70
  71 !CHECK:      acc.loop gang {
  72 !CHECK:        fir.do_loop
  73 !CHECK:        acc.yield
  74 !CHECK-NEXT: }{{$}}
  75
  76   !$acc loop gang(num: 8)
  77   DO i = 1, n
  78     a(i) = b(i)
  79   END DO
  80
  81 !CHECK:      [[GANGNUM1:%.*]] = arith.constant 8 : i32
  82 !CHECK-NEXT: acc.loop gang(num=[[GANGNUM1]] : i32) {
  83 !CHECK:        fir.do_loop
  84 !CHECK:        acc.yield
  85 !CHECK-NEXT: }{{$}}
  86
  87   !$acc loop gang(num: gangNum)
  88   DO i = 1, n
  89     a(i) = b(i)
  90   END DO
  91
  92 !CHECK:      [[GANGNUM2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
  93 !CHECK-NEXT: acc.loop gang(num=[[GANGNUM2]] : i32) {
  94 !CHECK:        fir.do_loop
  95 !CHECK:        acc.yield
  96 !CHECK-NEXT: }{{$}}
  97
  98  !$acc loop gang(num: gangNum, static: gangStatic)
  99   DO i = 1, n
 100     a(i) = b(i)
 101   END DO
 102
 103 !CHECK: acc.loop gang(num=%{{.*}} : i32, static=%{{.*}} : i32) {
 104 !CHECK:        fir.do_loop
 105 !CHECK:        acc.yield
 106 !CHECK-NEXT: }{{$}}
 107
 108   !$acc loop vector
 109   DO i = 1, n
 110     a(i) = b(i)
 111   END DO
 112
 113 !CHECK:      acc.loop vector {
 114 !CHECK:        fir.do_loop
 115 !CHECK:        acc.yield
 116 !CHECK-NEXT: }{{$}}
 117
 118   !$acc loop vector(128)
 119   DO i = 1, n
 120     a(i) = b(i)
 121   END DO
 122
 123 !CHECK: [[CONSTANT128:%.*]] = arith.constant 128 : i32
 124 !CHECK:      acc.loop vector([[CONSTANT128]] : i32) {
 125 !CHECK:        fir.do_loop
 126 !CHECK:        acc.yield
 127 !CHECK-NEXT: }{{$}}
 128
 129   !$acc loop vector(vectorLength)
 130   DO i = 1, n
 131     a(i) = b(i)
 132   END DO
 133
 134 !CHECK:      [[VECTORLENGTH:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
 135 !CHECK:      acc.loop vector([[VECTORLENGTH]] : i32) {
 136 !CHECK:        fir.do_loop
 137 !CHECK:        acc.yield
 138 !CHECK-NEXT: }{{$}}
 139
 140 !$acc loop worker
 141   DO i = 1, n
 142     a(i) = b(i)
 143   END DO
 144
 145 !CHECK:      acc.loop worker {
 146 !CHECK:        fir.do_loop
 147 !CHECK:        acc.yield
 148 !CHECK-NEXT: }{{$}}
 149
 150   !$acc loop worker(128)
 151   DO i = 1, n
 152     a(i) = b(i)
 153   END DO
 154
 155 !CHECK: [[WORKER128:%.*]] = arith.constant 128 : i32
 156 !CHECK:      acc.loop worker([[WORKER128]] : i32) {
 157 !CHECK:        fir.do_loop
 158 !CHECK:        acc.yield
 159 !CHECK-NEXT: }{{$}}
 160
 161   !$acc loop private(c)
 162   DO i = 1, n
 163     a(i) = b(i)
 164   END DO
 165
 166 !CHECK:      acc.loop private(@privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref<!fir.array<10x10xf32>>) {
 167 !CHECK:        fir.do_loop
 168 !CHECK:        acc.yield
 169 !CHECK-NEXT: }{{$}}
 170
 171   !$acc loop private(c, d)
 172   DO i = 1, n
 173     a(i) = b(i)
 174   END DO
 175
 176 !CHECK:      acc.loop private(@privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref<!fir.array<10x10xf32>>, @privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref<!fir.array<10x10xf32>>) {
 177 !CHECK:        fir.do_loop
 178 !CHECK:        acc.yield
 179 !CHECK-NEXT: }{{$}}
 180
 181   !$acc loop private(c) private(d)
 182   DO i = 1, n
 183     a(i) = b(i)
 184   END DO
 185
 186 !CHECK:      acc.loop private(@privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref<!fir.array<10x10xf32>>, @privatization_ref_10x10xf32 -> %{{.*}} : !fir.ref<!fir.array<10x10xf32>>) {
 187 !CHECK:        fir.do_loop
 188 !CHECK:        acc.yield
 189 !CHECK-NEXT: }{{$}}
 190
 191   !$acc loop tile(2)
 192   DO i = 1, n
 193     a(i) = b(i)
 194   END DO
 195 !CHECK:      [[TILESIZE:%.*]] = arith.constant 2 : i32
 196 !CHECK:      acc.loop tile([[TILESIZE]] : i32) {
 197 !CHECK:        fir.do_loop
 198 !CHECK:        acc.yield
 199 !CHECK-NEXT: }{{$}}
 200
 201  !$acc loop tile(*)
 202   DO i = 1, n
 203     a(i) = b(i)
 204   END DO
 205 !CHECK:      [[TILESIZEM1:%.*]] = arith.constant -1 : i32
 206 !CHECK:      acc.loop tile([[TILESIZEM1]] : i32) {
 207 !CHECK:        fir.do_loop
 208 !CHECK:        acc.yield
 209 !CHECK-NEXT: }{{$}}
 210
 211   !$acc loop tile(2, 2)
 212   DO i = 1, n
 213     DO j = 1, n
 214       c(i, j) = d(i, j)
 215     END DO
 216   END DO
 217
 218 !CHECK:      [[TILESIZE1:%.*]] = arith.constant 2 : i32
 219 !CHECK:      [[TILESIZE2:%.*]] = arith.constant 2 : i32
 220 !CHECK:      acc.loop tile([[TILESIZE1]], [[TILESIZE2]] : i32, i32) {
 221 !CHECK:        fir.do_loop
 222 !CHECK:        acc.yield
 223 !CHECK-NEXT: }{{$}}
 224
 225   !$acc loop tile(tileSize)
 226   DO i = 1, n
 227     a(i) = b(i)
 228   END DO
 229
 230 !CHECK:      acc.loop tile(%{{.*}} : i32) {
 231 !CHECK:        fir.do_loop
 232 !CHECK:        acc.yield
 233 !CHECK-NEXT: }{{$}}
 234
 235   !$acc loop tile(tileSize, tileSize)
 236   DO i = 1, n
 237     DO j = 1, n
 238       c(i, j) = d(i, j)
 239     END DO
 240   END DO
 241
 242 !CHECK:      acc.loop tile(%{{.*}}, %{{.*}} : i32, i32) {
 243 !CHECK:        fir.do_loop
 244 !CHECK:        acc.yield
 245 !CHECK-NEXT: }{{$}}
 246
 247   !$acc loop collapse(2)
 248   DO i = 1, n
 249     DO j = 1, n
 250       c(i, j) = d(i, j)
 251     END DO
 252   END DO
 253
 254 !CHECK:      acc.loop {
 255 !CHECK:        fir.do_loop
 256 !CHECK:          fir.do_loop
 257 !CHECK:        acc.yield
 258 !CHECK-NEXT: } attributes {collapse = 2 : i64}
 259
 260   !$acc loop
 261   DO i = 1, n
 262     !$acc loop
 263     DO j = 1, n
 264       c(i, j) = d(i, j)
 265     END DO
 266   END DO
 267
 268 !CHECK:      acc.loop {
 269 !CHECK:        fir.do_loop
 270 !CHECK:          acc.loop {
 271 !CHECK:            fir.do_loop
 272 !CHECK:            acc.yield
 273 !CHECK-NEXT:   }{{$}}
 274 !CHECK:        acc.yield
 275 !CHECK-NEXT: }{{$}}
 276
 277   !$acc loop reduction(+:reduction_r) reduction(*:reduction_i)
 278   do i = 1, n
 279     reduction_r = reduction_r + a(i)
 280     reduction_i = 1
 281   end do
 282
 283 ! CHECK:      acc.loop reduction(@reduction_add_ref_f32 -> %{{.*}} : !fir.ref<f32>, @reduction_mul_ref_i32 -> %{{.*}} : !fir.ref<i32>) {
 284 ! CHECK:        fir.do_loop
 285 ! CHECK:        acc.yield
 286 ! CHECK-NEXT: }{{$}}
 287
 288  !$acc loop gang(dim: gangDim, static: gangStatic)
 289   DO i = 1, n
 290     a(i) = b(i)
 291   END DO
 292
 293 !CHECK: acc.loop gang(dim=%{{.*}}, static=%{{.*}} : i32) {
 294 !CHECK:        fir.do_loop
 295 !CHECK:        acc.yield
 296 !CHECK-NEXT: }{{$}}
 297
 298   !$acc loop gang(dim: 1)
 299   DO i = 1, n
 300     a(i) = b(i)
 301   END DO
 302
 303 !CHECK:      [[GANGDIM1:%.*]] = arith.constant 1 : i32
 304 !CHECK-NEXT: acc.loop gang(dim=[[GANGDIM1]] : i32) {
 305 !CHECK:        fir.do_loop
 306 !CHECK:        acc.yield
 307 !CHECK-NEXT: }{{$}}
 308
 309   !$acc loop
 310   DO i = 1, n
 311     !$acc cache(b)
 312     a(i) = b(i)
 313   END DO
 314
 315 ! CHECK: %[[CACHE:.*]] = acc.cache varPtr(%{{.*}} : !fir.ref<!fir.array<10xf32>>) bounds(%{{.*}}) -> !fir.ref<!fir.array<10xf32>> {name = "b"}
 316 ! CHECK: acc.loop cache(%[[CACHE]] : !fir.ref<!fir.array<10xf32>>)
 317
 318   !$acc loop
 319   do 100 i=0, n
 320   100 continue
 321 ! CHECK: acc.loop
 322 ! CHECK: fir.do_loop
 323
 324 end program