-/* Copyright (C) 2005 Free Software Foundation, Inc.
+/* Copyright (C) 2005, 2007, 2008, 2009, 2010 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.
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, 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
+ FOR A PARTICULAR PURPOSE. See the GNU 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. */
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
-/* 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. */
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ <http://www.gnu.org/licenses/>. */
/* This file handles the (bare) PARALLEL construct. */
#include "libgomp.h"
+#include <limits.h>
/* Determine the number of threads to be launched for a PARALLEL construct.
- This algorithm is explicitly described in OpenMP 2.5 section 2.4.1.
+ This algorithm is explicitly described in OpenMP 3.0 section 2.4.1.
SPECIFIED is a combination of the NUM_THREADS clause and the IF clause.
If the IF clause is false, SPECIFIED is forced to 1. When NUM_THREADS
is not present, SPECIFIED is 0. */
unsigned
-gomp_resolve_num_threads (unsigned specified)
+gomp_resolve_num_threads (unsigned specified, unsigned count)
{
- /* Early exit for false IF condition or degenerate NUM_THREADS. */
+ struct gomp_thread *thread = gomp_thread();
+ struct gomp_task_icv *icv;
+ unsigned threads_requested, max_num_threads, num_threads;
+ unsigned long remaining;
+
+ icv = gomp_icv (false);
+
if (specified == 1)
return 1;
-
- /* If this is a nested region, and nested regions are disabled, force
- this team to use only one thread. */
- if (gomp_thread()->ts.team && !gomp_nest_var)
+ else if (thread->ts.active_level >= 1 && !icv->nest_var)
+ return 1;
+ else if (thread->ts.active_level >= gomp_max_active_levels_var)
return 1;
/* If NUM_THREADS not specified, use nthreads_var. */
if (specified == 0)
- specified = gomp_nthreads_var;
+ threads_requested = icv->nthreads_var;
+ else
+ threads_requested = specified;
+
+ max_num_threads = threads_requested;
/* If dynamic threads are enabled, bound the number of threads
that we launch. */
- if (gomp_dyn_var)
+ if (icv->dyn_var)
{
unsigned dyn = gomp_dynamic_max_threads ();
- if (dyn < specified)
- return dyn;
+ if (dyn < max_num_threads)
+ max_num_threads = dyn;
+
+ /* Optimization for parallel sections. */
+ if (count && count < max_num_threads)
+ max_num_threads = count;
}
- return specified;
+ /* ULONG_MAX stands for infinity. */
+ if (__builtin_expect (gomp_thread_limit_var == ULONG_MAX, 1)
+ || max_num_threads == 1)
+ return max_num_threads;
+
+#ifdef HAVE_SYNC_BUILTINS
+ do
+ {
+ remaining = gomp_remaining_threads_count;
+ num_threads = max_num_threads;
+ if (num_threads > remaining)
+ num_threads = remaining + 1;
+ }
+ while (__sync_val_compare_and_swap (&gomp_remaining_threads_count,
+ remaining, remaining - num_threads + 1)
+ != remaining);
+#else
+ gomp_mutex_lock (&gomp_remaining_threads_lock);
+ num_threads = max_num_threads;
+ remaining = gomp_remaining_threads_count;
+ if (num_threads > remaining)
+ num_threads = remaining + 1;
+ gomp_remaining_threads_count -= num_threads - 1;
+ gomp_mutex_unlock (&gomp_remaining_threads_lock);
+#endif
+
+ return num_threads;
}
void
GOMP_parallel_start (void (*fn) (void *), void *data, unsigned num_threads)
{
- num_threads = gomp_resolve_num_threads (num_threads);
- gomp_team_start (fn, data, num_threads, NULL);
+ num_threads = gomp_resolve_num_threads (num_threads, 0);
+ gomp_team_start (fn, data, num_threads, gomp_new_team (num_threads));
}
void
GOMP_parallel_end (void)
{
+ if (__builtin_expect (gomp_thread_limit_var != ULONG_MAX, 0))
+ {
+ struct gomp_thread *thr = gomp_thread ();
+ struct gomp_team *team = thr->ts.team;
+ if (team && team->nthreads > 1)
+ {
+#ifdef HAVE_SYNC_BUILTINS
+ __sync_fetch_and_add (&gomp_remaining_threads_count,
+ 1UL - team->nthreads);
+#else
+ gomp_mutex_lock (&gomp_remaining_threads_lock);
+ gomp_remaining_threads_count -= team->nthreads - 1;
+ gomp_mutex_unlock (&gomp_remaining_threads_lock);
+#endif
+ }
+ }
gomp_team_end ();
}
return team ? team->nthreads : 1;
}
-/* ??? Does this function need to disregard dyn_var? I don't see
- how else one could get a useable "maximum". */
-
int
-omp_get_max_threads (void)
+omp_get_thread_num (void)
{
- return gomp_resolve_num_threads (0);
+ return gomp_thread ()->ts.team_id;
}
+/* This wasn't right for OpenMP 2.5. Active region used to be non-zero
+ when the IF clause doesn't evaluate to false, starting with OpenMP 3.0
+ it is non-zero with more than one thread in the team. */
+
int
-omp_get_thread_num (void)
+omp_in_parallel (void)
{
- return gomp_thread ()->ts.team_id;
+ return gomp_thread ()->ts.active_level > 0;
}
-/* ??? This isn't right. The definition of this function is false if any
- of the IF clauses for any of the parallels is false. Which is not the
- same thing as any outer team having more than one thread. */
+int
+omp_get_level (void)
+{
+ return gomp_thread ()->ts.level;
+}
-int omp_in_parallel (void)
+int
+omp_get_ancestor_thread_num (int level)
{
- struct gomp_team *team = gomp_thread ()->ts.team;
+ struct gomp_team_state *ts = &gomp_thread ()->ts;
+ if (level < 0 || level > ts->level)
+ return -1;
+ for (level = ts->level - level; level > 0; --level)
+ ts = &ts->team->prev_ts;
+ return ts->team_id;
+}
- while (team)
- {
- if (team->nthreads > 1)
- return true;
- team = team->prev_ts.team;
- }
+int
+omp_get_team_size (int level)
+{
+ struct gomp_team_state *ts = &gomp_thread ()->ts;
+ if (level < 0 || level > ts->level)
+ return -1;
+ for (level = ts->level - level; level > 0; --level)
+ ts = &ts->team->prev_ts;
+ if (ts->team == NULL)
+ return 1;
+ else
+ return ts->team->nthreads;
+}
- return false;
+int
+omp_get_active_level (void)
+{
+ return gomp_thread ()->ts.active_level;
}
ialias (omp_get_num_threads)
-ialias (omp_get_max_threads)
ialias (omp_get_thread_num)
ialias (omp_in_parallel)
+ialias (omp_get_level)
+ialias (omp_get_ancestor_thread_num)
+ialias (omp_get_team_size)
+ialias (omp_get_active_level)
OSDN Git Service
