libgomp/testsuite/libgomp.oacc-c-c++-common/acc_prof-dispatch-1.c

   1 /* Test dispatch of events to callbacks.  */
   2
   3 #undef NDEBUG
   4 #include <assert.h>
   5
   6 #include <acc_prof.h>
   7
   8
   9 /* Use explicit 'copyin' clauses, to work around "'firstprivate'
  10    optimizations", which will cause the value at the point of call to be used
  11    (*before* any potential modifications done in callbacks), as opposed to its
  12    address being taken, which then later gets dereferenced (*after* any
  13    modifications done in callbacks).  */
  14 #define COPYIN(...) copyin(__VA_ARGS__)
  15
  16
  17 #define DEBUG_printf(...) //__builtin_printf (__VA_ARGS__)
  18
  19
  20 static int state = -1;
  21
  22 #define STATE_OP(state, op) \
  23   do \
  24     { \
  25       typeof (state) state_o = (state); \
  26       (void) state_o; \
  27       (state)op; \
  28       DEBUG_printf("state: %d -> %d\n", state_o, (state)); \
  29     } \
  30   while (0)
  31
  32
  33 static void cb_compute_construct_start_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
  34 {
  35   DEBUG_printf ("%s\n", __FUNCTION__);
  36
  37   assert (state == 0
  38           || state == 10
  39           || state == 30
  40           || state == 41
  41           || state == 51
  42           || state == 91
  43           || state == 101
  44           || state == 151);
  45   STATE_OP (state, ++);
  46 }
  47
  48 static void cb_compute_construct_start_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
  49 {
  50   DEBUG_printf ("%s\n", __FUNCTION__);
  51
  52   assert (state == 1
  53           || state == 11
  54           || state == 40
  55           || state == 50
  56           || state == 90
  57           || state == 100
  58           || state == 150);
  59   STATE_OP (state, ++);
  60 }
  61
  62 static void cb_compute_construct_end_1 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
  63 {
  64   DEBUG_printf ("%s\n", __FUNCTION__);
  65
  66   assert (state == 14
  67           || state == 21
  68           || state == 32
  69           || state == 42
  70           || state == 80
  71           || state == 103
  72           || state == 152);
  73   STATE_OP (state, ++);
  74 }
  75
  76 static void cb_compute_construct_end_2 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
  77 {
  78   DEBUG_printf ("%s\n", __FUNCTION__);
  79
  80   assert (state == 13
  81           || state == 43
  82           || state == 102
  83           || state == 154);
  84   STATE_OP (state, ++);
  85 }
  86
  87 static void cb_compute_construct_end_3 (acc_prof_info *prof_info, acc_event_info *event_info, acc_api_info *api_info)
  88 {
  89   DEBUG_printf ("%s\n", __FUNCTION__);
  90
  91   assert (state == 12
  92           || state == 20
  93           || state == 31
  94           || state == 44
  95           || state == 81
  96           || state == 104
  97           || state == 153);
  98   STATE_OP (state, ++);
  99 }
 100
 101
 102 static acc_prof_reg reg;
 103 static acc_prof_reg unreg;
 104 static acc_prof_lookup_func lookup;
 105 void acc_register_library (acc_prof_reg reg_, acc_prof_reg unreg_, acc_prof_lookup_func lookup_)
 106 {
 107   DEBUG_printf ("%s\n", __FUNCTION__);
 108
 109   reg = reg_;
 110   unreg = unreg_;
 111   lookup = lookup_;
 112 }
 113
 114
 115 int main()
 116 {
 117   acc_register_library (acc_prof_register, acc_prof_unregister, acc_prof_lookup);
 118
 119   STATE_OP (state, = 0);
 120   reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
 121   reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
 122   reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
 123   {
 124     int state_init;
 125 #pragma acc parallel COPYIN(state) copyout(state_init)
 126     {
 127       state_init = state;
 128     }
 129     assert (state_init == 2);
 130   }
 131   assert (state == 2);
 132
 133   STATE_OP (state, = 10);
 134   reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
 135   reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
 136   reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
 137   reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
 138   reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
 139   reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
 140   {
 141     int state_init;
 142 #pragma acc parallel COPYIN(state) copyout(state_init)
 143     {
 144       state_init = state;
 145     }
 146     assert (state_init == 12);
 147   }
 148   assert (state == 15);
 149
 150   STATE_OP (state, = 20);
 151   unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
 152   unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
 153   unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
 154   unreg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
 155   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
 156   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
 157   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
 158   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
 159   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
 160   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
 161   reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
 162   {
 163     int state_init;
 164 #pragma acc parallel COPYIN(state) copyout(state_init)
 165     {
 166       state_init = state;
 167     }
 168     assert (state_init == 20);
 169   }
 170   assert (state == 20);
 171
 172   STATE_OP (state, = 30);
 173   reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_toggle);
 174   reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_toggle);
 175   reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_toggle);
 176   reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_toggle);
 177   reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_toggle);
 178   {
 179     int state_init;
 180 #pragma acc parallel COPYIN(state) copyout(state_init)
 181     {
 182       state_init = state;
 183     }
 184     assert (state_init == 31);
 185   }
 186   assert (state == 33);
 187
 188   STATE_OP (state, = 40);
 189   reg (acc_ev_compute_construct_start, cb_compute_construct_start_2, acc_reg);
 190   unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
 191   reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
 192   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
 193   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
 194   reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
 195   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
 196   reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
 197   {
 198     int state_init;
 199 #pragma acc parallel COPYIN(state) copyout(state_init)
 200     {
 201       state_init = state;
 202     }
 203     assert (state_init == 42);
 204   }
 205   assert (state == 45);
 206
 207   STATE_OP (state, = 50);
 208   unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
 209   {
 210     int state_init;
 211 #pragma acc parallel COPYIN(state) copyout(state_init)
 212     {
 213       state_init = state;
 214     }
 215     assert (state_init == 52);
 216   }
 217   assert (state == 52);
 218
 219   STATE_OP (state, = 60);
 220   unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
 221   unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
 222   unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
 223   {
 224     int state_init;
 225 #pragma acc parallel COPYIN(state) copyout(state_init)
 226     {
 227       state_init = state;
 228     }
 229     assert (state_init == 60);
 230   }
 231   assert (state == 60);
 232
 233   STATE_OP (state, = 70);
 234   unreg (acc_ev_compute_construct_start, NULL, acc_toggle);
 235   reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
 236   {
 237     int state_init;
 238 #pragma acc parallel COPYIN(state) copyout(state_init)
 239     {
 240       state_init = state;
 241     }
 242     assert (state_init == 70);
 243   }
 244   assert (state == 70);
 245
 246   STATE_OP (state, = 80);
 247   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
 248   reg (acc_ev_compute_construct_end, NULL, acc_toggle);
 249   reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
 250   {
 251     int state_init;
 252 #pragma acc parallel COPYIN(state) copyout(state_init)
 253     {
 254       state_init = state;
 255     }
 256     assert (state_init == 80);
 257   }
 258   assert (state == 82);
 259
 260   STATE_OP (state, = 90);
 261   reg (acc_ev_compute_construct_start, NULL, acc_toggle);
 262   unreg (acc_ev_compute_construct_end, NULL, acc_toggle);
 263   reg (acc_ev_compute_construct_end, cb_compute_construct_end_2, acc_reg);
 264   {
 265     int state_init;
 266 #pragma acc parallel COPYIN(state) copyout(state_init)
 267     {
 268       state_init = state;
 269     }
 270     assert (state_init == 92);
 271   }
 272   assert (state == 92);
 273
 274   STATE_OP (state, = 100);
 275   reg (acc_ev_compute_construct_end, NULL, acc_toggle);
 276   {
 277     int state_init;
 278 #pragma acc parallel COPYIN(state) copyout(state_init)
 279     {
 280       state_init = state;
 281     }
 282     assert (state_init == 102);
 283   }
 284   assert (state == 105);
 285
 286   STATE_OP (state, = 110);
 287   unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
 288   unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
 289   {
 290     int state_init;
 291 #pragma acc parallel COPYIN(state) copyout(state_init)
 292     {
 293       state_init = state;
 294     }
 295     assert (state_init == 110);
 296   }
 297   assert (state == 110);
 298
 299   STATE_OP (state, = 120);
 300   unreg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
 301   {
 302     int state_init;
 303 #pragma acc parallel COPYIN(state) copyout(state_init)
 304     {
 305       state_init = state;
 306     }
 307     assert (state_init == 120);
 308   }
 309   assert (state == 120);
 310
 311   STATE_OP (state, = 130);
 312   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
 313   reg (acc_ev_compute_construct_end, cb_compute_construct_end_3, acc_reg);
 314   reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle);
 315   {
 316     int state_init;
 317 #pragma acc parallel COPYIN(state) copyout(state_init)
 318     {
 319       state_init = state;
 320     }
 321     assert (state_init == 130);
 322   }
 323   assert (state == 130);
 324
 325   STATE_OP (state, = 140);
 326   unreg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
 327   reg (acc_ev_compute_construct_start, cb_compute_construct_start_1, acc_reg);
 328   unreg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
 329   reg (acc_ev_compute_construct_end, cb_compute_construct_end_1, acc_reg);
 330   {
 331     int state_init;
 332 #pragma acc parallel COPYIN(state) copyout(state_init)
 333     {
 334       state_init = state;
 335     }
 336     assert (state_init == 140);
 337   }
 338   assert (state == 140);
 339
 340   STATE_OP (state, = 150);
 341   reg (/* TODO */ (acc_event_t) 0, NULL, acc_toggle_per_thread);
 342   {
 343     int state_init;
 344 #pragma acc parallel COPYIN(state) copyout(state_init)
 345     {
 346       state_init = state;
 347     }
 348     assert (state_init == 152);
 349   }
 350   assert (state == 155);
 351
 352   return 0;
 353 }