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
15using namespace llvm;
16using namespace acc;
17
18namespace {
19
20static 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
67TEST(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
115TEST(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
211static 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
226TEST(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

source code of llvm/unittests/Frontend/OpenACCTest.cpp