29 #ifndef _GLIBCXX_SHARED_MUTEX
30 #define _GLIBCXX_SHARED_MUTEX 1
32 #pragma GCC system_header
34 #if __cplusplus >= 201402L
40 namespace std _GLIBCXX_VISIBILITY(default)
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
49 #ifdef _GLIBCXX_HAS_GTHREADS
51 #if __cplusplus >= 201703L
52 #define __cpp_lib_shared_mutex 201505
56 #define __cpp_lib_shared_timed_mutex 201402
57 class shared_timed_mutex;
59 #if _GLIBCXX_USE_PTHREAD_RWLOCK_T
61 #define _GLIBCXX_GTHRW(name) \
62 __gthrw(pthread_ ## name); \
64 __glibcxx_ ## name (pthread_rwlock_t *__rwlock) \
66 if (__gthread_active_p ()) \
67 return __gthrw_(pthread_ ## name) (__rwlock); \
71 _GLIBCXX_GTHRW(rwlock_rdlock)
72 _GLIBCXX_GTHRW(rwlock_tryrdlock)
73 _GLIBCXX_GTHRW(rwlock_wrlock)
74 _GLIBCXX_GTHRW(rwlock_trywrlock)
75 _GLIBCXX_GTHRW(rwlock_unlock)
76 # ifndef PTHREAD_RWLOCK_INITIALIZER
77 _GLIBCXX_GTHRW(rwlock_destroy)
78 __gthrw(pthread_rwlock_init);
80 __glibcxx_rwlock_init (pthread_rwlock_t *__rwlock)
82 if (__gthread_active_p ())
83 return __gthrw_(pthread_rwlock_init) (__rwlock, NULL);
88 # if _GTHREAD_USE_MUTEX_TIMEDLOCK
89 __gthrw(pthread_rwlock_timedrdlock);
91 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
94 if (__gthread_active_p ())
95 return __gthrw_(pthread_rwlock_timedrdlock) (__rwlock, __ts);
99 __gthrw(pthread_rwlock_timedwrlock);
101 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
102 const timespec *__ts)
104 if (__gthread_active_p ())
105 return __gthrw_(pthread_rwlock_timedwrlock) (__rwlock, __ts);
112 __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock)
113 {
return pthread_rwlock_rdlock (__rwlock); }
115 __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
116 {
return pthread_rwlock_tryrdlock (__rwlock); }
118 __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock)
119 {
return pthread_rwlock_wrlock (__rwlock); }
121 __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
122 {
return pthread_rwlock_trywrlock (__rwlock); }
124 __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock)
125 {
return pthread_rwlock_unlock (__rwlock); }
127 __glibcxx_rwlock_destroy(pthread_rwlock_t *__rwlock)
128 {
return pthread_rwlock_destroy (__rwlock); }
130 __glibcxx_rwlock_init(pthread_rwlock_t *__rwlock)
131 {
return pthread_rwlock_init (__rwlock, NULL); }
132 # if _GTHREAD_USE_MUTEX_TIMEDLOCK
134 __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
135 const timespec *__ts)
136 {
return pthread_rwlock_timedrdlock (__rwlock, __ts); }
138 __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
139 const timespec *__ts)
140 {
return pthread_rwlock_timedwrlock (__rwlock, __ts); }
145 class __shared_mutex_pthread
147 friend class shared_timed_mutex;
149 #ifdef PTHREAD_RWLOCK_INITIALIZER
150 pthread_rwlock_t _M_rwlock = PTHREAD_RWLOCK_INITIALIZER;
153 __shared_mutex_pthread() =
default;
154 ~__shared_mutex_pthread() =
default;
156 pthread_rwlock_t _M_rwlock;
159 __shared_mutex_pthread()
161 int __ret = __glibcxx_rwlock_init(&_M_rwlock, NULL);
164 else if (__ret == EAGAIN)
165 __throw_system_error(
int(errc::resource_unavailable_try_again));
166 else if (__ret == EPERM)
167 __throw_system_error(
int(errc::operation_not_permitted));
169 __glibcxx_assert(__ret == 0);
172 ~__shared_mutex_pthread()
174 int __ret __attribute((__unused__)) = __glibcxx_rwlock_destroy(&_M_rwlock);
176 __glibcxx_assert(__ret == 0);
180 __shared_mutex_pthread(
const __shared_mutex_pthread&) =
delete;
181 __shared_mutex_pthread& operator=(
const __shared_mutex_pthread&) =
delete;
186 int __ret = __glibcxx_rwlock_wrlock(&_M_rwlock);
187 if (__ret == EDEADLK)
188 __throw_system_error(
int(errc::resource_deadlock_would_occur));
190 __glibcxx_assert(__ret == 0);
196 int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock);
197 if (__ret == EBUSY)
return false;
199 __glibcxx_assert(__ret == 0);
206 int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock);
208 __glibcxx_assert(__ret == 0);
222 __ret = __glibcxx_rwlock_rdlock(&_M_rwlock);
223 while (__ret == EAGAIN);
224 if (__ret == EDEADLK)
225 __throw_system_error(
int(errc::resource_deadlock_would_occur));
227 __glibcxx_assert(__ret == 0);
233 int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock);
237 if (__ret == EBUSY || __ret == EAGAIN)
return false;
239 __glibcxx_assert(__ret == 0);
249 void* native_handle() {
return &_M_rwlock; }
253 #if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
293 static constexpr
unsigned _S_write_entered
294 = 1U << (
sizeof(unsigned)*__CHAR_BIT__ - 1);
295 static constexpr
unsigned _S_max_readers = ~_S_write_entered;
298 bool _M_write_entered()
const {
return _M_state & _S_write_entered; }
301 unsigned _M_readers()
const {
return _M_state & _S_max_readers; }
308 __glibcxx_assert( _M_state == 0 );
321 _M_gate1.wait(__lk, [=]{
return !_M_write_entered(); });
322 _M_state |= _S_write_entered;
324 _M_gate2.wait(__lk, [=]{
return _M_readers() == 0; });
331 if (__lk.owns_lock() && _M_state == 0)
333 _M_state = _S_write_entered;
343 __glibcxx_assert( _M_write_entered() );
347 _M_gate1.notify_all();
356 _M_gate1.wait(__lk, [=]{
return _M_state < _S_max_readers; });
364 if (!__lk.owns_lock())
366 if (_M_state < _S_max_readers)
378 __glibcxx_assert( _M_readers() > 0 );
379 auto __prev = _M_state--;
380 if (_M_write_entered())
383 if (_M_readers() == 0)
384 _M_gate2.notify_one();
392 if (__prev == _S_max_readers)
393 _M_gate1.notify_one();
399 #if __cplusplus > 201402L
404 shared_mutex() =
default;
405 ~shared_mutex() =
default;
407 shared_mutex(
const shared_mutex&) =
delete;
408 shared_mutex& operator=(
const shared_mutex&) =
delete;
412 void lock() { _M_impl.lock(); }
413 bool try_lock() {
return _M_impl.try_lock(); }
414 void unlock() { _M_impl.unlock(); }
418 void lock_shared() { _M_impl.lock_shared(); }
419 bool try_lock_shared() {
return _M_impl.try_lock_shared(); }
420 void unlock_shared() { _M_impl.unlock_shared(); }
422 #if _GLIBCXX_USE_PTHREAD_RWLOCK_T
423 typedef void* native_handle_type;
424 native_handle_type native_handle() {
return _M_impl.native_handle(); }
427 __shared_mutex_pthread _M_impl;
430 __shared_mutex_cv _M_impl;
435 #if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
448 typedef chrono::system_clock __clock_t;
459 void lock() { _Base::lock(); }
460 bool try_lock() {
return _Base::try_lock(); }
461 void unlock() { _Base::unlock(); }
463 template<
typename _Rep,
typename _Period>
467 return try_lock_until(__clock_t::now() + __rel_time);
472 void lock_shared() { _Base::lock_shared(); }
473 bool try_lock_shared() {
return _Base::try_lock_shared(); }
474 void unlock_shared() { _Base::unlock_shared(); }
476 template<
typename _Rep,
typename _Period>
480 return try_lock_shared_until(__clock_t::now() + __rel_time);
483 #if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
487 template<
typename _Duration>
494 __gthread_time_t __ts =
496 static_cast<std::time_t
>(__s.time_since_epoch().count()),
497 static_cast<long>(__ns.count())
500 int __ret = __glibcxx_rwlock_timedwrlock(&_M_rwlock, &__ts);
503 if (__ret == ETIMEDOUT || __ret == EDEADLK)
506 __glibcxx_assert(__ret == 0);
510 template<
typename _Clock,
typename _Duration>
515 const typename _Clock::time_point __c_entry = _Clock::now();
516 const __clock_t::time_point __s_entry = __clock_t::now();
517 const auto __delta = __abs_time - __c_entry;
518 const auto __s_atime = __s_entry + __delta;
519 return try_lock_until(__s_atime);
524 template<
typename _Duration>
532 __gthread_time_t __ts =
534 static_cast<std::time_t
>(__s.time_since_epoch().count()),
535 static_cast<long>(__ns.count())
553 __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts);
554 while (__ret == EAGAIN || __ret == EDEADLK);
555 if (__ret == ETIMEDOUT)
558 __glibcxx_assert(__ret == 0);
562 template<
typename _Clock,
typename _Duration>
565 _Duration>& __abs_time)
568 const typename _Clock::time_point __c_entry = _Clock::now();
569 const __clock_t::time_point __s_entry = __clock_t::now();
570 const auto __delta = __abs_time - __c_entry;
571 const auto __s_atime = __s_entry + __delta;
572 return try_lock_shared_until(__s_atime);
575 #else // ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
579 template<
typename _Clock,
typename _Duration>
584 if (!_M_gate1.wait_until(__lk, __abs_time,
585 [=]{
return !_M_write_entered(); }))
589 _M_state |= _S_write_entered;
590 if (!_M_gate2.wait_until(__lk, __abs_time,
591 [=]{
return _M_readers() == 0; }))
593 _M_state ^= _S_write_entered;
595 _M_gate1.notify_all();
603 template <
typename _Clock,
typename _Duration>
606 _Duration>& __abs_time)
609 if (!_M_gate1.wait_until(__lk, __abs_time,
610 [=]{
return _M_state < _S_max_readers; }))
618 #endif // _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
620 #endif // _GLIBCXX_HAS_GTHREADS
623 template<
typename _Mutex>
627 typedef _Mutex mutex_type;
636 { __m.lock_shared(); }
647 template<
typename _Clock,
typename _Duration>
651 _M_owns(__m.try_lock_shared_until(__abs_time)) { }
653 template<
typename _Rep,
typename _Period>
657 _M_owns(__m.try_lock_shared_for(__rel_time)) { }
662 _M_pm->unlock_shared();
682 _M_pm->lock_shared();
690 return _M_owns = _M_pm->try_lock_shared();
693 template<
typename _Rep,
typename _Period>
698 return _M_owns = _M_pm->try_lock_shared_for(__rel_time);
701 template<
typename _Clock,
typename _Duration>
706 return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
713 __throw_system_error(
int(errc::resource_deadlock_would_occur));
714 _M_pm->unlock_shared();
723 std::swap(_M_pm, __u._M_pm);
724 std::swap(_M_owns, __u._M_owns);
736 bool owns_lock()
const noexcept {
return _M_owns; }
738 explicit operator bool()
const noexcept {
return _M_owns; }
746 if (_M_pm ==
nullptr)
747 __throw_system_error(
int(errc::operation_not_permitted));
749 __throw_system_error(
int(errc::resource_deadlock_would_occur));
757 template<
typename _Mutex>
763 _GLIBCXX_END_NAMESPACE_VERSION
768 #endif // _GLIBCXX_SHARED_MUTEX
__shared_mutex_cv __shared_timed_mutex_base
Swap specialization for shared_lock.
_Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
constexpr enable_if< __is_duration< _ToDur >::value, time_point< _Clock, _ToDur > >::type time_point_cast(const time_point< _Clock, _Dur > &__t)
time_point_cast
int try_lock(_Lock1 &__l1, _Lock2 &__l2, _Lock3 &...__l3)
Generic try_lock.
Try to acquire ownership of the mutex without blocking.
void lock(_L1 &__l1, _L2 &__l2, _L3 &...__l3)
Generic lock.
Assume the calling thread has already obtained mutex ownership and manage it.
The standard shared timed mutex type.
A shared mutex type implemented using std::condition_variable.
A simple scoped lock type.
enable_if< ::__array_traits< _Tp, _Nm >::_Is_swappable::value >::type noexcept(noexcept(__one.swap(__two)))
swap
A movable scoped lock type.
constexpr __enable_if_is_duration< _ToDur > duration_cast(const duration< _Rep, _Period > &__d)
duration_cast
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
_GLIBCXX17_INLINE constexpr try_to_lock_t try_to_lock
Tag used to prevent a scoped lock from blocking if a mutex is locked.
Do not acquire ownership of the mutex.