llvm/unittests/Frontend/OpenACCTest.cpp

   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