29#ifndef _GLIBCXX_SHARED_MUTEX
30#define _GLIBCXX_SHARED_MUTEX 1
32#pragma GCC system_header
36#if __cplusplus >= 201402L
44#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
48namespace std _GLIBCXX_VISIBILITY(default)
50_GLIBCXX_BEGIN_NAMESPACE_VERSION
57#ifdef _GLIBCXX_HAS_GTHREADS
59#if __cplusplus >= 201703L
60#define __cpp_lib_shared_mutex 201505L
64#define __cpp_lib_shared_timed_mutex 201402L
65 class shared_timed_mutex;
69#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
71#define _GLIBCXX_GTHRW(name) \
72 __gthrw(pthread_ ## name); \
74 __glibcxx_ ## name (pthread_rwlock_t *__rwlock) \
76 if (__gthread_active_p ()) \
77 return __gthrw_(pthread_ ## name) (__rwlock); \
81 _GLIBCXX_GTHRW(rwlock_rdlock)
82 _GLIBCXX_GTHRW(rwlock_tryrdlock)
83 _GLIBCXX_GTHRW(rwlock_wrlock)
84 _GLIBCXX_GTHRW(rwlock_trywrlock)
85 _GLIBCXX_GTHRW(rwlock_unlock)
86# ifndef PTHREAD_RWLOCK_INITIALIZER
87 _GLIBCXX_GTHRW(rwlock_destroy)
88 __gthrw(pthread_rwlock_init);
90 __glibcxx_rwlock_init (pthread_rwlock_t *__rwlock)
92 if (__gthread_active_p ())
93 return __gthrw_(pthread_rwlock_init) (__rwlock, NULL);
98# if _GTHREAD_USE_MUTEX_TIMEDLOCK
99 __gthrw(pthread_rwlock_timedrdlock);
101 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
102 const timespec *__ts)
104 if (__gthread_active_p ())
105 return __gthrw_(pthread_rwlock_timedrdlock) (__rwlock, __ts);
109 __gthrw(pthread_rwlock_timedwrlock);
111 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
112 const timespec *__ts)
114 if (__gthread_active_p ())
115 return __gthrw_(pthread_rwlock_timedwrlock) (__rwlock, __ts);
122 __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock)
123 {
return pthread_rwlock_rdlock (__rwlock); }
125 __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
126 {
return pthread_rwlock_tryrdlock (__rwlock); }
128 __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock)
129 {
return pthread_rwlock_wrlock (__rwlock); }
131 __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
132 {
return pthread_rwlock_trywrlock (__rwlock); }
134 __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock)
135 {
return pthread_rwlock_unlock (__rwlock); }
137 __glibcxx_rwlock_destroy(pthread_rwlock_t *__rwlock)
138 {
return pthread_rwlock_destroy (__rwlock); }
140 __glibcxx_rwlock_init(pthread_rwlock_t *__rwlock)
141 {
return pthread_rwlock_init (__rwlock, NULL); }
142# if _GTHREAD_USE_MUTEX_TIMEDLOCK
144 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
145 const timespec *__ts)
146 {
return pthread_rwlock_timedrdlock (__rwlock, __ts); }
148 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
149 const timespec *__ts)
150 {
return pthread_rwlock_timedwrlock (__rwlock, __ts); }
155 class __shared_mutex_pthread
157 friend class shared_timed_mutex;
159#ifdef PTHREAD_RWLOCK_INITIALIZER
160 pthread_rwlock_t _M_rwlock = PTHREAD_RWLOCK_INITIALIZER;
163 __shared_mutex_pthread() =
default;
164 ~__shared_mutex_pthread() =
default;
166 pthread_rwlock_t _M_rwlock;
169 __shared_mutex_pthread()
171 int __ret = __glibcxx_rwlock_init(&_M_rwlock);
174 else if (__ret == EAGAIN)
175 __throw_system_error(
int(errc::resource_unavailable_try_again));
176 else if (__ret == EPERM)
177 __throw_system_error(
int(errc::operation_not_permitted));
179 __glibcxx_assert(__ret == 0);
182 ~__shared_mutex_pthread()
184 int __ret __attribute((__unused__)) = __glibcxx_rwlock_destroy(&_M_rwlock);
186 __glibcxx_assert(__ret == 0);
190 __shared_mutex_pthread(
const __shared_mutex_pthread&) =
delete;
191 __shared_mutex_pthread& operator=(
const __shared_mutex_pthread&) =
delete;
196 int __ret = __glibcxx_rwlock_wrlock(&_M_rwlock);
197 if (__ret == EDEADLK)
198 __throw_system_error(
int(errc::resource_deadlock_would_occur));
200 __glibcxx_assert(__ret == 0);
206 int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock);
207 if (__ret == EBUSY)
return false;
209 __glibcxx_assert(__ret == 0);
216 int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock);
218 __glibcxx_assert(__ret == 0);
232 __ret = __glibcxx_rwlock_rdlock(&_M_rwlock);
233 while (__ret == EAGAIN);
234 if (__ret == EDEADLK)
235 __throw_system_error(
int(errc::resource_deadlock_would_occur));
237 __glibcxx_assert(__ret == 0);
243 int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock);
247 if (__ret == EBUSY || __ret == EAGAIN)
return false;
249 __glibcxx_assert(__ret == 0);
259 void* native_handle() {
return &_M_rwlock; }
263#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
265 class __shared_mutex_cv
267 friend class shared_timed_mutex;
297 condition_variable _M_gate1;
299 condition_variable _M_gate2;
303 static constexpr unsigned _S_write_entered
304 = 1U << (
sizeof(unsigned)*__CHAR_BIT__ - 1);
305 static constexpr unsigned _S_max_readers = ~_S_write_entered;
308 bool _M_write_entered()
const {
return _M_state & _S_write_entered; }
311 unsigned _M_readers()
const {
return _M_state & _S_max_readers; }
314 __shared_mutex_cv() : _M_state(0) {}
318 __glibcxx_assert( _M_state == 0 );
321 __shared_mutex_cv(
const __shared_mutex_cv&) =
delete;
322 __shared_mutex_cv& operator=(
const __shared_mutex_cv&) =
delete;
329 unique_lock<mutex> __lk(_M_mut);
331 _M_gate1.wait(__lk, [=]{
return !_M_write_entered(); });
332 _M_state |= _S_write_entered;
334 _M_gate2.wait(__lk, [=]{
return _M_readers() == 0; });
341 if (__lk.owns_lock() && _M_state == 0)
343 _M_state = _S_write_entered;
352 lock_guard<mutex> __lk(_M_mut);
353 __glibcxx_assert( _M_write_entered() );
357 _M_gate1.notify_all();
365 unique_lock<mutex> __lk(_M_mut);
366 _M_gate1.wait(__lk, [=]{
return _M_state < _S_max_readers; });
374 if (!__lk.owns_lock())
376 if (_M_state < _S_max_readers)
387 lock_guard<mutex> __lk(_M_mut);
388 __glibcxx_assert( _M_readers() > 0 );
389 auto __prev = _M_state--;
390 if (_M_write_entered())
393 if (_M_readers() == 0)
394 _M_gate2.notify_one();
402 if (__prev == _S_max_readers)
403 _M_gate1.notify_one();
410#if __cplusplus >= 201703L
423 void lock() { _M_impl.lock(); }
424 [[nodiscard]]
bool try_lock() {
return _M_impl.try_lock(); }
425 void unlock() { _M_impl.unlock(); }
429 void lock_shared() { _M_impl.lock_shared(); }
430 [[nodiscard]]
bool try_lock_shared() {
return _M_impl.try_lock_shared(); }
431 void unlock_shared() { _M_impl.unlock_shared(); }
433#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
434 typedef void* native_handle_type;
435 native_handle_type native_handle() {
return _M_impl.native_handle(); }
438 __shared_mutex_pthread _M_impl;
441 __shared_mutex_cv _M_impl;
447#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
448 using __shared_timed_mutex_base = __shared_mutex_pthread;
450 using __shared_timed_mutex_base = __shared_mutex_cv;
456 :
private __shared_timed_mutex_base
458 using _Base = __shared_timed_mutex_base;
461#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
478 void unlock() { _Base::unlock(); }
480 template<
typename _Rep,
typename _Period>
485 auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
488 return try_lock_until(__clock_t::now() + __rt);
493 void lock_shared() { _Base::lock_shared(); }
495 bool try_lock_shared() {
return _Base::try_lock_shared(); }
496 void unlock_shared() { _Base::unlock_shared(); }
498 template<
typename _Rep,
typename _Period>
503 auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
506 return try_lock_shared_until(__clock_t::now() + __rt);
509#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
513 template<
typename _Duration>
519 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
520 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
522 __gthread_time_t __ts =
524 static_cast<std::time_t
>(__s.time_since_epoch().count()),
525 static_cast<long>(__ns.count())
528 int __ret = __glibcxx_rwlock_timedwrlock(&_M_rwlock, &__ts);
531 if (__ret == ETIMEDOUT || __ret == EDEADLK)
534 __glibcxx_assert(__ret == 0);
538#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
539 template<
typename _Duration>
545 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
546 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
548 __gthread_time_t __ts =
550 static_cast<std::time_t
>(__s.time_since_epoch().count()),
551 static_cast<long>(__ns.count())
554 int __ret = pthread_rwlock_clockwrlock(&_M_rwlock, CLOCK_MONOTONIC,
558 if (__ret == ETIMEDOUT || __ret == EDEADLK)
561 __glibcxx_assert(__ret == 0);
566 template<
typename _Clock,
typename _Duration>
571#if __cplusplus > 201703L
572 static_assert(chrono::is_clock_v<_Clock>);
577 typename _Clock::time_point __now = _Clock::now();
579 auto __rtime = __atime - __now;
580 if (try_lock_for(__rtime))
582 __now = _Clock::now();
583 }
while (__atime > __now);
589 template<
typename _Duration>
595 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
596 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
598 __gthread_time_t __ts =
600 static_cast<std::time_t
>(__s.time_since_epoch().count()),
601 static_cast<long>(__ns.count())
619 __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts);
620 while (__ret == EAGAIN || __ret == EDEADLK);
621 if (__ret == ETIMEDOUT)
624 __glibcxx_assert(__ret == 0);
628#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
629 template<
typename _Duration>
635 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
636 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
638 __gthread_time_t __ts =
640 static_cast<std::time_t
>(__s.time_since_epoch().count()),
641 static_cast<long>(__ns.count())
644 int __ret = pthread_rwlock_clockrdlock(&_M_rwlock, CLOCK_MONOTONIC,
648 if (__ret == ETIMEDOUT || __ret == EDEADLK)
651 __glibcxx_assert(__ret == 0);
656 template<
typename _Clock,
typename _Duration>
662#if __cplusplus > 201703L
663 static_assert(chrono::is_clock_v<_Clock>);
668 typename _Clock::time_point __now = _Clock::now();
670 auto __rtime = __atime - __now;
671 if (try_lock_shared_for(__rtime))
673 __now = _Clock::now();
674 }
while (__atime > __now);
682 template<
typename _Clock,
typename _Duration>
688 if (!_M_gate1.wait_until(__lk, __abs_time,
689 [=]{ return !_M_write_entered(); }))
693 _M_state |= _S_write_entered;
694 if (!_M_gate2.wait_until(__lk, __abs_time,
695 [=]{ return _M_readers() == 0; }))
697 _M_state ^= _S_write_entered;
699 _M_gate1.notify_all();
707 template <
typename _Clock,
typename _Duration>
711 _Duration>& __abs_time)
714 if (!_M_gate1.wait_until(__lk, __abs_time,
715 [=]{ return _M_state < _S_max_readers; }))
728 template<
typename _Mutex>
732 typedef _Mutex mutex_type;
736 shared_lock() noexcept : _M_pm(
nullptr), _M_owns(
false) { }
741 { __m.lock_shared(); }
752 template<
typename _Clock,
typename _Duration>
756 _M_owns(__m.try_lock_shared_until(__abs_time)) { }
758 template<
typename _Rep,
typename _Period>
762 _M_owns(__m.try_lock_shared_for(__rel_time)) { }
767 _M_pm->unlock_shared();
787 _M_pm->lock_shared();
796 return _M_owns = _M_pm->try_lock_shared();
799 template<
typename _Rep,
typename _Period>
805 return _M_owns = _M_pm->try_lock_shared_for(__rel_time);
808 template<
typename _Clock,
typename _Duration>
814 return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
821 __throw_system_error(
int(errc::resource_deadlock_would_occur));
822 _M_pm->unlock_shared();
839 return std::__exchange(_M_pm,
nullptr);
845 bool owns_lock()
const noexcept {
return _M_owns; }
847 explicit operator bool()
const noexcept {
return _M_owns; }
850 mutex_type*
mutex()
const noexcept {
return _M_pm; }
856 if (_M_pm ==
nullptr)
857 __throw_system_error(
int(errc::operation_not_permitted));
859 __throw_system_error(
int(errc::resource_deadlock_would_occur));
868 template<
typename _Mutex>
874_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.