blob: 127e67a2627e6fb04ea0c8713e1ced457f5e19fd [file] [log] [blame]
Howard Hinnant3e519522010-05-11 19:42:161//===------------------------- mutex.cpp ----------------------------------===//
2//
Howard Hinnant5b08a8a2010-05-11 21:36:013// The LLVM Compiler Infrastructure
Howard Hinnant3e519522010-05-11 19:42:164//
Howard Hinnant412dbeb2010-11-16 22:09:025// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
Howard Hinnant3e519522010-05-11 19:42:167//
8//===----------------------------------------------------------------------===//
9
Howard Hinnant02e610e2012-07-21 16:13:0910#define _LIBCPP_BUILDING_MUTEX
Howard Hinnant3e519522010-05-11 19:42:1611#include "mutex"
12#include "limits"
13#include "system_error"
14#include "cassert"
Eric Fiseliere8fd1642015-08-18 21:08:5415#include "include/atomic_support.h"
Howard Hinnant3e519522010-05-11 19:42:1616
17_LIBCPP_BEGIN_NAMESPACE_STD
Jonathan Roelofsb3fcc672014-09-05 19:45:0518#ifndef _LIBCPP_HAS_NO_THREADS
Howard Hinnant3e519522010-05-11 19:42:1619
20const defer_lock_t defer_lock = {};
21const try_to_lock_t try_to_lock = {};
22const adopt_lock_t adopt_lock = {};
23
24mutex::~mutex()
25{
Howard Hinnantc2063662011-12-01 20:21:0426 pthread_mutex_destroy(&__m_);
Howard Hinnant3e519522010-05-11 19:42:1627}
28
29void
30mutex::lock()
31{
32 int ec = pthread_mutex_lock(&__m_);
33 if (ec)
34 __throw_system_error(ec, "mutex lock failed");
35}
36
37bool
Howard Hinnant02e610e2012-07-21 16:13:0938mutex::try_lock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:1639{
40 return pthread_mutex_trylock(&__m_) == 0;
41}
42
43void
Howard Hinnant02e610e2012-07-21 16:13:0944mutex::unlock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:1645{
46 int ec = pthread_mutex_unlock(&__m_);
Howard Hinnant12bfc4f2013-09-21 21:26:3747 (void)ec;
Howard Hinnant3e519522010-05-11 19:42:1648 assert(ec == 0);
49}
50
51// recursive_mutex
52
53recursive_mutex::recursive_mutex()
54{
55 pthread_mutexattr_t attr;
56 int ec = pthread_mutexattr_init(&attr);
57 if (ec)
58 goto fail;
59 ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
60 if (ec)
61 {
62 pthread_mutexattr_destroy(&attr);
63 goto fail;
64 }
65 ec = pthread_mutex_init(&__m_, &attr);
66 if (ec)
67 {
68 pthread_mutexattr_destroy(&attr);
69 goto fail;
70 }
71 ec = pthread_mutexattr_destroy(&attr);
72 if (ec)
73 {
74 pthread_mutex_destroy(&__m_);
75 goto fail;
76 }
77 return;
78fail:
79 __throw_system_error(ec, "recursive_mutex constructor failed");
80}
81
82recursive_mutex::~recursive_mutex()
83{
84 int e = pthread_mutex_destroy(&__m_);
Howard Hinnant12bfc4f2013-09-21 21:26:3785 (void)e;
Howard Hinnant3e519522010-05-11 19:42:1686 assert(e == 0);
87}
88
89void
90recursive_mutex::lock()
91{
92 int ec = pthread_mutex_lock(&__m_);
93 if (ec)
94 __throw_system_error(ec, "recursive_mutex lock failed");
95}
96
97void
Howard Hinnant02e610e2012-07-21 16:13:0998recursive_mutex::unlock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:1699{
100 int e = pthread_mutex_unlock(&__m_);
Howard Hinnant12bfc4f2013-09-21 21:26:37101 (void)e;
Howard Hinnant3e519522010-05-11 19:42:16102 assert(e == 0);
103}
104
105bool
Howard Hinnant02e610e2012-07-21 16:13:09106recursive_mutex::try_lock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:16107{
108 return pthread_mutex_trylock(&__m_) == 0;
109}
110
111// timed_mutex
112
113timed_mutex::timed_mutex()
114 : __locked_(false)
115{
116}
117
118timed_mutex::~timed_mutex()
119{
120 lock_guard<mutex> _(__m_);
121}
122
123void
124timed_mutex::lock()
125{
126 unique_lock<mutex> lk(__m_);
127 while (__locked_)
128 __cv_.wait(lk);
129 __locked_ = true;
130}
131
132bool
Howard Hinnant02e610e2012-07-21 16:13:09133timed_mutex::try_lock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:16134{
135 unique_lock<mutex> lk(__m_, try_to_lock);
136 if (lk.owns_lock() && !__locked_)
137 {
138 __locked_ = true;
139 return true;
140 }
141 return false;
142}
143
144void
Howard Hinnant02e610e2012-07-21 16:13:09145timed_mutex::unlock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:16146{
147 lock_guard<mutex> _(__m_);
148 __locked_ = false;
149 __cv_.notify_one();
150}
151
152// recursive_timed_mutex
153
154recursive_timed_mutex::recursive_timed_mutex()
155 : __count_(0),
Howard Hinnant128ba712010-05-24 17:49:41156 __id_(0)
Howard Hinnant3e519522010-05-11 19:42:16157{
158}
159
160recursive_timed_mutex::~recursive_timed_mutex()
161{
162 lock_guard<mutex> _(__m_);
163}
164
165void
166recursive_timed_mutex::lock()
167{
168 pthread_t id = pthread_self();
169 unique_lock<mutex> lk(__m_);
170 if (pthread_equal(id, __id_))
171 {
172 if (__count_ == numeric_limits<size_t>::max())
173 __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
174 ++__count_;
175 return;
176 }
177 while (__count_ != 0)
178 __cv_.wait(lk);
179 __count_ = 1;
180 __id_ = id;
181}
182
183bool
Howard Hinnant02e610e2012-07-21 16:13:09184recursive_timed_mutex::try_lock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:16185{
186 pthread_t id = pthread_self();
187 unique_lock<mutex> lk(__m_, try_to_lock);
188 if (lk.owns_lock() && (__count_ == 0 || pthread_equal(id, __id_)))
189 {
190 if (__count_ == numeric_limits<size_t>::max())
191 return false;
192 ++__count_;
193 __id_ = id;
194 return true;
195 }
196 return false;
197}
198
199void
Howard Hinnant02e610e2012-07-21 16:13:09200recursive_timed_mutex::unlock() _NOEXCEPT
Howard Hinnant3e519522010-05-11 19:42:16201{
202 unique_lock<mutex> lk(__m_);
203 if (--__count_ == 0)
204 {
Howard Hinnant128ba712010-05-24 17:49:41205 __id_ = 0;
Howard Hinnant3e519522010-05-11 19:42:16206 lk.unlock();
207 __cv_.notify_one();
208 }
209}
210
Jonathan Roelofsb3fcc672014-09-05 19:45:05211#endif // !_LIBCPP_HAS_NO_THREADS
212
Howard Hinnant3e519522010-05-11 19:42:16213// If dispatch_once_f ever handles C++ exceptions, and if one can get to it
214// without illegal macros (unexpected macros not beginning with _UpperCase or
215// __lowercase), and if it stops spinning waiting threads, then call_once should
216// call into dispatch_once_f instead of here. Relevant radar this code needs to
217// keep in sync with: 7741191.
218
Jonathan Roelofsb3fcc672014-09-05 19:45:05219#ifndef _LIBCPP_HAS_NO_THREADS
Howard Hinnant3e519522010-05-11 19:42:16220static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
221static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
Jonathan Roelofsb3fcc672014-09-05 19:45:05222#endif
Howard Hinnant3e519522010-05-11 19:42:16223
Eric Fiselier1faf2892015-07-07 00:27:16224/// NOTE: Changes to flag are done via relaxed atomic stores
225/// even though the accesses are protected by a mutex because threads
226/// just entering 'call_once` concurrently read from flag.
Howard Hinnant3e519522010-05-11 19:42:16227void
228__call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
229{
Jonathan Roelofsb3fcc672014-09-05 19:45:05230#if defined(_LIBCPP_HAS_NO_THREADS)
231 if (flag == 0)
232 {
233#ifndef _LIBCPP_NO_EXCEPTIONS
234 try
235 {
236#endif // _LIBCPP_NO_EXCEPTIONS
237 flag = 1;
238 func(arg);
239 flag = ~0ul;
240#ifndef _LIBCPP_NO_EXCEPTIONS
241 }
242 catch (...)
243 {
244 flag = 0ul;
245 throw;
246 }
247#endif // _LIBCPP_NO_EXCEPTIONS
248 }
249#else // !_LIBCPP_HAS_NO_THREADS
Howard Hinnant3e519522010-05-11 19:42:16250 pthread_mutex_lock(&mut);
251 while (flag == 1)
252 pthread_cond_wait(&cv, &mut);
253 if (flag == 0)
254 {
Howard Hinnant54b409f2010-08-11 17:04:31255#ifndef _LIBCPP_NO_EXCEPTIONS
Howard Hinnant3e519522010-05-11 19:42:16256 try
257 {
Howard Hinnant940e2112010-08-22 00:03:27258#endif // _LIBCPP_NO_EXCEPTIONS
Eric Fiselier1faf2892015-07-07 00:27:16259 __libcpp_relaxed_store(&flag, 1ul);
Howard Hinnant3e519522010-05-11 19:42:16260 pthread_mutex_unlock(&mut);
261 func(arg);
262 pthread_mutex_lock(&mut);
Eric Fiselier1faf2892015-07-07 00:27:16263 __libcpp_relaxed_store(&flag, ~0ul);
Howard Hinnant3e519522010-05-11 19:42:16264 pthread_mutex_unlock(&mut);
265 pthread_cond_broadcast(&cv);
Howard Hinnant54b409f2010-08-11 17:04:31266#ifndef _LIBCPP_NO_EXCEPTIONS
Howard Hinnant3e519522010-05-11 19:42:16267 }
268 catch (...)
269 {
270 pthread_mutex_lock(&mut);
Eric Fiselier1faf2892015-07-07 00:27:16271 __libcpp_relaxed_store(&flag, 0ul);
Howard Hinnant3e519522010-05-11 19:42:16272 pthread_mutex_unlock(&mut);
Howard Hinnantd1803b62010-06-03 16:42:57273 pthread_cond_broadcast(&cv);
Howard Hinnant3e519522010-05-11 19:42:16274 throw;
275 }
Howard Hinnant940e2112010-08-22 00:03:27276#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnant3e519522010-05-11 19:42:16277 }
278 else
279 pthread_mutex_unlock(&mut);
Jonathan Roelofsb3fcc672014-09-05 19:45:05280#endif // !_LIBCPP_HAS_NO_THREADS
281
Howard Hinnant3e519522010-05-11 19:42:16282}
283
284_LIBCPP_END_NAMESPACE_STD