29 #ifndef _GLIBCXX_SHARED_MUTEX
30 #define _GLIBCXX_SHARED_MUTEX 1
32 #pragma GCC system_header
34 #if __cplusplus <= 201103L
43 namespace std _GLIBCXX_VISIBILITY(default)
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
52 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
53 #ifdef _GLIBCXX_HAS_GTHREADS
55 #define __cpp_lib_shared_timed_mutex 201402
58 class shared_timed_mutex
60 #if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
61 typedef chrono::system_clock __clock_t;
63 #ifdef PTHREAD_RWLOCK_INITIALIZER
64 pthread_rwlock_t _M_rwlock = PTHREAD_RWLOCK_INITIALIZER;
67 shared_timed_mutex() =
default;
68 ~shared_timed_mutex() =
default;
70 pthread_rwlock_t _M_rwlock;
75 int __ret = pthread_rwlock_init(&_M_rwlock, NULL);
78 else if (__ret == EAGAIN)
79 __throw_system_error(
int(errc::resource_unavailable_try_again));
80 else if (__ret == EPERM)
81 __throw_system_error(
int(errc::operation_not_permitted));
83 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
88 int __ret __attribute((__unused__)) = pthread_rwlock_destroy(&_M_rwlock);
90 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
94 shared_timed_mutex(
const shared_timed_mutex&) =
delete;
95 shared_timed_mutex& operator=(
const shared_timed_mutex&) =
delete;
102 int __ret = pthread_rwlock_wrlock(&_M_rwlock);
103 if (__ret == EDEADLK)
104 __throw_system_error(
int(errc::resource_deadlock_would_occur));
106 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
112 int __ret = pthread_rwlock_trywrlock(&_M_rwlock);
113 if (__ret == EBUSY)
return false;
115 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
119 template<
typename _Rep,
typename _Period>
121 try_lock_for(
const chrono::duration<_Rep, _Period>& __rel_time)
123 return try_lock_until(__clock_t::now() + __rel_time);
126 template<
typename _Duration>
128 try_lock_until(
const chrono::time_point<__clock_t, _Duration>& __atime)
133 __gthread_time_t __ts =
135 static_cast<std::time_t
>(__s.time_since_epoch().count()),
136 static_cast<long>(__ns.count())
139 int __ret = pthread_rwlock_timedwrlock(&_M_rwlock, &__ts);
142 if (__ret == ETIMEDOUT || __ret == EDEADLK)
145 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
149 template<
typename _Clock,
typename _Duration>
151 try_lock_until(
const chrono::time_point<_Clock, _Duration>& __abs_time)
154 const typename _Clock::time_point __c_entry = _Clock::now();
155 const __clock_t::time_point __s_entry = __clock_t::now();
156 const auto __delta = __abs_time - __c_entry;
157 const auto __s_atime = __s_entry + __delta;
158 return try_lock_until(__s_atime);
164 int __ret __attribute((__unused__)) = pthread_rwlock_unlock(&_M_rwlock);
166 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
180 __ret = pthread_rwlock_rdlock(&_M_rwlock);
181 while (__ret == EAGAIN);
182 if (__ret == EDEADLK)
183 __throw_system_error(
int(errc::resource_deadlock_would_occur));
185 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
191 int __ret = pthread_rwlock_tryrdlock(&_M_rwlock);
195 if (__ret == EBUSY || __ret == EAGAIN)
return false;
197 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
201 template<
typename _Rep,
typename _Period>
203 try_lock_shared_for(
const chrono::duration<_Rep, _Period>& __rel_time)
205 return try_lock_shared_until(__clock_t::now() + __rel_time);
208 template<
typename _Duration>
210 try_lock_shared_until(
const chrono::time_point<__clock_t,
216 __gthread_time_t __ts =
218 static_cast<std::time_t
>(__s.time_since_epoch().count()),
219 static_cast<long>(__ns.count())
237 __ret = pthread_rwlock_timedrdlock(&_M_rwlock, &__ts);
238 while (__ret == EAGAIN || __ret == EDEADLK);
239 if (__ret == ETIMEDOUT)
242 _GLIBCXX_DEBUG_ASSERT(__ret == 0);
246 template<
typename _Clock,
typename _Duration>
248 try_lock_shared_until(
const chrono::time_point<_Clock,
249 _Duration>& __abs_time)
252 const typename _Clock::time_point __c_entry = _Clock::now();
253 const __clock_t::time_point __s_entry = __clock_t::now();
254 const auto __delta = __abs_time - __c_entry;
255 const auto __s_atime = __s_entry + __delta;
256 return try_lock_shared_until(__s_atime);
265 #else // ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
268 typedef chrono::system_clock __clock_t;
298 condition_variable _M_gate1;
300 condition_variable _M_gate2;
304 static constexpr
unsigned _S_write_entered
305 = 1U << (
sizeof(unsigned)*__CHAR_BIT__ - 1);
306 static constexpr
unsigned _S_max_readers = ~_S_write_entered;
309 bool _M_write_entered()
const {
return _M_state & _S_write_entered; }
312 unsigned _M_readers()
const {
return _M_state & _S_max_readers; }
315 shared_timed_mutex() : _M_state(0) {}
317 ~shared_timed_mutex()
319 _GLIBCXX_DEBUG_ASSERT( _M_state == 0 );
322 shared_timed_mutex(
const shared_timed_mutex&) =
delete;
323 shared_timed_mutex& operator=(
const shared_timed_mutex&) =
delete;
330 unique_lock<mutex> __lk(_M_mut);
332 _M_gate1.wait(__lk, [=]{
return !_M_write_entered(); });
333 _M_state |= _S_write_entered;
335 _M_gate2.wait(__lk, [=]{
return _M_readers() == 0; });
341 unique_lock<mutex> __lk(_M_mut, try_to_lock);
342 if (__lk.owns_lock() && _M_state == 0)
344 _M_state = _S_write_entered;
350 template<
typename _Rep,
typename _Period>
352 try_lock_for(
const chrono::duration<_Rep, _Period>& __rel_time)
354 return try_lock_until(__clock_t::now() + __rel_time);
357 template<
typename _Clock,
typename _Duration>
359 try_lock_until(
const chrono::time_point<_Clock, _Duration>& __abs_time)
361 unique_lock<mutex> __lk(_M_mut);
362 if (!_M_gate1.wait_until(__lk, __abs_time,
363 [=]{
return !_M_write_entered(); }))
367 _M_state |= _S_write_entered;
368 if (!_M_gate2.wait_until(__lk, __abs_time,
369 [=]{
return _M_readers() == 0; }))
371 _M_state ^= _S_write_entered;
373 _M_gate1.notify_all();
382 lock_guard<mutex> __lk(_M_mut);
383 _GLIBCXX_DEBUG_ASSERT( _M_write_entered() );
387 _M_gate1.notify_all();
395 unique_lock<mutex> __lk(_M_mut);
396 _M_gate1.wait(__lk, [=]{
return _M_state < _S_max_readers; });
403 unique_lock<mutex> __lk(_M_mut, try_to_lock);
404 if (!__lk.owns_lock())
406 if (_M_state < _S_max_readers)
414 template<
typename _Rep,
typename _Period>
416 try_lock_shared_for(
const chrono::duration<_Rep, _Period>& __rel_time)
418 return try_lock_shared_until(__clock_t::now() + __rel_time);
421 template <
typename _Clock,
typename _Duration>
423 try_lock_shared_until(
const chrono::time_point<_Clock,
424 _Duration>& __abs_time)
426 unique_lock<mutex> __lk(_M_mut);
427 if (!_M_gate1.wait_until(__lk, __abs_time,
428 [=]{
return _M_state < _S_max_readers; }))
439 lock_guard<mutex> __lk(_M_mut);
440 _GLIBCXX_DEBUG_ASSERT( _M_readers() > 0 );
441 auto __prev = _M_state--;
442 if (_M_write_entered())
445 if (_M_readers() == 0)
446 _M_gate2.notify_one();
454 if (__prev == _S_max_readers)
455 _M_gate1.notify_one();
458 #endif // _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
460 #endif // _GLIBCXX_HAS_GTHREADS
463 template<
typename _Mutex>
467 typedef _Mutex mutex_type;
471 shared_lock() noexcept : _M_pm(
nullptr), _M_owns(false) { }
474 shared_lock(mutex_type& __m) : _M_pm(&__m), _M_owns(true)
475 { __m.lock_shared(); }
477 shared_lock(mutex_type& __m, defer_lock_t) noexcept
478 : _M_pm(&__m), _M_owns(false) { }
480 shared_lock(mutex_type& __m, try_to_lock_t)
481 : _M_pm(&__m), _M_owns(__m.try_lock_shared()) { }
483 shared_lock(mutex_type& __m, adopt_lock_t)
484 : _M_pm(&__m), _M_owns(true) { }
486 template<
typename _Clock,
typename _Duration>
487 shared_lock(mutex_type& __m,
488 const chrono::time_point<_Clock, _Duration>& __abs_time)
489 : _M_pm(&__m), _M_owns(__m.try_lock_shared_until(__abs_time)) { }
491 template<
typename _Rep,
typename _Period>
492 shared_lock(mutex_type& __m,
493 const chrono::duration<_Rep, _Period>& __rel_time)
494 : _M_pm(&__m), _M_owns(__m.try_lock_shared_for(__rel_time)) { }
499 _M_pm->unlock_shared();
502 shared_lock(shared_lock
const&) =
delete;
503 shared_lock& operator=(shared_lock
const&) =
delete;
505 shared_lock(shared_lock&& __sl) noexcept : shared_lock()
509 operator=(shared_lock&& __sl) noexcept
511 shared_lock(std::move(__sl)).swap(*
this);
519 _M_pm->lock_shared();
527 return _M_owns = _M_pm->try_lock_shared();
530 template<
typename _Rep,
typename _Period>
532 try_lock_for(
const chrono::duration<_Rep, _Period>& __rel_time)
535 return _M_owns = _M_pm->try_lock_shared_for(__rel_time);
538 template<
typename _Clock,
typename _Duration>
540 try_lock_until(
const chrono::time_point<_Clock, _Duration>& __abs_time)
543 return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
550 __throw_system_error(
int(errc::resource_deadlock_would_occur));
551 _M_pm->unlock_shared();
558 swap(shared_lock& __u) noexcept
568 return std::exchange(_M_pm,
nullptr);
573 bool owns_lock() const noexcept {
return _M_owns; }
575 explicit operator bool() const noexcept {
return _M_owns; }
577 mutex_type* mutex() const noexcept {
return _M_pm; }
583 if (_M_pm ==
nullptr)
584 __throw_system_error(
int(errc::operation_not_permitted));
586 __throw_system_error(
int(errc::resource_deadlock_would_occur));
594 template<
typename _Mutex>
596 swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
599 #endif // _GLIBCXX_USE_C99_STDINT_TR1
602 _GLIBCXX_END_NAMESPACE_VERSION
607 #endif // _GLIBCXX_SHARED_MUTEX
duration< int64_t, nano > nanoseconds
nanoseconds
void lock(_L1 &__l1, _L2 &__l2, _L3 &...__l3)
Generic lock.
constexpr enable_if< __is_duration< _ToDur >::value, time_point< _Clock, _ToDur > >::type time_point_cast(const time_point< _Clock, _Dur > &__t)
time_point_cast
constexpr enable_if< __is_duration< _ToDur >::value, _ToDur >::type duration_cast(const duration< _Rep, _Period > &__d)
duration_cast
duration< int64_t > seconds
seconds
void swap(basic_filebuf< _CharT, _Traits > &__x, basic_filebuf< _CharT, _Traits > &__y)
Swap specialization for filebufs.
int try_lock(_Lock1 &__l1, _Lock2 &__l2, _Lock3 &...__l3)
Generic try_lock.