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