MemoryPool #1

MemoryPool.hpp

#ifndef MEMORYPOOL_HPP
#define MEMORYPOOL_HPP

#include <cstdlib>

#define SliceCount 64

class MemoryPool
{
    public:
        MemoryPool(size_t inSize);
        virtual ~MemoryPool();

        void* acquire();
        void release(void* inSlice);
        inline size_t sliceSize() const { return mSize; }

    protected:
    private:
        struct Header
        {
            MemoryPool* pool;
            Header* next;
            Header* previous;
        };

        const size_t mSize;
        void* mBlock;
        void* mFree;
};

#endif

/// /// /// ///


#include "MemoryPool.hpp"
#include <cstring>
#include <cassert>
#include <iostream>

MemoryPool::MemoryPool(size_t inSize) : mSize(inSize)
{
    const size_t sliceSize = sizeof(Header) + mSize;
    mBlock = malloc(sliceSize * SliceCount);
    memset(mBlock, 0, sliceSize * SliceCount);

    Header* previous = NULL;

    for (size_t i = 0; i < SliceCount; ++i)
    {
        void* start = mBlock + (i * sliceSize);

        Header* header = static_cast<Header*>(start);
        header->pool = this;
        header->previous = previous;

        if (previous)
            previous->next = header;
        else
            mFree = header;

        previous = header;
    }
}

MemoryPool::~MemoryPool()
{
    free(mBlock);
}

void* MemoryPool::acquire()
{
    void* outResult = NULL;

    if (mFree)
    {
        Header* header = static_cast<Header*>(mFree);

        void* next = header->next;

        if (header->next)
            header->next->previous = header->previous;

        if (header->previous)
            header->previous->next = header->next;

        header->previous = NULL;
        header->next = NULL;

        outResult = mFree + sizeof(Header);
        mFree = next;
    }

    return outResult;
}

void MemoryPool::release(void* inSlice)
{
    if (inSlice)
    {
        Header* header = static_cast<Header*>(inSlice - sizeof(Header));
        assert(header->pool == this);

        if (mFree)
        {
            Header* freeHeader = static_cast<Header*>(mFree);
            freeHeader->previous = header;
            header->next = freeHeader;
        }

        mFree = header;
    }
}