source/utils/CarlaMutex.hpp

   1 /*
   2  * Carla Mutex
   3  * Copyright (C) 2013-2023 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #ifndef CARLA_MUTEX_HPP_INCLUDED
  19 #define CARLA_MUTEX_HPP_INCLUDED
  20
  21 #include "CarlaUtils.hpp"
  22
  23 #include <pthread.h>
  24
  25 class CarlaSignal;
  26
  27 // -----------------------------------------------------------------------
  28 // CarlaMutex class
  29
  30 class CARLA_API CarlaMutex
  31 {
  32 public:
  33     /*
  34      * Constructor.
  35      */
  36     CarlaMutex(const bool inheritPriority = true) noexcept
  37         : fMutex(),
  38           fTryLockWasCalled(false)
  39     {
  40         pthread_mutexattr_t attr;
  41         pthread_mutexattr_init(&attr);
  42        #ifndef PTW32_DLLPORT
  43         pthread_mutexattr_setprotocol(&attr, inheritPriority ? PTHREAD_PRIO_INHERIT : PTHREAD_PRIO_NONE);
  44        #else
  45         // unsupported?
  46         (void)inheritPriority;
  47        #endif
  48         pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
  49         pthread_mutex_init(&fMutex, &attr);
  50         pthread_mutexattr_destroy(&attr);
  51     }
  52
  53     /*
  54      * Destructor.
  55      */
  56     ~CarlaMutex() noexcept
  57     {
  58         pthread_mutex_destroy(&fMutex);
  59     }
  60
  61     /*
  62      * Check if "tryLock()" was called before.
  63      */
  64     bool wasTryLockCalled() const noexcept
  65     {
  66         const bool ret(fTryLockWasCalled);
  67         fTryLockWasCalled = false;
  68         return ret;
  69     }
  70
  71     /*
  72      * Lock the mutex.
  73      */
  74     bool lock() const noexcept
  75     {
  76         return (pthread_mutex_lock(&fMutex) == 0);
  77     }
  78
  79     /*
  80      * Try to lock the mutex.
  81      * Returns true if successful.
  82      */
  83     bool tryLock() const noexcept
  84     {
  85         fTryLockWasCalled = true;
  86
  87         return (pthread_mutex_trylock(&fMutex) == 0);
  88     }
  89
  90     /*
  91      * Unlock the mutex, optionally resetting the tryLock check.
  92      */
  93     void unlock(const bool resetTryLock = false) const noexcept
  94     {
  95         if (resetTryLock)
  96             fTryLockWasCalled = false;
  97
  98         pthread_mutex_unlock(&fMutex);
  99     }
 100
 101 private:
 102     mutable pthread_mutex_t fMutex;
 103     mutable volatile bool fTryLockWasCalled; // true if "tryLock()" was called at least once
 104
 105     CARLA_DECLARE_NON_COPYABLE(CarlaMutex)
 106 };
 107
 108 // -----------------------------------------------------------------------
 109 // CarlaRecursiveMutex class
 110
 111 class CarlaRecursiveMutex
 112 {
 113 public:
 114     /*
 115      * Constructor.
 116      */
 117     CarlaRecursiveMutex() noexcept
 118        #ifdef CARLA_OS_WIN
 119         : fSection()
 120        #else
 121         : fMutex()
 122        #endif
 123     {
 124        #ifdef CARLA_OS_WIN
 125         InitializeCriticalSection(&fSection);
 126        #else
 127         pthread_mutexattr_t attr;
 128         pthread_mutexattr_init(&attr);
 129         pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
 130         pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 131         pthread_mutex_init(&fMutex, &attr);
 132         pthread_mutexattr_destroy(&attr);
 133        #endif
 134     }
 135
 136     /*
 137      * Destructor.
 138      */
 139     ~CarlaRecursiveMutex() noexcept
 140     {
 141        #ifdef CARLA_OS_WIN
 142         DeleteCriticalSection(&fSection);
 143        #else
 144         pthread_mutex_destroy(&fMutex);
 145        #endif
 146     }
 147
 148     /*
 149      * Lock the mutex.
 150      */
 151     bool lock() const noexcept
 152     {
 153        #ifdef CARLA_OS_WIN
 154         EnterCriticalSection(&fSection);
 155         return true;
 156        #else
 157         return (pthread_mutex_lock(&fMutex) == 0);
 158        #endif
 159     }
 160
 161     /*
 162      * Try to lock the mutex.
 163      * Returns true if successful.
 164      */
 165     bool tryLock() const noexcept
 166     {
 167        #ifdef CARLA_OS_WIN
 168         return (TryEnterCriticalSection(&fSection) != FALSE);
 169        #else
 170         return (pthread_mutex_trylock(&fMutex) == 0);
 171        #endif
 172     }
 173
 174     /*
 175      * Unlock the mutex.
 176      */
 177     void unlock() const noexcept
 178     {
 179        #ifdef CARLA_OS_WIN
 180         LeaveCriticalSection(&fSection);
 181        #else
 182         pthread_mutex_unlock(&fMutex);
 183        #endif
 184     }
 185
 186 private:
 187    #ifdef CARLA_OS_WIN
 188     mutable CRITICAL_SECTION fSection;
 189    #else
 190     mutable pthread_mutex_t fMutex;
 191    #endif
 192
 193     CARLA_DECLARE_NON_COPYABLE(CarlaRecursiveMutex)
 194 };
 195
 196 // -----------------------------------------------------------------------
 197 // CarlaSignal class
 198
 199 class CarlaSignal
 200 {
 201 public:
 202     /*
 203      * Constructor.
 204      */
 205     CarlaSignal() noexcept
 206         : fCondition(),
 207           fMutex(),
 208           fTriggered(false)
 209     {
 210         pthread_condattr_t cattr;
 211         pthread_condattr_init(&cattr);
 212         pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_PRIVATE);
 213         pthread_cond_init(&fCondition, &cattr);
 214         pthread_condattr_destroy(&cattr);
 215
 216         pthread_mutexattr_t mattr;
 217         pthread_mutexattr_init(&mattr);
 218        #ifndef PTW32_DLLPORT
 219         pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
 220        #endif
 221         pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_NORMAL);
 222         pthread_mutex_init(&fMutex, &mattr);
 223         pthread_mutexattr_destroy(&mattr);
 224     }
 225
 226     /*
 227      * Destructor.
 228      */
 229     ~CarlaSignal() noexcept
 230     {
 231         pthread_cond_destroy(&fCondition);
 232         pthread_mutex_destroy(&fMutex);
 233     }
 234
 235     /*
 236      * Wait for a signal.
 237      */
 238     void wait() noexcept
 239     {
 240         pthread_mutex_lock(&fMutex);
 241
 242         while (! fTriggered)
 243         {
 244             try {
 245                 pthread_cond_wait(&fCondition, &fMutex);
 246             } CARLA_SAFE_EXCEPTION("pthread_cond_wait");
 247         }
 248
 249         fTriggered = false;
 250
 251         pthread_mutex_unlock(&fMutex);
 252     }
 253
 254     /*
 255      * Wake up all waiting threads.
 256      */
 257     void signal() noexcept
 258     {
 259         pthread_mutex_lock(&fMutex);
 260
 261         if (! fTriggered)
 262         {
 263             fTriggered = true;
 264             pthread_cond_broadcast(&fCondition);
 265         }
 266
 267         pthread_mutex_unlock(&fMutex);
 268     }
 269
 270 private:
 271     pthread_cond_t  fCondition;
 272     pthread_mutex_t fMutex;
 273     volatile bool   fTriggered;
 274
 275     CARLA_PREVENT_HEAP_ALLOCATION
 276     CARLA_DECLARE_NON_COPYABLE(CarlaSignal)
 277 };
 278
 279 // -----------------------------------------------------------------------
 280 // Helper class to lock&unlock a mutex during a function scope.
 281
 282 template <class Mutex>
 283 class CarlaScopeLocker
 284 {
 285 public:
 286     CarlaScopeLocker(const Mutex& mutex) noexcept
 287         : fMutex(mutex)
 288     {
 289         fMutex.lock();
 290     }
 291
 292     ~CarlaScopeLocker() noexcept
 293     {
 294         fMutex.unlock();
 295     }
 296
 297 private:
 298     const Mutex& fMutex;
 299
 300     CARLA_PREVENT_HEAP_ALLOCATION
 301     CARLA_DECLARE_NON_COPYABLE(CarlaScopeLocker)
 302 };
 303
 304 // -----------------------------------------------------------------------
 305 // Helper class to try-lock&unlock a mutex during a function scope.
 306
 307 template <class Mutex>
 308 class CarlaScopeTryLocker
 309 {
 310 public:
 311     CarlaScopeTryLocker(const Mutex& mutex) noexcept
 312         : fMutex(mutex),
 313           fLocked(mutex.tryLock()) {}
 314
 315     CarlaScopeTryLocker(const Mutex& mutex, const bool forceLock) noexcept
 316         : fMutex(mutex),
 317           fLocked(forceLock ? mutex.lock() : mutex.tryLock()) {}
 318
 319     ~CarlaScopeTryLocker() noexcept
 320     {
 321         if (fLocked)
 322             fMutex.unlock();
 323     }
 324
 325     bool wasLocked() const noexcept
 326     {
 327         return fLocked;
 328     }
 329
 330     bool wasNotLocked() const noexcept
 331     {
 332         return !fLocked;
 333     }
 334
 335     bool tryAgain() const noexcept
 336     {
 337         return fMutex.tryLock();
 338     }
 339
 340 private:
 341     const Mutex& fMutex;
 342     const bool   fLocked;
 343
 344     CARLA_PREVENT_HEAP_ALLOCATION
 345     CARLA_DECLARE_NON_COPYABLE(CarlaScopeTryLocker)
 346 };
 347
 348 // -----------------------------------------------------------------------
 349 // Helper class to unlock&lock a mutex during a function scope.
 350
 351 template <class Mutex>
 352 class CarlaScopeUnlocker
 353 {
 354 public:
 355     CarlaScopeUnlocker(const Mutex& mutex) noexcept
 356         : fMutex(mutex)
 357     {
 358         fMutex.unlock();
 359     }
 360
 361     ~CarlaScopeUnlocker() noexcept
 362     {
 363         fMutex.lock();
 364     }
 365
 366 private:
 367     const Mutex& fMutex;
 368
 369     CARLA_PREVENT_HEAP_ALLOCATION
 370     CARLA_DECLARE_NON_COPYABLE(CarlaScopeUnlocker)
 371 };
 372
 373 // -----------------------------------------------------------------------
 374 // Define types
 375
 376 typedef CarlaScopeLocker<CarlaMutex>          CarlaMutexLocker;
 377 typedef CarlaScopeLocker<CarlaRecursiveMutex> CarlaRecursiveMutexLocker;
 378
 379 typedef CarlaScopeTryLocker<CarlaMutex>          CarlaMutexTryLocker;
 380 typedef CarlaScopeTryLocker<CarlaRecursiveMutex> CarlaRecursiveMutexTryLocker;
 381
 382 typedef CarlaScopeUnlocker<CarlaMutex>          CarlaMutexUnlocker;
 383 typedef CarlaScopeUnlocker<CarlaRecursiveMutex> CarlaRecursiveMutexUnlocker;
 384
 385 // -----------------------------------------------------------------------
 386
 387 #endif // CARLA_MUTEX_HPP_INCLUDED