libcxx/src/mutex.cpp

   1 //===------------------------- mutex.cpp ----------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #define _LIBCPP_BUILDING_MUTEX
  11 #include "mutex"
  12 #include "limits"
  13 #include "system_error"
  14 #include "include/atomic_support.h"
  15 #include "__undef_macros"
  16
  17 _LIBCPP_BEGIN_NAMESPACE_STD
  18 #ifndef _LIBCPP_HAS_NO_THREADS
  19
  20 const defer_lock_t  defer_lock = {};
  21 const try_to_lock_t try_to_lock = {};
  22 const adopt_lock_t  adopt_lock = {};
  23
  24 mutex::~mutex()
  25 {
  26     __libcpp_mutex_destroy(&__m_);
  27 }
  28
  29 void
  30 mutex::lock()
  31 {
  32     int ec = __libcpp_mutex_lock(&__m_);
  33     if (ec)
  34         __throw_system_error(ec, "mutex lock failed");
  35 }
  36
  37 bool
  38 mutex::try_lock() _NOEXCEPT
  39 {
  40     return __libcpp_mutex_trylock(&__m_);
  41 }
  42
  43 void
  44 mutex::unlock() _NOEXCEPT
  45 {
  46     int ec = __libcpp_mutex_unlock(&__m_);
  47     (void)ec;
  48     _LIBCPP_ASSERT(ec == 0, "call to mutex::unlock failed");
  49 }
  50
  51 // recursive_mutex
  52
  53 recursive_mutex::recursive_mutex()
  54 {
  55     int ec = __libcpp_recursive_mutex_init(&__m_);
  56     if (ec)
  57         __throw_system_error(ec, "recursive_mutex constructor failed");
  58 }
  59
  60 recursive_mutex::~recursive_mutex()
  61 {
  62     int e = __libcpp_recursive_mutex_destroy(&__m_);
  63     (void)e;
  64     _LIBCPP_ASSERT(e == 0, "call to ~recursive_mutex() failed");
  65 }
  66
  67 void
  68 recursive_mutex::lock()
  69 {
  70     int ec = __libcpp_recursive_mutex_lock(&__m_);
  71     if (ec)
  72         __throw_system_error(ec, "recursive_mutex lock failed");
  73 }
  74
  75 void
  76 recursive_mutex::unlock() _NOEXCEPT
  77 {
  78     int e = __libcpp_recursive_mutex_unlock(&__m_);
  79     (void)e;
  80     _LIBCPP_ASSERT(e == 0, "call to recursive_mutex::unlock() failed");
  81 }
  82
  83 bool
  84 recursive_mutex::try_lock() _NOEXCEPT
  85 {
  86     return __libcpp_recursive_mutex_trylock(&__m_);
  87 }
  88
  89 // timed_mutex
  90
  91 timed_mutex::timed_mutex()
  92     : __locked_(false)
  93 {
  94 }
  95
  96 timed_mutex::~timed_mutex()
  97 {
  98     lock_guard<mutex> _(__m_);
  99 }
 100
 101 void
 102 timed_mutex::lock()
 103 {
 104     unique_lock<mutex> lk(__m_);
 105     while (__locked_)
 106         __cv_.wait(lk);
 107     __locked_ = true;
 108 }
 109
 110 bool
 111 timed_mutex::try_lock() _NOEXCEPT
 112 {
 113     unique_lock<mutex> lk(__m_, try_to_lock);
 114     if (lk.owns_lock() && !__locked_)
 115     {
 116         __locked_ = true;
 117         return true;
 118     }
 119     return false;
 120 }
 121
 122 void
 123 timed_mutex::unlock() _NOEXCEPT
 124 {
 125     lock_guard<mutex> _(__m_);
 126     __locked_ = false;
 127     __cv_.notify_one();
 128 }
 129
 130 // recursive_timed_mutex
 131
 132 recursive_timed_mutex::recursive_timed_mutex()
 133     : __count_(0),
 134       __id_(0)
 135 {
 136 }
 137
 138 recursive_timed_mutex::~recursive_timed_mutex()
 139 {
 140     lock_guard<mutex> _(__m_);
 141 }
 142
 143 void
 144 recursive_timed_mutex::lock()
 145 {
 146     __libcpp_thread_id id = __libcpp_thread_get_current_id();
 147     unique_lock<mutex> lk(__m_);
 148     if (__libcpp_thread_id_equal(id, __id_))
 149     {
 150         if (__count_ == numeric_limits<size_t>::max())
 151             __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
 152         ++__count_;
 153         return;
 154     }
 155     while (__count_ != 0)
 156         __cv_.wait(lk);
 157     __count_ = 1;
 158     __id_ = id;
 159 }
 160
 161 bool
 162 recursive_timed_mutex::try_lock() _NOEXCEPT
 163 {
 164     __libcpp_thread_id id = __libcpp_thread_get_current_id();
 165     unique_lock<mutex> lk(__m_, try_to_lock);
 166     if (lk.owns_lock() && (__count_ == 0 || __libcpp_thread_id_equal(id, __id_)))
 167     {
 168         if (__count_ == numeric_limits<size_t>::max())
 169             return false;
 170         ++__count_;
 171         __id_ = id;
 172         return true;
 173     }
 174     return false;
 175 }
 176
 177 void
 178 recursive_timed_mutex::unlock() _NOEXCEPT
 179 {
 180     unique_lock<mutex> lk(__m_);
 181     if (--__count_ == 0)
 182     {
 183         __id_ = 0;
 184         lk.unlock();
 185         __cv_.notify_one();
 186     }
 187 }
 188
 189 #endif // !_LIBCPP_HAS_NO_THREADS
 190
 191 // If dispatch_once_f ever handles C++ exceptions, and if one can get to it
 192 // without illegal macros (unexpected macros not beginning with _UpperCase or
 193 // __lowercase), and if it stops spinning waiting threads, then call_once should
 194 // call into dispatch_once_f instead of here. Relevant radar this code needs to
 195 // keep in sync with:  7741191.
 196
 197 #ifndef _LIBCPP_HAS_NO_THREADS
 198 _LIBCPP_SAFE_STATIC static __libcpp_mutex_t mut = _LIBCPP_MUTEX_INITIALIZER;
 199 _LIBCPP_SAFE_STATIC static __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER;
 200 #endif
 201
 202 void
 203 __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
 204 {
 205 #if defined(_LIBCPP_HAS_NO_THREADS)
 206     if (flag == 0)
 207     {
 208 #ifndef _LIBCPP_NO_EXCEPTIONS
 209         try
 210         {
 211 #endif  // _LIBCPP_NO_EXCEPTIONS
 212             flag = 1;
 213             func(arg);
 214             flag = ~0ul;
 215 #ifndef _LIBCPP_NO_EXCEPTIONS
 216         }
 217         catch (...)
 218         {
 219             flag = 0ul;
 220             throw;
 221         }
 222 #endif  // _LIBCPP_NO_EXCEPTIONS
 223     }
 224 #else // !_LIBCPP_HAS_NO_THREADS
 225     __libcpp_mutex_lock(&mut);
 226     while (flag == 1)
 227         __libcpp_condvar_wait(&cv, &mut);
 228     if (flag == 0)
 229     {
 230 #ifndef _LIBCPP_NO_EXCEPTIONS
 231         try
 232         {
 233 #endif  // _LIBCPP_NO_EXCEPTIONS
 234             __libcpp_relaxed_store(&flag, 1ul);
 235             __libcpp_mutex_unlock(&mut);
 236             func(arg);
 237             __libcpp_mutex_lock(&mut);
 238             __libcpp_atomic_store(&flag, ~0ul, _AO_Release);
 239             __libcpp_mutex_unlock(&mut);
 240             __libcpp_condvar_broadcast(&cv);
 241 #ifndef _LIBCPP_NO_EXCEPTIONS
 242         }
 243         catch (...)
 244         {
 245             __libcpp_mutex_lock(&mut);
 246             __libcpp_relaxed_store(&flag, 0ul);
 247             __libcpp_mutex_unlock(&mut);
 248             __libcpp_condvar_broadcast(&cv);
 249             throw;
 250         }
 251 #endif  // _LIBCPP_NO_EXCEPTIONS
 252     }
 253     else
 254         __libcpp_mutex_unlock(&mut);
 255 #endif // !_LIBCPP_HAS_NO_THREADS
 256
 257 }
 258
 259 _LIBCPP_END_NAMESPACE_STD