libgomp/parallel.c

   1 /* Copyright (C) 2005-2020 Free Software Foundation, Inc.
   2    Contributed by Richard Henderson <rth@redhat.com>.
   3
   4    This file is part of the GNU Offloading and Multi Processing Library
   5    (libgomp).
   6
   7    Libgomp is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15    more details.
  16
  17    Under Section 7 of GPL version 3, you are granted additional
  18    permissions described in the GCC Runtime Library Exception, version
  19    3.1, as published by the Free Software Foundation.
  20
  21    You should have received a copy of the GNU General Public License and
  22    a copy of the GCC Runtime Library Exception along with this program;
  23    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24    <http://www.gnu.org/licenses/>.  */
  25
  26 /* This file handles the (bare) PARALLEL construct.  */
  27
  28 #include "libgomp.h"
  29 #include <limits.h>
  30
  31
  32 /* Determine the number of threads to be launched for a PARALLEL construct.
  33    This algorithm is explicitly described in OpenMP 3.0 section 2.4.1.
  34    SPECIFIED is a combination of the NUM_THREADS clause and the IF clause.
  35    If the IF clause is false, SPECIFIED is forced to 1.  When NUM_THREADS
  36    is not present, SPECIFIED is 0.  */
  37
  38 unsigned
  39 gomp_resolve_num_threads (unsigned specified, unsigned count)
  40 {
  41   struct gomp_thread *thr = gomp_thread ();
  42   struct gomp_task_icv *icv;
  43   unsigned threads_requested, max_num_threads, num_threads;
  44   unsigned long busy;
  45   struct gomp_thread_pool *pool;
  46
  47   icv = gomp_icv (false);
  48
  49   if (specified == 1)
  50     return 1;
  51
  52   if (thr->ts.active_level >= 1
  53   /* Accelerators with fixed thread counts require this to return 1 for
  54      nested parallel regions.  */
  55 #if !defined(__AMDGCN__) && !defined(__nvptx__)
  56       && !icv->nest_var
  57 #endif
  58       )
  59     return 1;
  60   else if (thr->ts.active_level >= gomp_max_active_levels_var)
  61     return 1;
  62
  63   /* If NUM_THREADS not specified, use nthreads_var.  */
  64   if (specified == 0)
  65     threads_requested = icv->nthreads_var;
  66   else
  67     threads_requested = specified;
  68
  69   max_num_threads = threads_requested;
  70
  71   /* If dynamic threads are enabled, bound the number of threads
  72      that we launch.  */
  73   if (icv->dyn_var)
  74     {
  75       unsigned dyn = gomp_dynamic_max_threads ();
  76       if (dyn < max_num_threads)
  77         max_num_threads = dyn;
  78
  79       /* Optimization for parallel sections.  */
  80       if (count && count < max_num_threads)
  81         max_num_threads = count;
  82     }
  83
  84   /* UINT_MAX stands for infinity.  */
  85   if (__builtin_expect (icv->thread_limit_var == UINT_MAX, 1)
  86       || max_num_threads == 1)
  87     return max_num_threads;
  88
  89   /* The threads_busy counter lives in thread_pool, if there
  90      isn't a thread_pool yet, there must be just one thread
  91      in the contention group.  If thr->team is NULL, this isn't
  92      nested parallel, so there is just one thread in the
  93      contention group as well, no need to handle it atomically.  */
  94   pool = thr->thread_pool;
  95   if (thr->ts.team == NULL || pool == NULL)
  96     {
  97       num_threads = max_num_threads;
  98       if (num_threads > icv->thread_limit_var)
  99         num_threads = icv->thread_limit_var;
 100       if (pool)
 101         pool->threads_busy = num_threads;
 102       return num_threads;
 103     }
 104
 105 #ifdef HAVE_SYNC_BUILTINS
 106   do
 107     {
 108       busy = pool->threads_busy;
 109       num_threads = max_num_threads;
 110       if (icv->thread_limit_var - busy + 1 < num_threads)
 111         num_threads = icv->thread_limit_var - busy + 1;
 112     }
 113   while (__sync_val_compare_and_swap (&pool->threads_busy,
 114                                       busy, busy + num_threads - 1)
 115          != busy);
 116 #else
 117   gomp_mutex_lock (&gomp_managed_threads_lock);
 118   num_threads = max_num_threads;
 119   busy = pool->threads_busy;
 120   if (icv->thread_limit_var - busy + 1 < num_threads)
 121     num_threads = icv->thread_limit_var - busy + 1;
 122   pool->threads_busy += num_threads - 1;
 123   gomp_mutex_unlock (&gomp_managed_threads_lock);
 124 #endif
 125
 126   return num_threads;
 127 }
 128
 129 void
 130 GOMP_parallel_start (void (*fn) (void *), void *data, unsigned num_threads)
 131 {
 132   num_threads = gomp_resolve_num_threads (num_threads, 0);
 133   gomp_team_start (fn, data, num_threads, 0, gomp_new_team (num_threads),
 134                    NULL);
 135 }
 136
 137 void
 138 GOMP_parallel_end (void)
 139 {
 140   struct gomp_task_icv *icv = gomp_icv (false);
 141   if (__builtin_expect (icv->thread_limit_var != UINT_MAX, 0))
 142     {
 143       struct gomp_thread *thr = gomp_thread ();
 144       struct gomp_team *team = thr->ts.team;
 145       unsigned int nthreads = team ? team->nthreads : 1;
 146       gomp_team_end ();
 147       if (nthreads > 1)
 148         {
 149           /* If not nested, there is just one thread in the
 150              contention group left, no need for atomicity.  */
 151           if (thr->ts.team == NULL)
 152             thr->thread_pool->threads_busy = 1;
 153           else
 154             {
 155 #ifdef HAVE_SYNC_BUILTINS
 156               __sync_fetch_and_add (&thr->thread_pool->threads_busy,
 157                                     1UL - nthreads);
 158 #else
 159               gomp_mutex_lock (&gomp_managed_threads_lock);
 160               thr->thread_pool->threads_busy -= nthreads - 1;
 161               gomp_mutex_unlock (&gomp_managed_threads_lock);
 162 #endif
 163             }
 164         }
 165     }
 166   else
 167     gomp_team_end ();
 168 }
 169 ialias (GOMP_parallel_end)
 170
 171 void
 172 GOMP_parallel (void (*fn) (void *), void *data, unsigned num_threads,
 173                unsigned int flags)
 174 {
 175   num_threads = gomp_resolve_num_threads (num_threads, 0);
 176   gomp_team_start (fn, data, num_threads, flags, gomp_new_team (num_threads),
 177                    NULL);
 178   fn (data);
 179   ialias_call (GOMP_parallel_end) ();
 180 }
 181
 182 unsigned
 183 GOMP_parallel_reductions (void (*fn) (void *), void *data,
 184                           unsigned num_threads, unsigned int flags)
 185 {
 186   struct gomp_taskgroup *taskgroup;
 187   num_threads = gomp_resolve_num_threads (num_threads, 0);
 188   uintptr_t *rdata = *(uintptr_t **)data;
 189   taskgroup = gomp_parallel_reduction_register (rdata, num_threads);
 190   gomp_team_start (fn, data, num_threads, flags, gomp_new_team (num_threads),
 191                    taskgroup);
 192   fn (data);
 193   ialias_call (GOMP_parallel_end) ();
 194   gomp_sem_destroy (&taskgroup->taskgroup_sem);
 195   free (taskgroup);
 196   return num_threads;
 197 }
 198
 199 bool
 200 GOMP_cancellation_point (int which)
 201 {
 202   if (!gomp_cancel_var)
 203     return false;
 204
 205   struct gomp_thread *thr = gomp_thread ();
 206   struct gomp_team *team = thr->ts.team;
 207   if (which & (GOMP_CANCEL_LOOP | GOMP_CANCEL_SECTIONS))
 208     {
 209       if (team == NULL)
 210         return false;
 211       return team->work_share_cancelled != 0;
 212     }
 213   else if (which & GOMP_CANCEL_TASKGROUP)
 214     {
 215       if (thr->task->taskgroup)
 216         {
 217           if (thr->task->taskgroup->cancelled)
 218             return true;
 219           if (thr->task->taskgroup->workshare
 220               && thr->task->taskgroup->prev
 221               && thr->task->taskgroup->prev->cancelled)
 222             return true;
 223         }
 224       /* FALLTHRU into the GOMP_CANCEL_PARALLEL case,
 225          as #pragma omp cancel parallel also cancels all explicit
 226          tasks.  */
 227     }
 228   if (team)
 229     return gomp_team_barrier_cancelled (&team->barrier);
 230   return false;
 231 }
 232 ialias (GOMP_cancellation_point)
 233
 234 bool
 235 GOMP_cancel (int which, bool do_cancel)
 236 {
 237   if (!gomp_cancel_var)
 238     return false;
 239
 240   if (!do_cancel)
 241     return ialias_call (GOMP_cancellation_point) (which);
 242
 243   struct gomp_thread *thr = gomp_thread ();
 244   struct gomp_team *team = thr->ts.team;
 245   if (which & (GOMP_CANCEL_LOOP | GOMP_CANCEL_SECTIONS))
 246     {
 247       /* In orphaned worksharing region, all we want to cancel
 248          is current thread.  */
 249       if (team != NULL)
 250         team->work_share_cancelled = 1;
 251       return true;
 252     }
 253   else if (which & GOMP_CANCEL_TASKGROUP)
 254     {
 255       if (thr->task->taskgroup)
 256         {
 257           struct gomp_taskgroup *taskgroup = thr->task->taskgroup;
 258           if (taskgroup->workshare && taskgroup->prev)
 259             taskgroup = taskgroup->prev;
 260           if (!taskgroup->cancelled)
 261             {
 262               gomp_mutex_lock (&team->task_lock);
 263               taskgroup->cancelled = true;
 264               gomp_mutex_unlock (&team->task_lock);
 265             }
 266         }
 267       return true;
 268     }
 269   team->team_cancelled = 1;
 270   gomp_team_barrier_cancel (team);
 271   return true;
 272 }
 273 \f
 274 /* The public OpenMP API for thread and team related inquiries.  */
 275
 276 int
 277 omp_get_num_threads (void)
 278 {
 279   struct gomp_team *team = gomp_thread ()->ts.team;
 280   return team ? team->nthreads : 1;
 281 }
 282
 283 int
 284 omp_get_thread_num (void)
 285 {
 286   return gomp_thread ()->ts.team_id;
 287 }
 288
 289 /* This wasn't right for OpenMP 2.5.  Active region used to be non-zero
 290    when the IF clause doesn't evaluate to false, starting with OpenMP 3.0
 291    it is non-zero with more than one thread in the team.  */
 292
 293 int
 294 omp_in_parallel (void)
 295 {
 296   return gomp_thread ()->ts.active_level > 0;
 297 }
 298
 299 int
 300 omp_get_level (void)
 301 {
 302   return gomp_thread ()->ts.level;
 303 }
 304
 305 int
 306 omp_get_ancestor_thread_num (int level)
 307 {
 308   struct gomp_team_state *ts = &gomp_thread ()->ts;
 309   if (level < 0 || level > ts->level)
 310     return -1;
 311   for (level = ts->level - level; level > 0; --level)
 312     ts = &ts->team->prev_ts;
 313   return ts->team_id;
 314 }
 315
 316 int
 317 omp_get_team_size (int level)
 318 {
 319   struct gomp_team_state *ts = &gomp_thread ()->ts;
 320   if (level < 0 || level > ts->level)
 321     return -1;
 322   for (level = ts->level - level; level > 0; --level)
 323     ts = &ts->team->prev_ts;
 324   if (ts->team == NULL)
 325     return 1;
 326   else
 327     return ts->team->nthreads;
 328 }
 329
 330 int
 331 omp_get_active_level (void)
 332 {
 333   return gomp_thread ()->ts.active_level;
 334 }
 335
 336 ialias (omp_get_num_threads)
 337 ialias (omp_get_thread_num)
 338 ialias (omp_in_parallel)
 339 ialias (omp_get_level)
 340 ialias (omp_get_ancestor_thread_num)
 341 ialias (omp_get_team_size)
 342 ialias (omp_get_active_level)