contrib/libc++/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 "cassert"
  15
  16 _LIBCPP_BEGIN_NAMESPACE_STD
  17
  18 const defer_lock_t  defer_lock = {};
  19 const try_to_lock_t try_to_lock = {};
  20 const adopt_lock_t  adopt_lock = {};
  21
  22 mutex::~mutex()
  23 {
  24     pthread_mutex_destroy(&__m_);
  25 }
  26
  27 void
  28 mutex::lock()
  29 {
  30     int ec = pthread_mutex_lock(&__m_);
  31     if (ec)
  32         __throw_system_error(ec, "mutex lock failed");
  33 }
  34
  35 bool
  36 mutex::try_lock() _NOEXCEPT
  37 {
  38     return pthread_mutex_trylock(&__m_) == 0;
  39 }
  40
  41 void
  42 mutex::unlock() _NOEXCEPT
  43 {
  44     int ec = pthread_mutex_unlock(&__m_);
  45     (void)ec;
  46     assert(ec == 0);
  47 }
  48
  49 // recursive_mutex
  50
  51 recursive_mutex::recursive_mutex()
  52 {
  53     pthread_mutexattr_t attr;
  54     int ec = pthread_mutexattr_init(&attr);
  55     if (ec)
  56         goto fail;
  57     ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
  58     if (ec)
  59     {
  60         pthread_mutexattr_destroy(&attr);
  61         goto fail;
  62     }
  63     ec = pthread_mutex_init(&__m_, &attr);
  64     if (ec)
  65     {
  66         pthread_mutexattr_destroy(&attr);
  67         goto fail;
  68     }
  69     ec = pthread_mutexattr_destroy(&attr);
  70     if (ec)
  71     {
  72         pthread_mutex_destroy(&__m_);
  73         goto fail;
  74     }
  75     return;
  76 fail:
  77     __throw_system_error(ec, "recursive_mutex constructor failed");
  78 }
  79
  80 recursive_mutex::~recursive_mutex()
  81 {
  82     int e = pthread_mutex_destroy(&__m_);
  83     (void)e;
  84     assert(e == 0);
  85 }
  86
  87 void
  88 recursive_mutex::lock()
  89 {
  90     int ec = pthread_mutex_lock(&__m_);
  91     if (ec)
  92         __throw_system_error(ec, "recursive_mutex lock failed");
  93 }
  94
  95 void
  96 recursive_mutex::unlock() _NOEXCEPT
  97 {
  98     int e = pthread_mutex_unlock(&__m_);
  99     (void)e;
 100     assert(e == 0);
 101 }
 102
 103 bool
 104 recursive_mutex::try_lock() _NOEXCEPT
 105 {
 106     return pthread_mutex_trylock(&__m_) == 0;
 107 }
 108
 109 // timed_mutex
 110
 111 timed_mutex::timed_mutex()
 112     : __locked_(false)
 113 {
 114 }
 115
 116 timed_mutex::~timed_mutex()
 117 {
 118     lock_guard<mutex> _(__m_);
 119 }
 120
 121 void
 122 timed_mutex::lock()
 123 {
 124     unique_lock<mutex> lk(__m_);
 125     while (__locked_)
 126         __cv_.wait(lk);
 127     __locked_ = true;
 128 }
 129
 130 bool
 131 timed_mutex::try_lock() _NOEXCEPT
 132 {
 133     unique_lock<mutex> lk(__m_, try_to_lock);
 134     if (lk.owns_lock() && !__locked_)
 135     {
 136         __locked_ = true;
 137         return true;
 138     }
 139     return false;
 140 }
 141
 142 void
 143 timed_mutex::unlock() _NOEXCEPT
 144 {
 145     lock_guard<mutex> _(__m_);
 146     __locked_ = false;
 147     __cv_.notify_one();
 148 }
 149
 150 // recursive_timed_mutex
 151
 152 recursive_timed_mutex::recursive_timed_mutex()
 153     : __count_(0),
 154       __id_(0)
 155 {
 156 }
 157
 158 recursive_timed_mutex::~recursive_timed_mutex()
 159 {
 160     lock_guard<mutex> _(__m_);
 161 }
 162
 163 void
 164 recursive_timed_mutex::lock()
 165 {
 166     pthread_t id = pthread_self();
 167     unique_lock<mutex> lk(__m_);
 168     if (pthread_equal(id, __id_))
 169     {
 170         if (__count_ == numeric_limits<size_t>::max())
 171             __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
 172         ++__count_;
 173         return;
 174     }
 175     while (__count_ != 0)
 176         __cv_.wait(lk);
 177     __count_ = 1;
 178     __id_ = id;
 179 }
 180
 181 bool
 182 recursive_timed_mutex::try_lock() _NOEXCEPT
 183 {
 184     pthread_t id = pthread_self();
 185     unique_lock<mutex> lk(__m_, try_to_lock);
 186     if (lk.owns_lock() && (__count_ == 0 || pthread_equal(id, __id_)))
 187     {
 188         if (__count_ == numeric_limits<size_t>::max())
 189             return false;
 190         ++__count_;
 191         __id_ = id;
 192         return true;
 193     }
 194     return false;
 195 }
 196
 197 void
 198 recursive_timed_mutex::unlock() _NOEXCEPT
 199 {
 200     unique_lock<mutex> lk(__m_);
 201     if (--__count_ == 0)
 202     {
 203         __id_ = 0;
 204         lk.unlock();
 205         __cv_.notify_one();
 206     }
 207 }
 208
 209 // If dispatch_once_f ever handles C++ exceptions, and if one can get to it
 210 // without illegal macros (unexpected macros not beginning with _UpperCase or
 211 // __lowercase), and if it stops spinning waiting threads, then call_once should
 212 // call into dispatch_once_f instead of here. Relevant radar this code needs to
 213 // keep in sync with:  7741191.
 214
 215 static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
 216 static pthread_cond_t  cv  = PTHREAD_COND_INITIALIZER;
 217
 218 void
 219 __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
 220 {
 221     pthread_mutex_lock(&mut);
 222     while (flag == 1)
 223         pthread_cond_wait(&cv, &mut);
 224     if (flag == 0)
 225     {
 226 #ifndef _LIBCPP_NO_EXCEPTIONS
 227         try
 228         {
 229 #endif  // _LIBCPP_NO_EXCEPTIONS
 230             flag = 1;
 231             pthread_mutex_unlock(&mut);
 232             func(arg);
 233             pthread_mutex_lock(&mut);
 234             flag = ~0ul;
 235             pthread_mutex_unlock(&mut);
 236             pthread_cond_broadcast(&cv);
 237 #ifndef _LIBCPP_NO_EXCEPTIONS
 238         }
 239         catch (...)
 240         {
 241             pthread_mutex_lock(&mut);
 242             flag = 0ul;
 243             pthread_mutex_unlock(&mut);
 244             pthread_cond_broadcast(&cv);
 245             throw;
 246         }
 247 #endif  // _LIBCPP_NO_EXCEPTIONS
 248     }
 249     else
 250         pthread_mutex_unlock(&mut);
 251 }
 252
 253 _LIBCPP_END_NAMESPACE_STD