libgomp/oacc-parallel.c

   1 /* Copyright (C) 2013-2015 Free Software Foundation, Inc.
   2
   3    Contributed by Mentor Embedded.
   4
   5    This file is part of the GNU Offloading and Multi Processing Library
   6    (libgomp).
   7
   8    Libgomp is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  14    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16    more details.
  17
  18    Under Section 7 of GPL version 3, you are granted additional
  19    permissions described in the GCC Runtime Library Exception, version
  20    3.1, as published by the Free Software Foundation.
  21
  22    You should have received a copy of the GNU General Public License and
  23    a copy of the GCC Runtime Library Exception along with this program;
  24    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25    <http://www.gnu.org/licenses/>.  */
  26
  27 /* This file handles OpenACC constructs.  */
  28
  29 #include "openacc.h"
  30 #include "libgomp.h"
  31 #include "libgomp_g.h"
  32 #include "gomp-constants.h"
  33 #include "oacc-int.h"
  34 #include <string.h>
  35 #include <stdarg.h>
  36 #include <assert.h>
  37
  38 static int
  39 find_pset (int pos, size_t mapnum, unsigned short *kinds)
  40 {
  41   if (pos + 1 >= mapnum)
  42     return 0;
  43
  44   unsigned char kind = kinds[pos+1] & 0xff;
  45
  46   return kind == GOMP_MAP_TO_PSET;
  47 }
  48
  49
  50 /* Ensure that the target device for DEVICE_TYPE is initialised (and that
  51    plugins have been loaded if appropriate).  The ACC_dev variable for the
  52    current thread will be set appropriately for the given device type on
  53    return.  */
  54
  55 attribute_hidden void
  56 select_acc_device (int device_type)
  57 {
  58   goacc_lazy_initialize ();
  59
  60   if (device_type == GOMP_DEVICE_HOST_FALLBACK)
  61     return;
  62
  63   if (device_type == acc_device_none)
  64     device_type = acc_device_host;
  65
  66   if (device_type >= 0)
  67     {
  68       /* NOTE: this will go badly if the surrounding data environment is set up
  69          to use a different device type.  We'll just have to trust that users
  70          know what they're doing...  */
  71       acc_set_device_type (device_type);
  72     }
  73 }
  74
  75 static void goacc_wait (int async, int num_waits, va_list ap);
  76
  77 void
  78 GOACC_parallel (int device, void (*fn) (void *),
  79                 size_t mapnum, void **hostaddrs, size_t *sizes,
  80                 unsigned short *kinds,
  81                 int num_gangs, int num_workers, int vector_length,
  82                 int async, int num_waits, ...)
  83 {
  84   bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
  85   va_list ap;
  86   struct goacc_thread *thr;
  87   struct gomp_device_descr *acc_dev;
  88   struct target_mem_desc *tgt;
  89   void **devaddrs;
  90   unsigned int i;
  91   struct splay_tree_key_s k;
  92   splay_tree_key tgt_fn_key;
  93   void (*tgt_fn);
  94
  95   if (num_workers != 1)
  96     gomp_fatal ("num_workers (%d) different from one is not yet supported",
  97                 num_workers);
  98
  99   gomp_debug (0, "%s: mapnum=%zd, hostaddrs=%p, sizes=%p, kinds=%p, async=%d\n",
 100               __FUNCTION__, mapnum, hostaddrs, sizes, kinds, async);
 101
 102   select_acc_device (device);
 103
 104   thr = goacc_thread ();
 105   acc_dev = thr->dev;
 106
 107   /* Host fallback if "if" clause is false or if the current device is set to
 108      the host.  */
 109   if (host_fallback)
 110     {
 111       goacc_save_and_set_bind (acc_device_host);
 112       fn (hostaddrs);
 113       goacc_restore_bind ();
 114       return;
 115     }
 116   else if (acc_device_type (acc_dev->type) == acc_device_host)
 117     {
 118       fn (hostaddrs);
 119       return;
 120     }
 121
 122   va_start (ap, num_waits);
 123
 124   if (num_waits > 0)
 125     goacc_wait (async, num_waits, ap);
 126
 127   va_end (ap);
 128
 129   acc_dev->openacc.async_set_async_func (async);
 130
 131   if (!(acc_dev->capabilities & GOMP_OFFLOAD_CAP_NATIVE_EXEC))
 132     {
 133       k.host_start = (uintptr_t) fn;
 134       k.host_end = k.host_start + 1;
 135       gomp_mutex_lock (&acc_dev->mem_map.lock);
 136       tgt_fn_key = splay_tree_lookup (&acc_dev->mem_map.splay_tree, &k);
 137       gomp_mutex_unlock (&acc_dev->mem_map.lock);
 138
 139       if (tgt_fn_key == NULL)
 140         gomp_fatal ("target function wasn't mapped");
 141
 142       tgt_fn = (void (*)) tgt_fn_key->tgt->tgt_start;
 143     }
 144   else
 145     tgt_fn = (void (*)) fn;
 146
 147   tgt = gomp_map_vars (acc_dev, mapnum, hostaddrs, NULL, sizes, kinds, true,
 148                        false);
 149
 150   devaddrs = gomp_alloca (sizeof (void *) * mapnum);
 151   for (i = 0; i < mapnum; i++)
 152     devaddrs[i] = (void *) (tgt->list[i]->tgt->tgt_start
 153                             + tgt->list[i]->tgt_offset);
 154
 155   acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs, sizes, kinds,
 156                               num_gangs, num_workers, vector_length, async,
 157                               tgt);
 158
 159   /* If running synchronously, unmap immediately.  */
 160   if (async < acc_async_noval)
 161     gomp_unmap_vars (tgt, true);
 162   else
 163     {
 164       gomp_copy_from_async (tgt);
 165       acc_dev->openacc.register_async_cleanup_func (tgt);
 166     }
 167
 168   acc_dev->openacc.async_set_async_func (acc_async_sync);
 169 }
 170
 171 void
 172 GOACC_data_start (int device, size_t mapnum,
 173                   void **hostaddrs, size_t *sizes, unsigned short *kinds)
 174 {
 175   bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
 176   struct target_mem_desc *tgt;
 177
 178   gomp_debug (0, "%s: mapnum=%zd, hostaddrs=%p, sizes=%p, kinds=%p\n",
 179               __FUNCTION__, mapnum, hostaddrs, sizes, kinds);
 180
 181   select_acc_device (device);
 182
 183   struct goacc_thread *thr = goacc_thread ();
 184   struct gomp_device_descr *acc_dev = thr->dev;
 185
 186   /* Host fallback or 'do nothing'.  */
 187   if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
 188       || host_fallback)
 189     {
 190       tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true, false);
 191       tgt->prev = thr->mapped_data;
 192       thr->mapped_data = tgt;
 193
 194       return;
 195     }
 196
 197   gomp_debug (0, "  %s: prepare mappings\n", __FUNCTION__);
 198   tgt = gomp_map_vars (acc_dev, mapnum, hostaddrs, NULL, sizes, kinds, true,
 199                        false);
 200   gomp_debug (0, "  %s: mappings prepared\n", __FUNCTION__);
 201   tgt->prev = thr->mapped_data;
 202   thr->mapped_data = tgt;
 203 }
 204
 205 void
 206 GOACC_data_end (void)
 207 {
 208   struct goacc_thread *thr = goacc_thread ();
 209   struct target_mem_desc *tgt = thr->mapped_data;
 210
 211   gomp_debug (0, "  %s: restore mappings\n", __FUNCTION__);
 212   thr->mapped_data = tgt->prev;
 213   gomp_unmap_vars (tgt, true);
 214   gomp_debug (0, "  %s: mappings restored\n", __FUNCTION__);
 215 }
 216
 217 void
 218 GOACC_enter_exit_data (int device, size_t mapnum,
 219                        void **hostaddrs, size_t *sizes, unsigned short *kinds,
 220                        int async, int num_waits, ...)
 221 {
 222   struct goacc_thread *thr;
 223   struct gomp_device_descr *acc_dev;
 224   bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
 225   bool data_enter = false;
 226   size_t i;
 227
 228   select_acc_device (device);
 229
 230   thr = goacc_thread ();
 231   acc_dev = thr->dev;
 232
 233   if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
 234       || host_fallback)
 235     return;
 236
 237   if (num_waits > 0)
 238     {
 239       va_list ap;
 240
 241       va_start (ap, num_waits);
 242
 243       goacc_wait (async, num_waits, ap);
 244
 245       va_end (ap);
 246     }
 247
 248   acc_dev->openacc.async_set_async_func (async);
 249
 250   /* Determine if this is an "acc enter data".  */
 251   for (i = 0; i < mapnum; ++i)
 252     {
 253       unsigned char kind = kinds[i] & 0xff;
 254
 255       if (kind == GOMP_MAP_POINTER || kind == GOMP_MAP_TO_PSET)
 256         continue;
 257
 258       if (kind == GOMP_MAP_FORCE_ALLOC
 259           || kind == GOMP_MAP_FORCE_PRESENT
 260           || kind == GOMP_MAP_FORCE_TO)
 261         {
 262           data_enter = true;
 263           break;
 264         }
 265
 266       if (kind == GOMP_MAP_FORCE_DEALLOC
 267           || kind == GOMP_MAP_FORCE_FROM)
 268         break;
 269
 270       gomp_fatal (">>>> GOACC_enter_exit_data UNHANDLED kind 0x%.2x",
 271                       kind);
 272     }
 273
 274   if (data_enter)
 275     {
 276       for (i = 0; i < mapnum; i++)
 277         {
 278           unsigned char kind = kinds[i] & 0xff;
 279
 280           /* Scan for PSETs.  */
 281           int psets = find_pset (i, mapnum, kinds);
 282
 283           if (!psets)
 284             {
 285               switch (kind)
 286                 {
 287                 case GOMP_MAP_POINTER:
 288                   gomp_acc_insert_pointer (1, &hostaddrs[i], &sizes[i],
 289                                         &kinds[i]);
 290                   break;
 291                 case GOMP_MAP_FORCE_ALLOC:
 292                   acc_create (hostaddrs[i], sizes[i]);
 293                   break;
 294                 case GOMP_MAP_FORCE_PRESENT:
 295                   acc_present_or_copyin (hostaddrs[i], sizes[i]);
 296                   break;
 297                 case GOMP_MAP_FORCE_TO:
 298                   acc_present_or_copyin (hostaddrs[i], sizes[i]);
 299                   break;
 300                 default:
 301                   gomp_fatal (">>>> GOACC_enter_exit_data UNHANDLED kind 0x%.2x",
 302                               kind);
 303                   break;
 304                 }
 305             }
 306           else
 307             {
 308               gomp_acc_insert_pointer (3, &hostaddrs[i], &sizes[i], &kinds[i]);
 309               /* Increment 'i' by two because OpenACC requires fortran
 310                  arrays to be contiguous, so each PSET is associated with
 311                  one of MAP_FORCE_ALLOC/MAP_FORCE_PRESET/MAP_FORCE_TO, and
 312                  one MAP_POINTER.  */
 313               i += 2;
 314             }
 315         }
 316     }
 317   else
 318     for (i = 0; i < mapnum; ++i)
 319       {
 320         unsigned char kind = kinds[i] & 0xff;
 321
 322         int psets = find_pset (i, mapnum, kinds);
 323
 324         if (!psets)
 325           {
 326             switch (kind)
 327               {
 328               case GOMP_MAP_POINTER:
 329                 gomp_acc_remove_pointer (hostaddrs[i], (kinds[i] & 0xff)
 330                                          == GOMP_MAP_FORCE_FROM,
 331                                          async, 1);
 332                 break;
 333               case GOMP_MAP_FORCE_DEALLOC:
 334                 acc_delete (hostaddrs[i], sizes[i]);
 335                 break;
 336               case GOMP_MAP_FORCE_FROM:
 337                 acc_copyout (hostaddrs[i], sizes[i]);
 338                 break;
 339               default:
 340                 gomp_fatal (">>>> GOACC_enter_exit_data UNHANDLED kind 0x%.2x",
 341                             kind);
 342                 break;
 343               }
 344           }
 345         else
 346           {
 347             gomp_acc_remove_pointer (hostaddrs[i], (kinds[i] & 0xff)
 348                                      == GOMP_MAP_FORCE_FROM, async, 3);
 349             /* See the above comment.  */
 350             i += 2;
 351           }
 352       }
 353
 354   acc_dev->openacc.async_set_async_func (acc_async_sync);
 355 }
 356
 357 void
 358 GOACC_kernels (int device, void (*fn) (void *),
 359                size_t mapnum, void **hostaddrs, size_t *sizes,
 360                unsigned short *kinds,
 361                int num_gangs, int num_workers, int vector_length,
 362                int async, int num_waits, ...)
 363 {
 364   gomp_debug (0, "%s: mapnum=%zd, hostaddrs=%p, sizes=%p, kinds=%p\n",
 365               __FUNCTION__, mapnum, hostaddrs, sizes, kinds);
 366
 367   va_list ap;
 368
 369   select_acc_device (device);
 370
 371   va_start (ap, num_waits);
 372
 373   if (num_waits > 0)
 374     goacc_wait (async, num_waits, ap);
 375
 376   va_end (ap);
 377
 378   GOACC_parallel (device, fn, mapnum, hostaddrs, sizes, kinds,
 379                   num_gangs, num_workers, vector_length, async, 0);
 380 }
 381
 382 static void
 383 goacc_wait (int async, int num_waits, va_list ap)
 384 {
 385   struct goacc_thread *thr = goacc_thread ();
 386   struct gomp_device_descr *acc_dev = thr->dev;
 387   int i;
 388
 389   assert (num_waits >= 0);
 390
 391   if (async == acc_async_sync && num_waits == 0)
 392     {
 393       acc_wait_all ();
 394       return;
 395     }
 396
 397   if (async == acc_async_sync && num_waits)
 398     {
 399       for (i = 0; i < num_waits; i++)
 400         {
 401           int qid = va_arg (ap, int);
 402
 403           if (acc_async_test (qid))
 404             continue;
 405
 406           acc_wait (qid);
 407         }
 408       return;
 409     }
 410
 411   if (async == acc_async_noval && num_waits == 0)
 412     {
 413       acc_dev->openacc.async_wait_all_async_func (acc_async_noval);
 414       return;
 415     }
 416
 417   for (i = 0; i < num_waits; i++)
 418     {
 419       int qid = va_arg (ap, int);
 420
 421       if (acc_async_test (qid))
 422         continue;
 423
 424       /* If we're waiting on the same asynchronous queue as we're launching on,
 425          the queue itself will order work as required, so there's no need to
 426          wait explicitly.  */
 427       if (qid != async)
 428         acc_dev->openacc.async_wait_async_func (qid, async);
 429     }
 430 }
 431
 432 void
 433 GOACC_update (int device, size_t mapnum,
 434               void **hostaddrs, size_t *sizes, unsigned short *kinds,
 435               int async, int num_waits, ...)
 436 {
 437   bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
 438   size_t i;
 439
 440   select_acc_device (device);
 441
 442   struct goacc_thread *thr = goacc_thread ();
 443   struct gomp_device_descr *acc_dev = thr->dev;
 444
 445   if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
 446       || host_fallback)
 447     return;
 448
 449   if (num_waits > 0)
 450     {
 451       va_list ap;
 452
 453       va_start (ap, num_waits);
 454
 455       goacc_wait (async, num_waits, ap);
 456
 457       va_end (ap);
 458     }
 459
 460   acc_dev->openacc.async_set_async_func (async);
 461
 462   for (i = 0; i < mapnum; ++i)
 463     {
 464       unsigned char kind = kinds[i] & 0xff;
 465
 466       switch (kind)
 467         {
 468         case GOMP_MAP_POINTER:
 469         case GOMP_MAP_TO_PSET:
 470           break;
 471
 472         case GOMP_MAP_FORCE_TO:
 473           acc_update_device (hostaddrs[i], sizes[i]);
 474           break;
 475
 476         case GOMP_MAP_FORCE_FROM:
 477           acc_update_self (hostaddrs[i], sizes[i]);
 478           break;
 479
 480         default:
 481           gomp_fatal (">>>> GOACC_update UNHANDLED kind 0x%.2x", kind);
 482           break;
 483         }
 484     }
 485
 486   acc_dev->openacc.async_set_async_func (acc_async_sync);
 487 }
 488
 489 void
 490 GOACC_wait (int async, int num_waits, ...)
 491 {
 492   va_list ap;
 493
 494   va_start (ap, num_waits);
 495
 496   goacc_wait (async, num_waits, ap);
 497
 498   va_end (ap);
 499 }
 500
 501 int
 502 GOACC_get_num_threads (void)
 503 {
 504   return 1;
 505 }
 506
 507 int
 508 GOACC_get_thread_num (void)
 509 {
 510   return 0;
 511 }