29#ifndef _GLIBCXX_SHARED_MUTEX
30#define _GLIBCXX_SHARED_MUTEX 1
33#pragma GCC system_header
38#if __cplusplus >= 201402L
46#define __glibcxx_want_shared_mutex
47#define __glibcxx_want_shared_timed_mutex
50#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
54namespace std _GLIBCXX_VISIBILITY(default)
56_GLIBCXX_BEGIN_NAMESPACE_VERSION
63#ifdef _GLIBCXX_HAS_GTHREADS
65#ifdef __cpp_lib_shared_mutex
69 class shared_timed_mutex;
73#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
75#define _GLIBCXX_GTHRW(name) \
76 __gthrw(pthread_ ## name); \
78 __glibcxx_ ## name (pthread_rwlock_t *__rwlock) \
80 if (__gthread_active_p ()) \
81 return __gthrw_(pthread_ ## name) (__rwlock); \
85 _GLIBCXX_GTHRW(rwlock_rdlock)
86 _GLIBCXX_GTHRW(rwlock_tryrdlock)
87 _GLIBCXX_GTHRW(rwlock_wrlock)
88 _GLIBCXX_GTHRW(rwlock_trywrlock)
89 _GLIBCXX_GTHRW(rwlock_unlock)
90# ifndef PTHREAD_RWLOCK_INITIALIZER
91 _GLIBCXX_GTHRW(rwlock_destroy)
92 __gthrw(pthread_rwlock_init);
94 __glibcxx_rwlock_init (pthread_rwlock_t *__rwlock)
96 if (__gthread_active_p ())
97 return __gthrw_(pthread_rwlock_init) (__rwlock, NULL);
102# if _GTHREAD_USE_MUTEX_TIMEDLOCK
103 __gthrw(pthread_rwlock_timedrdlock);
105 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
106 const timespec *__ts)
108 if (__gthread_active_p ())
109 return __gthrw_(pthread_rwlock_timedrdlock) (__rwlock, __ts);
113 __gthrw(pthread_rwlock_timedwrlock);
115 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
116 const timespec *__ts)
118 if (__gthread_active_p ())
119 return __gthrw_(pthread_rwlock_timedwrlock) (__rwlock, __ts);
126 __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock)
127 {
return pthread_rwlock_rdlock (__rwlock); }
129 __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
130 {
return pthread_rwlock_tryrdlock (__rwlock); }
132 __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock)
133 {
return pthread_rwlock_wrlock (__rwlock); }
135 __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
136 {
return pthread_rwlock_trywrlock (__rwlock); }
138 __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock)
139 {
return pthread_rwlock_unlock (__rwlock); }
141 __glibcxx_rwlock_destroy(pthread_rwlock_t *__rwlock)
142 {
return pthread_rwlock_destroy (__rwlock); }
144 __glibcxx_rwlock_init(pthread_rwlock_t *__rwlock)
145 {
return pthread_rwlock_init (__rwlock, NULL); }
146# if _GTHREAD_USE_MUTEX_TIMEDLOCK
148 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
149 const timespec *__ts)
150 {
return pthread_rwlock_timedrdlock (__rwlock, __ts); }
152 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
153 const timespec *__ts)
154 {
return pthread_rwlock_timedwrlock (__rwlock, __ts); }
159 class __shared_mutex_pthread
161 friend class shared_timed_mutex;
163#ifdef PTHREAD_RWLOCK_INITIALIZER
164 pthread_rwlock_t _M_rwlock = PTHREAD_RWLOCK_INITIALIZER;
167 __shared_mutex_pthread() =
default;
168 ~__shared_mutex_pthread() =
default;
170 pthread_rwlock_t _M_rwlock;
173 __shared_mutex_pthread()
175 int __ret = __glibcxx_rwlock_init(&_M_rwlock);
178 else if (__ret == EAGAIN)
179 __throw_system_error(
int(errc::resource_unavailable_try_again));
180 else if (__ret == EPERM)
181 __throw_system_error(
int(errc::operation_not_permitted));
183 __glibcxx_assert(__ret == 0);
186 ~__shared_mutex_pthread()
188 int __ret __attribute((__unused__)) = __glibcxx_rwlock_destroy(&_M_rwlock);
190 __glibcxx_assert(__ret == 0);
194 __shared_mutex_pthread(
const __shared_mutex_pthread&) =
delete;
195 __shared_mutex_pthread& operator=(
const __shared_mutex_pthread&) =
delete;
200 int __ret = __glibcxx_rwlock_wrlock(&_M_rwlock);
201 if (__ret == EDEADLK)
202 __throw_system_error(
int(errc::resource_deadlock_would_occur));
204 __glibcxx_assert(__ret == 0);
210 int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock);
211 if (__ret == EBUSY)
return false;
213 __glibcxx_assert(__ret == 0);
220 int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock);
222 __glibcxx_assert(__ret == 0);
236 __ret = __glibcxx_rwlock_rdlock(&_M_rwlock);
237 while (__ret == EAGAIN);
238 if (__ret == EDEADLK)
239 __throw_system_error(
int(errc::resource_deadlock_would_occur));
241 __glibcxx_assert(__ret == 0);
247 int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock);
251 if (__ret == EBUSY || __ret == EAGAIN)
return false;
253 __glibcxx_assert(__ret == 0);
263 void* native_handle() {
return &_M_rwlock; }
267#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
269 class __shared_mutex_cv
271 friend class shared_timed_mutex;
301 condition_variable _M_gate1;
303 condition_variable _M_gate2;
307 static constexpr unsigned _S_write_entered
308 = 1U << (
sizeof(unsigned)*__CHAR_BIT__ - 1);
309 static constexpr unsigned _S_max_readers = ~_S_write_entered;
312 bool _M_write_entered()
const {
return _M_state & _S_write_entered; }
315 unsigned _M_readers()
const {
return _M_state & _S_max_readers; }
318 __shared_mutex_cv() : _M_state(0) {}
322 __glibcxx_assert( _M_state == 0 );
325 __shared_mutex_cv(
const __shared_mutex_cv&) =
delete;
326 __shared_mutex_cv& operator=(
const __shared_mutex_cv&) =
delete;
333 unique_lock<mutex> __lk(_M_mut);
335 _M_gate1.wait(__lk, [
this]{
return !_M_write_entered(); });
336 _M_state |= _S_write_entered;
338 _M_gate2.wait(__lk, [
this]{
return _M_readers() == 0; });
344 unique_lock<mutex> __lk(_M_mut, try_to_lock);
345 if (__lk.owns_lock() && _M_state == 0)
347 _M_state = _S_write_entered;
356 lock_guard<mutex> __lk(_M_mut);
357 __glibcxx_assert( _M_write_entered() );
361 _M_gate1.notify_all();
369 unique_lock<mutex> __lk(_M_mut);
370 _M_gate1.wait(__lk, [
this]{
return _M_state < _S_max_readers; });
377 unique_lock<mutex> __lk(_M_mut, try_to_lock);
378 if (!__lk.owns_lock())
380 if (_M_state < _S_max_readers)
391 lock_guard<mutex> __lk(_M_mut);
392 __glibcxx_assert( _M_readers() > 0 );
393 auto __prev = _M_state--;
394 if (_M_write_entered())
397 if (_M_readers() == 0)
398 _M_gate2.notify_one();
406 if (__prev == _S_max_readers)
407 _M_gate1.notify_one();
414#ifdef __cpp_lib_shared_mutex
419 shared_mutex() =
default;
420 ~shared_mutex() =
default;
422 shared_mutex(
const shared_mutex&) =
delete;
423 shared_mutex& operator=(
const shared_mutex&) =
delete;
427 void lock() { _M_impl.lock(); }
428 [[nodiscard]]
bool try_lock() {
return _M_impl.try_lock(); }
429 void unlock() { _M_impl.unlock(); }
433 void lock_shared() { _M_impl.lock_shared(); }
434 [[nodiscard]]
bool try_lock_shared() {
return _M_impl.try_lock_shared(); }
435 void unlock_shared() { _M_impl.unlock_shared(); }
437#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
438 typedef void* native_handle_type;
439 native_handle_type native_handle() {
return _M_impl.native_handle(); }
442 __shared_mutex_pthread _M_impl;
445 __shared_mutex_cv _M_impl;
451#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
452 using __shared_timed_mutex_base = __shared_mutex_pthread;
454 using __shared_timed_mutex_base = __shared_mutex_cv;
460 :
private __shared_timed_mutex_base
462 using _Base = __shared_timed_mutex_base;
465#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
480 void lock() { _Base::lock(); }
481 _GLIBCXX_NODISCARD
bool try_lock() {
return _Base::try_lock(); }
482 void unlock() { _Base::unlock(); }
484 template<
typename _Rep,
typename _Period>
489 auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
492 return try_lock_until(__clock_t::now() + __rt);
497 void lock_shared() { _Base::lock_shared(); }
499 bool try_lock_shared() {
return _Base::try_lock_shared(); }
500 void unlock_shared() { _Base::unlock_shared(); }
502 template<
typename _Rep,
typename _Period>
507 auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
510 return try_lock_shared_until(__clock_t::now() + __rt);
513#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
517 template<
typename _Duration>
523 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
524 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
526 __gthread_time_t __ts =
528 static_cast<std::time_t
>(__s.time_since_epoch().count()),
529 static_cast<long>(__ns.count())
532 int __ret = __glibcxx_rwlock_timedwrlock(&_M_rwlock, &__ts);
535 if (__ret == ETIMEDOUT || __ret == EDEADLK)
538 __glibcxx_assert(__ret == 0);
542#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
543 template<
typename _Duration>
549 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
550 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
552 __gthread_time_t __ts =
554 static_cast<std::time_t
>(__s.time_since_epoch().count()),
555 static_cast<long>(__ns.count())
558 int __ret = pthread_rwlock_clockwrlock(&_M_rwlock, CLOCK_MONOTONIC,
562 if (__ret == ETIMEDOUT || __ret == EDEADLK)
565 __glibcxx_assert(__ret == 0);
570 template<
typename _Clock,
typename _Duration>
575#if __cplusplus > 201703L
576 static_assert(chrono::is_clock_v<_Clock>);
581 typename _Clock::time_point __now = _Clock::now();
583 auto __rtime = __atime - __now;
584 if (try_lock_for(__rtime))
586 __now = _Clock::now();
587 }
while (__atime > __now);
593 template<
typename _Duration>
599 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
600 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
602 __gthread_time_t __ts =
604 static_cast<std::time_t
>(__s.time_since_epoch().count()),
605 static_cast<long>(__ns.count())
623 __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts);
624 while (__ret == EAGAIN || __ret == EDEADLK);
625 if (__ret == ETIMEDOUT)
628 __glibcxx_assert(__ret == 0);
632#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
633 template<
typename _Duration>
639 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
640 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
642 __gthread_time_t __ts =
644 static_cast<std::time_t
>(__s.time_since_epoch().count()),
645 static_cast<long>(__ns.count())
648 int __ret = pthread_rwlock_clockrdlock(&_M_rwlock, CLOCK_MONOTONIC,
652 if (__ret == ETIMEDOUT || __ret == EDEADLK)
655 __glibcxx_assert(__ret == 0);
660 template<
typename _Clock,
typename _Duration>
666#if __cplusplus > 201703L
667 static_assert(chrono::is_clock_v<_Clock>);
672 typename _Clock::time_point __now = _Clock::now();
674 auto __rtime = __atime - __now;
675 if (try_lock_shared_for(__rtime))
677 __now = _Clock::now();
678 }
while (__atime > __now);
686 template<
typename _Clock,
typename _Duration>
692 if (!_M_gate1.wait_until(__lk, __abs_time,
693 [
this]{ return !_M_write_entered(); }))
697 _M_state |= _S_write_entered;
698 if (!_M_gate2.wait_until(__lk, __abs_time,
699 [
this]{ return _M_readers() == 0; }))
701 _M_state ^= _S_write_entered;
703 _M_gate1.notify_all();
711 template <
typename _Clock,
typename _Duration>
715 _Duration>& __abs_time)
718 if (!_M_gate1.wait_until(__lk, __abs_time,
719 [
this]{ return _M_state < _S_max_readers; }))
732 template<
typename _Mutex>
736 typedef _Mutex mutex_type;
740 shared_lock() noexcept : _M_pm(
nullptr), _M_owns(
false) { }
745 { __m.lock_shared(); }
756 template<
typename _Clock,
typename _Duration>
760 _M_owns(__m.try_lock_shared_until(__abs_time)) { }
762 template<
typename _Rep,
typename _Period>
766 _M_owns(__m.try_lock_shared_for(__rel_time)) { }
771 _M_pm->unlock_shared();
791 _M_pm->lock_shared();
800 return _M_owns = _M_pm->try_lock_shared();
803 template<
typename _Rep,
typename _Period>
809 return _M_owns = _M_pm->try_lock_shared_for(__rel_time);
812 template<
typename _Clock,
typename _Duration>
818 return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
825 __throw_system_error(
int(errc::operation_not_permitted));
826 _M_pm->unlock_shared();
835 std::swap(_M_pm, __u._M_pm);
836 std::swap(_M_owns, __u._M_owns);
843 return std::__exchange(_M_pm,
nullptr);
849 bool owns_lock()
const noexcept {
return _M_owns; }
851 explicit operator bool()
const noexcept {
return _M_owns; }
854 mutex_type*
mutex()
const noexcept {
return _M_pm; }
860 if (_M_pm ==
nullptr)
861 __throw_system_error(
int(errc::operation_not_permitted));
863 __throw_system_error(
int(errc::resource_deadlock_would_occur));
872 template<
typename _Mutex>
878_GLIBCXX_END_NAMESPACE_VERSION
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
void lock(_L1 &__l1, _L2 &__l2, _L3 &... __l3)
Generic lock.
int try_lock(_L1 &__l1, _L2 &__l2, _L3 &... __l3)
Generic try_lock.
ISO C++ entities toplevel namespace is std.
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.