1 | //===- llvm/unittest/Frontend/OpenACCTest.cpp - OpenACC Frontend tests ----===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "llvm/ADT/ArrayRef.h" |
10 | #include "llvm/ADT/SmallSet.h" |
11 | #include "llvm/ADT/SmallVector.h" |
12 | #include "llvm/Frontend/OpenACC/ACC.h.inc" |
13 | #include "gtest/gtest.h" |
14 | |
15 | using namespace llvm; |
16 | using namespace acc; |
17 | |
18 | namespace { |
19 | |
20 | static const Clause AllClauses[] = {ACCC_unknown, |
21 | ACCC_async, |
22 | ACCC_attach, |
23 | ACCC_auto, |
24 | ACCC_bind, |
25 | ACCC_capture, |
26 | ACCC_collapse, |
27 | ACCC_copy, |
28 | ACCC_copyin, |
29 | ACCC_copyout, |
30 | ACCC_create, |
31 | ACCC_default, |
32 | ACCC_default_async, |
33 | ACCC_delete, |
34 | ACCC_detach, |
35 | ACCC_device, |
36 | ACCC_device_num, |
37 | ACCC_deviceptr, |
38 | ACCC_device_resident, |
39 | ACCC_device_type, |
40 | ACCC_finalize, |
41 | ACCC_firstprivate, |
42 | ACCC_gang, |
43 | ACCC_host, |
44 | ACCC_if, |
45 | ACCC_if_present, |
46 | ACCC_independent, |
47 | ACCC_link, |
48 | ACCC_no_create, |
49 | ACCC_nohost, |
50 | ACCC_num_gangs, |
51 | ACCC_num_workers, |
52 | ACCC_present, |
53 | ACCC_private, |
54 | ACCC_read, |
55 | ACCC_reduction, |
56 | ACCC_self, |
57 | ACCC_seq, |
58 | ACCC_tile, |
59 | ACCC_unknown, |
60 | ACCC_use_device, |
61 | ACCC_vector, |
62 | ACCC_vector_length, |
63 | ACCC_wait, |
64 | ACCC_worker, |
65 | ACCC_write}; |
66 | |
67 | TEST(OpenACCTest, DirectiveHelpers) { |
68 | EXPECT_EQ(getOpenACCDirectiveKind("" ), ACCD_unknown); |
69 | EXPECT_EQ(getOpenACCDirectiveKind("dummy" ), ACCD_unknown); |
70 | EXPECT_EQ(getOpenACCDirectiveKind("atomic" ), ACCD_atomic); |
71 | EXPECT_EQ(getOpenACCDirectiveKind("cache" ), ACCD_cache); |
72 | EXPECT_EQ(getOpenACCDirectiveKind("data" ), ACCD_data); |
73 | EXPECT_EQ(getOpenACCDirectiveKind("declare" ), ACCD_declare); |
74 | EXPECT_EQ(getOpenACCDirectiveKind("enter data" ), ACCD_enter_data); |
75 | EXPECT_EQ(getOpenACCDirectiveKind("exit data" ), ACCD_exit_data); |
76 | EXPECT_EQ(getOpenACCDirectiveKind("host_data" ), ACCD_host_data); |
77 | EXPECT_EQ(getOpenACCDirectiveKind("init" ), ACCD_init); |
78 | EXPECT_EQ(getOpenACCDirectiveKind("kernels" ), ACCD_kernels); |
79 | EXPECT_EQ(getOpenACCDirectiveKind("kernels loop" ), ACCD_kernels_loop); |
80 | EXPECT_EQ(getOpenACCDirectiveKind("loop" ), ACCD_loop); |
81 | EXPECT_EQ(getOpenACCDirectiveKind("parallel" ), ACCD_parallel); |
82 | EXPECT_EQ(getOpenACCDirectiveKind("parallel loop" ), ACCD_parallel_loop); |
83 | EXPECT_EQ(getOpenACCDirectiveKind("routine" ), ACCD_routine); |
84 | EXPECT_EQ(getOpenACCDirectiveKind("serial" ), ACCD_serial); |
85 | EXPECT_EQ(getOpenACCDirectiveKind("serial loop" ), ACCD_serial_loop); |
86 | EXPECT_EQ(getOpenACCDirectiveKind("set" ), ACCD_set); |
87 | EXPECT_EQ(getOpenACCDirectiveKind("shutdown" ), ACCD_shutdown); |
88 | EXPECT_EQ(getOpenACCDirectiveKind("unknown" ), ACCD_unknown); |
89 | EXPECT_EQ(getOpenACCDirectiveKind("update" ), ACCD_update); |
90 | EXPECT_EQ(getOpenACCDirectiveKind("wait" ), ACCD_wait); |
91 | |
92 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_atomic), "atomic" ); |
93 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_cache), "cache" ); |
94 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_data), "data" ); |
95 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_declare), "declare" ); |
96 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_enter_data), "enter data" ); |
97 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_exit_data), "exit data" ); |
98 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_host_data), "host_data" ); |
99 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_init), "init" ); |
100 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_kernels), "kernels" ); |
101 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_kernels_loop), "kernels loop" ); |
102 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_loop), "loop" ); |
103 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_parallel), "parallel" ); |
104 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_parallel_loop), "parallel loop" ); |
105 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_routine), "routine" ); |
106 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_serial), "serial" ); |
107 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_serial_loop), "serial loop" ); |
108 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_set), "set" ); |
109 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_shutdown), "shutdown" ); |
110 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_unknown), "unknown" ); |
111 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_update), "update" ); |
112 | EXPECT_EQ(getOpenACCDirectiveName(ACCD_wait), "wait" ); |
113 | } |
114 | |
115 | TEST(OpenACCTest, ClauseHelpers) { |
116 | EXPECT_EQ(getOpenACCClauseKind("" ), ACCC_unknown); |
117 | EXPECT_EQ(getOpenACCClauseKind("dummy" ), ACCC_unknown); |
118 | EXPECT_EQ(getOpenACCClauseKind("async" ), ACCC_async); |
119 | EXPECT_EQ(getOpenACCClauseKind("attach" ), ACCC_attach); |
120 | EXPECT_EQ(getOpenACCClauseKind("auto" ), ACCC_auto); |
121 | EXPECT_EQ(getOpenACCClauseKind("bind" ), ACCC_bind); |
122 | EXPECT_EQ(getOpenACCClauseKind("capture" ), ACCC_capture); |
123 | EXPECT_EQ(getOpenACCClauseKind("collapse" ), ACCC_collapse); |
124 | EXPECT_EQ(getOpenACCClauseKind("copy" ), ACCC_copy); |
125 | EXPECT_EQ(getOpenACCClauseKind("copyin" ), ACCC_copyin); |
126 | EXPECT_EQ(getOpenACCClauseKind("copyout" ), ACCC_copyout); |
127 | EXPECT_EQ(getOpenACCClauseKind("create" ), ACCC_create); |
128 | EXPECT_EQ(getOpenACCClauseKind("default" ), ACCC_default); |
129 | EXPECT_EQ(getOpenACCClauseKind("default_async" ), ACCC_default_async); |
130 | EXPECT_EQ(getOpenACCClauseKind("delete" ), ACCC_delete); |
131 | EXPECT_EQ(getOpenACCClauseKind("detach" ), ACCC_detach); |
132 | EXPECT_EQ(getOpenACCClauseKind("device" ), ACCC_device); |
133 | EXPECT_EQ(getOpenACCClauseKind("device_num" ), ACCC_device_num); |
134 | EXPECT_EQ(getOpenACCClauseKind("deviceptr" ), ACCC_deviceptr); |
135 | EXPECT_EQ(getOpenACCClauseKind("device_resident" ), ACCC_device_resident); |
136 | EXPECT_EQ(getOpenACCClauseKind("device_type" ), ACCC_device_type); |
137 | EXPECT_EQ(getOpenACCClauseKind("finalize" ), ACCC_finalize); |
138 | EXPECT_EQ(getOpenACCClauseKind("firstprivate" ), ACCC_firstprivate); |
139 | EXPECT_EQ(getOpenACCClauseKind("gang" ), ACCC_gang); |
140 | EXPECT_EQ(getOpenACCClauseKind("host" ), ACCC_host); |
141 | EXPECT_EQ(getOpenACCClauseKind("if" ), ACCC_if); |
142 | EXPECT_EQ(getOpenACCClauseKind("if_present" ), ACCC_if_present); |
143 | EXPECT_EQ(getOpenACCClauseKind("independent" ), ACCC_independent); |
144 | EXPECT_EQ(getOpenACCClauseKind("link" ), ACCC_link); |
145 | EXPECT_EQ(getOpenACCClauseKind("no_create" ), ACCC_no_create); |
146 | EXPECT_EQ(getOpenACCClauseKind("nohost" ), ACCC_nohost); |
147 | EXPECT_EQ(getOpenACCClauseKind("num_gangs" ), ACCC_num_gangs); |
148 | EXPECT_EQ(getOpenACCClauseKind("num_workers" ), ACCC_num_workers); |
149 | EXPECT_EQ(getOpenACCClauseKind("present" ), ACCC_present); |
150 | EXPECT_EQ(getOpenACCClauseKind("private" ), ACCC_private); |
151 | EXPECT_EQ(getOpenACCClauseKind("read" ), ACCC_read); |
152 | EXPECT_EQ(getOpenACCClauseKind("reduction" ), ACCC_reduction); |
153 | EXPECT_EQ(getOpenACCClauseKind("self" ), ACCC_self); |
154 | EXPECT_EQ(getOpenACCClauseKind("seq" ), ACCC_seq); |
155 | EXPECT_EQ(getOpenACCClauseKind("tile" ), ACCC_tile); |
156 | EXPECT_EQ(getOpenACCClauseKind("unknown" ), ACCC_unknown); |
157 | EXPECT_EQ(getOpenACCClauseKind("use_device" ), ACCC_use_device); |
158 | EXPECT_EQ(getOpenACCClauseKind("vector" ), ACCC_vector); |
159 | EXPECT_EQ(getOpenACCClauseKind("vector_length" ), ACCC_vector_length); |
160 | EXPECT_EQ(getOpenACCClauseKind("wait" ), ACCC_wait); |
161 | EXPECT_EQ(getOpenACCClauseKind("worker" ), ACCC_worker); |
162 | EXPECT_EQ(getOpenACCClauseKind("write" ), ACCC_write); |
163 | |
164 | EXPECT_EQ(getOpenACCClauseName(ACCC_async), "async" ); |
165 | EXPECT_EQ(getOpenACCClauseName(ACCC_attach), "attach" ); |
166 | EXPECT_EQ(getOpenACCClauseName(ACCC_auto), "auto" ); |
167 | EXPECT_EQ(getOpenACCClauseName(ACCC_bind), "bind" ); |
168 | EXPECT_EQ(getOpenACCClauseName(ACCC_capture), "capture" ); |
169 | EXPECT_EQ(getOpenACCClauseName(ACCC_collapse), "collapse" ); |
170 | EXPECT_EQ(getOpenACCClauseName(ACCC_copy), "copy" ); |
171 | EXPECT_EQ(getOpenACCClauseName(ACCC_copyin), "copyin" ); |
172 | EXPECT_EQ(getOpenACCClauseName(ACCC_copyout), "copyout" ); |
173 | EXPECT_EQ(getOpenACCClauseName(ACCC_create), "create" ); |
174 | EXPECT_EQ(getOpenACCClauseName(ACCC_default), "default" ); |
175 | EXPECT_EQ(getOpenACCClauseName(ACCC_default_async), "default_async" ); |
176 | EXPECT_EQ(getOpenACCClauseName(ACCC_delete), "delete" ); |
177 | EXPECT_EQ(getOpenACCClauseName(ACCC_detach), "detach" ); |
178 | EXPECT_EQ(getOpenACCClauseName(ACCC_device), "device" ); |
179 | EXPECT_EQ(getOpenACCClauseName(ACCC_device_num), "device_num" ); |
180 | EXPECT_EQ(getOpenACCClauseName(ACCC_deviceptr), "deviceptr" ); |
181 | EXPECT_EQ(getOpenACCClauseName(ACCC_device_resident), "device_resident" ); |
182 | EXPECT_EQ(getOpenACCClauseName(ACCC_device_type), "device_type" ); |
183 | EXPECT_EQ(getOpenACCClauseName(ACCC_finalize), "finalize" ); |
184 | EXPECT_EQ(getOpenACCClauseName(ACCC_firstprivate), "firstprivate" ); |
185 | EXPECT_EQ(getOpenACCClauseName(ACCC_gang), "gang" ); |
186 | EXPECT_EQ(getOpenACCClauseName(ACCC_host), "host" ); |
187 | EXPECT_EQ(getOpenACCClauseName(ACCC_if), "if" ); |
188 | EXPECT_EQ(getOpenACCClauseName(ACCC_if_present), "if_present" ); |
189 | EXPECT_EQ(getOpenACCClauseName(ACCC_independent), "independent" ); |
190 | EXPECT_EQ(getOpenACCClauseName(ACCC_link), "link" ); |
191 | EXPECT_EQ(getOpenACCClauseName(ACCC_no_create), "no_create" ); |
192 | EXPECT_EQ(getOpenACCClauseName(ACCC_nohost), "nohost" ); |
193 | EXPECT_EQ(getOpenACCClauseName(ACCC_num_gangs), "num_gangs" ); |
194 | EXPECT_EQ(getOpenACCClauseName(ACCC_num_workers), "num_workers" ); |
195 | EXPECT_EQ(getOpenACCClauseName(ACCC_present), "present" ); |
196 | EXPECT_EQ(getOpenACCClauseName(ACCC_private), "private" ); |
197 | EXPECT_EQ(getOpenACCClauseName(ACCC_read), "read" ); |
198 | EXPECT_EQ(getOpenACCClauseName(ACCC_reduction), "reduction" ); |
199 | EXPECT_EQ(getOpenACCClauseName(ACCC_self), "self" ); |
200 | EXPECT_EQ(getOpenACCClauseName(ACCC_seq), "seq" ); |
201 | EXPECT_EQ(getOpenACCClauseName(ACCC_tile), "tile" ); |
202 | EXPECT_EQ(getOpenACCClauseName(ACCC_unknown), "unknown" ); |
203 | EXPECT_EQ(getOpenACCClauseName(ACCC_use_device), "use_device" ); |
204 | EXPECT_EQ(getOpenACCClauseName(ACCC_vector), "vector" ); |
205 | EXPECT_EQ(getOpenACCClauseName(ACCC_vector_length), "vector_length" ); |
206 | EXPECT_EQ(getOpenACCClauseName(ACCC_wait), "wait" ); |
207 | EXPECT_EQ(getOpenACCClauseName(ACCC_worker), "worker" ); |
208 | EXPECT_EQ(getOpenACCClauseName(ACCC_write), "write" ); |
209 | } |
210 | |
211 | static void expectAllowedClauses(Directive Dir, unsigned Version, |
212 | const ArrayRef<Clause> &AllowedClauses) { |
213 | SmallSet<Clause, 30> AllowedClausesSet; |
214 | for (Clause Cl : AllowedClauses) { |
215 | EXPECT_TRUE(isAllowedClauseForDirective(Dir, Cl, Version)); |
216 | AllowedClausesSet.insert(Cl); |
217 | } |
218 | |
219 | for (Clause Cl : AllClauses) { |
220 | if (!AllowedClausesSet.contains(Cl)) { |
221 | EXPECT_FALSE(isAllowedClauseForDirective(Dir, Cl, Version)); |
222 | } |
223 | } |
224 | } |
225 | |
226 | TEST(OpenACCTest, AllowedClause) { |
227 | expectAllowedClauses(ACCD_atomic, 3, {}); |
228 | expectAllowedClauses(ACCD_cache, 3, {}); |
229 | expectAllowedClauses(ACCD_unknown, 3, {}); |
230 | expectAllowedClauses(ACCD_parallel, 0, {}); // Version starts at 1 |
231 | |
232 | expectAllowedClauses(ACCD_data, 3, |
233 | {ACCC_if, ACCC_attach, ACCC_copy, ACCC_copyin, |
234 | ACCC_copyout, ACCC_create, ACCC_default, ACCC_deviceptr, |
235 | ACCC_no_create, ACCC_present}); |
236 | |
237 | expectAllowedClauses(ACCD_declare, 3, |
238 | {ACCC_copy, ACCC_copyin, ACCC_copyout, ACCC_create, |
239 | ACCC_present, ACCC_deviceptr, ACCC_device_resident, |
240 | ACCC_link}); |
241 | |
242 | expectAllowedClauses( |
243 | ACCD_enter_data, 3, |
244 | {ACCC_async, ACCC_if, ACCC_wait, ACCC_attach, ACCC_create, ACCC_copyin}); |
245 | |
246 | expectAllowedClauses(ACCD_exit_data, 3, |
247 | {ACCC_async, ACCC_if, ACCC_wait, ACCC_finalize, |
248 | ACCC_copyout, ACCC_delete, ACCC_detach}); |
249 | |
250 | expectAllowedClauses(ACCD_host_data, 3, |
251 | {ACCC_if, ACCC_if_present, ACCC_use_device}); |
252 | |
253 | expectAllowedClauses(ACCD_init, 3, |
254 | {ACCC_device_num, ACCC_device_type, ACCC_if}); |
255 | |
256 | expectAllowedClauses(ACCD_kernels, 3, |
257 | {ACCC_attach, ACCC_copy, ACCC_copyin, ACCC_copyout, |
258 | ACCC_create, ACCC_device_type, ACCC_no_create, |
259 | ACCC_present, ACCC_deviceptr, ACCC_async, ACCC_default, |
260 | ACCC_if, ACCC_num_gangs, ACCC_num_workers, ACCC_self, |
261 | ACCC_vector_length, ACCC_wait}); |
262 | |
263 | expectAllowedClauses( |
264 | ACCD_kernels_loop, 3, |
265 | {ACCC_copy, ACCC_copyin, ACCC_copyout, ACCC_create, |
266 | ACCC_device_type, ACCC_no_create, ACCC_present, ACCC_private, |
267 | ACCC_reduction, ACCC_deviceptr, ACCC_attach, ACCC_async, |
268 | ACCC_collapse, ACCC_default, ACCC_gang, ACCC_if, |
269 | ACCC_num_gangs, ACCC_num_workers, ACCC_self, ACCC_tile, |
270 | ACCC_vector, ACCC_vector_length, ACCC_wait, ACCC_worker, |
271 | ACCC_auto, ACCC_independent, ACCC_seq}); |
272 | |
273 | expectAllowedClauses(ACCD_loop, 3, |
274 | {ACCC_device_type, ACCC_private, ACCC_reduction, |
275 | ACCC_collapse, ACCC_gang, ACCC_tile, ACCC_vector, |
276 | ACCC_worker, ACCC_auto, ACCC_independent, ACCC_seq}); |
277 | |
278 | expectAllowedClauses( |
279 | ACCD_parallel, 3, |
280 | {ACCC_async, ACCC_wait, ACCC_num_gangs, ACCC_num_workers, |
281 | ACCC_vector_length, ACCC_device_type, ACCC_if, ACCC_self, |
282 | ACCC_copy, ACCC_copyin, ACCC_copyout, ACCC_create, |
283 | ACCC_no_create, ACCC_present, ACCC_deviceptr, ACCC_attach, |
284 | ACCC_private, ACCC_firstprivate, ACCC_reduction, ACCC_default}); |
285 | |
286 | expectAllowedClauses( |
287 | ACCD_parallel_loop, 3, |
288 | {ACCC_attach, ACCC_copy, ACCC_copyin, ACCC_copyout, |
289 | ACCC_create, ACCC_deviceptr, ACCC_device_type, ACCC_firstprivate, |
290 | ACCC_no_create, ACCC_present, ACCC_private, ACCC_reduction, |
291 | ACCC_tile, ACCC_wait, ACCC_async, ACCC_collapse, |
292 | ACCC_default, ACCC_gang, ACCC_if, ACCC_num_gangs, |
293 | ACCC_num_workers, ACCC_self, ACCC_vector, ACCC_vector_length, |
294 | ACCC_worker, ACCC_auto, ACCC_independent, ACCC_seq}); |
295 | |
296 | expectAllowedClauses(ACCD_routine, 3, |
297 | {ACCC_bind, ACCC_device_type, ACCC_nohost, ACCC_gang, |
298 | ACCC_seq, ACCC_vector, ACCC_worker}); |
299 | |
300 | expectAllowedClauses(ACCD_serial, 3, |
301 | {ACCC_attach, ACCC_copy, ACCC_copyin, ACCC_copyout, |
302 | ACCC_create, ACCC_deviceptr, ACCC_device_type, |
303 | ACCC_no_create, ACCC_present, ACCC_private, |
304 | ACCC_firstprivate, ACCC_reduction, ACCC_wait, |
305 | ACCC_async, ACCC_default, ACCC_if, ACCC_self}); |
306 | |
307 | expectAllowedClauses( |
308 | ACCD_serial_loop, 3, |
309 | {ACCC_attach, ACCC_copy, ACCC_copyin, ACCC_copyout, |
310 | ACCC_create, ACCC_deviceptr, ACCC_device_type, ACCC_firstprivate, |
311 | ACCC_no_create, ACCC_present, ACCC_private, ACCC_reduction, |
312 | ACCC_wait, ACCC_async, ACCC_collapse, ACCC_default, |
313 | ACCC_gang, ACCC_if, ACCC_self, ACCC_tile, |
314 | ACCC_vector, ACCC_worker, ACCC_auto, ACCC_independent, |
315 | ACCC_seq}); |
316 | |
317 | expectAllowedClauses( |
318 | ACCD_set, 3, |
319 | {ACCC_default_async, ACCC_device_num, ACCC_device_type, ACCC_if}); |
320 | |
321 | expectAllowedClauses(ACCD_shutdown, 3, |
322 | {ACCC_device_num, ACCC_device_type, ACCC_if}); |
323 | |
324 | expectAllowedClauses(ACCD_update, 3, |
325 | {ACCC_async, ACCC_wait, ACCC_device_type, ACCC_if, |
326 | ACCC_if_present, ACCC_self, ACCC_host, ACCC_device}); |
327 | |
328 | expectAllowedClauses(ACCD_wait, 3, {ACCC_async, ACCC_if}); |
329 | } |
330 | |
331 | } // namespace |
332 | |