The C and C++ Include Header Files

/usr/include/c++/11/bits/shared_ptr_atomic.h


$ cat -n /usr/include/c++/11/bits/shared_ptr_atomic.h

     1	// shared_ptr atomic access -*- C++ -*-
     2	
     3	// Copyright (C) 2014-2021 Free Software Foundation, Inc.
     4	//
     5	// This file is part of the GNU ISO C++ Library.  This library is free
     6	// software; you can redistribute it and/or modify it under the
     7	// terms of the GNU General Public License as published by the
     8	// Free Software Foundation; either version 3, or (at your option)
     9	// any later version.
    10	
    11	// This library is distributed in the hope that it will be useful,
    12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
    13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14	// GNU General Public License for more details.
    15	
    16	// Under Section 7 of GPL version 3, you are granted additional
    17	// permissions described in the GCC Runtime Library Exception, version
    18	// 3.1, as published by the Free Software Foundation.
    19	
    20	// You should have received a copy of the GNU General Public License and
    21	// a copy of the GCC Runtime Library Exception along with this program;
    22	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    23	// <http://www.gnu.org/licenses/>.
    24	
    25	/** @file bits/shared_ptr_atomic.h
    26	 *  This is an internal header file, included by other library headers.
    27	 *  Do not attempt to use it directly. @headername{memory}
    28	 */
    29	
    30	#ifndef _SHARED_PTR_ATOMIC_H
    31	#define _SHARED_PTR_ATOMIC_H 1
    32	
    33	#include <bits/atomic_base.h>
    34	
    35	namespace std _GLIBCXX_VISIBILITY(default)
    36	{
    37	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    38	
    39	  /**
    40	   * @addtogroup pointer_abstractions
    41	   * @{
    42	   */
    43	  /// @relates shared_ptr @{
    44	
    45	  /// @cond undocumented
    46	
    47	  struct _Sp_locker
    48	  {
    49	    _Sp_locker(const _Sp_locker&) = delete;
    50	    _Sp_locker& operator=(const _Sp_locker&) = delete;
    51	
    52	#ifdef __GTHREADS
    53	    explicit
    54	    _Sp_locker(const void*) noexcept;
    55	    _Sp_locker(const void*, const void*) noexcept;
    56	    ~_Sp_locker();
    57	
    58	  private:
    59	    unsigned char _M_key1;
    60	    unsigned char _M_key2;
    61	#else
    62	    explicit _Sp_locker(const void*, const void* = nullptr) { }
    63	#endif
    64	  };
    65	
    66	  /// @endcond
    67	
    68	  /**
    69	   *  @brief  Report whether shared_ptr atomic operations are lock-free.
    70	   *  @param  __p A non-null pointer to a shared_ptr object.
    71	   *  @return True if atomic access to @c *__p is lock-free, false otherwise.
    72	   *  @{
    73	  */
    74	  template<typename _Tp, _Lock_policy _Lp>
    75	    inline bool
    76	    atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
    77	    {
    78	#ifdef __GTHREADS
    79	      return __gthread_active_p() == 0;
    80	#else
    81	      return true;
    82	#endif
    83	    }
    84	
    85	  template<typename _Tp>
    86	    inline bool
    87	    atomic_is_lock_free(const shared_ptr<_Tp>* __p)
    88	    { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
    89	
    90	  /// @}
    91	
    92	  /**
    93	   *  @brief  Atomic load for shared_ptr objects.
    94	   *  @param  __p A non-null pointer to a shared_ptr object.
    95	   *  @return @c *__p
    96	   *
    97	   *  The memory order shall not be @c memory_order_release or
    98	   *  @c memory_order_acq_rel.
    99	   *  @{
   100	  */
   101	  template<typename _Tp>
   102	    inline shared_ptr<_Tp>
   103	    atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
   104	    {
   105	      _Sp_locker __lock{__p};
   106	      return *__p;
   107	    }
   108	
   109	  template<typename _Tp>
   110	    inline shared_ptr<_Tp>
   111	    atomic_load(const shared_ptr<_Tp>* __p)
   112	    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
   113	
   114	  template<typename _Tp, _Lock_policy _Lp>
   115	    inline __shared_ptr<_Tp, _Lp>
   116	    atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
   117	    {
   118	      _Sp_locker __lock{__p};
   119	      return *__p;
   120	    }
   121	
   122	  template<typename _Tp, _Lock_policy _Lp>
   123	    inline __shared_ptr<_Tp, _Lp>
   124	    atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
   125	    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
   126	  /// @}
   127	
   128	  /**
   129	   *  @brief  Atomic store for shared_ptr objects.
   130	   *  @param  __p A non-null pointer to a shared_ptr object.
   131	   *  @param  __r The value to store.
   132	   *
   133	   *  The memory order shall not be @c memory_order_acquire or
   134	   *  @c memory_order_acq_rel.
   135	   *  @{
   136	  */
   137	  template<typename _Tp>
   138	    inline void
   139	    atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
   140				  memory_order)
   141	    {
   142	      _Sp_locker __lock{__p};
   143	      __p->swap(__r); // use swap so that **__p not destroyed while lock held
   144	    }
   145	
   146	  template<typename _Tp>
   147	    inline void
   148	    atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
   149	    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
   150	
   151	  template<typename _Tp, _Lock_policy _Lp>
   152	    inline void
   153	    atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
   154				  __shared_ptr<_Tp, _Lp> __r,
   155				  memory_order)
   156	    {
   157	      _Sp_locker __lock{__p};
   158	      __p->swap(__r); // use swap so that **__p not destroyed while lock held
   159	    }
   160	
   161	  template<typename _Tp, _Lock_policy _Lp>
   162	    inline void
   163	    atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
   164	    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
   165	  /// @}
   166	
   167	  /**
   168	   *  @brief  Atomic exchange for shared_ptr objects.
   169	   *  @param  __p A non-null pointer to a shared_ptr object.
   170	   *  @param  __r New value to store in @c *__p.
   171	   *  @return The original value of @c *__p
   172	   *  @{
   173	  */
   174	  template<typename _Tp>
   175	    inline shared_ptr<_Tp>
   176	    atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
   177				     memory_order)
   178	    {
   179	      _Sp_locker __lock{__p};
   180	      __p->swap(__r);
   181	      return __r;
   182	    }
   183	
   184	  template<typename _Tp>
   185	    inline shared_ptr<_Tp>
   186	    atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
   187	    {
   188	      return std::atomic_exchange_explicit(__p, std::move(__r),
   189						   memory_order_seq_cst);
   190	    }
   191	
   192	  template<typename _Tp, _Lock_policy _Lp>
   193	    inline __shared_ptr<_Tp, _Lp>
   194	    atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
   195				     __shared_ptr<_Tp, _Lp> __r,
   196				     memory_order)
   197	    {
   198	      _Sp_locker __lock{__p};
   199	      __p->swap(__r);
   200	      return __r;
   201	    }
   202	
   203	  template<typename _Tp, _Lock_policy _Lp>
   204	    inline __shared_ptr<_Tp, _Lp>
   205	    atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
   206	    {
   207	      return std::atomic_exchange_explicit(__p, std::move(__r),
   208						   memory_order_seq_cst);
   209	    }
   210	  /// @}
   211	
   212	  /**
   213	   *  @brief  Atomic compare-and-swap for shared_ptr objects.
   214	   *  @param  __p A non-null pointer to a shared_ptr object.
   215	   *  @param  __v A non-null pointer to a shared_ptr object.
   216	   *  @param  __w A non-null pointer to a shared_ptr object.
   217	   *  @return True if @c *__p was equivalent to @c *__v, false otherwise.
   218	   *
   219	   *  The memory order for failure shall not be @c memory_order_release or
   220	   *  @c memory_order_acq_rel, or stronger than the memory order for success.
   221	   *  @{
   222	  */
   223	  template<typename _Tp>
   224	    bool
   225	    atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
   226						    shared_ptr<_Tp>* __v,
   227						    shared_ptr<_Tp> __w,
   228						    memory_order,
   229						    memory_order)
   230	    {
   231	      shared_ptr<_Tp> __x; // goes out of scope after __lock
   232	      _Sp_locker __lock{__p, __v};
   233	      owner_less<shared_ptr<_Tp>> __less;
   234	      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
   235		{
   236		  __x = std::move(*__p);
   237		  *__p = std::move(__w);
   238		  return true;
   239		}
   240	      __x = std::move(*__v);
   241	      *__v = *__p;
   242	      return false;
   243	    }
   244	
   245	  template<typename _Tp>
   246	    inline bool
   247	    atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
   248					 shared_ptr<_Tp> __w)
   249	    {
   250	      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   251		  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
   252	    }
   253	
   254	  template<typename _Tp>
   255	    inline bool
   256	    atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
   257						  shared_ptr<_Tp>* __v,
   258						  shared_ptr<_Tp> __w,
   259						  memory_order __success,
   260						  memory_order __failure)
   261	    {
   262	      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   263		  std::move(__w), __success, __failure);
   264	    }
   265	
   266	  template<typename _Tp>
   267	    inline bool
   268	    atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
   269					 shared_ptr<_Tp> __w)
   270	    {
   271	      return std::atomic_compare_exchange_weak_explicit(__p, __v,
   272		  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
   273	    }
   274	
   275	  template<typename _Tp, _Lock_policy _Lp>
   276	    bool
   277	    atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
   278						    __shared_ptr<_Tp, _Lp>* __v,
   279						    __shared_ptr<_Tp, _Lp> __w,
   280						    memory_order,
   281						    memory_order)
   282	    {
   283	      __shared_ptr<_Tp, _Lp> __x; // goes out of scope after __lock
   284	      _Sp_locker __lock{__p, __v};
   285	      owner_less<__shared_ptr<_Tp, _Lp>> __less;
   286	      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
   287		{
   288		  __x = std::move(*__p);
   289		  *__p = std::move(__w);
   290		  return true;
   291		}
   292	      __x = std::move(*__v);
   293	      *__v = *__p;
   294	      return false;
   295	    }
   296	
   297	  template<typename _Tp, _Lock_policy _Lp>
   298	    inline bool
   299	    atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
   300					   __shared_ptr<_Tp, _Lp>* __v,
   301					   __shared_ptr<_Tp, _Lp> __w)
   302	    {
   303	      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   304		  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
   305	    }
   306	
   307	  template<typename _Tp, _Lock_policy _Lp>
   308	    inline bool
   309	    atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
   310						  __shared_ptr<_Tp, _Lp>* __v,
   311						  __shared_ptr<_Tp, _Lp> __w,
   312						  memory_order __success,
   313						  memory_order __failure)
   314	    {
   315	      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   316		  std::move(__w), __success, __failure);
   317	    }
   318	
   319	  template<typename _Tp, _Lock_policy _Lp>
   320	    inline bool
   321	    atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
   322					 __shared_ptr<_Tp, _Lp>* __v,
   323					 __shared_ptr<_Tp, _Lp> __w)
   324	    {
   325	      return std::atomic_compare_exchange_weak_explicit(__p, __v,
   326		  std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
   327	    }
   328	  /// @}
   329	
   330	  /// @} relates shared_ptr
   331	  /// @} group pointer_abstractions
   332	
   333	_GLIBCXX_END_NAMESPACE_VERSION
   334	} // namespace
   335	
   336	#endif // _SHARED_PTR_ATOMIC_H