libgomp/work.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 contains routines to manage the work-share queue for a team
  29    of threads.  */
  30
  31 #include "libgomp.h"
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35
  36 /* Create a new work share structure.  */
  37
  38 struct gomp_work_share *
  39 gomp_new_work_share (bool ordered, unsigned nthreads)
  40 {
  41   struct gomp_work_share *ws;
  42   size_t size;
  43
  44   size = sizeof (*ws);
  45   if (ordered)
  46     size += nthreads * sizeof (ws->ordered_team_ids[0]);
  47
  48   ws = gomp_malloc_cleared (size);
  49   gomp_mutex_init (&ws->lock);
  50   ws->ordered_owner = -1;
  51
  52   return ws;
  53 }
  54
  55
  56 /* Free a work share structure.  */
  57
  58 static void
  59 free_work_share (struct gomp_work_share *ws)
  60 {
  61   gomp_mutex_destroy (&ws->lock);
  62   free (ws);
  63 }
  64
  65
  66 /* The current thread is ready to begin the next work sharing construct.
  67    In all cases, thr->ts.work_share is updated to point to the new
  68    structure.  In all cases the work_share lock is locked.  Return true
  69    if this was the first thread to reach this point.  */
  70
  71 bool
  72 gomp_work_share_start (bool ordered)
  73 {
  74   struct gomp_thread *thr = gomp_thread ();
  75   struct gomp_team *team = thr->ts.team;
  76   struct gomp_work_share *ws;
  77   unsigned ws_index, ws_gen;
  78
  79   /* Work sharing constructs can be orphaned.  */
  80   if (team == NULL)
  81     {
  82       ws = gomp_new_work_share (ordered, 1);
  83       thr->ts.work_share = ws;
  84       thr->ts.static_trip = 0;
  85       gomp_mutex_lock (&ws->lock);
  86       return true;
  87     }
  88
  89   gomp_mutex_lock (&team->work_share_lock);
  90
  91   /* This thread is beginning its next generation.  */
  92   ws_gen = ++thr->ts.work_share_generation;
  93
  94   /* If this next generation is not newer than any other generation in
  95      the team, then simply reference the existing construct.  */
  96   if (ws_gen - team->oldest_live_gen < team->num_live_gen)
  97     {
  98       ws_index = ws_gen & team->generation_mask;
  99       ws = team->work_shares[ws_index];
 100       thr->ts.work_share = ws;
 101       thr->ts.static_trip = 0;
 102
 103       gomp_mutex_lock (&ws->lock);
 104       gomp_mutex_unlock (&team->work_share_lock);
 105
 106       return false;
 107     }
 108
 109   /* Resize the work shares queue if we've run out of space.  */
 110   if (team->num_live_gen++ == team->generation_mask)
 111     {
 112       team->work_shares = gomp_realloc (team->work_shares,
 113                                         2 * team->num_live_gen
 114                                         * sizeof (*team->work_shares));
 115
 116       /* Unless oldest_live_gen is zero, the sequence of live elements
 117          wraps around the end of the array.  If we do nothing, we break
 118          lookup of the existing elements.  Fix that by unwrapping the
 119          data from the front to the end.  */
 120       if (team->oldest_live_gen > 0)
 121         memcpy (team->work_shares + team->num_live_gen,
 122                 team->work_shares,
 123                 (team->oldest_live_gen & team->generation_mask)
 124                 * sizeof (*team->work_shares));
 125
 126       team->generation_mask = team->generation_mask * 2 + 1;
 127     }
 128
 129   ws_index = ws_gen & team->generation_mask;
 130   ws = gomp_new_work_share (ordered, team->nthreads);
 131   thr->ts.work_share = ws;
 132   thr->ts.static_trip = 0;
 133   team->work_shares[ws_index] = ws;
 134
 135   gomp_mutex_lock (&ws->lock);
 136   gomp_mutex_unlock (&team->work_share_lock);
 137
 138   return true;
 139 }
 140
 141
 142 /* The current thread is done with its current work sharing construct.
 143    This version does imply a barrier at the end of the work-share.  */
 144
 145 void
 146 gomp_work_share_end (void)
 147 {
 148   struct gomp_thread *thr = gomp_thread ();
 149   struct gomp_team *team = thr->ts.team;
 150   struct gomp_work_share *ws = thr->ts.work_share;
 151   bool last;
 152
 153   thr->ts.work_share = NULL;
 154
 155   /* Work sharing constructs can be orphaned.  */
 156   if (team == NULL)
 157     {
 158       free_work_share (ws);
 159       return;
 160     }
 161
 162   last = gomp_barrier_wait_start (&team->barrier);
 163
 164   if (last)
 165     {
 166       unsigned ws_index;
 167
 168       ws_index = thr->ts.work_share_generation & team->generation_mask;
 169       team->work_shares[ws_index] = NULL;
 170       team->oldest_live_gen++;
 171       team->num_live_gen = 0;
 172
 173       free_work_share (ws);
 174     }
 175
 176   gomp_barrier_wait_end (&team->barrier, last);
 177 }
 178
 179
 180 /* The current thread is done with its current work sharing construct.
 181    This version does NOT imply a barrier at the end of the work-share.  */
 182
 183 void
 184 gomp_work_share_end_nowait (void)
 185 {
 186   struct gomp_thread *thr = gomp_thread ();
 187   struct gomp_team *team = thr->ts.team;
 188   struct gomp_work_share *ws = thr->ts.work_share;
 189   unsigned completed;
 190
 191   thr->ts.work_share = NULL;
 192
 193   /* Work sharing constructs can be orphaned.  */
 194   if (team == NULL)
 195     {
 196       free_work_share (ws);
 197       return;
 198     }
 199
 200 #ifdef HAVE_SYNC_BUILTINS
 201   completed = __sync_add_and_fetch (&ws->threads_completed, 1);
 202 #else
 203   gomp_mutex_lock (&ws->lock);
 204   completed = ++ws->threads_completed;
 205   gomp_mutex_unlock (&ws->lock);
 206 #endif
 207
 208   if (completed == team->nthreads)
 209     {
 210       unsigned ws_index;
 211
 212       gomp_mutex_lock (&team->work_share_lock);
 213
 214       ws_index = thr->ts.work_share_generation & team->generation_mask;
 215       team->work_shares[ws_index] = NULL;
 216       team->oldest_live_gen++;
 217       team->num_live_gen--;
 218
 219       gomp_mutex_unlock (&team->work_share_lock);
 220
 221       free_work_share (ws);
 222     }
 223 }