libgomp/libgomp.h

   1 /* Copyright (C) 2005-2013 Free Software Foundation, Inc.
   2    Contributed by Richard Henderson <rth@redhat.com>.
   3
   4    This file is part of the GNU OpenMP Library (libgomp).
   5
   6    Libgomp is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  12    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14    more details.
  15
  16    Under Section 7 of GPL version 3, you are granted additional
  17    permissions described in the GCC Runtime Library Exception, version
  18    3.1, as published by the Free Software Foundation.
  19
  20    You should have received a copy of the GNU General Public License and
  21    a copy of the GCC Runtime Library Exception along with this program;
  22    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23    <http://www.gnu.org/licenses/>.  */
  24
  25 /* This file contains data types and function declarations that are not
  26    part of the official OpenMP user interface.  There are declarations
  27    in here that are part of the GNU OpenMP ABI, in that the compiler is
  28    required to know about them and use them.
  29
  30    The convention is that the all caps prefix "GOMP" is used group items
  31    that are part of the external ABI, and the lower case prefix "gomp"
  32    is used group items that are completely private to the library.  */
  33
  34 #ifndef LIBGOMP_H
  35 #define LIBGOMP_H 1
  36
  37 #include "config.h"
  38 #include "gstdint.h"
  39
  40 #include <pthread.h>
  41 #include <stdbool.h>
  42
  43 #ifdef HAVE_ATTRIBUTE_VISIBILITY
  44 # pragma GCC visibility push(hidden)
  45 #endif
  46
  47 /* If we were a C++ library, we'd get this from <std/atomic>.  */
  48 enum memmodel
  49 {
  50   MEMMODEL_RELAXED = 0,
  51   MEMMODEL_CONSUME = 1,
  52   MEMMODEL_ACQUIRE = 2,
  53   MEMMODEL_RELEASE = 3,
  54   MEMMODEL_ACQ_REL = 4,
  55   MEMMODEL_SEQ_CST = 5
  56 };
  57
  58 #include "sem.h"
  59 #include "mutex.h"
  60 #include "bar.h"
  61 #include "ptrlock.h"
  62
  63
  64 /* This structure contains the data to control one work-sharing construct,
  65    either a LOOP (FOR/DO) or a SECTIONS.  */
  66
  67 enum gomp_schedule_type
  68 {
  69   GFS_RUNTIME,
  70   GFS_STATIC,
  71   GFS_DYNAMIC,
  72   GFS_GUIDED,
  73   GFS_AUTO
  74 };
  75
  76 struct gomp_work_share
  77 {
  78   /* This member records the SCHEDULE clause to be used for this construct.
  79      The user specification of "runtime" will already have been resolved.
  80      If this is a SECTIONS construct, this value will always be DYNAMIC.  */
  81   enum gomp_schedule_type sched;
  82
  83   int mode;
  84
  85   union {
  86     struct {
  87       /* This is the chunk_size argument to the SCHEDULE clause.  */
  88       long chunk_size;
  89
  90       /* This is the iteration end point.  If this is a SECTIONS construct,
  91          this is the number of contained sections.  */
  92       long end;
  93
  94       /* This is the iteration step.  If this is a SECTIONS construct, this
  95          is always 1.  */
  96       long incr;
  97     };
  98
  99     struct {
 100       /* The same as above, but for the unsigned long long loop variants.  */
 101       unsigned long long chunk_size_ull;
 102       unsigned long long end_ull;
 103       unsigned long long incr_ull;
 104     };
 105   };
 106
 107   /* This is a circular queue that details which threads will be allowed
 108      into the ordered region and in which order.  When a thread allocates
 109      iterations on which it is going to work, it also registers itself at
 110      the end of the array.  When a thread reaches the ordered region, it
 111      checks to see if it is the one at the head of the queue.  If not, it
 112      blocks on its RELEASE semaphore.  */
 113   unsigned *ordered_team_ids;
 114
 115   /* This is the number of threads that have registered themselves in
 116      the circular queue ordered_team_ids.  */
 117   unsigned ordered_num_used;
 118
 119   /* This is the team_id of the currently acknowledged owner of the ordered
 120      section, or -1u if the ordered section has not been acknowledged by
 121      any thread.  This is distinguished from the thread that is *allowed*
 122      to take the section next.  */
 123   unsigned ordered_owner;
 124
 125   /* This is the index into the circular queue ordered_team_ids of the
 126      current thread that's allowed into the ordered reason.  */
 127   unsigned ordered_cur;
 128
 129   /* This is a chain of allocated gomp_work_share blocks, valid only
 130      in the first gomp_work_share struct in the block.  */
 131   struct gomp_work_share *next_alloc;
 132
 133   /* The above fields are written once during workshare initialization,
 134      or related to ordered worksharing.  Make sure the following fields
 135      are in a different cache line.  */
 136
 137   /* This lock protects the update of the following members.  */
 138   gomp_mutex_t lock __attribute__((aligned (64)));
 139
 140   /* This is the count of the number of threads that have exited the work
 141      share construct.  If the construct was marked nowait, they have moved on
 142      to other work; otherwise they're blocked on a barrier.  The last member
 143      of the team to exit the work share construct must deallocate it.  */
 144   unsigned threads_completed;
 145
 146   union {
 147     /* This is the next iteration value to be allocated.  In the case of
 148        GFS_STATIC loops, this the iteration start point and never changes.  */
 149     long next;
 150
 151     /* The same, but with unsigned long long type.  */
 152     unsigned long long next_ull;
 153
 154     /* This is the returned data structure for SINGLE COPYPRIVATE.  */
 155     void *copyprivate;
 156   };
 157
 158   union {
 159     /* Link to gomp_work_share struct for next work sharing construct
 160        encountered after this one.  */
 161     gomp_ptrlock_t next_ws;
 162
 163     /* gomp_work_share structs are chained in the free work share cache
 164        through this.  */
 165     struct gomp_work_share *next_free;
 166   };
 167
 168   /* If only few threads are in the team, ordered_team_ids can point
 169      to this array which fills the padding at the end of this struct.  */
 170   unsigned inline_ordered_team_ids[0];
 171 };
 172
 173 /* This structure contains all of the thread-local data associated with
 174    a thread team.  This is the data that must be saved when a thread
 175    encounters a nested PARALLEL construct.  */
 176
 177 struct gomp_team_state
 178 {
 179   /* This is the team of which the thread is currently a member.  */
 180   struct gomp_team *team;
 181
 182   /* This is the work share construct which this thread is currently
 183      processing.  Recall that with NOWAIT, not all threads may be
 184      processing the same construct.  */
 185   struct gomp_work_share *work_share;
 186
 187   /* This is the previous work share construct or NULL if there wasn't any.
 188      When all threads are done with the current work sharing construct,
 189      the previous one can be freed.  The current one can't, as its
 190      next_ws field is used.  */
 191   struct gomp_work_share *last_work_share;
 192
 193   /* This is the ID of this thread within the team.  This value is
 194      guaranteed to be between 0 and N-1, where N is the number of
 195      threads in the team.  */
 196   unsigned team_id;
 197
 198   /* Nesting level.  */
 199   unsigned level;
 200
 201   /* Active nesting level.  Only active parallel regions are counted.  */
 202   unsigned active_level;
 203
 204 #ifdef HAVE_SYNC_BUILTINS
 205   /* Number of single stmts encountered.  */
 206   unsigned long single_count;
 207 #endif
 208
 209   /* For GFS_RUNTIME loops that resolved to GFS_STATIC, this is the
 210      trip number through the loop.  So first time a particular loop
 211      is encountered this number is 0, the second time through the loop
 212      is 1, etc.  This is unused when the compiler knows in advance that
 213      the loop is statically scheduled.  */
 214   unsigned long static_trip;
 215 };
 216
 217 /* These are the OpenMP 3.0 Internal Control Variables described in
 218    section 2.3.1.  Those described as having one copy per task are
 219    stored within the structure; those described as having one copy
 220    for the whole program are (naturally) global variables.  */
 221
 222 struct gomp_task_icv
 223 {
 224   unsigned long nthreads_var;
 225   enum gomp_schedule_type run_sched_var;
 226   int run_sched_modifier;
 227   bool dyn_var;
 228   bool nest_var;
 229 };
 230
 231 extern struct gomp_task_icv gomp_global_icv;
 232 extern unsigned long gomp_thread_limit_var;
 233 extern unsigned long gomp_remaining_threads_count;
 234 #ifndef HAVE_SYNC_BUILTINS
 235 extern gomp_mutex_t gomp_remaining_threads_lock;
 236 #endif
 237 extern unsigned long gomp_max_active_levels_var;
 238 extern unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var;
 239 extern unsigned long gomp_available_cpus, gomp_managed_threads;
 240 extern unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len;
 241
 242 enum gomp_task_kind
 243 {
 244   GOMP_TASK_IMPLICIT,
 245   GOMP_TASK_IFFALSE,
 246   GOMP_TASK_WAITING,
 247   GOMP_TASK_TIED
 248 };
 249
 250 /* This structure describes a "task" to be run by a thread.  */
 251
 252 struct gomp_task
 253 {
 254   struct gomp_task *parent;
 255   struct gomp_task *children;
 256   struct gomp_task *next_child;
 257   struct gomp_task *prev_child;
 258   struct gomp_task *next_queue;
 259   struct gomp_task *prev_queue;
 260   struct gomp_task_icv icv;
 261   void (*fn) (void *);
 262   void *fn_data;
 263   enum gomp_task_kind kind;
 264   bool in_taskwait;
 265   bool in_tied_task;
 266   bool final_task;
 267   gomp_sem_t taskwait_sem;
 268 };
 269
 270 /* This structure describes a "team" of threads.  These are the threads
 271    that are spawned by a PARALLEL constructs, as well as the work sharing
 272    constructs that the team encounters.  */
 273
 274 struct gomp_team
 275 {
 276   /* This is the number of threads in the current team.  */
 277   unsigned nthreads;
 278
 279   /* This is number of gomp_work_share structs that have been allocated
 280      as a block last time.  */
 281   unsigned work_share_chunk;
 282
 283   /* This is the saved team state that applied to a master thread before
 284      the current thread was created.  */
 285   struct gomp_team_state prev_ts;
 286
 287   /* This semaphore should be used by the master thread instead of its
 288      "native" semaphore in the thread structure.  Required for nested
 289      parallels, as the master is a member of two teams.  */
 290   gomp_sem_t master_release;
 291
 292   /* This points to an array with pointers to the release semaphore
 293      of the threads in the team.  */
 294   gomp_sem_t **ordered_release;
 295
 296   /* List of gomp_work_share structs chained through next_free fields.
 297      This is populated and taken off only by the first thread in the
 298      team encountering a new work sharing construct, in a critical
 299      section.  */
 300   struct gomp_work_share *work_share_list_alloc;
 301
 302   /* List of gomp_work_share structs freed by free_work_share.  New
 303      entries are atomically added to the start of the list, and
 304      alloc_work_share can safely only move all but the first entry
 305      to work_share_list alloc, as free_work_share can happen concurrently
 306      with alloc_work_share.  */
 307   struct gomp_work_share *work_share_list_free;
 308
 309 #ifdef HAVE_SYNC_BUILTINS
 310   /* Number of simple single regions encountered by threads in this
 311      team.  */
 312   unsigned long single_count;
 313 #else
 314   /* Mutex protecting addition of workshares to work_share_list_free.  */
 315   gomp_mutex_t work_share_list_free_lock;
 316 #endif
 317
 318   /* This barrier is used for most synchronization of the team.  */
 319   gomp_barrier_t barrier;
 320
 321   /* Initial work shares, to avoid allocating any gomp_work_share
 322      structs in the common case.  */
 323   struct gomp_work_share work_shares[8];
 324
 325   gomp_mutex_t task_lock;
 326   struct gomp_task *task_queue;
 327   int task_count;
 328   int task_running_count;
 329
 330   /* This array contains structures for implicit tasks.  */
 331   struct gomp_task implicit_task[];
 332 };
 333
 334 /* This structure contains all data that is private to libgomp and is
 335    allocated per thread.  */
 336
 337 struct gomp_thread
 338 {
 339   /* This is the function that the thread should run upon launch.  */
 340   void (*fn) (void *data);
 341   void *data;
 342
 343   /* This is the current team state for this thread.  The ts.team member
 344      is NULL only if the thread is idle.  */
 345   struct gomp_team_state ts;
 346
 347   /* This is the task that the thread is currently executing.  */
 348   struct gomp_task *task;
 349
 350   /* This semaphore is used for ordered loops.  */
 351   gomp_sem_t release;
 352
 353   /* user pthread thread pool */
 354   struct gomp_thread_pool *thread_pool;
 355 };
 356
 357
 358 struct gomp_thread_pool
 359 {
 360   /* This array manages threads spawned from the top level, which will
 361      return to the idle loop once the current PARALLEL construct ends.  */
 362   struct gomp_thread **threads;
 363   unsigned threads_size;
 364   unsigned threads_used;
 365   struct gomp_team *last_team;
 366
 367   /* This barrier holds and releases threads waiting in threads.  */
 368   gomp_barrier_t threads_dock;
 369 };
 370
 371 /* ... and here is that TLS data.  */
 372
 373 #ifdef HAVE_TLS
 374 extern __thread struct gomp_thread gomp_tls_data;
 375 static inline struct gomp_thread *gomp_thread (void)
 376 {
 377   return &gomp_tls_data;
 378 }
 379 #else
 380 extern pthread_key_t gomp_tls_key;
 381 static inline struct gomp_thread *gomp_thread (void)
 382 {
 383   return pthread_getspecific (gomp_tls_key);
 384 }
 385 #endif
 386
 387 extern struct gomp_task_icv *gomp_new_icv (void);
 388
 389 /* Here's how to access the current copy of the ICVs.  */
 390
 391 static inline struct gomp_task_icv *gomp_icv (bool write)
 392 {
 393   struct gomp_task *task = gomp_thread ()->task;
 394   if (task)
 395     return &task->icv;
 396   else if (write)
 397     return gomp_new_icv ();
 398   else
 399     return &gomp_global_icv;
 400 }
 401
 402 /* The attributes to be used during thread creation.  */
 403 extern pthread_attr_t gomp_thread_attr;
 404
 405 /* Other variables.  */
 406
 407 extern unsigned short *gomp_cpu_affinity;
 408 extern size_t gomp_cpu_affinity_len;
 409
 410 /* Function prototypes.  */
 411
 412 /* affinity.c */
 413
 414 extern void gomp_init_affinity (void);
 415 extern void gomp_init_thread_affinity (pthread_attr_t *);
 416
 417 /* alloc.c */
 418
 419 extern void *gomp_malloc (size_t) __attribute__((malloc));
 420 extern void *gomp_malloc_cleared (size_t) __attribute__((malloc));
 421 extern void *gomp_realloc (void *, size_t);
 422
 423 /* Avoid conflicting prototypes of alloca() in system headers by using
 424    GCC's builtin alloca().  */
 425 #define gomp_alloca(x)  __builtin_alloca(x)
 426
 427 /* error.c */
 428
 429 extern void gomp_error (const char *, ...)
 430         __attribute__((format (printf, 1, 2)));
 431 extern void gomp_fatal (const char *, ...)
 432         __attribute__((noreturn, format (printf, 1, 2)));
 433
 434 /* iter.c */
 435
 436 extern int gomp_iter_static_next (long *, long *);
 437 extern bool gomp_iter_dynamic_next_locked (long *, long *);
 438 extern bool gomp_iter_guided_next_locked (long *, long *);
 439
 440 #ifdef HAVE_SYNC_BUILTINS
 441 extern bool gomp_iter_dynamic_next (long *, long *);
 442 extern bool gomp_iter_guided_next (long *, long *);
 443 #endif
 444
 445 /* iter_ull.c */
 446
 447 extern int gomp_iter_ull_static_next (unsigned long long *,
 448                                       unsigned long long *);
 449 extern bool gomp_iter_ull_dynamic_next_locked (unsigned long long *,
 450                                                unsigned long long *);
 451 extern bool gomp_iter_ull_guided_next_locked (unsigned long long *,
 452                                               unsigned long long *);
 453
 454 #if defined HAVE_SYNC_BUILTINS && defined __LP64__
 455 extern bool gomp_iter_ull_dynamic_next (unsigned long long *,
 456                                         unsigned long long *);
 457 extern bool gomp_iter_ull_guided_next (unsigned long long *,
 458                                        unsigned long long *);
 459 #endif
 460
 461 /* ordered.c */
 462
 463 extern void gomp_ordered_first (void);
 464 extern void gomp_ordered_last (void);
 465 extern void gomp_ordered_next (void);
 466 extern void gomp_ordered_static_init (void);
 467 extern void gomp_ordered_static_next (void);
 468 extern void gomp_ordered_sync (void);
 469
 470 /* parallel.c */
 471
 472 extern unsigned gomp_resolve_num_threads (unsigned, unsigned);
 473
 474 /* proc.c (in config/) */
 475
 476 extern void gomp_init_num_threads (void);
 477 extern unsigned gomp_dynamic_max_threads (void);
 478
 479 /* task.c */
 480
 481 extern void gomp_init_task (struct gomp_task *, struct gomp_task *,
 482                             struct gomp_task_icv *);
 483 extern void gomp_end_task (void);
 484 extern void gomp_barrier_handle_tasks (gomp_barrier_state_t);
 485
 486 static void inline
 487 gomp_finish_task (struct gomp_task *task)
 488 {
 489   gomp_sem_destroy (&task->taskwait_sem);
 490 }
 491
 492 /* team.c */
 493
 494 extern struct gomp_team *gomp_new_team (unsigned);
 495 extern void gomp_team_start (void (*) (void *), void *, unsigned,
 496                              struct gomp_team *);
 497 extern void gomp_team_end (void);
 498
 499 /* work.c */
 500
 501 extern void gomp_init_work_share (struct gomp_work_share *, bool, unsigned);
 502 extern void gomp_fini_work_share (struct gomp_work_share *);
 503 extern bool gomp_work_share_start (bool);
 504 extern void gomp_work_share_end (void);
 505 extern void gomp_work_share_end_nowait (void);
 506
 507 static inline void
 508 gomp_work_share_init_done (void)
 509 {
 510   struct gomp_thread *thr = gomp_thread ();
 511   if (__builtin_expect (thr->ts.last_work_share != NULL, 1))
 512     gomp_ptrlock_set (&thr->ts.last_work_share->next_ws, thr->ts.work_share);
 513 }
 514
 515 #ifdef HAVE_ATTRIBUTE_VISIBILITY
 516 # pragma GCC visibility pop
 517 #endif
 518
 519 /* Now that we're back to default visibility, include the globals.  */
 520 #include "libgomp_g.h"
 521
 522 /* Include omp.h by parts.  */
 523 #include "omp-lock.h"
 524 #define _LIBGOMP_OMP_LOCK_DEFINED 1
 525 #include "omp.h.in"
 526
 527 #if !defined (HAVE_ATTRIBUTE_VISIBILITY) \
 528     || !defined (HAVE_ATTRIBUTE_ALIAS) \
 529     || !defined (HAVE_AS_SYMVER_DIRECTIVE) \
 530     || !defined (PIC) \
 531     || !defined (HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
 532 # undef LIBGOMP_GNU_SYMBOL_VERSIONING
 533 #endif
 534
 535 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING
 536 extern void gomp_init_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
 537 extern void gomp_destroy_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
 538 extern void gomp_set_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
 539 extern void gomp_unset_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
 540 extern int gomp_test_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
 541 extern void gomp_init_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
 542 extern void gomp_destroy_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
 543 extern void gomp_set_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
 544 extern void gomp_unset_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
 545 extern int gomp_test_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
 546
 547 extern void gomp_init_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
 548 extern void gomp_destroy_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
 549 extern void gomp_set_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
 550 extern void gomp_unset_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
 551 extern int gomp_test_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
 552 extern void gomp_init_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
 553 extern void gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
 554 extern void gomp_set_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
 555 extern void gomp_unset_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
 556 extern int gomp_test_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
 557
 558 # define strong_alias(fn, al) \
 559   extern __typeof (fn) al __attribute__ ((alias (#fn)));
 560 # define omp_lock_symver(fn) \
 561   __asm (".symver g" #fn "_30, " #fn "@@OMP_3.0"); \
 562   __asm (".symver g" #fn "_25, " #fn "@OMP_1.0");
 563 #else
 564 # define gomp_init_lock_30 omp_init_lock
 565 # define gomp_destroy_lock_30 omp_destroy_lock
 566 # define gomp_set_lock_30 omp_set_lock
 567 # define gomp_unset_lock_30 omp_unset_lock
 568 # define gomp_test_lock_30 omp_test_lock
 569 # define gomp_init_nest_lock_30 omp_init_nest_lock
 570 # define gomp_destroy_nest_lock_30 omp_destroy_nest_lock
 571 # define gomp_set_nest_lock_30 omp_set_nest_lock
 572 # define gomp_unset_nest_lock_30 omp_unset_nest_lock
 573 # define gomp_test_nest_lock_30 omp_test_nest_lock
 574 #endif
 575
 576 #ifdef HAVE_ATTRIBUTE_VISIBILITY
 577 # define attribute_hidden __attribute__ ((visibility ("hidden")))
 578 #else
 579 # define attribute_hidden
 580 #endif
 581
 582 #ifdef HAVE_ATTRIBUTE_ALIAS
 583 # define ialias(fn) \
 584   extern __typeof (fn) gomp_ialias_##fn \
 585     __attribute__ ((alias (#fn))) attribute_hidden;
 586 #else
 587 # define ialias(fn)
 588 #endif
 589
 590 #endif /* LIBGOMP_H */