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 */ 591