libstdc++-v3/include/tr1_impl/boost_sp_counted_base.h

   1 // <tr1_impl/boost_sp_counted_base.h> -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2009 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 //  shared_count.hpp
  26 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
  27
  28 //  shared_ptr.hpp
  29 //  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
  30 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
  31
  32 //  weak_ptr.hpp
  33 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
  34
  35 //  enable_shared_from_this.hpp
  36 //  Copyright (C) 2002 Peter Dimov
  37
  38 // Distributed under the Boost Software License, Version 1.0. (See
  39 // accompanying file LICENSE_1_0.txt or copy at
  40 // http://www.boost.org/LICENSE_1_0.txt)
  41
  42 // GCC Note:  based on version 1.32.0 of the Boost library.
  43
  44 /** @file tr1_impl/boost_sp_counted_base.h
  45  *  This is an internal header file, included by other library headers.
  46  *  You should not attempt to use it directly.
  47  */
  48
  49
  50 namespace std
  51 {
  52 _GLIBCXX_BEGIN_NAMESPACE_TR1
  53
  54   class bad_weak_ptr : public std::exception
  55   {
  56   public:
  57     virtual char const*
  58     what() const throw()
  59 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
  60     { return "std::bad_weak_ptr"; }
  61 #else
  62     { return "tr1::bad_weak_ptr"; }
  63 #endif
  64   };
  65
  66   // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
  67   inline void
  68   __throw_bad_weak_ptr()
  69   {
  70 #if __EXCEPTIONS
  71     throw bad_weak_ptr();
  72 #else
  73     __builtin_abort();
  74 #endif
  75   }
  76
  77   using __gnu_cxx::_Lock_policy;
  78   using __gnu_cxx::__default_lock_policy;
  79   using __gnu_cxx::_S_single;
  80   using __gnu_cxx::_S_mutex;
  81   using __gnu_cxx::_S_atomic;
  82
  83   // Empty helper class except when the template argument is _S_mutex.
  84   template<_Lock_policy _Lp>
  85     class _Mutex_base
  86     {
  87     protected:
  88       // The atomic policy uses fully-fenced builtins, single doesn't care.
  89       enum { _S_need_barriers = 0 };
  90     };
  91
  92   template<>
  93     class _Mutex_base<_S_mutex>
  94     : public __gnu_cxx::__mutex
  95     {
  96     protected:
  97       // This policy is used when atomic builtins are not available.
  98       // The replacement atomic operations might not have the necessary
  99       // memory barriers.
 100       enum { _S_need_barriers = 1 };
 101     };
 102
 103   template<_Lock_policy _Lp = __default_lock_policy>
 104     class _Sp_counted_base
 105     : public _Mutex_base<_Lp>
 106     {
 107     public:
 108       _Sp_counted_base()
 109       : _M_use_count(1), _M_weak_count(1) { }
 110
 111       virtual
 112       ~_Sp_counted_base() // nothrow
 113       { }
 114
 115       // Called when _M_use_count drops to zero, to release the resources
 116       // managed by *this.
 117       virtual void
 118       _M_dispose() = 0; // nothrow
 119
 120       // Called when _M_weak_count drops to zero.
 121       virtual void
 122       _M_destroy() // nothrow
 123       { delete this; }
 124
 125       virtual void*
 126       _M_get_deleter(const std::type_info&) = 0;
 127
 128       void
 129       _M_add_ref_copy()
 130       { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
 131
 132       void
 133       _M_add_ref_lock();
 134
 135       void
 136       _M_release() // nothrow
 137       {
 138         if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 139           {
 140             _M_dispose();
 141             // There must be a memory barrier between dispose() and destroy()
 142             // to ensure that the effects of dispose() are observed in the
 143             // thread that runs destroy().
 144             // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
 145             if (_Mutex_base<_Lp>::_S_need_barriers)
 146               {
 147                 _GLIBCXX_READ_MEM_BARRIER;
 148                 _GLIBCXX_WRITE_MEM_BARRIER;
 149               }
 150
 151             if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
 152                                                        -1) == 1)
 153               _M_destroy();
 154           }
 155       }
 156
 157       void
 158       _M_weak_add_ref() // nothrow
 159       { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
 160
 161       void
 162       _M_weak_release() // nothrow
 163       {
 164         if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
 165           {
 166             if (_Mutex_base<_Lp>::_S_need_barriers)
 167               {
 168                 // See _M_release(),
 169                 // destroy() must observe results of dispose()
 170                 _GLIBCXX_READ_MEM_BARRIER;
 171                 _GLIBCXX_WRITE_MEM_BARRIER;
 172               }
 173             _M_destroy();
 174           }
 175       }
 176
 177       long
 178       _M_get_use_count() const // nothrow
 179       {
 180         // No memory barrier is used here so there is no synchronization
 181         // with other threads.
 182         return const_cast<const volatile _Atomic_word&>(_M_use_count);
 183       }
 184
 185     private:
 186       _Sp_counted_base(_Sp_counted_base const&);
 187       _Sp_counted_base& operator=(_Sp_counted_base const&);
 188
 189       _Atomic_word  _M_use_count;     // #shared
 190       _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
 191     };
 192
 193   template<>
 194     inline void
 195     _Sp_counted_base<_S_single>::
 196     _M_add_ref_lock()
 197     {
 198       if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
 199         {
 200           _M_use_count = 0;
 201           __throw_bad_weak_ptr();
 202         }
 203     }
 204
 205   template<>
 206     inline void
 207     _Sp_counted_base<_S_mutex>::
 208     _M_add_ref_lock()
 209     {
 210       __gnu_cxx::__scoped_lock sentry(*this);
 211       if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
 212         {
 213           _M_use_count = 0;
 214           __throw_bad_weak_ptr();
 215         }
 216     }
 217
 218   template<>
 219     inline void
 220     _Sp_counted_base<_S_atomic>::
 221     _M_add_ref_lock()
 222     {
 223       // Perform lock-free add-if-not-zero operation.
 224       _Atomic_word __count;
 225       do
 226         {
 227           __count = _M_use_count;
 228           if (__count == 0)
 229             __throw_bad_weak_ptr();
 230
 231           // Replace the current counter value with the old value + 1, as
 232           // long as it's not changed meanwhile.
 233         }
 234       while (!__sync_bool_compare_and_swap(&_M_use_count, __count,
 235                                            __count + 1));
 236     }
 237
 238 _GLIBCXX_END_NAMESPACE_TR1
 239 }