Admin

name	type	size	perms	modified	actions
[parent directory]
backward/	dir	-	0755	2026-08-19 08:10:09
bits/	dir	-	0755	2026-08-19 08:10:09
debug/	dir	-	0755	2026-08-19 08:10:09
decimal/	dir	-	0755	2026-08-19 08:10:09
experimental/	dir	-	0755	2026-08-19 08:10:09
ext/	dir	-	0755	2026-08-19 08:10:09
parallel/	dir	-	0755	2026-08-19 08:10:09
pstl/	dir	-	0755	2026-08-19 08:10:09
tr1/	dir	-	0755	2026-08-19 08:10:09
tr2/	dir	-	0755	2026-08-19 08:10:09
x86_64-redhat-linux/	dir	-	0755	2026-08-19 08:10:09
algorithm	file	3,385 B	0644	2026-02-26 00:00:00	edit
any	file	19,155 B	0644	2026-02-26 00:00:00	edit
array	file	15,765 B	0644	2026-02-26 00:00:00	edit
atomic	file	52,386 B	0644	2026-02-26 00:00:00	edit
barrier	file	8,055 B	0644	2026-02-26 00:00:00	edit
bit	file	14,341 B	0644	2026-02-26 00:00:00	edit
bitset	file	50,370 B	0644	2026-02-26 00:00:00	edit
cassert	file	1,648 B	0644	2026-02-26 00:00:00	edit
ccomplex	file	1,335 B	0644	2026-02-26 00:00:00	edit
cctype	file	2,401 B	0644	2026-02-26 00:00:00	edit
cerrno	file	1,770 B	0644	2026-02-26 00:00:00	edit
cfenv	file	2,043 B	0644	2026-02-26 00:00:00	edit
cfloat	file	1,889 B	0644	2026-02-26 00:00:00	edit
charconv	file	29,830 B	0644	2026-02-26 00:00:00	edit
chrono	file	96,713 B	0644	2026-02-26 00:00:00	edit
cinttypes	file	2,145 B	0644	2026-02-26 00:00:00	edit
ciso646	file	1,464 B	0644	2026-02-26 00:00:00	edit
climits	file	1,913 B	0644	2026-02-26 00:00:00	edit
clocale	file	1,905 B	0644	2026-02-26 00:00:00	edit
cmath	file	97,153 B	0644	2026-02-26 00:00:00	edit
codecvt	file	5,275 B	0644	2026-02-26 00:00:00	edit
compare	file	38,139 B	0644	2026-02-26 00:00:00	edit
complex	file	76,638 B	0644	2026-02-26 00:00:00	edit
complex.h	file	1,596 B	0644	2026-02-26 00:00:00	edit
concepts	file	13,024 B	0644	2026-02-26 00:00:00	edit
condition_variable	file	12,895 B	0644	2026-02-26 00:00:00	edit
coroutine	file	9,614 B	0644	2026-02-26 00:00:00	edit
csetjmp	file	1,949 B	0644	2026-02-26 00:00:00	edit
csignal	file	1,855 B	0644	2026-02-26 00:00:00	edit
cstdalign	file	1,407 B	0644	2026-02-26 00:00:00	edit
cstdarg	file	1,868 B	0644	2026-02-26 00:00:00	edit
cstdbool	file	1,401 B	0644	2026-02-26 00:00:00	edit
cstddef	file	6,696 B	0644	2026-02-26 00:00:00	edit
cstdint	file	3,841 B	0644	2026-02-26 00:00:00	edit
cstdio	file	4,439 B	0644	2026-02-26 00:00:00	edit
cstdlib	file	6,918 B	0644	2026-02-26 00:00:00	edit
cstring	file	3,251 B	0644	2026-02-26 00:00:00	edit
ctgmath	file	1,360 B	0644	2026-02-26 00:00:00	edit
ctime	file	2,298 B	0644	2026-02-26 00:00:00	edit
cuchar	file	2,904 B	0644	2026-02-26 00:00:00	edit
cwchar	file	6,542 B	0644	2026-02-26 00:00:00	edit
cwctype	file	2,793 B	0644	2026-02-26 00:00:00	edit
cxxabi.h	file	22,290 B	0644	2026-02-26 00:00:00	edit
deque	file	4,667 B	0644	2026-02-26 00:00:00	edit
exception	file	5,437 B	0644	2026-02-26 00:00:00	edit
execution	file	1,918 B	0644	2026-02-26 00:00:00	edit
expected	file	52,371 B	0644	2026-02-26 00:00:00	edit
fenv.h	file	2,012 B	0644	2026-02-26 00:00:00	edit
filesystem	file	1,762 B	0644	2026-02-26 00:00:00	edit
format	file	132,026 B	0644	2026-02-26 00:00:00	edit
forward_list	file	3,030 B	0644	2026-02-26 00:00:00	edit
fstream	file	42,580 B	0644	2026-02-26 00:00:00	edit
functional	file	48,445 B	0644	2026-02-26 00:00:00	edit
future	file	53,559 B	0644	2026-02-26 00:00:00	edit
generator	file	22,693 B	0644	2026-02-26 00:00:00	edit
initializer_list	file	3,001 B	0644	2026-02-26 00:00:00	edit
iomanip	file	16,791 B	0644	2026-02-26 00:00:00	edit
ios	file	1,713 B	0644	2026-02-26 00:00:00	edit
iosfwd	file	8,406 B	0644	2026-02-26 00:00:00	edit
iostream	file	3,094 B	0644	2026-02-26 00:00:00	edit
istream	file	36,477 B	0644	2026-02-26 00:00:00	edit
iterator	file	3,093 B	0644	2026-02-26 00:00:00	edit
latch	file	2,765 B	0644	2026-02-26 00:00:00	edit
limits	file	83,976 B	0644	2026-02-26 00:00:00	edit
list	file	4,006 B	0644	2026-02-26 00:00:00	edit
locale	file	1,534 B	0644	2026-02-26 00:00:00	edit
map	file	4,471 B	0644	2026-02-26 00:00:00	edit
math.h	file	4,577 B	0644	2026-02-26 00:00:00	edit
memory	file	5,430 B	0644	2026-02-26 00:00:00	edit
memory_resource	file	14,491 B	0644	2026-02-26 00:00:00	edit
mutex	file	27,611 B	0644	2026-02-26 00:00:00	edit
new	file	8,686 B	0644	2026-02-26 00:00:00	edit
numbers	file	7,076 B	0644	2026-02-26 00:00:00	edit
numeric	file	26,220 B	0644	2026-02-26 00:00:00	edit
optional	file	45,160 B	0644	2026-02-26 00:00:00	edit
ostream	file	31,277 B	0644	2026-02-26 00:00:00	edit
print	file	4,844 B	0644	2026-02-26 00:00:00	edit
queue	file	2,600 B	0644	2026-02-26 00:00:00	edit
random	file	1,674 B	0644	2026-02-26 00:00:00	edit
ranges	file	278,497 B	0644	2026-02-26 00:00:00	edit
ratio	file	22,795 B	0644	2026-02-26 00:00:00	edit
regex	file	3,232 B	0644	2026-02-26 00:00:00	edit
scoped_allocator	file	17,824 B	0644	2026-02-26 00:00:00	edit
semaphore	file	3,108 B	0644	2026-02-26 00:00:00	edit
set	file	4,258 B	0644	2026-02-26 00:00:00	edit
shared_mutex	file	25,186 B	0644	2026-02-26 00:00:00	edit
source_location	file	2,761 B	0644	2026-02-26 00:00:00	edit
span	file	14,462 B	0644	2026-02-26 00:00:00	edit
spanstream	file	12,492 B	0644	2026-02-26 00:00:00	edit
sstream	file	39,767 B	0644	2026-02-26 00:00:00	edit
stack	file	2,524 B	0644	2026-02-26 00:00:00	edit
stacktrace	file	21,721 B	0644	2026-02-26 00:00:00	edit
stdatomic.h	file	4,116 B	0644	2026-02-26 00:00:00	edit
stdexcept	file	9,878 B	0644	2026-02-26 00:00:00	edit
stdfloat	file	1,766 B	0644	2026-02-26 00:00:00	edit
stdlib.h	file	2,305 B	0644	2026-02-26 00:00:00	edit
stop_token	file	16,098 B	0644	2026-02-26 00:00:00	edit
streambuf	file	29,938 B	0644	2026-02-26 00:00:00	edit
string	file	4,331 B	0644	2026-02-26 00:00:00	edit
string_view	file	28,180 B	0644	2026-02-26 00:00:00	edit
syncstream	file	8,378 B	0644	2026-02-26 00:00:00	edit
system_error	file	18,387 B	0644	2026-02-26 00:00:00	edit
text_encoding	file	16,655 B	0644	2026-02-26 00:00:00	edit
tgmath.h	file	1,360 B	0644	2026-02-26 00:00:00	edit
thread	file	10,005 B	0644	2026-02-26 00:00:00	edit
tuple	file	102,167 B	0644	2026-02-26 00:00:00	edit
type_traits	file	120,983 B	0644	2026-02-26 00:00:00	edit
typeindex	file	3,512 B	0644	2026-02-26 00:00:00	edit
typeinfo	file	8,290 B	0644	2026-02-26 00:00:00	edit
unordered_map	file	3,780 B	0644	2026-02-26 00:00:00	edit
unordered_set	file	3,561 B	0644	2026-02-26 00:00:00	edit
utility	file	7,561 B	0644	2026-02-26 00:00:00	edit
valarray	file	41,169 B	0644	2026-02-26 00:00:00	edit
variant	file	66,366 B	0644	2026-02-26 00:00:00	edit
vector	file	5,095 B	0644	2026-02-26 00:00:00	edit
version	file	1,449 B	0644	2026-02-26 00:00:00	edit

editing: shared_mutex

// <shared_mutex> -*- C++ -*-

// Copyright (C) 2013-2024 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file include/shared_mutex
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_SHARED_MUTEX
#define _GLIBCXX_SHARED_MUTEX 1

#pragma GCC system_header

#include <bits/requires_hosted.h> // concurrency

#if __cplusplus >= 201402L

#include <bits/chrono.h>
#include <bits/error_constants.h>
#include <bits/functexcept.h>
#include <bits/move.h>        // move, __exchange
#include <bits/std_mutex.h>   // defer_lock_t

#define __glibcxx_want_shared_mutex
#define __glibcxx_want_shared_timed_mutex
#include <bits/version.h>

#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
# include <condition_variable>
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
   * @addtogroup mutexes
   * @{
   */

#ifdef _GLIBCXX_HAS_GTHREADS

#ifdef __cpp_lib_shared_mutex // C++ >= 17 && hosted && gthread
  class shared_mutex;
#endif

class shared_timed_mutex;

/// @cond undocumented

#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
#ifdef __gthrw
#define _GLIBCXX_GTHRW(name) \
  __gthrw(pthread_ ## name); \
  static inline int \
  __glibcxx_ ## name (pthread_rwlock_t *__rwlock) \
  { \
    if (__gthread_active_p ()) \
      return __gthrw_(pthread_ ## name) (__rwlock); \
    else \
      return 0; \
  }
  _GLIBCXX_GTHRW(rwlock_rdlock)
  _GLIBCXX_GTHRW(rwlock_tryrdlock)
  _GLIBCXX_GTHRW(rwlock_wrlock)
  _GLIBCXX_GTHRW(rwlock_trywrlock)
  _GLIBCXX_GTHRW(rwlock_unlock)
# ifndef PTHREAD_RWLOCK_INITIALIZER
  _GLIBCXX_GTHRW(rwlock_destroy)
  __gthrw(pthread_rwlock_init);
  static inline int
  __glibcxx_rwlock_init (pthread_rwlock_t *__rwlock)
  {
    if (__gthread_active_p ())
      return __gthrw_(pthread_rwlock_init) (__rwlock, NULL);
    else
      return 0;
  }
# endif
# if _GTHREAD_USE_MUTEX_TIMEDLOCK
   __gthrw(pthread_rwlock_timedrdlock);
  static inline int
  __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
				const timespec *__ts)
  {
    if (__gthread_active_p ())
      return __gthrw_(pthread_rwlock_timedrdlock) (__rwlock, __ts);
    else
      return 0;
  }
   __gthrw(pthread_rwlock_timedwrlock);
  static inline int
  __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
				const timespec *__ts)
  {
    if (__gthread_active_p ())
      return __gthrw_(pthread_rwlock_timedwrlock) (__rwlock, __ts);
    else
      return 0;
  }
# endif
#else
  static inline int
  __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock)
  { return pthread_rwlock_rdlock (__rwlock); }
  static inline int
  __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  { return pthread_rwlock_tryrdlock (__rwlock); }
  static inline int
  __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock)
  { return pthread_rwlock_wrlock (__rwlock); }
  static inline int
  __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
  { return pthread_rwlock_trywrlock (__rwlock); }
  static inline int
  __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock)
  { return pthread_rwlock_unlock (__rwlock); }
  static inline int
  __glibcxx_rwlock_destroy(pthread_rwlock_t *__rwlock)
  { return pthread_rwlock_destroy (__rwlock); }
  static inline int
  __glibcxx_rwlock_init(pthread_rwlock_t *__rwlock)
  { return pthread_rwlock_init (__rwlock, NULL); }
# if _GTHREAD_USE_MUTEX_TIMEDLOCK
  static inline int
  __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
				const timespec *__ts)
  { return pthread_rwlock_timedrdlock (__rwlock, __ts); }
  static inline int
  __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
				const timespec *__ts)
  { return pthread_rwlock_timedwrlock (__rwlock, __ts); }
# endif
#endif

/// A shared mutex type implemented using pthread_rwlock_t.
  class __shared_mutex_pthread
  {
    friend class shared_timed_mutex;

#ifdef PTHREAD_RWLOCK_INITIALIZER
    pthread_rwlock_t	_M_rwlock = PTHREAD_RWLOCK_INITIALIZER;

public:
    __shared_mutex_pthread() = default;
    ~__shared_mutex_pthread() = default;
#else
    pthread_rwlock_t	_M_rwlock;

public:
    __shared_mutex_pthread()
    {
      int __ret = __glibcxx_rwlock_init(&_M_rwlock);
      if (__ret == ENOMEM)
	__throw_bad_alloc();
      else if (__ret == EAGAIN)
	__throw_system_error(int(errc::resource_unavailable_try_again));
      else if (__ret == EPERM)
	__throw_system_error(int(errc::operation_not_permitted));
      // Errors not handled: EBUSY, EINVAL
      __glibcxx_assert(__ret == 0);
    }

~__shared_mutex_pthread()
    {
      int __ret __attribute((__unused__)) = __glibcxx_rwlock_destroy(&_M_rwlock);
      // Errors not handled: EBUSY, EINVAL
      __glibcxx_assert(__ret == 0);
    }
#endif

__shared_mutex_pthread(const __shared_mutex_pthread&) = delete;
    __shared_mutex_pthread& operator=(const __shared_mutex_pthread&) = delete;

void
    lock()
    {
      int __ret = __glibcxx_rwlock_wrlock(&_M_rwlock);
      if (__ret == EDEADLK)
	__throw_system_error(int(errc::resource_deadlock_would_occur));
      // Errors not handled: EINVAL
      __glibcxx_assert(__ret == 0);
    }

bool
    try_lock()
    {
      int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock);
      if (__ret == EBUSY) return false;
      // Errors not handled: EINVAL
      __glibcxx_assert(__ret == 0);
      return true;
    }

void
    unlock()
    {
      int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock);
      // Errors not handled: EPERM, EBUSY, EINVAL
      __glibcxx_assert(__ret == 0);
    }

// Shared ownership

void
    lock_shared()
    {
      int __ret;
      // We retry if we exceeded the maximum number of read locks supported by
      // the POSIX implementation; this can result in busy-waiting, but this
      // is okay based on the current specification of forward progress
      // guarantees by the standard.
      do
	__ret = __glibcxx_rwlock_rdlock(&_M_rwlock);
      while (__ret == EAGAIN);
      if (__ret == EDEADLK)
	__throw_system_error(int(errc::resource_deadlock_would_occur));
      // Errors not handled: EINVAL
      __glibcxx_assert(__ret == 0);
    }

bool
    try_lock_shared()
    {
      int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock);
      // If the maximum number of read locks has been exceeded, we just fail
      // to acquire the lock.  Unlike for lock(), we are not allowed to throw
      // an exception.
      if (__ret == EBUSY || __ret == EAGAIN) return false;
      // Errors not handled: EINVAL
      __glibcxx_assert(__ret == 0);
      return true;
    }

void
    unlock_shared()
    {
      unlock();
    }

void* native_handle() { return &_M_rwlock; }
  };
#endif

#if ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)
  /// A shared mutex type implemented using std::condition_variable.
  class __shared_mutex_cv
  {
    friend class shared_timed_mutex;

// Based on Howard Hinnant's reference implementation from N2406.

// The high bit of _M_state is the write-entered flag which is set to
    // indicate a writer has taken the lock or is queuing to take the lock.
    // The remaining bits are the count of reader locks.
    //
    // To take a reader lock, block on gate1 while the write-entered flag is
    // set or the maximum number of reader locks is held, then increment the
    // reader lock count.
    // To release, decrement the count, then if the write-entered flag is set
    // and the count is zero then signal gate2 to wake a queued writer,
    // otherwise if the maximum number of reader locks was held signal gate1
    // to wake a reader.
    //
    // To take a writer lock, block on gate1 while the write-entered flag is
    // set, then set the write-entered flag to start queueing, then block on
    // gate2 while the number of reader locks is non-zero.
    // To release, unset the write-entered flag and signal gate1 to wake all
    // blocked readers and writers.
    //
    // This means that when no reader locks are held readers and writers get
    // equal priority. When one or more reader locks is held a writer gets
    // priority and no more reader locks can be taken while the writer is
    // queued.

// Only locked when accessing _M_state or waiting on condition variables.
    mutex		_M_mut;
    // Used to block while write-entered is set or reader count at maximum.
    condition_variable	_M_gate1;
    // Used to block queued writers while reader count is non-zero.
    condition_variable	_M_gate2;
    // The write-entered flag and reader count.
    unsigned		_M_state;

static constexpr unsigned _S_write_entered
      = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1);
    static constexpr unsigned _S_max_readers = ~_S_write_entered;

// Test whether the write-entered flag is set. _M_mut must be locked.
    bool _M_write_entered() const { return _M_state & _S_write_entered; }

// The number of reader locks currently held. _M_mut must be locked.
    unsigned _M_readers() const { return _M_state & _S_max_readers; }

public:
    __shared_mutex_cv() : _M_state(0) {}

~__shared_mutex_cv()
    {
      __glibcxx_assert( _M_state == 0 );
    }

__shared_mutex_cv(const __shared_mutex_cv&) = delete;
    __shared_mutex_cv& operator=(const __shared_mutex_cv&) = delete;

// Exclusive ownership

void
    lock()
    {
      unique_lock<mutex> __lk(_M_mut);
      // Wait until we can set the write-entered flag.
      _M_gate1.wait(__lk, [=]{ return !_M_write_entered(); });
      _M_state |= _S_write_entered;
      // Then wait until there are no more readers.
      _M_gate2.wait(__lk, [=]{ return _M_readers() == 0; });
    }

bool
    try_lock()
    {
      unique_lock<mutex> __lk(_M_mut, try_to_lock);
      if (__lk.owns_lock() && _M_state == 0)
	{
	  _M_state = _S_write_entered;
	  return true;
	}
      return false;
    }

void
    unlock()
    {
      lock_guard<mutex> __lk(_M_mut);
      __glibcxx_assert( _M_write_entered() );
      _M_state = 0;
      // call notify_all() while mutex is held so that another thread can't
      // lock and unlock the mutex then destroy *this before we make the call.
      _M_gate1.notify_all();
    }

// Shared ownership

void
    lock_shared()
    {
      unique_lock<mutex> __lk(_M_mut);
      _M_gate1.wait(__lk, [=]{ return _M_state < _S_max_readers; });
      ++_M_state;
    }

bool
    try_lock_shared()
    {
      unique_lock<mutex> __lk(_M_mut, try_to_lock);
      if (!__lk.owns_lock())
	return false;
      if (_M_state < _S_max_readers)
	{
	  ++_M_state;
	  return true;
	}
      return false;
    }

void
    unlock_shared()
    {
      lock_guard<mutex> __lk(_M_mut);
      __glibcxx_assert( _M_readers() > 0 );
      auto __prev = _M_state--;
      if (_M_write_entered())
	{
	  // Wake the queued writer if there are no more readers.
	  if (_M_readers() == 0)
	    _M_gate2.notify_one();
	  // No need to notify gate1 because we give priority to the queued
	  // writer, and that writer will eventually notify gate1 after it
	  // clears the write-entered flag.
	}
      else
	{
	  // Wake any thread that was blocked on reader overflow.
	  if (__prev == _S_max_readers)
	    _M_gate1.notify_one();
	}
    }
  };
#endif
  /// @endcond

#ifdef __cpp_lib_shared_mutex
  /// The standard shared mutex type.
  class shared_mutex
  {
  public:
    shared_mutex() = default;
    ~shared_mutex() = default;

shared_mutex(const shared_mutex&) = delete;
    shared_mutex& operator=(const shared_mutex&) = delete;

// Exclusive ownership

void lock() { _M_impl.lock(); }
    [[nodiscard]] bool try_lock() { return _M_impl.try_lock(); }
    void unlock() { _M_impl.unlock(); }

// Shared ownership

void lock_shared() { _M_impl.lock_shared(); }
    [[nodiscard]] bool try_lock_shared() { return _M_impl.try_lock_shared(); }
    void unlock_shared() { _M_impl.unlock_shared(); }

#if _GLIBCXX_USE_PTHREAD_RWLOCK_T
    typedef void* native_handle_type;
    native_handle_type native_handle() { return _M_impl.native_handle(); }

private:
    __shared_mutex_pthread _M_impl;
#else
  private:
    __shared_mutex_cv _M_impl;
#endif
  };
#endif // __cpp_lib_shared_mutex

/// @cond undocumented
#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
  using __shared_timed_mutex_base = __shared_mutex_pthread;
#else
  using __shared_timed_mutex_base = __shared_mutex_cv;
#endif
  /// @endcond

/// The standard shared timed mutex type.
  class shared_timed_mutex
  : private __shared_timed_mutex_base
  {
    using _Base = __shared_timed_mutex_base;

// Must use the same clock as condition_variable for __shared_mutex_cv.
#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
    using __clock_t = chrono::steady_clock;
#else
    using __clock_t = chrono::system_clock;
#endif

public:
    shared_timed_mutex() = default;
    ~shared_timed_mutex() = default;

shared_timed_mutex(const shared_timed_mutex&) = delete;
    shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;

// Exclusive ownership

void lock() { _Base::lock(); }
    _GLIBCXX_NODISCARD bool try_lock() { return _Base::try_lock(); }
    void unlock() { _Base::unlock(); }

template<typename _Rep, typename _Period>
      _GLIBCXX_NODISCARD
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      {
	auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
	if (ratio_greater<__clock_t::period, _Period>())
	  ++__rt;
	return try_lock_until(__clock_t::now() + __rt);
      }

// Shared ownership

void lock_shared() { _Base::lock_shared(); }
    _GLIBCXX_NODISCARD
    bool try_lock_shared() { return _Base::try_lock_shared(); }
    void unlock_shared() { _Base::unlock_shared(); }

template<typename _Rep, typename _Period>
      _GLIBCXX_NODISCARD
      bool
      try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rtime)
      {
	auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
	if (ratio_greater<__clock_t::period, _Period>())
	  ++__rt;
	return try_lock_shared_until(__clock_t::now() + __rt);
      }

#if _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK

// Exclusive ownership

template<typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_until(const chrono::time_point<chrono::system_clock,
		     _Duration>& __atime)
      {
	auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

__gthread_time_t __ts =
	  {
	    static_cast<std::time_t>(__s.time_since_epoch().count()),
	    static_cast<long>(__ns.count())
	  };

int __ret = __glibcxx_rwlock_timedwrlock(&_M_rwlock, &__ts);
	// On self-deadlock, we just fail to acquire the lock.  Technically,
	// the program violated the precondition.
	if (__ret == ETIMEDOUT || __ret == EDEADLK)
	  return false;
	// Errors not handled: EINVAL
	__glibcxx_assert(__ret == 0);
	return true;
      }

#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
    template<typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_until(const chrono::time_point<chrono::steady_clock,
		   _Duration>& __atime)
      {
	auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

__gthread_time_t __ts =
	  {
	    static_cast<std::time_t>(__s.time_since_epoch().count()),
	    static_cast<long>(__ns.count())
	  };

int __ret = pthread_rwlock_clockwrlock(&_M_rwlock, CLOCK_MONOTONIC,
					       &__ts);
	// On self-deadlock, we just fail to acquire the lock.  Technically,
	// the program violated the precondition.
	if (__ret == ETIMEDOUT || __ret == EDEADLK)
	  return false;
	// Errors not handled: EINVAL
	__glibcxx_assert(__ret == 0);
	return true;
      }
#endif

template<typename _Clock, typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
      {
#if __cplusplus > 201703L
	static_assert(chrono::is_clock_v<_Clock>);
#endif
	// The user-supplied clock may not tick at the same rate as
	// steady_clock, so we must loop in order to guarantee that
	// the timeout has expired before returning false.
	typename _Clock::time_point __now = _Clock::now();
	do {
	    auto __rtime = __atime - __now;
	    if (try_lock_for(__rtime))
	      return true;
	    __now = _Clock::now();
	} while (__atime > __now);
	return false;
      }

// Shared ownership

template<typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_shared_until(const chrono::time_point<chrono::system_clock,
			    _Duration>& __atime)
      {
	auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

__gthread_time_t __ts =
	  {
	    static_cast<std::time_t>(__s.time_since_epoch().count()),
	    static_cast<long>(__ns.count())
	  };

int __ret;
	// Unlike for lock(), we are not allowed to throw an exception so if
	// the maximum number of read locks has been exceeded, or we would
	// deadlock, we just try to acquire the lock again (and will time out
	// eventually).
	// In cases where we would exceed the maximum number of read locks
	// throughout the whole time until the timeout, we will fail to
	// acquire the lock even if it would be logically free; however, this
	// is allowed by the standard, and we made a "strong effort"
	// (see C++14 30.4.1.4p26).
	// For cases where the implementation detects a deadlock we
	// intentionally block and timeout so that an early return isn't
	// mistaken for a spurious failure, which might help users realise
	// there is a deadlock.
	do
	  __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts);
	while (__ret == EAGAIN || __ret == EDEADLK);
	if (__ret == ETIMEDOUT)
	  return false;
	// Errors not handled: EINVAL
	__glibcxx_assert(__ret == 0);
	return true;
      }

#ifdef _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK
    template<typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_shared_until(const chrono::time_point<chrono::steady_clock,
			    _Duration>& __atime)
      {
	auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

__gthread_time_t __ts =
	  {
	    static_cast<std::time_t>(__s.time_since_epoch().count()),
	    static_cast<long>(__ns.count())
	  };

int __ret = pthread_rwlock_clockrdlock(&_M_rwlock, CLOCK_MONOTONIC,
					       &__ts);
	// On self-deadlock, we just fail to acquire the lock.  Technically,
	// the program violated the precondition.
	if (__ret == ETIMEDOUT || __ret == EDEADLK)
	  return false;
	// Errors not handled: EINVAL
	__glibcxx_assert(__ret == 0);
	return true;
      }
#endif

template<typename _Clock, typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_shared_until(const chrono::time_point<_Clock,
						     _Duration>& __atime)
      {
#if __cplusplus > 201703L
	static_assert(chrono::is_clock_v<_Clock>);
#endif
	// The user-supplied clock may not tick at the same rate as
	// steady_clock, so we must loop in order to guarantee that
	// the timeout has expired before returning false.
	typename _Clock::time_point __now = _Clock::now();
	do {
	    auto __rtime = __atime - __now;
	    if (try_lock_shared_for(__rtime))
	      return true;
	    __now = _Clock::now();
	} while (__atime > __now);
	return false;
      }

#else // ! (_GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK)

// Exclusive ownership

template<typename _Clock, typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
      {
	unique_lock<mutex> __lk(_M_mut);
	if (!_M_gate1.wait_until(__lk, __abs_time,
				 [=]{ return !_M_write_entered(); }))
	  {
	    return false;
	  }
	_M_state |= _S_write_entered;
	if (!_M_gate2.wait_until(__lk, __abs_time,
				 [=]{ return _M_readers() == 0; }))
	  {
	    _M_state ^= _S_write_entered;
	    // Wake all threads blocked while the write-entered flag was set.
	    _M_gate1.notify_all();
	    return false;
	  }
	return true;
      }

// Shared ownership

template <typename _Clock, typename _Duration>
      _GLIBCXX_NODISCARD
      bool
      try_lock_shared_until(const chrono::time_point<_Clock,
						     _Duration>& __abs_time)
      {
	unique_lock<mutex> __lk(_M_mut);
	if (!_M_gate1.wait_until(__lk, __abs_time,
				 [=]{ return _M_state < _S_max_readers; }))
	  {
	    return false;
	  }
	++_M_state;
	return true;
      }

#endif // _GLIBCXX_USE_PTHREAD_RWLOCK_T && _GTHREAD_USE_MUTEX_TIMEDLOCK
  };
#endif // _GLIBCXX_HAS_GTHREADS

/// shared_lock
  template<typename _Mutex>
    class shared_lock
    {
    public:
      typedef _Mutex mutex_type;

// Shared locking

shared_lock() noexcept : _M_pm(nullptr), _M_owns(false) { }

explicit
      shared_lock(mutex_type& __m)
      : _M_pm(std::__addressof(__m)), _M_owns(true)
      { __m.lock_shared(); }

shared_lock(mutex_type& __m, defer_lock_t) noexcept
      : _M_pm(std::__addressof(__m)), _M_owns(false) { }

shared_lock(mutex_type& __m, try_to_lock_t)
      : _M_pm(std::__addressof(__m)), _M_owns(__m.try_lock_shared()) { }

shared_lock(mutex_type& __m, adopt_lock_t)
      : _M_pm(std::__addressof(__m)), _M_owns(true) { }

template<typename _Clock, typename _Duration>
	shared_lock(mutex_type& __m,
		    const chrono::time_point<_Clock, _Duration>& __abs_time)
      : _M_pm(std::__addressof(__m)),
	_M_owns(__m.try_lock_shared_until(__abs_time)) { }

template<typename _Rep, typename _Period>
	shared_lock(mutex_type& __m,
		    const chrono::duration<_Rep, _Period>& __rel_time)
      : _M_pm(std::__addressof(__m)),
	_M_owns(__m.try_lock_shared_for(__rel_time)) { }

~shared_lock()
      {
	if (_M_owns)
	  _M_pm->unlock_shared();
      }

shared_lock(shared_lock const&) = delete;
      shared_lock& operator=(shared_lock const&) = delete;

shared_lock(shared_lock&& __sl) noexcept : shared_lock()
      { swap(__sl); }

shared_lock&
      operator=(shared_lock&& __sl) noexcept
      {
	shared_lock(std::move(__sl)).swap(*this);
	return *this;
      }

void
      lock()
      {
	_M_lockable();
	_M_pm->lock_shared();
	_M_owns = true;
      }

_GLIBCXX_NODISCARD
      bool
      try_lock()
      {
	_M_lockable();
	return _M_owns = _M_pm->try_lock_shared();
      }

template<typename _Rep, typename _Period>
	_GLIBCXX_NODISCARD
	bool
	try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
	{
	  _M_lockable();
	  return _M_owns = _M_pm->try_lock_shared_for(__rel_time);
	}

template<typename _Clock, typename _Duration>
	_GLIBCXX_NODISCARD
	bool
	try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
	{
	  _M_lockable();
	  return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
	}

void
      unlock()
      {
	if (!_M_owns)
	  __throw_system_error(int(errc::operation_not_permitted));
	_M_pm->unlock_shared();
	_M_owns = false;
      }

// Setters

void
      swap(shared_lock& __u) noexcept
      {
	std::swap(_M_pm, __u._M_pm);
	std::swap(_M_owns, __u._M_owns);
      }

mutex_type*
      release() noexcept
      {
	_M_owns = false;
	return std::__exchange(_M_pm, nullptr);
      }

// Getters

_GLIBCXX_NODISCARD
      bool owns_lock() const noexcept { return _M_owns; }

explicit operator bool() const noexcept { return _M_owns; }

_GLIBCXX_NODISCARD
      mutex_type* mutex() const noexcept { return _M_pm; }

private:
      void
      _M_lockable() const
      {
	if (_M_pm == nullptr)
	  __throw_system_error(int(errc::operation_not_permitted));
	if (_M_owns)
	  __throw_system_error(int(errc::resource_deadlock_would_occur));
      }

mutex_type*	_M_pm;
      bool		_M_owns;
    };

/// Swap specialization for shared_lock
  /// @relates shared_mutex
  template<typename _Mutex>
    void
    swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
    { __x.swap(__y); }

/// @} group mutexes
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif // C++14

#endif // _GLIBCXX_SHARED_MUTEX

cancel