libgomp/sections.c

   1 /* Copyright (C) 2005-2023 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 SECTIONS construct.  */
  27
  28 #include "libgomp.h"
  29 #include <string.h>
  30
  31
  32 ialias_redirect (GOMP_taskgroup_reduction_register)
  33
  34 /* Initialize the given work share construct from the given arguments.  */
  35
  36 static inline void
  37 gomp_sections_init (struct gomp_work_share *ws, unsigned count)
  38 {
  39   ws->sched = GFS_DYNAMIC;
  40   ws->chunk_size = 1;
  41   ws->end = count + 1L;
  42   ws->incr = 1;
  43   ws->next = 1;
  44 #ifdef HAVE_SYNC_BUILTINS
  45   /* Prepare things to make each iteration faster.  */
  46   if (sizeof (long) > sizeof (unsigned))
  47     ws->mode = 1;
  48   else
  49     {
  50       struct gomp_thread *thr = gomp_thread ();
  51       struct gomp_team *team = thr->ts.team;
  52       long nthreads = team ? team->nthreads : 1;
  53
  54       ws->mode = ((nthreads | ws->end)
  55                   < 1UL << (sizeof (long) * __CHAR_BIT__ / 2 - 1));
  56     }
  57 #else
  58   ws->mode = 0;
  59 #endif
  60 }
  61
  62 /* This routine is called when first encountering a sections construct
  63    that is not bound directly to a parallel construct.  The first thread
  64    that arrives will create the work-share construct; subsequent threads
  65    will see the construct exists and allocate work from it.
  66
  67    COUNT is the number of sections in this construct.
  68
  69    Returns the 1-based section number for this thread to perform, or 0 if
  70    all work was assigned to other threads prior to this thread's arrival.  */
  71
  72 unsigned
  73 GOMP_sections_start (unsigned count)
  74 {
  75   struct gomp_thread *thr = gomp_thread ();
  76   long s, e, ret;
  77
  78   if (gomp_work_share_start (0))
  79     {
  80       gomp_sections_init (thr->ts.work_share, count);
  81       gomp_work_share_init_done ();
  82     }
  83
  84 #ifdef HAVE_SYNC_BUILTINS
  85   if (gomp_iter_dynamic_next (&s, &e))
  86     ret = s;
  87   else
  88     ret = 0;
  89 #else
  90   gomp_mutex_lock (&thr->ts.work_share->lock);
  91   if (gomp_iter_dynamic_next_locked (&s, &e))
  92     ret = s;
  93   else
  94     ret = 0;
  95   gomp_mutex_unlock (&thr->ts.work_share->lock);
  96 #endif
  97
  98   return ret;
  99 }
 100
 101 unsigned
 102 GOMP_sections2_start (unsigned count, uintptr_t *reductions, void **mem)
 103 {
 104   struct gomp_thread *thr = gomp_thread ();
 105   long s, e, ret;
 106
 107   if (reductions)
 108     gomp_workshare_taskgroup_start ();
 109   if (gomp_work_share_start (0))
 110     {
 111       gomp_sections_init (thr->ts.work_share, count);
 112       if (reductions)
 113         {
 114           GOMP_taskgroup_reduction_register (reductions);
 115           thr->task->taskgroup->workshare = true;
 116           thr->ts.work_share->task_reductions = reductions;
 117         }
 118       if (mem)
 119         {
 120           uintptr_t size = (uintptr_t) *mem;
 121 #define INLINE_ORDERED_TEAM_IDS_OFF \
 122   ((offsetof (struct gomp_work_share, inline_ordered_team_ids)          \
 123     + __alignof__ (long long) - 1) & ~(__alignof__ (long long) - 1))
 124           if (sizeof (struct gomp_work_share)
 125               <= INLINE_ORDERED_TEAM_IDS_OFF
 126               || __alignof__ (struct gomp_work_share) < __alignof__ (long long)
 127               || size > (sizeof (struct gomp_work_share)
 128                         - INLINE_ORDERED_TEAM_IDS_OFF))
 129             *mem
 130               = (void *) (thr->ts.work_share->ordered_team_ids
 131                           = gomp_malloc_cleared (size));
 132           else
 133             *mem = memset (((char *) thr->ts.work_share)
 134                            + INLINE_ORDERED_TEAM_IDS_OFF, '\0', size);
 135         }
 136       gomp_work_share_init_done ();
 137     }
 138   else
 139     {
 140       if (reductions)
 141         {
 142           uintptr_t *first_reductions = thr->ts.work_share->task_reductions;
 143           gomp_workshare_task_reduction_register (reductions,
 144                                                   first_reductions);
 145         }
 146       if (mem)
 147         {
 148           if ((offsetof (struct gomp_work_share, inline_ordered_team_ids)
 149                & (__alignof__ (long long) - 1)) == 0)
 150             *mem = (void *) thr->ts.work_share->ordered_team_ids;
 151           else
 152             {
 153               uintptr_t p = (uintptr_t) thr->ts.work_share->ordered_team_ids;
 154               p += __alignof__ (long long) - 1;
 155               p &= ~(__alignof__ (long long) - 1);
 156               *mem = (void *) p;
 157             }
 158         }
 159     }
 160
 161 #ifdef HAVE_SYNC_BUILTINS
 162   if (gomp_iter_dynamic_next (&s, &e))
 163     ret = s;
 164   else
 165     ret = 0;
 166 #else
 167   gomp_mutex_lock (&thr->ts.work_share->lock);
 168   if (gomp_iter_dynamic_next_locked (&s, &e))
 169     ret = s;
 170   else
 171     ret = 0;
 172   gomp_mutex_unlock (&thr->ts.work_share->lock);
 173 #endif
 174
 175   return ret;
 176 }
 177
 178 /* This routine is called when the thread completes processing of the
 179    section currently assigned to it.  If the work-share construct is
 180    bound directly to a parallel construct, then the construct may have
 181    been set up before the parallel.  In which case, this may be the
 182    first iteration for the thread.
 183
 184    Returns the 1-based section number for this thread to perform, or 0 if
 185    all work was assigned to other threads prior to this thread's arrival.  */
 186
 187 unsigned
 188 GOMP_sections_next (void)
 189 {
 190   long s, e, ret;
 191
 192 #ifdef HAVE_SYNC_BUILTINS
 193   if (gomp_iter_dynamic_next (&s, &e))
 194     ret = s;
 195   else
 196     ret = 0;
 197 #else
 198   struct gomp_thread *thr = gomp_thread ();
 199
 200   gomp_mutex_lock (&thr->ts.work_share->lock);
 201   if (gomp_iter_dynamic_next_locked (&s, &e))
 202     ret = s;
 203   else
 204     ret = 0;
 205   gomp_mutex_unlock (&thr->ts.work_share->lock);
 206 #endif
 207
 208   return ret;
 209 }
 210
 211 /* This routine pre-initializes a work-share construct to avoid one
 212    synchronization once we get into the loop.  */
 213
 214 void
 215 GOMP_parallel_sections_start (void (*fn) (void *), void *data,
 216                               unsigned num_threads, unsigned count)
 217 {
 218   struct gomp_team *team;
 219
 220   num_threads = gomp_resolve_num_threads (num_threads, count);
 221   team = gomp_new_team (num_threads);
 222   gomp_sections_init (&team->work_shares[0], count);
 223   gomp_team_start (fn, data, num_threads, 0, team, NULL);
 224 }
 225
 226 ialias_redirect (GOMP_parallel_end)
 227
 228 void
 229 GOMP_parallel_sections (void (*fn) (void *), void *data,
 230                         unsigned num_threads, unsigned count, unsigned flags)
 231 {
 232   struct gomp_team *team;
 233
 234   num_threads = gomp_resolve_num_threads (num_threads, count);
 235   team = gomp_new_team (num_threads);
 236   gomp_sections_init (&team->work_shares[0], count);
 237   gomp_team_start (fn, data, num_threads, flags, team, NULL);
 238   fn (data);
 239   GOMP_parallel_end ();
 240 }
 241
 242 /* The GOMP_section_end* routines are called after the thread is told
 243    that all sections are complete.  The first two versions synchronize
 244    all threads; the nowait version does not.  */
 245
 246 void
 247 GOMP_sections_end (void)
 248 {
 249   gomp_work_share_end ();
 250 }
 251
 252 bool
 253 GOMP_sections_end_cancel (void)
 254 {
 255   return gomp_work_share_end_cancel ();
 256 }
 257
 258 void
 259 GOMP_sections_end_nowait (void)
 260 {
 261   gomp_work_share_end_nowait ();
 262 }