libstdc++
boost_sp_counted_base.h
Go to the documentation of this file.
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 }