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
~mutex()24 mutex::~mutex()
25 {
26 __libcpp_mutex_destroy(&__m_);
27 }
28
29 void
lock()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
try_lock()38 mutex::try_lock() _NOEXCEPT
39 {
40 return __libcpp_mutex_trylock(&__m_);
41 }
42
43 void
unlock()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
recursive_mutex()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
~recursive_mutex()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
lock()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
unlock()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
try_lock()84 recursive_mutex::try_lock() _NOEXCEPT
85 {
86 return __libcpp_recursive_mutex_trylock(&__m_);
87 }
88
89 // timed_mutex
90
timed_mutex()91 timed_mutex::timed_mutex()
92 : __locked_(false)
93 {
94 }
95
~timed_mutex()96 timed_mutex::~timed_mutex()
97 {
98 lock_guard<mutex> _(__m_);
99 }
100
101 void
lock()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
try_lock()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
unlock()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
recursive_timed_mutex()132 recursive_timed_mutex::recursive_timed_mutex()
133 : __count_(0),
134 __id_(0)
135 {
136 }
137
~recursive_timed_mutex()138 recursive_timed_mutex::~recursive_timed_mutex()
139 {
140 lock_guard<mutex> _(__m_);
141 }
142
143 void
lock()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
try_lock()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
unlock()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
__call_once(volatile unsigned long & flag,void * arg,void (* func)(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
260