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 <atomic>
#include <cassert>
#include <memory>

#include <oneapi/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() noexcept {
      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;
      if (m_availableQueue.try_pop(item)) {
        return wrapCustomDeleter(std::move(item));
      } else {
        return std::shared_ptr<T>{};
      }
    }

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

    template <typename FM, typename FC>
    std::shared_ptr<T> makeOrGetAndClear(FM&& iMakeFunc, FC&& iClearFunc) {
      std::shared_ptr<T> returnValue = makeOrGet(std::forward<FM>(iMakeFunc));
      iClearFunc(returnValue.get());
      return returnValue;
    }

  private:
    // back to the queue instead of deleting it
    std::shared_ptr<T> wrapCustomDeleter(std::unique_ptr<T, Deleter> item) {
      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});
                                }};
    }

    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;
    }

    oneapi::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 */