edm::ReusableObjectHolder< T, Deleter > Class Template Reference

#include <ReusableObjectHolder.h>

Public Types
using	deleter_type = Deleter

Public Member Functions
void	add (std::unique_ptr< T, Deleter > iItem)
template<typename FM >
std::shared_ptr< T >	makeOrGet (FM &&iMakeFunc)
	Takes an object from the queue if one is available, or creates one using iMakeFunc. More...
template<typename FM , typename FC >
std::shared_ptr< T >	makeOrGetAndClear (FM &&iMakeFunc, FC &&iClearFunc)
	ReusableObjectHolder ()
	ReusableObjectHolder (ReusableObjectHolder &&iOther)
std::shared_ptr< T >	tryToGet ()
	~ReusableObjectHolder ()

Private Member Functions
void	addBack (std::unique_ptr< T, Deleter > iItem)
std::unique_ptr< T >	makeUnique (T *ptr)
std::unique_ptr< T, Deleter >	makeUnique (std::unique_ptr< T, Deleter > ptr)
std::shared_ptr< T >	wrapCustomDeleter (std::unique_ptr< T, Deleter > item)
	Wraps an object in a shared_ptr<T> with a custom deleter, that hands the wrapped object. More...

Private Attributes
tbb::concurrent_queue < std::unique_ptr< T, Deleter > >	m_availableQueue
std::atomic< size_t >	m_outstandingObjects

Detailed Description

template<class T, class Deleter = std::default_delete<T>>
class edm::ReusableObjectHolder< T, Deleter >

Description: Thread safe way to do create and reuse a group of the same object type.

Usage: This class can be used to safely reuse a series of objects created on demand. The reuse of the objects is safe even across different threads since one can safely call all member functions of this class on the same instance of this class from multiple threads.

This class manages the cache of reusable objects and therefore an instance of this class must live as long as you want the cache to live.

The primary way of using the class is to call makeOrGet:

auto objectToUse = holder.makeOrGet([]() { return new MyObject(); });
use(*objectToUse);

If the returned object should be be automatically set or reset, call makeOrGetAndClear:

auto objectToUse = holder.makeOrGetAndClear([]() { return new MyObject(10); },   // makes new objects
                                            [](MyObject* old) { old->reset(); }  // resets any object before returning it
);

which is equivalent to

auto objectToUse = holder.makeOrGet([]() { return new MyObject(10); });
objectToUse->reset();

NOTE: If you hold onto the std::shared_ptr<> until another call to the ReusableObjectHolder, make sure to release the shared_ptr before the call. That way the object you were just using can go back into the cache and be reused for the call you are going to make. An example

std::shared_ptr<MyObject> obj;
while(someCondition()) {
  //release object so it can re-enter the cache
  obj.release();
  obj = holder.makeOrGet([]{ return new MyObject();} );
  obj->setValue(someNewValue());
  useTheObject(obj);
}

The above example is very contrived, since the better way to do the above is

while(someCondition()) {
  auto obj = holder.makeOrGet([]{ return new MyObject();} );
  obj->setValue(someNewValue());
  useTheObject(obj);
  //obj goes out of scope and returns the object to the cache
}

When a custom deleter is used, the deleter type must be the same to all objects. The deleter is allowed to have state that depends on the object. The deleter object is passed along the std::unique_ptr, and is internally kept along the object. The deleter object must be copyable.

Definition at line 82 of file ReusableObjectHolder.h.

Member Typedef Documentation

template<class T, class Deleter = std::default_delete<T>>

using edm::ReusableObjectHolder< T, Deleter >::deleter_type = Deleter

Definition at line 84 of file ReusableObjectHolder.h.

Constructor & Destructor Documentation

template<class T, class Deleter = std::default_delete<T>>

edm::ReusableObjectHolder< T, Deleter >::ReusableObjectHolder ( )

inline

Definition at line 86 of file ReusableObjectHolder.h.

: m_outstandingObjects(0) {}

template<class T, class Deleter = std::default_delete<T>>

edm::ReusableObjectHolder< T, Deleter >::ReusableObjectHolder ( ReusableObjectHolder< T, Deleter > &&  iOther )

inline

Definition at line 87 of file ReusableObjectHolder.h.

        : m_availableQueue(std::move(iOther.m_availableQueue)), m_outstandingObjects(0) {
      assert(0 == iOther.m_outstandingObjects);
    }

template<class T, class Deleter = std::default_delete<T>>

edm::ReusableObjectHolder< T, Deleter >::~ReusableObjectHolder ( )

inline

Definition at line 91 of file ReusableObjectHolder.h.

                            {
      assert(0 == m_outstandingObjects);
      std::unique_ptr<T, Deleter> item;
      while (m_availableQueue.try_pop(item)) {
        item.reset();
      }
    }

Member Function Documentation

template<class T, class Deleter = std::default_delete<T>>

void edm::ReusableObjectHolder< T, Deleter >::add ( std::unique_ptr< T, Deleter >  iItem )

inline

Adds the item to the cache. Use this function if you know ahead of time how many cached items you will need.

Definition at line 102 of file ReusableObjectHolder.h.

Referenced by counter.Counter::register().

                                              {
      if (nullptr != iItem) {
        m_availableQueue.push(std::move(iItem));
      }
    }

template<class T, class Deleter = std::default_delete<T>>

void edm::ReusableObjectHolder< T, Deleter >::addBack ( std::unique_ptr< T, Deleter >  iItem )

inlineprivate

Definition at line 159 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::wrapCustomDeleter().

                                                  {
      m_availableQueue.push(std::move(iItem));
      --m_outstandingObjects;
    }

template<class T, class Deleter = std::default_delete<T>>

template<typename FM >

std::shared_ptr<T> edm::ReusableObjectHolder< T, Deleter >::makeOrGet ( FM &&  iMakeFunc )

inline

Takes an object from the queue if one is available, or creates one using iMakeFunc.

Definition at line 122 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGetAndClear(), EcalSeverityLevelESProducer::produce(), RPCInverseCPPFLinkMapESProducer::produce(), RPCInverseTwinMuxLinkMapESProducer::produce(), RPCInverseOMTFLinkMapESProducer::produce(), EcalNextToDeadChannelESProducer::produce(), RPCInverseLBLinkMapESProducer::produce(), EcalLaserCorrectionService::produce(), EcalLaserCorrectionServiceMC::produce(), HcalDbProducer::produce(), HcalTPGCoderULUT::produce(), CastorDbProducer::produce(), and DTGeometryESProducer::produce().

                                               {
      std::unique_ptr<T, Deleter> item;
      if (m_availableQueue.try_pop(item)) {
        return wrapCustomDeleter(std::move(item));
      } else {
        return wrapCustomDeleter(makeUnique(iMakeFunc()));
      }
    }

template<class T, class Deleter = std::default_delete<T>>

template<typename FM , typename FC >

std::shared_ptr<T> edm::ReusableObjectHolder< T, Deleter >::makeOrGetAndClear ( FM &&  iMakeFunc, FC &&  iClearFunc  )

inline

Takes an object from the queue if one is available, or creates one using iMakeFunc. Then, passes the object to iClearFunc, and returns it.

Definition at line 134 of file ReusableObjectHolder.h.

                                                                        {
      std::shared_ptr<T> returnValue = makeOrGet(std::forward<FM>(iMakeFunc));
      iClearFunc(returnValue.get());
      return returnValue;
    }

template<class T, class Deleter = std::default_delete<T>>

std::unique_ptr<T> edm::ReusableObjectHolder< T, Deleter >::makeUnique ( T *  ptr )

inlineprivate

Definition at line 151 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGet().

                                        {
      static_assert(std::is_same_v<Deleter, std::default_delete<T>>,
                    "Generating functions returning raw pointers are supported only with std::default_delete<T>");
      return std::unique_ptr<T>{ptr};
    }

template<class T, class Deleter = std::default_delete<T>>

std::unique_ptr<T, Deleter> edm::ReusableObjectHolder< T, Deleter >::makeUnique ( std::unique_ptr< T, Deleter >  ptr )

inlineprivate

Definition at line 157 of file ReusableObjectHolder.h.

{ return ptr; }

template<class T, class Deleter = std::default_delete<T>>

std::shared_ptr<T> edm::ReusableObjectHolder< T, Deleter >::tryToGet ( )

inline

Tries to get an already created object, if none are available, returns an empty shared_ptr. Use this function in conjunction with add()

Definition at line 111 of file ReusableObjectHolder.h.

                                {
      std::unique_ptr<T, Deleter> item;
      if (m_availableQueue.try_pop(item)) {
        return wrapCustomDeleter(std::move(item));
      } else {
        return std::shared_ptr<T>{};
      }
    }

template<class T, class Deleter = std::default_delete<T>>

std::shared_ptr<T> edm::ReusableObjectHolder< T, Deleter >::wrapCustomDeleter ( std::unique_ptr< T, Deleter >  item )

inlineprivate

Wraps an object in a shared_ptr<T> with a custom deleter, that hands the wrapped object.

Definition at line 143 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGet(), and edm::ReusableObjectHolder< edm::ESProductHost >::tryToGet().

                                                                       {
      auto deleter = item.get_deleter();
      ++m_outstandingObjects;
      return std::shared_ptr<T>{item.release(), [this, deleter](T* iItem) {
                                  this->addBack(std::unique_ptr<T, Deleter>{iItem, deleter});
                                }};
    }

Member Data Documentation

template<class T, class Deleter = std::default_delete<T>>

tbb::concurrent_queue<std::unique_ptr<T, Deleter> > edm::ReusableObjectHolder< T, Deleter >::m_availableQueue

private

Definition at line 164 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::add(), edm::ReusableObjectHolder< edm::ESProductHost >::addBack(), edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGet(), edm::ReusableObjectHolder< edm::ESProductHost >::tryToGet(), and edm::ReusableObjectHolder< edm::ESProductHost >::~ReusableObjectHolder().

template<class T, class Deleter = std::default_delete<T>>

std::atomic<size_t> edm::ReusableObjectHolder< T, Deleter >::m_outstandingObjects

private

Definition at line 165 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::addBack(), edm::ReusableObjectHolder< edm::ESProductHost >::wrapCustomDeleter(), and edm::ReusableObjectHolder< edm::ESProductHost >::~ReusableObjectHolder().