genericmemorypool.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
#include "core/types.h"
#include "threading/safequeue.h"
 
//------------------------------------------------------------------------------
namespace Base
{
class GenericMemoryPool
{
public:
    GenericMemoryPool();
    ~GenericMemoryPool();
    static uint ComputeAlignedBlockSize(uint blockSize);
    void Setup(Memory::HeapType heapType, uint blockSize, uint numBlocks);
    void* Alloc();
    void Free(void* ptr);
    bool IsPoolBlock(void* ptr) const;
    uint GetNumBlocks() const;
    uint GetBlockSize() const;
    uint GetAlignedBlockSize() const;
    uint GetPoolSize() const;
    #if NEBULA_MEMORY_STATS
    uint GetAllocCount() const;
    #endif
 
private:
    static const uint FreeBlockPattern = 0xFE;
    static const uint NewBlockPattern = 0xFD;
    static const int  BlockAlign = 16;
 
    Memory::HeapType heapType;
    uint blockSize;
    uint alignedBlockSize;
    uint poolSize;
    uint numBlocks;
    #if NEBULA_MEMORY_STATS
    volatile long allocCount;
    #endif
    
    Threading::SafeQueue<ubyte*> freeList;
    ubyte* poolStart;
    ubyte* poolEnd;
};
 
//------------------------------------------------------------------------------
#if NEBULA_MEMORY_STATS
inline uint
GenericMemoryPool::GetAllocCount() const
{
    return this->allocCount;
}
#endif
 
//------------------------------------------------------------------------------
inline uint
GenericMemoryPool::ComputeAlignedBlockSize(uint blockSize)
{
    uint blockSizeWithHeader = blockSize;
    uint padding = (BlockAlign - (blockSizeWithHeader % BlockAlign)) % BlockAlign;
    return (blockSizeWithHeader + padding);
}
 
//------------------------------------------------------------------------------
inline uint
GenericMemoryPool::GetNumBlocks() const
{
    return this->numBlocks;
}
 
//------------------------------------------------------------------------------
inline uint
GenericMemoryPool::GetBlockSize() const
{
    return this->blockSize;
}
 
//------------------------------------------------------------------------------
inline uint
GenericMemoryPool::GetAlignedBlockSize() const
{
    return this->alignedBlockSize;
}
 
//------------------------------------------------------------------------------
inline uint
GenericMemoryPool::GetPoolSize() const
{
    return this->poolSize;
}
 
//------------------------------------------------------------------------------
inline bool
GenericMemoryPool::IsPoolBlock(void* ptr) const
{
    return (ptr >= this->poolStart) && (ptr < this->poolEnd);
}
 
} // namespace Base
//------------------------------------------------------------------------------