shared_ptr
implementation.
The shared_ptr class template stores a pointer, usually obtained via new, and implements shared ownership semantics.
20.6.6.2 - Class template shared_ptr [util.smartptr.shared]
The standard deliberately doesn't require a reference-counted implementation, allowing other techniques such as a circular-linked-list.
At the time of writing the C++0x working paper doesn't mention how threads
affect shared_ptr, but it is likely to follow the existing practice set by
boost::shared_ptr
. The shared_ptr in libstdc++ is derived
from Boost's, so the same rules apply.
The interface of tr1::shared_ptr
was extended for C++0x with
support for rvalue-references and the other features from N2351. As
with other libstdc++ headers shared by TR1 and C++0x, boost_shared_ptr.h
uses conditional compilation, based on the macros _GLIBCXX_INCLUDE_AS_CXX0X
and _GLIBCXX_INCLUDE_AS_TR1, to enable and disable features.
C++0x-only features are: rvalue-ref/move support, allocator support, aliasing constructor, make_shared & allocate_shared. Additionally, the constructors taking auto_ptr parameters are deprecated in C++0x mode.
The Thread Safety section of the Boost shared_ptr documentation says "shared_ptr objects offer the same level of thread safety as built-in types." The implementation must ensure that concurrent updates to separate shared_ptr instances are correct even when those instances share a reference count e.g.
shared_ptr<A> a(new A); shared_ptr<A> b(a); // Thread 1 // Thread 2 a.reset(); b.reset();
The dynamically-allocated object must be destroyed by exactly one of the threads. Weak references make things even more interesting. The shared state used to implement shared_ptr must be transparent to the user and invariants must be preserved at all times. The key pieces of shared state are the strong and weak reference counts. Updates to these need to be atomic and visible to all threads to ensure correct cleanup of the managed resource (which is, after all, shared_ptr's job!) On multi-processor systems memory synchronisation may be needed so that reference-count updates and the destruction of the managed resource are race-free.
The function _Sp_counted_base::_M_add_ref_lock()
, called when
obtaining a shared_ptr from a weak_ptr, has to test if the managed
resource still exists and either increment the reference count or throw
std::bad_weak_ptr
.
In a multi-threaded program there is a potential race condition if the last
reference is dropped (and the managed resource destroyed) between testing
the reference count and incrementing it, which could result in a shared_ptr
pointing to invalid memory.
The Boost shared_ptr (as used in GCC) features a clever lock-free algorithm to avoid the race condition, but this relies on the processor supporting an atomic Compare-And-Swap instruction. For other platforms there are fall-backs using mutex locks. Boost (as of version 1.35) includes several different implementations and the preprocessor selects one based on the compiler, standard library, platform etc. For the version of shared_ptr in libstdc++ the compiler and library are fixed, which makes things much simpler: we have an atomic CAS or we don't, see Lock Policy below for details.
The shared_ptr code in libstdc++ was kindly donated to GCC by the Boost project and the original authors of the code. The basic design and algorithms are from Boost, the notes below describe details specific to the GCC implementation. Names have been uglified in this implementation, but the design should be recognisable to anyone familiar with the Boost 1.32 shared_ptr.
The basic design is an abstract base class, _Sp_counted_base
that
does the reference-counting and calls virtual functions when the count
drops to zero.
Derived classes override those functions to destroy resources in a context
where the correct dynamic type is known. This is an application of the
technique known as type erasure.
The classes derived from _Sp_counted_base
(see Class Hierarchy
below) and __shared_count
are implemented separately for C++0x
and TR1, in bits/boost_sp_shared_count.h and
tr1/boost_sp_shared_count.h respectively. All other classes
including _Sp_counted_base
are shared by both implementations.
The TR1 implementation is considered relatively stable, so is unlikely to change unless bug fixes require it to. If the code that is common to both C++0x and TR1 modes needs to diverge further then it might be necessary to duplicate additional classes and only make changes to the C++0x versions.
Libstdc++ has a single _Sp_counted_base
class, which is a
template parameterized on the enum __gnu_cxx::_Lock_policy
.
The entire family of classes is parameterized on the lock policy, right up
to __shared_ptr
, __weak_ptr
and
__enable_shared_from_this
. The actual
std::shared_ptr
class inherits from __shared_ptr
with the lock policy parameter selected automatically based on the thread
model and platform that libstdc++ is configured for, so that the best
available template specialization will be used. This design is necessary
because it would not be conforming for std::shared_ptr
to have
an extra template parameter, even if it had a default value.
The available policies are:
_S_Atomic
_S_Mutex
_S_Single
For all three policies, reference count increments and decrements are done via the functions in <ext/atomicity.h>, which detect if the program is multi-threaded. If only one thread of execution exists in the program then less expensive non-atomic operations are used.
A shared_ptr<T>
contains a pointer of type T*
and an object of type __shared_count
. The shared_count contains
a pointer of type _Sp_counted_base*
which points to the object
that maintains the reference-counts and destroys the managed resource.
_Sp_counted_base<Lp>
_Sp_counted_base_impl<Ptr, Deleter, Lp>
Ptr
and a deleter of type Deleter
. _Sp_deleter
is
used when the user doesn't supply a custom deleter. Unlike Boost's, this
default deleter is not "checked" because GCC already issues a warning if
delete
is used with an incomplete type.
This is the only derived type used by tr1::shared_ptr<Ptr>
and it is never used by std::shared_ptr
, which uses one of
the following types, depending on how the shared_ptr is constructed.
_Sp_counted_ptr<Ptr, Lp>
Ptr
,
which is passed to delete
when the last reference is dropped.
This is the simplest form and is used when there is no custom deleter or
allocator.
_Sp_counted_deleter<Ptr, Deleter, Alloc>
std::allocator
is used as the allocator.
_Sp_counted_ptr_inplace<Tp, Alloc, Lp>
allocate_shared
and make_shared
.
Contains aligned storage to hold an object of type Tp
,
which is constructed in-place with placement new
.
Has a variadic template constructor allowing any number of arguments to
be forwarded to Tp
's constructor.
Unlike the other _Sp_counted_* classes, this one is parameterized on the
type of object, not the type of pointer; this is purely a convenience
that simplifies the implementation slightly.
dynamic_pointer_cast
, static_pointer_cast
,
const_pointer_cast
enable_shared_from_this
enable_shared_from_this
comes straight from Boost.
There is an extra overload for __enable_shared_from_this
to
work smoothly with __shared_ptr<Tp, Lp>
using any lock
policy.
make_shared
, allocate_shared
make_shared
simply forwards to allocate_shared
with std::allocator
as the allocator.
Although these functions can be implemented non-intrusively using the
alias constructor, if they have access to the implementation then it is
possible to save storage and reduce the number of heap allocations. The
newly constructed object and the _Sp_counted_* can be allocated in a single
block and the standard says implementations are "encouraged, but not required,"
to do so. This implementation provides additional non-standard constructors
(selected with the type _Sp_make_shared_tag
) which create an
object of type _Sp_counted_ptr_inplace
to hold the new object.
The returned shared_ptr<A>
needs to know the address of the
new A
object embedded in the _Sp_counted_ptr_inplace
,
but it has no way to access it.
This implementation uses a "covert channel" to return the address of the
embedded object when get_deleter<_Sp_make_shared_tag>()
is called. Users should not try to use this.
As well as the extra constructors, this implementation also needs some
members of _Sp_counted_deleter to be protected where they could otherwise
be private.
Examples of use can be found in the testsuite, under testsuite/tr1/2_general_utilities/shared_ptr.
The resolution to C++ Standard Library issue 674, "shared_ptr interface changes for consistency with N1856" will need to be implemented after it is accepted into the working paper. Issue 743 might also require changes.
The _S_single policy uses atomics when used in MT code, because it uses the same dispatcher functions that check __gthread_active_p(). This could be addressed by providing template specialisations for some members of _Sp_counted_base<_S_single>.
Unlike Boost, this implementation does not use separate classes for the pointer+deleter and pointer+deleter+allocator cases in C++0x mode, combining both into _Sp_counted_deleter and using std::allocator when the user doesn't specify an allocator. If it was found to be beneficial an additional class could easily be added. With the current implementation, the _Sp_counted_deleter and __shared_count constructors taking a custom deleter but no allocator are technically redundant and could be removed, changing callers to always specify an allocator. If a separate pointer+deleter class was added the __shared_count constructor would be needed, so it has been kept for now.
The hack used to get the address of the managed object from _Sp_counted_ptr_inplace::_M_get_deleter() is accessible to users. This could be prevented if get_deleter<_Sp_make_shared_tag>() always returned NULL, since the hack only needs to work at a lower level, not in the public API. This wouldn't be difficult, but hasn't been done since there is no danger of accidental misuse: users already know they are relying on unsupported features if they refer to implementation details such as _Sp_make_shared_tag.
tr1::_Sp_deleter could be a private member of tr1::__shared_count but it would alter the ABI.
Exposing the alias constructor in TR1 mode could simplify the *_pointer_cast functions. Constructor could be private in TR1 mode, with the cast functions as friends.
The original authors of the Boost shared_ptr, which is really nice code to work with, Peter Dimov in particular for his help and invaluable advice on thread safety. Phillip Jordan and Paolo Carlini for the lock policy implementation.
N2351 Improving shared_ptr for C++0x, Revision 2 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2351.htm
N2456 C++ Standard Library Active Issues List (Revision R52) http://open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2456.html
N2461 Working Draft, Standard for Programming Language C++ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf
Boost C++ Libraries documentation - shared_ptr class template http://boost.org/libs/smart_ptr/shared_ptr.htm