1 /* Copyright (C) 2005-2021 Free Software Foundation, Inc.
2 Contributed by Richard Henderson <rth@redhat.com>.
4 This file is part of the GNU Offloading and Multi Processing Library
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)
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
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.
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/>. */
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
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. */
39 #ifndef _LIBGOMP_CHECKING_
40 /* Define to 1 to perform internal sanity checks. */
41 #define _LIBGOMP_CHECKING_ 0
46 #include "libgomp-plugin.h"
47 #include "gomp-constants.h"
56 /* Needed for memset in priority_queue.c. */
57 #if _LIBGOMP_CHECKING_
58 # ifdef STRING_WITH_STRINGS
65 # ifdef HAVE_STRINGS_H
72 #ifdef HAVE_ATTRIBUTE_VISIBILITY
73 # pragma GCC visibility push(hidden)
76 /* If we were a C++ library, we'd get this from <std/atomic>. */
89 #if defined(HAVE_ALIGNED_ALLOC) \
90 || defined(HAVE__ALIGNED_MALLOC) \
91 || defined(HAVE_POSIX_MEMALIGN) \
92 || defined(HAVE_MEMALIGN)
93 /* Defined if gomp_aligned_alloc doesn't use fallback version
94 and free can be used instead of gomp_aligned_free. */
95 #define GOMP_HAVE_EFFICIENT_ALIGNED_ALLOC 1
98 extern void *gomp_malloc (size_t) __attribute__((malloc
));
99 extern void *gomp_malloc_cleared (size_t) __attribute__((malloc
));
100 extern void *gomp_realloc (void *, size_t);
101 extern void *gomp_aligned_alloc (size_t, size_t)
102 __attribute__((malloc
, alloc_size (2)));
103 extern void gomp_aligned_free (void *);
105 /* Avoid conflicting prototypes of alloca() in system headers by using
106 GCC's builtin alloca(). */
107 #define gomp_alloca(x) __builtin_alloca(x)
109 /* Optimized allocators for team-specific data that will die with the team. */
112 /* The arena is initialized in config/gcn/team.c. */
113 #define TEAM_ARENA_SIZE 64*1024 /* Must match the value in plugin-gcn.c. */
114 #define TEAM_ARENA_START 16 /* LDS offset of free pointer. */
115 #define TEAM_ARENA_FREE 24 /* LDS offset of free pointer. */
116 #define TEAM_ARENA_END 32 /* LDS offset of end pointer. */
118 static inline void * __attribute__((malloc
))
119 team_malloc (size_t size
)
121 /* 4-byte align the size. */
122 size
= (size
+ 3) & ~3;
124 /* Allocate directly from the arena.
125 The compiler does not support DS atomics, yet. */
127 asm ("ds_add_rtn_u64 %0, %1, %2\n\ts_waitcnt 0"
128 : "=v"(result
) : "v"(TEAM_ARENA_FREE
), "v"(size
), "e"(1L) : "memory");
131 if (result
+ size
> *(void * __lds
*)TEAM_ARENA_END
)
133 /* While this is experimental, let's make sure we know when OOM
135 const char msg
[] = "GCN team arena exhausted\n";
136 write (2, msg
, sizeof(msg
)-1);
138 /* Fall back to using the heap (slowly). */
139 result
= gomp_malloc (size
);
144 static inline void * __attribute__((malloc
))
145 team_malloc_cleared (size_t size
)
147 char *result
= team_malloc (size
);
149 /* Clear the allocated memory. */
150 __builtin_memset (result
, 0, size
);
156 team_free (void *ptr
)
158 /* The whole arena is freed when the kernel exits.
159 However, if we fell back to using heap then we should free it.
160 It would be better if this function could be a no-op, but at least
161 LDS loads are cheap. */
162 if (ptr
< *(void * __lds
*)TEAM_ARENA_START
163 || ptr
>= *(void * __lds
*)TEAM_ARENA_END
)
167 #define team_malloc(...) gomp_malloc (__VA_ARGS__)
168 #define team_malloc_cleared(...) gomp_malloc_cleared (__VA_ARGS__)
169 #define team_free(...) free (__VA_ARGS__)
174 extern void gomp_vdebug (int, const char *, va_list);
175 extern void gomp_debug (int, const char *, ...)
176 __attribute__ ((format (printf
, 2, 3)));
177 #define gomp_vdebug(KIND, FMT, VALIST) \
179 if (__builtin_expect (gomp_debug_var, 0)) \
180 (gomp_vdebug) ((KIND), (FMT), (VALIST)); \
182 #define gomp_debug(KIND, ...) \
184 if (__builtin_expect (gomp_debug_var, 0)) \
185 (gomp_debug) ((KIND), __VA_ARGS__); \
187 extern void gomp_verror (const char *, va_list);
188 extern void gomp_error (const char *, ...)
189 __attribute__ ((format (printf
, 1, 2)));
190 extern void gomp_vfatal (const char *, va_list)
191 __attribute__ ((noreturn
));
192 extern void gomp_fatal (const char *, ...)
193 __attribute__ ((noreturn
, format (printf
, 1, 2)));
196 struct gomp_taskgroup
;
199 #include "priority_queue.h"
203 #include "simple-bar.h"
207 /* This structure contains the data to control one work-sharing construct,
208 either a LOOP (FOR/DO) or a SECTIONS. */
210 enum gomp_schedule_type
217 GFS_MONOTONIC
= 0x80000000U
220 struct gomp_doacross_work_share
223 /* chunk_size copy, as ws->chunk_size is multiplied by incr for
226 /* Likewise, but for ull implementation. */
227 unsigned long long chunk_size_ull
;
228 /* For schedule(static,0) this is the number
229 of iterations assigned to the last thread, i.e. number of
230 iterations / number of threads. */
232 /* Likewise, but for ull implementation. */
233 unsigned long long q_ull
;
235 /* Size of each array entry (padded to cache line size). */
236 unsigned long elt_sz
;
237 /* Number of dimensions in sink vectors. */
238 unsigned int ncounts
;
239 /* True if the iterations can be flattened. */
241 /* Actual array (of elt_sz sized units), aligned to cache line size.
242 This is indexed by team_id for GFS_STATIC and outermost iteration
243 / chunk_size for other schedules. */
244 unsigned char *array
;
245 /* These two are only used for schedule(static,0). */
246 /* This one is number of iterations % number of threads. */
249 /* And this one is cached t * (q + 1). */
251 /* Likewise, but for the ull implementation. */
252 unsigned long long boundary_ull
;
254 /* Pointer to extra memory if needed for lastprivate(conditional). */
256 /* Array of shift counts for each dimension if they can be flattened. */
257 unsigned int shift_counts
[];
260 struct gomp_work_share
262 /* This member records the SCHEDULE clause to be used for this construct.
263 The user specification of "runtime" will already have been resolved.
264 If this is a SECTIONS construct, this value will always be DYNAMIC. */
265 enum gomp_schedule_type sched
;
271 /* This is the chunk_size argument to the SCHEDULE clause. */
274 /* This is the iteration end point. If this is a SECTIONS construct,
275 this is the number of contained sections. */
278 /* This is the iteration step. If this is a SECTIONS construct, this
284 /* The same as above, but for the unsigned long long loop variants. */
285 unsigned long long chunk_size_ull
;
286 unsigned long long end_ull
;
287 unsigned long long incr_ull
;
292 /* This is a circular queue that details which threads will be allowed
293 into the ordered region and in which order. When a thread allocates
294 iterations on which it is going to work, it also registers itself at
295 the end of the array. When a thread reaches the ordered region, it
296 checks to see if it is the one at the head of the queue. If not, it
297 blocks on its RELEASE semaphore. */
298 unsigned *ordered_team_ids
;
300 /* This is a pointer to DOACROSS work share data. */
301 struct gomp_doacross_work_share
*doacross
;
304 /* This is the number of threads that have registered themselves in
305 the circular queue ordered_team_ids. */
306 unsigned ordered_num_used
;
308 /* This is the team_id of the currently acknowledged owner of the ordered
309 section, or -1u if the ordered section has not been acknowledged by
310 any thread. This is distinguished from the thread that is *allowed*
311 to take the section next. */
312 unsigned ordered_owner
;
314 /* This is the index into the circular queue ordered_team_ids of the
315 current thread that's allowed into the ordered reason. */
316 unsigned ordered_cur
;
318 /* This is a chain of allocated gomp_work_share blocks, valid only
319 in the first gomp_work_share struct in the block. */
320 struct gomp_work_share
*next_alloc
;
322 /* The above fields are written once during workshare initialization,
323 or related to ordered worksharing. Make sure the following fields
324 are in a different cache line. */
326 /* This lock protects the update of the following members. */
327 gomp_mutex_t lock
__attribute__((aligned (64)));
329 /* This is the count of the number of threads that have exited the work
330 share construct. If the construct was marked nowait, they have moved on
331 to other work; otherwise they're blocked on a barrier. The last member
332 of the team to exit the work share construct must deallocate it. */
333 unsigned threads_completed
;
336 /* This is the next iteration value to be allocated. In the case of
337 GFS_STATIC loops, this the iteration start point and never changes. */
340 /* The same, but with unsigned long long type. */
341 unsigned long long next_ull
;
343 /* This is the returned data structure for SINGLE COPYPRIVATE. */
348 /* Link to gomp_work_share struct for next work sharing construct
349 encountered after this one. */
350 gomp_ptrlock_t next_ws
;
352 /* gomp_work_share structs are chained in the free work share cache
354 struct gomp_work_share
*next_free
;
357 /* Task reductions for this work-sharing construct. */
358 uintptr_t *task_reductions
;
360 /* If only few threads are in the team, ordered_team_ids can point
361 to this array which fills the padding at the end of this struct. */
362 unsigned inline_ordered_team_ids
[0];
365 /* This structure contains all of the thread-local data associated with
366 a thread team. This is the data that must be saved when a thread
367 encounters a nested PARALLEL construct. */
369 struct gomp_team_state
371 /* This is the team of which the thread is currently a member. */
372 struct gomp_team
*team
;
374 /* This is the work share construct which this thread is currently
375 processing. Recall that with NOWAIT, not all threads may be
376 processing the same construct. */
377 struct gomp_work_share
*work_share
;
379 /* This is the previous work share construct or NULL if there wasn't any.
380 When all threads are done with the current work sharing construct,
381 the previous one can be freed. The current one can't, as its
382 next_ws field is used. */
383 struct gomp_work_share
*last_work_share
;
385 /* This is the ID of this thread within the team. This value is
386 guaranteed to be between 0 and N-1, where N is the number of
387 threads in the team. */
393 /* Active nesting level. Only active parallel regions are counted. */
394 unsigned active_level
;
396 /* Place-partition-var, offset and length into gomp_places_list array. */
397 unsigned place_partition_off
;
398 unsigned place_partition_len
;
400 /* Def-allocator-var ICV. */
401 uintptr_t def_allocator
;
403 #ifdef HAVE_SYNC_BUILTINS
404 /* Number of single stmts encountered. */
405 unsigned long single_count
;
408 /* For GFS_RUNTIME loops that resolved to GFS_STATIC, this is the
409 trip number through the loop. So first time a particular loop
410 is encountered this number is 0, the second time through the loop
411 is 1, etc. This is unused when the compiler knows in advance that
412 the loop is statically scheduled. */
413 unsigned long static_trip
;
416 struct target_mem_desc
;
418 /* These are the OpenMP 4.0 Internal Control Variables described in
419 section 2.3.1. Those described as having one copy per task are
420 stored within the structure; those described as having one copy
421 for the whole program are (naturally) global variables. */
425 unsigned long nthreads_var
;
426 enum gomp_schedule_type run_sched_var
;
427 int run_sched_chunk_size
;
428 int default_device_var
;
429 unsigned int thread_limit_var
;
431 unsigned char max_active_levels_var
;
434 struct target_mem_desc
*target_data
;
437 enum gomp_target_offload_t
439 GOMP_TARGET_OFFLOAD_DEFAULT
,
440 GOMP_TARGET_OFFLOAD_MANDATORY
,
441 GOMP_TARGET_OFFLOAD_DISABLED
444 #define gomp_supported_active_levels UCHAR_MAX
446 extern struct gomp_task_icv gomp_global_icv
;
447 #ifndef HAVE_SYNC_BUILTINS
448 extern gomp_mutex_t gomp_managed_threads_lock
;
450 extern bool gomp_cancel_var
;
451 extern enum gomp_target_offload_t gomp_target_offload_var
;
452 extern int gomp_max_task_priority_var
;
453 extern unsigned long long gomp_spin_count_var
, gomp_throttled_spin_count_var
;
454 extern unsigned long gomp_available_cpus
, gomp_managed_threads
;
455 extern unsigned long *gomp_nthreads_var_list
, gomp_nthreads_var_list_len
;
456 extern char *gomp_bind_var_list
;
457 extern unsigned long gomp_bind_var_list_len
;
458 extern void **gomp_places_list
;
459 extern unsigned long gomp_places_list_len
;
460 extern unsigned int gomp_num_teams_var
;
461 extern int gomp_debug_var
;
462 extern bool gomp_display_affinity_var
;
463 extern char *gomp_affinity_format_var
;
464 extern size_t gomp_affinity_format_len
;
465 extern uintptr_t gomp_def_allocator
;
466 extern int goacc_device_num
;
467 extern char *goacc_device_type
;
468 extern int goacc_default_dims
[GOMP_DIM_MAX
];
474 /* Undeferred task. */
475 GOMP_TASK_UNDEFERRED
,
476 /* Task created by GOMP_task and waiting to be run. */
478 /* Task currently executing or scheduled and about to execute. */
480 /* Used for target tasks that have vars mapped and async run started,
481 but not yet completed. Once that completes, they will be readded
482 into the queues as GOMP_TASK_WAITING in order to perform the var
484 GOMP_TASK_ASYNC_RUNNING
487 struct gomp_task_depend_entry
489 /* Address of dependency. */
491 struct gomp_task_depend_entry
*next
;
492 struct gomp_task_depend_entry
*prev
;
493 /* Task that provides the dependency in ADDR. */
494 struct gomp_task
*task
;
495 /* Depend entry is of type "IN". */
501 struct gomp_dependers_vec
505 struct gomp_task
*elem
[];
508 /* Used when in GOMP_taskwait or in gomp_task_maybe_wait_for_dependencies. */
514 /* Number of tasks we are waiting for. */
516 gomp_sem_t taskwait_sem
;
519 /* This structure describes a "task" to be run by a thread. */
523 /* Parent of this task. */
524 struct gomp_task
*parent
;
525 /* Children of this task. */
526 struct priority_queue children_queue
;
527 /* Taskgroup this task belongs in. */
528 struct gomp_taskgroup
*taskgroup
;
529 /* Tasks that depend on this task. */
530 struct gomp_dependers_vec
*dependers
;
531 struct htab
*depend_hash
;
532 struct gomp_taskwait
*taskwait
;
533 /* Number of items in DEPEND. */
535 /* Number of tasks this task depends on. Once this counter reaches
536 0, we have no unsatisfied dependencies, and this task can be put
537 into the various queues to be scheduled. */
538 size_t num_dependees
;
540 /* Priority of this task. */
542 /* The priority node for this task in each of the different queues.
543 We put this here to avoid allocating space for each priority
544 node. Then we play offsetof() games to convert between pnode[]
545 entries and the gomp_task in which they reside. */
546 struct priority_node pnode
[3];
549 gomp_sem_t completion_sem
;
551 struct gomp_task_icv icv
;
554 enum gomp_task_kind kind
;
557 bool copy_ctors_done
;
558 /* Set for undeferred tasks with unsatisfied dependencies which
559 block further execution of their parent until the dependencies
561 bool parent_depends_on
;
562 /* Dependencies provided and/or needed for this task. DEPEND_COUNT
563 is the number of items available. */
564 struct gomp_task_depend_entry depend
[];
567 /* This structure describes a single #pragma omp taskgroup. */
569 struct gomp_taskgroup
571 struct gomp_taskgroup
*prev
;
572 /* Queue of tasks that belong in this taskgroup. */
573 struct priority_queue taskgroup_queue
;
574 uintptr_t *reductions
;
575 bool in_taskgroup_wait
;
578 gomp_sem_t taskgroup_sem
;
582 /* Various state of OpenMP async offloading tasks. */
583 enum gomp_target_task_state
585 GOMP_TARGET_TASK_DATA
,
586 GOMP_TARGET_TASK_BEFORE_MAP
,
587 GOMP_TARGET_TASK_FALLBACK
,
588 GOMP_TARGET_TASK_READY_TO_RUN
,
589 GOMP_TARGET_TASK_RUNNING
,
590 GOMP_TARGET_TASK_FINISHED
593 /* This structure describes a target task. */
595 struct gomp_target_task
597 struct gomp_device_descr
*devicep
;
601 unsigned short *kinds
;
603 enum gomp_target_task_state state
;
604 struct target_mem_desc
*tgt
;
605 struct gomp_task
*task
;
606 struct gomp_team
*team
;
607 /* Device-specific target arguments. */
612 /* This structure describes a "team" of threads. These are the threads
613 that are spawned by a PARALLEL constructs, as well as the work sharing
614 constructs that the team encounters. */
618 /* This is the number of threads in the current team. */
621 /* This is number of gomp_work_share structs that have been allocated
622 as a block last time. */
623 unsigned work_share_chunk
;
625 /* This is the saved team state that applied to a master thread before
626 the current thread was created. */
627 struct gomp_team_state prev_ts
;
629 /* This semaphore should be used by the master thread instead of its
630 "native" semaphore in the thread structure. Required for nested
631 parallels, as the master is a member of two teams. */
632 gomp_sem_t master_release
;
634 /* This points to an array with pointers to the release semaphore
635 of the threads in the team. */
636 gomp_sem_t
**ordered_release
;
638 /* List of work shares on which gomp_fini_work_share hasn't been
639 called yet. If the team hasn't been cancelled, this should be
640 equal to each thr->ts.work_share, but otherwise it can be a possibly
641 long list of workshares. */
642 struct gomp_work_share
*work_shares_to_free
;
644 /* List of gomp_work_share structs chained through next_free fields.
645 This is populated and taken off only by the first thread in the
646 team encountering a new work sharing construct, in a critical
648 struct gomp_work_share
*work_share_list_alloc
;
650 /* List of gomp_work_share structs freed by free_work_share. New
651 entries are atomically added to the start of the list, and
652 alloc_work_share can safely only move all but the first entry
653 to work_share_list alloc, as free_work_share can happen concurrently
654 with alloc_work_share. */
655 struct gomp_work_share
*work_share_list_free
;
657 #ifdef HAVE_SYNC_BUILTINS
658 /* Number of simple single regions encountered by threads in this
660 unsigned long single_count
;
662 /* Mutex protecting addition of workshares to work_share_list_free. */
663 gomp_mutex_t work_share_list_free_lock
;
666 /* This barrier is used for most synchronization of the team. */
667 gomp_barrier_t barrier
;
669 /* Initial work shares, to avoid allocating any gomp_work_share
670 structs in the common case. */
671 struct gomp_work_share work_shares
[8];
673 gomp_mutex_t task_lock
;
674 /* Scheduled tasks. */
675 struct priority_queue task_queue
;
676 /* Number of all GOMP_TASK_{WAITING,TIED} tasks in the team. */
677 unsigned int task_count
;
678 /* Number of GOMP_TASK_WAITING tasks currently waiting to be scheduled. */
679 unsigned int task_queued_count
;
680 /* Number of GOMP_TASK_{WAITING,TIED} tasks currently running
681 directly in gomp_barrier_handle_tasks; tasks spawned
682 from e.g. GOMP_taskwait or GOMP_taskgroup_end don't count, even when
683 that is called from a task run from gomp_barrier_handle_tasks.
684 task_running_count should be always <= team->nthreads,
685 and if current task isn't in_tied_task, then it will be
686 even < team->nthreads. */
687 unsigned int task_running_count
;
688 int work_share_cancelled
;
691 /* Tasks waiting for their completion event to be fulfilled. */
692 struct priority_queue task_detach_queue
;
693 unsigned int task_detach_count
;
695 /* This array contains structures for implicit tasks. */
696 struct gomp_task implicit_task
[];
699 /* This structure contains all data that is private to libgomp and is
700 allocated per thread. */
704 /* This is the function that the thread should run upon launch. */
705 void (*fn
) (void *data
);
708 /* This is the current team state for this thread. The ts.team member
709 is NULL only if the thread is idle. */
710 struct gomp_team_state ts
;
712 /* This is the task that the thread is currently executing. */
713 struct gomp_task
*task
;
715 /* This semaphore is used for ordered loops. */
718 /* Place this thread is bound to plus one, or zero if not bound
722 /* User pthread thread pool */
723 struct gomp_thread_pool
*thread_pool
;
725 #if defined(LIBGOMP_USE_PTHREADS) \
726 && (!defined(HAVE_TLS) \
727 || !defined(__GLIBC__) \
728 || !defined(USING_INITIAL_EXEC_TLS))
729 /* pthread_t of the thread containing this gomp_thread.
730 On Linux when using initial-exec TLS,
731 (typeof (pthread_t)) gomp_thread () - pthread_self ()
732 is constant in all threads, so we can optimize and not
734 #define GOMP_NEEDS_THREAD_HANDLE 1
740 struct gomp_thread_pool
742 /* This array manages threads spawned from the top level, which will
743 return to the idle loop once the current PARALLEL construct ends. */
744 struct gomp_thread
**threads
;
745 unsigned threads_size
;
746 unsigned threads_used
;
747 /* The last team is used for non-nested teams to delay their destruction to
748 make sure all the threads in the team move on to the pool's barrier before
749 the team's barrier is destroyed. */
750 struct gomp_team
*last_team
;
751 /* Number of threads running in this contention group. */
752 unsigned long threads_busy
;
754 /* This barrier holds and releases threads waiting in thread pools. */
755 gomp_simple_barrier_t threads_dock
;
758 enum gomp_cancel_kind
760 GOMP_CANCEL_PARALLEL
= 1,
761 GOMP_CANCEL_LOOP
= 2,
762 GOMP_CANCEL_FOR
= GOMP_CANCEL_LOOP
,
763 GOMP_CANCEL_DO
= GOMP_CANCEL_LOOP
,
764 GOMP_CANCEL_SECTIONS
= 4,
765 GOMP_CANCEL_TASKGROUP
= 8
768 /* ... and here is that TLS data. */
770 #if defined __nvptx__
771 extern struct gomp_thread
*nvptx_thrs
__attribute__((shared
));
772 static inline struct gomp_thread
*gomp_thread (void)
775 asm ("mov.u32 %0, %%tid.y;" : "=r" (tid
));
776 return nvptx_thrs
+ tid
;
778 #elif defined __AMDGCN__
779 static inline struct gomp_thread
*gcn_thrs (void)
781 /* The value is at the bottom of LDS. */
782 struct gomp_thread
* __lds
*thrs
= (struct gomp_thread
* __lds
*)4;
785 static inline void set_gcn_thrs (struct gomp_thread
*val
)
787 /* The value is at the bottom of LDS. */
788 struct gomp_thread
* __lds
*thrs
= (struct gomp_thread
* __lds
*)4;
791 static inline struct gomp_thread
*gomp_thread (void)
793 int tid
= __builtin_gcn_dim_pos(1);
794 return gcn_thrs () + tid
;
796 #elif defined HAVE_TLS || defined USE_EMUTLS
797 extern __thread
struct gomp_thread gomp_tls_data
;
798 static inline struct gomp_thread
*gomp_thread (void)
800 return &gomp_tls_data
;
803 extern pthread_key_t gomp_tls_key
;
804 static inline struct gomp_thread
*gomp_thread (void)
806 return pthread_getspecific (gomp_tls_key
);
810 extern struct gomp_task_icv
*gomp_new_icv (void);
812 /* Here's how to access the current copy of the ICVs. */
814 static inline struct gomp_task_icv
*gomp_icv (bool write
)
816 struct gomp_task
*task
= gomp_thread ()->task
;
820 return gomp_new_icv ();
822 return &gomp_global_icv
;
825 #ifdef LIBGOMP_USE_PTHREADS
826 /* The attributes to be used during thread creation. */
827 extern pthread_attr_t gomp_thread_attr
;
829 extern pthread_key_t gomp_thread_destructor
;
832 /* Function prototypes. */
836 extern void gomp_init_affinity (void);
837 #ifdef LIBGOMP_USE_PTHREADS
838 extern void gomp_init_thread_affinity (pthread_attr_t
*, unsigned int);
840 extern void **gomp_affinity_alloc (unsigned long, bool);
841 extern void gomp_affinity_init_place (void *);
842 extern bool gomp_affinity_add_cpus (void *, unsigned long, unsigned long,
844 extern bool gomp_affinity_remove_cpu (void *, unsigned long);
845 extern bool gomp_affinity_copy_place (void *, void *, long);
846 extern bool gomp_affinity_same_place (void *, void *);
847 extern bool gomp_affinity_finalize_place_list (bool);
848 extern bool gomp_affinity_init_level (int, unsigned long, bool);
849 extern void gomp_affinity_print_place (void *);
850 extern void gomp_get_place_proc_ids_8 (int, int64_t *);
851 extern void gomp_display_affinity_place (char *, size_t, size_t *, int);
855 extern bool gomp_print_string (const char *str
, size_t len
);
856 extern void gomp_set_affinity_format (const char *, size_t);
857 extern void gomp_display_string (char *, size_t, size_t *, const char *,
859 #ifdef LIBGOMP_USE_PTHREADS
860 typedef pthread_t gomp_thread_handle
;
862 typedef struct {} gomp_thread_handle
;
864 extern size_t gomp_display_affinity (char *, size_t, const char *,
866 struct gomp_team_state
*, unsigned int);
867 extern void gomp_display_affinity_thread (gomp_thread_handle
,
868 struct gomp_team_state
*,
869 unsigned int) __attribute__((cold
));
873 extern int gomp_iter_static_next (long *, long *);
874 extern bool gomp_iter_dynamic_next_locked (long *, long *);
875 extern bool gomp_iter_guided_next_locked (long *, long *);
877 #ifdef HAVE_SYNC_BUILTINS
878 extern bool gomp_iter_dynamic_next (long *, long *);
879 extern bool gomp_iter_guided_next (long *, long *);
884 extern int gomp_iter_ull_static_next (unsigned long long *,
885 unsigned long long *);
886 extern bool gomp_iter_ull_dynamic_next_locked (unsigned long long *,
887 unsigned long long *);
888 extern bool gomp_iter_ull_guided_next_locked (unsigned long long *,
889 unsigned long long *);
891 #if defined HAVE_SYNC_BUILTINS && defined __LP64__
892 extern bool gomp_iter_ull_dynamic_next (unsigned long long *,
893 unsigned long long *);
894 extern bool gomp_iter_ull_guided_next (unsigned long long *,
895 unsigned long long *);
900 extern void gomp_ordered_first (void);
901 extern void gomp_ordered_last (void);
902 extern void gomp_ordered_next (void);
903 extern void gomp_ordered_static_init (void);
904 extern void gomp_ordered_static_next (void);
905 extern void gomp_ordered_sync (void);
906 extern void gomp_doacross_init (unsigned, long *, long, size_t);
907 extern void gomp_doacross_ull_init (unsigned, unsigned long long *,
908 unsigned long long, size_t);
912 extern unsigned gomp_resolve_num_threads (unsigned, unsigned);
914 /* proc.c (in config/) */
916 extern void gomp_init_num_threads (void);
917 extern unsigned gomp_dynamic_max_threads (void);
921 extern void gomp_init_task (struct gomp_task
*, struct gomp_task
*,
922 struct gomp_task_icv
*);
923 extern void gomp_end_task (void);
924 extern void gomp_barrier_handle_tasks (gomp_barrier_state_t
);
925 extern void gomp_task_maybe_wait_for_dependencies (void **);
926 extern bool gomp_create_target_task (struct gomp_device_descr
*,
927 void (*) (void *), size_t, void **,
928 size_t *, unsigned short *, unsigned int,
930 enum gomp_target_task_state
);
931 extern struct gomp_taskgroup
*gomp_parallel_reduction_register (uintptr_t *,
933 extern void gomp_workshare_taskgroup_start (void);
934 extern void gomp_workshare_task_reduction_register (uintptr_t *, uintptr_t *);
937 gomp_finish_task (struct gomp_task
*task
)
939 if (__builtin_expect (task
->depend_hash
!= NULL
, 0))
940 free (task
->depend_hash
);
945 extern struct gomp_team
*gomp_new_team (unsigned);
946 extern void gomp_team_start (void (*) (void *), void *, unsigned,
947 unsigned, struct gomp_team
*,
948 struct gomp_taskgroup
*);
949 extern void gomp_team_end (void);
950 extern void gomp_free_thread (void *);
951 extern int gomp_pause_host (void);
955 extern void gomp_init_targets_once (void);
956 extern int gomp_get_num_devices (void);
957 extern bool gomp_target_task_fn (void *);
959 /* Splay tree definitions. */
960 typedef struct splay_tree_node_s
*splay_tree_node
;
961 typedef struct splay_tree_s
*splay_tree
;
962 typedef struct splay_tree_key_s
*splay_tree_key
;
964 struct target_var_desc
{
967 /* True if data should be copied from device to host at the end. */
969 /* True if data always should be copied from device to host at the end. */
970 bool always_copy_from
;
971 /* True if this is for OpenACC 'attach'. */
973 /* If GOMP_MAP_TO_PSET had a NULL pointer; used for Fortran descriptors,
974 which were initially unallocated. */
975 bool has_null_ptr_assoc
;
976 /* Relative offset against key host_start. */
982 struct target_mem_desc
{
983 /* Reference count. */
985 /* All the splay nodes allocated together. */
986 splay_tree_node array
;
987 /* Start of the target region. */
989 /* End of the targer region. */
991 /* Handle to free. */
993 /* Previous target_mem_desc. */
994 struct target_mem_desc
*prev
;
995 /* Number of items in following list. */
998 /* Corresponding target device descriptor. */
999 struct gomp_device_descr
*device_descr
;
1001 /* List of target items to remove (or decrease refcount)
1002 at the end of region. */
1003 struct target_var_desc list
[];
1006 /* Special value for refcount - infinity. */
1007 #define REFCOUNT_INFINITY (~(uintptr_t) 0)
1008 /* Special value for refcount - tgt_offset contains target address of the
1009 artificial pointer to "omp declare target link" object. */
1010 #define REFCOUNT_LINK (~(uintptr_t) 1)
1012 /* Special offset values. */
1013 #define OFFSET_INLINED (~(uintptr_t) 0)
1014 #define OFFSET_POINTER (~(uintptr_t) 1)
1015 #define OFFSET_STRUCT (~(uintptr_t) 2)
1017 /* Auxiliary structure for infrequently-used or API-specific data. */
1019 struct splay_tree_aux
{
1020 /* Pointer to the original mapping of "omp declare target link" object. */
1021 splay_tree_key link_key
;
1022 /* For a block with attached pointers, the attachment counters for each.
1023 Only used for OpenACC. */
1024 uintptr_t *attach_count
;
1027 struct splay_tree_key_s
{
1028 /* Address of the host object. */
1029 uintptr_t host_start
;
1030 /* Address immediately after the host object. */
1032 /* Descriptor of the target memory. */
1033 struct target_mem_desc
*tgt
;
1034 /* Offset from tgt->tgt_start to the start of the target object. */
1035 uintptr_t tgt_offset
;
1036 /* Reference count. */
1038 /* Dynamic reference count. */
1039 uintptr_t dynamic_refcount
;
1040 struct splay_tree_aux
*aux
;
1043 /* The comparison function. */
1046 splay_compare (splay_tree_key x
, splay_tree_key y
)
1048 if (x
->host_start
== x
->host_end
1049 && y
->host_start
== y
->host_end
)
1051 if (x
->host_end
<= y
->host_start
)
1053 if (x
->host_start
>= y
->host_end
)
1058 #include "splay-tree.h"
1060 typedef struct acc_dispatch_t
1063 __typeof (GOMP_OFFLOAD_openacc_exec
) *exec_func
;
1065 /* Create/destroy TLS data. */
1066 __typeof (GOMP_OFFLOAD_openacc_create_thread_data
) *create_thread_data_func
;
1067 __typeof (GOMP_OFFLOAD_openacc_destroy_thread_data
)
1068 *destroy_thread_data_func
;
1071 /* Once created and put into the "active" list, asyncqueues are then never
1072 destructed and removed from the "active" list, other than if the TODO
1073 device is shut down. */
1076 struct goacc_asyncqueue
**asyncqueue
;
1077 struct goacc_asyncqueue_list
*active
;
1079 __typeof (GOMP_OFFLOAD_openacc_async_construct
) *construct_func
;
1080 __typeof (GOMP_OFFLOAD_openacc_async_destruct
) *destruct_func
;
1081 __typeof (GOMP_OFFLOAD_openacc_async_test
) *test_func
;
1082 __typeof (GOMP_OFFLOAD_openacc_async_synchronize
) *synchronize_func
;
1083 __typeof (GOMP_OFFLOAD_openacc_async_serialize
) *serialize_func
;
1084 __typeof (GOMP_OFFLOAD_openacc_async_queue_callback
) *queue_callback_func
;
1086 __typeof (GOMP_OFFLOAD_openacc_async_exec
) *exec_func
;
1087 __typeof (GOMP_OFFLOAD_openacc_async_dev2host
) *dev2host_func
;
1088 __typeof (GOMP_OFFLOAD_openacc_async_host2dev
) *host2dev_func
;
1091 __typeof (GOMP_OFFLOAD_openacc_get_property
) *get_property_func
;
1093 /* NVIDIA target specific routines. */
1095 __typeof (GOMP_OFFLOAD_openacc_cuda_get_current_device
)
1096 *get_current_device_func
;
1097 __typeof (GOMP_OFFLOAD_openacc_cuda_get_current_context
)
1098 *get_current_context_func
;
1099 __typeof (GOMP_OFFLOAD_openacc_cuda_get_stream
) *get_stream_func
;
1100 __typeof (GOMP_OFFLOAD_openacc_cuda_set_stream
) *set_stream_func
;
1104 /* Various state of the accelerator device. */
1105 enum gomp_device_state
1107 GOMP_DEVICE_UNINITIALIZED
,
1108 GOMP_DEVICE_INITIALIZED
,
1109 GOMP_DEVICE_FINALIZED
1112 /* This structure describes accelerator device.
1113 It contains name of the corresponding libgomp plugin, function handlers for
1114 interaction with the device, ID-number of the device, and information about
1116 struct gomp_device_descr
1118 /* Immutable data, which is only set during initialization, and which is not
1119 guarded by the lock. */
1121 /* The name of the device. */
1124 /* Capabilities of device (supports OpenACC, OpenMP). */
1125 unsigned int capabilities
;
1127 /* This is the ID number of device among devices of the same type. */
1130 /* This is the TYPE of device. */
1131 enum offload_target_type type
;
1133 /* Function handlers. */
1134 __typeof (GOMP_OFFLOAD_get_name
) *get_name_func
;
1135 __typeof (GOMP_OFFLOAD_get_caps
) *get_caps_func
;
1136 __typeof (GOMP_OFFLOAD_get_type
) *get_type_func
;
1137 __typeof (GOMP_OFFLOAD_get_num_devices
) *get_num_devices_func
;
1138 __typeof (GOMP_OFFLOAD_init_device
) *init_device_func
;
1139 __typeof (GOMP_OFFLOAD_fini_device
) *fini_device_func
;
1140 __typeof (GOMP_OFFLOAD_version
) *version_func
;
1141 __typeof (GOMP_OFFLOAD_load_image
) *load_image_func
;
1142 __typeof (GOMP_OFFLOAD_unload_image
) *unload_image_func
;
1143 __typeof (GOMP_OFFLOAD_alloc
) *alloc_func
;
1144 __typeof (GOMP_OFFLOAD_free
) *free_func
;
1145 __typeof (GOMP_OFFLOAD_dev2host
) *dev2host_func
;
1146 __typeof (GOMP_OFFLOAD_host2dev
) *host2dev_func
;
1147 __typeof (GOMP_OFFLOAD_dev2dev
) *dev2dev_func
;
1148 __typeof (GOMP_OFFLOAD_can_run
) *can_run_func
;
1149 __typeof (GOMP_OFFLOAD_run
) *run_func
;
1150 __typeof (GOMP_OFFLOAD_async_run
) *async_run_func
;
1152 /* Splay tree containing information about mapped memory regions. */
1153 struct splay_tree_s mem_map
;
1155 /* Mutex for the mutable data. */
1158 /* Current state of the device. OpenACC allows to move from INITIALIZED state
1159 back to UNINITIALIZED state. OpenMP allows only to move from INITIALIZED
1160 to FINALIZED state (at program shutdown). */
1161 enum gomp_device_state state
;
1163 /* OpenACC-specific data and functions. */
1164 /* This is mutable because of its mutable target_data member. */
1165 acc_dispatch_t openacc
;
1168 /* Kind of the pragma, for which gomp_map_vars () is called. */
1169 enum gomp_map_vars_kind
1171 GOMP_MAP_VARS_OPENACC
= 1,
1172 GOMP_MAP_VARS_TARGET
= 2,
1173 GOMP_MAP_VARS_DATA
= 4,
1174 GOMP_MAP_VARS_ENTER_DATA
= 8
1177 extern void gomp_acc_declare_allocate (bool, size_t, void **, size_t *,
1179 struct gomp_coalesce_buf
;
1180 extern void gomp_copy_host2dev (struct gomp_device_descr
*,
1181 struct goacc_asyncqueue
*, void *, const void *,
1182 size_t, struct gomp_coalesce_buf
*);
1183 extern void gomp_copy_dev2host (struct gomp_device_descr
*,
1184 struct goacc_asyncqueue
*, void *, const void *,
1186 extern uintptr_t gomp_map_val (struct target_mem_desc
*, void **, size_t);
1187 extern void gomp_attach_pointer (struct gomp_device_descr
*,
1188 struct goacc_asyncqueue
*, splay_tree
,
1189 splay_tree_key
, uintptr_t, size_t,
1190 struct gomp_coalesce_buf
*);
1191 extern void gomp_detach_pointer (struct gomp_device_descr
*,
1192 struct goacc_asyncqueue
*, splay_tree_key
,
1193 uintptr_t, bool, struct gomp_coalesce_buf
*);
1195 extern struct target_mem_desc
*gomp_map_vars (struct gomp_device_descr
*,
1196 size_t, void **, void **,
1197 size_t *, void *, bool,
1198 enum gomp_map_vars_kind
);
1199 extern struct target_mem_desc
*gomp_map_vars_async (struct gomp_device_descr
*,
1200 struct goacc_asyncqueue
*,
1201 size_t, void **, void **,
1202 size_t *, void *, bool,
1203 enum gomp_map_vars_kind
);
1204 extern void gomp_unmap_vars (struct target_mem_desc
*, bool);
1205 extern void gomp_unmap_vars_async (struct target_mem_desc
*, bool,
1206 struct goacc_asyncqueue
*);
1207 extern void gomp_init_device (struct gomp_device_descr
*);
1208 extern bool gomp_fini_device (struct gomp_device_descr
*);
1209 extern void gomp_unload_device (struct gomp_device_descr
*);
1210 extern bool gomp_remove_var (struct gomp_device_descr
*, splay_tree_key
);
1211 extern void gomp_remove_var_async (struct gomp_device_descr
*, splay_tree_key
,
1212 struct goacc_asyncqueue
*);
1216 extern void gomp_init_work_share (struct gomp_work_share
*, size_t, unsigned);
1217 extern void gomp_fini_work_share (struct gomp_work_share
*);
1218 extern bool gomp_work_share_start (size_t);
1219 extern void gomp_work_share_end (void);
1220 extern bool gomp_work_share_end_cancel (void);
1221 extern void gomp_work_share_end_nowait (void);
1224 gomp_work_share_init_done (void)
1226 struct gomp_thread
*thr
= gomp_thread ();
1227 if (__builtin_expect (thr
->ts
.last_work_share
!= NULL
, 1))
1228 gomp_ptrlock_set (&thr
->ts
.last_work_share
->next_ws
, thr
->ts
.work_share
);
1231 #ifdef HAVE_ATTRIBUTE_VISIBILITY
1232 # pragma GCC visibility pop
1235 /* Now that we're back to default visibility, include the globals. */
1236 #include "libgomp_g.h"
1238 /* Include omp.h by parts. */
1239 #include "omp-lock.h"
1240 #define _LIBGOMP_OMP_LOCK_DEFINED 1
1243 #if !defined (HAVE_ATTRIBUTE_VISIBILITY) \
1244 || !defined (HAVE_ATTRIBUTE_ALIAS) \
1245 || !defined (HAVE_AS_SYMVER_DIRECTIVE) \
1247 || !defined (HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
1248 # undef LIBGOMP_GNU_SYMBOL_VERSIONING
1251 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING
1252 extern void gomp_init_lock_30 (omp_lock_t
*) __GOMP_NOTHROW
;
1253 extern void gomp_destroy_lock_30 (omp_lock_t
*) __GOMP_NOTHROW
;
1254 extern void gomp_set_lock_30 (omp_lock_t
*) __GOMP_NOTHROW
;
1255 extern void gomp_unset_lock_30 (omp_lock_t
*) __GOMP_NOTHROW
;
1256 extern int gomp_test_lock_30 (omp_lock_t
*) __GOMP_NOTHROW
;
1257 extern void gomp_init_nest_lock_30 (omp_nest_lock_t
*) __GOMP_NOTHROW
;
1258 extern void gomp_destroy_nest_lock_30 (omp_nest_lock_t
*) __GOMP_NOTHROW
;
1259 extern void gomp_set_nest_lock_30 (omp_nest_lock_t
*) __GOMP_NOTHROW
;
1260 extern void gomp_unset_nest_lock_30 (omp_nest_lock_t
*) __GOMP_NOTHROW
;
1261 extern int gomp_test_nest_lock_30 (omp_nest_lock_t
*) __GOMP_NOTHROW
;
1263 extern void gomp_init_lock_25 (omp_lock_25_t
*) __GOMP_NOTHROW
;
1264 extern void gomp_destroy_lock_25 (omp_lock_25_t
*) __GOMP_NOTHROW
;
1265 extern void gomp_set_lock_25 (omp_lock_25_t
*) __GOMP_NOTHROW
;
1266 extern void gomp_unset_lock_25 (omp_lock_25_t
*) __GOMP_NOTHROW
;
1267 extern int gomp_test_lock_25 (omp_lock_25_t
*) __GOMP_NOTHROW
;
1268 extern void gomp_init_nest_lock_25 (omp_nest_lock_25_t
*) __GOMP_NOTHROW
;
1269 extern void gomp_destroy_nest_lock_25 (omp_nest_lock_25_t
*) __GOMP_NOTHROW
;
1270 extern void gomp_set_nest_lock_25 (omp_nest_lock_25_t
*) __GOMP_NOTHROW
;
1271 extern void gomp_unset_nest_lock_25 (omp_nest_lock_25_t
*) __GOMP_NOTHROW
;
1272 extern int gomp_test_nest_lock_25 (omp_nest_lock_25_t
*) __GOMP_NOTHROW
;
1274 # define omp_lock_symver(fn) \
1275 __asm (".symver g" #fn "_30, " #fn "@@OMP_3.0"); \
1276 __asm (".symver g" #fn "_25, " #fn "@OMP_1.0");
1278 # define gomp_init_lock_30 omp_init_lock
1279 # define gomp_destroy_lock_30 omp_destroy_lock
1280 # define gomp_set_lock_30 omp_set_lock
1281 # define gomp_unset_lock_30 omp_unset_lock
1282 # define gomp_test_lock_30 omp_test_lock
1283 # define gomp_init_nest_lock_30 omp_init_nest_lock
1284 # define gomp_destroy_nest_lock_30 omp_destroy_nest_lock
1285 # define gomp_set_nest_lock_30 omp_set_nest_lock
1286 # define gomp_unset_nest_lock_30 omp_unset_nest_lock
1287 # define gomp_test_nest_lock_30 omp_test_nest_lock
1290 #ifdef HAVE_ATTRIBUTE_VISIBILITY
1291 # define attribute_hidden __attribute__ ((visibility ("hidden")))
1293 # define attribute_hidden
1297 # define HAVE_ATTRIBUTE_COPY
1300 #ifdef HAVE_ATTRIBUTE_COPY
1301 # define attribute_copy(arg) __attribute__ ((copy (arg)))
1303 # define attribute_copy(arg)
1306 #ifdef HAVE_ATTRIBUTE_ALIAS
1307 # define strong_alias(fn, al) \
1308 extern __typeof (fn) al __attribute__ ((alias (#fn))) attribute_copy (fn);
1310 # define ialias_ulp ialias_str1(__USER_LABEL_PREFIX__)
1311 # define ialias_str1(x) ialias_str2(x)
1312 # define ialias_str2(x) #x
1313 # define ialias(fn) \
1314 extern __typeof (fn) gomp_ialias_##fn \
1315 __attribute__ ((alias (#fn))) attribute_hidden attribute_copy (fn);
1316 # define ialias_redirect(fn) \
1317 extern __typeof (fn) fn __asm__ (ialias_ulp "gomp_ialias_" #fn) attribute_hidden;
1318 # define ialias_call(fn) gomp_ialias_ ## fn
1321 # define ialias_redirect(fn)
1322 # define ialias_call(fn) fn
1325 /* Helper function for priority_node_to_task() and
1326 task_to_priority_node().
1328 Return the offset from a task to its priority_node entry. The
1329 priority_node entry is has a type of TYPE. */
1331 static inline size_t
1332 priority_queue_offset (enum priority_queue_type type
)
1334 return offsetof (struct gomp_task
, pnode
[(int) type
]);
1337 /* Return the task associated with a priority NODE of type TYPE. */
1339 static inline struct gomp_task
*
1340 priority_node_to_task (enum priority_queue_type type
,
1341 struct priority_node
*node
)
1343 return (struct gomp_task
*) ((char *) node
- priority_queue_offset (type
));
1346 /* Return the priority node of type TYPE for a given TASK. */
1348 static inline struct priority_node
*
1349 task_to_priority_node (enum priority_queue_type type
,
1350 struct gomp_task
*task
)
1352 return (struct priority_node
*) ((char *) task
1353 + priority_queue_offset (type
));
1356 #ifdef LIBGOMP_USE_PTHREADS
1357 static inline gomp_thread_handle
1358 gomp_thread_self (void)
1360 return pthread_self ();
1363 static inline gomp_thread_handle
1364 gomp_thread_to_pthread_t (struct gomp_thread
*thr
)
1366 struct gomp_thread
*this_thr
= gomp_thread ();
1367 if (thr
== this_thr
)
1368 return pthread_self ();
1369 #ifdef GOMP_NEEDS_THREAD_HANDLE
1372 /* On Linux with initial-exec TLS, the pthread_t of the thread containing
1373 thr can be computed from thr, this_thr and pthread_self (),
1374 as the distance between this_thr and pthread_self () is constant. */
1375 return pthread_self () + ((uintptr_t) thr
- (uintptr_t) this_thr
);
1379 static inline gomp_thread_handle
1380 gomp_thread_self (void)
1382 return (gomp_thread_handle
) {};
1385 static inline gomp_thread_handle
1386 gomp_thread_to_pthread_t (struct gomp_thread
*thr
)
1389 return gomp_thread_self ();
1393 #endif /* LIBGOMP_H */