| 1 |
// Tests converting `fir.do_concurrent` ops to `fir.do_loop` ops. |
| 2 |
|
| 3 |
// RUN: fir-opt --split-input-file --simplify-fir-operations %s | FileCheck %s |
| 4 |
|
| 5 |
func.func @dc_1d(%i_lb: index, %i_ub: index, %i_st: index) { |
| 6 |
fir.do_concurrent { |
| 7 |
%i = fir.alloca i32 |
| 8 |
fir.do_concurrent.loop (%i_iv) = (%i_lb) to (%i_ub) step (%i_st) { |
| 9 |
%0 = fir.convert %i_iv : (index) -> i32 |
| 10 |
fir.store %0 to %i : !fir.ref<i32> |
| 11 |
} |
| 12 |
} |
| 13 |
return |
| 14 |
} |
| 15 |
|
| 16 |
// CHECK-LABEL: func.func @dc_1d( |
| 17 |
// CHECK-SAME: %[[I_LB:[^[:space:]]+]]: index, |
| 18 |
// CHECK-SAME: %[[I_UB:[^[:space:]]+]]: index, |
| 19 |
// CHECK-SAME: %[[I_ST:[^[:space:]]+]]: index) { |
| 20 |
|
| 21 |
// CHECK: %[[I:.*]] = fir.alloca i32 |
| 22 |
|
| 23 |
// CHECK: fir.do_loop %[[I_IV:.*]] = %[[I_LB]] to %[[I_UB]] step %[[I_ST]] unordered { |
| 24 |
// CHECK: %[[I_IV_CVT:.*]] = fir.convert %[[I_IV]] : (index) -> i32 |
| 25 |
// CHECK: fir.store %[[I_IV_CVT]] to %[[I]] : !fir.ref<i32> |
| 26 |
// CHECK: } |
| 27 |
|
| 28 |
// CHECK: return |
| 29 |
// CHECK: } |
| 30 |
|
| 31 |
// ----- |
| 32 |
|
| 33 |
func.func @dc_2d(%i_lb: index, %i_ub: index, %i_st: index, |
| 34 |
%j_lb: index, %j_ub: index, %j_st: index) { |
| 35 |
llvm.br ^bb1 |
| 36 |
|
| 37 |
^bb1: |
| 38 |
fir.do_concurrent { |
| 39 |
%i = fir.alloca i32 |
| 40 |
%j = fir.alloca i32 |
| 41 |
fir.do_concurrent.loop |
| 42 |
(%i_iv, %j_iv) = (%i_lb, %j_lb) to (%i_ub, %j_ub) step (%i_st, %j_st) { |
| 43 |
%0 = fir.convert %i_iv : (index) -> i32 |
| 44 |
fir.store %0 to %i : !fir.ref<i32> |
| 45 |
|
| 46 |
%1 = fir.convert %j_iv : (index) -> i32 |
| 47 |
fir.store %1 to %j : !fir.ref<i32> |
| 48 |
} |
| 49 |
} |
| 50 |
return |
| 51 |
} |
| 52 |
|
| 53 |
// CHECK-LABEL: func.func @dc_2d( |
| 54 |
// CHECK-SAME: %[[I_LB:[^[:space:]]+]]: index, |
| 55 |
// CHECK-SAME: %[[I_UB:[^[:space:]]+]]: index, |
| 56 |
// CHECK-SAME: %[[I_ST:[^[:space:]]+]]: index, |
| 57 |
// CHECK-SAME: %[[J_LB:[^[:space:]]+]]: index, |
| 58 |
// CHECK-SAME: %[[J_UB:[^[:space:]]+]]: index, |
| 59 |
// CHECK-SAME: %[[J_ST:[^[:space:]]+]]: index) { |
| 60 |
|
| 61 |
// CHECK: %[[I:.*]] = fir.alloca i32 |
| 62 |
// CHECK: %[[J:.*]] = fir.alloca i32 |
| 63 |
// CHECK: llvm.br ^bb1 |
| 64 |
|
| 65 |
// CHECK: ^bb1: |
| 66 |
// CHECK: fir.do_loop %[[I_IV:.*]] = %[[I_LB]] to %[[I_UB]] step %[[I_ST]] unordered { |
| 67 |
// CHECK: fir.do_loop %[[J_IV:.*]] = %[[J_LB]] to %[[J_UB]] step %[[J_ST]] unordered { |
| 68 |
// CHECK: %[[I_IV_CVT:.*]] = fir.convert %[[I_IV]] : (index) -> i32 |
| 69 |
// CHECK: fir.store %[[I_IV_CVT]] to %[[I]] : !fir.ref<i32> |
| 70 |
// CHECK: %[[J_IV_CVT:.*]] = fir.convert %[[J_IV]] : (index) -> i32 |
| 71 |
// CHECK: fir.store %[[J_IV_CVT]] to %[[J]] : !fir.ref<i32> |
| 72 |
// CHECK: } |
| 73 |
// CHECK: } |
| 74 |
|
| 75 |
// CHECK: return |
| 76 |
// CHECK: } |
| 77 |
|
| 78 |
// ----- |
| 79 |
|
| 80 |
func.func @dc_2d_reduction(%i_lb: index, %i_ub: index, %i_st: index, |
| 81 |
%j_lb: index, %j_ub: index, %j_st: index) { |
| 82 |
%sum = fir.alloca i32 |
| 83 |
|
| 84 |
fir.do_concurrent { |
| 85 |
%i = fir.alloca i32 |
| 86 |
%j = fir.alloca i32 |
| 87 |
fir.do_concurrent.loop |
| 88 |
(%i_iv, %j_iv) = (%i_lb, %j_lb) to (%i_ub, %j_ub) step (%i_st, %j_st) |
| 89 |
reduce(@add_reduction_i32 #fir.reduce_attr<add> %sum -> %sum_arg : !fir.ref<i32>) { |
| 90 |
%0 = fir.convert %i_iv : (index) -> i32 |
| 91 |
fir.store %0 to %i : !fir.ref<i32> |
| 92 |
|
| 93 |
%1 = fir.convert %j_iv : (index) -> i32 |
| 94 |
fir.store %1 to %j : !fir.ref<i32> |
| 95 |
} |
| 96 |
} |
| 97 |
return |
| 98 |
} |
| 99 |
|
| 100 |
// CHECK-LABEL: func.func @dc_2d_reduction( |
| 101 |
// CHECK-SAME: %[[I_LB:[^[:space:]]+]]: index, |
| 102 |
// CHECK-SAME: %[[I_UB:[^[:space:]]+]]: index, |
| 103 |
// CHECK-SAME: %[[I_ST:[^[:space:]]+]]: index, |
| 104 |
// CHECK-SAME: %[[J_LB:[^[:space:]]+]]: index, |
| 105 |
// CHECK-SAME: %[[J_UB:[^[:space:]]+]]: index, |
| 106 |
// CHECK-SAME: %[[J_ST:[^[:space:]]+]]: index) { |
| 107 |
|
| 108 |
// CHECK: %[[I:.*]] = fir.alloca i32 |
| 109 |
// CHECK: %[[J:.*]] = fir.alloca i32 |
| 110 |
// CHECK: %[[SUM:.*]] = fir.alloca i32 |
| 111 |
|
| 112 |
// CHECK: fir.do_loop %[[I_IV:.*]] = %[[I_LB]] to %[[I_UB]] step %[[I_ST]] unordered reduce({{.*}}<add>] -> %[[SUM]] : !fir.ref<i32>) { |
| 113 |
// CHECK: fir.do_loop %[[J_IV:.*]] = %[[J_LB]] to %[[J_UB]] step %[[J_ST]] unordered reduce({{.*}}<add>] -> %[[SUM]] : !fir.ref<i32>) { |
| 114 |
// CHECK: %[[I_IV_CVT:.*]] = fir.convert %[[I_IV]] : (index) -> i32 |
| 115 |
// CHECK: fir.store %[[I_IV_CVT]] to %[[I]] : !fir.ref<i32> |
| 116 |
// CHECK: %[[J_IV_CVT:.*]] = fir.convert %[[J_IV]] : (index) -> i32 |
| 117 |
// CHECK: fir.store %[[J_IV_CVT]] to %[[J]] : !fir.ref<i32> |
| 118 |
// CHECK: fir.result |
| 119 |
// CHECK: } |
| 120 |
// CHECK: fir.result |
| 121 |
// CHECK: } |
| 122 |
// CHECK: return |
| 123 |
// CHECK: } |
| 124 |
|
| 125 |
// ----- |
| 126 |
|
| 127 |
fir.local {type = local} @local_localizer : i32 |
| 128 |
|
| 129 |
fir.local {type = local_init} @local_init_localizer : i32 copy { |
| 130 |
^bb0(%arg0: !fir.ref<i32>, %arg1: !fir.ref<i32>): |
| 131 |
%0 = fir.load %arg0 : !fir.ref<i32> |
| 132 |
fir.store %0 to %arg1 : !fir.ref<i32> |
| 133 |
fir.yield(%arg1 : !fir.ref<i32>) |
| 134 |
} |
| 135 |
|
| 136 |
func.func @do_concurrent_locality_specs() { |
| 137 |
%3 = fir.alloca i32 {bindc_name = "local_init_var", uniq_name = "_QFdo_concurrentElocal_init_var"} |
| 138 |
%4:2 = hlfir.declare %3 {uniq_name = "_QFdo_concurrentElocal_init_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>) |
| 139 |
%5 = fir.alloca i32 {bindc_name = "local_var", uniq_name = "_QFdo_concurrentElocal_var"} |
| 140 |
%6:2 = hlfir.declare %5 {uniq_name = "_QFdo_concurrentElocal_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>) |
| 141 |
%c1 = arith.constant 1 : index |
| 142 |
%c10 = arith.constant 1 : index |
| 143 |
fir.do_concurrent { |
| 144 |
%9 = fir.alloca i32 {bindc_name = "i"} |
| 145 |
%10:2 = hlfir.declare %9 {uniq_name = "_QFdo_concurrentEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>) |
| 146 |
fir.do_concurrent.loop (%arg0) = (%c1) to (%c10) step (%c1) local(@local_localizer %6#0 -> %arg1, @local_init_localizer %4#0 -> %arg2 : !fir.ref<i32>, !fir.ref<i32>) { |
| 147 |
%11 = fir.convert %arg0 : (index) -> i32 |
| 148 |
fir.store %11 to %10#0 : !fir.ref<i32> |
| 149 |
%13:2 = hlfir.declare %arg1 {uniq_name = "_QFdo_concurrentElocal_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>) |
| 150 |
%15:2 = hlfir.declare %arg2 {uniq_name = "_QFdo_concurrentElocal_init_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>) |
| 151 |
%17 = fir.load %10#0 : !fir.ref<i32> |
| 152 |
%c5_i32 = arith.constant 5 : i32 |
| 153 |
%18 = arith.cmpi slt, %17, %c5_i32 : i32 |
| 154 |
fir.if %18 { |
| 155 |
%c42_i32 = arith.constant 42 : i32 |
| 156 |
hlfir.assign %c42_i32 to %13#0 : i32, !fir.ref<i32> |
| 157 |
} else { |
| 158 |
%c84_i32 = arith.constant 84 : i32 |
| 159 |
hlfir.assign %c84_i32 to %15#0 : i32, !fir.ref<i32> |
| 160 |
} |
| 161 |
} |
| 162 |
} |
| 163 |
return |
| 164 |
} |
| 165 |
|
| 166 |
// CHECK-LABEL: func.func @do_concurrent_locality_specs() { |
| 167 |
// CHECK: %[[LOC_INIT_DECL:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "{{.*}}Elocal_init_var"} |
| 168 |
// CHECK: fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered { |
| 169 |
// Verify localization of the `local` var. |
| 170 |
// CHECK: %[[PRIV_LOC_ALLOC:.*]] = fir.alloca i32 |
| 171 |
|
| 172 |
// Verify localization of the `local_init` var. |
| 173 |
// CHECK: %[[PRIV_LOC_INIT_ALLOC:.*]] = fir.alloca i32 |
| 174 |
// CHECK: %[[LOC_INIT_VAL:.*]] = fir.load %[[LOC_INIT_DECL]]#0 : !fir.ref<i32> |
| 175 |
// CHECK: fir.store %[[LOC_INIT_VAL]] to %[[PRIV_LOC_INIT_ALLOC]] : !fir.ref<i32> |
| 176 |
|
| 177 |
// CHECK: %[[VAL_15:.*]]:2 = hlfir.declare %[[PRIV_LOC_ALLOC]] |
| 178 |
// CHECK: %[[VAL_16:.*]]:2 = hlfir.declare %[[PRIV_LOC_INIT_ALLOC]] |
| 179 |
|
| 180 |
// CHECK: hlfir.assign %{{.*}} to %[[VAL_15]]#0 : i32, !fir.ref<i32> |
| 181 |
// CHECK: hlfir.assign %{{.*}} to %[[VAL_16]]#0 : i32, !fir.ref<i32> |
| 182 |
// CHECK: } |
| 183 |
// CHECK: return |
| 184 |
// CHECK: } |