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 ReusableObjectHolder {
  public:
    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);
      T* item = 0;
      while (m_availableQueue.try_pop(item)) {
        delete item;
      }
    }

    void add(std::unique_ptr<T> iItem) {
      if (0 != iItem) {
        m_availableQueue.push(iItem.release());
      }
    }

    std::shared_ptr<T> tryToGet() {
      T* item = 0;
      m_availableQueue.try_pop(item);
      if (0 == item) {
        return std::shared_ptr<T>{};
      }
      //instead of deleting, hand back to queue
      auto pHolder = this;
      ++m_outstandingObjects;
      return std::shared_ptr<T>{item, [pHolder](T* iItem) { pHolder->addBack(iItem); }};
    }

    template <typename F>
    std::shared_ptr<T> makeOrGet(F iFunc) {
      std::shared_ptr<T> returnValue;
      while (!(returnValue = tryToGet())) {
        add(std::unique_ptr<T>(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(std::unique_ptr<T>(iMakeFunc()));
      }
      iClearFunc(returnValue.get());
      return returnValue;
    }

  private:
    void addBack(T* iItem) {
      m_availableQueue.push(iItem);
      --m_outstandingObjects;
    }

    tbb::concurrent_queue<T*> m_availableQueue;
    std::atomic<size_t> m_outstandingObjects;
  };

}  // namespace edm

#endif /* end of include guard: FWCore_Utilities_ReusableObjectHolder_h */