How to get boost::object_pool thread safe?

Question

After asking Is there a faster heap allocation/deallocation mechanism available than boost::object_pool? I got feedback that this object pool is NOT thread safe.

So I wrote an ObjectFactory wrapping boost::object_pool and adding mutex locks:

#include <memory>
using std::shared_ptr;

#include <boost/pool/object_pool.hpp>
#include <boost/thread/mutex.hpp>

template <typename T>
class ObjectFactory 
{
private:
    struct SharedDeleter 
    {
        ObjectFactory<T>* m_pFact;

        SharedDeleter(ObjectFactory<T>* fact) : m_pFact(fact) {}

        inline void operator()(T* p) const 
        {      
          m_pFact->destroy(p);
        }
    };


    boost::object_pool<T>   m_Pool;
    boost::mutex            m_PoolMutex;

    SharedDeleter           m_Deleter;


public:
    ObjectFactory() : m_Deleter(this)
    {
    }

    template<typename TType = T, typename... TArgs> 
    inline TType* create(TArgs&&... mArgs)
    {
        boost::unique_lock<boost::mutex> scoped_lock(m_PoolMutex);
        return m_Pool.construct(mArgs...);
    }

    inline void destroy(T* mObj) 
    { 
        boost::unique_lock<boost::mutex> scoped_lock(m_PoolMutex);
        m_Pool.destroy(mObj); 
    }


    template<typename TType = T, typename... TArgs> 
    inline std::shared_ptr<TType> make_shared(TArgs&&... mArgs)
    {
        return std::shared_ptr<TType>(this->create(mArgs...), m_Deleter);
    }

};

Timing results without the mutex lock:

 With WithObjectFactory!: 
Start time: 1381682855810868000 nanoseconds since Jan 1, 1970
End time: 1381682863375427000 nanoseconds since Jan 1, 1970
Duration: 7.56456 seconds

 With WithObjectFactory and std::shared_ptr!: 
Start time: 1381682863375476000 nanoseconds since Jan 1, 1970
End time: 1381682879114065000 nanoseconds since Jan 1, 1970
Duration: 15.7386 seconds

Timing results WITH the mutex locks:

 With WithObjectFactory!: 
Start time: 1381683562246086000 nanoseconds since Jan 1, 1970
End time: 1381683574399319000 nanoseconds since Jan 1, 1970
Duration: 12.1532 seconds

 With WithObjectFactory and std::shared_ptr!: 
Start time: 1381683574399378000 nanoseconds since Jan 1, 1970
End time: 1381683595103438000 nanoseconds since Jan 1, 1970
Duration: 20.7041 seconds

What you see is that the mutex locking takes more than 20% of the time leaving, IMHO, boost::object_pool only usable for single thread applications.

My questions: Am I using the proper locking mechanism? Does the destroy also needs a mutex lock? Is there any bug I am not seeing in above code?

Thanks

EDIT: Tested with std::map but is to slow. Found boost::thread_specific_ptr and it seems to work:

#include <memory>
using std::shared_ptr;

#include <boost/pool/object_pool.hpp>
#include <boost/thread.hpp>

template <typename T>
class ObjectFactory 
{
private:
    struct SharedDeleter 
    {
        ObjectFactory<T>* m_pFact;

        SharedDeleter(ObjectFactory<T>* fact) : m_pFact(fact) {}

        inline void operator()(T* p) const 
        {      
          m_pFact->destroy(p);
        }
    };

    boost::thread_specific_ptr<boost::object_pool<T>>   m_tpPool;   
    SharedDeleter           m_Deleter;

public:
    ObjectFactory() : m_Deleter(this)
    {
        if ( !m_tpPool.get() )
            m_tpPool.reset(new boost::object_pool<T>());
    }

    template<typename TType = T, typename... TArgs> 
    inline TType* create(TArgs&&... mArgs)
    {
        return m_tpPool->construct(mArgs...);
    }

    inline void destroy(T* mObj) 
    { 
        m_tpPool->destroy(mObj);
    }

    template<typename TType = T, typename... TArgs> 
    inline std::shared_ptr<TType> make_shared(TArgs&&... mArgs)
    {
        return std::shared_ptr<TType>(this->create(mArgs...), m_Deleter);
    }
};

Results with above code:

 With WithObjectFactory!: 
Start time: 1381714923605177000 nanoseconds since Jan 1, 1970
End time: 1381714934202228000 nanoseconds since Jan 1, 1970
Duration: 10.5971 seconds

 With WithObjectFactory and std::shared_ptr!: 
Start time: 1381714934202285000 nanoseconds since Jan 1, 1970
End time: 1381714950900537000 nanoseconds since Jan 1, 1970
Duration: 16.6983 seconds

Answer 1

I think you would still need synchronization for the m_Deleter since the shared_ptr could be released from another thread.

Answer 2

• Using std::mutex and boost:thread_specific_ptr where both to slow
• std::atomic_load(std::shared_ptr<...>*) does NOT seem to work on GCC 4.6
• Fallback to good old pthread calls using this solution

Results: On Ubuntu LTS 12.04 with GCC 4.6

 With OUT smartptrs (new and delete): 
Start time: 1381746876399819258 nanoseconds since Jan 1, 1970
End time: 1381746881851990579 nanoseconds since Jan 1, 1970
Duration: 5.45217 seconds

 With smartptrs (boost::shared_ptr withOUT make_shared): 
Start time: 1381746881852079492 nanoseconds since Jan 1, 1970
End time: 1381746889453586405 nanoseconds since Jan 1, 1970
Duration: 7.60151 seconds

 With smartptrs (boost::shared_ptr with make_shared): 
Start time: 1381746889453642790 nanoseconds since Jan 1, 1970
End time: 1381746896396534068 nanoseconds since Jan 1, 1970
Duration: 6.94289 seconds

 With STD smart_ptr (std::shared_ptr with make_shared): 
Start time: 1381746896396596314 nanoseconds since Jan 1, 1970
End time: 1381746902544346880 nanoseconds since Jan 1, 1970
Duration: 6.14775 seconds

 With UniquePtr (boost::unique_ptr): 
Start time: 1381746902544386766 nanoseconds since Jan 1, 1970
End time: 1381746907842640751 nanoseconds since Jan 1, 1970
Duration: 5.29825 seconds

 With STD UniquePtr (std::unique_ptr): 
Start time: 1381746907842679994 nanoseconds since Jan 1, 1970
End time: 1381746913141429138 nanoseconds since Jan 1, 1970
Duration: 5.29875 seconds

 With Object Pool (boost::object_pool<>): 
Start time: 1381746913141469017 nanoseconds since Jan 1, 1970
End time: 1381746917062689541 nanoseconds since Jan 1, 1970
Duration: 3.92122 seconds


 With Thread Safe ObjectFactory<TestClass>...
Start time: 1381746917062729671 nanoseconds since Jan 1, 1970
End time: 1381746921388452186 nanoseconds since Jan 1, 1970
Duration: 4.32572 seconds

 With Thread Safe ObjectFactory<TestClass> and std::shared_ptr...
Start time: 1381746921388491395 nanoseconds since Jan 1, 1970
End time: 1381746928808481617 nanoseconds since Jan 1, 1970
Duration: 7.41999 seconds

So the Thread Safe ObjectFactory is still 1+ second faster than using plain old new & delete.

Anyone have a beter suggestion please add it!

Thanks for all the helpfull feedback!

EDIT: Using __thread gnu option also works fast:

#include <memory>
#include <boost/pool/object_pool.hpp>

template <typename T>
class ObjectFactory 
{
private:
    struct SharedDeleter 
    {
        ObjectFactory<T>* m_pFact;

        SharedDeleter(ObjectFactory<T>* fact) : m_pFact(fact) {}

        inline void operator()(T* p) const 
        {      
          m_pFact->destroy(p);
        }
    };

    static __thread boost::object_pool<T>* m_tlsPool;
    SharedDeleter           m_Deleter;

public:
    ObjectFactory() :  m_Deleter(this)
    {
        m_tlsPool = new boost::object_pool<T>();
    }

    virtual ~ObjectFactory() 
    {
        delete m_tlsPool;
    }

    template<typename TType = T, typename... TArgs> 
    inline TType* create(TArgs&&... mArgs)
    {
        return m_tlsPool->construct(mArgs...);       
    }

    inline void destroy(T* mObj) 
    { 
        m_tlsPool->destroy(mObj);
    }

    template<typename TType = T, typename... TArgs> 
    inline std::shared_ptr<TType> make_shared(TArgs&&... mArgs)
    {
        return std::shared_ptr<TType>(this->create(mArgs...), m_Deleter);
    }
};

template<typename T>
/*static*/__thread boost::object_pool<T>* ObjectFactory<T>::m_tlsPool(NULL);

However m_tlsPool does not need to be static?