diff options
Diffstat (limited to 'contrib/gcclibs/libgomp/libgomp.h')
| -rw-r--r-- | contrib/gcclibs/libgomp/libgomp.h | 336 |
1 files changed, 336 insertions, 0 deletions
diff --git a/contrib/gcclibs/libgomp/libgomp.h b/contrib/gcclibs/libgomp/libgomp.h new file mode 100644 index 0000000..47e68e6 --- /dev/null +++ b/contrib/gcclibs/libgomp/libgomp.h @@ -0,0 +1,336 @@ +/* Copyright (C) 2005 Free Software Foundation, Inc. + Contributed by Richard Henderson <rth@redhat.com>. + + This file is part of the GNU OpenMP Library (libgomp). + + Libgomp is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for + more details. + + You should have received a copy of the GNU Lesser General Public License + along with libgomp; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + MA 02110-1301, USA. */ + +/* As a special exception, if you link this library with other files, some + of which are compiled with GCC, to produce an executable, this library + does not by itself cause the resulting executable to be covered by the + GNU General Public License. This exception does not however invalidate + any other reasons why the executable file might be covered by the GNU + General Public License. */ + +/* This file contains data types and function declarations that are not + part of the official OpenMP user interface. There are declarations + in here that are part of the GNU OpenMP ABI, in that the compiler is + required to know about them and use them. + + The convention is that the all caps prefix "GOMP" is used group items + that are part of the external ABI, and the lower case prefix "gomp" + is used group items that are completely private to the library. */ + +#ifndef LIBGOMP_H +#define LIBGOMP_H 1 + +#include "config.h" +#include "gstdint.h" + +#include <pthread.h> +#include <stdbool.h> + +#ifdef HAVE_ATTRIBUTE_VISIBILITY +# pragma GCC visibility push(hidden) +#endif + +#include "sem.h" +#include "mutex.h" +#include "bar.h" + + +/* This structure contains the data to control one work-sharing construct, + either a LOOP (FOR/DO) or a SECTIONS. */ + +enum gomp_schedule_type +{ + GFS_STATIC, + GFS_DYNAMIC, + GFS_GUIDED, + GFS_RUNTIME +}; + +struct gomp_work_share +{ + /* This member records the SCHEDULE clause to be used for this construct. + The user specification of "runtime" will already have been resolved. + If this is a SECTIONS construct, this value will always be DYNAMIC. */ + enum gomp_schedule_type sched; + + /* This is the chunk_size argument to the SCHEDULE clause. */ + long chunk_size; + + /* This is the iteration end point. If this is a SECTIONS construct, + this is the number of contained sections. */ + long end; + + /* This is the iteration step. If this is a SECTIONS construct, this + is always 1. */ + long incr; + + /* This lock protects the update of the following members. */ + gomp_mutex_t lock; + + union { + /* This is the next iteration value to be allocated. In the case of + GFS_STATIC loops, this the iteration start point and never changes. */ + long next; + + /* This is the returned data structure for SINGLE COPYPRIVATE. */ + void *copyprivate; + }; + + /* This is the count of the number of threads that have exited the work + share construct. If the construct was marked nowait, they have moved on + to other work; otherwise they're blocked on a barrier. The last member + of the team to exit the work share construct must deallocate it. */ + unsigned threads_completed; + + /* This is the index into the circular queue ordered_team_ids of the + current thread that's allowed into the ordered reason. */ + unsigned ordered_cur; + + /* This is the number of threads that have registered themselves in + the circular queue ordered_team_ids. */ + unsigned ordered_num_used; + + /* This is the team_id of the currently acknoledged owner of the ordered + section, or -1u if the ordered section has not been acknowledged by + any thread. This is distinguished from the thread that is *allowed* + to take the section next. */ + unsigned ordered_owner; + + /* This is a circular queue that details which threads will be allowed + into the ordered region and in which order. When a thread allocates + iterations on which it is going to work, it also registers itself at + the end of the array. When a thread reaches the ordered region, it + checks to see if it is the one at the head of the queue. If not, it + blocks on its RELEASE semaphore. */ + unsigned ordered_team_ids[]; +}; + +/* This structure contains all of the thread-local data associated with + a thread team. This is the data that must be saved when a thread + encounters a nested PARALLEL construct. */ + +struct gomp_team_state +{ + /* This is the team of which the thread is currently a member. */ + struct gomp_team *team; + + /* This is the work share construct which this thread is currently + processing. Recall that with NOWAIT, not all threads may be + processing the same construct. This value is NULL when there + is no construct being processed. */ + struct gomp_work_share *work_share; + + /* This is the ID of this thread within the team. This value is + guaranteed to be between 0 and N-1, where N is the number of + threads in the team. */ + unsigned team_id; + + /* The work share "generation" is a number that increases by one for + each work share construct encountered in the dynamic flow of the + program. It is used to find the control data for the work share + when encountering it for the first time. This particular number + reflects the generation of the work_share member of this struct. */ + unsigned work_share_generation; + + /* For GFS_RUNTIME loops that resolved to GFS_STATIC, this is the + trip number through the loop. So first time a particular loop + is encountered this number is 0, the second time through the loop + is 1, etc. This is unused when the compiler knows in advance that + the loop is statically scheduled. */ + unsigned long static_trip; +}; + +/* This structure describes a "team" of threads. These are the threads + that are spawned by a PARALLEL constructs, as well as the work sharing + constructs that the team encounters. */ + +struct gomp_team +{ + /* This lock protects access to the following work shares data structures. */ + gomp_mutex_t work_share_lock; + + /* This is a dynamically sized array containing pointers to the control + structs for all "live" work share constructs. Here "live" means that + the construct has been encountered by at least one thread, and not + completed by all threads. */ + struct gomp_work_share **work_shares; + + /* The work_shares array is indexed by "generation & generation_mask". + The mask will be 2**N - 1, where 2**N is the size of the array. */ + unsigned generation_mask; + + /* These two values define the bounds of the elements of the work_shares + array that are currently in use. */ + unsigned oldest_live_gen; + unsigned num_live_gen; + + /* This is the number of threads in the current team. */ + unsigned nthreads; + + /* This is the saved team state that applied to a master thread before + the current thread was created. */ + struct gomp_team_state prev_ts; + + /* This barrier is used for most synchronization of the team. */ + gomp_barrier_t barrier; + + /* This semaphore should be used by the master thread instead of its + "native" semaphore in the thread structure. Required for nested + parallels, as the master is a member of two teams. */ + gomp_sem_t master_release; + + /* This array contains pointers to the release semaphore of the threads + in the team. */ + gomp_sem_t *ordered_release[]; +}; + +/* This structure contains all data that is private to libgomp and is + allocated per thread. */ + +struct gomp_thread +{ + /* This is the function that the thread should run upon launch. */ + void (*fn) (void *data); + void *data; + + /* This is the current team state for this thread. The ts.team member + is NULL only if the thread is idle. */ + struct gomp_team_state ts; + + /* This semaphore is used for ordered loops. */ + gomp_sem_t release; +}; + +/* ... and here is that TLS data. */ + +#ifdef HAVE_TLS +extern __thread struct gomp_thread gomp_tls_data; +static inline struct gomp_thread *gomp_thread (void) +{ + return &gomp_tls_data; +} +#else +extern pthread_key_t gomp_tls_key; +static inline struct gomp_thread *gomp_thread (void) +{ + return pthread_getspecific (gomp_tls_key); +} +#endif + +/* These are the OpenMP 2.5 internal control variables described in + section 2.3. At least those that correspond to environment variables. */ + +extern unsigned long gomp_nthreads_var; +extern bool gomp_dyn_var; +extern bool gomp_nest_var; +extern enum gomp_schedule_type gomp_run_sched_var; +extern unsigned long gomp_run_sched_chunk; + +/* The attributes to be used during thread creation. */ +extern pthread_attr_t gomp_thread_attr; + +/* Function prototypes. */ + +/* alloc.c */ + +extern void *gomp_malloc (size_t) __attribute__((malloc)); +extern void *gomp_malloc_cleared (size_t) __attribute__((malloc)); +extern void *gomp_realloc (void *, size_t); + +/* Avoid conflicting prototypes of alloca() in system headers by using + GCC's builtin alloca(). */ +#define gomp_alloca(x) __builtin_alloca(x) + +/* error.c */ + +extern void gomp_error (const char *, ...) + __attribute__((format (printf, 1, 2))); +extern void gomp_fatal (const char *, ...) + __attribute__((noreturn, format (printf, 1, 2))); + +/* iter.c */ + +extern int gomp_iter_static_next (long *, long *); +extern bool gomp_iter_dynamic_next_locked (long *, long *); +extern bool gomp_iter_guided_next_locked (long *, long *); + +#ifdef HAVE_SYNC_BUILTINS +extern bool gomp_iter_dynamic_next (long *, long *); +extern bool gomp_iter_guided_next (long *, long *); +#endif + +/* ordered.c */ + +extern void gomp_ordered_first (void); +extern void gomp_ordered_last (void); +extern void gomp_ordered_next (void); +extern void gomp_ordered_static_init (void); +extern void gomp_ordered_static_next (void); +extern void gomp_ordered_sync (void); + +/* parallel.c */ + +extern unsigned gomp_resolve_num_threads (unsigned); + +/* proc.c (in config/) */ + +extern void gomp_init_num_threads (void); +extern unsigned gomp_dynamic_max_threads (void); + +/* team.c */ + +extern void gomp_team_start (void (*) (void *), void *, unsigned, + struct gomp_work_share *); +extern void gomp_team_end (void); + +/* work.c */ + +extern struct gomp_work_share * gomp_new_work_share (bool, unsigned); +extern bool gomp_work_share_start (bool); +extern void gomp_work_share_end (void); +extern void gomp_work_share_end_nowait (void); + +#ifdef HAVE_ATTRIBUTE_VISIBILITY +# pragma GCC visibility pop +#endif + +/* Now that we're back to default visibility, include the globals. */ +#include "libgomp_g.h" + +/* Include omp.h by parts. */ +#include "omp-lock.h" +#define _LIBGOMP_OMP_LOCK_DEFINED 1 +#include "omp.h.in" + +#ifdef HAVE_ATTRIBUTE_VISIBILITY +# define attribute_hidden __attribute__ ((visibility ("hidden"))) +#else +# define attribute_hidden +#endif + +#ifdef HAVE_ATTRIBUTE_ALIAS +# define ialias(fn) \ + extern __typeof (fn) gomp_ialias_##fn \ + __attribute__ ((alias (#fn))) attribute_hidden; +#else +# define ialias(fn) +#endif + +#endif /* LIBGOMP_H */ |
