libgomp/config/posix95/lock.c

   1 /* Copyright (C) 2006, 2008, 2009 Free Software Foundation, Inc.
   2
   3    This file is part of the GNU OpenMP Library (libgomp).
   4
   5    Libgomp is free software; you can redistribute it and/or modify it
   6    under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3, or (at your option)
   8    any later version.
   9
  10    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  11    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  12    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13    more details.
  14
  15    Under Section 7 of GPL version 3, you are granted additional
  16    permissions described in the GCC Runtime Library Exception, version
  17    3.1, as published by the Free Software Foundation.
  18
  19    You should have received a copy of the GNU General Public License and
  20    a copy of the GCC Runtime Library Exception along with this program;
  21    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22    <http://www.gnu.org/licenses/>.  */
  23
  24 /* This is the POSIX95 implementation of the public OpenMP locking primitives.
  25
  26    Because OpenMP uses different entry points for normal and recursive
  27    locks, and pthreads uses only one entry point, a system may be able
  28    to do better and streamline the locking as well as reduce the size
  29    of the types exported.  */
  30
  31 #include "libgomp.h"
  32
  33 #ifdef HAVE_BROKEN_POSIX_SEMAPHORES
  34 void
  35 gomp_init_lock_30 (omp_lock_t *lock)
  36 {
  37   pthread_mutex_init (lock, NULL);
  38 }
  39
  40 void
  41 gomp_destroy_lock_30 (omp_lock_t *lock)
  42 {
  43   pthread_mutex_destroy (lock);
  44 }
  45
  46 void
  47 gomp_set_lock_30 (omp_lock_t *lock)
  48 {
  49   pthread_mutex_lock (lock);
  50 }
  51
  52 void
  53 gomp_unset_lock_30 (omp_lock_t *lock)
  54 {
  55   pthread_mutex_unlock (lock);
  56 }
  57
  58 int
  59 gomp_test_lock_30 (omp_lock_t *lock)
  60 {
  61   return pthread_mutex_trylock (lock) == 0;
  62 }
  63
  64 void
  65 gomp_init_nest_lock_30 (omp_nest_lock_t *lock)
  66 {
  67   pthread_mutex_init (&lock->lock, NULL);
  68   lock->owner = NULL;
  69   lock->count = 0;
  70 }
  71
  72 void
  73 gomp_destroy_nest_lock_30 (omp_nest_lock_t *lock)
  74 {
  75   pthread_mutex_destroy (&lock->lock);
  76 }
  77
  78 void
  79 gomp_set_nest_lock_30 (omp_nest_lock_t *lock)
  80 {
  81   void *me = gomp_icv (true);
  82
  83   if (lock->owner != me)
  84     {
  85       pthread_mutex_lock (&lock->lock);
  86       lock->owner = me;
  87     }
  88
  89   lock->count++;
  90 }
  91
  92 void
  93 gomp_unset_nest_lock_30 (omp_nest_lock_t *lock)
  94 {
  95   lock->count--;
  96
  97   if (lock->count == 0)
  98     {
  99       lock->owner = NULL;
 100       pthread_mutex_unlock (&lock->lock);
 101     }
 102 }
 103
 104 int
 105 gomp_test_nest_lock_30 (omp_nest_lock_t *lock)
 106 {
 107   void *me = gomp_icv (true);
 108
 109   if (lock->owner != me)
 110     {
 111       if (pthread_mutex_trylock (&lock->lock) != 0)
 112         return 0;
 113       lock->owner = me;
 114     }
 115
 116   return ++lock->count;
 117 }
 118
 119 #else
 120
 121 void
 122 gomp_init_lock_30 (omp_lock_t *lock)
 123 {
 124   sem_init (lock, 0, 1);
 125 }
 126
 127 void
 128 gomp_destroy_lock_30 (omp_lock_t *lock)
 129 {
 130   sem_destroy (lock);
 131 }
 132
 133 void
 134 gomp_set_lock_30 (omp_lock_t *lock)
 135 {
 136   while (sem_wait (lock) != 0)
 137     ;
 138 }
 139
 140 void
 141 gomp_unset_lock_30 (omp_lock_t *lock)
 142 {
 143   sem_post (lock);
 144 }
 145
 146 int
 147 gomp_test_lock_30 (omp_lock_t *lock)
 148 {
 149   return sem_trywait (lock) == 0;
 150 }
 151
 152 void
 153 gomp_init_nest_lock_30 (omp_nest_lock_t *lock)
 154 {
 155   sem_init (&lock->lock, 0, 1);
 156   lock->count = 0;
 157   lock->owner = NULL;
 158 }
 159
 160 void
 161 gomp_destroy_nest_lock_30 (omp_nest_lock_t *lock)
 162 {
 163   sem_destroy (&lock->lock);
 164 }
 165
 166 void
 167 gomp_set_nest_lock_30 (omp_nest_lock_t *lock)
 168 {
 169   void *me = gomp_icv (true);
 170
 171   if (lock->owner != me)
 172     {
 173       while (sem_wait (&lock->lock) != 0)
 174         ;
 175       lock->owner = me;
 176     }
 177   lock->count++;
 178 }
 179
 180 void
 181 gomp_unset_nest_lock_30 (omp_nest_lock_t *lock)
 182 {
 183   if (--lock->count == 0)
 184     {
 185       lock->owner = NULL;
 186       sem_post (&lock->lock);
 187     }
 188 }
 189
 190 int
 191 gomp_test_nest_lock_30 (omp_nest_lock_t *lock)
 192 {
 193   void *me = gomp_icv (true);
 194
 195   if (lock->owner != me)
 196     {
 197       if (sem_trywait (&lock->lock) != 0)
 198         return 0;
 199       lock->owner = me;
 200     }
 201
 202   return ++lock->count;
 203 }
 204 #endif
 205
 206 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING
 207 void
 208 gomp_init_lock_25 (omp_lock_25_t *lock)
 209 {
 210   pthread_mutex_init (lock, NULL);
 211 }
 212
 213 void
 214 gomp_destroy_lock_25 (omp_lock_25_t *lock)
 215 {
 216   pthread_mutex_destroy (lock);
 217 }
 218
 219 void
 220 gomp_set_lock_25 (omp_lock_25_t *lock)
 221 {
 222   pthread_mutex_lock (lock);
 223 }
 224
 225 void
 226 gomp_unset_lock_25 (omp_lock_25_t *lock)
 227 {
 228   pthread_mutex_unlock (lock);
 229 }
 230
 231 int
 232 gomp_test_lock_25 (omp_lock_25_t *lock)
 233 {
 234   return pthread_mutex_trylock (lock) == 0;
 235 }
 236
 237 void
 238 gomp_init_nest_lock_25 (omp_nest_lock_25_t *lock)
 239 {
 240   pthread_mutex_init (&lock->lock, NULL);
 241   lock->owner = (pthread_t) 0;
 242   lock->count = 0;
 243 }
 244
 245 void
 246 gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *lock)
 247 {
 248   pthread_mutex_destroy (&lock->lock);
 249 }
 250
 251 void
 252 gomp_set_nest_lock_25 (omp_nest_lock_25_t *lock)
 253 {
 254   pthread_t me = pthread_self ();
 255
 256   if (lock->owner != me)
 257     {
 258       pthread_mutex_lock (&lock->lock);
 259       lock->owner = me;
 260     }
 261
 262   lock->count++;
 263 }
 264
 265 void
 266 gomp_unset_nest_lock_25 (omp_nest_lock_25_t *lock)
 267 {
 268   lock->count--;
 269
 270   if (lock->count == 0)
 271     {
 272       lock->owner = (pthread_t) 0;
 273       pthread_mutex_unlock (&lock->lock);
 274     }
 275 }
 276
 277 int
 278 gomp_test_nest_lock_25 (omp_nest_lock_25_t *lock)
 279 {
 280   pthread_t me = pthread_self ();
 281
 282   if (lock->owner != me)
 283     {
 284       if (pthread_mutex_trylock (&lock->lock) != 0)
 285         return 0;
 286       lock->owner = me;
 287     }
 288
 289   return ++lock->count;
 290 }
 291
 292 omp_lock_symver (omp_init_lock)
 293 omp_lock_symver (omp_destroy_lock)
 294 omp_lock_symver (omp_set_lock)
 295 omp_lock_symver (omp_unset_lock)
 296 omp_lock_symver (omp_test_lock)
 297 omp_lock_symver (omp_init_nest_lock)
 298 omp_lock_symver (omp_destroy_nest_lock)
 299 omp_lock_symver (omp_set_nest_lock)
 300 omp_lock_symver (omp_unset_nest_lock)
 301 omp_lock_symver (omp_test_nest_lock)
 302
 303 #else
 304
 305 ialias (omp_init_lock)
 306 ialias (omp_init_nest_lock)
 307 ialias (omp_destroy_lock)
 308 ialias (omp_destroy_nest_lock)
 309 ialias (omp_set_lock)
 310 ialias (omp_set_nest_lock)
 311 ialias (omp_unset_lock)
 312 ialias (omp_unset_nest_lock)
 313 ialias (omp_test_lock)
 314 ialias (omp_test_nest_lock)
 315
 316 #endif