ꦫꦣꦺꦤ꧀ꦄꦤ꧀ꦠꦱꦺꦤ

PATH: usr / include / c++ / 11 / bits

// shared_ptr atomic access -*- C++ -*-

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

#ifndef _SHARED_PTR_ATOMIC_H
#define _SHARED_PTR_ATOMIC_H 1

#include <bits/atomic_base.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
   * @addtogroup pointer_abstractions
   * @{
   */
  /// @relates shared_ptr @{

/// @cond undocumented

struct _Sp_locker
  {
    _Sp_locker(const _Sp_locker&) = delete;
    _Sp_locker& operator=(const _Sp_locker&) = delete;

#ifdef __GTHREADS
    explicit
    _Sp_locker(const void*) noexcept;
    _Sp_locker(const void*, const void*) noexcept;
    ~_Sp_locker();

private:
    unsigned char _M_key1;
    unsigned char _M_key2;
#else
    explicit _Sp_locker(const void*, const void* = nullptr) { }
#endif
  };

/// @endcond

/**
   *  @brief  Report whether shared_ptr atomic operations are lock-free.
   *  @param  __p A non-null pointer to a shared_ptr object.
   *  @return True if atomic access to @c *__p is lock-free, false otherwise.
   *  @{
  */
  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
    {
#ifdef __GTHREADS
      return __gthread_active_p() == 0;
#else
      return true;
#endif
    }

template<typename _Tp>
    inline bool
    atomic_is_lock_free(const shared_ptr<_Tp>* __p)
    { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }

/// @}

/**
   *  @brief  Atomic load for shared_ptr objects.
   *  @param  __p A non-null pointer to a shared_ptr object.
   *  @return @c *__p
   *
   *  The memory order shall not be @c memory_order_release or
   *  @c memory_order_acq_rel.
   *  @{
  */
  template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_load(const shared_ptr<_Tp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }

template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
  /// @}

/**
   *  @brief  Atomic store for shared_ptr objects.
   *  @param  __p A non-null pointer to a shared_ptr object.
   *  @param  __r The value to store.
   *
   *  The memory order shall not be @c memory_order_acquire or
   *  @c memory_order_acq_rel.
   *  @{
  */
  template<typename _Tp>
    inline void
    atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
			  memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r); // use swap so that **__p not destroyed while lock held
    }

template<typename _Tp>
    inline void
    atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }

template<typename _Tp, _Lock_policy _Lp>
    inline void
    atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
			  __shared_ptr<_Tp, _Lp> __r,
			  memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r); // use swap so that **__p not destroyed while lock held
    }

template<typename _Tp, _Lock_policy _Lp>
    inline void
    atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
  /// @}

/**
   *  @brief  Atomic exchange for shared_ptr objects.
   *  @param  __p A non-null pointer to a shared_ptr object.
   *  @param  __r New value to store in @c *__p.
   *  @return The original value of @c *__p
   *  @{
  */
  template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
			     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    {
      return std::atomic_exchange_explicit(__p, std::move(__r),
					   memory_order_seq_cst);
    }

template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
			     __shared_ptr<_Tp, _Lp> __r,
			     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
    {
      return std::atomic_exchange_explicit(__p, std::move(__r),
					   memory_order_seq_cst);
    }
  /// @}

/**
   *  @brief  Atomic compare-and-swap for shared_ptr objects.
   *  @param  __p A non-null pointer to a shared_ptr object.
   *  @param  __v A non-null pointer to a shared_ptr object.
   *  @param  __w A non-null pointer to a shared_ptr object.
   *  @return True if @c *__p was equivalent to @c *__v, false otherwise.
   *
   *  The memory order for failure shall not be @c memory_order_release or
   *  @c memory_order_acq_rel, or stronger than the memory order for success.
   *  @{
  */
  template<typename _Tp>
    bool
    atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
					    shared_ptr<_Tp>* __v,
					    shared_ptr<_Tp> __w,
					    memory_order,
					    memory_order)
    {
      shared_ptr<_Tp> __x; // goes out of scope after __lock
      _Sp_locker __lock{__p, __v};
      owner_less<shared_ptr<_Tp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
	{
	  __x = std::move(*__p);
	  *__p = std::move(__w);
	  return true;
	}
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

template<typename _Tp>
    inline bool
    atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
				 shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
	  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

template<typename _Tp>
    inline bool
    atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
					  shared_ptr<_Tp>* __v,
					  shared_ptr<_Tp> __w,
					  memory_order __success,
					  memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
	  std::move(__w), __success, __failure);
    }

template<typename _Tp>
    inline bool
    atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
				 shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_weak_explicit(__p, __v,
	  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

template<typename _Tp, _Lock_policy _Lp>
    bool
    atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
					    __shared_ptr<_Tp, _Lp>* __v,
					    __shared_ptr<_Tp, _Lp> __w,
					    memory_order,
					    memory_order)
    {
      __shared_ptr<_Tp, _Lp> __x; // goes out of scope after __lock
      _Sp_locker __lock{__p, __v};
      owner_less<__shared_ptr<_Tp, _Lp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
	{
	  __x = std::move(*__p);
	  *__p = std::move(__w);
	  return true;
	}
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
				   __shared_ptr<_Tp, _Lp>* __v,
				   __shared_ptr<_Tp, _Lp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
	  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
					  __shared_ptr<_Tp, _Lp>* __v,
					  __shared_ptr<_Tp, _Lp> __w,
					  memory_order __success,
					  memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
	  std::move(__w), __success, __failure);
    }

template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
				 __shared_ptr<_Tp, _Lp>* __v,
				 __shared_ptr<_Tp, _Lp> __w)
    {
      return std::atomic_compare_exchange_weak_explicit(__p, __v,
	  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }
  /// @}

/// @} relates shared_ptr
  /// @} group pointer_abstractions

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif // _SHARED_PTR_ATOMIC_H

[+] ..
[-] atomic_futex.h [edit]
[-] random.h [edit]
[-] functexcept.h [edit]
[-] exception.h [edit]
[-] regex.tcc [edit]
[-] char_traits.h [edit]
[-] uses_allocator.h [edit]
[-] specfun.h [edit]
[-] regex_automaton.tcc [edit]
[-] stl_stack.h [edit]
[-] node_handle.h [edit]
[-] regex_error.h [edit]
[-] stl_list.h [edit]
[-] vector.tcc [edit]
[-] stl_algobase.h [edit]
[-] regex_automaton.h [edit]
[-] cxxabi_init_exception.h [edit]
[-] basic_ios.tcc [edit]
[-] deque.tcc [edit]
[-] fs_fwd.h [edit]
[-] concept_check.h [edit]
[-] stl_algo.h [edit]
[-] functional_hash.h [edit]
[-] random.tcc [edit]
[-] fs_path.h [edit]
[-] max_size_type.h [edit]
[-] nested_exception.h [edit]
[-] atomic_base.h [edit]
[-] charconv.h [edit]
[-] ostream.tcc [edit]
[-] predefined_ops.h [edit]
[-] boost_concept_check.h [edit]
[-] atomic_lockfree_defines.h [edit]
[-] stl_construct.h [edit]
[-] list.tcc [edit]
[-] locale_classes.tcc [edit]
[-] uniform_int_dist.h [edit]
[-] semaphore_base.h [edit]
[-] mask_array.h [edit]
[-] ranges_algobase.h [edit]
[-] stl_heap.h [edit]
[-] alloc_traits.h [edit]
[-] string_view.tcc [edit]
[-] sstream.tcc [edit]
[-] regex_executor.tcc [edit]
[-] cpp_type_traits.h [edit]
[-] stl_map.h [edit]
[-] hashtable_policy.h [edit]
[-] regex_scanner.tcc [edit]
[-] ranges_base.h [edit]
[-] forward_list.h [edit]
[-] allocator.h [edit]
[-] codecvt.h [edit]
[-] istream.tcc [edit]
[-] memoryfwd.h [edit]
[-] stl_vector.h [edit]
[-] valarray_array.tcc [edit]
[-] valarray_array.h [edit]
[-] locale_facets.tcc [edit]
[-] stl_tree.h [edit]
[-] atomic_timed_wait.h [edit]
[-] streambuf_iterator.h [edit]
[-] unique_lock.h [edit]
[-] exception_defines.h [edit]
[-] stl_raw_storage_iter.h [edit]
[-] locale_facets_nonio.tcc [edit]
[-] regex.h [edit]
[-] stl_tempbuf.h [edit]
[-] unordered_map.h [edit]
[-] std_mutex.h [edit]
[-] regex_scanner.h [edit]
[-] locale_facets_nonio.h [edit]
[-] basic_string.h [edit]
[-] locale_classes.h [edit]
[-] regex_executor.h [edit]
[-] stl_multiset.h [edit]
[-] postypes.h [edit]
[-] stl_multimap.h [edit]
[-] std_thread.h [edit]
[-] atomic_wait.h [edit]
[-] fs_dir.h [edit]
[-] exception_ptr.h [edit]
[-] move.h [edit]
[-] erase_if.h [edit]
[-] valarray_after.h [edit]
[-] hash_bytes.h [edit]
[-] ranges_cmp.h [edit]
[-] ios_base.h [edit]
[-] invoke.h [edit]
[-] stream_iterator.h [edit]
[-] std_function.h [edit]
[-] stl_iterator.h [edit]
[-] slice_array.h [edit]
[-] stringfwd.h [edit]
[-] stl_function.h [edit]
[-] forward_list.tcc [edit]
[-] stl_iterator_base_funcs.h [edit]
[-] refwrap.h [edit]
[-] unordered_set.h [edit]
[-] stl_uninitialized.h [edit]
[-] streambuf.tcc [edit]
[-] algorithmfwd.h [edit]
[-] range_access.h [edit]
[-] enable_special_members.h [edit]
[-] unique_ptr.h [edit]
[-] localefwd.h [edit]
[-] quoted_string.h [edit]
[-] uses_allocator_args.h [edit]
[-] stl_queue.h [edit]
[-] gslice_array.h [edit]
[-] ptr_traits.h [edit]
[-] ranges_algo.h [edit]
[-] cxxabi_forced.h [edit]
[-] std_abs.h [edit]
[-] align.h [edit]
[-] regex_compiler.h [edit]
[-] stl_relops.h [edit]
[-] indirect_array.h [edit]
[-] regex_constants.h [edit]
[-] stl_bvector.h [edit]
[-] fs_ops.h [edit]
[-] parse_numbers.h [edit]
[-] shared_ptr_base.h [edit]
[-] c++0x_warning.h [edit]
[-] basic_string.tcc [edit]
[-] stl_deque.h [edit]
[-] ranges_uninitialized.h [edit]
[-] hashtable.h [edit]
[-] iterator_concepts.h [edit]
[-] stl_iterator_base_types.h [edit]
[-] locale_conv.h [edit]
[-] stl_pair.h [edit]
[-] shared_ptr_atomic.h [edit]
[-] ranges_util.h [edit]
[-] valarray_before.h [edit]
[-] stl_set.h [edit]
[-] stl_numeric.h [edit]
[-] locale_facets.h [edit]
[-] gslice.h [edit]
[-] shared_ptr.h [edit]
[-] ostream_insert.h [edit]
[-] fstream.tcc [edit]
[-] this_thread_sleep.h [edit]
[-] basic_ios.h [edit]
[-] allocated_ptr.h [edit]
[-] regex_compiler.tcc [edit]