ssInstancePool.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2015
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:     Steve Butrimas    Date: Jan 2015

#ifndef SS_INSTANCE_POOL_H
#define SS_INSTANCE_POOL_H

#include <memory>
#include <vector>
#include <algorithm>

template<class T>
struct ssInstancePoolTrait 
{
    
    // Constructs an object or array of type T. The memory is constructed
    // via the placement new operator but has the option of using recycled
    // memory (if ptr is not NULL) or allocating a new block.
     
    static T* construct(int count, void *pointer)
    {
        if(pointer) 
            return new (pointer) T();
        
        else 
            return new (malloc( count * sizeof(T) )) T();
    }

    
    // Destroys an object or array of type T. Calling the object's
    // destructor will be made to. If destroy is true, the memory block 
    // will be deleted with free().

    static void destruct(T *pointer, bool Free)
    {
        if(!pointer) 
            return;

        if(Free) 
            free(pointer);
        else
            pointer->~T();
    }

};

template<class T, class Trait>
struct DeleteAll
{
    void operator() (T *instance) const
    {
        Trait::destruct(instance, true);
    }
};




// ssInstancePool is a template class that implements a memory pool design. 
// The premise behind the pool is reuse of memory to avoid unnecessary
// allocation and deallocation of memory. This class will hold onto memory blocks
// for subsequent reuse and avoid the allocation overhead.
// 
// TODO: Consider/Implement multithread safety on the memory pool access
 
template<class T, class Trait = ssInstancePoolTrait<T> >
class ssInstancePool 
{
    public:
        typedef std::vector<T *> pool_container;
        typedef typename pool_container::iterator iterator;

        ssInstancePool(int num  = 1 ) : n_number(num)
        {}

        ~ssInstancePool()
        {
            clear();
        }

        // This will retrieve the memory from the pool utilizing
        // the trait property to dictate how the memory is obtained
        T *obtain()
        {
            T *ptr = NULL;
        
            if( !m_InstancePool.empty()) {
            
                ptr = m_InstancePool.back();
            
                m_InstancePool.pop_back();
            }
            
            ptr = Trait::construct(n_number,ptr);         
               
            return ptr;
        }

        // Return the pointer to the pool dictated by the trait behavior
        void recycle(T *ptr)
        {
            if(!ptr) return;

            Trait::destruct(ptr,false);

            m_InstancePool.push_back(ptr);
        }

        size_t size()
        { 
            return m_InstancePool.size(); 
        }

        void clear() 
        { 
            // Must use the same trait for deletion functor to avoid undefined behavior
            for_each(m_InstancePool.begin(), m_InstancePool.end(), DeleteAll<T, Trait>());

            m_InstancePool.clear();

            // Apply swap trick to clear out vector
            pool_container(m_InstancePool).swap(m_InstancePool);
        }

    private:

        pool_container m_InstancePool;
        int n_number;
    
        // Prevent unwanted compiler generated default assignment and copy operators
        ssInstancePool(const ssInstancePool &);
        ssInstancePool &operator=(const ssInstancePool &);
};

#endif