ReusableObjectHolder.h

Go to the documentation of this file.

#ifndef FWCore_Utilities_ReusableObjectHolder_h
#define FWCore_Utilities_ReusableObjectHolder_h
 
// -*- C++ -*-
//
// Package:     FWCore/Utilities
// Class  :     ReusableObjectHolder
//
//
// Original Author:  Chris Jones
//         Created:  Fri, 31 July 2014 14:29:41 GMT
//
 
#include <memory>
#include <cassert>
#include <atomic>
#include "tbb/task.h"
#include "tbb/concurrent_queue.h"
 
namespace edm {
  template <class T, class Deleter = std::default_delete<T>>
  class ReusableObjectHolder {
  public:
    using deleter_type = Deleter;
 
    ReusableObjectHolder() : m_outstandingObjects(0) {}
    ReusableObjectHolder(ReusableObjectHolder&& iOther)
        : m_availableQueue(std::move(iOther.m_availableQueue)), m_outstandingObjects(0) {
      assert(0 == iOther.m_outstandingObjects);
    }
    ~ReusableObjectHolder() {
      assert(0 == m_outstandingObjects);
      std::unique_ptr<T, Deleter> item;
      while (m_availableQueue.try_pop(item)) {
        item.reset();
      }
    }
 
    void add(std::unique_ptr<T, Deleter> iItem) {
      if (nullptr != iItem) {
        m_availableQueue.push(std::move(iItem));
      }
    }
 
    std::shared_ptr<T> tryToGet() {
      std::unique_ptr<T, Deleter> item;
      m_availableQueue.try_pop(item);
      if (nullptr == item) {
        return std::shared_ptr<T>{};
      }
      //instead of deleting, hand back to queue
      auto pHolder = this;
      auto deleter = item.get_deleter();
      ++m_outstandingObjects;
      return std::shared_ptr<T>{item.release(), [pHolder, deleter](T* iItem) {
                                  pHolder->addBack(std::unique_ptr<T, Deleter>{iItem, deleter});
                                }};
    }
 
    template <typename F>
    std::shared_ptr<T> makeOrGet(F iFunc) {
      std::shared_ptr<T> returnValue;
      while (!(returnValue = tryToGet())) {
        add(makeUnique(iFunc()));
      }
      return returnValue;
    }
 
    template <typename FM, typename FC>
    std::shared_ptr<T> makeOrGetAndClear(FM iMakeFunc, FC iClearFunc) {
      std::shared_ptr<T> returnValue;
      while (!(returnValue = tryToGet())) {
        add(makeUnique(iMakeFunc()));
      }
      iClearFunc(returnValue.get());
      return returnValue;
    }
 
  private:
    std::unique_ptr<T> makeUnique(T* ptr) {
      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};
    }
 
    std::unique_ptr<T, Deleter> makeUnique(std::unique_ptr<T, Deleter> ptr) { return ptr; }
 
    void addBack(std::unique_ptr<T, Deleter> iItem) {
      m_availableQueue.push(std::move(iItem));
      --m_outstandingObjects;
    }
 
    tbb::concurrent_queue<std::unique_ptr<T, Deleter>> m_availableQueue;
    std::atomic<size_t> m_outstandingObjects;
  };
 
}  // namespace edm
 
#endif /* end of include guard: FWCore_Utilities_ReusableObjectHolder_h */