FM / bits

/usr/include/c++/11/bits

Name	Size	Mode	Actions
algorithmfwd.h	24547	0644	edit dl rm
align.h	3711	0644	edit dl rm
allocated_ptr.h	3329	0644	edit dl rm
allocator.h	9737	0644	edit dl rm
alloc_traits.h	27632	0644	edit dl rm
atomic_base.h	57414	0644	edit dl rm
atomic_futex.h	12394	0644	edit dl rm
atomic_lockfree_defines.h	2353	0644	edit dl rm
atomic_timed_wait.h	13530	0644	edit dl rm
atomic_wait.h	12557	0644	edit dl rm
basic_ios.h	16080	0644	edit dl rm
basic_ios.tcc	6083	0644	edit dl rm
basic_string.h	251944	0644	edit dl rm
basic_string.tcc	54189	0644	edit dl rm
boost_concept_check.h	27182	0644	edit dl rm
c++0x_warning.h	1474	0644	edit dl rm
charconv.h	3435	0644	edit dl rm
char_traits.h	29350	0644	edit dl rm
codecvt.h	25500	0644	edit dl rm
concept_check.h	3423	0644	edit dl rm
cpp_type_traits.h	14003	0644	edit dl rm
cxxabi_forced.h	1811	0644	edit dl rm
cxxabi_init_exception.h	2220	0644	edit dl rm
deque.tcc	42361	0644	edit dl rm
enable_special_members.h	12452	0644	edit dl rm
erase_if.h	2066	0644	edit dl rm
exception.h	2504	0644	edit dl rm
exception_defines.h	1645	0644	edit dl rm
exception_ptr.h	7640	0644	edit dl rm
forward_list.h	50387	0644	edit dl rm
forward_list.tcc	14035	0644	edit dl rm
fstream.tcc	33672	0644	edit dl rm
fs_dir.h	16409	0644	edit dl rm
fs_fwd.h	10771	0644	edit dl rm
fs_ops.h	10739	0644	edit dl rm
fs_path.h	39745	0644	edit dl rm
functexcept.h	3509	0644	edit dl rm
functional_hash.h	8591	0644	edit dl rm
gslice.h	5519	0644	edit dl rm
gslice_array.h	7892	0644	edit dl rm
hashtable.h	84951	0644	edit dl rm
hashtable_policy.h	62156	0644	edit dl rm
hash_bytes.h	2146	0644	edit dl rm
indirect_array.h	7902	0644	edit dl rm
invoke.h	6059	0644	edit dl rm
ios_base.h	31934	0644	edit dl rm
istream.tcc	31595	0644	edit dl rm
iterator_concepts.h	33335	0644	edit dl rm
list.tcc	17201	0644	edit dl rm
localefwd.h	5943	0644	edit dl rm
locale_classes.h	25044	0644	edit dl rm
locale_classes.tcc	8375	0644	edit dl rm
locale_conv.h	18822	0644	edit dl rm
locale_facets.h	93655	0644	edit dl rm
locale_facets.tcc	40463	0644	edit dl rm
locale_facets_nonio.h	69704	0644	edit dl rm
locale_facets_nonio.tcc	47533	0644	edit dl rm
mask_array.h	7716	0644	edit dl rm
max_size_type.h	22715	0644	edit dl rm
memoryfwd.h	2504	0644	edit dl rm
move.h	6798	0644	edit dl rm
nested_exception.h	4887	0644	edit dl rm
node_handle.h	10920	0644	edit dl rm
ostream.tcc	12315	0644	edit dl rm
ostream_insert.h	4038	0644	edit dl rm
parse_numbers.h	7980	0644	edit dl rm
postypes.h	8465	0644	edit dl rm
predefined_ops.h	10177	0644	edit dl rm
ptr_traits.h	6708	0644	edit dl rm
quoted_string.h	5053	0644	edit dl rm
random.h	178359	0644	edit dl rm
random.tcc	105688	0644	edit dl rm
ranges_algo.h	116831	0644	edit dl rm
ranges_algobase.h	18871	0644	edit dl rm
ranges_base.h	24392	0644	edit dl rm
ranges_cmp.h	6017	0644	edit dl rm
ranges_uninitialized.h	18130	0644	edit dl rm
ranges_util.h	20591	0644	edit dl rm
range_access.h	10707	0644	edit dl rm
refwrap.h	13208	0644	edit dl rm
regex.h	103969	0644	edit dl rm
regex.tcc	16492	0644	edit dl rm
regex_automaton.h	10788	0644	edit dl rm
regex_automaton.tcc	7722	0644	edit dl rm
regex_compiler.h	16219	0644	edit dl rm
regex_compiler.tcc	19158	0644	edit dl rm
regex_constants.h	15549	0644	edit dl rm
regex_error.h	5015	0644	edit dl rm
regex_executor.h	8852	0644	edit dl rm
regex_executor.tcc	18837	0644	edit dl rm
regex_scanner.h	7047	0644	edit dl rm
regex_scanner.tcc	15249	0644	edit dl rm
semaphore_base.h	7936	0644	edit dl rm
shared_ptr.h	30981	0644	edit dl rm
shared_ptr_atomic.h	9874	0644	edit dl rm
shared_ptr_base.h	54907	0644	edit dl rm
slice_array.h	9619	0644	edit dl rm
specfun.h	47240	0644	edit dl rm
sstream.tcc	10148	0644	edit dl rm
std_abs.h	3384	0644	edit dl rm
std_function.h	22863	0644	edit dl rm
std_mutex.h	6443	0644	edit dl rm
std_thread.h	8589	0644	edit dl rm
stl_algo.h	214703	0644	edit dl rm
stl_algobase.h	76254	0644	edit dl rm
stl_bvector.h	35574	0644	edit dl rm
stl_construct.h	8800	0644	edit dl rm
stl_deque.h	76970	0644	edit dl rm
stl_function.h	43897	0644	edit dl rm
stl_heap.h	20756	0644	edit dl rm
stl_iterator.h	78851	0644	edit dl rm
stl_iterator_base_funcs.h	8178	0644	edit dl rm
stl_iterator_base_types.h	9662	0644	edit dl rm
stl_list.h	69779	0644	edit dl rm
stl_map.h	54693	0644	edit dl rm
stl_multimap.h	43534	0644	edit dl rm
stl_multiset.h	37675	0644	edit dl rm
stl_numeric.h	14601	0644	edit dl rm
stl_pair.h	20135	0644	edit dl rm
stl_queue.h	25036	0644	edit dl rm
stl_raw_storage_iter.h	3830	0644	edit dl rm
stl_relops.h	4594	0644	edit dl rm
stl_set.h	37939	0644	edit dl rm
stl_stack.h	12684	0644	edit dl rm
stl_tempbuf.h	8655	0644	edit dl rm
stl_tree.h	73922	0644	edit dl rm
stl_uninitialized.h	34013	0644	edit dl rm
stl_vector.h	65919	0644	edit dl rm
streambuf.tcc	4929	0644	edit dl rm
streambuf_iterator.h	15532	0644	edit dl rm
stream_iterator.h	7697	0644	edit dl rm
stringfwd.h	2690	0644	edit dl rm
string_view.tcc	7167	0644	edit dl rm
this_thread_sleep.h	3307	0644	edit dl rm
uniform_int_dist.h	13052	0644	edit dl rm
unique_lock.h	6143	0644	edit dl rm
unique_ptr.h	32537	0644	edit dl rm
unordered_map.h	76669	0644	edit dl rm
unordered_set.h	62934	0644	edit dl rm
uses_allocator.h	6906	0644	edit dl rm
uses_allocator_args.h	7562	0644	edit dl rm
valarray_after.h	23283	0644	edit dl rm
valarray_array.h	21295	0644	edit dl rm
valarray_array.tcc	7254	0644	edit dl rm
valarray_before.h	19142	0644	edit dl rm
vector.tcc	30985	0644	edit dl rm

Edit: /usr/include/c++/11/bits/atomic_timed_wait.h (13530B)

// -*- C++ -*- header.

// Copyright (C) 2020-2021 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 bits/atomic_timed_wait.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{atomic}
 */

#ifndef _GLIBCXX_ATOMIC_TIMED_WAIT_H
#define _GLIBCXX_ATOMIC_TIMED_WAIT_H 1

#pragma GCC system_header

#include <bits/atomic_wait.h>

#if __cpp_lib_atomic_wait
#include <bits/functional_hash.h>
#include <bits/this_thread_sleep.h>

#include <chrono>

#ifdef _GLIBCXX_HAVE_LINUX_FUTEX
#include <exception> // std::terminate
#include <sys/time.h>
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace __detail
  {
    using __wait_clock_t = chrono::steady_clock;

template<typename _Clock, typename _Dur>
      __wait_clock_t::time_point
      __to_wait_clock(const chrono::time_point<_Clock, _Dur>& __atime) noexcept
      {
	const typename _Clock::time_point __c_entry = _Clock::now();
	const __wait_clock_t::time_point __w_entry = __wait_clock_t::now();
	const auto __delta = __atime - __c_entry;
	using __w_dur = typename __wait_clock_t::duration;
	return __w_entry + chrono::ceil<__w_dur>(__delta);
      }

template<typename _Dur>
      __wait_clock_t::time_point
      __to_wait_clock(const chrono::time_point<__wait_clock_t,
					       _Dur>& __atime) noexcept
      {
	using __w_dur = typename __wait_clock_t::duration;
	return chrono::ceil<__w_dur>(__atime);
      }

#ifdef _GLIBCXX_HAVE_LINUX_FUTEX
#define _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT
    // returns true if wait ended before timeout
    template<typename _Dur>
      bool
      __platform_wait_until_impl(const __platform_wait_t* __addr,
				 __platform_wait_t __old,
				 const chrono::time_point<__wait_clock_t, _Dur>&
				      __atime) noexcept
      {
	auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

struct timespec __rt =
	{
	  static_cast<std::time_t>(__s.time_since_epoch().count()),
	  static_cast<long>(__ns.count())
	};

auto __e = syscall (SYS_futex, __addr,
			    static_cast<int>(__futex_wait_flags::
						__wait_bitset_private),
			    __old, &__rt, nullptr,
			    static_cast<int>(__futex_wait_flags::
						__bitset_match_any));

if (__e)
	  {
	    if (errno == ETIMEDOUT)
	      return false;
	    if (errno != EINTR && errno != EAGAIN)
	      __throw_system_error(errno);
	  }
	return true;
      }

// returns true if wait ended before timeout
    template<typename _Clock, typename _Dur>
      bool
      __platform_wait_until(const __platform_wait_t* __addr, __platform_wait_t __old,
			    const chrono::time_point<_Clock, _Dur>& __atime)
      {
	if constexpr (is_same_v<__wait_clock_t, _Clock>)
	  {
	    return __platform_wait_until_impl(__addr, __old, __atime);
	  }
	else
	  {
	    if (!__platform_wait_until_impl(__addr, __old,
					    __to_wait_clock(__atime)))
	      {
		// We got a timeout when measured against __clock_t but
		// we need to check against the caller-supplied clock
		// to tell whether we should return a timeout.
		if (_Clock::now() < __atime)
		  return true;
	      }
	    return false;
	  }
      }
#else
// define _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT and implement __platform_wait_until()
// if there is a more efficient primitive supported by the platform
// (e.g. __ulock_wait())which is better than pthread_cond_clockwait
#endif // ! PLATFORM_TIMED_WAIT

#ifdef _GLIBCXX_HAS_GTHREADS
    // Returns true if wait ended before timeout.
    // _Clock must be either steady_clock or system_clock.
    template<typename _Clock, typename _Dur>
      bool
      __cond_wait_until_impl(__condvar& __cv, mutex& __mx,
			     const chrono::time_point<_Clock, _Dur>& __atime)
      {
	static_assert(std::__is_one_of<_Clock, chrono::steady_clock,
					       chrono::system_clock>::value);

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())
	  };

#ifdef _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT
	if constexpr (is_same_v<chrono::steady_clock, _Clock>)
	  __cv.wait_until(__mx, CLOCK_MONOTONIC, __ts);
	else
#endif
	  __cv.wait_until(__mx, __ts);
	return _Clock::now() < __atime;
      }

// returns true if wait ended before timeout
    template<typename _Clock, typename _Dur>
      bool
      __cond_wait_until(__condvar& __cv, mutex& __mx,
	  const chrono::time_point<_Clock, _Dur>& __atime)
      {
#ifdef _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT
	if constexpr (is_same_v<_Clock, chrono::steady_clock>)
	  return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
	else
#endif
	if constexpr (is_same_v<_Clock, chrono::system_clock>)
	  return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
	else
	  {
	    if (__cond_wait_until_impl(__cv, __mx,
				       __to_wait_clock(__atime)))
	      {
		// We got a timeout when measured against __clock_t but
		// we need to check against the caller-supplied clock
		// to tell whether we should return a timeout.
		if (_Clock::now() < __atime)
		  return true;
	      }
	    return false;
	  }
      }
#endif // _GLIBCXX_HAS_GTHREADS

struct __timed_waiter_pool : __waiter_pool_base
    {
      // returns true if wait ended before timeout
      template<typename _Clock, typename _Dur>
	bool
	_M_do_wait_until(__platform_wait_t* __addr, __platform_wait_t __old,
			 const chrono::time_point<_Clock, _Dur>& __atime)
	{
#ifdef _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT
	  return __platform_wait_until(__addr, __old, __atime);
#else
	  __platform_wait_t __val;
	  __atomic_load(__addr, &__val, __ATOMIC_RELAXED);
	  if (__val == __old)
	    {
	      lock_guard<mutex> __l(_M_mtx);
	      return __cond_wait_until(_M_cv, _M_mtx, __atime);
	    }
	  else
	    return true;
#endif // _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT
	}
    };

struct __timed_backoff_spin_policy
    {
      __wait_clock_t::time_point _M_deadline;
      __wait_clock_t::time_point _M_t0;

template<typename _Clock, typename _Dur>
	__timed_backoff_spin_policy(chrono::time_point<_Clock, _Dur>
				      __deadline = _Clock::time_point::max(),
				    chrono::time_point<_Clock, _Dur>
				      __t0 = _Clock::now()) noexcept
	  : _M_deadline(__to_wait_clock(__deadline))
	  , _M_t0(__to_wait_clock(__t0))
	{ }

bool
      operator()() const noexcept
      {
	using namespace literals::chrono_literals;
	auto __now = __wait_clock_t::now();
	if (_M_deadline <= __now)
	  return false;

// FIXME: this_thread::sleep_for not available #ifdef _GLIBCXX_NO_SLEEP

auto __elapsed = __now - _M_t0;
	if (__elapsed > 128ms)
	  {
	    this_thread::sleep_for(64ms);
	  }
	else if (__elapsed > 64us)
	  {
	    this_thread::sleep_for(__elapsed / 2);
	  }
	else if (__elapsed > 4us)
	  {
	    __thread_yield();
	  }
	else
	  return false;
	return true;
      }
    };

template<typename _EntersWait>
      struct __timed_waiter : __waiter_base<__timed_waiter_pool>
      {
	using __base_type = __waiter_base<__timed_waiter_pool>;

template<typename _Tp>
	  __timed_waiter(const _Tp* __addr) noexcept
	  : __base_type(__addr)
	{
	  if constexpr (_EntersWait::value)
	    _M_w._M_enter_wait();
	}

~__timed_waiter()
	{
	  if constexpr (_EntersWait::value)
	    _M_w._M_leave_wait();
	}

// returns true if wait ended before timeout
	template<typename _Tp, typename _ValFn,
		 typename _Clock, typename _Dur>
	  bool
	  _M_do_wait_until_v(_Tp __old, _ValFn __vfn,
			     const chrono::time_point<_Clock, _Dur>&
								__atime) noexcept
	  {
	    __platform_wait_t __val;
	    if (_M_do_spin(__old, std::move(__vfn), __val,
			   __timed_backoff_spin_policy(__atime)))
	      return true;
	    return __base_type::_M_w._M_do_wait_until(__base_type::_M_addr, __val, __atime);
	  }

// returns true if wait ended before timeout
	template<typename _Pred,
		 typename _Clock, typename _Dur>
	  bool
	  _M_do_wait_until(_Pred __pred, __platform_wait_t __val,
			  const chrono::time_point<_Clock, _Dur>&
							      __atime) noexcept
	  {
	    for (auto __now = _Clock::now(); __now < __atime;
		  __now = _Clock::now())
	      {
		if (__base_type::_M_w._M_do_wait_until(
		      __base_type::_M_addr, __val, __atime)
		    && __pred())
		  return true;

if (__base_type::_M_do_spin(__pred, __val,
			       __timed_backoff_spin_policy(__atime, __now)))
		  return true;
	      }
	    return false;
	  }

// returns true if wait ended before timeout
	template<typename _Pred,
		 typename _Clock, typename _Dur>
	  bool
	  _M_do_wait_until(_Pred __pred,
			   const chrono::time_point<_Clock, _Dur>&
								__atime) noexcept
	  {
	    __platform_wait_t __val;
	    if (__base_type::_M_do_spin(__pred, __val,
					__timed_backoff_spin_policy(__atime)))
	      return true;
	    return _M_do_wait_until(__pred, __val, __atime);
	  }

template<typename _Tp, typename _ValFn,
		 typename _Rep, typename _Period>
	  bool
	  _M_do_wait_for_v(_Tp __old, _ValFn __vfn,
			   const chrono::duration<_Rep, _Period>&
								__rtime) noexcept
	  {
	    __platform_wait_t __val;
	    if (_M_do_spin_v(__old, std::move(__vfn), __val))
	      return true;

if (!__rtime.count())
	      return false; // no rtime supplied, and spin did not acquire

auto __reltime = chrono::ceil<__wait_clock_t::duration>(__rtime);

return __base_type::_M_w._M_do_wait_until(
					  __base_type::_M_addr,
					  __val,
					  chrono::steady_clock::now() + __reltime);
	  }

template<typename _Pred,
		 typename _Rep, typename _Period>
	  bool
	  _M_do_wait_for(_Pred __pred,
			 const chrono::duration<_Rep, _Period>& __rtime) noexcept
	  {
	    __platform_wait_t __val;
	    if (__base_type::_M_do_spin(__pred, __val))
	      return true;

if (!__rtime.count())
	      return false; // no rtime supplied, and spin did not acquire

auto __reltime = chrono::ceil<__wait_clock_t::duration>(__rtime);

return _M_do_wait_until(__pred, __val,
				    chrono::steady_clock::now() + __reltime);
	  }
      };

using __enters_timed_wait = __timed_waiter<std::true_type>;
    using __bare_timed_wait = __timed_waiter<std::false_type>;
  } // namespace __detail

// returns true if wait ended before timeout
  template<typename _Tp, typename _ValFn,
	   typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until_v(const _Tp* __addr, _Tp&& __old, _ValFn&& __vfn,
			const chrono::time_point<_Clock, _Dur>&
			    __atime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_until_v(__old, __vfn, __atime);
    }

template<typename _Tp, typename _Pred,
	   typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until(const _Tp* __addr, _Pred __pred,
				const chrono::time_point<_Clock, _Dur>&
							      __atime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_until(__pred, __atime);
    }

template<typename _Pred,
	   typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until_bare(const __detail::__platform_wait_t* __addr,
				_Pred __pred,
				const chrono::time_point<_Clock, _Dur>&
							      __atime) noexcept
    {
      __detail::__bare_timed_wait __w{__addr};
      return __w._M_do_wait_until(__pred, __atime);
    }

template<typename _Tp, typename _ValFn,
	   typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for_v(const _Tp* __addr, _Tp&& __old, _ValFn&& __vfn,
		      const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_for_v(__old, __vfn, __rtime);
    }

template<typename _Tp, typename _Pred,
	   typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for(const _Tp* __addr, _Pred __pred,
		      const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {

__detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_for(__pred, __rtime);
    }

template<typename _Pred,
	   typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for_bare(const __detail::__platform_wait_t* __addr,
			_Pred __pred,
			const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {
      __detail::__bare_timed_wait __w{__addr};
      return __w._M_do_wait_for(__pred, __rtime);
    }
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cpp_lib_atomic_wait
#endif // _GLIBCXX_ATOMIC_TIMED_WAIT_H

cmd: