source/utils/CarlaSemUtils.hpp

   1 /*
   2  * Carla semaphore utils
   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_SEM_UTILS_HPP_INCLUDED
  19 #define CARLA_SEM_UTILS_HPP_INCLUDED
  20
  21 #include "CarlaUtils.hpp"
  22
  23 #include <ctime>
  24
  25 #if defined(CARLA_OS_LINUX) && ! defined(STOAT_TEST_BUILD)
  26 # define CARLA_USE_FUTEXES 1
  27 #endif
  28
  29 #if defined(CARLA_OS_WIN)
  30 # ifdef __WINE__
  31 #  error Wine is not supposed to use this!
  32 # endif
  33 struct carla_sem_t { HANDLE handle; };
  34 #elif defined(CARLA_OS_MAC)
  35 # include <cerrno>
  36 #define UL_COMPARE_AND_WAIT        1
  37 #define UL_COMPARE_AND_WAIT_SHARED 3
  38 #define ULF_NO_ERRNO               0x01000000
  39 extern "C" {
  40 int __ulock_wait(uint32_t operation, void* addr, uint64_t value, uint32_t timeout_us);
  41 int __ulock_wake(uint32_t operation, void* addr, uint64_t value);
  42 }
  43 struct carla_sem_t { int count; bool external; };
  44 #elif defined(CARLA_USE_FUTEXES)
  45 # include <cerrno>
  46 # include <syscall.h>
  47 # include <sys/time.h>
  48 # include <linux/futex.h>
  49 struct carla_sem_t { int count; bool external; };
  50 #else
  51 # include <cerrno>
  52 # include <semaphore.h>
  53 # include <sys/time.h>
  54 # include <sys/types.h>
  55 struct carla_sem_t { sem_t sem; };
  56 #endif
  57
  58 /*
  59  * Create a new semaphore, pre-allocated version.
  60  */
  61 static inline
  62 bool carla_sem_create2(carla_sem_t& sem, const bool externalIPC) noexcept
  63 {
  64     carla_zeroStruct(sem);
  65 #if defined(CARLA_OS_WIN)
  66     SECURITY_ATTRIBUTES sa;
  67     carla_zeroStruct(sa);
  68     sa.nLength        = sizeof(SECURITY_ATTRIBUTES);
  69     sa.bInheritHandle = TRUE;
  70
  71     sem.handle = ::CreateSemaphoreA(externalIPC ? &sa : nullptr, 0, 1, nullptr);
  72
  73     return (sem.handle != INVALID_HANDLE_VALUE);
  74 #elif defined(CARLA_OS_MAC) || defined(CARLA_USE_FUTEXES)
  75     sem.external = externalIPC;
  76     return true;
  77 #else
  78     return (::sem_init(&sem.sem, externalIPC, 0) == 0);
  79 #endif
  80 }
  81
  82 /*
  83  * Create a new semaphore.
  84  */
  85 static inline
  86 carla_sem_t* carla_sem_create(const bool externalIPC) noexcept
  87 {
  88     if (carla_sem_t* const sem = (carla_sem_t*)std::malloc(sizeof(carla_sem_t)))
  89     {
  90         if (carla_sem_create2(*sem, externalIPC))
  91             return sem;
  92
  93         std::free(sem);
  94     }
  95
  96     return nullptr;
  97 }
  98
  99 /*
 100  * Destroy a semaphore, pre-allocated version.
 101  */
 102 static inline
 103 void carla_sem_destroy2(carla_sem_t& sem) noexcept
 104 {
 105 #if defined(CARLA_OS_WIN)
 106     ::CloseHandle(sem.handle);
 107 #elif defined(CARLA_OS_MAC) || defined(CARLA_USE_FUTEXES)
 108     // nothing to do
 109 #else
 110     ::sem_destroy(&sem.sem);
 111 #endif
 112     carla_zeroStruct(sem);
 113 }
 114
 115 /*
 116  * Destroy a semaphore.
 117  */
 118 static inline
 119 void carla_sem_destroy(carla_sem_t* const sem) noexcept
 120 {
 121     CARLA_SAFE_ASSERT_RETURN(sem != nullptr,);
 122
 123     carla_sem_destroy2(*sem);
 124     std::free(sem);
 125 }
 126
 127 /*
 128  * Post semaphore (unlock).
 129  */
 130 static inline
 131 void carla_sem_post(carla_sem_t& sem) noexcept
 132 {
 133 #ifdef CARLA_OS_WIN
 134     ::ReleaseSemaphore(sem.handle, 1, nullptr);
 135 #elif defined(CARLA_OS_MAC)
 136     const bool unlocked = __sync_bool_compare_and_swap(&sem.count, 0, 1);
 137     CARLA_SAFE_ASSERT_RETURN(unlocked,);
 138     __ulock_wake(ULF_NO_ERRNO | (sem.external ? UL_COMPARE_AND_WAIT_SHARED : UL_COMPARE_AND_WAIT), &sem.count, 0);
 139 #elif defined(CARLA_USE_FUTEXES)
 140     const bool unlocked = __sync_bool_compare_and_swap(&sem.count, 0, 1);
 141     CARLA_SAFE_ASSERT_RETURN(unlocked,);
 142     ::syscall(__NR_futex, &sem.count, sem.external ? FUTEX_WAKE : FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr, 0);
 143 #else
 144     ::sem_post(&sem.sem);
 145 #endif
 146 }
 147
 148 #ifndef CARLA_OS_WASM
 149 /*
 150  * Wait for a semaphore (lock).
 151  */
 152 static inline
 153 bool carla_sem_timedwait(carla_sem_t& sem, const uint msecs) noexcept
 154 {
 155     CARLA_SAFE_ASSERT_RETURN(msecs > 0, false);
 156
 157 #if defined(CARLA_OS_WIN)
 158     return (::WaitForSingleObject(sem.handle, msecs) == WAIT_OBJECT_0);
 159 #elif defined(CARLA_OS_MAC)
 160     const uint32_t timeout = msecs * 1000;
 161
 162     for (;;)
 163     {
 164         if (__sync_bool_compare_and_swap(&sem.count, 1, 0))
 165             return true;
 166
 167         if (__ulock_wait(sem.external ? UL_COMPARE_AND_WAIT_SHARED : UL_COMPARE_AND_WAIT, &sem.count, 0, timeout) != 0)
 168             if (errno != EAGAIN && errno != EINTR)
 169                 return false;
 170     }
 171 #elif defined(CARLA_USE_FUTEXES)
 172     const uint secs        =  msecs / 1000;
 173     const uint nsecs       = (msecs % 1000) * 1000000;
 174     const timespec timeout = { static_cast<time_t>(secs), static_cast<long>(nsecs) };
 175
 176     for (;;)
 177     {
 178         if (__sync_bool_compare_and_swap(&sem.count, 1, 0))
 179             return true;
 180
 181         if (::syscall(__NR_futex, &sem.count, sem.external ? FUTEX_WAIT : FUTEX_WAIT_PRIVATE, 0, &timeout, nullptr, 0) != 0)
 182             if (errno != EAGAIN && errno != EINTR)
 183                 return false;
 184     }
 185 #else
 186     if (::sem_trywait(&sem.sem) == 0)
 187         return true;
 188
 189     timespec now;
 190     ::clock_gettime(CLOCK_REALTIME, &now);
 191
 192     const uint secs      =  msecs / 1000;
 193     const uint nsecs     = (msecs % 1000) * 1000000;
 194     const timespec delta = { static_cast<time_t>(secs), static_cast<long>(nsecs) };
 195     /* */ timespec end   = { now.tv_sec + delta.tv_sec, now.tv_nsec + delta.tv_nsec };
 196     if (end.tv_nsec >= 1000000000L) {
 197         ++end.tv_sec;
 198         end.tv_nsec -= 1000000000L;
 199     }
 200
 201     for (int ret;;)
 202     {
 203         try {
 204             ret = sem_timedwait(&sem.sem, &end);
 205         } CARLA_SAFE_EXCEPTION_RETURN("carla_sem_timedwait", false);
 206
 207         if (ret == 0)
 208             return true;
 209         if (errno != EAGAIN && errno != EINTR)
 210             return false;
 211     }
 212 #endif
 213 }
 214 #endif
 215
 216 // -----------------------------------------------------------------------
 217
 218 #endif // CARLA_SEM_UTILS_HPP_INCLUDED