sekaita.com

#pragma once

namespace util
{
    template<typename T> class MemoryPool
    {
    public:
        MemoryPool(unsigned int capacity) : m_size(0), m_freeHead(0),
            m_buffer(nullptr), m_full(false)
        {
            if(capacity == 0)
            {
                throw std::exception("invalid memory pool capacity specified.");
            }

            m_size = capacity;
            m_buffer = (T*)::operator new(sizeof(T) * m_size);

            for(unsigned int offset = 0; offset < m_size; ++offset)
            {   // set each free object to point to the next
                *(reinterpret_cast<unsigned int*>(&(m_buffer[offset]))) =
                    offset + 1;
            }
            // the last entry in the free-list points to itself
            *(reinterpret_cast<unsigned int*>(&(m_buffer[m_size - 1]))) =
                m_size - 1;
        }

        ~MemoryPool()
        {
            delete m_buffer;
        }

        T* Create()
        {
            if(m_full == true)
            {
                return nullptr;
            }

            T* freeObject = &m_buffer[m_freeHead];
            unsigned int newHead =
                *(reinterpret_cast<unsigned int*>(&(m_buffer[m_freeHead])));
            // if the next free-list object is this object, the free-list has
            // been exhausted and the pool is full
            if(newHead == m_freeHead)
            {
                m_full = true;
            }

            m_freeHead = newHead;

            freeObject = new(freeObject) T();
            return freeObject;
        }

        bool Destroy(T* object)
        {
            unsigned int objectOffset = (object - &m_buffer[0]);

            if(objectOffset >= m_size || object < &m_buffer[0])
            {
                return false;
            }

            object->~T();

            if(m_full == true)
            {
                m_freeHead = objectOffset;
                m_full = false;
            }

            *(reinterpret_cast<unsigned int*>(&(m_buffer[objectOffset]))) =
                m_freeHead;

            m_freeHead = objectOffset;
            return true;
        }
    private:
        unsigned int m_size;
        unsigned int m_freeHead;
        T* m_buffer;
        bool m_full;
    };    
}

#include <vector>
#include <string>
#include <ctime>
#include <iostream>
#include <conio.h>
#include <assert.h>

#include "MemoryPool.h"

namespace test
{
    struct obj
    {
        obj() : i(1), f(2.0f), b(true)
        {}

        int i;
        float f;
        bool b;
    };

    template<typename T> class MemoryPoolAllocator
    {
    public:
        MemoryPoolAllocator(unsigned int objectCount) :
          m_memoryPool(objectCount), m_objectCount(objectCount)
          {}

          T* Create()
          {
              return m_memoryPool.Create();
          }

          bool Destroy(T* objectPtr)
          {
              return m_memoryPool.Destroy(objectPtr);
          }

          std::string Name()
          {
              return "memory pool";
          }

          unsigned int Size()
          {
              return m_objectCount;
          }
    private:
        util::MemoryPool<T> m_memoryPool;
        unsigned int m_objectCount;
    };

    template<typename T> class DefaultAllocator
    {
    public:
        DefaultAllocator(unsigned int objectCount) :
          m_objectCount(objectCount)
          {}

          T* Create()
          {
              return new T();
          }

          bool Destroy(T* objectPtr)
          {
              delete objectPtr;
              return true;
          }

          std::string Name()
          {
              return "default allocator";
          }

          unsigned int Size()
          {
              return m_objectCount;
          }
    private:
        unsigned int m_objectCount;
    };

    template<typename T> void TimeAllocator(T& allocator)
    {
        std::time_t timeVal = std::time(nullptr);
        std::vector<obj*> objects;
        const unsigned int objectCount = allocator.Size();

        std::cout << allocator.Name() << " test started - creating " << objectCount <<
            " objects: " << std::asctime(std::localtime(&timeVal));
        clock_t createStarted = clock();

        for(unsigned int i = objectCount; i-- > 0;)
        {
            obj* object = allocator.Create();
            objects.push_back(object);
            assert(object != nullptr);
        }

        clock_t createStopped = clock();
        std::cout << allocator.Name() << " test stopped - creating " << objectCount <<
            " objects: " << std::asctime(std::localtime(&timeVal));
        float createDuration = 1000.0f * (((float)createStopped - createStarted) / CLOCKS_PER_SEC);
        std::cout << "duration: " << createDuration << "ms" << std::endl;

        std::cout << allocator.Name() << " test started - destroying " << objectCount <<
            " objects: " << std::asctime(std::localtime(&timeVal));
        clock_t destroyStarted = clock();

        for(unsigned int i = 0; i < objectCount; ++i)
        {
            obj* objectPtr = objects[i];
            bool result = allocator.Destroy(objectPtr);
            assert(result == true);
        }

        clock_t destroyStopped = clock();
        std::cout << allocator.Name() << " test stopped - destroying " << objectCount <<
            " objects: " << std::asctime(std::localtime(&timeVal));
        float destroyDuration = 1000.0f * (((float)destroyStopped - destroyStarted) / CLOCKS_PER_SEC);
        std::cout << "duration: " << destroyDuration << "ms" << std::endl;
    }

    void TimeTest()
    {
        const unsigned int objectCount = 1024 * 256;

        MemoryPoolAllocator<obj> memoryPoolAllocator(objectCount);
        TimeAllocator(memoryPoolAllocator);

        DefaultAllocator<obj> defaultAllocator(objectCount);
        TimeAllocator(defaultAllocator);
    }

    void OverCapacityTest()
    {
        const unsigned int objectCount = 3;
        util::MemoryPool<obj> memoryPool(objectCount);
        std::vector<obj*> objects;

        for(int i = objectCount; i-- > 0;)
        {
            objects.push_back(memoryPool.Create());
        }
        // try to create from full pool
        obj* createFailed = memoryPool.Create();
        assert(createFailed == nullptr);
    }

    void DeleteExternalObjectTest()
    {
        const unsigned int objectCount = 3;
        util::MemoryPool<obj> memoryPool(objectCount);
        std::vector<obj*> objects;

        for(int i = objectCount; i-- > 0;)
        {
            objects.push_back(memoryPool.Create());
        }
        // try to destroy object not belonging to pool
        obj* externalObject = new obj();
        bool destroyFailed = memoryPool.Destroy(externalObject);
        delete externalObject;
        assert(destroyFailed == false);

        for(int i = 0; i < objectCount; ++i)
        {
            obj* objectPtr = objects[i];
            memoryPool.Destroy(objectPtr);
        }
    }
}

int main(int argc, char* argv[])
{
    using namespace test;

    TimeTest();
    OverCapacityTest();
    DeleteExternalObjectTest();

    _getch();
    return 0;
}