1 | // Support for concurrent programing -*- C++ -*- |
2 | |
3 | // Copyright (C) 2003-2019 Free Software Foundation, Inc. |
4 | // |
5 | // This file is part of the GNU ISO C++ Library. This library is free |
6 | // software; you can redistribute it and/or modify it under the |
7 | // terms of the GNU General Public License as published by the |
8 | // Free Software Foundation; either version 3, or (at your option) |
9 | // any later version. |
10 | |
11 | // This library is distributed in the hope that it will be useful, |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | // GNU General Public License for more details. |
15 | |
16 | // Under Section 7 of GPL version 3, you are granted additional |
17 | // permissions described in the GCC Runtime Library Exception, version |
18 | // 3.1, as published by the Free Software Foundation. |
19 | |
20 | // You should have received a copy of the GNU General Public License and |
21 | // a copy of the GCC Runtime Library Exception along with this program; |
22 | // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
23 | // <http://www.gnu.org/licenses/>. |
24 | |
25 | /** @file ext/concurrence.h |
26 | * This file is a GNU extension to the Standard C++ Library. |
27 | */ |
28 | |
29 | #ifndef _CONCURRENCE_H |
30 | #define _CONCURRENCE_H 1 |
31 | |
32 | #pragma GCC system_header |
33 | |
34 | #include <exception> |
35 | #include <bits/gthr.h> |
36 | #include <bits/functexcept.h> |
37 | #include <bits/cpp_type_traits.h> |
38 | #include <ext/type_traits.h> |
39 | |
40 | namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) |
41 | { |
42 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
43 | |
44 | // Available locking policies: |
45 | // _S_single single-threaded code that doesn't need to be locked. |
46 | // _S_mutex multi-threaded code that requires additional support |
47 | // from gthr.h or abstraction layers in concurrence.h. |
48 | // _S_atomic multi-threaded code using atomic operations. |
49 | enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; |
50 | |
51 | // Compile time constant that indicates prefered locking policy in |
52 | // the current configuration. |
53 | static const _Lock_policy __default_lock_policy = |
54 | #ifndef __GTHREADS |
55 | _S_single; |
56 | #elif defined _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY |
57 | _S_atomic; |
58 | #else |
59 | _S_mutex; |
60 | #endif |
61 | |
62 | // NB: As this is used in libsupc++, need to only depend on |
63 | // exception. No stdexception classes, no use of std::string. |
64 | class __concurrence_lock_error : public std::exception |
65 | { |
66 | public: |
67 | virtual char const* |
68 | what() const throw() |
69 | { return "__gnu_cxx::__concurrence_lock_error" ; } |
70 | }; |
71 | |
72 | class __concurrence_unlock_error : public std::exception |
73 | { |
74 | public: |
75 | virtual char const* |
76 | what() const throw() |
77 | { return "__gnu_cxx::__concurrence_unlock_error" ; } |
78 | }; |
79 | |
80 | class __concurrence_broadcast_error : public std::exception |
81 | { |
82 | public: |
83 | virtual char const* |
84 | what() const throw() |
85 | { return "__gnu_cxx::__concurrence_broadcast_error" ; } |
86 | }; |
87 | |
88 | class __concurrence_wait_error : public std::exception |
89 | { |
90 | public: |
91 | virtual char const* |
92 | what() const throw() |
93 | { return "__gnu_cxx::__concurrence_wait_error" ; } |
94 | }; |
95 | |
96 | // Substitute for concurrence_error object in the case of -fno-exceptions. |
97 | inline void |
98 | __throw_concurrence_lock_error() |
99 | { _GLIBCXX_THROW_OR_ABORT(__concurrence_lock_error()); } |
100 | |
101 | inline void |
102 | __throw_concurrence_unlock_error() |
103 | { _GLIBCXX_THROW_OR_ABORT(__concurrence_unlock_error()); } |
104 | |
105 | #ifdef __GTHREAD_HAS_COND |
106 | inline void |
107 | __throw_concurrence_broadcast_error() |
108 | { _GLIBCXX_THROW_OR_ABORT(__concurrence_broadcast_error()); } |
109 | |
110 | inline void |
111 | __throw_concurrence_wait_error() |
112 | { _GLIBCXX_THROW_OR_ABORT(__concurrence_wait_error()); } |
113 | #endif |
114 | |
115 | class __mutex |
116 | { |
117 | private: |
118 | #if __GTHREADS && defined __GTHREAD_MUTEX_INIT |
119 | __gthread_mutex_t _M_mutex = __GTHREAD_MUTEX_INIT; |
120 | #else |
121 | __gthread_mutex_t _M_mutex; |
122 | #endif |
123 | |
124 | __mutex(const __mutex&); |
125 | __mutex& operator=(const __mutex&); |
126 | |
127 | public: |
128 | __mutex() |
129 | { |
130 | #if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT |
131 | if (__gthread_active_p()) |
132 | __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); |
133 | #endif |
134 | } |
135 | |
136 | #if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT |
137 | ~__mutex() |
138 | { |
139 | if (__gthread_active_p()) |
140 | __gthread_mutex_destroy(&_M_mutex); |
141 | } |
142 | #endif |
143 | |
144 | void lock() |
145 | { |
146 | #if __GTHREADS |
147 | if (__gthread_active_p()) |
148 | { |
149 | if (__gthread_mutex_lock(&_M_mutex) != 0) |
150 | __throw_concurrence_lock_error(); |
151 | } |
152 | #endif |
153 | } |
154 | |
155 | void unlock() |
156 | { |
157 | #if __GTHREADS |
158 | if (__gthread_active_p()) |
159 | { |
160 | if (__gthread_mutex_unlock(&_M_mutex) != 0) |
161 | __throw_concurrence_unlock_error(); |
162 | } |
163 | #endif |
164 | } |
165 | |
166 | __gthread_mutex_t* gthread_mutex(void) |
167 | { return &_M_mutex; } |
168 | }; |
169 | |
170 | class __recursive_mutex |
171 | { |
172 | private: |
173 | #if __GTHREADS && defined __GTHREAD_RECURSIVE_MUTEX_INIT |
174 | __gthread_recursive_mutex_t _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT; |
175 | #else |
176 | __gthread_recursive_mutex_t _M_mutex; |
177 | #endif |
178 | |
179 | __recursive_mutex(const __recursive_mutex&); |
180 | __recursive_mutex& operator=(const __recursive_mutex&); |
181 | |
182 | public: |
183 | __recursive_mutex() |
184 | { |
185 | #if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT |
186 | if (__gthread_active_p()) |
187 | __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex); |
188 | #endif |
189 | } |
190 | |
191 | #if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT |
192 | ~__recursive_mutex() |
193 | { |
194 | if (__gthread_active_p()) |
195 | __gthread_recursive_mutex_destroy(&_M_mutex); |
196 | } |
197 | #endif |
198 | |
199 | void lock() |
200 | { |
201 | #if __GTHREADS |
202 | if (__gthread_active_p()) |
203 | { |
204 | if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) |
205 | __throw_concurrence_lock_error(); |
206 | } |
207 | #endif |
208 | } |
209 | |
210 | void unlock() |
211 | { |
212 | #if __GTHREADS |
213 | if (__gthread_active_p()) |
214 | { |
215 | if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) |
216 | __throw_concurrence_unlock_error(); |
217 | } |
218 | #endif |
219 | } |
220 | |
221 | __gthread_recursive_mutex_t* gthread_recursive_mutex(void) |
222 | { return &_M_mutex; } |
223 | }; |
224 | |
225 | /// Scoped lock idiom. |
226 | // Acquire the mutex here with a constructor call, then release with |
227 | // the destructor call in accordance with RAII style. |
228 | class __scoped_lock |
229 | { |
230 | public: |
231 | typedef __mutex __mutex_type; |
232 | |
233 | private: |
234 | __mutex_type& _M_device; |
235 | |
236 | __scoped_lock(const __scoped_lock&); |
237 | __scoped_lock& operator=(const __scoped_lock&); |
238 | |
239 | public: |
240 | explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) |
241 | { _M_device.lock(); } |
242 | |
243 | ~__scoped_lock() throw() |
244 | { _M_device.unlock(); } |
245 | }; |
246 | |
247 | #ifdef __GTHREAD_HAS_COND |
248 | class __cond |
249 | { |
250 | private: |
251 | #if __GTHREADS && defined __GTHREAD_COND_INIT |
252 | __gthread_cond_t _M_cond = __GTHREAD_COND_INIT; |
253 | #else |
254 | __gthread_cond_t _M_cond; |
255 | #endif |
256 | |
257 | __cond(const __cond&); |
258 | __cond& operator=(const __cond&); |
259 | |
260 | public: |
261 | __cond() |
262 | { |
263 | #if __GTHREADS && ! defined __GTHREAD_COND_INIT |
264 | if (__gthread_active_p()) |
265 | __GTHREAD_COND_INIT_FUNCTION(&_M_cond); |
266 | #endif |
267 | } |
268 | |
269 | #if __GTHREADS && ! defined __GTHREAD_COND_INIT |
270 | ~__cond() |
271 | { |
272 | if (__gthread_active_p()) |
273 | __gthread_cond_destroy(&_M_cond); |
274 | } |
275 | #endif |
276 | |
277 | void broadcast() |
278 | { |
279 | #if __GTHREADS |
280 | if (__gthread_active_p()) |
281 | { |
282 | if (__gthread_cond_broadcast(&_M_cond) != 0) |
283 | __throw_concurrence_broadcast_error(); |
284 | } |
285 | #endif |
286 | } |
287 | |
288 | void wait(__mutex *mutex) |
289 | { |
290 | #if __GTHREADS |
291 | { |
292 | if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) |
293 | __throw_concurrence_wait_error(); |
294 | } |
295 | #endif |
296 | } |
297 | |
298 | void wait_recursive(__recursive_mutex *mutex) |
299 | { |
300 | #if __GTHREADS |
301 | { |
302 | if (__gthread_cond_wait_recursive(&_M_cond, |
303 | mutex->gthread_recursive_mutex()) |
304 | != 0) |
305 | __throw_concurrence_wait_error(); |
306 | } |
307 | #endif |
308 | } |
309 | }; |
310 | #endif |
311 | |
312 | _GLIBCXX_END_NAMESPACE_VERSION |
313 | } // namespace |
314 | |
315 | #endif |
316 | |