| 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_deviceptr, ACCC_attach, ACCC_async, ACCC_collapse, |
| 268 |
ACCC_default, ACCC_gang, ACCC_if, ACCC_num_gangs, |
| 269 |
ACCC_num_workers, ACCC_reduction, 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_collapse, |
| 275 |
ACCC_gang, ACCC_reduction, ACCC_tile, ACCC_vector, |
| 276 |
ACCC_worker, ACCC_auto, ACCC_independent, ACCC_seq}); |
| 277 |
|
| 278 |
expectAllowedClauses(ACCD_parallel, 3, |
| 279 |
{ACCC_async, ACCC_wait, ACCC_num_gangs, |
| 280 |
ACCC_num_workers, ACCC_vector_length, ACCC_device_type, |
| 281 |
ACCC_if, ACCC_self, ACCC_reduction, |
| 282 |
ACCC_copy, ACCC_copyin, ACCC_copyout, |
| 283 |
ACCC_create, ACCC_no_create, ACCC_present, |
| 284 |
ACCC_deviceptr, ACCC_attach, ACCC_private, |
| 285 |
ACCC_firstprivate, ACCC_default}); |
| 286 |
|
| 287 |
expectAllowedClauses( |
| 288 |
ACCD_parallel_loop, 3, |
| 289 |
{ACCC_attach, ACCC_copy, ACCC_copyin, ACCC_copyout, |
| 290 |
ACCC_create, ACCC_deviceptr, ACCC_device_type, ACCC_firstprivate, |
| 291 |
ACCC_no_create, ACCC_present, ACCC_private, ACCC_tile, |
| 292 |
ACCC_wait, ACCC_async, ACCC_collapse, ACCC_default, |
| 293 |
ACCC_gang, ACCC_if, ACCC_num_gangs, ACCC_num_workers, |
| 294 |
ACCC_reduction, ACCC_self, ACCC_vector, ACCC_vector_length, |
| 295 |
ACCC_worker, ACCC_auto, ACCC_independent, ACCC_seq}); |
| 296 |
|
| 297 |
expectAllowedClauses(ACCD_routine, 3, |
| 298 |
{ACCC_bind, ACCC_device_type, ACCC_nohost, ACCC_gang, |
| 299 |
ACCC_seq, ACCC_vector, ACCC_worker}); |
| 300 |
|
| 301 |
expectAllowedClauses(ACCD_serial, 3, |
| 302 |
{ACCC_attach, ACCC_copy, ACCC_copyin, ACCC_copyout, |
| 303 |
ACCC_create, ACCC_deviceptr, ACCC_device_type, |
| 304 |
ACCC_firstprivate, ACCC_no_create, ACCC_present, |
| 305 |
ACCC_private, ACCC_wait, ACCC_async, ACCC_default, |
| 306 |
ACCC_if, ACCC_reduction, ACCC_self}); |
| 307 |
|
| 308 |
expectAllowedClauses( |
| 309 |
ACCD_serial_loop, 3, |
| 310 |
{ACCC_attach, ACCC_copy, ACCC_copyin, ACCC_copyout, |
| 311 |
ACCC_create, ACCC_deviceptr, ACCC_device_type, ACCC_firstprivate, |
| 312 |
ACCC_no_create, ACCC_present, ACCC_private, ACCC_wait, |
| 313 |
ACCC_async, ACCC_collapse, ACCC_default, ACCC_gang, |
| 314 |
ACCC_if, ACCC_reduction, ACCC_self, ACCC_tile, |
| 315 |
ACCC_vector, ACCC_worker, ACCC_auto, ACCC_independent, |
| 316 |
ACCC_seq}); |
| 317 |
|
| 318 |
expectAllowedClauses( |
| 319 |
ACCD_set, 3, |
| 320 |
{ACCC_default_async, ACCC_device_num, ACCC_device_type, ACCC_if}); |
| 321 |
|
| 322 |
expectAllowedClauses(ACCD_shutdown, 3, |
| 323 |
{ACCC_device_num, ACCC_device_type, ACCC_if}); |
| 324 |
|
| 325 |
expectAllowedClauses(ACCD_update, 3, |
| 326 |
{ACCC_async, ACCC_wait, ACCC_device_type, ACCC_if, |
| 327 |
ACCC_if_present, ACCC_self, ACCC_host, ACCC_device}); |
| 328 |
|
| 329 |
expectAllowedClauses(ACCD_wait, 3, {ACCC_async, ACCC_if}); |
| 330 |
} |
| 331 |
|
| 332 |
} // namespace |