libgomp/libgomp.h

   1 /* Copyright (C) 2005-2016 Free Software Foundation, Inc.
   2    Contributed by Richard Henderson <rth@redhat.com>.
   3
   4    This file is part of the GNU Offloading and Multi Processing Library
   5    (libgomp).
   6
   7    Libgomp is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15    more details.
  16
  17    Under Section 7 of GPL version 3, you are granted additional
  18    permissions described in the GCC Runtime Library Exception, version
  19    3.1, as published by the Free Software Foundation.
  20
  21    You should have received a copy of the GNU General Public License and
  22    a copy of the GCC Runtime Library Exception along with this program;
  23    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24    <http://www.gnu.org/licenses/>.  */
  25
  26 /* This file contains data types and function declarations that are not
  27    part of the official OpenACC or OpenMP user interfaces.  There are
  28    declarations in here that are part of the GNU Offloading and Multi
  29    Processing ABI, in that the compiler is required to know about them
  30    and use them.
  31
  32    The convention is that the all caps prefix "GOMP" is used group items
  33    that are part of the external ABI, and the lower case prefix "gomp"
  34    is used group items that are completely private to the library.  */
  35
  36 #ifndef LIBGOMP_H
  37 #define LIBGOMP_H 1
  38
  39 #ifndef _LIBGOMP_CHECKING_
  40 /* Define to 1 to perform internal sanity checks.  */
  41 #define _LIBGOMP_CHECKING_ 0
  42 #endif
  43
  44 #include "config.h"
  45 #include "gstdint.h"
  46 #include "libgomp-plugin.h"
  47
  48 #include <pthread.h>
  49 #include <stdbool.h>
  50 #include <stdlib.h>
  51 #include <stdarg.h>
  52
  53 /* Needed for memset in priority_queue.c.  */
  54 #if _LIBGOMP_CHECKING_
  55 # ifdef STRING_WITH_STRINGS
  56 #  include <string.h>
  57 #  include <strings.h>
  58 # else
  59 #  ifdef HAVE_STRING_H
  60 #   include <string.h>
  61 #  else
  62 #   ifdef HAVE_STRINGS_H
  63 #    include <strings.h>
  64 #   endif
  65 #  endif
  66 # endif
  67 #endif
  68
  69 #ifdef HAVE_ATTRIBUTE_VISIBILITY
  70 # pragma GCC visibility push(hidden)
  71 #endif
  72
  73 /* If we were a C++ library, we'd get this from <std/atomic>.  */
  74 enum memmodel
  75 {
  76   MEMMODEL_RELAXED = 0,
  77   MEMMODEL_CONSUME = 1,
  78   MEMMODEL_ACQUIRE = 2,
  79   MEMMODEL_RELEASE = 3,
  80   MEMMODEL_ACQ_REL = 4,
  81   MEMMODEL_SEQ_CST = 5
  82 };
  83
  84 /* alloc.c */
  85
  86 extern void *gomp_malloc (size_t) __attribute__((malloc));
  87 extern void *gomp_malloc_cleared (size_t) __attribute__((malloc));
  88 extern void *gomp_realloc (void *, size_t);
  89
  90 /* Avoid conflicting prototypes of alloca() in system headers by using
  91    GCC's builtin alloca().  */
  92 #define gomp_alloca(x)  __builtin_alloca(x)
  93
  94 /* error.c */
  95
  96 extern void gomp_vdebug (int, const char *, va_list);
  97 extern void gomp_debug (int, const char *, ...)
  98         __attribute__ ((format (printf, 2, 3)));
  99 #define gomp_vdebug(KIND, FMT, VALIST) \
 100   do { \
 101     if (__builtin_expect (gomp_debug_var, 0)) \
 102       (gomp_vdebug) ((KIND), (FMT), (VALIST)); \
 103   } while (0)
 104 #define gomp_debug(KIND, ...) \
 105   do { \
 106     if (__builtin_expect (gomp_debug_var, 0)) \
 107       (gomp_debug) ((KIND), __VA_ARGS__); \
 108   } while (0)
 109 extern void gomp_verror (const char *, va_list);
 110 extern void gomp_error (const char *, ...)
 111         __attribute__ ((format (printf, 1, 2)));
 112 extern void gomp_vfatal (const char *, va_list)
 113         __attribute__ ((noreturn));
 114 extern void gomp_fatal (const char *, ...)
 115         __attribute__ ((noreturn, format (printf, 1, 2)));
 116
 117 struct gomp_task;
 118 struct gomp_taskgroup;
 119 struct htab;
 120
 121 #include "priority_queue.h"
 122 #include "sem.h"
 123 #include "mutex.h"
 124 #include "bar.h"
 125 #include "ptrlock.h"
 126
 127
 128 /* This structure contains the data to control one work-sharing construct,
 129    either a LOOP (FOR/DO) or a SECTIONS.  */
 130
 131 enum gomp_schedule_type
 132 {
 133   GFS_RUNTIME,
 134   GFS_STATIC,
 135   GFS_DYNAMIC,
 136   GFS_GUIDED,
 137   GFS_AUTO
 138 };
 139
 140 struct gomp_doacross_work_share
 141 {
 142   union {
 143     /* chunk_size copy, as ws->chunk_size is multiplied by incr for
 144        GFS_DYNAMIC.  */
 145     long chunk_size;
 146     /* Likewise, but for ull implementation.  */
 147     unsigned long long chunk_size_ull;
 148     /* For schedule(static,0) this is the number
 149        of iterations assigned to the last thread, i.e. number of
 150        iterations / number of threads.  */
 151     long q;
 152     /* Likewise, but for ull implementation.  */
 153     unsigned long long q_ull;
 154   };
 155   /* Size of each array entry (padded to cache line size).  */
 156   unsigned long elt_sz;
 157   /* Number of dimensions in sink vectors.  */
 158   unsigned int ncounts;
 159   /* True if the iterations can be flattened.  */
 160   bool flattened;
 161   /* Actual array (of elt_sz sized units), aligned to cache line size.
 162      This is indexed by team_id for GFS_STATIC and outermost iteration
 163      / chunk_size for other schedules.  */
 164   unsigned char *array;
 165   /* These two are only used for schedule(static,0).  */
 166   /* This one is number of iterations % number of threads.  */
 167   long t;
 168   union {
 169     /* And this one is cached t * (q + 1).  */
 170     long boundary;
 171     /* Likewise, but for the ull implementation.  */
 172     unsigned long long boundary_ull;
 173   };
 174   /* Array of shift counts for each dimension if they can be flattened.  */
 175   unsigned int shift_counts[];
 176 };
 177
 178 struct gomp_work_share
 179 {
 180   /* This member records the SCHEDULE clause to be used for this construct.
 181      The user specification of "runtime" will already have been resolved.
 182      If this is a SECTIONS construct, this value will always be DYNAMIC.  */
 183   enum gomp_schedule_type sched;
 184
 185   int mode;
 186
 187   union {
 188     struct {
 189       /* This is the chunk_size argument to the SCHEDULE clause.  */
 190       long chunk_size;
 191
 192       /* This is the iteration end point.  If this is a SECTIONS construct,
 193          this is the number of contained sections.  */
 194       long end;
 195
 196       /* This is the iteration step.  If this is a SECTIONS construct, this
 197          is always 1.  */
 198       long incr;
 199     };
 200
 201     struct {
 202       /* The same as above, but for the unsigned long long loop variants.  */
 203       unsigned long long chunk_size_ull;
 204       unsigned long long end_ull;
 205       unsigned long long incr_ull;
 206     };
 207   };
 208
 209   union {
 210     /* This is a circular queue that details which threads will be allowed
 211        into the ordered region and in which order.  When a thread allocates
 212        iterations on which it is going to work, it also registers itself at
 213        the end of the array.  When a thread reaches the ordered region, it
 214        checks to see if it is the one at the head of the queue.  If not, it
 215        blocks on its RELEASE semaphore.  */
 216     unsigned *ordered_team_ids;
 217
 218     /* This is a pointer to DOACROSS work share data.  */
 219     struct gomp_doacross_work_share *doacross;
 220   };
 221
 222   /* This is the number of threads that have registered themselves in
 223      the circular queue ordered_team_ids.  */
 224   unsigned ordered_num_used;
 225
 226   /* This is the team_id of the currently acknowledged owner of the ordered
 227      section, or -1u if the ordered section has not been acknowledged by
 228      any thread.  This is distinguished from the thread that is *allowed*
 229      to take the section next.  */
 230   unsigned ordered_owner;
 231
 232   /* This is the index into the circular queue ordered_team_ids of the
 233      current thread that's allowed into the ordered reason.  */
 234   unsigned ordered_cur;
 235
 236   /* This is a chain of allocated gomp_work_share blocks, valid only
 237      in the first gomp_work_share struct in the block.  */
 238   struct gomp_work_share *next_alloc;
 239
 240   /* The above fields are written once during workshare initialization,
 241      or related to ordered worksharing.  Make sure the following fields
 242      are in a different cache line.  */
 243
 244   /* This lock protects the update of the following members.  */
 245   gomp_mutex_t lock __attribute__((aligned (64)));
 246
 247   /* This is the count of the number of threads that have exited the work
 248      share construct.  If the construct was marked nowait, they have moved on
 249      to other work; otherwise they're blocked on a barrier.  The last member
 250      of the team to exit the work share construct must deallocate it.  */
 251   unsigned threads_completed;
 252
 253   union {
 254     /* This is the next iteration value to be allocated.  In the case of
 255        GFS_STATIC loops, this the iteration start point and never changes.  */
 256     long next;
 257
 258     /* The same, but with unsigned long long type.  */
 259     unsigned long long next_ull;
 260
 261     /* This is the returned data structure for SINGLE COPYPRIVATE.  */
 262     void *copyprivate;
 263   };
 264
 265   union {
 266     /* Link to gomp_work_share struct for next work sharing construct
 267        encountered after this one.  */
 268     gomp_ptrlock_t next_ws;
 269
 270     /* gomp_work_share structs are chained in the free work share cache
 271        through this.  */
 272     struct gomp_work_share *next_free;
 273   };
 274
 275   /* If only few threads are in the team, ordered_team_ids can point
 276      to this array which fills the padding at the end of this struct.  */
 277   unsigned inline_ordered_team_ids[0];
 278 };
 279
 280 /* This structure contains all of the thread-local data associated with
 281    a thread team.  This is the data that must be saved when a thread
 282    encounters a nested PARALLEL construct.  */
 283
 284 struct gomp_team_state
 285 {
 286   /* This is the team of which the thread is currently a member.  */
 287   struct gomp_team *team;
 288
 289   /* This is the work share construct which this thread is currently
 290      processing.  Recall that with NOWAIT, not all threads may be
 291      processing the same construct.  */
 292   struct gomp_work_share *work_share;
 293
 294   /* This is the previous work share construct or NULL if there wasn't any.
 295      When all threads are done with the current work sharing construct,
 296      the previous one can be freed.  The current one can't, as its
 297      next_ws field is used.  */
 298   struct gomp_work_share *last_work_share;
 299
 300   /* This is the ID of this thread within the team.  This value is
 301      guaranteed to be between 0 and N-1, where N is the number of
 302      threads in the team.  */
 303   unsigned team_id;
 304
 305   /* Nesting level.  */
 306   unsigned level;
 307
 308   /* Active nesting level.  Only active parallel regions are counted.  */
 309   unsigned active_level;
 310
 311   /* Place-partition-var, offset and length into gomp_places_list array.  */
 312   unsigned place_partition_off;
 313   unsigned place_partition_len;
 314
 315 #ifdef HAVE_SYNC_BUILTINS
 316   /* Number of single stmts encountered.  */
 317   unsigned long single_count;
 318 #endif
 319
 320   /* For GFS_RUNTIME loops that resolved to GFS_STATIC, this is the
 321      trip number through the loop.  So first time a particular loop
 322      is encountered this number is 0, the second time through the loop
 323      is 1, etc.  This is unused when the compiler knows in advance that
 324      the loop is statically scheduled.  */
 325   unsigned long static_trip;
 326 };
 327
 328 struct target_mem_desc;
 329
 330 /* These are the OpenMP 4.0 Internal Control Variables described in
 331    section 2.3.1.  Those described as having one copy per task are
 332    stored within the structure; those described as having one copy
 333    for the whole program are (naturally) global variables.  */
 334
 335 struct gomp_task_icv
 336 {
 337   unsigned long nthreads_var;
 338   enum gomp_schedule_type run_sched_var;
 339   int run_sched_chunk_size;
 340   int default_device_var;
 341   unsigned int thread_limit_var;
 342   bool dyn_var;
 343   bool nest_var;
 344   char bind_var;
 345   /* Internal ICV.  */
 346   struct target_mem_desc *target_data;
 347 };
 348
 349 extern struct gomp_task_icv gomp_global_icv;
 350 #ifndef HAVE_SYNC_BUILTINS
 351 extern gomp_mutex_t gomp_managed_threads_lock;
 352 #endif
 353 extern unsigned long gomp_max_active_levels_var;
 354 extern bool gomp_cancel_var;
 355 extern int gomp_max_task_priority_var;
 356 extern unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var;
 357 extern unsigned long gomp_available_cpus, gomp_managed_threads;
 358 extern unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len;
 359 extern char *gomp_bind_var_list;
 360 extern unsigned long gomp_bind_var_list_len;
 361 extern void **gomp_places_list;
 362 extern unsigned long gomp_places_list_len;
 363 extern int gomp_debug_var;
 364 extern int goacc_device_num;
 365 extern char *goacc_device_type;
 366
 367 enum gomp_task_kind
 368 {
 369   /* Implicit task.  */
 370   GOMP_TASK_IMPLICIT,
 371   /* Undeferred task.  */
 372   GOMP_TASK_UNDEFERRED,
 373   /* Task created by GOMP_task and waiting to be run.  */
 374   GOMP_TASK_WAITING,
 375   /* Task currently executing or scheduled and about to execute.  */
 376   GOMP_TASK_TIED,
 377   /* Used for target tasks that have vars mapped and async run started,
 378      but not yet completed.  Once that completes, they will be readded
 379      into the queues as GOMP_TASK_WAITING in order to perform the var
 380      unmapping.  */
 381   GOMP_TASK_ASYNC_RUNNING
 382 };
 383
 384 struct gomp_task_depend_entry
 385 {
 386   /* Address of dependency.  */
 387   void *addr;
 388   struct gomp_task_depend_entry *next;
 389   struct gomp_task_depend_entry *prev;
 390   /* Task that provides the dependency in ADDR.  */
 391   struct gomp_task *task;
 392   /* Depend entry is of type "IN".  */
 393   bool is_in;
 394   bool redundant;
 395   bool redundant_out;
 396 };
 397
 398 struct gomp_dependers_vec
 399 {
 400   size_t n_elem;
 401   size_t allocated;
 402   struct gomp_task *elem[];
 403 };
 404
 405 /* Used when in GOMP_taskwait or in gomp_task_maybe_wait_for_dependencies.  */
 406
 407 struct gomp_taskwait
 408 {
 409   bool in_taskwait;
 410   bool in_depend_wait;
 411   /* Number of tasks we are waiting for.  */
 412   size_t n_depend;
 413   gomp_sem_t taskwait_sem;
 414 };
 415
 416 /* This structure describes a "task" to be run by a thread.  */
 417
 418 struct gomp_task
 419 {
 420   /* Parent of this task.  */
 421   struct gomp_task *parent;
 422   /* Children of this task.  */
 423   struct priority_queue children_queue;
 424   /* Taskgroup this task belongs in.  */
 425   struct gomp_taskgroup *taskgroup;
 426   /* Tasks that depend on this task.  */
 427   struct gomp_dependers_vec *dependers;
 428   struct htab *depend_hash;
 429   struct gomp_taskwait *taskwait;
 430   /* Number of items in DEPEND.  */
 431   size_t depend_count;
 432   /* Number of tasks this task depends on.  Once this counter reaches
 433      0, we have no unsatisfied dependencies, and this task can be put
 434      into the various queues to be scheduled.  */
 435   size_t num_dependees;
 436
 437   /* Priority of this task.  */
 438   int priority;
 439   /* The priority node for this task in each of the different queues.
 440      We put this here to avoid allocating space for each priority
 441      node.  Then we play offsetof() games to convert between pnode[]
 442      entries and the gomp_task in which they reside.  */
 443   struct priority_node pnode[3];
 444
 445   struct gomp_task_icv icv;
 446   void (*fn) (void *);
 447   void *fn_data;
 448   enum gomp_task_kind kind;
 449   bool in_tied_task;
 450   bool final_task;
 451   bool copy_ctors_done;
 452   /* Set for undeferred tasks with unsatisfied dependencies which
 453      block further execution of their parent until the dependencies
 454      are satisfied.  */
 455   bool parent_depends_on;
 456   /* Dependencies provided and/or needed for this task.  DEPEND_COUNT
 457      is the number of items available.  */
 458   struct gomp_task_depend_entry depend[];
 459 };
 460
 461 /* This structure describes a single #pragma omp taskgroup.  */
 462
 463 struct gomp_taskgroup
 464 {
 465   struct gomp_taskgroup *prev;
 466   /* Queue of tasks that belong in this taskgroup.  */
 467   struct priority_queue taskgroup_queue;
 468   bool in_taskgroup_wait;
 469   bool cancelled;
 470   gomp_sem_t taskgroup_sem;
 471   size_t num_children;
 472 };
 473
 474 /* Various state of OpenMP async offloading tasks.  */
 475 enum gomp_target_task_state
 476 {
 477   GOMP_TARGET_TASK_DATA,
 478   GOMP_TARGET_TASK_BEFORE_MAP,
 479   GOMP_TARGET_TASK_FALLBACK,
 480   GOMP_TARGET_TASK_READY_TO_RUN,
 481   GOMP_TARGET_TASK_RUNNING,
 482   GOMP_TARGET_TASK_FINISHED
 483 };
 484
 485 /* This structure describes a target task.  */
 486
 487 struct gomp_target_task
 488 {
 489   struct gomp_device_descr *devicep;
 490   void (*fn) (void *);
 491   size_t mapnum;
 492   size_t *sizes;
 493   unsigned short *kinds;
 494   unsigned int flags;
 495   enum gomp_target_task_state state;
 496   struct target_mem_desc *tgt;
 497   struct gomp_task *task;
 498   struct gomp_team *team;
 499   /* Device-specific target arguments.  */
 500   void **args;
 501   void *hostaddrs[];
 502 };
 503
 504 /* This structure describes a "team" of threads.  These are the threads
 505    that are spawned by a PARALLEL constructs, as well as the work sharing
 506    constructs that the team encounters.  */
 507
 508 struct gomp_team
 509 {
 510   /* This is the number of threads in the current team.  */
 511   unsigned nthreads;
 512
 513   /* This is number of gomp_work_share structs that have been allocated
 514      as a block last time.  */
 515   unsigned work_share_chunk;
 516
 517   /* This is the saved team state that applied to a master thread before
 518      the current thread was created.  */
 519   struct gomp_team_state prev_ts;
 520
 521   /* This semaphore should be used by the master thread instead of its
 522      "native" semaphore in the thread structure.  Required for nested
 523      parallels, as the master is a member of two teams.  */
 524   gomp_sem_t master_release;
 525
 526   /* This points to an array with pointers to the release semaphore
 527      of the threads in the team.  */
 528   gomp_sem_t **ordered_release;
 529
 530   /* List of work shares on which gomp_fini_work_share hasn't been
 531      called yet.  If the team hasn't been cancelled, this should be
 532      equal to each thr->ts.work_share, but otherwise it can be a possibly
 533      long list of workshares.  */
 534   struct gomp_work_share *work_shares_to_free;
 535
 536   /* List of gomp_work_share structs chained through next_free fields.
 537      This is populated and taken off only by the first thread in the
 538      team encountering a new work sharing construct, in a critical
 539      section.  */
 540   struct gomp_work_share *work_share_list_alloc;
 541
 542   /* List of gomp_work_share structs freed by free_work_share.  New
 543      entries are atomically added to the start of the list, and
 544      alloc_work_share can safely only move all but the first entry
 545      to work_share_list alloc, as free_work_share can happen concurrently
 546      with alloc_work_share.  */
 547   struct gomp_work_share *work_share_list_free;
 548
 549 #ifdef HAVE_SYNC_BUILTINS
 550   /* Number of simple single regions encountered by threads in this
 551      team.  */
 552   unsigned long single_count;
 553 #else
 554   /* Mutex protecting addition of workshares to work_share_list_free.  */
 555   gomp_mutex_t work_share_list_free_lock;
 556 #endif
 557
 558   /* This barrier is used for most synchronization of the team.  */
 559   gomp_barrier_t barrier;
 560
 561   /* Initial work shares, to avoid allocating any gomp_work_share
 562      structs in the common case.  */
 563   struct gomp_work_share work_shares[8];
 564
 565   gomp_mutex_t task_lock;
 566   /* Scheduled tasks.  */
 567   struct priority_queue task_queue;
 568   /* Number of all GOMP_TASK_{WAITING,TIED} tasks in the team.  */
 569   unsigned int task_count;
 570   /* Number of GOMP_TASK_WAITING tasks currently waiting to be scheduled.  */
 571   unsigned int task_queued_count;
 572   /* Number of GOMP_TASK_{WAITING,TIED} tasks currently running
 573      directly in gomp_barrier_handle_tasks; tasks spawned
 574      from e.g. GOMP_taskwait or GOMP_taskgroup_end don't count, even when
 575      that is called from a task run from gomp_barrier_handle_tasks.
 576      task_running_count should be always <= team->nthreads,
 577      and if current task isn't in_tied_task, then it will be
 578      even < team->nthreads.  */
 579   unsigned int task_running_count;
 580   int work_share_cancelled;
 581   int team_cancelled;
 582
 583   /* This array contains structures for implicit tasks.  */
 584   struct gomp_task implicit_task[];
 585 };
 586
 587 /* This structure contains all data that is private to libgomp and is
 588    allocated per thread.  */
 589
 590 struct gomp_thread
 591 {
 592   /* This is the function that the thread should run upon launch.  */
 593   void (*fn) (void *data);
 594   void *data;
 595
 596   /* This is the current team state for this thread.  The ts.team member
 597      is NULL only if the thread is idle.  */
 598   struct gomp_team_state ts;
 599
 600   /* This is the task that the thread is currently executing.  */
 601   struct gomp_task *task;
 602
 603   /* This semaphore is used for ordered loops.  */
 604   gomp_sem_t release;
 605
 606   /* Place this thread is bound to plus one, or zero if not bound
 607      to any place.  */
 608   unsigned int place;
 609
 610   /* User pthread thread pool */
 611   struct gomp_thread_pool *thread_pool;
 612 };
 613
 614
 615 struct gomp_thread_pool
 616 {
 617   /* This array manages threads spawned from the top level, which will
 618      return to the idle loop once the current PARALLEL construct ends.  */
 619   struct gomp_thread **threads;
 620   unsigned threads_size;
 621   unsigned threads_used;
 622   /* The last team is used for non-nested teams to delay their destruction to
 623      make sure all the threads in the team move on to the pool's barrier before
 624      the team's barrier is destroyed.  */
 625   struct gomp_team *last_team;
 626   /* Number of threads running in this contention group.  */
 627   unsigned long threads_busy;
 628
 629   /* This barrier holds and releases threads waiting in threads.  */
 630   gomp_barrier_t threads_dock;
 631 };
 632
 633 enum gomp_cancel_kind
 634 {
 635   GOMP_CANCEL_PARALLEL = 1,
 636   GOMP_CANCEL_LOOP = 2,
 637   GOMP_CANCEL_FOR = GOMP_CANCEL_LOOP,
 638   GOMP_CANCEL_DO = GOMP_CANCEL_LOOP,
 639   GOMP_CANCEL_SECTIONS = 4,
 640   GOMP_CANCEL_TASKGROUP = 8
 641 };
 642
 643 /* ... and here is that TLS data.  */
 644
 645 #if defined HAVE_TLS || defined USE_EMUTLS
 646 extern __thread struct gomp_thread gomp_tls_data;
 647 static inline struct gomp_thread *gomp_thread (void)
 648 {
 649   return &gomp_tls_data;
 650 }
 651 #else
 652 extern pthread_key_t gomp_tls_key;
 653 static inline struct gomp_thread *gomp_thread (void)
 654 {
 655   return pthread_getspecific (gomp_tls_key);
 656 }
 657 #endif
 658
 659 extern struct gomp_task_icv *gomp_new_icv (void);
 660
 661 /* Here's how to access the current copy of the ICVs.  */
 662
 663 static inline struct gomp_task_icv *gomp_icv (bool write)
 664 {
 665   struct gomp_task *task = gomp_thread ()->task;
 666   if (task)
 667     return &task->icv;
 668   else if (write)
 669     return gomp_new_icv ();
 670   else
 671     return &gomp_global_icv;
 672 }
 673
 674 /* The attributes to be used during thread creation.  */
 675 extern pthread_attr_t gomp_thread_attr;
 676
 677 extern pthread_key_t gomp_thread_destructor;
 678
 679 /* Function prototypes.  */
 680
 681 /* affinity.c */
 682
 683 extern void gomp_init_affinity (void);
 684 extern void gomp_init_thread_affinity (pthread_attr_t *, unsigned int);
 685 extern void **gomp_affinity_alloc (unsigned long, bool);
 686 extern void gomp_affinity_init_place (void *);
 687 extern bool gomp_affinity_add_cpus (void *, unsigned long, unsigned long,
 688                                     long, bool);
 689 extern bool gomp_affinity_remove_cpu (void *, unsigned long);
 690 extern bool gomp_affinity_copy_place (void *, void *, long);
 691 extern bool gomp_affinity_same_place (void *, void *);
 692 extern bool gomp_affinity_finalize_place_list (bool);
 693 extern bool gomp_affinity_init_level (int, unsigned long, bool);
 694 extern void gomp_affinity_print_place (void *);
 695 extern void gomp_get_place_proc_ids_8 (int, int64_t *);
 696
 697 /* iter.c */
 698
 699 extern int gomp_iter_static_next (long *, long *);
 700 extern bool gomp_iter_dynamic_next_locked (long *, long *);
 701 extern bool gomp_iter_guided_next_locked (long *, long *);
 702
 703 #ifdef HAVE_SYNC_BUILTINS
 704 extern bool gomp_iter_dynamic_next (long *, long *);
 705 extern bool gomp_iter_guided_next (long *, long *);
 706 #endif
 707
 708 /* iter_ull.c */
 709
 710 extern int gomp_iter_ull_static_next (unsigned long long *,
 711                                       unsigned long long *);
 712 extern bool gomp_iter_ull_dynamic_next_locked (unsigned long long *,
 713                                                unsigned long long *);
 714 extern bool gomp_iter_ull_guided_next_locked (unsigned long long *,
 715                                               unsigned long long *);
 716
 717 #if defined HAVE_SYNC_BUILTINS && defined __LP64__
 718 extern bool gomp_iter_ull_dynamic_next (unsigned long long *,
 719                                         unsigned long long *);
 720 extern bool gomp_iter_ull_guided_next (unsigned long long *,
 721                                        unsigned long long *);
 722 #endif
 723
 724 /* ordered.c */
 725
 726 extern void gomp_ordered_first (void);
 727 extern void gomp_ordered_last (void);
 728 extern void gomp_ordered_next (void);
 729 extern void gomp_ordered_static_init (void);
 730 extern void gomp_ordered_static_next (void);
 731 extern void gomp_ordered_sync (void);
 732 extern void gomp_doacross_init (unsigned, long *, long);
 733 extern void gomp_doacross_ull_init (unsigned, unsigned long long *,
 734                                     unsigned long long);
 735
 736 /* parallel.c */
 737
 738 extern unsigned gomp_resolve_num_threads (unsigned, unsigned);
 739
 740 /* proc.c (in config/) */
 741
 742 extern void gomp_init_num_threads (void);
 743 extern unsigned gomp_dynamic_max_threads (void);
 744
 745 /* task.c */
 746
 747 extern void gomp_init_task (struct gomp_task *, struct gomp_task *,
 748                             struct gomp_task_icv *);
 749 extern void gomp_end_task (void);
 750 extern void gomp_barrier_handle_tasks (gomp_barrier_state_t);
 751 extern void gomp_task_maybe_wait_for_dependencies (void **);
 752 extern bool gomp_create_target_task (struct gomp_device_descr *,
 753                                      void (*) (void *), size_t, void **,
 754                                      size_t *, unsigned short *, unsigned int,
 755                                      void **, void **,
 756                                      enum gomp_target_task_state);
 757
 758 static void inline
 759 gomp_finish_task (struct gomp_task *task)
 760 {
 761   if (__builtin_expect (task->depend_hash != NULL, 0))
 762     free (task->depend_hash);
 763 }
 764
 765 /* team.c */
 766
 767 extern struct gomp_team *gomp_new_team (unsigned);
 768 extern void gomp_team_start (void (*) (void *), void *, unsigned,
 769                              unsigned, struct gomp_team *);
 770 extern void gomp_team_end (void);
 771 extern void gomp_free_thread (void *);
 772
 773 /* target.c */
 774
 775 extern void gomp_init_targets_once (void);
 776 extern int gomp_get_num_devices (void);
 777 extern bool gomp_target_task_fn (void *);
 778
 779 /* Splay tree definitions.  */
 780 typedef struct splay_tree_node_s *splay_tree_node;
 781 typedef struct splay_tree_s *splay_tree;
 782 typedef struct splay_tree_key_s *splay_tree_key;
 783
 784 struct target_var_desc {
 785   /* Splay key.  */
 786   splay_tree_key key;
 787   /* True if data should be copied from device to host at the end.  */
 788   bool copy_from;
 789   /* True if data always should be copied from device to host at the end.  */
 790   bool always_copy_from;
 791   /* Relative offset against key host_start.  */
 792   uintptr_t offset;
 793   /* Actual length.  */
 794   uintptr_t length;
 795 };
 796
 797 struct target_mem_desc {
 798   /* Reference count.  */
 799   uintptr_t refcount;
 800   /* All the splay nodes allocated together.  */
 801   splay_tree_node array;
 802   /* Start of the target region.  */
 803   uintptr_t tgt_start;
 804   /* End of the targer region.  */
 805   uintptr_t tgt_end;
 806   /* Handle to free.  */
 807   void *to_free;
 808   /* Previous target_mem_desc.  */
 809   struct target_mem_desc *prev;
 810   /* Number of items in following list.  */
 811   size_t list_count;
 812
 813   /* Corresponding target device descriptor.  */
 814   struct gomp_device_descr *device_descr;
 815
 816   /* List of target items to remove (or decrease refcount)
 817      at the end of region.  */
 818   struct target_var_desc list[];
 819 };
 820
 821 /* Special value for refcount - infinity.  */
 822 #define REFCOUNT_INFINITY (~(uintptr_t) 0)
 823 /* Special value for refcount - tgt_offset contains target address of the
 824    artificial pointer to "omp declare target link" object.  */
 825 #define REFCOUNT_LINK (~(uintptr_t) 1)
 826
 827 struct splay_tree_key_s {
 828   /* Address of the host object.  */
 829   uintptr_t host_start;
 830   /* Address immediately after the host object.  */
 831   uintptr_t host_end;
 832   /* Descriptor of the target memory.  */
 833   struct target_mem_desc *tgt;
 834   /* Offset from tgt->tgt_start to the start of the target object.  */
 835   uintptr_t tgt_offset;
 836   /* Reference count.  */
 837   uintptr_t refcount;
 838   /* Pointer to the original mapping of "omp declare target link" object.  */
 839   splay_tree_key link_key;
 840 };
 841
 842 /* The comparison function.  */
 843
 844 static inline int
 845 splay_compare (splay_tree_key x, splay_tree_key y)
 846 {
 847   if (x->host_start == x->host_end
 848       && y->host_start == y->host_end)
 849     return 0;
 850   if (x->host_end <= y->host_start)
 851     return -1;
 852   if (x->host_start >= y->host_end)
 853     return 1;
 854   return 0;
 855 }
 856
 857 #include "splay-tree.h"
 858
 859 typedef struct acc_dispatch_t
 860 {
 861   /* This is a linked list of data mapped using the
 862      acc_map_data/acc_unmap_data or "acc enter data"/"acc exit data" pragmas.
 863      Unlike mapped_data in the goacc_thread struct, unmapping can
 864      happen out-of-order with respect to mapping.  */
 865   /* This is guarded by the lock in the "outer" struct gomp_device_descr.  */
 866   struct target_mem_desc *data_environ;
 867
 868   /* Execute.  */
 869   void (*exec_func) (void (*) (void *), size_t, void **, void **, int,
 870                      unsigned *, void *);
 871
 872   /* Async cleanup callback registration.  */
 873   void (*register_async_cleanup_func) (void *, int);
 874
 875   /* Asynchronous routines.  */
 876   int (*async_test_func) (int);
 877   int (*async_test_all_func) (void);
 878   void (*async_wait_func) (int);
 879   void (*async_wait_async_func) (int, int);
 880   void (*async_wait_all_func) (void);
 881   void (*async_wait_all_async_func) (int);
 882   void (*async_set_async_func) (int);
 883
 884   /* Create/destroy TLS data.  */
 885   void *(*create_thread_data_func) (int);
 886   void (*destroy_thread_data_func) (void *);
 887
 888   /* NVIDIA target specific routines.  */
 889   struct {
 890     void *(*get_current_device_func) (void);
 891     void *(*get_current_context_func) (void);
 892     void *(*get_stream_func) (int);
 893     int (*set_stream_func) (int, void *);
 894   } cuda;
 895 } acc_dispatch_t;
 896
 897 /* Various state of the accelerator device.  */
 898 enum gomp_device_state
 899 {
 900   GOMP_DEVICE_UNINITIALIZED,
 901   GOMP_DEVICE_INITIALIZED,
 902   GOMP_DEVICE_FINALIZED
 903 };
 904
 905 /* This structure describes accelerator device.
 906    It contains name of the corresponding libgomp plugin, function handlers for
 907    interaction with the device, ID-number of the device, and information about
 908    mapped memory.  */
 909 struct gomp_device_descr
 910 {
 911   /* Immutable data, which is only set during initialization, and which is not
 912      guarded by the lock.  */
 913
 914   /* The name of the device.  */
 915   const char *name;
 916
 917   /* Capabilities of device (supports OpenACC, OpenMP).  */
 918   unsigned int capabilities;
 919
 920   /* This is the ID number of device among devices of the same type.  */
 921   int target_id;
 922
 923   /* This is the TYPE of device.  */
 924   enum offload_target_type type;
 925
 926   /* Function handlers.  */
 927   const char *(*get_name_func) (void);
 928   unsigned int (*get_caps_func) (void);
 929   int (*get_type_func) (void);
 930   int (*get_num_devices_func) (void);
 931   bool (*init_device_func) (int);
 932   bool (*fini_device_func) (int);
 933   unsigned (*version_func) (void);
 934   int (*load_image_func) (int, unsigned, const void *, struct addr_pair **);
 935   bool (*unload_image_func) (int, unsigned, const void *);
 936   void *(*alloc_func) (int, size_t);
 937   bool (*free_func) (int, void *);
 938   bool (*dev2host_func) (int, void *, const void *, size_t);
 939   bool (*host2dev_func) (int, void *, const void *, size_t);
 940   bool (*dev2dev_func) (int, void *, const void *, size_t);
 941   bool (*can_run_func) (void *);
 942   void (*run_func) (int, void *, void *, void **);
 943   void (*async_run_func) (int, void *, void *, void **, void *);
 944
 945   /* Splay tree containing information about mapped memory regions.  */
 946   struct splay_tree_s mem_map;
 947
 948   /* Mutex for the mutable data.  */
 949   gomp_mutex_t lock;
 950
 951   /* Current state of the device.  OpenACC allows to move from INITIALIZED state
 952      back to UNINITIALIZED state.  OpenMP allows only to move from INITIALIZED
 953      to FINALIZED state (at program shutdown).  */
 954   enum gomp_device_state state;
 955
 956   /* OpenACC-specific data and functions.  */
 957   /* This is mutable because of its mutable data_environ and target_data
 958      members.  */
 959   acc_dispatch_t openacc;
 960 };
 961
 962 /* Kind of the pragma, for which gomp_map_vars () is called.  */
 963 enum gomp_map_vars_kind
 964 {
 965   GOMP_MAP_VARS_OPENACC,
 966   GOMP_MAP_VARS_TARGET,
 967   GOMP_MAP_VARS_DATA,
 968   GOMP_MAP_VARS_ENTER_DATA
 969 };
 970
 971 extern void gomp_acc_insert_pointer (size_t, void **, size_t *, void *);
 972 extern void gomp_acc_remove_pointer (void *, bool, int, int);
 973
 974 extern struct target_mem_desc *gomp_map_vars (struct gomp_device_descr *,
 975                                               size_t, void **, void **,
 976                                               size_t *, void *, bool,
 977                                               enum gomp_map_vars_kind);
 978 extern void gomp_unmap_vars (struct target_mem_desc *, bool);
 979 extern void gomp_init_device (struct gomp_device_descr *);
 980 extern void gomp_free_memmap (struct splay_tree_s *);
 981 extern void gomp_unload_device (struct gomp_device_descr *);
 982
 983 /* work.c */
 984
 985 extern void gomp_init_work_share (struct gomp_work_share *, bool, unsigned);
 986 extern void gomp_fini_work_share (struct gomp_work_share *);
 987 extern bool gomp_work_share_start (bool);
 988 extern void gomp_work_share_end (void);
 989 extern bool gomp_work_share_end_cancel (void);
 990 extern void gomp_work_share_end_nowait (void);
 991
 992 static inline void
 993 gomp_work_share_init_done (void)
 994 {
 995   struct gomp_thread *thr = gomp_thread ();
 996   if (__builtin_expect (thr->ts.last_work_share != NULL, 1))
 997     gomp_ptrlock_set (&thr->ts.last_work_share->next_ws, thr->ts.work_share);
 998 }
 999
1000 #ifdef HAVE_ATTRIBUTE_VISIBILITY
1001 # pragma GCC visibility pop
1002 #endif
1003
1004 /* Now that we're back to default visibility, include the globals.  */
1005 #include "libgomp_g.h"
1006
1007 /* Include omp.h by parts.  */
1008 #include "omp-lock.h"
1009 #define _LIBGOMP_OMP_LOCK_DEFINED 1
1010 #include "omp.h.in"
1011
1012 #if !defined (HAVE_ATTRIBUTE_VISIBILITY) \
1013     || !defined (HAVE_ATTRIBUTE_ALIAS) \
1014     || !defined (HAVE_AS_SYMVER_DIRECTIVE) \
1015     || !defined (PIC) \
1016     || !defined (HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
1017 # undef LIBGOMP_GNU_SYMBOL_VERSIONING
1018 #endif
1019
1020 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING
1021 extern void gomp_init_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
1022 extern void gomp_destroy_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
1023 extern void gomp_set_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
1024 extern void gomp_unset_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
1025 extern int gomp_test_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
1026 extern void gomp_init_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
1027 extern void gomp_destroy_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
1028 extern void gomp_set_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
1029 extern void gomp_unset_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
1030 extern int gomp_test_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
1031
1032 extern void gomp_init_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
1033 extern void gomp_destroy_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
1034 extern void gomp_set_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
1035 extern void gomp_unset_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
1036 extern int gomp_test_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
1037 extern void gomp_init_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
1038 extern void gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
1039 extern void gomp_set_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
1040 extern void gomp_unset_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
1041 extern int gomp_test_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
1042
1043 # define strong_alias(fn, al) \
1044   extern __typeof (fn) al __attribute__ ((alias (#fn)));
1045 # define omp_lock_symver(fn) \
1046   __asm (".symver g" #fn "_30, " #fn "@@OMP_3.0"); \
1047   __asm (".symver g" #fn "_25, " #fn "@OMP_1.0");
1048 #else
1049 # define gomp_init_lock_30 omp_init_lock
1050 # define gomp_destroy_lock_30 omp_destroy_lock
1051 # define gomp_set_lock_30 omp_set_lock
1052 # define gomp_unset_lock_30 omp_unset_lock
1053 # define gomp_test_lock_30 omp_test_lock
1054 # define gomp_init_nest_lock_30 omp_init_nest_lock
1055 # define gomp_destroy_nest_lock_30 omp_destroy_nest_lock
1056 # define gomp_set_nest_lock_30 omp_set_nest_lock
1057 # define gomp_unset_nest_lock_30 omp_unset_nest_lock
1058 # define gomp_test_nest_lock_30 omp_test_nest_lock
1059 #endif
1060
1061 #ifdef HAVE_ATTRIBUTE_VISIBILITY
1062 # define attribute_hidden __attribute__ ((visibility ("hidden")))
1063 #else
1064 # define attribute_hidden
1065 #endif
1066
1067 #ifdef HAVE_ATTRIBUTE_ALIAS
1068 # define ialias_ulp     ialias_str1(__USER_LABEL_PREFIX__)
1069 # define ialias_str1(x) ialias_str2(x)
1070 # define ialias_str2(x) #x
1071 # define ialias(fn) \
1072   extern __typeof (fn) gomp_ialias_##fn \
1073     __attribute__ ((alias (#fn))) attribute_hidden;
1074 # define ialias_redirect(fn) \
1075   extern __typeof (fn) fn __asm__ (ialias_ulp "gomp_ialias_" #fn) attribute_hidden;
1076 # define ialias_call(fn) gomp_ialias_ ## fn
1077 #else
1078 # define ialias(fn)
1079 # define ialias_redirect(fn)
1080 # define ialias_call(fn) fn
1081 #endif
1082
1083 /* Helper function for priority_node_to_task() and
1084    task_to_priority_node().
1085
1086    Return the offset from a task to its priority_node entry.  The
1087    priority_node entry is has a type of TYPE.  */
1088
1089 static inline size_t
1090 priority_queue_offset (enum priority_queue_type type)
1091 {
1092   return offsetof (struct gomp_task, pnode[(int) type]);
1093 }
1094
1095 /* Return the task associated with a priority NODE of type TYPE.  */
1096
1097 static inline struct gomp_task *
1098 priority_node_to_task (enum priority_queue_type type,
1099                        struct priority_node *node)
1100 {
1101   return (struct gomp_task *) ((char *) node - priority_queue_offset (type));
1102 }
1103
1104 /* Return the priority node of type TYPE for a given TASK.  */
1105
1106 static inline struct priority_node *
1107 task_to_priority_node (enum priority_queue_type type,
1108                        struct gomp_task *task)
1109 {
1110   return (struct priority_node *) ((char *) task
1111                                    + priority_queue_offset (type));
1112 }
1113 #endif /* LIBGOMP_H */