/** * @file include/ActivMiddleware/Misc/ObjectPool.h * * @brief Classes to cache a number of objects to avoid constructing/destructing them continually. */ #if (!defined ACTIV_MISC_OBJECT_POOL_H) #define ACTIV_MISC_OBJECT_POOL_H #include "ActivMiddleware/Misc/FunctionObjects.h" #include "ActivMiddleware/Misc/Singleton.h" #include "ActivMiddleware/Misc/StlHelper.h" #include "ActivMiddleware/ActivBase/StatusCodeException.h" #include ACTIV_BOOST_INCLUDE(range/algorithm_ext/push_back.hpp) #include #include //! Activ namespace. namespace Activ { namespace Detail { ACTIV_BOOST_TTI_HAS_MEMBER_FUNCTION(GetMemoryUsage) template class HasGetMemoryUsage : public Boost::mpl::or_< has_member_function_GetMemoryUsage, has_member_function_GetMemoryUsage > { }; } // namespace Detail // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Object pool. * * This pool provides no built-in thread safety. It provides no object-tracking; all objects allocated from * the pool must be manually returned to the pool to avoid memory leaks. * * T the type of the object to cache; must be default constructible. */ template class ObjectPool { public: typedef T ObjectType; /** * @brief Pool statistics. */ class Stats { public: size_t m_initialFreeListSize; size_t m_currentFreeListSize; size_t m_maximumFreeListSize; size_t m_maximumAllowedFreeListSize; }; /** * @brief Constructor. * * @param initialFreeListSize how many objects to create initially. * @param maximumAllowedFreeListSize maximum allowed free list size, or 0 for no upper bound. * * @throw Exception invalid parameters. */ ObjectPool(const size_t initialFreeListSize = 0, const size_t maximumAllowedFreeListSize = 0) : m_maximumAllowedFreeListSize(maximumAllowedFreeListSize) { if ((0 != maximumAllowedFreeListSize) && (initialFreeListSize > maximumAllowedFreeListSize)) ACTIV_THROW(StatusCodeException, STATUS_CODE_INVALID_PARAMETER); m_freeList.reserve(initialFreeListSize); for (size_t i = 0; i < initialFreeListSize; ++i) { T *pObject = new (std::nothrow) T; if (0 != pObject) m_freeList.push_back(pObject); } m_initialFreeListSize = m_freeList.size(); m_maximumFreeListSize = m_initialFreeListSize; } /** * @brief Get an object from the pool. * * If the free list is non-empty, an object from it is returned, *without* invoking the object's constructor. Otherwise, * a new object is allocated from the heap (and therefore it's constructor is called). * * @return Pointer to an object, or 0 if the pool and heap are empty. */ T *Get() { T *pObject; if (!m_freeList.empty()) { pObject = m_freeList.back(); m_freeList.pop_back(); } else { pObject = new (std::nothrow) T; if (0 == pObject) return 0; } return pObject; } /** * @brief Return an in use object to the pool. * * The object will be deleted if the free list is already full. Otherwise, it is added to the free list *without* * invoking the object's destructor. * * @param pObject Pointer to object to return. * * @return true */ bool Return(T * const pObject) { if ((0 == m_maximumAllowedFreeListSize) || (m_freeList.size() < m_maximumAllowedFreeListSize)) { m_freeList.push_back(pObject); if (m_freeList.size() > m_maximumFreeListSize) m_maximumFreeListSize = m_freeList.size(); } else { delete pObject; } return true; } //! Trim the free-list to its initial size. void TrimFreeList() { if (m_freeList.size() > m_initialFreeListSize) { std::for_each(m_freeList.begin() + m_initialFreeListSize, m_freeList.end(), DeleteObject()); m_freeList.resize(m_initialFreeListSize); } } /** * @brief Apply a function object to all objects in the free-list. * * @param fn */ template void ApplyToFreeList(const F &fn) { std::for_each(m_freeList.begin(), m_freeList.end(), fn); } /** * @brief Get statistics. * * @return Stats. */ Stats GetStats() const { Stats stats; stats.m_initialFreeListSize = m_initialFreeListSize; stats.m_currentFreeListSize = m_freeList.size(); stats.m_maximumFreeListSize = m_maximumFreeListSize; stats.m_maximumAllowedFreeListSize = m_maximumAllowedFreeListSize; return stats; } /** * @brief Get the approximate memory usage of this object and objects in the free-list. * * Note this can be a slow operation. * * @return Approximate memory usage in bytes. */ size_t GetMemoryUsage() const { ACTIV_BOOST_STATIC_ASSERT(Detail::HasGetMemoryUsage::value); return GetMemoryUsageImpl(); } protected: typedef std::vector ObjectList; const size_t m_maximumAllowedFreeListSize; ObjectList m_freeList; ///< List of free objects. private: template typename Boost::enable_if, size_t>::type GetMemoryUsageImpl() const { size_t memoryUsage = sizeof(*this); memoryUsage += m_freeList.capacity() * sizeof(typename ObjectList::value_type); for (typename ObjectList::const_iterator iter = m_freeList.begin(), iterEnd = m_freeList.end(); iter != iterEnd; ++iter) { const T * const pObject = *iter; if (0 != pObject) memoryUsage += pObject->GetMemoryUsage(); } return memoryUsage; } size_t m_initialFreeListSize; size_t m_maximumFreeListSize; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Object pool with object tracking. * * This pool provides no built-in thread safety. * * T the type of the object to cache; must be default constructible. */ template class TrackedObjectPool : public ObjectPool { private: typedef ObjectPool BasePool; public: /** * @brief Pool statistics. */ class Stats : public BasePool::Stats { public: size_t m_currentInUseCount; size_t m_maximumInUseCount; }; /** * @brief Constructor. * * @param initialFreeListSize how many objects to create initially. * @param maximumAllowedFreeListSize maximum allowed free list size, or 0 for no upper bound. */ TrackedObjectPool(const size_t initialFreeListSize = 0, const size_t maximumAllowedFreeListSize = 0) : ObjectPool(initialFreeListSize, maximumAllowedFreeListSize), m_maximumInUseCount(0) { } /** * @brief Destructor. * * All objects in the pool, or allocated, are destroyed. */ ~TrackedObjectPool() { DestroyAll(); } /** * @brief Get an object from the pool. * * If the free list is non-empty, an object from it is returned, *without* invoking the object's constructor. Otherwise, * a new object is allocated. * * @return Pointer to an object, or 0 if the heap is empty. */ T *Get() { T * const pObject = BasePool::Get(); (void) m_inUseSet.insert(pObject); if (m_inUseSet.size() > m_maximumInUseCount) m_maximumInUseCount = m_inUseSet.size(); return pObject; } /** * @brief Return an in use object to the pool. * * The object will be deleted if the free list is already full. Otherwise, it is added to the free list *without* * invoking the object's destructor. * * @param pObject Pointer to object to return. * * @return true if object was returned to the pool or deleted, false if object was not allocated by the pool. */ bool Return(T * const pObject) { typename ObjectSet::iterator iter = m_inUseSet.find(pObject); if (m_inUseSet.end() == iter) return false; m_inUseSet.erase(iter); return BasePool::Return(pObject); } /** * @brief Return all in use objects to the pool (invalidates all in use pointers). * * Some objects may be deleted if the free list maximum size isn't sufficient to hold all in use objects. */ void ReturnAll() { // Move from the in use set to the free list. Boost::range::push_back(this->m_freeList, m_inUseSet); m_inUseSet.clear(); // And trim if necessary. if ((0 != this->m_maximumAllowedFreeListSize) && (this->m_freeList.size() > this->m_maximumAllowedFreeListSize)) { std::for_each(this->m_freeList.begin() + this->m_maximumAllowedFreeListSize, this->m_freeList.end(), DeleteObject()); this->m_freeList.erase(this->m_freeList.begin() + this->m_maximumAllowedFreeListSize, this->m_freeList.end()); } } /** * @brief Destroy all objects allocated by the pool (those currently in use and in the free list). */ void DestroyAll() { std::for_each(m_inUseSet.begin(), m_inUseSet.end(), DeleteObject()); m_inUseSet.clear(); std::for_each(this->m_freeList.begin(), this->m_freeList.end(), DeleteObject()); this->m_freeList.clear(); } /** * @brief Get statistics. * * @return Stats. */ Stats GetStats() const { Stats stats; static_cast(stats) = BasePool::GetStats(); stats.m_currentInUseCount = m_inUseSet.size(); stats.m_maximumInUseCount = m_maximumInUseCount; return stats; } /** * @brief Get the approximate memory usage of this object, objects in the free-list and objects in use. * * Note this can be a slow operation. * * @return Approximate memory usage in bytes. */ size_t GetMemoryUsage() const { size_t memoryUsage = ObjectPool::GetMemoryUsage(); memoryUsage += sizeof(*this) - sizeof(ObjectPool); // This will be low; we can't easily account for node size. memoryUsage += m_inUseSet.size() * sizeof(typename ObjectSet::value_type); for (typename ObjectSet::const_iterator iter = m_inUseSet.begin(), iterEnd = m_inUseSet.end(); iter != iterEnd; ++iter) { const T * const pObject = *iter; if (0 != pObject) memoryUsage += pObject->GetMemoryUsage(); } return memoryUsage; } private: typedef std::set ObjectSet; ObjectSet m_inUseSet; ///< Set of objects in currently use. size_t m_maximumInUseCount; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Object pool singleton. * * This pool provides no built-in thread safety. * * T the type of pool to create (ObjectPool or TrackedObjectPool). * INITIAL_FREE_LIST_SIZE the initial size of the free list. * MAX_FREE_LIST_SIZE the maximum size of the free list. 0 is no upper bound. */ template class ObjectPoolSingleton : public Singleton >, public T { public: ACTIV_BOOST_STATIC_ASSERT((0 == MAX_FREE_LIST_SIZE) || (INITIAL_FREE_LIST_SIZE <= MAX_FREE_LIST_SIZE)); /** * @brief Get a reference to the singleton instance. * * @return Reference. */ static ObjectPoolSingleton &GetInstance(); private: /** * @brief Private constructor (singleton class). */ ObjectPoolSingleton() : T(INITIAL_FREE_LIST_SIZE, MAX_FREE_LIST_SIZE) { } friend class Singleton >; }; // --------------------------------------------------------------------------------------------------------------------------------- template ObjectPoolSingleton & ObjectPoolSingleton::GetInstance() { static ObjectPoolSingleton ObjectPoolSingleton; return ObjectPoolSingleton; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Helper class to get an object from an ObjectPool and return it when the helper goes out of scope. * * T is the ObjectPool type. */ template class ScopedPooledObject { public: typedef typename T::ObjectType ObjectType; /** * @brief Constructor. * * @throw Exception if can't allocate an object from the pool. */ ScopedPooledObject(T &objectPool) : m_objectPool(objectPool), m_p(objectPool.Get()) { if (0 == m_p) ACTIV_THROW(StatusCodeException, STATUS_CODE_HEAP_EMPTY); } /** * @brief Destructor. * * Returns the object to the pool. */ ~ScopedPooledObject() { (void) m_objectPool.Return(m_p); } /** * @brief Object accessor. * * @return Reference to the object. */ ObjectType &operator()() { return *m_p; } /** * @brief Object accessor. * * @return Const reference to the object. */ const ObjectType &operator()() const { return *m_p; } private: T & m_objectPool; ObjectType * const m_p; }; } // namespace Activ #endif // (!defined ACTIV_MISC_OBJECT_POOL_H)