OSDN Git Service

PR libgomp/25877
[pf3gnuchains/gcc-fork.git] / libgomp / team.c
1 /* Copyright (C) 2005 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 Lesser General Public License as published by
8    the Free Software Foundation; either version 2.1 of the License, or
9    (at your option) 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 Lesser General Public License for
14    more details.
15
16    You should have received a copy of the GNU Lesser General Public License 
17    along with libgomp; see the file COPYING.LIB.  If not, write to the
18    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 /* As a special exception, if you link this library with other files, some
22    of which are compiled with GCC, to produce an executable, this library
23    does not by itself cause the resulting executable to be covered by the
24    GNU General Public License.  This exception does not however invalidate
25    any other reasons why the executable file might be covered by the GNU
26    General Public License.  */
27
28 /* This file handles the maintainence of threads in response to team
29    creation and termination.  */
30
31 #include "libgomp.h"
32 #include <stdlib.h>
33 #include <string.h>
34
35 #ifdef HAVE_ALLOCA_H
36 # include <alloca.h>
37 #endif
38
39
40 /* This array manages threads spawned from the top level, which will
41    return to the idle loop once the current PARALLEL construct ends.  */
42 static struct gomp_thread **gomp_threads;
43 static unsigned gomp_threads_size;
44 static unsigned gomp_threads_used;
45
46 /* This attribute contains PTHREAD_CREATE_DETACHED.  */
47 static pthread_attr_t gomp_thread_attr;
48
49 /* This barrier holds and releases threads waiting in gomp_threads.  */
50 static gomp_barrier_t gomp_threads_dock;
51
52 /* This is the libgomp per-thread data structure.  */
53 #ifdef HAVE_TLS
54 __thread struct gomp_thread gomp_tls_data;
55 #else
56 pthread_key_t gomp_tls_key;
57 #endif
58
59
60 /* This structure is used to communicate across pthread_create.  */
61
62 struct gomp_thread_start_data
63 {
64   struct gomp_team_state ts;
65   void (*fn) (void *);
66   void *fn_data;
67   bool nested;
68 };
69
70
71 /* This function is a pthread_create entry point.  This contains the idle
72    loop in which a thread waits to be called up to become part of a team.  */
73
74 static void *
75 gomp_thread_start (void *xdata)
76 {
77   struct gomp_thread_start_data *data = xdata;
78   struct gomp_thread *thr;
79   void (*local_fn) (void *);
80   void *local_data;
81
82 #ifdef HAVE_TLS
83   thr = &gomp_tls_data;
84 #else
85   struct gomp_thread local_thr;
86   thr = &local_thr;
87   pthread_setspecific (gomp_tls_key, thr);
88 #endif
89   gomp_sem_init (&thr->release, 0);
90
91   /* Extract what we need from data.  */
92   local_fn = data->fn;
93   local_data = data->fn_data;
94   thr->ts = data->ts;
95
96   thr->ts.team->ordered_release[thr->ts.team_id] = &thr->release;
97
98   if (data->nested)
99     {
100       gomp_barrier_wait (&thr->ts.team->barrier);
101       local_fn (local_data);
102       gomp_barrier_wait (&thr->ts.team->barrier);
103     }
104   else
105     {
106       gomp_threads[thr->ts.team_id] = thr;
107
108       gomp_barrier_wait (&gomp_threads_dock);
109       do
110         {
111           struct gomp_team *team;
112
113           local_fn (local_data);
114
115           /* Clear out the team and function data.  This is a debugging
116              signal that we're in fact back in the dock.  */
117           team = thr->ts.team;
118           thr->fn = NULL;
119           thr->data = NULL;
120           thr->ts.team = NULL;
121           thr->ts.work_share = NULL;
122           thr->ts.team_id = 0;
123           thr->ts.work_share_generation = 0;
124           thr->ts.static_trip = 0;
125
126           gomp_barrier_wait (&team->barrier);
127           gomp_barrier_wait (&gomp_threads_dock);
128
129           local_fn = thr->fn;
130           local_data = thr->data;
131         }
132       while (local_fn);
133     }
134
135   return NULL;
136 }
137
138
139 /* Create a new team data structure.  */
140
141 static struct gomp_team *
142 new_team (unsigned nthreads, struct gomp_work_share *work_share)
143 {
144   struct gomp_team *team;
145   size_t size;
146
147   size = sizeof (*team) + nthreads * sizeof (team->ordered_release[0]);
148   team = gomp_malloc (size);
149   gomp_mutex_init (&team->work_share_lock);
150
151   team->work_shares = gomp_malloc (4 * sizeof (struct gomp_work_share *));
152   team->generation_mask = 3;
153   team->oldest_live_gen = work_share == NULL;
154   team->num_live_gen = work_share != NULL;
155   team->work_shares[0] = work_share;
156
157   team->nthreads = nthreads;
158   gomp_barrier_init (&team->barrier, nthreads);
159
160   gomp_sem_init (&team->master_release, 0);
161   team->ordered_release[0] = &team->master_release;
162
163   return team;
164 }
165
166
167 /* Free a team data structure.  */
168
169 static void
170 free_team (struct gomp_team *team)
171 {
172   free (team->work_shares);
173   gomp_mutex_destroy (&team->work_share_lock);
174   gomp_barrier_destroy (&team->barrier);
175   gomp_sem_destroy (&team->master_release);
176   free (team);
177 }
178
179
180 /* Launch a team.  */
181
182 void
183 gomp_team_start (void (*fn) (void *), void *data, unsigned nthreads,
184                  struct gomp_work_share *work_share)
185 {
186   struct gomp_thread_start_data *start_data;
187   struct gomp_thread *thr, *nthr;
188   struct gomp_team *team;
189   bool nested;
190   unsigned i, n, old_threads_used = 0;
191
192   thr = gomp_thread ();
193   nested = thr->ts.team != NULL;
194
195   team = new_team (nthreads, work_share);
196
197   /* Always save the previous state, even if this isn't a nested team.
198      In particular, we should save any work share state from an outer
199      orphaned work share construct.  */
200   team->prev_ts = thr->ts;
201
202   thr->ts.team = team;
203   thr->ts.work_share = work_share;
204   thr->ts.team_id = 0;
205   thr->ts.work_share_generation = 0;
206   thr->ts.static_trip = 0;
207
208   if (nthreads == 1)
209     return;
210
211   i = 1;
212
213   /* We only allow the reuse of idle threads for non-nested PARALLEL
214      regions.  This appears to be implied by the semantics of
215      threadprivate variables, but perhaps that's reading too much into
216      things.  Certainly it does prevent any locking problems, since
217      only the initial program thread will modify gomp_threads.  */
218   if (!nested)
219     {
220       old_threads_used = gomp_threads_used;
221
222       if (nthreads <= old_threads_used)
223         n = nthreads;
224       else if (old_threads_used == 0)
225         {
226           n = 0;
227           gomp_barrier_init (&gomp_threads_dock, nthreads);
228         }
229       else
230         {
231           n = old_threads_used;
232
233           /* Increase the barrier threshold to make sure all new
234              threads arrive before the team is released.  */
235           gomp_barrier_reinit (&gomp_threads_dock, nthreads);
236         }
237
238       /* Not true yet, but soon will be.  We're going to release all
239          threads from the dock, and those that aren't part of the 
240          team will exit.  */
241       gomp_threads_used = nthreads;
242
243       /* Release existing idle threads.  */
244       for (; i < n; ++i)
245         {
246           nthr = gomp_threads[i];
247           nthr->ts.team = team;
248           nthr->ts.work_share = work_share;
249           nthr->ts.team_id = i;
250           nthr->ts.work_share_generation = 0;
251           nthr->ts.static_trip = 0;
252           nthr->fn = fn;
253           nthr->data = data;
254           team->ordered_release[i] = &nthr->release;
255         }
256
257       if (i == nthreads)
258         goto do_release;
259
260       /* If necessary, expand the size of the gomp_threads array.  It is
261          expected that changes in the number of threads is rare, thus we
262          make no effort to expand gomp_threads_size geometrically.  */
263       if (nthreads >= gomp_threads_size)
264         {
265           gomp_threads_size = nthreads + 1;
266           gomp_threads
267             = gomp_realloc (gomp_threads,
268                             gomp_threads_size
269                             * sizeof (struct gomp_thread_data *));
270         }
271     }
272
273   start_data = alloca (sizeof (struct gomp_thread_start_data) * (nthreads-i));
274
275   /* Launch new threads.  */
276   for (; i < nthreads; ++i, ++start_data)
277     {
278       pthread_t pt;
279       int err;
280
281       start_data->ts.team = team;
282       start_data->ts.work_share = work_share;
283       start_data->ts.team_id = i;
284       start_data->ts.work_share_generation = 0;
285       start_data->ts.static_trip = 0;
286       start_data->fn = fn;
287       start_data->fn_data = data;
288       start_data->nested = nested;
289
290       err = pthread_create (&pt, &gomp_thread_attr,
291                             gomp_thread_start, start_data);
292       if (err != 0)
293         gomp_fatal ("Thread creation failed: %s", strerror (err));
294     }
295
296  do_release:
297   gomp_barrier_wait (nested ? &team->barrier : &gomp_threads_dock);
298
299   /* Decrease the barrier threshold to match the number of threads
300      that should arrive back at the end of this team.  The extra
301      threads should be exiting.  Note that we arrange for this test
302      to never be true for nested teams.  */
303   if (nthreads < old_threads_used)
304     gomp_barrier_reinit (&gomp_threads_dock, nthreads);
305 }
306
307
308 /* Terminate the current team.  This is only to be called by the master
309    thread.  We assume that we must wait for the other threads.  */
310
311 void
312 gomp_team_end (void)
313 {
314   struct gomp_thread *thr = gomp_thread ();
315   struct gomp_team *team = thr->ts.team;
316
317   gomp_barrier_wait (&team->barrier);
318
319   thr->ts = team->prev_ts;
320
321   free_team (team);
322 }
323
324
325 /* Constructors for this file.  */
326
327 static void __attribute__((constructor))
328 initialize_team (void)
329 {
330   struct gomp_thread *thr;
331
332 #ifndef HAVE_TLS
333   static struct gomp_thread initial_thread_tls_data;
334
335   pthread_key_create (&gomp_tls_key, NULL);
336   pthread_setspecific (gomp_tls_key, &initial_thread_tls_data);
337 #endif
338
339 #ifdef HAVE_TLS
340   thr = &gomp_tls_data;
341 #else
342   thr = &initial_thread_tls_data;
343 #endif
344   gomp_sem_init (&thr->release, 0);
345
346   pthread_attr_init (&gomp_thread_attr);
347   pthread_attr_setdetachstate (&gomp_thread_attr, PTHREAD_CREATE_DETACHED);
348 }