OSDN Git Service

Check if GCC uses assembler cfi support
[pf3gnuchains/gcc-fork.git] / libgomp / parallel.c
1 /* Copyright (C) 2005, 2007, 2008, 2009, 2010 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 handles the (bare) PARALLEL construct.  */
26
27 #include "libgomp.h"
28 #include <limits.h>
29
30
31 /* Determine the number of threads to be launched for a PARALLEL construct.
32    This algorithm is explicitly described in OpenMP 3.0 section 2.4.1.
33    SPECIFIED is a combination of the NUM_THREADS clause and the IF clause.
34    If the IF clause is false, SPECIFIED is forced to 1.  When NUM_THREADS
35    is not present, SPECIFIED is 0.  */
36
37 unsigned
38 gomp_resolve_num_threads (unsigned specified, unsigned count)
39 {
40   struct gomp_thread *thread = gomp_thread();
41   struct gomp_task_icv *icv;
42   unsigned threads_requested, max_num_threads, num_threads;
43   unsigned long remaining;
44
45   icv = gomp_icv (false);
46
47   if (specified == 1)
48     return 1;
49   else if (thread->ts.active_level >= 1 && !icv->nest_var)
50     return 1;
51   else if (thread->ts.active_level >= gomp_max_active_levels_var)
52     return 1;
53
54   /* If NUM_THREADS not specified, use nthreads_var.  */
55   if (specified == 0)
56     threads_requested = icv->nthreads_var;
57   else
58     threads_requested = specified;
59
60   max_num_threads = threads_requested;
61
62   /* If dynamic threads are enabled, bound the number of threads
63      that we launch.  */
64   if (icv->dyn_var)
65     {
66       unsigned dyn = gomp_dynamic_max_threads ();
67       if (dyn < max_num_threads)
68         max_num_threads = dyn;
69
70       /* Optimization for parallel sections.  */
71       if (count && count < max_num_threads)
72         max_num_threads = count;
73     }
74
75   /* ULONG_MAX stands for infinity.  */
76   if (__builtin_expect (gomp_thread_limit_var == ULONG_MAX, 1)
77       || max_num_threads == 1)
78     return max_num_threads;
79
80 #ifdef HAVE_SYNC_BUILTINS
81   do
82     {
83       remaining = gomp_remaining_threads_count;
84       num_threads = max_num_threads;
85       if (num_threads > remaining)
86         num_threads = remaining + 1;
87     }
88   while (__sync_val_compare_and_swap (&gomp_remaining_threads_count,
89                                       remaining, remaining - num_threads + 1)
90          != remaining);
91 #else
92   gomp_mutex_lock (&gomp_remaining_threads_lock);
93   num_threads = max_num_threads;
94   remaining = gomp_remaining_threads_count;
95   if (num_threads > remaining)
96     num_threads = remaining + 1;
97   gomp_remaining_threads_count -= num_threads - 1;
98   gomp_mutex_unlock (&gomp_remaining_threads_lock);
99 #endif
100
101   return num_threads;
102 }
103
104 void
105 GOMP_parallel_start (void (*fn) (void *), void *data, unsigned num_threads)
106 {
107   num_threads = gomp_resolve_num_threads (num_threads, 0);
108   gomp_team_start (fn, data, num_threads, gomp_new_team (num_threads));
109 }
110
111 void
112 GOMP_parallel_end (void)
113 {
114   if (__builtin_expect (gomp_thread_limit_var != ULONG_MAX, 0))
115     {
116       struct gomp_thread *thr = gomp_thread ();
117       struct gomp_team *team = thr->ts.team;
118       if (team && team->nthreads > 1)
119         {
120 #ifdef HAVE_SYNC_BUILTINS
121           __sync_fetch_and_add (&gomp_remaining_threads_count,
122                                 1UL - team->nthreads);
123 #else
124           gomp_mutex_lock (&gomp_remaining_threads_lock);
125           gomp_remaining_threads_count -= team->nthreads - 1;
126           gomp_mutex_unlock (&gomp_remaining_threads_lock);
127 #endif
128         }
129     }
130   gomp_team_end ();
131 }
132
133 \f
134 /* The public OpenMP API for thread and team related inquiries.  */
135
136 int
137 omp_get_num_threads (void)
138 {
139   struct gomp_team *team = gomp_thread ()->ts.team;
140   return team ? team->nthreads : 1;
141 }
142
143 int
144 omp_get_thread_num (void)
145 {
146   return gomp_thread ()->ts.team_id;
147 }
148
149 /* This wasn't right for OpenMP 2.5.  Active region used to be non-zero
150    when the IF clause doesn't evaluate to false, starting with OpenMP 3.0
151    it is non-zero with more than one thread in the team.  */
152
153 int
154 omp_in_parallel (void)
155 {
156   return gomp_thread ()->ts.active_level > 0;
157 }
158
159 int
160 omp_get_level (void)
161 {
162   return gomp_thread ()->ts.level;
163 }
164
165 int
166 omp_get_ancestor_thread_num (int level)
167 {
168   struct gomp_team_state *ts = &gomp_thread ()->ts;
169   if (level < 0 || level > ts->level)
170     return -1;
171   for (level = ts->level - level; level > 0; --level)
172     ts = &ts->team->prev_ts;
173   return ts->team_id;
174 }
175
176 int
177 omp_get_team_size (int level)
178 {
179   struct gomp_team_state *ts = &gomp_thread ()->ts;
180   if (level < 0 || level > ts->level)
181     return -1;
182   for (level = ts->level - level; level > 0; --level)
183     ts = &ts->team->prev_ts;
184   if (ts->team == NULL)
185     return 1;
186   else
187     return ts->team->nthreads;
188 }
189
190 int
191 omp_get_active_level (void)
192 {
193   return gomp_thread ()->ts.active_level;
194 }
195
196 ialias (omp_get_num_threads)
197 ialias (omp_get_thread_num)
198 ialias (omp_in_parallel)
199 ialias (omp_get_level)
200 ialias (omp_get_ancestor_thread_num)
201 ialias (omp_get_team_size)
202 ialias (omp_get_active_level)