openmp/tools/archer/tests/task/omp_task_depend_all.c

   1 // RUN--: %libarcher-compile-and-run | FileCheck %s --check-prefix=NOENV
   2 // RUN: %libarcher-compile && env ARCHER_OPTIONS="all_memory=1" \
   3 // RUN:   %libarcher-run | FileCheck %s --check-prefix=ENV
   4 // REQUIRES: tsan
   5
   6 // The runtime currently does not get dependency information from GCC.
   7 // UNSUPPORTED: gcc
   8
   9 // Tests OMP 5.x task dependence "omp_all_memory",
  10 // emulates compiler codegen versions for new dep kind
  11 //
  12 // Task tree created:
  13 //      task0 - task1 (in: i1, i2)
  14 //             \
  15 //        task2 (inoutset: i2), (in: i1)
  16 //             /
  17 //        task3 (omp_all_memory) via flag=0x80
  18 //             /
  19 //      task4 - task5 (in: i1, i2)
  20 //           /
  21 //       task6 (omp_all_memory) via addr=-1
  22 //           /
  23 //       task7 (omp_all_memory) via flag=0x80
  24 //           /
  25 //       task8 (in: i3)
  26 //
  27
  28 #include <omp.h>
  29 #include <stdio.h>
  30
  31 #ifdef _WIN32
  32 #include <windows.h>
  33 #define mysleep(n) Sleep(n)
  34 #else
  35 #include <unistd.h>
  36 #define mysleep(n) usleep((n)*1000)
  37 #endif
  38
  39 // to check the # of concurrent tasks (must be 1 for MTX, <3 for other kinds)
  40 static int checker = 0;
  41 static int err = 0;
  42 #ifndef DELAY
  43 #define DELAY 100
  44 #endif
  45
  46 // ---------------------------------------------------------------------------
  47 // internal data to emulate compiler codegen
  48 typedef struct DEP {
  49   size_t addr;
  50   size_t len;
  51   unsigned char flags;
  52 } dep;
  53 #define DEP_ALL_MEM 0x80
  54 typedef struct task {
  55   void **shareds;
  56   void *entry;
  57   int part_id;
  58   void *destr_thunk;
  59   int priority;
  60   long long device_id;
  61   int f_priv;
  62 } task_t;
  63 #define TIED 1
  64 typedef int (*entry_t)(int, task_t *);
  65 typedef struct ID {
  66   int reserved_1;
  67   int flags;
  68   int reserved_2;
  69   int reserved_3;
  70   char *psource;
  71 } id;
  72 // thunk routine for tasks with ALL dependency
  73 int thunk_m(int gtid, task_t *ptask) {
  74   int lcheck, th;
  75 #pragma omp atomic capture
  76   lcheck = ++checker;
  77   th = omp_get_thread_num();
  78   printf("task m_%d, th %d, checker %d\n", ptask->f_priv, th, lcheck);
  79   if (lcheck != 1) { // no more than 1 task at a time
  80     err++;
  81     printf("Error m1, checker %d != 1\n", lcheck);
  82   }
  83   mysleep(DELAY);
  84 #pragma omp atomic read
  85   lcheck = checker; // must still be equal to 1
  86   if (lcheck != 1) {
  87     err++;
  88     printf("Error m2, checker %d != 1\n", lcheck);
  89   }
  90 #pragma omp atomic
  91   --checker;
  92   return 0;
  93 }
  94 // thunk routine for tasks with inoutset dependency
  95 int thunk_s(int gtid, task_t *ptask) {
  96   int lcheck, th;
  97 #pragma omp atomic capture
  98   lcheck = ++checker; // 1
  99   th = omp_get_thread_num();
 100   printf("task 2_%d, th %d, checker %d\n", ptask->f_priv, th, lcheck);
 101   if (lcheck != 1) { // no more than 1 task at a time
 102     err++;
 103     printf("Error s1, checker %d != 1\n", lcheck);
 104   }
 105   mysleep(DELAY);
 106 #pragma omp atomic read
 107   lcheck = checker; // must still be equal to 1
 108   if (lcheck != 1) {
 109     err++;
 110     printf("Error s2, checker %d != 1\n", lcheck);
 111   }
 112 #pragma omp atomic
 113   --checker;
 114   return 0;
 115 }
 116
 117 #ifdef __cplusplus
 118 extern "C" {
 119 #endif
 120 int __kmpc_global_thread_num(id *);
 121 task_t *__kmpc_omp_task_alloc(id *loc, int gtid, int flags, size_t sz,
 122                               size_t shar, entry_t rtn);
 123 int __kmpc_omp_task_with_deps(id *loc, int gtid, task_t *task, int ndeps,
 124                               dep *dep_lst, int nd_noalias, dep *noalias_lst);
 125 static id loc = {0, 2, 0, 0, ";file;func;0;0;;"};
 126 #ifdef __cplusplus
 127 } // extern "C"
 128 #endif
 129 // End of internal data
 130 // ---------------------------------------------------------------------------
 131
 132 int main() {
 133   char *ompx_all_memory = (void *)0xffffffffffffffff;
 134   int i1, i2, i3;
 135   omp_set_num_threads(8);
 136   omp_set_dynamic(0);
 137 #pragma omp parallel
 138   {
 139 #pragma omp single nowait
 140     {
 141       dep sdep[2];
 142       task_t *ptr;
 143       int gtid = __kmpc_global_thread_num(&loc);
 144       int t = omp_get_thread_num();
 145 #pragma omp task depend(in : i1, i2)
 146       { // task 0
 147         int lcheck, th;
 148 #pragma omp atomic capture
 149         lcheck = ++checker; // 1 or 2
 150         th = omp_get_thread_num();
 151         printf("task 0_%d, th %d, checker %d\n", t, th, lcheck);
 152         if (lcheck > 2 || lcheck < 1) {
 153           err++; // no more than 2 tasks concurrently
 154           printf("Error1, checker %d, not 1 or 2\n", lcheck);
 155         }
 156         mysleep(DELAY);
 157 #pragma omp atomic read
 158         lcheck = checker; // 1 or 2
 159         if (lcheck > 2 || lcheck < 1) {
 160 #pragma omp atomic
 161           err++;
 162           printf("Error2, checker %d, not 1 or 2\n", lcheck);
 163         }
 164 #pragma omp atomic
 165         --checker;
 166       }
 167 #pragma omp task depend(in : i1, i2)
 168       { // task 1
 169         int lcheck, th;
 170 #pragma omp atomic capture
 171         lcheck = ++checker; // 1 or 2
 172         th = omp_get_thread_num();
 173         printf("task 1_%d, th %d, checker %d\n", t, th, lcheck);
 174         if (lcheck > 2 || lcheck < 1) {
 175           err++; // no more than 2 tasks concurrently
 176           printf("Error3, checker %d, not 1 or 2\n", lcheck);
 177         }
 178         mysleep(DELAY);
 179 #pragma omp atomic read
 180         lcheck = checker; // 1 or 2
 181         if (lcheck > 2 || lcheck < 1) {
 182           err++;
 183           printf("Error4, checker %d, not 1 or 2\n", lcheck);
 184         }
 185 #pragma omp atomic
 186         --checker;
 187       }
 188       // compiler codegen start
 189       // task2
 190       ptr = __kmpc_omp_task_alloc(&loc, gtid, TIED, sizeof(task_t), 0, thunk_s);
 191       sdep[0].addr = (size_t)&i1;
 192       sdep[0].len = 0;   // not used
 193       sdep[0].flags = 1; // IN
 194       sdep[1].addr = (size_t)&i2;
 195       sdep[1].len = 0;      // not used
 196       sdep[1].flags = 8;    // INOUTSET
 197       ptr->f_priv = t + 10; // init single first-private variable
 198       __kmpc_omp_task_with_deps(&loc, gtid, ptr, 2, sdep, 0, 0);
 199
 200 // task3
 201 #pragma omp task depend(in : i1) depend(inout : ompx_all_memory[0])
 202       {
 203         int lcheck, th;
 204 #pragma omp atomic capture
 205         lcheck = ++checker;
 206         th = omp_get_thread_num();
 207         printf("task 3_%d, th %d, checker %d\n", t, th, lcheck);
 208         if (lcheck != 1) { // no more than 1 task at a time
 209           err++;
 210           printf("Error m1, checker %d != 1\n", lcheck);
 211         }
 212         mysleep(DELAY);
 213 #pragma omp atomic read
 214         lcheck = checker; // must still be equal to 1
 215         if (lcheck != 1) {
 216           err++;
 217           printf("Error m2, checker %d != 1\n", lcheck);
 218         }
 219 #pragma omp atomic
 220         --checker;
 221       }
 222       // compiler codegen end
 223 #pragma omp task depend(in : i1, i2)
 224       { // task 4
 225         int lcheck, th;
 226 #pragma omp atomic capture
 227         lcheck = ++checker; // 1 or 2
 228         th = omp_get_thread_num();
 229         printf("task 4_%d, th %d, checker %d\n", t, th, lcheck);
 230         if (lcheck > 2 || lcheck < 1) {
 231           err++; // no more than 2 tasks concurrently
 232           printf("Error5, checker %d, not 1 or 2\n", lcheck);
 233         }
 234         mysleep(DELAY);
 235 #pragma omp atomic read
 236         lcheck = checker; // 1 or 2
 237         if (lcheck > 2 || lcheck < 1) {
 238           err++;
 239           printf("Error6, checker %d, not 1 or 2\n", lcheck);
 240         }
 241 #pragma omp atomic
 242         --checker;
 243       }
 244 #pragma omp task depend(in : i1, i2)
 245       { // task 5
 246         int lcheck, th;
 247 #pragma omp atomic capture
 248         lcheck = ++checker; // 1 or 2
 249         th = omp_get_thread_num();
 250         printf("task 5_%d, th %d, checker %d\n", t, th, lcheck);
 251         if (lcheck > 2 || lcheck < 1) {
 252           err++; // no more than 2 tasks concurrently
 253           printf("Error7, checker %d, not 1 or 2\n", lcheck);
 254         }
 255         mysleep(DELAY);
 256 #pragma omp atomic read
 257         lcheck = checker; // 1 or 2
 258         if (lcheck > 2 || lcheck < 1) {
 259           err++;
 260           printf("Error8, checker %d, not 1 or 2\n", lcheck);
 261         }
 262 #pragma omp atomic
 263         --checker;
 264       }
 265 // task6
 266 #pragma omp task depend(inout : ompx_all_memory[0])
 267       {
 268         int lcheck, th;
 269 #pragma omp atomic capture
 270         lcheck = ++checker;
 271         th = omp_get_thread_num();
 272         printf("task 6_%d, th %d, checker %d\n", t, th, lcheck);
 273         if (lcheck != 1) { // no more than 1 task at a time
 274           err++;
 275           printf("Error m1, checker %d != 1\n", lcheck);
 276         }
 277         mysleep(DELAY);
 278 #pragma omp atomic read
 279         lcheck = checker; // must still be equal to 1
 280         if (lcheck != 1) {
 281           err++;
 282           printf("Error m2, checker %d != 1\n", lcheck);
 283         }
 284 #pragma omp atomic
 285         --checker;
 286       }
 287 // task7
 288 #pragma omp task depend(inout : ompx_all_memory[0]) depend(mutexinoutset : i3)
 289       {
 290         int lcheck, th;
 291 #pragma omp atomic capture
 292         lcheck = ++checker;
 293         th = omp_get_thread_num();
 294         printf("task 7_%d, th %d, checker %d\n", t, th, lcheck);
 295         if (lcheck != 1) { // no more than 1 task at a time
 296           err++;
 297           printf("Error m1, checker %d != 1\n", lcheck);
 298         }
 299         mysleep(DELAY);
 300 #pragma omp atomic read
 301         lcheck = checker; // must still be equal to 1
 302         if (lcheck != 1) {
 303           err++;
 304           printf("Error m2, checker %d != 1\n", lcheck);
 305         }
 306 #pragma omp atomic
 307         --checker;
 308       }
 309 #pragma omp task depend(in : i3)
 310       { // task 8
 311         int lcheck, th;
 312 #pragma omp atomic capture
 313         lcheck = ++checker; // 1
 314         th = omp_get_thread_num();
 315         printf("task 8_%d, th %d, checker %d\n", t, th, lcheck);
 316         if (lcheck != 1) {
 317           err++;
 318           printf("Error9, checker %d, != 1\n", lcheck);
 319         }
 320         mysleep(DELAY);
 321 #pragma omp atomic read
 322         lcheck = checker;
 323         if (lcheck != 1) {
 324           err++;
 325           printf("Error10, checker %d, != 1\n", lcheck);
 326         }
 327 #pragma omp atomic
 328         --checker;
 329       }
 330     } // single
 331   }   // parallel
 332   if (err == 0 && checker == 0) {
 333     printf("passed\n");
 334     return 0;
 335   } else {
 336     printf("failed, err = %d, checker = %d\n", err, checker);
 337     return 1;
 338   }
 339 }
 340
 341 // NOENV-NOT: ThreadSanitizer: data race
 342 // NOENV-NOT: ThreadSanitizer: reported
 343 // NOENV: omp_all_memory
 344 // NOENV-NOT: ThreadSanitizer: data race
 345 // NOENV-NOT: ThreadSanitizer: reported
 346 // NOENV: passed
 347
 348 // ENV-NOT: ThreadSanitizer: data race
 349 // ENV-NOT: ThreadSanitizer: reported
 350 // ENV: passed