Line data Source code
1 : // <mutex> -*- C++ -*-
2 :
3 : // Copyright (C) 2003-2023 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 include/mutex
26 : * This is a Standard C++ Library header.
27 : */
28 :
29 : #ifndef _GLIBCXX_MUTEX
30 : #define _GLIBCXX_MUTEX 1
31 :
32 : #pragma GCC system_header
33 :
34 : #include <bits/requires_hosted.h> // concurrency
35 :
36 : #if __cplusplus < 201103L
37 : # include <bits/c++0x_warning.h>
38 : #else
39 :
40 : #include <tuple>
41 : #include <exception>
42 : #include <type_traits>
43 : #include <bits/chrono.h>
44 : #include <bits/error_constants.h>
45 : #include <bits/std_mutex.h>
46 : #include <bits/unique_lock.h>
47 : #if ! _GTHREAD_USE_MUTEX_TIMEDLOCK
48 : # include <condition_variable>
49 : # include <thread>
50 : #endif
51 : #include <ext/atomicity.h> // __gnu_cxx::__is_single_threaded
52 :
53 : #if defined _GLIBCXX_HAS_GTHREADS && ! defined _GLIBCXX_HAVE_TLS
54 : # include <bits/std_function.h> // std::function
55 : #endif
56 :
57 : namespace std _GLIBCXX_VISIBILITY(default)
58 : {
59 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
60 :
61 : /**
62 : * @addtogroup mutexes
63 : * @{
64 : */
65 :
66 : #ifdef _GLIBCXX_HAS_GTHREADS
67 : /// @cond undocumented
68 :
69 : // Common base class for std::recursive_mutex and std::recursive_timed_mutex
70 : class __recursive_mutex_base
71 : {
72 : protected:
73 : typedef __gthread_recursive_mutex_t __native_type;
74 :
75 : __recursive_mutex_base(const __recursive_mutex_base&) = delete;
76 : __recursive_mutex_base& operator=(const __recursive_mutex_base&) = delete;
77 :
78 : #ifdef __GTHREAD_RECURSIVE_MUTEX_INIT
79 : __native_type _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT;
80 :
81 : __recursive_mutex_base() = default;
82 : #else
83 : __native_type _M_mutex;
84 :
85 : __recursive_mutex_base()
86 : {
87 : // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
88 : __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
89 : }
90 :
91 : ~__recursive_mutex_base()
92 : { __gthread_recursive_mutex_destroy(&_M_mutex); }
93 : #endif
94 : };
95 : /// @endcond
96 :
97 : /** The standard recursive mutex type.
98 : *
99 : * A recursive mutex can be locked more than once by the same thread.
100 : * Other threads cannot lock the mutex until the owning thread unlocks it
101 : * as many times as it was locked.
102 : *
103 : * @headerfile mutex
104 : * @since C++11
105 : */
106 : class recursive_mutex : private __recursive_mutex_base
107 : {
108 : public:
109 : typedef __native_type* native_handle_type;
110 :
111 : recursive_mutex() = default;
112 : ~recursive_mutex() = default;
113 :
114 : recursive_mutex(const recursive_mutex&) = delete;
115 : recursive_mutex& operator=(const recursive_mutex&) = delete;
116 :
117 : void
118 3564 : lock()
119 : {
120 3564 : int __e = __gthread_recursive_mutex_lock(&_M_mutex);
121 :
122 : // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
123 3564 : if (__e)
124 0 : __throw_system_error(__e);
125 3564 : }
126 :
127 : _GLIBCXX_NODISCARD
128 : bool
129 : try_lock() noexcept
130 : {
131 : // XXX EINVAL, EAGAIN, EBUSY
132 : return !__gthread_recursive_mutex_trylock(&_M_mutex);
133 : }
134 :
135 : void
136 3564 : unlock()
137 : {
138 : // XXX EINVAL, EAGAIN, EBUSY
139 3564 : __gthread_recursive_mutex_unlock(&_M_mutex);
140 3564 : }
141 :
142 : native_handle_type
143 : native_handle() noexcept
144 : { return &_M_mutex; }
145 : };
146 :
147 : #if _GTHREAD_USE_MUTEX_TIMEDLOCK
148 : /// @cond undocumented
149 :
150 : template<typename _Derived>
151 : class __timed_mutex_impl
152 : {
153 : protected:
154 : template<typename _Rep, typename _Period>
155 : bool
156 : _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
157 : {
158 : #if _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK
159 : using __clock = chrono::steady_clock;
160 : #else
161 : using __clock = chrono::system_clock;
162 : #endif
163 :
164 : auto __rt = chrono::duration_cast<__clock::duration>(__rtime);
165 : if (ratio_greater<__clock::period, _Period>())
166 : ++__rt;
167 : return _M_try_lock_until(__clock::now() + __rt);
168 : }
169 :
170 : template<typename _Duration>
171 : bool
172 : _M_try_lock_until(const chrono::time_point<chrono::system_clock,
173 : _Duration>& __atime)
174 : {
175 : auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
176 : auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
177 :
178 : __gthread_time_t __ts = {
179 : static_cast<std::time_t>(__s.time_since_epoch().count()),
180 : static_cast<long>(__ns.count())
181 : };
182 :
183 : return static_cast<_Derived*>(this)->_M_timedlock(__ts);
184 : }
185 :
186 : #ifdef _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK
187 : template<typename _Duration>
188 : bool
189 : _M_try_lock_until(const chrono::time_point<chrono::steady_clock,
190 : _Duration>& __atime)
191 : {
192 : auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
193 : auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
194 :
195 : __gthread_time_t __ts = {
196 : static_cast<std::time_t>(__s.time_since_epoch().count()),
197 : static_cast<long>(__ns.count())
198 : };
199 :
200 : return static_cast<_Derived*>(this)->_M_clocklock(CLOCK_MONOTONIC,
201 : __ts);
202 : }
203 : #endif
204 :
205 : template<typename _Clock, typename _Duration>
206 : bool
207 : _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
208 : {
209 : #if __cplusplus > 201703L
210 : static_assert(chrono::is_clock_v<_Clock>);
211 : #endif
212 : // The user-supplied clock may not tick at the same rate as
213 : // steady_clock, so we must loop in order to guarantee that
214 : // the timeout has expired before returning false.
215 : auto __now = _Clock::now();
216 : do {
217 : auto __rtime = __atime - __now;
218 : if (_M_try_lock_for(__rtime))
219 : return true;
220 : __now = _Clock::now();
221 : } while (__atime > __now);
222 : return false;
223 : }
224 : };
225 : /// @endcond
226 :
227 : /** The standard timed mutex type.
228 : *
229 : * A non-recursive mutex that supports a timeout when trying to acquire the
230 : * lock.
231 : *
232 : * @headerfile mutex
233 : * @since C++11
234 : */
235 : class timed_mutex
236 : : private __mutex_base, public __timed_mutex_impl<timed_mutex>
237 : {
238 : public:
239 : typedef __native_type* native_handle_type;
240 :
241 : timed_mutex() = default;
242 : ~timed_mutex() = default;
243 :
244 : timed_mutex(const timed_mutex&) = delete;
245 : timed_mutex& operator=(const timed_mutex&) = delete;
246 :
247 : void
248 : lock()
249 : {
250 : int __e = __gthread_mutex_lock(&_M_mutex);
251 :
252 : // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
253 : if (__e)
254 : __throw_system_error(__e);
255 : }
256 :
257 : _GLIBCXX_NODISCARD
258 : bool
259 : try_lock() noexcept
260 : {
261 : // XXX EINVAL, EAGAIN, EBUSY
262 : return !__gthread_mutex_trylock(&_M_mutex);
263 : }
264 :
265 : template <class _Rep, class _Period>
266 : _GLIBCXX_NODISCARD
267 : bool
268 : try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
269 : { return _M_try_lock_for(__rtime); }
270 :
271 : template <class _Clock, class _Duration>
272 : _GLIBCXX_NODISCARD
273 : bool
274 : try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
275 : { return _M_try_lock_until(__atime); }
276 :
277 : void
278 : unlock()
279 : {
280 : // XXX EINVAL, EAGAIN, EBUSY
281 : __gthread_mutex_unlock(&_M_mutex);
282 : }
283 :
284 : native_handle_type
285 : native_handle() noexcept
286 : { return &_M_mutex; }
287 :
288 : private:
289 : friend class __timed_mutex_impl<timed_mutex>;
290 :
291 : bool
292 : _M_timedlock(const __gthread_time_t& __ts)
293 : { return !__gthread_mutex_timedlock(&_M_mutex, &__ts); }
294 :
295 : #if _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK
296 : bool
297 : _M_clocklock(clockid_t __clockid, const __gthread_time_t& __ts)
298 : { return !pthread_mutex_clocklock(&_M_mutex, __clockid, &__ts); }
299 : #endif
300 : };
301 :
302 : /** The standard recursive timed mutex type.
303 : *
304 : * A recursive mutex that supports a timeout when trying to acquire the
305 : * lock. A recursive mutex can be locked more than once by the same thread.
306 : * Other threads cannot lock the mutex until the owning thread unlocks it
307 : * as many times as it was locked.
308 : *
309 : * @headerfile mutex
310 : * @since C++11
311 : */
312 : class recursive_timed_mutex
313 : : private __recursive_mutex_base,
314 : public __timed_mutex_impl<recursive_timed_mutex>
315 : {
316 : public:
317 : typedef __native_type* native_handle_type;
318 :
319 : recursive_timed_mutex() = default;
320 : ~recursive_timed_mutex() = default;
321 :
322 : recursive_timed_mutex(const recursive_timed_mutex&) = delete;
323 : recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
324 :
325 : void
326 : lock()
327 : {
328 : int __e = __gthread_recursive_mutex_lock(&_M_mutex);
329 :
330 : // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
331 : if (__e)
332 : __throw_system_error(__e);
333 : }
334 :
335 : _GLIBCXX_NODISCARD
336 : bool
337 : try_lock() noexcept
338 : {
339 : // XXX EINVAL, EAGAIN, EBUSY
340 : return !__gthread_recursive_mutex_trylock(&_M_mutex);
341 : }
342 :
343 : template <class _Rep, class _Period>
344 : _GLIBCXX_NODISCARD
345 : bool
346 : try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
347 : { return _M_try_lock_for(__rtime); }
348 :
349 : template <class _Clock, class _Duration>
350 : _GLIBCXX_NODISCARD
351 : bool
352 : try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
353 : { return _M_try_lock_until(__atime); }
354 :
355 : void
356 : unlock()
357 : {
358 : // XXX EINVAL, EAGAIN, EBUSY
359 : __gthread_recursive_mutex_unlock(&_M_mutex);
360 : }
361 :
362 : native_handle_type
363 : native_handle() noexcept
364 : { return &_M_mutex; }
365 :
366 : private:
367 : friend class __timed_mutex_impl<recursive_timed_mutex>;
368 :
369 : bool
370 : _M_timedlock(const __gthread_time_t& __ts)
371 : { return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); }
372 :
373 : #ifdef _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK
374 : bool
375 : _M_clocklock(clockid_t __clockid, const __gthread_time_t& __ts)
376 : { return !pthread_mutex_clocklock(&_M_mutex, __clockid, &__ts); }
377 : #endif
378 : };
379 :
380 : #else // !_GTHREAD_USE_MUTEX_TIMEDLOCK
381 :
382 : /// timed_mutex
383 : class timed_mutex
384 : {
385 : mutex _M_mut;
386 : condition_variable _M_cv;
387 : bool _M_locked = false;
388 :
389 : public:
390 :
391 : timed_mutex() = default;
392 : ~timed_mutex() { __glibcxx_assert( !_M_locked ); }
393 :
394 : timed_mutex(const timed_mutex&) = delete;
395 : timed_mutex& operator=(const timed_mutex&) = delete;
396 :
397 : void
398 : lock()
399 : {
400 : unique_lock<mutex> __lk(_M_mut);
401 : _M_cv.wait(__lk, [&]{ return !_M_locked; });
402 : _M_locked = true;
403 : }
404 :
405 : _GLIBCXX_NODISCARD
406 : bool
407 : try_lock()
408 : {
409 : lock_guard<mutex> __lk(_M_mut);
410 : if (_M_locked)
411 : return false;
412 : _M_locked = true;
413 : return true;
414 : }
415 :
416 : template<typename _Rep, typename _Period>
417 : _GLIBCXX_NODISCARD
418 : bool
419 : try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
420 : {
421 : unique_lock<mutex> __lk(_M_mut);
422 : if (!_M_cv.wait_for(__lk, __rtime, [&]{ return !_M_locked; }))
423 : return false;
424 : _M_locked = true;
425 : return true;
426 : }
427 :
428 : template<typename _Clock, typename _Duration>
429 : _GLIBCXX_NODISCARD
430 : bool
431 : try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
432 : {
433 : unique_lock<mutex> __lk(_M_mut);
434 : if (!_M_cv.wait_until(__lk, __atime, [&]{ return !_M_locked; }))
435 : return false;
436 : _M_locked = true;
437 : return true;
438 : }
439 :
440 : void
441 : unlock()
442 : {
443 : lock_guard<mutex> __lk(_M_mut);
444 : __glibcxx_assert( _M_locked );
445 : _M_locked = false;
446 : _M_cv.notify_one();
447 : }
448 : };
449 :
450 : /// recursive_timed_mutex
451 : class recursive_timed_mutex
452 : {
453 : mutex _M_mut;
454 : condition_variable _M_cv;
455 : thread::id _M_owner;
456 : unsigned _M_count = 0;
457 :
458 : // Predicate type that tests whether the current thread can lock a mutex.
459 : struct _Can_lock
460 : {
461 : // Returns true if the mutex is unlocked or is locked by _M_caller.
462 : bool
463 : operator()() const noexcept
464 : { return _M_mx->_M_count == 0 || _M_mx->_M_owner == _M_caller; }
465 :
466 : const recursive_timed_mutex* _M_mx;
467 : thread::id _M_caller;
468 : };
469 :
470 : public:
471 :
472 : recursive_timed_mutex() = default;
473 : ~recursive_timed_mutex() { __glibcxx_assert( _M_count == 0 ); }
474 :
475 : recursive_timed_mutex(const recursive_timed_mutex&) = delete;
476 : recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
477 :
478 : void
479 : lock()
480 : {
481 : auto __id = this_thread::get_id();
482 : _Can_lock __can_lock{this, __id};
483 : unique_lock<mutex> __lk(_M_mut);
484 : _M_cv.wait(__lk, __can_lock);
485 : if (_M_count == -1u)
486 : __throw_system_error(EAGAIN); // [thread.timedmutex.recursive]/3
487 : _M_owner = __id;
488 : ++_M_count;
489 : }
490 :
491 : _GLIBCXX_NODISCARD
492 : bool
493 : try_lock()
494 : {
495 : auto __id = this_thread::get_id();
496 : _Can_lock __can_lock{this, __id};
497 : lock_guard<mutex> __lk(_M_mut);
498 : if (!__can_lock())
499 : return false;
500 : if (_M_count == -1u)
501 : return false;
502 : _M_owner = __id;
503 : ++_M_count;
504 : return true;
505 : }
506 :
507 : template<typename _Rep, typename _Period>
508 : _GLIBCXX_NODISCARD
509 : bool
510 : try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
511 : {
512 : auto __id = this_thread::get_id();
513 : _Can_lock __can_lock{this, __id};
514 : unique_lock<mutex> __lk(_M_mut);
515 : if (!_M_cv.wait_for(__lk, __rtime, __can_lock))
516 : return false;
517 : if (_M_count == -1u)
518 : return false;
519 : _M_owner = __id;
520 : ++_M_count;
521 : return true;
522 : }
523 :
524 : template<typename _Clock, typename _Duration>
525 : _GLIBCXX_NODISCARD
526 : bool
527 : try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
528 : {
529 : auto __id = this_thread::get_id();
530 : _Can_lock __can_lock{this, __id};
531 : unique_lock<mutex> __lk(_M_mut);
532 : if (!_M_cv.wait_until(__lk, __atime, __can_lock))
533 : return false;
534 : if (_M_count == -1u)
535 : return false;
536 : _M_owner = __id;
537 : ++_M_count;
538 : return true;
539 : }
540 :
541 : void
542 : unlock()
543 : {
544 : lock_guard<mutex> __lk(_M_mut);
545 : __glibcxx_assert( _M_owner == this_thread::get_id() );
546 : __glibcxx_assert( _M_count > 0 );
547 : if (--_M_count == 0)
548 : {
549 : _M_owner = {};
550 : _M_cv.notify_one();
551 : }
552 : }
553 : };
554 :
555 : #endif
556 : #endif // _GLIBCXX_HAS_GTHREADS
557 :
558 : /// @cond undocumented
559 : namespace __detail
560 : {
561 : // Lock the last lockable, after all previous ones are locked.
562 : template<typename _Lockable>
563 : inline int
564 : __try_lock_impl(_Lockable& __l)
565 : {
566 : if (unique_lock<_Lockable> __lock{__l, try_to_lock})
567 : {
568 : __lock.release();
569 : return -1;
570 : }
571 : else
572 : return 0;
573 : }
574 :
575 : // Lock each lockable in turn.
576 : // Use iteration if all lockables are the same type, recursion otherwise.
577 : template<typename _L0, typename... _Lockables>
578 : inline int
579 : __try_lock_impl(_L0& __l0, _Lockables&... __lockables)
580 : {
581 : #if __cplusplus >= 201703L
582 : if constexpr ((is_same_v<_L0, _Lockables> && ...))
583 : {
584 : constexpr int _Np = 1 + sizeof...(_Lockables);
585 : unique_lock<_L0> __locks[_Np] = {
586 : {__l0, defer_lock}, {__lockables, defer_lock}...
587 : };
588 : for (int __i = 0; __i < _Np; ++__i)
589 : {
590 : if (!__locks[__i].try_lock())
591 : {
592 : const int __failed = __i;
593 : while (__i--)
594 : __locks[__i].unlock();
595 : return __failed;
596 : }
597 : }
598 : for (auto& __l : __locks)
599 : __l.release();
600 : return -1;
601 : }
602 : else
603 : #endif
604 : if (unique_lock<_L0> __lock{__l0, try_to_lock})
605 : {
606 : int __idx = __detail::__try_lock_impl(__lockables...);
607 : if (__idx == -1)
608 : {
609 : __lock.release();
610 : return -1;
611 : }
612 : return __idx + 1;
613 : }
614 : else
615 : return 0;
616 : }
617 :
618 : } // namespace __detail
619 : /// @endcond
620 :
621 : /** @brief Generic try_lock.
622 : * @param __l1 Meets Lockable requirements (try_lock() may throw).
623 : * @param __l2 Meets Lockable requirements (try_lock() may throw).
624 : * @param __l3 Meets Lockable requirements (try_lock() may throw).
625 : * @return Returns -1 if all try_lock() calls return true. Otherwise returns
626 : * a 0-based index corresponding to the argument that returned false.
627 : * @post Either all arguments are locked, or none will be.
628 : *
629 : * Sequentially calls try_lock() on each argument.
630 : */
631 : template<typename _L1, typename _L2, typename... _L3>
632 : _GLIBCXX_NODISCARD
633 : inline int
634 : try_lock(_L1& __l1, _L2& __l2, _L3&... __l3)
635 : {
636 : return __detail::__try_lock_impl(__l1, __l2, __l3...);
637 : }
638 :
639 : /// @cond undocumented
640 : namespace __detail
641 : {
642 : // This function can recurse up to N levels deep, for N = 1+sizeof...(L1).
643 : // On each recursion the lockables are rotated left one position,
644 : // e.g. depth 0: l0, l1, l2; depth 1: l1, l2, l0; depth 2: l2, l0, l1.
645 : // When a call to l_i.try_lock() fails it recurses/returns to depth=i
646 : // so that l_i is the first argument, and then blocks until l_i is locked.
647 : template<typename _L0, typename... _L1>
648 : void
649 : __lock_impl(int& __i, int __depth, _L0& __l0, _L1&... __l1)
650 : {
651 : while (__i >= __depth)
652 : {
653 : if (__i == __depth)
654 : {
655 : int __failed = 1; // index that couldn't be locked
656 : {
657 : unique_lock<_L0> __first(__l0);
658 : __failed += __detail::__try_lock_impl(__l1...);
659 : if (!__failed)
660 : {
661 : __i = -1; // finished
662 : __first.release();
663 : return;
664 : }
665 : }
666 : #if defined _GLIBCXX_HAS_GTHREADS && defined _GLIBCXX_USE_SCHED_YIELD
667 : __gthread_yield();
668 : #endif
669 : constexpr auto __n = 1 + sizeof...(_L1);
670 : __i = (__depth + __failed) % __n;
671 : }
672 : else // rotate left until l_i is first.
673 : __detail::__lock_impl(__i, __depth + 1, __l1..., __l0);
674 : }
675 : }
676 :
677 : } // namespace __detail
678 : /// @endcond
679 :
680 : /** @brief Generic lock.
681 : * @param __l1 Meets Lockable requirements (try_lock() may throw).
682 : * @param __l2 Meets Lockable requirements (try_lock() may throw).
683 : * @param __l3 Meets Lockable requirements (try_lock() may throw).
684 : * @throw An exception thrown by an argument's lock() or try_lock() member.
685 : * @post All arguments are locked.
686 : *
687 : * All arguments are locked via a sequence of calls to lock(), try_lock()
688 : * and unlock(). If this function exits via an exception any locks that
689 : * were obtained will be released.
690 : */
691 : template<typename _L1, typename _L2, typename... _L3>
692 : void
693 : lock(_L1& __l1, _L2& __l2, _L3&... __l3)
694 : {
695 : #if __cplusplus >= 201703L
696 : if constexpr (is_same_v<_L1, _L2> && (is_same_v<_L1, _L3> && ...))
697 : {
698 : constexpr int _Np = 2 + sizeof...(_L3);
699 : unique_lock<_L1> __locks[] = {
700 : {__l1, defer_lock}, {__l2, defer_lock}, {__l3, defer_lock}...
701 : };
702 : int __first = 0;
703 : do {
704 : __locks[__first].lock();
705 : for (int __j = 1; __j < _Np; ++__j)
706 : {
707 : const int __idx = (__first + __j) % _Np;
708 : if (!__locks[__idx].try_lock())
709 : {
710 : for (int __k = __j; __k != 0; --__k)
711 : __locks[(__first + __k - 1) % _Np].unlock();
712 : __first = __idx;
713 : break;
714 : }
715 : }
716 : } while (!__locks[__first].owns_lock());
717 :
718 : for (auto& __l : __locks)
719 : __l.release();
720 : }
721 : else
722 : #endif
723 : {
724 : int __i = 0;
725 : __detail::__lock_impl(__i, 0, __l1, __l2, __l3...);
726 : }
727 : }
728 :
729 : #if __cplusplus >= 201703L
730 : #define __cpp_lib_scoped_lock 201703L
731 : /** @brief A scoped lock type for multiple lockable objects.
732 : *
733 : * A scoped_lock controls mutex ownership within a scope, releasing
734 : * ownership in the destructor.
735 : *
736 : * @headerfile mutex
737 : * @since C++17
738 : */
739 : template<typename... _MutexTypes>
740 : class scoped_lock
741 : {
742 : public:
743 : explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m...))
744 : { std::lock(__m...); }
745 :
746 : explicit scoped_lock(adopt_lock_t, _MutexTypes&... __m) noexcept
747 : : _M_devices(std::tie(__m...))
748 : { } // calling thread owns mutex
749 :
750 : ~scoped_lock()
751 : { std::apply([](auto&... __m) { (__m.unlock(), ...); }, _M_devices); }
752 :
753 : scoped_lock(const scoped_lock&) = delete;
754 : scoped_lock& operator=(const scoped_lock&) = delete;
755 :
756 : private:
757 : tuple<_MutexTypes&...> _M_devices;
758 : };
759 :
760 : template<>
761 : class scoped_lock<>
762 : {
763 : public:
764 : explicit scoped_lock() = default;
765 : explicit scoped_lock(adopt_lock_t) noexcept { }
766 : ~scoped_lock() = default;
767 :
768 : scoped_lock(const scoped_lock&) = delete;
769 : scoped_lock& operator=(const scoped_lock&) = delete;
770 : };
771 :
772 : template<typename _Mutex>
773 : class scoped_lock<_Mutex>
774 : {
775 : public:
776 : using mutex_type = _Mutex;
777 :
778 : explicit scoped_lock(mutex_type& __m) : _M_device(__m)
779 : { _M_device.lock(); }
780 :
781 : explicit scoped_lock(adopt_lock_t, mutex_type& __m) noexcept
782 : : _M_device(__m)
783 : { } // calling thread owns mutex
784 :
785 : ~scoped_lock()
786 : { _M_device.unlock(); }
787 :
788 : scoped_lock(const scoped_lock&) = delete;
789 : scoped_lock& operator=(const scoped_lock&) = delete;
790 :
791 : private:
792 : mutex_type& _M_device;
793 : };
794 : #endif // C++17
795 :
796 : #ifdef _GLIBCXX_HAS_GTHREADS
797 : /// Flag type used by std::call_once
798 : struct once_flag
799 : {
800 : constexpr once_flag() noexcept = default;
801 :
802 : /// Deleted copy constructor
803 : once_flag(const once_flag&) = delete;
804 : /// Deleted assignment operator
805 : once_flag& operator=(const once_flag&) = delete;
806 :
807 : private:
808 : // For gthreads targets a pthread_once_t is used with pthread_once, but
809 : // for most targets this doesn't work correctly for exceptional executions.
810 : __gthread_once_t _M_once = __GTHREAD_ONCE_INIT;
811 :
812 : struct _Prepare_execution;
813 :
814 : template<typename _Callable, typename... _Args>
815 : friend void
816 : call_once(once_flag& __once, _Callable&& __f, _Args&&... __args);
817 : };
818 :
819 : /// @cond undocumented
820 : # ifdef _GLIBCXX_HAVE_TLS
821 : // If TLS is available use thread-local state for the type-erased callable
822 : // that is being run by std::call_once in the current thread.
823 : extern __thread void* __once_callable;
824 : extern __thread void (*__once_call)();
825 :
826 : // RAII type to set up state for pthread_once call.
827 : struct once_flag::_Prepare_execution
828 : {
829 : template<typename _Callable>
830 : explicit
831 : _Prepare_execution(_Callable& __c)
832 : {
833 : // Store address in thread-local pointer:
834 : __once_callable = std::__addressof(__c);
835 : // Trampoline function to invoke the closure via thread-local pointer:
836 : __once_call = [] { (*static_cast<_Callable*>(__once_callable))(); };
837 : }
838 :
839 : ~_Prepare_execution()
840 : {
841 : // PR libstdc++/82481
842 : __once_callable = nullptr;
843 : __once_call = nullptr;
844 : }
845 :
846 : _Prepare_execution(const _Prepare_execution&) = delete;
847 : _Prepare_execution& operator=(const _Prepare_execution&) = delete;
848 : };
849 :
850 : # else
851 : // Without TLS use a global std::mutex and store the callable in a
852 : // global std::function.
853 : extern function<void()> __once_functor;
854 :
855 : extern void
856 : __set_once_functor_lock_ptr(unique_lock<mutex>*);
857 :
858 : extern mutex&
859 : __get_once_mutex();
860 :
861 : // RAII type to set up state for pthread_once call.
862 : struct once_flag::_Prepare_execution
863 : {
864 : template<typename _Callable>
865 : explicit
866 : _Prepare_execution(_Callable& __c)
867 : {
868 : // Store the callable in the global std::function
869 : __once_functor = __c;
870 : __set_once_functor_lock_ptr(&_M_functor_lock);
871 : }
872 :
873 : ~_Prepare_execution()
874 : {
875 : if (_M_functor_lock)
876 : __set_once_functor_lock_ptr(nullptr);
877 : }
878 :
879 : private:
880 : // XXX This deadlocks if used recursively (PR 97949)
881 : unique_lock<mutex> _M_functor_lock{__get_once_mutex()};
882 :
883 : _Prepare_execution(const _Prepare_execution&) = delete;
884 : _Prepare_execution& operator=(const _Prepare_execution&) = delete;
885 : };
886 : # endif
887 : /// @endcond
888 :
889 : // This function is passed to pthread_once by std::call_once.
890 : // It runs __once_call() or __once_functor().
891 : extern "C" void __once_proxy(void);
892 :
893 : /// Invoke a callable and synchronize with other calls using the same flag
894 : template<typename _Callable, typename... _Args>
895 : void
896 : call_once(once_flag& __once, _Callable&& __f, _Args&&... __args)
897 : {
898 : // Closure type that runs the function
899 : auto __callable = [&] {
900 : std::__invoke(std::forward<_Callable>(__f),
901 : std::forward<_Args>(__args)...);
902 : };
903 :
904 : once_flag::_Prepare_execution __exec(__callable);
905 :
906 : // XXX pthread_once does not reset the flag if an exception is thrown.
907 : if (int __e = __gthread_once(&__once._M_once, &__once_proxy))
908 : __throw_system_error(__e);
909 : }
910 :
911 : #else // _GLIBCXX_HAS_GTHREADS
912 :
913 : /// Flag type used by std::call_once
914 : struct once_flag
915 : {
916 : constexpr once_flag() noexcept = default;
917 :
918 : /// Deleted copy constructor
919 : once_flag(const once_flag&) = delete;
920 : /// Deleted assignment operator
921 : once_flag& operator=(const once_flag&) = delete;
922 :
923 : private:
924 : // There are two different std::once_flag interfaces, abstracting four
925 : // different implementations.
926 : // The single-threaded interface uses the _M_activate() and _M_finish(bool)
927 : // functions, which start and finish an active execution respectively.
928 : // See [thread.once.callonce] in C++11 for the definition of
929 : // active/passive/returning/exceptional executions.
930 : enum _Bits : int { _Init = 0, _Active = 1, _Done = 2 };
931 :
932 : int _M_once = _Bits::_Init;
933 :
934 : // Check to see if all executions will be passive now.
935 : bool
936 : _M_passive() const noexcept;
937 :
938 : // Attempts to begin an active execution.
939 : bool _M_activate();
940 :
941 : // Must be called to complete an active execution.
942 : // The argument is true if the active execution was a returning execution,
943 : // false if it was an exceptional execution.
944 : void _M_finish(bool __returning) noexcept;
945 :
946 : // RAII helper to call _M_finish.
947 : struct _Active_execution
948 : {
949 : explicit _Active_execution(once_flag& __flag) : _M_flag(__flag) { }
950 :
951 : ~_Active_execution() { _M_flag._M_finish(_M_returning); }
952 :
953 : _Active_execution(const _Active_execution&) = delete;
954 : _Active_execution& operator=(const _Active_execution&) = delete;
955 :
956 : once_flag& _M_flag;
957 : bool _M_returning = false;
958 : };
959 :
960 : template<typename _Callable, typename... _Args>
961 : friend void
962 : call_once(once_flag& __once, _Callable&& __f, _Args&&... __args);
963 : };
964 :
965 : // Inline definitions of std::once_flag members for single-threaded targets.
966 :
967 : inline bool
968 : once_flag::_M_passive() const noexcept
969 : { return _M_once == _Bits::_Done; }
970 :
971 : inline bool
972 : once_flag::_M_activate()
973 : {
974 : if (_M_once == _Bits::_Init) [[__likely__]]
975 : {
976 : _M_once = _Bits::_Active;
977 : return true;
978 : }
979 : else if (_M_passive()) // Caller should have checked this already.
980 : return false;
981 : else
982 : __throw_system_error(EDEADLK);
983 : }
984 :
985 : inline void
986 : once_flag::_M_finish(bool __returning) noexcept
987 : { _M_once = __returning ? _Bits::_Done : _Bits::_Init; }
988 :
989 : /// Invoke a callable and synchronize with other calls using the same flag
990 : template<typename _Callable, typename... _Args>
991 : inline void
992 : call_once(once_flag& __once, _Callable&& __f, _Args&&... __args)
993 : {
994 : if (__once._M_passive())
995 : return;
996 : else if (__once._M_activate())
997 : {
998 : once_flag::_Active_execution __exec(__once);
999 :
1000 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1001 : // 2442. call_once() shouldn't DECAY_COPY()
1002 : std::__invoke(std::forward<_Callable>(__f),
1003 : std::forward<_Args>(__args)...);
1004 :
1005 : // __f(__args...) did not throw
1006 : __exec._M_returning = true;
1007 : }
1008 : }
1009 : #endif // _GLIBCXX_HAS_GTHREADS
1010 :
1011 : /// @} group mutexes
1012 : _GLIBCXX_END_NAMESPACE_VERSION
1013 : } // namespace
1014 :
1015 : #endif // C++11
1016 :
1017 : #endif // _GLIBCXX_MUTEX
|
