libstdc++-v3/include/bits/shared_ptr_atomic.h

   1 // shared_ptr atomic access -*- C++ -*-
   2
   3 // Copyright (C) 2014-2015 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
  44   struct _Sp_locker
  45   {
  46     _Sp_locker(const _Sp_locker&) = delete;
  47     _Sp_locker& operator=(const _Sp_locker&) = delete;
  48
  49 #ifdef __GTHREADS
  50     explicit
  51     _Sp_locker(const void*) noexcept;
  52     _Sp_locker(const void*, const void*) noexcept;
  53     ~_Sp_locker();
  54
  55   private:
  56     unsigned char _M_key1;
  57     unsigned char _M_key2;
  58 #else
  59     explicit _Sp_locker(const void*, const void* = nullptr) { }
  60 #endif
  61   };
  62
  63   /**
  64    *  @brief  Report whether shared_ptr atomic operations are lock-free.
  65    *  @param  __p A non-null pointer to a shared_ptr object.
  66    *  @return True if atomic access to @c *__p is lock-free, false otherwise.
  67    *  @{
  68   */
  69   template<typename _Tp, _Lock_policy _Lp>
  70     inline bool
  71     atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
  72     {
  73 #ifdef __GTHREADS
  74       return __gthread_active_p() == 0;
  75 #else
  76       return true;
  77 #endif
  78     }
  79
  80   template<typename _Tp>
  81     inline bool
  82     atomic_is_lock_free(const shared_ptr<_Tp>* __p)
  83     { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
  84
  85   // @}
  86
  87   /**
  88    *  @brief  Atomic load for shared_ptr objects.
  89    *  @param  __p A non-null pointer to a shared_ptr object.
  90    *  @return @c *__p
  91    *
  92    *  The memory order shall not be @c memory_order_release or
  93    *  @c memory_order_acq_rel.
  94    *  @{
  95   */
  96   template<typename _Tp>
  97     inline shared_ptr<_Tp>
  98     atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
  99     {
 100       _Sp_locker __lock{__p};
 101       return *__p;
 102     }
 103
 104   template<typename _Tp>
 105     inline shared_ptr<_Tp>
 106     atomic_load(const shared_ptr<_Tp>* __p)
 107     { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
 108
 109   template<typename _Tp, _Lock_policy _Lp>
 110     inline __shared_ptr<_Tp, _Lp>
 111     atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
 112     {
 113       _Sp_locker __lock{__p};
 114       return *__p;
 115     }
 116
 117   template<typename _Tp, _Lock_policy _Lp>
 118     inline __shared_ptr<_Tp, _Lp>
 119     atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
 120     { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
 121   // @}
 122
 123   /**
 124    *  @brief  Atomic store for shared_ptr objects.
 125    *  @param  __p A non-null pointer to a shared_ptr object.
 126    *  @param  __r The value to store.
 127    *
 128    *  The memory order shall not be @c memory_order_acquire or
 129    *  @c memory_order_acq_rel.
 130    *  @{
 131   */
 132   template<typename _Tp>
 133     inline void
 134     atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
 135                           memory_order)
 136     {
 137       _Sp_locker __lock{__p};
 138       __p->swap(__r); // use swap so that **__p not destroyed while lock held
 139     }
 140
 141   template<typename _Tp>
 142     inline void
 143     atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
 144     { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
 145
 146   template<typename _Tp, _Lock_policy _Lp>
 147     inline void
 148     atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
 149                           __shared_ptr<_Tp, _Lp> __r,
 150                           memory_order)
 151     {
 152       _Sp_locker __lock{__p};
 153       __p->swap(__r); // use swap so that **__p not destroyed while lock held
 154     }
 155
 156   template<typename _Tp, _Lock_policy _Lp>
 157     inline void
 158     atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
 159     { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
 160   // @}
 161
 162   /**
 163    *  @brief  Atomic exchange for shared_ptr objects.
 164    *  @param  __p A non-null pointer to a shared_ptr object.
 165    *  @param  __r New value to store in @c *__p.
 166    *  @return The original value of @c *__p
 167    *  @{
 168   */
 169   template<typename _Tp>
 170     inline shared_ptr<_Tp>
 171     atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
 172                              memory_order)
 173     {
 174       _Sp_locker __lock{__p};
 175       __p->swap(__r);
 176       return __r;
 177     }
 178
 179   template<typename _Tp>
 180     inline shared_ptr<_Tp>
 181     atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
 182     {
 183       return std::atomic_exchange_explicit(__p, std::move(__r),
 184                                            memory_order_seq_cst);
 185     }
 186
 187   template<typename _Tp, _Lock_policy _Lp>
 188     inline __shared_ptr<_Tp, _Lp>
 189     atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
 190                              __shared_ptr<_Tp, _Lp> __r,
 191                              memory_order)
 192     {
 193       _Sp_locker __lock{__p};
 194       __p->swap(__r);
 195       return __r;
 196     }
 197
 198   template<typename _Tp, _Lock_policy _Lp>
 199     inline __shared_ptr<_Tp, _Lp>
 200     atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
 201     {
 202       return std::atomic_exchange_explicit(__p, std::move(__r),
 203                                            memory_order_seq_cst);
 204     }
 205   // @}
 206
 207   /**
 208    *  @brief  Atomic compare-and-swap for shared_ptr objects.
 209    *  @param  __p A non-null pointer to a shared_ptr object.
 210    *  @param  __v A non-null pointer to a shared_ptr object.
 211    *  @param  __w A non-null pointer to a shared_ptr object.
 212    *  @return True if @c *__p was equivalent to @c *__v, false otherwise.
 213    *
 214    *  The memory order for failure shall not be @c memory_order_release or
 215    *  @c memory_order_acq_rel, or stronger than the memory order for success.
 216    *  @{
 217   */
 218   template<typename _Tp>
 219     bool
 220     atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
 221                                             shared_ptr<_Tp>* __v,
 222                                             shared_ptr<_Tp> __w,
 223                                             memory_order,
 224                                             memory_order)
 225     {
 226       shared_ptr<_Tp> __x; // goes out of scope after __lock
 227       _Sp_locker __lock{__p, __v};
 228       owner_less<shared_ptr<_Tp>> __less;
 229       if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 230         {
 231           __x = std::move(*__p);
 232           *__p = std::move(__w);
 233           return true;
 234         }
 235       __x = std::move(*__v);
 236       *__v = *__p;
 237       return false;
 238     }
 239
 240   template<typename _Tp>
 241     inline bool
 242     atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
 243                                  shared_ptr<_Tp> __w)
 244     {
 245       return std::atomic_compare_exchange_strong_explicit(__p, __v,
 246           std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
 247     }
 248
 249   template<typename _Tp>
 250     inline bool
 251     atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
 252                                           shared_ptr<_Tp>* __v,
 253                                           shared_ptr<_Tp> __w,
 254                                           memory_order __success,
 255                                           memory_order __failure)
 256     {
 257       return std::atomic_compare_exchange_strong_explicit(__p, __v,
 258           std::move(__w), __success, __failure);
 259     }
 260
 261   template<typename _Tp>
 262     inline bool
 263     atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
 264                                  shared_ptr<_Tp> __w)
 265     {
 266       return std::atomic_compare_exchange_weak_explicit(__p, __v,
 267           std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
 268     }
 269
 270   template<typename _Tp, _Lock_policy _Lp>
 271     bool
 272     atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
 273                                             __shared_ptr<_Tp, _Lp>* __v,
 274                                             __shared_ptr<_Tp, _Lp> __w,
 275                                             memory_order,
 276                                             memory_order)
 277     {
 278       __shared_ptr<_Tp, _Lp> __x; // goes out of scope after __lock
 279       _Sp_locker __lock{__p, __v};
 280       owner_less<__shared_ptr<_Tp, _Lp>> __less;
 281       if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 282         {
 283           __x = std::move(*__p);
 284           *__p = std::move(__w);
 285           return true;
 286         }
 287       __x = std::move(*__v);
 288       *__v = *__p;
 289       return false;
 290     }
 291
 292   template<typename _Tp, _Lock_policy _Lp>
 293     inline bool
 294     atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
 295                                    __shared_ptr<_Tp, _Lp>* __v,
 296                                    __shared_ptr<_Tp, _Lp> __w)
 297     {
 298       return std::atomic_compare_exchange_strong_explicit(__p, __v,
 299           std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
 300     }
 301
 302   template<typename _Tp, _Lock_policy _Lp>
 303     inline bool
 304     atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
 305                                           __shared_ptr<_Tp, _Lp>* __v,
 306                                           __shared_ptr<_Tp, _Lp> __w,
 307                                           memory_order __success,
 308                                           memory_order __failure)
 309     {
 310       return std::atomic_compare_exchange_strong_explicit(__p, __v,
 311           std::move(__w), __success, __failure);
 312     }
 313
 314   template<typename _Tp, _Lock_policy _Lp>
 315     inline bool
 316     atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
 317                                  __shared_ptr<_Tp, _Lp>* __v,
 318                                  __shared_ptr<_Tp, _Lp> __w)
 319     {
 320       return std::atomic_compare_exchange_weak_explicit(__p, __v,
 321           std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
 322     }
 323   // @}
 324
 325   // @} group pointer_abstractions
 326
 327 _GLIBCXX_END_NAMESPACE_VERSION
 328 } // namespace
 329
 330 #endif // _SHARED_PTR_ATOMIC_H