337 lines
11 KiB
C
337 lines
11 KiB
C
/* 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 */
|