common/threads.h

   1 #ifndef AL_THREADS_H
   2 #define AL_THREADS_H
   3
   4 #include <time.h>
   5
   6 #if defined(__GNUC__) && defined(__i386__)
   7 /* force_align_arg_pointer is required for proper function arguments aligning
   8  * when SSE code is used. Some systems (Windows, QNX) do not guarantee our
   9  * thread functions will be properly aligned on the stack, even though GCC may
  10  * generate code with the assumption that it is. */
  11 #define FORCE_ALIGN __attribute__((force_align_arg_pointer))
  12 #else
  13 #define FORCE_ALIGN
  14 #endif
  15
  16 #ifdef __cplusplus
  17 extern "C" {
  18 #endif
  19
  20 enum {
  21     althrd_success = 0,
  22     althrd_error,
  23     althrd_nomem,
  24     althrd_timedout,
  25     althrd_busy
  26 };
  27
  28 enum {
  29     almtx_plain = 0,
  30     almtx_recursive = 1,
  31 };
  32
  33 typedef int (*althrd_start_t)(void*);
  34
  35
  36 #ifdef _WIN32
  37 #define WIN32_LEAN_AND_MEAN
  38 #include <windows.h>
  39
  40 typedef DWORD althrd_t;
  41 typedef CRITICAL_SECTION almtx_t;
  42 typedef HANDLE alsem_t;
  43
  44
  45 inline void althrd_yield(void)
  46 {
  47     SwitchToThread();
  48 }
  49
  50
  51 inline int almtx_lock(almtx_t *mtx)
  52 {
  53     if(!mtx) return althrd_error;
  54     EnterCriticalSection(mtx);
  55     return althrd_success;
  56 }
  57
  58 inline int almtx_unlock(almtx_t *mtx)
  59 {
  60     if(!mtx) return althrd_error;
  61     LeaveCriticalSection(mtx);
  62     return althrd_success;
  63 }
  64
  65 #else
  66
  67 #include <stdint.h>
  68 #include <errno.h>
  69 #include <pthread.h>
  70 #ifdef __APPLE__
  71 #include <dispatch/dispatch.h>
  72 #else /* !__APPLE__ */
  73 #include <semaphore.h>
  74 #endif /* __APPLE__ */
  75
  76 typedef pthread_t althrd_t;
  77 typedef pthread_mutex_t almtx_t;
  78 #ifdef __APPLE__
  79 typedef dispatch_semaphore_t alsem_t;
  80 #else /* !__APPLE__ */
  81 typedef sem_t alsem_t;
  82 #endif /* __APPLE__ */
  83
  84
  85 inline void althrd_yield(void)
  86 {
  87     sched_yield();
  88 }
  89
  90
  91 inline int almtx_lock(almtx_t *mtx)
  92 {
  93     if(pthread_mutex_lock(mtx) != 0)
  94         return althrd_error;
  95     return althrd_success;
  96 }
  97
  98 inline int almtx_unlock(almtx_t *mtx)
  99 {
 100     if(pthread_mutex_unlock(mtx) != 0)
 101         return althrd_error;
 102     return althrd_success;
 103 }
 104
 105 #endif
 106
 107
 108 int althrd_create(althrd_t *thr, althrd_start_t func, void *arg);
 109 int althrd_detach(althrd_t thr);
 110 int althrd_join(althrd_t thr, int *res);
 111 void althrd_setname(const char *name);
 112
 113 int almtx_init(almtx_t *mtx, int type);
 114 void almtx_destroy(almtx_t *mtx);
 115
 116 int alsem_init(alsem_t *sem, unsigned int initial);
 117 void alsem_destroy(alsem_t *sem);
 118 int alsem_post(alsem_t *sem);
 119 int alsem_wait(alsem_t *sem);
 120 int alsem_trywait(alsem_t *sem);
 121
 122 #ifdef __cplusplus
 123 } // extern "C"
 124
 125 #include <mutex>
 126
 127 /* Add specializations for std::lock_guard and std::unique_lock which take an
 128  * almtx_t and call the appropriate almtx_* functions.
 129  */
 130 namespace std {
 131
 132 template<>
 133 class lock_guard<almtx_t> {
 134     almtx_t &mMtx;
 135
 136 public:
 137     using mutex_type = almtx_t;
 138
 139     explicit lock_guard(almtx_t &mtx) : mMtx(mtx) { almtx_lock(&mMtx); }
 140     lock_guard(almtx_t &mtx, std::adopt_lock_t) noexcept : mMtx(mtx) { }
 141     ~lock_guard() { almtx_unlock(&mMtx); }
 142
 143     lock_guard(const lock_guard&) = delete;
 144     lock_guard& operator=(const lock_guard&) = delete;
 145 };
 146
 147 template<>
 148 class unique_lock<almtx_t> {
 149     almtx_t *mMtx{nullptr};
 150     bool mLocked{false};
 151
 152 public:
 153     using mutex_type = almtx_t;
 154
 155     unique_lock() noexcept = default;
 156     explicit unique_lock(almtx_t &mtx) : mMtx(&mtx) { almtx_lock(mMtx); mLocked = true; }
 157     unique_lock(unique_lock&& rhs) noexcept : mMtx(rhs.mMtx), mLocked(rhs.mLocked)
 158     { rhs.mMtx = nullptr; rhs.mLocked = false; }
 159     ~unique_lock() { if(mLocked) almtx_unlock(mMtx); }
 160
 161     unique_lock& operator=(const unique_lock&) = delete;
 162     unique_lock& operator=(unique_lock&& rhs)
 163     {
 164         if(mLocked)
 165             almtx_unlock(mMtx);
 166         mMtx = rhs.mMtx; rhs.mMtx = nullptr;
 167         mLocked = rhs.mLocked; rhs.mLocked = false;
 168         return *this;
 169     }
 170
 171     void lock()
 172     {
 173         almtx_lock(mMtx);
 174         mLocked = true;
 175     }
 176     void unlock()
 177     {
 178         mLocked = false;
 179         almtx_unlock(mMtx);
 180     }
 181 };
 182
 183 } // namespace std
 184 #endif
 185
 186 #endif /* AL_THREADS_H */