src/misc/threads.c

   1 /*****************************************************************************
   2  * threads.c: LibVLC generic thread support
   3  *****************************************************************************
   4  * Copyright (C) 2009-2016 Rémi Denis-Courmont
   5  *
   6  * This program 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  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27
  28 #include <vlc_common.h>
  29
  30 /*** Global locks ***/
  31
  32 void vlc_global_mutex (unsigned n, bool acquire)
  33 {
  34     static vlc_mutex_t locks[] = {
  35         VLC_STATIC_MUTEX,
  36         VLC_STATIC_MUTEX,
  37         VLC_STATIC_MUTEX,
  38         VLC_STATIC_MUTEX,
  39 #ifdef _WIN32
  40         VLC_STATIC_MUTEX, // For MTA holder
  41 #endif
  42     };
  43     static_assert (VLC_MAX_MUTEX == (sizeof (locks) / sizeof (locks[0])),
  44                    "Wrong number of global mutexes");
  45     assert (n < (sizeof (locks) / sizeof (locks[0])));
  46
  47     vlc_mutex_t *lock = locks + n;
  48     if (acquire)
  49         vlc_mutex_lock (lock);
  50     else
  51         vlc_mutex_unlock (lock);
  52 }
  53
  54 #if defined (_WIN32) && (_WIN32_WINNT < _WIN32_WINNT_WIN8)
  55 /* Cannot define OS version-dependent stuff in public headers */
  56 # undef LIBVLC_NEED_SLEEP
  57 # undef LIBVLC_NEED_SEMAPHORE
  58 #endif
  59
  60 #if defined(LIBVLC_NEED_SLEEP) || defined(LIBVLC_NEED_CONDVAR)
  61 #include <stdatomic.h>
  62
  63 static void vlc_cancel_addr_prepare(void *addr)
  64 {
  65     /* Let thread subsystem on address to broadcast for cancellation */
  66     vlc_cancel_addr_set(addr);
  67     vlc_cleanup_push(vlc_cancel_addr_clear, addr);
  68     /* Check if cancellation was pending before vlc_cancel_addr_set() */
  69     vlc_testcancel();
  70     vlc_cleanup_pop();
  71 }
  72
  73 static void vlc_cancel_addr_finish(void *addr)
  74 {
  75     vlc_cancel_addr_clear(addr);
  76     /* Act on cancellation as potential wake-up source */
  77     vlc_testcancel();
  78 }
  79 #endif
  80
  81 #ifdef LIBVLC_NEED_SLEEP
  82 void (vlc_tick_wait)(vlc_tick_t deadline)
  83 {
  84     vlc_tick_t delay;
  85     atomic_int value = ATOMIC_VAR_INIT(0);
  86
  87     vlc_cancel_addr_prepare(&value);
  88
  89     while ((delay = (deadline - vlc_tick_now())) > 0)
  90     {
  91         vlc_addr_timedwait(&value, 0, delay);
  92         vlc_testcancel();
  93     }
  94
  95     vlc_cancel_addr_finish(&value);
  96 }
  97
  98 void (vlc_tick_sleep)(vlc_tick_t delay)
  99 {
 100     vlc_tick_wait(vlc_tick_now() + delay);
 101 }
 102 #endif
 103
 104 #ifdef LIBVLC_NEED_CONDVAR
 105 #include <stdalign.h>
 106
 107 static inline atomic_uint *vlc_cond_value(vlc_cond_t *cond)
 108 {
 109     /* XXX: ugly but avoids including stdatomic.h in vlc_threads.h */
 110     static_assert (sizeof (cond->value) <= sizeof (atomic_uint),
 111                    "Size mismatch!");
 112     static_assert ((alignof (cond->value) % alignof (atomic_uint)) == 0,
 113                    "Alignment mismatch");
 114     return (atomic_uint *)&cond->value;
 115 }
 116
 117 void vlc_cond_init(vlc_cond_t *cond)
 118 {
 119     /* Initial value is irrelevant but set it for happy debuggers */
 120     atomic_init(vlc_cond_value(cond), 0);
 121 }
 122
 123 void vlc_cond_init_daytime(vlc_cond_t *cond)
 124 {
 125     vlc_cond_init(cond);
 126 }
 127
 128 void vlc_cond_destroy(vlc_cond_t *cond)
 129 {
 130     /* Tempting sanity check but actually incorrect:
 131     assert((atomic_load_explicit(vlc_cond_value(cond),
 132                                  memory_order_relaxed) & 1) == 0);
 133      * Due to timeouts and spurious wake-ups, the futex value can look like
 134      * there are waiters, even though there are none. */
 135     (void) cond;
 136 }
 137
 138 void vlc_cond_signal(vlc_cond_t *cond)
 139 {
 140     /* Probably the best documented approach is that of Bionic: increment
 141      * the futex here, and simply load the value in cnd_wait(). This has a bug
 142      * as unlikely as well-known: signals get lost if the futex is incremented
 143      * an exact multiple of 2^(CHAR_BIT * sizeof (int)) times.
 144      *
 145      * A different presumably bug-free solution is used here:
 146      * - cnd_signal() sets the futex to the equal-or-next odd value, while
 147      * - cnd_wait() sets the futex to the equal-or-next even value.
 148      **/
 149     atomic_fetch_or_explicit(vlc_cond_value(cond), 1, memory_order_relaxed);
 150     vlc_addr_signal(&cond->value);
 151 }
 152
 153 void vlc_cond_broadcast(vlc_cond_t *cond)
 154 {
 155     atomic_fetch_or_explicit(vlc_cond_value(cond), 1, memory_order_relaxed);
 156     vlc_addr_broadcast(&cond->value);
 157 }
 158
 159 void vlc_cond_wait(vlc_cond_t *cond, vlc_mutex_t *mutex)
 160 {
 161     unsigned value = atomic_load_explicit(vlc_cond_value(cond),
 162                                      memory_order_relaxed);
 163     while (value & 1)
 164     {
 165         if (atomic_compare_exchange_weak_explicit(vlc_cond_value(cond), &value,
 166                                                   value + 1,
 167                                                   memory_order_relaxed,
 168                                                   memory_order_relaxed))
 169             value++;
 170     }
 171
 172     vlc_cancel_addr_prepare(&cond->value);
 173     vlc_mutex_unlock(mutex);
 174
 175     vlc_addr_wait(&cond->value, value);
 176
 177     vlc_mutex_lock(mutex);
 178     vlc_cancel_addr_finish(&cond->value);
 179 }
 180
 181 static int vlc_cond_wait_delay(vlc_cond_t *cond, vlc_mutex_t *mutex,
 182                                vlc_tick_t delay)
 183 {
 184     unsigned value = atomic_load_explicit(vlc_cond_value(cond),
 185                                           memory_order_relaxed);
 186     while (value & 1)
 187     {
 188         if (atomic_compare_exchange_weak_explicit(vlc_cond_value(cond), &value,
 189                                                   value + 1,
 190                                                   memory_order_relaxed,
 191                                                   memory_order_relaxed))
 192             value++;
 193     }
 194
 195     vlc_cancel_addr_prepare(&cond->value);
 196     vlc_mutex_unlock(mutex);
 197
 198     if (delay > 0)
 199         value = vlc_addr_timedwait(&cond->value, value, delay);
 200     else
 201         value = 0;
 202
 203     vlc_mutex_lock(mutex);
 204     vlc_cancel_addr_finish(&cond->value);
 205
 206     return value ? 0 : ETIMEDOUT;
 207 }
 208
 209 int vlc_cond_timedwait(vlc_cond_t *cond, vlc_mutex_t *mutex, vlc_tick_t deadline)
 210 {
 211     return vlc_cond_wait_delay(cond, mutex, deadline - vlc_tick_now());
 212 }
 213
 214 int vlc_cond_timedwait_daytime(vlc_cond_t *cond, vlc_mutex_t *mutex,
 215                                time_t deadline_daytime)
 216 {
 217     struct timespec ts;
 218     vlc_tick_t deadline = vlc_tick_from_sec( deadline_daytime );
 219
 220     timespec_get(&ts, TIME_UTC);
 221     deadline -= vlc_tick_from_timespec( &ts );
 222
 223     return vlc_cond_wait_delay(cond, mutex, deadline);
 224 }
 225 #endif
 226
 227 #ifdef LIBVLC_NEED_RWLOCK
 228 /*** Generic read/write locks ***/
 229 #include <stdlib.h>
 230 #include <limits.h>
 231 /* NOTE:
 232  * lock->state is a signed long integer:
 233  *  - The sign bit is set when the lock is held for writing.
 234  *  - The other bits code the number of times the lock is held for reading.
 235  * Consequently:
 236  *  - The value is negative if and only if the lock is held for writing.
 237  *  - The value is zero if and only if the lock is not held at all.
 238  */
 239 #define READER_MASK LONG_MAX
 240 #define WRITER_BIT  LONG_MIN
 241
 242 void vlc_rwlock_init (vlc_rwlock_t *lock)
 243 {
 244     vlc_mutex_init (&lock->mutex);
 245     vlc_cond_init (&lock->wait);
 246     lock->state = 0;
 247 }
 248
 249 void vlc_rwlock_destroy (vlc_rwlock_t *lock)
 250 {
 251     vlc_cond_destroy (&lock->wait);
 252     vlc_mutex_destroy (&lock->mutex);
 253 }
 254
 255 void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
 256 {
 257     vlc_mutex_lock (&lock->mutex);
 258     /* Recursive read-locking is allowed.
 259      * Ensure that there is no active writer. */
 260     while (lock->state < 0)
 261     {
 262         assert (lock->state == WRITER_BIT);
 263         mutex_cleanup_push (&lock->mutex);
 264         vlc_cond_wait (&lock->wait, &lock->mutex);
 265         vlc_cleanup_pop ();
 266     }
 267     if (unlikely(lock->state >= READER_MASK))
 268         abort (); /* An overflow is certainly a recursion bug. */
 269     lock->state++;
 270     vlc_mutex_unlock (&lock->mutex);
 271 }
 272
 273 void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
 274 {
 275     vlc_mutex_lock (&lock->mutex);
 276     /* Wait until nobody owns the lock in any way. */
 277     while (lock->state != 0)
 278     {
 279         mutex_cleanup_push (&lock->mutex);
 280         vlc_cond_wait (&lock->wait, &lock->mutex);
 281         vlc_cleanup_pop ();
 282     }
 283     lock->state = WRITER_BIT;
 284     vlc_mutex_unlock (&lock->mutex);
 285 }
 286
 287 void vlc_rwlock_unlock (vlc_rwlock_t *lock)
 288 {
 289     vlc_mutex_lock (&lock->mutex);
 290     if (lock->state < 0)
 291     {   /* Write unlock */
 292         assert (lock->state == WRITER_BIT);
 293         /* Let reader and writer compete. OS scheduler decides who wins. */
 294         lock->state = 0;
 295         vlc_cond_broadcast (&lock->wait);
 296     }
 297     else
 298     {   /* Read unlock */
 299         assert (lock->state > 0);
 300         /* If there are no readers left, wake up one pending writer. */
 301         if (--lock->state == 0)
 302             vlc_cond_signal (&lock->wait);
 303     }
 304     vlc_mutex_unlock (&lock->mutex);
 305 }
 306 #endif /* LIBVLC_NEED_RWLOCK */
 307
 308 #ifdef LIBVLC_NEED_SEMAPHORE
 309 /*** Generic semaphores ***/
 310 #include <limits.h>
 311 #include <errno.h>
 312
 313 void vlc_sem_init (vlc_sem_t *sem, unsigned value)
 314 {
 315     vlc_mutex_init (&sem->lock);
 316     vlc_cond_init (&sem->wait);
 317     sem->value = value;
 318 }
 319
 320 void vlc_sem_destroy (vlc_sem_t *sem)
 321 {
 322     vlc_cond_destroy (&sem->wait);
 323     vlc_mutex_destroy (&sem->lock);
 324 }
 325
 326 int vlc_sem_post (vlc_sem_t *sem)
 327 {
 328     int ret = 0;
 329
 330     vlc_mutex_lock (&sem->lock);
 331     if (likely(sem->value != UINT_MAX))
 332         sem->value++;
 333     else
 334         ret = EOVERFLOW;
 335     vlc_mutex_unlock (&sem->lock);
 336     vlc_cond_signal (&sem->wait);
 337
 338     return ret;
 339 }
 340
 341 void vlc_sem_wait (vlc_sem_t *sem)
 342 {
 343     vlc_mutex_lock (&sem->lock);
 344     mutex_cleanup_push (&sem->lock);
 345     while (!sem->value)
 346         vlc_cond_wait (&sem->wait, &sem->lock);
 347     sem->value--;
 348     vlc_cleanup_pop ();
 349     vlc_mutex_unlock (&sem->lock);
 350 }
 351 #endif /* LIBVLC_NEED_SEMAPHORE */