29#ifndef _GLIBCXX_SHARED_MUTEX
30#define _GLIBCXX_SHARED_MUTEX 1
32#pragma GCC system_header
36#if __cplusplus >= 201402L
43#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
47namespace std _GLIBCXX_VISIBILITY(default)
49_GLIBCXX_BEGIN_NAMESPACE_VERSION
56#ifdef _GLIBCXX_HAS_GTHREADS
58#if __cplusplus >= 201703L
59#define __cpp_lib_shared_mutex 201505L
63#define __cpp_lib_shared_timed_mutex 201402L
64 class shared_timed_mutex;
68#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
70#define _GLIBCXX_GTHRW(name) \
71 __gthrw(pthread_ ## name); \
73 __glibcxx_ ## name (pthread_rwlock_t *__rwlock) \
75 if (__gthread_active_p ()) \
76 return __gthrw_(pthread_ ## name) (__rwlock); \
80 _GLIBCXX_GTHRW(rwlock_rdlock)
81 _GLIBCXX_GTHRW(rwlock_tryrdlock)
82 _GLIBCXX_GTHRW(rwlock_wrlock)
83 _GLIBCXX_GTHRW(rwlock_trywrlock)
84 _GLIBCXX_GTHRW(rwlock_unlock)
85# ifndef PTHREAD_RWLOCK_INITIALIZER
86 _GLIBCXX_GTHRW(rwlock_destroy)
87 __gthrw(pthread_rwlock_init);
89 __glibcxx_rwlock_init (pthread_rwlock_t *__rwlock)
91 if (__gthread_active_p ())
92 return __gthrw_(pthread_rwlock_init) (__rwlock, NULL);
97# if _GTHREAD_USE_MUTEX_TIMEDLOCK
98 __gthrw(pthread_rwlock_timedrdlock);
100 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
101 const timespec *__ts)
103 if (__gthread_active_p ())
104 return __gthrw_(pthread_rwlock_timedrdlock) (__rwlock, __ts);
108 __gthrw(pthread_rwlock_timedwrlock);
110 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
111 const timespec *__ts)
113 if (__gthread_active_p ())
114 return __gthrw_(pthread_rwlock_timedwrlock) (__rwlock, __ts);
121 __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock)
122 {
return pthread_rwlock_rdlock (__rwlock); }
124 __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
125 {
return pthread_rwlock_tryrdlock (__rwlock); }
127 __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock)
128 {
return pthread_rwlock_wrlock (__rwlock); }
130 __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
131 {
return pthread_rwlock_trywrlock (__rwlock); }
133 __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock)
134 {
return pthread_rwlock_unlock (__rwlock); }
136 __glibcxx_rwlock_destroy(pthread_rwlock_t *__rwlock)
137 {
return pthread_rwlock_destroy (__rwlock); }
139 __glibcxx_rwlock_init(pthread_rwlock_t *__rwlock)
140 {
return pthread_rwlock_init (__rwlock, NULL); }
141# if _GTHREAD_USE_MUTEX_TIMEDLOCK
143 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
144 const timespec *__ts)
145 {
return pthread_rwlock_timedrdlock (__rwlock, __ts); }
147 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
148 const timespec *__ts)
149 {
return pthread_rwlock_timedwrlock (__rwlock, __ts); }
154 class __shared_mutex_pthread
156 friend class shared_timed_mutex;
158#ifdef PTHREAD_RWLOCK_INITIALIZER
159 pthread_rwlock_t _M_rwlock = PTHREAD_RWLOCK_INITIALIZER;
162 __shared_mutex_pthread() =
default;
163 ~__shared_mutex_pthread() =
default;
165 pthread_rwlock_t _M_rwlock;
168 __shared_mutex_pthread()
170 int __ret = __glibcxx_rwlock_init(&_M_rwlock);
173 else if (__ret == EAGAIN)
174 __throw_system_error(
int(errc::resource_unavailable_try_again));
175 else if (__ret == EPERM)
176 __throw_system_error(
int(errc::operation_not_permitted));
178 __glibcxx_assert(__ret == 0);
181 ~__shared_mutex_pthread()
183 int __ret __attribute((__unused__)) = __glibcxx_rwlock_destroy(&_M_rwlock);
185 __glibcxx_assert(__ret == 0);
189 __shared_mutex_pthread(
const __shared_mutex_pthread&) =
delete;
190 __shared_mutex_pthread& operator=(
const __shared_mutex_pthread&) =
delete;
195 int __ret = __glibcxx_rwlock_wrlock(&_M_rwlock);
196 if (__ret == EDEADLK)
197 __throw_system_error(
int(errc::resource_deadlock_would_occur));
199 __glibcxx_assert(__ret == 0);
205 int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock);
206 if (__ret == EBUSY)
return false;
208 __glibcxx_assert(__ret == 0);
215 int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock);
217 __glibcxx_assert(__ret == 0);
231 __ret = __glibcxx_rwlock_rdlock(&_M_rwlock);
232 while (__ret == EAGAIN);
233 if (__ret == EDEADLK)
234 __throw_system_error(
int(errc::resource_deadlock_would_occur));
236 __glibcxx_assert(__ret == 0);
242 int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock);
246 if (__ret == EBUSY || __ret == EAGAIN)
return false;
248 __glibcxx_assert(__ret == 0);
258 void* native_handle() {
return &_M_rwlock; }
262#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
264 class __shared_mutex_cv
266 friend class shared_timed_mutex;
296 condition_variable _M_gate1;
298 condition_variable _M_gate2;
302 static constexpr unsigned _S_write_entered
303 = 1U << (
sizeof(unsigned)*__CHAR_BIT__ - 1);
304 static constexpr unsigned _S_max_readers = ~_S_write_entered;
307 bool _M_write_entered()
const {
return _M_state & _S_write_entered; }
310 unsigned _M_readers()
const {
return _M_state & _S_max_readers; }
313 __shared_mutex_cv() : _M_state(0) {}
317 __glibcxx_assert( _M_state == 0 );
320 __shared_mutex_cv(
const __shared_mutex_cv&) =
delete;
321 __shared_mutex_cv& operator=(
const __shared_mutex_cv&) =
delete;
328 unique_lock<mutex> __lk(_M_mut);
330 _M_gate1.wait(__lk, [=]{
return !_M_write_entered(); });
331 _M_state |= _S_write_entered;
333 _M_gate2.wait(__lk, [=]{
return _M_readers() == 0; });
340 if (__lk.owns_lock() && _M_state == 0)
342 _M_state = _S_write_entered;
351 lock_guard<mutex> __lk(_M_mut);
352 __glibcxx_assert( _M_write_entered() );
356 _M_gate1.notify_all();
364 unique_lock<mutex> __lk(_M_mut);
365 _M_gate1.wait(__lk, [=]{
return _M_state < _S_max_readers; });
373 if (!__lk.owns_lock())
375 if (_M_state < _S_max_readers)
386 lock_guard<mutex> __lk(_M_mut);
387 __glibcxx_assert( _M_readers() > 0 );
388 auto __prev = _M_state--;
389 if (_M_write_entered())
392 if (_M_readers() == 0)
393 _M_gate2.notify_one();
401 if (__prev == _S_max_readers)
402 _M_gate1.notify_one();
409#if __cplusplus >= 201703L
422 void lock() { _M_impl.lock(); }
423 [[nodiscard]]
bool try_lock() {
return _M_impl.try_lock(); }
424 void unlock() { _M_impl.unlock(); }
428 void lock_shared() { _M_impl.lock_shared(); }
429 [[nodiscard]]
bool try_lock_shared() {
return _M_impl.try_lock_shared(); }
430 void unlock_shared() { _M_impl.unlock_shared(); }
432#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
433 typedef void* native_handle_type;
434 native_handle_type native_handle() {
return _M_impl.native_handle(); }
437 __shared_mutex_pthread _M_impl;
440 __shared_mutex_cv _M_impl;
446#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
447 using __shared_timed_mutex_base = __shared_mutex_pthread;
449 using __shared_timed_mutex_base = __shared_mutex_cv;
455 :
private __shared_timed_mutex_base
457 using _Base = __shared_timed_mutex_base;
460#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
477 void unlock() { _Base::unlock(); }
479 template<
typename _Rep,
typename _Period>
484 auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
487 return try_lock_until(__clock_t::now() + __rt);
492 void lock_shared() { _Base::lock_shared(); }
494 bool try_lock_shared() {
return _Base::try_lock_shared(); }
495 void unlock_shared() { _Base::unlock_shared(); }
497 template<
typename _Rep,
typename _Period>
502 auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
505 return try_lock_shared_until(__clock_t::now() + __rt);
508#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
512 template<
typename _Duration>
518 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
519 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
521 __gthread_time_t __ts =
523 static_cast<std::time_t
>(__s.time_since_epoch().count()),
524 static_cast<long>(__ns.count())
527 int __ret = __glibcxx_rwlock_timedwrlock(&_M_rwlock, &__ts);
530 if (__ret == ETIMEDOUT || __ret == EDEADLK)
533 __glibcxx_assert(__ret == 0);
537#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
538 template<
typename _Duration>
544 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
545 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
547 __gthread_time_t __ts =
549 static_cast<std::time_t
>(__s.time_since_epoch().count()),
550 static_cast<long>(__ns.count())
553 int __ret = pthread_rwlock_clockwrlock(&_M_rwlock, CLOCK_MONOTONIC,
557 if (__ret == ETIMEDOUT || __ret == EDEADLK)
560 __glibcxx_assert(__ret == 0);
565 template<
typename _Clock,
typename _Duration>
570#if __cplusplus > 201703L
571 static_assert(chrono::is_clock_v<_Clock>);
576 typename _Clock::time_point __now = _Clock::now();
578 auto __rtime = __atime - __now;
579 if (try_lock_for(__rtime))
581 __now = _Clock::now();
582 }
while (__atime > __now);
588 template<
typename _Duration>
594 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
595 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
597 __gthread_time_t __ts =
599 static_cast<std::time_t
>(__s.time_since_epoch().count()),
600 static_cast<long>(__ns.count())
618 __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts);
619 while (__ret == EAGAIN || __ret == EDEADLK);
620 if (__ret == ETIMEDOUT)
623 __glibcxx_assert(__ret == 0);
627#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
628 template<
typename _Duration>
634 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
635 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
637 __gthread_time_t __ts =
639 static_cast<std::time_t
>(__s.time_since_epoch().count()),
640 static_cast<long>(__ns.count())
643 int __ret = pthread_rwlock_clockrdlock(&_M_rwlock, CLOCK_MONOTONIC,
647 if (__ret == ETIMEDOUT || __ret == EDEADLK)
650 __glibcxx_assert(__ret == 0);
655 template<
typename _Clock,
typename _Duration>
661#if __cplusplus > 201703L
662 static_assert(chrono::is_clock_v<_Clock>);
667 typename _Clock::time_point __now = _Clock::now();
669 auto __rtime = __atime - __now;
670 if (try_lock_shared_for(__rtime))
672 __now = _Clock::now();
673 }
while (__atime > __now);
681 template<
typename _Clock,
typename _Duration>
687 if (!_M_gate1.wait_until(__lk, __abs_time,
688 [=]{ return !_M_write_entered(); }))
692 _M_state |= _S_write_entered;
693 if (!_M_gate2.wait_until(__lk, __abs_time,
694 [=]{ return _M_readers() == 0; }))
696 _M_state ^= _S_write_entered;
698 _M_gate1.notify_all();
706 template <
typename _Clock,
typename _Duration>
710 _Duration>& __abs_time)
713 if (!_M_gate1.wait_until(__lk, __abs_time,
714 [=]{ return _M_state < _S_max_readers; }))
727 template<
typename _Mutex>
731 typedef _Mutex mutex_type;
735 shared_lock() noexcept : _M_pm(
nullptr), _M_owns(
false) { }
740 { __m.lock_shared(); }
751 template<
typename _Clock,
typename _Duration>
755 _M_owns(__m.try_lock_shared_until(__abs_time)) { }
757 template<
typename _Rep,
typename _Period>
761 _M_owns(__m.try_lock_shared_for(__rel_time)) { }
766 _M_pm->unlock_shared();
786 _M_pm->lock_shared();
795 return _M_owns = _M_pm->try_lock_shared();
798 template<
typename _Rep,
typename _Period>
804 return _M_owns = _M_pm->try_lock_shared_for(__rel_time);
807 template<
typename _Clock,
typename _Duration>
813 return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
820 __throw_system_error(
int(errc::resource_deadlock_would_occur));
821 _M_pm->unlock_shared();
838 return std::__exchange(_M_pm,
nullptr);
844 bool owns_lock()
const noexcept {
return _M_owns; }
846 explicit operator bool()
const noexcept {
return _M_owns; }
849 mutex_type*
mutex()
const noexcept {
return _M_pm; }
855 if (_M_pm ==
nullptr)
856 __throw_system_error(
int(errc::operation_not_permitted));
858 __throw_system_error(
int(errc::resource_deadlock_would_occur));
867 template<
typename _Mutex>
873_GLIBCXX_END_NAMESPACE_VERSION
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
void swap(shared_lock< _Mutex > &__x, shared_lock< _Mutex > &__y) noexcept
Swap specialization for shared_lock.
void lock(_L1 &__l1, _L2 &__l2, _L3 &... __l3)
Generic lock.
constexpr try_to_lock_t try_to_lock
Tag used to prevent a scoped lock from blocking if a mutex is locked.
int try_lock(_L1 &__l1, _L2 &__l2, _L3 &... __l3)
Generic try_lock.
ISO C++ entities toplevel namespace is std.
The standard shared mutex type.
The standard shared timed mutex type.
chrono::duration represents a distance between two points in time
chrono::time_point represents a point in time as measured by a clock
Do not acquire ownership of the mutex.
Try to acquire ownership of the mutex without blocking.
Assume the calling thread has already obtained mutex ownership and manage it.
A movable scoped lock type.