Ticket #6829: make_shared_perf.patch

File make_shared_perf.patch, 59.2 KB (added by mt.wizard@…, 10 years ago)

More optimal implementation of make_shared: don't use RTTI and don't store exptra pointer to allocated object as its position is know without it

  • boost/smart_ptr/detail/shared_count.hpp 

    diff --git boost/smart_ptr/detail/shared_count.hpp boost/smart_ptr/detail/shared_count.hpp
index f96a220..ff8e8a4 100644
    public:  
    7979    {
    8080    }
    8181
     82    shared_count(sp_counted_base* counter): pi_(counter) // nothrow
     83#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
     84       , id_(shared_count_id)
     85#endif
     86    {
     87    }
     88
    8289    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
    8390#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
    8491        , id_(shared_count_id)

  • new file oost/smart_ptr/detail/sp_counted_impl_ms.hpp 

    diff --git boost/smart_ptr/detail/sp_counted_impl_ms.hpp boost/smart_ptr/detail/sp_counted_impl_ms.hpp
new file mode 100644
index 0000000..634f8b9
    - +  
     1#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_MS_HPP_INCLUDED
     2#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_MS_HPP_INCLUDED
     3
     4// MS compatible compilers support #pragma once
     5
     6#if defined(_MSC_VER) && (_MSC_VER >= 1020)
     7# pragma once
     8#endif
     9
     10#include <boost/smart_ptr/detail/sp_counted_base.hpp>
     11#include <boost/aligned_storage.hpp>
     12#include <boost/type_traits/alignment_of.hpp>
     13
     14namespace boost
     15{
     16
     17namespace detail
     18{
     19
     20template <class T>
     21class sp_counted_base_ms : public sp_counted_base
     22{
     23public:
     24   T* get_pointer()
     25   {
     26      return reinterpret_cast<T*>(p_.address());
     27   }
     28
     29   virtual void dispose() // nothrow
     30   {
     31      get_pointer()->~T();
     32   }
     33
     34   virtual void* get_deleter(detail::sp_typeinfo const &)
     35   {
     36      return NULL;
     37   }
     38
     39private:
     40   typedef boost::aligned_storage<sizeof(T), boost::alignment_of<T>::value> storage_t;
     41   storage_t p_;
     42};
     43
     44template <class T>
     45class sp_counted_impl_ms : public sp_counted_base_ms<T>
     46{
     47};
     48
     49template <class T, class A>
     50class sp_counted_impl_ms_a : public sp_counted_base_ms<T>, private A // use empty base optimization
     51{
     52public:
     53   sp_counted_impl_ms_a(A a) : A(a) // can throw if A's copy ctor throws
     54   {
     55   }
     56
     57   virtual void destroy()
     58   {
     59      typename A::template rebind<sp_counted_impl_ms_a>::other a2(static_cast<A&>(*this));
     60      this->sp_counted_impl_ms_a::~sp_counted_impl_ms_a();
     61      a2.deallocate(this, 1);
     62   }
     63};
     64
     65} // namespace boost::detail
     66
     67} // namespace boost
     68
     69#endif // BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_MS_HPP_INCLUDED

  • boost/smart_ptr/make_shared.hpp 

    diff --git boost/smart_ptr/make_shared.hpp boost/smart_ptr/make_shared.hpp
index 7b605e2..95c8180 100644
     
    11#ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
    22#define BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
    33
    4 //  make_shared.hpp
    5 //
    6 //  Copyright (c) 2007, 2008 Peter Dimov
    7 //
    8 //  Distributed under the Boost Software License, Version 1.0.
    9 //  See accompanying file LICENSE_1_0.txt or copy at
    10 //  http://www.boost.org/LICENSE_1_0.txt
    11 //
    12 //  See http://www.boost.org/libs/smart_ptr/make_shared.html
    13 //  for documentation.
     4// MS compatible compilers support #pragma once
     5
     6#if defined( _MSC_VER ) && ( _MSC_VER >= 1020 )
     7# pragma once
     8#endif
    149
    1510#include <boost/config.hpp>
    1611#include <boost/smart_ptr/shared_ptr.hpp>
    17 #include <boost/type_traits/type_with_alignment.hpp>
    18 #include <boost/type_traits/alignment_of.hpp>
    19 #include <cstddef>
     12#include <boost/smart_ptr/detail/sp_counted_impl_ms.hpp>
     13#include <boost/throw_exception.hpp>
     14#include <boost/noncopyable.hpp>
     15
     16#include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
     17#include <exception> // std::bad_alloc
    2018#include <new>
    2119
    2220namespace boost
    … … namespace boost  
    2523namespace detail
    2624{
    2725
    28 template< std::size_t N, std::size_t A > struct sp_aligned_storage
    29 {
    30     union type
    31     {
    32         char data_[ N ];
    33         typename boost::type_with_alignment< A >::type align_;
    34     };
    35 };
     26#ifdef BOOST_NO_EXCEPTIONS
    3627
    37 template< class T > class sp_ms_deleter
     28template <class T>
     29void verify_allocation(T* p)
    3830{
    39 private:
    40 
    41     typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
    42 
    43     bool initialized_;
    44     storage_type storage_;
    45 
    46 private:
    47 
    48     void destroy()
    49     {
    50         if( initialized_ )
    51         {
    52 #if defined( __GNUC__ )
    53 
    54             // fixes incorrect aliasing warning
    55             T * p = reinterpret_cast< T* >( storage_.data_ );
    56             p->~T();
     31   if (!p)
     32   {
     33      boost::throw_exception(std::bad_alloc());
     34   }
     35}
    5736
    5837#else
    5938
    60             reinterpret_cast< T* >( storage_.data_ )->~T();
     39template <class T>
     40void verify_allocation(T*) {}
    6141
    62 #endif
     42#endif // BOOST_NO_EXCEPTIONS
    6343
    64             initialized_ = false;
    65         }
    66     }
     44// scoped holder of sp counter object allocated with custom allocator
     45template <class SpCounter, class Alloc>
     46class scoped_sp_counter : private boost::noncopyable
     47{
     48   typedef typename Alloc::template rebind<SpCounter>::other sp_counter_alloc_t;
    6749
    6850public:
     51   scoped_sp_counter(const Alloc& a) : a_(a)
     52   {
     53      p_ = a_.allocate(1, NULL);
     54      boost::detail::verify_allocation(p_);
     55      new (p_) SpCounter(a); // nothrow if a's copy ctor doesn't throw
     56   }
     57
     58   ~scoped_sp_counter()
     59   {
     60      if (p_)
     61      {
     62         p_->~SpCounter();
     63         a_.deallocate(p_, 1);
     64      }
     65   }
     66
     67   SpCounter* operator->() const { return p_; }
     68   SpCounter* release() { SpCounter* released = p_; p_ = NULL; return released; }
    6969
    70     sp_ms_deleter(): initialized_( false )
    71     {
    72     }
    73 
    74     // optimization: do not copy storage_
    75     sp_ms_deleter( sp_ms_deleter const & ): initialized_( false )
    76     {
    77     }
    78 
    79     ~sp_ms_deleter()
    80     {
    81         destroy();
    82     }
    83 
    84     void operator()( T * )
    85     {
    86         destroy();
    87     }
    88 
    89     void * address()
    90     {
    91         return storage_.data_;
    92     }
    93 
    94     void set_initialized()
    95     {
    96         initialized_ = true;
    97     }
     70private:
     71   SpCounter* p_;
     72   sp_counter_alloc_t a_;
    9873};
    9974
    100 #if defined( BOOST_HAS_RVALUE_REFS )
     75} // namespace boost::detail
    10176
    102 template< class T > T&& sp_forward( T & t )
    103 {
    104     return static_cast< T&& >( t );
    105 }
    106 
    107 #endif
    108 
    109 } // namespace detail
    110 
    111 #if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
    112 # define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
    113 #else
    114 # define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
    115 #endif
    11677
    117 // Zero-argument versions
    118 //
    119 // Used even when variadic templates are available because of the new T() vs new T issue
    120 
    121 template< class T > boost::shared_ptr< T > make_shared()
     78template <class T>
     79boost::shared_ptr<T> make_shared()
    12280{
    123     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    124 
    125     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    126 
    127     void * pv = pd->address();
    128 
    129     ::new( pv ) T();
    130     pd->set_initialized();
    131 
    132     T * pt2 = static_cast< T* >( pv );
    133 
    134     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    135     return boost::shared_ptr< T >( pt, pt2 );
     81   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     82   boost::detail::verify_allocation(counter.get());
     83   ::new (counter->get_pointer()) T();
     84   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     85   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    13686}
    13787
    138 template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
     88template <class T, class A>
     89boost::shared_ptr<T> allocate_shared(A const & a)
    13990{
    140     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    141 
    142     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    143 
    144     void * pv = pd->address();
    145 
    146     ::new( pv ) T();
    147     pd->set_initialized();
    148 
    149     T * pt2 = static_cast< T* >( pv );
    150 
    151     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    152     return boost::shared_ptr< T >( pt, pt2 );
     91   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     92   ::new (counter->get_pointer()) T();
     93   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     94   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    15395}
    15496
    155 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
    156 
    157 // Variadic templates, rvalue reference
     97#if defined(BOOST_HAS_VARIADIC_TMPL) && defined(BOOST_HAS_RVALUE_REFS)
    15898
    159 template< class T, class Arg1, class... Args > boost::shared_ptr< T > make_shared( Arg1 && arg1, Args && ... args )
     99template <class T, class Arg1, class... Args>
     100boost::shared_ptr<T> make_shared(Arg1&& arg1, Args&&... args)
    160101{
    161     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    162 
    163     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    164 
    165     void * pv = pd->address();
    166 
    167     ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
    168     pd->set_initialized();
    169 
    170     T * pt2 = static_cast< T* >( pv );
    171 
    172     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    173     return boost::shared_ptr< T >( pt, pt2 );
     102   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     103   boost::detail::verify_allocation(counter.get());
     104   ::new (counter->get_pointer()) T(std::forward<Arg1>(arg1), std::forward<Args>(args)...);
     105   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     106   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    174107}
    175108
    176 template< class T, class A, class Arg1, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Arg1 && arg1, Args && ... args )
     109template <class T, class A, class Arg1, class... Args>
     110boost::shared_ptr<T> allocate_shared(A const & a, Arg1&& arg1, Args&&... args)
    177111{
    178     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    179 
    180     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    181 
    182     void * pv = pd->address();
    183 
    184     ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
    185     pd->set_initialized();
    186 
    187     T * pt2 = static_cast< T* >( pv );
    188 
    189     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    190     return boost::shared_ptr< T >( pt, pt2 );
     112   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     113   ::new (counter->get_pointer()) T(std::forward<Arg1>(arg1), std::forward<Args>(args)...);
     114   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     115   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    191116}
    192117
    193 #elif defined( BOOST_HAS_RVALUE_REFS )
     118#elif defined(BOOST_HAS_RVALUE_REFS)
    194119
    195 // For example MSVC 10.0
    196 
    197 template< class T, class A1 >
    198 boost::shared_ptr< T > make_shared( A1 && a1 )
     120template <class T, class A1>
     121boost::shared_ptr<T> make_shared(A1&& a1)
    199122{
    200     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    201 
    202     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    203 
    204     void * pv = pd->address();
    205 
    206     ::new( pv ) T(
    207         boost::detail::sp_forward<A1>( a1 )
    208         );
    209 
    210     pd->set_initialized();
    211 
    212     T * pt2 = static_cast< T* >( pv );
    213 
    214     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    215     return boost::shared_ptr< T >( pt, pt2 );
     123   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     124   boost::detail::verify_allocation(counter.get());
     125   ::new (counter->get_pointer()) T(std::forward<A1>(a1));
     126   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     127   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    216128}
    217129
    218 template< class T, class A, class A1 >
    219 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1 )
     130template <class T, class A1, class A2>
     131boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2)
    220132{
    221     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    222 
    223     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    224 
    225     void * pv = pd->address();
    226 
    227     ::new( pv ) T(
    228         boost::detail::sp_forward<A1>( a1 )
    229         );
    230 
    231     pd->set_initialized();
    232 
    233     T * pt2 = static_cast< T* >( pv );
    234 
    235     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    236     return boost::shared_ptr< T >( pt, pt2 );
     133   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     134   boost::detail::verify_allocation(counter.get());
     135   ::new (counter->get_pointer()) T(
     136      std::forward<A1>(a1), std::forward<A2>(a2));
     137   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     138   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    237139}
    238140
    239 template< class T, class A1, class A2 >
    240 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2 )
     141template <class T, class A1, class A2, class A3>
     142boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2, A3&& a3)
    241143{
    242     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    243 
    244     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    245 
    246     void * pv = pd->address();
    247 
    248     ::new( pv ) T(
    249         boost::detail::sp_forward<A1>( a1 ),
    250         boost::detail::sp_forward<A2>( a2 )
    251         );
    252 
    253     pd->set_initialized();
    254 
    255     T * pt2 = static_cast< T* >( pv );
    256 
    257     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    258     return boost::shared_ptr< T >( pt, pt2 );
     144   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     145   boost::detail::verify_allocation(counter.get());
     146   ::new (counter->get_pointer()) T(
     147      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3));
     148   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     149   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    259150}
    260151
    261 template< class T, class A, class A1, class A2 >
    262 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2 )
     152template <class T, class A1, class A2, class A3, class A4>
     153boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2, A3&& a3, A4&& a4)
    263154{
    264     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    265 
    266     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    267 
    268     void * pv = pd->address();
    269 
    270     ::new( pv ) T(
    271         boost::detail::sp_forward<A1>( a1 ),
    272         boost::detail::sp_forward<A2>( a2 )
    273         );
    274 
    275     pd->set_initialized();
    276 
    277     T * pt2 = static_cast< T* >( pv );
    278 
    279     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    280     return boost::shared_ptr< T >( pt, pt2 );
     155   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     156   boost::detail::verify_allocation(counter.get());
     157   ::new (counter->get_pointer()) T(
     158      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     159      std::forward<A4>(a4));
     160   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     161   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    281162}
    282163
    283 template< class T, class A1, class A2, class A3 >
    284 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3 )
     164template <class T, class A1, class A2, class A3, class A4, class A5>
     165boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5)
    285166{
    286     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    287 
    288     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    289 
    290     void * pv = pd->address();
    291 
    292     ::new( pv ) T(
    293         boost::detail::sp_forward<A1>( a1 ),
    294         boost::detail::sp_forward<A2>( a2 ),
    295         boost::detail::sp_forward<A3>( a3 )
    296         );
    297 
    298     pd->set_initialized();
    299 
    300     T * pt2 = static_cast< T* >( pv );
    301 
    302     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    303     return boost::shared_ptr< T >( pt, pt2 );
     167   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     168   boost::detail::verify_allocation(counter.get());
     169   ::new (counter->get_pointer()) T(
     170      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     171      std::forward<A4>(a4), std::forward<A5>(a5));
     172   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     173   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    304174}
    305175
    306 template< class T, class A, class A1, class A2, class A3 >
    307 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3 )
     176template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
     177boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6)
    308178{
    309     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    310 
    311     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    312 
    313     void * pv = pd->address();
    314 
    315     ::new( pv ) T(
    316         boost::detail::sp_forward<A1>( a1 ),
    317         boost::detail::sp_forward<A2>( a2 ),
    318         boost::detail::sp_forward<A3>( a3 )
    319         );
    320 
    321     pd->set_initialized();
    322 
    323     T * pt2 = static_cast< T* >( pv );
    324 
    325     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    326     return boost::shared_ptr< T >( pt, pt2 );
     179   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     180   boost::detail::verify_allocation(counter.get());
     181   ::new (counter->get_pointer()) T(
     182      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     183      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6));
     184   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     185   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    327186}
    328187
    329 template< class T, class A1, class A2, class A3, class A4 >
    330 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
     188template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     189boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7)
    331190{
    332     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    333 
    334     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    335 
    336     void * pv = pd->address();
    337 
    338     ::new( pv ) T(
    339         boost::detail::sp_forward<A1>( a1 ),
    340         boost::detail::sp_forward<A2>( a2 ),
    341         boost::detail::sp_forward<A3>( a3 ),
    342         boost::detail::sp_forward<A4>( a4 )
    343         );
    344 
    345     pd->set_initialized();
    346 
    347     T * pt2 = static_cast< T* >( pv );
    348 
    349     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    350     return boost::shared_ptr< T >( pt, pt2 );
     191   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     192   boost::detail::verify_allocation(counter.get());
     193   ::new (counter->get_pointer()) T(
     194      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     195      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6),
     196      std::forward<A7>(a7));
     197   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     198   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    351199}
    352200
    353 template< class T, class A, class A1, class A2, class A3, class A4 >
    354 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
     201template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     202boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8)
    355203{
    356     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    357 
    358     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    359 
    360     void * pv = pd->address();
    361 
    362     ::new( pv ) T(
    363         boost::detail::sp_forward<A1>( a1 ),
    364         boost::detail::sp_forward<A2>( a2 ),
    365         boost::detail::sp_forward<A3>( a3 ),
    366         boost::detail::sp_forward<A4>( a4 )
    367         );
    368 
    369     pd->set_initialized();
    370 
    371     T * pt2 = static_cast< T* >( pv );
    372 
    373     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    374     return boost::shared_ptr< T >( pt, pt2 );
     204   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     205   boost::detail::verify_allocation(counter.get());
     206   ::new (counter->get_pointer()) T(
     207      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     208      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6),
     209      std::forward<A7>(a7), std::forward<A8>(a8));
     210   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     211   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    375212}
    376213
    377 template< class T, class A1, class A2, class A3, class A4, class A5 >
    378 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
     214template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     215boost::shared_ptr<T> make_shared(A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9)
    379216{
    380     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    381 
    382     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    383 
    384     void * pv = pd->address();
    385 
    386     ::new( pv ) T(
    387         boost::detail::sp_forward<A1>( a1 ),
    388         boost::detail::sp_forward<A2>( a2 ),
    389         boost::detail::sp_forward<A3>( a3 ),
    390         boost::detail::sp_forward<A4>( a4 ),
    391         boost::detail::sp_forward<A5>( a5 )
    392         );
    393 
    394     pd->set_initialized();
    395 
    396     T * pt2 = static_cast< T* >( pv );
    397 
    398     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    399     return boost::shared_ptr< T >( pt, pt2 );
     217   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     218   boost::detail::verify_allocation(counter.get());
     219   ::new (counter->get_pointer()) T(
     220      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     221      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6),
     222      std::forward<A7>(a7), std::forward<A8>(a8), std::forward<A9>(a9));
     223   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     224   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    400225}
    401226
    402 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
    403 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
     227template <class T, class A, class A1>
     228boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1)
    404229{
    405     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    406 
    407     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    408 
    409     void * pv = pd->address();
    410 
    411     ::new( pv ) T(
    412         boost::detail::sp_forward<A1>( a1 ),
    413         boost::detail::sp_forward<A2>( a2 ),
    414         boost::detail::sp_forward<A3>( a3 ),
    415         boost::detail::sp_forward<A4>( a4 ),
    416         boost::detail::sp_forward<A5>( a5 )
    417         );
    418 
    419     pd->set_initialized();
    420 
    421     T * pt2 = static_cast< T* >( pv );
    422 
    423     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    424     return boost::shared_ptr< T >( pt, pt2 );
     230   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     231   ::new (counter->get_pointer()) T(std::forward<A1>(a1));
     232   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     233   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    425234}
    426235
    427 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
    428 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
     236template <class T, class A, class A1, class A2>
     237boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2)
    429238{
    430     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    431 
    432     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    433 
    434     void * pv = pd->address();
    435 
    436     ::new( pv ) T(
    437         boost::detail::sp_forward<A1>( a1 ),
    438         boost::detail::sp_forward<A2>( a2 ),
    439         boost::detail::sp_forward<A3>( a3 ),
    440         boost::detail::sp_forward<A4>( a4 ),
    441         boost::detail::sp_forward<A5>( a5 ),
    442         boost::detail::sp_forward<A6>( a6 )
    443         );
    444 
    445     pd->set_initialized();
    446 
    447     T * pt2 = static_cast< T* >( pv );
    448 
    449     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    450     return boost::shared_ptr< T >( pt, pt2 );
     239   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     240   ::new (counter->get_pointer()) T(
     241      std::forward<A1>(a1), std::forward<A2>(a2));
     242   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     243   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    451244}
    452245
    453 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
    454 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
     246template <class T, class A, class A1, class A2, class A3>
     247boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2, A3&& a3)
    455248{
    456     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    457 
    458     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    459 
    460     void * pv = pd->address();
    461 
    462     ::new( pv ) T(
    463         boost::detail::sp_forward<A1>( a1 ),
    464         boost::detail::sp_forward<A2>( a2 ),
    465         boost::detail::sp_forward<A3>( a3 ),
    466         boost::detail::sp_forward<A4>( a4 ),
    467         boost::detail::sp_forward<A5>( a5 ),
    468         boost::detail::sp_forward<A6>( a6 )
    469         );
    470 
    471     pd->set_initialized();
    472 
    473     T * pt2 = static_cast< T* >( pv );
    474 
    475     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    476     return boost::shared_ptr< T >( pt, pt2 );
     249   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     250   ::new (counter->get_pointer()) T(
     251      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3));
     252   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     253   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    477254}
    478255
    479 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
    480 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
     256template <class T, class A, class A1, class A2, class A3, class A4>
     257boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2, A3&& a3, A4&& a4)
    481258{
    482     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    483 
    484     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    485 
    486     void * pv = pd->address();
    487 
    488     ::new( pv ) T(
    489         boost::detail::sp_forward<A1>( a1 ),
    490         boost::detail::sp_forward<A2>( a2 ),
    491         boost::detail::sp_forward<A3>( a3 ),
    492         boost::detail::sp_forward<A4>( a4 ),
    493         boost::detail::sp_forward<A5>( a5 ),
    494         boost::detail::sp_forward<A6>( a6 ),
    495         boost::detail::sp_forward<A7>( a7 )
    496         );
    497 
    498     pd->set_initialized();
    499 
    500     T * pt2 = static_cast< T* >( pv );
    501 
    502     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    503     return boost::shared_ptr< T >( pt, pt2 );
     259   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     260   ::new (counter->get_pointer()) T(
     261      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     262      std::forward<A4>(a4));
     263   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     264   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    504265}
    505266
    506 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
    507 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
     267template <class T, class A, class A1, class A2, class A3, class A4, class A5>
     268boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5)
    508269{
    509     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    510 
    511     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    512 
    513     void * pv = pd->address();
    514 
    515     ::new( pv ) T(
    516         boost::detail::sp_forward<A1>( a1 ),
    517         boost::detail::sp_forward<A2>( a2 ),
    518         boost::detail::sp_forward<A3>( a3 ),
    519         boost::detail::sp_forward<A4>( a4 ),
    520         boost::detail::sp_forward<A5>( a5 ),
    521         boost::detail::sp_forward<A6>( a6 ),
    522         boost::detail::sp_forward<A7>( a7 )
    523         );
    524 
    525     pd->set_initialized();
    526 
    527     T * pt2 = static_cast< T* >( pv );
    528 
    529     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    530     return boost::shared_ptr< T >( pt, pt2 );
     270   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     271   ::new (counter->get_pointer()) T(
     272      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     273      std::forward<A4>(a4), std::forward<A5>(a5));
     274   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     275   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    531276}
    532277
    533 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
    534 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
     278template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6>
     279boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6)
    535280{
    536     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    537 
    538     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    539 
    540     void * pv = pd->address();
    541 
    542     ::new( pv ) T(
    543         boost::detail::sp_forward<A1>( a1 ),
    544         boost::detail::sp_forward<A2>( a2 ),
    545         boost::detail::sp_forward<A3>( a3 ),
    546         boost::detail::sp_forward<A4>( a4 ),
    547         boost::detail::sp_forward<A5>( a5 ),
    548         boost::detail::sp_forward<A6>( a6 ),
    549         boost::detail::sp_forward<A7>( a7 ),
    550         boost::detail::sp_forward<A8>( a8 )
    551         );
    552 
    553     pd->set_initialized();
    554 
    555     T * pt2 = static_cast< T* >( pv );
    556 
    557     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    558     return boost::shared_ptr< T >( pt, pt2 );
     281   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     282   ::new (counter->get_pointer()) T(
     283      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     284      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6));
     285   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     286   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    559287}
    560288
    561 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
    562 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
     289template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     290boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7)
    563291{
    564     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    565 
    566     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    567 
    568     void * pv = pd->address();
    569 
    570     ::new( pv ) T(
    571         boost::detail::sp_forward<A1>( a1 ),
    572         boost::detail::sp_forward<A2>( a2 ),
    573         boost::detail::sp_forward<A3>( a3 ),
    574         boost::detail::sp_forward<A4>( a4 ),
    575         boost::detail::sp_forward<A5>( a5 ),
    576         boost::detail::sp_forward<A6>( a6 ),
    577         boost::detail::sp_forward<A7>( a7 ),
    578         boost::detail::sp_forward<A8>( a8 )
    579         );
    580 
    581     pd->set_initialized();
    582 
    583     T * pt2 = static_cast< T* >( pv );
    584 
    585     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    586     return boost::shared_ptr< T >( pt, pt2 );
     292   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     293   ::new (counter->get_pointer()) T(
     294      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     295      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6),
     296      std::forward<A7>(a7));
     297   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     298   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    587299}
    588300
    589 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
    590 boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
     301template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     302boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8)
    591303{
    592     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    593 
    594     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    595 
    596     void * pv = pd->address();
    597 
    598     ::new( pv ) T(
    599         boost::detail::sp_forward<A1>( a1 ),
    600         boost::detail::sp_forward<A2>( a2 ),
    601         boost::detail::sp_forward<A3>( a3 ),
    602         boost::detail::sp_forward<A4>( a4 ),
    603         boost::detail::sp_forward<A5>( a5 ),
    604         boost::detail::sp_forward<A6>( a6 ),
    605         boost::detail::sp_forward<A7>( a7 ),
    606         boost::detail::sp_forward<A8>( a8 ),
    607         boost::detail::sp_forward<A9>( a9 )
    608         );
    609 
    610     pd->set_initialized();
    611 
    612     T * pt2 = static_cast< T* >( pv );
    613 
    614     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    615     return boost::shared_ptr< T >( pt, pt2 );
     304   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     305   ::new (counter->get_pointer()) T(
     306      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     307      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6),
     308      std::forward<A7>(a7), std::forward<A8>(a8));
     309   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     310   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    616311}
    617312
    618 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
    619 boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
     313template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     314boost::shared_ptr<T> allocate_shared(A const & a, A1&& a1, A2&& a2, A3&& a3, A4&& a4, A5&& a5, A6&& a6, A7&& a7, A8&& a8, A9&& a9)
    620315{
    621     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    622 
    623     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    624 
    625     void * pv = pd->address();
    626 
    627     ::new( pv ) T(
    628         boost::detail::sp_forward<A1>( a1 ),
    629         boost::detail::sp_forward<A2>( a2 ),
    630         boost::detail::sp_forward<A3>( a3 ),
    631         boost::detail::sp_forward<A4>( a4 ),
    632         boost::detail::sp_forward<A5>( a5 ),
    633         boost::detail::sp_forward<A6>( a6 ),
    634         boost::detail::sp_forward<A7>( a7 ),
    635         boost::detail::sp_forward<A8>( a8 ),
    636         boost::detail::sp_forward<A9>( a9 )
    637         );
    638 
    639     pd->set_initialized();
    640 
    641     T * pt2 = static_cast< T* >( pv );
    642 
    643     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    644     return boost::shared_ptr< T >( pt, pt2 );
     316   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     317   ::new (counter->get_pointer()) T(
     318      std::forward<A1>(a1), std::forward<A2>(a2), std::forward<A3>(a3),
     319      std::forward<A4>(a4), std::forward<A5>(a5), std::forward<A6>(a6),
     320      std::forward<A7>(a7), std::forward<A8>(a8), std::forward<A9>(a9));
     321   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     322   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    645323}
    646324
    647 #else
    648 
    649 // C++03 version
     325#else // C++03
    650326
    651 template< class T, class A1 >
    652 boost::shared_ptr< T > make_shared( A1 const & a1 )
     327template <class T, class A1>
     328boost::shared_ptr<T> make_shared(A1 const & a1)
    653329{
    654     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    655 
    656     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    657 
    658     void * pv = pd->address();
    659 
    660     ::new( pv ) T( a1 );
    661     pd->set_initialized();
    662 
    663     T * pt2 = static_cast< T* >( pv );
    664 
    665     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    666     return boost::shared_ptr< T >( pt, pt2 );
     330   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     331   boost::detail::verify_allocation(counter.get());
     332   ::new (counter->get_pointer()) T(a1);
     333   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     334   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    667335}
    668336
    669 template< class T, class A, class A1 >
    670 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
     337template <class T, class A1, class A2>
     338boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2)
    671339{
    672     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    673 
    674     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    675 
    676     void * pv = pd->address();
    677 
    678     ::new( pv ) T( a1 );
    679     pd->set_initialized();
    680 
    681     T * pt2 = static_cast< T* >( pv );
    682 
    683     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    684     return boost::shared_ptr< T >( pt, pt2 );
     340   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     341   boost::detail::verify_allocation(counter.get());
     342   ::new (counter->get_pointer()) T(a1, a2);
     343   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     344   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    685345}
    686346
    687 template< class T, class A1, class A2 >
    688 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
     347template <class T, class A1, class A2, class A3>
     348boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2, A3 const & a3)
    689349{
    690     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    691 
    692     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    693 
    694     void * pv = pd->address();
    695 
    696     ::new( pv ) T( a1, a2 );
    697     pd->set_initialized();
    698 
    699     T * pt2 = static_cast< T* >( pv );
    700 
    701     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    702     return boost::shared_ptr< T >( pt, pt2 );
     350   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     351   boost::detail::verify_allocation(counter.get());
     352   ::new (counter->get_pointer()) T(a1, a2, a3);
     353   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     354   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    703355}
    704356
    705 template< class T, class A, class A1, class A2 >
    706 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
     357template <class T, class A1, class A2, class A3, class A4>
     358boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    707359{
    708     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    709 
    710     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    711 
    712     void * pv = pd->address();
    713 
    714     ::new( pv ) T( a1, a2 );
    715     pd->set_initialized();
    716 
    717     T * pt2 = static_cast< T* >( pv );
    718 
    719     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    720     return boost::shared_ptr< T >( pt, pt2 );
     360   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     361   boost::detail::verify_allocation(counter.get());
     362   ::new (counter->get_pointer()) T(a1, a2, a3, a4);
     363   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     364   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    721365}
    722366
    723 template< class T, class A1, class A2, class A3 >
    724 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
     367template <class T, class A1, class A2, class A3, class A4, class A5>
     368boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    725369{
    726     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    727 
    728     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    729 
    730     void * pv = pd->address();
    731 
    732     ::new( pv ) T( a1, a2, a3 );
    733     pd->set_initialized();
    734 
    735     T * pt2 = static_cast< T* >( pv );
    736 
    737     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    738     return boost::shared_ptr< T >( pt, pt2 );
     370   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     371   boost::detail::verify_allocation(counter.get());
     372   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5);
     373   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     374   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    739375}
    740376
    741 template< class T, class A, class A1, class A2, class A3 >
    742 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
     377template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
     378boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    743379{
    744     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    745 
    746     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    747 
    748     void * pv = pd->address();
    749 
    750     ::new( pv ) T( a1, a2, a3 );
    751     pd->set_initialized();
    752 
    753     T * pt2 = static_cast< T* >( pv );
    754 
    755     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    756     return boost::shared_ptr< T >( pt, pt2 );
     380   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     381   boost::detail::verify_allocation(counter.get());
     382   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6);
     383   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     384   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    757385}
    758386
    759 template< class T, class A1, class A2, class A3, class A4 >
    760 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
     387template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     388boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    761389{
    762     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    763 
    764     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    765 
    766     void * pv = pd->address();
    767 
    768     ::new( pv ) T( a1, a2, a3, a4 );
    769     pd->set_initialized();
    770 
    771     T * pt2 = static_cast< T* >( pv );
    772 
    773     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    774     return boost::shared_ptr< T >( pt, pt2 );
     390   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     391   boost::detail::verify_allocation(counter.get());
     392   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6, a7);
     393   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     394   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    775395}
    776396
    777 template< class T, class A, class A1, class A2, class A3, class A4 >
    778 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
     397template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     398boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    779399{
    780     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    781 
    782     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    783 
    784     void * pv = pd->address();
    785 
    786     ::new( pv ) T( a1, a2, a3, a4 );
    787     pd->set_initialized();
    788 
    789     T * pt2 = static_cast< T* >( pv );
    790 
    791     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    792     return boost::shared_ptr< T >( pt, pt2 );
     400   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     401   boost::detail::verify_allocation(counter.get());
     402   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6, a7, a8);
     403   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     404   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    793405}
    794406
    795 template< class T, class A1, class A2, class A3, class A4, class A5 >
    796 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
     407template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     408boost::shared_ptr<T> make_shared(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    797409{
    798     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    799 
    800     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    801 
    802     void * pv = pd->address();
    803 
    804     ::new( pv ) T( a1, a2, a3, a4, a5 );
    805     pd->set_initialized();
    806 
    807     T * pt2 = static_cast< T* >( pv );
    808 
    809     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    810     return boost::shared_ptr< T >( pt, pt2 );
     410   std::auto_ptr<boost::detail::sp_counted_impl_ms<T> > counter(new boost::detail::sp_counted_impl_ms<T>());
     411   boost::detail::verify_allocation(counter.get());
     412   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
     413   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     414   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    811415}
    812416
    813 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
    814 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
     417template <class T, class A, class A1>
     418boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1)
    815419{
    816     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    817 
    818     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    819 
    820     void * pv = pd->address();
    821 
    822     ::new( pv ) T( a1, a2, a3, a4, a5 );
    823     pd->set_initialized();
    824 
    825     T * pt2 = static_cast< T* >( pv );
    826 
    827     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    828     return boost::shared_ptr< T >( pt, pt2 );
     420   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     421   ::new (counter->get_pointer()) T(a1);
     422   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     423   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    829424}
    830425
    831 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
    832 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
     426template <class T, class A, class A1, class A2>
     427boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2)
    833428{
    834     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    835 
    836     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    837 
    838     void * pv = pd->address();
    839 
    840     ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
    841     pd->set_initialized();
    842 
    843     T * pt2 = static_cast< T* >( pv );
    844 
    845     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    846     return boost::shared_ptr< T >( pt, pt2 );
     429   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     430   ::new (counter->get_pointer()) T(a1, a2);
     431   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     432   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    847433}
    848434
    849 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
    850 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
     435template <class T, class A, class A1, class A2, class A3>
     436boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2, A3 const & a3)
    851437{
    852     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    853 
    854     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    855 
    856     void * pv = pd->address();
    857 
    858     ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
    859     pd->set_initialized();
    860 
    861     T * pt2 = static_cast< T* >( pv );
    862 
    863     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    864     return boost::shared_ptr< T >( pt, pt2 );
     438   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     439   ::new (counter->get_pointer()) T(a1, a2, a3);
     440   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     441   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    865442}
    866443
    867 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
    868 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
     444template <class T, class A, class A1, class A2, class A3, class A4>
     445boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    869446{
    870     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    871 
    872     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    873 
    874     void * pv = pd->address();
    875 
    876     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
    877     pd->set_initialized();
    878 
    879     T * pt2 = static_cast< T* >( pv );
    880 
    881     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    882     return boost::shared_ptr< T >( pt, pt2 );
     447   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     448   ::new (counter->get_pointer()) T(a1, a2, a3, a4);
     449   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     450   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    883451}
    884452
    885 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
    886 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
     453template <class T, class A, class A1, class A2, class A3, class A4, class A5>
     454boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    887455{
    888     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    889 
    890     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    891 
    892     void * pv = pd->address();
    893 
    894     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
    895     pd->set_initialized();
    896 
    897     T * pt2 = static_cast< T* >( pv );
    898 
    899     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    900     return boost::shared_ptr< T >( pt, pt2 );
     456   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     457   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5);
     458   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     459   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    901460}
    902461
    903 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
    904 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
     462template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6>
     463boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    905464{
    906     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    907 
    908     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    909 
    910     void * pv = pd->address();
    911 
    912     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
    913     pd->set_initialized();
    914 
    915     T * pt2 = static_cast< T* >( pv );
    916 
    917     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    918     return boost::shared_ptr< T >( pt, pt2 );
     465   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     466   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6);
     467   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     468   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    919469}
    920470
    921 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
    922 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
     471template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     472boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    923473{
    924     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    925 
    926     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    927 
    928     void * pv = pd->address();
    929 
    930     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
    931     pd->set_initialized();
    932 
    933     T * pt2 = static_cast< T* >( pv );
    934 
    935     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    936     return boost::shared_ptr< T >( pt, pt2 );
     474   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     475   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6, a7);
     476   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     477   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    937478}
    938479
    939 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
    940 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
     480template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     481boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    941482{
    942     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
    943 
    944     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    945 
    946     void * pv = pd->address();
    947 
    948     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
    949     pd->set_initialized();
    950 
    951     T * pt2 = static_cast< T* >( pv );
    952 
    953     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    954     return boost::shared_ptr< T >( pt, pt2 );
     483   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     484   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6, a7, a8);
     485   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     486   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    955487}
    956488
    957 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
    958 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
     489template <class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     490boost::shared_ptr<T> allocate_shared(A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    959491{
    960     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
    961 
    962     boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
    963 
    964     void * pv = pd->address();
    965 
    966     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
    967     pd->set_initialized();
    968 
    969     T * pt2 = static_cast< T* >( pv );
    970 
    971     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    972     return boost::shared_ptr< T >( pt, pt2 );
     492   boost::detail::scoped_sp_counter<boost::detail::sp_counted_impl_ms_a<T, A>, A> counter(a);
     493   ::new (counter->get_pointer()) T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
     494   boost::detail::sp_counted_base_ms<T>* c = counter.release();
     495   return boost::shared_ptr<T>(c->get_pointer(), static_cast<boost::detail::sp_counted_base*>(c));
    973496}
    974497
    975 #endif
    976 
    977 #undef BOOST_SP_MSD
     498#endif // C++03
    978499
    979500} // namespace boost
    980501

  • boost/smart_ptr/shared_ptr.hpp 

    diff --git boost/smart_ptr/shared_ptr.hpp boost/smart_ptr/shared_ptr.hpp
index 0932cc3..8412747 100644
    template< class X, class Y, class T > inline void sp_enable_shared_from_this( bo  
    108108
    109109template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
    110110
    111 #ifdef _MANAGED
     111#if defined(_MANAGED) || defined(BOOST_MSVC)
    112112
    113113// Avoid C4793, ... causes native code generation
     114// Also, function with (...) isn't inlined (bug?), so compiler generates call of empty function
     115// instead of throwing it out.
    114116
    115117struct sp_any_pointer
    116118{
    … … inline void sp_enable_shared_from_this( sp_any_pointer, sp_any_pointer, sp_any_p  
    121123{
    122124}
    123125
    124 #else // _MANAGED
     126#else // defined(_MANAGED) || defined(BOOST_MSVC)
    125127
    126128inline void sp_enable_shared_from_this( ... )
    127129{
    128130}
    129131
    130 #endif // _MANAGED
     132#endif // defined(_MANAGED) || defined(BOOST_MSVC)
    131133
    132134#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_AUTO_PTR )
    133135
    … … public:  
    273275        }
    274276    }
    275277
     278    template<class Y>
     279    shared_ptr(Y* p, boost::detail::sp_counted_base* counter): px(p), pn(counter) // never throws
     280    {
     281        boost::detail::sp_enable_shared_from_this( this, p, p );
     282    }
     283
    276284#ifndef BOOST_NO_AUTO_PTR
    277285
    278286    template<class Y>