libgomp/config/posix/bar.c

   1 /* Copyright (C) 2005-2013 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 is the default implementation of a barrier synchronization mechanism
  26    for libgomp.  This type is private to the library.  Note that we rely on
  27    being able to adjust the barrier count while threads are blocked, so the
  28    POSIX pthread_barrier_t won't work.  */
  29
  30 #include "libgomp.h"
  31
  32
  33 void
  34 gomp_barrier_init (gomp_barrier_t *bar, unsigned count)
  35 {
  36   gomp_mutex_init (&bar->mutex1);
  37 #ifndef HAVE_SYNC_BUILTINS
  38   gomp_mutex_init (&bar->mutex2);
  39 #endif
  40   gomp_sem_init (&bar->sem1, 0);
  41   gomp_sem_init (&bar->sem2, 0);
  42   bar->total = count;
  43   bar->arrived = 0;
  44   bar->generation = 0;
  45   bar->cancellable = false;
  46 }
  47
  48 void
  49 gomp_barrier_destroy (gomp_barrier_t *bar)
  50 {
  51   /* Before destroying, make sure all threads have left the barrier.  */
  52   gomp_mutex_lock (&bar->mutex1);
  53   gomp_mutex_unlock (&bar->mutex1);
  54
  55   gomp_mutex_destroy (&bar->mutex1);
  56 #ifndef HAVE_SYNC_BUILTINS
  57   gomp_mutex_destroy (&bar->mutex2);
  58 #endif
  59   gomp_sem_destroy (&bar->sem1);
  60   gomp_sem_destroy (&bar->sem2);
  61 }
  62
  63 void
  64 gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count)
  65 {
  66   gomp_mutex_lock (&bar->mutex1);
  67   bar->total = count;
  68   gomp_mutex_unlock (&bar->mutex1);
  69 }
  70
  71 void
  72 gomp_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)
  73 {
  74   unsigned int n;
  75
  76   if (state & BAR_WAS_LAST)
  77     {
  78       n = --bar->arrived;
  79       if (n > 0)
  80         {
  81           do
  82             gomp_sem_post (&bar->sem1);
  83           while (--n != 0);
  84           gomp_sem_wait (&bar->sem2);
  85         }
  86       gomp_mutex_unlock (&bar->mutex1);
  87     }
  88   else
  89     {
  90       gomp_mutex_unlock (&bar->mutex1);
  91       gomp_sem_wait (&bar->sem1);
  92
  93 #ifdef HAVE_SYNC_BUILTINS
  94       n = __sync_add_and_fetch (&bar->arrived, -1);
  95 #else
  96       gomp_mutex_lock (&bar->mutex2);
  97       n = --bar->arrived;
  98       gomp_mutex_unlock (&bar->mutex2);
  99 #endif
 100
 101       if (n == 0)
 102         gomp_sem_post (&bar->sem2);
 103     }
 104 }
 105
 106 void
 107 gomp_barrier_wait (gomp_barrier_t *barrier)
 108 {
 109   gomp_barrier_wait_end (barrier, gomp_barrier_wait_start (barrier));
 110 }
 111
 112 void
 113 gomp_team_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)
 114 {
 115   unsigned int n;
 116
 117   state &= ~BAR_CANCELLED;
 118   if (state & BAR_WAS_LAST)
 119     {
 120       n = --bar->arrived;
 121       struct gomp_thread *thr = gomp_thread ();
 122       struct gomp_team *team = thr->ts.team;
 123
 124       team->work_share_cancelled = 0;
 125       if (team->task_count)
 126         {
 127           gomp_barrier_handle_tasks (state);
 128           if (n > 0)
 129             gomp_sem_wait (&bar->sem2);
 130           gomp_mutex_unlock (&bar->mutex1);
 131           return;
 132         }
 133
 134       bar->generation = state + BAR_INCR - BAR_WAS_LAST;
 135       if (n > 0)
 136         {
 137           do
 138             gomp_sem_post (&bar->sem1);
 139           while (--n != 0);
 140           gomp_sem_wait (&bar->sem2);
 141         }
 142       gomp_mutex_unlock (&bar->mutex1);
 143     }
 144   else
 145     {
 146       gomp_mutex_unlock (&bar->mutex1);
 147       int gen;
 148       do
 149         {
 150           gomp_sem_wait (&bar->sem1);
 151           gen = __atomic_load_n (&bar->generation, MEMMODEL_ACQUIRE);
 152           if (gen & BAR_TASK_PENDING)
 153             {
 154               gomp_barrier_handle_tasks (state);
 155               gen = __atomic_load_n (&bar->generation, MEMMODEL_ACQUIRE);
 156             }
 157         }
 158       while (gen != state + BAR_INCR);
 159
 160 #ifdef HAVE_SYNC_BUILTINS
 161       n = __sync_add_and_fetch (&bar->arrived, -1);
 162 #else
 163       gomp_mutex_lock (&bar->mutex2);
 164       n = --bar->arrived;
 165       gomp_mutex_unlock (&bar->mutex2);
 166 #endif
 167
 168       if (n == 0)
 169         gomp_sem_post (&bar->sem2);
 170     }
 171 }
 172
 173 bool
 174 gomp_team_barrier_wait_cancel_end (gomp_barrier_t *bar,
 175                                    gomp_barrier_state_t state)
 176 {
 177   unsigned int n;
 178
 179   if (state & BAR_WAS_LAST)
 180     {
 181       bar->cancellable = false;
 182       n = --bar->arrived;
 183       struct gomp_thread *thr = gomp_thread ();
 184       struct gomp_team *team = thr->ts.team;
 185
 186       team->work_share_cancelled = 0;
 187       if (team->task_count)
 188         {
 189           gomp_barrier_handle_tasks (state);
 190           if (n > 0)
 191             gomp_sem_wait (&bar->sem2);
 192           gomp_mutex_unlock (&bar->mutex1);
 193           return false;
 194         }
 195
 196       bar->generation = state + BAR_INCR - BAR_WAS_LAST;
 197       if (n > 0)
 198         {
 199           do
 200             gomp_sem_post (&bar->sem1);
 201           while (--n != 0);
 202           gomp_sem_wait (&bar->sem2);
 203         }
 204       gomp_mutex_unlock (&bar->mutex1);
 205     }
 206   else
 207     {
 208       if (state & BAR_CANCELLED)
 209         {
 210           gomp_mutex_unlock (&bar->mutex1);
 211           return true;
 212         }
 213       bar->cancellable = true;
 214       gomp_mutex_unlock (&bar->mutex1);
 215       int gen;
 216       do
 217         {
 218           gomp_sem_wait (&bar->sem1);
 219           gen = __atomic_load_n (&bar->generation, MEMMODEL_ACQUIRE);
 220           if (gen & BAR_CANCELLED)
 221             break;
 222           if (gen & BAR_TASK_PENDING)
 223             {
 224               gomp_barrier_handle_tasks (state);
 225               gen = __atomic_load_n (&bar->generation, MEMMODEL_ACQUIRE);
 226               if (gen & BAR_CANCELLED)
 227                 break;
 228             }
 229         }
 230       while (gen != state + BAR_INCR);
 231
 232 #ifdef HAVE_SYNC_BUILTINS
 233       n = __sync_add_and_fetch (&bar->arrived, -1);
 234 #else
 235       gomp_mutex_lock (&bar->mutex2);
 236       n = --bar->arrived;
 237       gomp_mutex_unlock (&bar->mutex2);
 238 #endif
 239
 240       if (n == 0)
 241         gomp_sem_post (&bar->sem2);
 242       if (gen & BAR_CANCELLED)
 243         return true;
 244     }
 245   return false;
 246 }
 247
 248 void
 249 gomp_team_barrier_wait (gomp_barrier_t *barrier)
 250 {
 251   gomp_team_barrier_wait_end (barrier, gomp_barrier_wait_start (barrier));
 252 }
 253
 254 void
 255 gomp_team_barrier_wake (gomp_barrier_t *bar, int count)
 256 {
 257   if (count == 0)
 258     count = bar->total - 1;
 259   while (count-- > 0)
 260     gomp_sem_post (&bar->sem1);
 261 }
 262
 263 bool
 264 gomp_team_barrier_wait_cancel (gomp_barrier_t *bar)
 265 {
 266   gomp_barrier_state_t state = gomp_barrier_wait_cancel_start (bar);
 267   return gomp_team_barrier_wait_cancel_end (bar, state);
 268 }
 269
 270 void
 271 gomp_team_barrier_cancel (struct gomp_team *team)
 272 {
 273   if (team->barrier.generation & BAR_CANCELLED)
 274     return;
 275   gomp_mutex_lock (&team->barrier.mutex1);
 276   gomp_mutex_lock (&team->task_lock);
 277   if (team->barrier.generation & BAR_CANCELLED)
 278     {
 279       gomp_mutex_unlock (&team->task_lock);
 280       gomp_mutex_unlock (&team->barrier.mutex1);
 281       return;
 282     }
 283   team->barrier.generation |= BAR_CANCELLED;
 284   gomp_mutex_unlock (&team->task_lock);
 285   if (team->barrier.cancellable)
 286     {
 287       int n = team->barrier.arrived;
 288       if (n > 0)
 289         {
 290           do
 291             gomp_sem_post (&team->barrier.sem1);
 292           while (--n != 0);
 293           gomp_sem_wait (&team->barrier.sem2);
 294         }
 295       team->barrier.cancellable = false;
 296     }
 297   gomp_mutex_unlock (&team->barrier.mutex1);
 298 }