Debian Codegraph @

flang/test/Fir/do_concurrent.fir

raw
1 // Test fir.do_concurrent operation parse, verify (no errors), and unparse
2
3 // RUN: fir-opt %s | fir-opt | 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:.*]]: index, %[[I_UB:.*]]: index, %[[I_ST:.*]]: index)
18 // CHECK: fir.do_concurrent {
19 // CHECK: %[[I:.*]] = fir.alloca i32
20 // CHECK: fir.do_concurrent.loop (%[[I_IV:.*]]) = (%[[I_LB]]) to (%[[I_UB]]) step (%[[I_ST]]) {
21 // CHECK: %[[I_IV_CVT:.*]] = fir.convert %[[I_IV]] : (index) -> i32
22 // CHECK: fir.store %[[I_IV_CVT]] to %[[I]] : !fir.ref<i32>
23 // CHECK: }
24 // CHECK: }
25
26 func.func @dc_2d(%i_lb: index, %i_ub: index, %i_st: index,
27 %j_lb: index, %j_ub: index, %j_st: index) {
28 fir.do_concurrent {
29 %i = fir.alloca i32
30 %j = fir.alloca i32
31 fir.do_concurrent.loop
32 (%i_iv, %j_iv) = (%i_lb, %j_lb) to (%i_ub, %j_ub) step (%i_st, %j_st) {
33 %0 = fir.convert %i_iv : (index) -> i32
34 fir.store %0 to %i : !fir.ref<i32>
35
36 %1 = fir.convert %j_iv : (index) -> i32
37 fir.store %1 to %j : !fir.ref<i32>
38 }
39 }
40 return
41 }
42
43 // CHECK-LABEL: func.func @dc_2d
44 // CHECK-SAME: (%[[I_LB:.*]]: index, %[[I_UB:.*]]: index, %[[I_ST:.*]]: index, %[[J_LB:.*]]: index, %[[J_UB:.*]]: index, %[[J_ST:.*]]: index)
45 // CHECK: fir.do_concurrent {
46 // CHECK: %[[I:.*]] = fir.alloca i32
47 // CHECK: %[[J:.*]] = fir.alloca i32
48 // CHECK: fir.do_concurrent.loop
49 // CHECK-SAME: (%[[I_IV:.*]], %[[J_IV:.*]]) = (%[[I_LB]], %[[J_LB]]) to (%[[I_UB]], %[[J_UB]]) step (%[[I_ST]], %[[J_ST]]) {
50 // CHECK: %[[I_IV_CVT:.*]] = fir.convert %[[I_IV]] : (index) -> i32
51 // CHECK: fir.store %[[I_IV_CVT]] to %[[I]] : !fir.ref<i32>
52 // CHECK: %[[J_IV_CVT:.*]] = fir.convert %[[J_IV]] : (index) -> i32
53 // CHECK: fir.store %[[J_IV_CVT]] to %[[J]] : !fir.ref<i32>
54 // CHECK: }
55 // CHECK: }
56
57 func.func @dc_2d_reduction(%i_lb: index, %i_ub: index, %i_st: index,
58 %j_lb: index, %j_ub: index, %j_st: index) {
59 %sum = fir.alloca i32
60
61 fir.do_concurrent {
62 %i = fir.alloca i32
63 %j = fir.alloca i32
64 fir.do_concurrent.loop
65 (%i_iv, %j_iv) = (%i_lb, %j_lb) to (%i_ub, %j_ub) step (%i_st, %j_st)
66 reduce(@add_reduction_i32 #fir.reduce_attr<add> %sum -> %sum_arg : !fir.ref<i32>) {
67 %0 = fir.convert %i_iv : (index) -> i32
68 fir.store %0 to %i : !fir.ref<i32>
69
70 %1 = fir.convert %j_iv : (index) -> i32
71 fir.store %1 to %j : !fir.ref<i32>
72 }
73 }
74 return
75 }
76
77 // CHECK-LABEL: func.func @dc_2d_reduction
78 // CHECK-SAME: (%[[I_LB:.*]]: index, %[[I_UB:.*]]: index, %[[I_ST:.*]]: index, %[[J_LB:.*]]: index, %[[J_UB:.*]]: index, %[[J_ST:.*]]: index)
79
80 // CHECK: %[[SUM:.*]] = fir.alloca i32
81
82 // CHECK: fir.do_concurrent {
83 // CHECK: %[[I:.*]] = fir.alloca i32
84 // CHECK: %[[J:.*]] = fir.alloca i32
85 // CHECK: fir.do_concurrent.loop
86 // CHECK-SAME: (%[[I_IV:.*]], %[[J_IV:.*]]) = (%[[I_LB]], %[[J_LB]]) to (%[[I_UB]], %[[J_UB]]) step (%[[I_ST]], %[[J_ST]]) reduce(@add_reduction_i32 #fir.reduce_attr<add> %[[SUM]] -> %{{.*}} : !fir.ref<i32>) {
87 // CHECK: %[[I_IV_CVT:.*]] = fir.convert %[[I_IV]] : (index) -> i32
88 // CHECK: fir.store %[[I_IV_CVT]] to %[[I]] : !fir.ref<i32>
89 // CHECK: %[[J_IV_CVT:.*]] = fir.convert %[[J_IV]] : (index) -> i32
90 // CHECK: fir.store %[[J_IV_CVT]] to %[[J]] : !fir.ref<i32>
91 // CHECK: }
92 // CHECK: }
93
94 fir.local {type = local} @local_privatizer : i32
95
96 // CHECK: fir.local {type = local} @[[LOCAL_PRIV_SYM:local_privatizer]] : i32
97
98 fir.local {type = local_init} @local_init_privatizer : i32 copy {
99 ^bb0(%arg0: !fir.ref<i32>, %arg1: !fir.ref<i32>):
100 %0 = fir.load %arg0 : !fir.ref<i32>
101 fir.store %0 to %arg1 : !fir.ref<i32>
102 fir.yield(%arg1 : !fir.ref<i32>)
103 }
104
105 // CHECK: fir.local {type = local_init} @[[LOCAL_INIT_PRIV_SYM:local_init_privatizer]] : i32
106 // CHECK: ^bb0(%[[ORIG_VAL:.*]]: !fir.ref<i32>, %[[LOCAL_VAL:.*]]: !fir.ref<i32>):
107 // CHECK: %[[ORIG_VAL_LD:.*]] = fir.load %[[ORIG_VAL]]
108 // CHECK: fir.store %[[ORIG_VAL_LD]] to %[[LOCAL_VAL]] : !fir.ref<i32>
109 // CHECK: fir.yield(%[[LOCAL_VAL]] : !fir.ref<i32>)
110 // CHECK: }
111
112 func.func @do_concurrent_with_locality_specs() {
113 %3 = fir.alloca i32 {bindc_name = "local_init_var"}
114 %4:2 = hlfir.declare %3 {uniq_name = "_QFdo_concurrentElocal_init_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
115 %5 = fir.alloca i32 {bindc_name = "local_var"}
116 %6:2 = hlfir.declare %5 {uniq_name = "_QFdo_concurrentElocal_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
117 %c1 = arith.constant 1 : index
118 %c10 = arith.constant 10 : index
119
120 fir.do_concurrent {
121 %9 = fir.alloca i32 {bindc_name = "i"}
122 %10:2 = hlfir.declare %9 {uniq_name = "_QFdo_concurrentEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
123
124 fir.do_concurrent.loop (%arg0) = (%c1) to (%c10) step (%c1)
125 local(@local_privatizer %6#0 -> %arg1, @local_init_privatizer %4#0 -> %arg2 : !fir.ref<i32>, !fir.ref<i32>) {
126 %11 = fir.convert %arg0 : (index) -> i32
127 fir.store %11 to %10#0 : !fir.ref<i32>
128 %13:2 = hlfir.declare %arg1 {uniq_name = "_QFdo_concurrentElocal_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
129 %15:2 = hlfir.declare %arg2 {uniq_name = "_QFdo_concurrentElocal_init_var"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
130 }
131 }
132 return
133 }
134
135 // CHECK-LABEL: func.func @do_concurrent_with_locality_specs() {
136 // CHECK: %[[LOC_INIT_ALLOC:.*]] = fir.alloca i32 {bindc_name = "local_init_var"}
137 // CHECK: %[[LOC_INIT_DECL:.*]]:2 = hlfir.declare %[[LOC_INIT_ALLOC]]
138
139 // CHECK: %[[LOC_ALLOC:.*]] = fir.alloca i32 {bindc_name = "local_var"}
140 // CHECK: %[[LOC_DECL:.*]]:2 = hlfir.declare %[[LOC_ALLOC]]
141
142 // CHECK: %[[C1:.*]] = arith.constant 1 : index
143 // CHECK: %[[C10:.*]] = arith.constant 10 : index
144
145 // CHECK: fir.do_concurrent {
146 // CHECK: %[[DC_I_ALLOC:.*]] = fir.alloca i32 {bindc_name = "i"}
147 // CHECK: %[[DC_I_DECL:.*]]:2 = hlfir.declare %[[DC_I_ALLOC]]
148
149 // CHECK: fir.do_concurrent.loop (%[[IV:.*]]) = (%[[C1]]) to
150 // CHECK-SAME: (%[[C10]]) step (%[[C1]])
151 // CHECK-SAME: local(@[[LOCAL_PRIV_SYM]] %[[LOC_DECL]]#0 -> %[[LOC_ARG:[^,]*]],
152 // CHECK-SAME: @[[LOCAL_INIT_PRIV_SYM]] %[[LOC_INIT_DECL]]#0 -> %[[LOC_INIT_ARG:.*]] :
153 // CHECK-SAME: !fir.ref<i32>, !fir.ref<i32>) {
154
155 // CHECK: %[[IV_CVT:.*]] = fir.convert %[[IV]] : (index) -> i32
156 // CHECK: fir.store %[[IV_CVT]] to %[[DC_I_DECL]]#0 : !fir.ref<i32>
157
158 // CHECK: %[[LOC_PRIV_DECL:.*]]:2 = hlfir.declare %[[LOC_ARG]]
159 // CHECK: %[[LOC_INIT_PRIV_DECL:.*]]:2 = hlfir.declare %[[LOC_INIT_ARG]]
160 // CHECK: }
161 // CHECK: }
162 // CHECK: return
163 // CHECK: }
164
165 func.func @dc_reduce() {
166 %3 = fir.alloca i32 {bindc_name = "s", uniq_name = "dc_reduce"}
167 %4:2 = hlfir.declare %3 {uniq_name = "dc_reduce"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
168 %c1 = arith.constant 1 : index
169 fir.do_concurrent {
170 fir.do_concurrent.loop (%arg0) = (%c1) to (%c1) step (%c1) reduce(byref @add_reduction_i32 #fir.reduce_attr<add> %4#0 -> %arg1 : !fir.ref<i32>) {
171 }
172 }
173 return
174 }
175
176 // CHECK-LABEL: func.func @dc_reduce() {
177 // CHECK: %[[S_ALLOC:.*]] = fir.alloca i32 {bindc_name = "s", uniq_name = "dc_reduce"}
178 // CHECK: %[[S_DECL:.*]]:2 = hlfir.declare %[[S_ALLOC]] {uniq_name = "dc_reduce"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
179 // CHECK: fir.do_concurrent {
180 // CHECK: fir.do_concurrent.loop (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{.*}}) reduce(byref @add_reduction_i32 #fir.reduce_attr<add> %[[S_DECL]]#0 -> %[[S_ARG:.*]] : !fir.ref<i32>) {
181 // CHECK: }
182 // CHECK: }
183 // CHECK: return
184 // CHECK: }
185
186 func.func @dc_reduce_2() {
187 %3 = fir.alloca i32 {bindc_name = "s", uniq_name = "dc_reduce"}
188 %4:2 = hlfir.declare %3 {uniq_name = "dc_reduce"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
189
190 %5 = fir.alloca i32 {bindc_name = "m", uniq_name = "dc_reduce"}
191 %6:2 = hlfir.declare %5 {uniq_name = "dc_reduce"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
192
193 %c1 = arith.constant 1 : index
194
195 fir.do_concurrent {
196 fir.do_concurrent.loop (%arg0) = (%c1) to (%c1) step (%c1)
197 reduce(@add_reduction_i32 #fir.reduce_attr<add> %4#0 -> %arg1,
198 @mul_reduction_i32 #fir.reduce_attr<multiply> %6#0 -> %arg2
199 : !fir.ref<i32>, !fir.ref<i32>) {
200 }
201 }
202
203 return
204 }
205
206 // CHECK-LABEL: func.func @dc_reduce_2() {
207 // CHECK: %[[S_ALLOC:.*]] = fir.alloca i32 {bindc_name = "s", uniq_name = "dc_reduce"}
208 // CHECK: %[[S_DECL:.*]]:2 = hlfir.declare %[[S_ALLOC]] {uniq_name = "dc_reduce"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
209
210 // CHECK: %[[M_ALLOC:.*]] = fir.alloca i32 {bindc_name = "m", uniq_name = "dc_reduce"}
211 // CHECK: %[[M_DECL:.*]]:2 = hlfir.declare %[[M_ALLOC]] {uniq_name = "dc_reduce"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
212 // CHECK: fir.do_concurrent {
213 // CHECK: fir.do_concurrent.loop (%{{.*}}) = (%{{.*}}) to (%{{.*}}) step (%{{[^[:space:]]+}})
214 // CHECK-SAME: reduce(
215 // CHECK-SAME: @add_reduction_i32 #fir.reduce_attr<add> %[[S_DECL]]#0 -> %[[S_ARG:[^,]+]],
216 // CHECK-SAME: @mul_reduction_i32 #fir.reduce_attr<multiply> %[[M_DECL]]#0 -> %[[M_ARG:[^[:space:]]+]]
217 // CHECK-SAME: : !fir.ref<i32>, !fir.ref<i32>) {
218 // CHECK: }
219 // CHECK: }
220 // CHECK: return
221 // CHECK: }
222