Boost C++ Libraries: Ticket #1109: intrusive_ptr needs a helper base class

status changed; owner set

Peter Dimov — Sat, 21 Jul 2007 23:34:13 GMT

owner set to Peter Dimov
status new → assigned

milestone changed

Peter Dimov — Thu, 21 Aug 2008 15:13:40 GMT

milestone To Be Determined → Boost 1.37.0

milestone changed

Peter Dimov — Sat, 28 Feb 2009 16:59:40 GMT

milestone Boost 1.37.0 → To Be Determined

status changed

Peter Dimov — Thu, 24 Feb 2011 22:07:08 GMT

status assigned → new

NN — Tue, 31 May 2011 12:55:13 GMT

Virtual destructor is not necessary here:

template<typename T>
class counted_base
{
private:
    mutable detail::atomic_count count_;
protected:
    counted_base(): count_( 0 ) {}
    ~counted_base() {}
    counted_base( counted_base const & ): count_( 0 ) {}
    counted_base& operator=( counted_base const & ) { return *this; }
public:
    inline friend void intrusive_ptr_add_ref( T const * p )
    {
        ++p->counted_base<T>::count_;
    }
    inline friend void intrusive_ptr_release( T const * p )
    {
        if( --p->counted_base<T>::count_ == 0 )
            delete p;
    }
    long use_count() const { return count_; }
};

Mon, 03 Oct 2011 13:24:31 GMT

What's the advantage of intrusive over shared when make_shared is used?

ArtemGr — Mon, 16 Sep 2013 13:38:16 GMT

Replying to Olaf van der Spek <olafvdspek@…>:

What's the advantage of intrusive over shared when make_shared is used?

Olaf, one important advantage is that the class does not need to be fully defined,
another advantage is that you can create intrusive_ptr anywhere, you don't have to pass it around in order to have it.

Mon, 07 Oct 2013 06:33:24 GMT

I would also template the type of count_ variable, sometimes there's no need for thread-safe counter, and using long would give some performance boost

Thu, 07 Nov 2013 09:03:47 GMT

I use this base class. It is inspired by boost.intrusive and uses the example reference counter from boost.atomic.

If you want, I can improve this a bit. I think, it should be possible to select atomic/nonatomic internal counter and some checking policy (again inspired by boost.atomic).

#ifndef INTRUSIVE_PTR_BASE_HOOK_H_INCLUDED
#define INTRUSIVE_PTR_BASE_HOOK_H_INCLUDED
#include <memory>
#include <utility>
#include <boost/assert.hpp>
#include <boost/atomic.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/parameter/binding.hpp>
#include <boost/parameter/name.hpp>
#include <boost/parameter/parameters.hpp>
namespace utils {
BOOST_PARAMETER_TEMPLATE_KEYWORD(deleter)
BOOST_PARAMETER_TEMPLATE_KEYWORD(count_type)
typedef boost::parameter::parameters<
    boost::parameter::optional<tag::deleter>,
    boost::parameter::optional<tag::count_type>
> intrusive_ptr_base_hook_signature;
template<typename Derived, typename ... Params>
class intrusive_ptr_base_hook
{
    typedef typename intrusive_ptr_base_hook_signature::bind<Params...>::type args;
protected :
    typedef Derived derived_type;
    typedef typename boost::parameter::binding<
            args, tag::deleter, std::default_delete<derived_type>
        >::type deleter_type;
    typedef typename boost::parameter::binding<
            args, tag::count_type, unsigned
        >::type count_type;
private:
    struct Data
        : public deleter_type
    {
        boost::atomic<count_type> count;
        constexpr Data(count_type c, deleter_type const & d)
            : deleter_type(d)
            , count(c)
        {}
    } m_data;
protected :
    constexpr intrusive_ptr_base_hook()
        : m_data(0, deleter_type())
    {}
    intrusive_ptr_base_hook(intrusive_ptr_base_hook const &) = delete;
    intrusive_ptr_base_hook & operator=(intrusive_ptr_base_hook const &) = delete;
    ~intrusive_ptr_base_hook() noexcept
    {
        BOOST_ASSERT(m_count.load(boost::memory_order::memory_order_relaxed) == 0);
    }
public :
    friend void intrusive_ptr_add_ref(
            intrusive_ptr_base_hook const * p)
    {
        const_cast<intrusive_ptr_base_hook*>(p)
            ->m_data.count.fetch_add(1, boost::memory_order_relaxed);
    }
    friend void intrusive_ptr_release(
            intrusive_ptr_base_hook const * pc)
    {
        intrusive_ptr_base_hook * p = const_cast<intrusive_ptr_base_hook*>(pc);
        if(p->m_data.count.fetch_sub(1, boost::memory_order_release) == 1)
        {
            boost::atomic_thread_fence(boost::memory_order_acquire);
            // call deleter hidden in m_data
            p->m_data(static_cast<derived_type*>(p));
        }
    }
};
template<typename T, typename ... Args>
inline boost::intrusive_ptr<T> make_intrusive(Args && ... args)
{
    return boost::intrusive_ptr<T>(new T(std::forward<Args>(args)...));
}
}//namespace utils
#endif//INTRUSIVE_PTR_BASE_HOOK_H_INCLUDED

status changed; resolution set

Peter Dimov — Wed, 11 Dec 2013 18:02:23 GMT

status new → closed
resolution → fixed

There's boost/smart_ptr/intrusive_ref_counter.hpp now.