Subversion Repositories openrisc

         xml:id="std.util.memory.shared_ptr" xreflabel="shared_ptr">

      ISO C++

      shared_ptr

The shared_ptr class template stores a pointer, usually obtained via new,

and implements shared ownership semantics.

    The standard deliberately doesn't require a reference-counted

    implementation, allowing other techniques such as a

    circular-linked-list.

The shared_ptr code is 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.

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>

The base of the hierarchy is parameterized on the lock policy (see below.)

_Sp_counted_base doesn't depend on the type of pointer being managed,

it only maintains the reference counts and calls virtual functions when

the counts drop to zero. The managed object is destroyed when the last

strong reference is dropped, but the _Sp_counted_base itself must exist

until the last weak reference is dropped.

  _Sp_counted_base_impl<Ptr, Deleter, Lp>

Inherits from _Sp_counted_base and stores a pointer of type 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>

Inherits from _Sp_counted_base and stores a pointer of type 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>

Inherits from _Sp_counted_ptr and adds support for custom deleter and

allocator. Empty Base Optimization is used for the allocator. This class

is used even when the user only provides a custom deleter, in which case

allocator is used as the allocator.

  _Sp_counted_ptr_inplace<Tp, Alloc, Lp>

Used by 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.

C++11-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++11 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

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.

There is 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 shared_ptr to have an

extra template parameter, even if it had a default value.  The

available policies are:

       _S_Atomic

Selected when GCC supports a builtin atomic compare-and-swap operation

on the target processor (see Atomic

Builtins.)  The reference counts are maintained using a lock-free

algorithm and GCC's atomic builtins, which provide the required memory

synchronisation.

       _S_Mutex

The _Sp_counted_base specialization for this policy contains a mutex,

which is locked in add_ref_lock(). This policy is used when GCC's atomic

builtins aren't available so explicit memory barriers are needed in places.

       _S_Single

This policy uses a non-reentrant add_ref_lock() with no locking. It is

used when libstdc++ is built without --enable-threads.

       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.

  dynamic_pointer_cast, static_pointer_cast,

const_pointer_cast

As noted in N2351, these functions can be implemented non-intrusively using

the alias constructor.  However the aliasing constructor is only available

in C++11 mode, so in TR1 mode these casts rely on three non-standard

constructors in shared_ptr and __shared_ptr.

In C++11 mode these constructors and the related tag types are not needed.

  enable_shared_from_this

The clever overload to detect a base class of type

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,

      testsuite/20_util/shared_ptr

      and

      testsuite/20_util/weak_ptr.

      The shared_ptr atomic access

      clause in the C++11 standard is not implemented in GCC.

      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++11 mode, combining both into _Sp_counted_deleter and using

      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.

    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

      N2456

      N2461

      N2461