149 lines
3.5 KiB
C++
149 lines
3.5 KiB
C++
// Copyright (C) 2015 Jérôme Leclercq
|
|
// This file is part of the "Nazara Engine - Core module"
|
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
|
|
|
#include <Nazara/Core/MemoryHelper.hpp>
|
|
#include <utility>
|
|
#include <Nazara/Core/Debug.hpp>
|
|
|
|
namespace Nz
|
|
{
|
|
inline MemoryPool::MemoryPool(unsigned int blockSize, unsigned int size, bool canGrow) :
|
|
m_freeCount(size),
|
|
m_previous(nullptr),
|
|
m_canGrow(canGrow),
|
|
m_blockSize(blockSize),
|
|
m_size(size)
|
|
{
|
|
m_pool.reset(new UInt8[blockSize * size]);
|
|
m_freeList.reset(new void*[size]);
|
|
|
|
// Remplissage de la free list
|
|
for (unsigned int i = 0; i < size; ++i)
|
|
m_freeList[i] = &m_pool[m_blockSize * (size-i-1)];
|
|
}
|
|
|
|
inline MemoryPool::MemoryPool(MemoryPool&& pool) noexcept
|
|
{
|
|
operator=(std::move(pool));
|
|
}
|
|
|
|
inline MemoryPool::MemoryPool(MemoryPool* pool) :
|
|
MemoryPool(pool->m_blockSize, pool->m_size, pool->m_canGrow)
|
|
{
|
|
m_previous = pool;
|
|
}
|
|
|
|
inline void* MemoryPool::Allocate(unsigned int size)
|
|
{
|
|
///DOC: Si la taille est supérieure à celle d'un bloc du pool, l'opérateur new est utilisé
|
|
if (size <= m_blockSize)
|
|
{
|
|
if (m_freeCount > 0)
|
|
return m_freeList[--m_freeCount];
|
|
else if (m_canGrow)
|
|
{
|
|
if (!m_next)
|
|
m_next.reset(new MemoryPool(this));
|
|
|
|
return m_next->Allocate(size);
|
|
}
|
|
}
|
|
|
|
return OperatorNew(size);
|
|
}
|
|
|
|
template<typename T>
|
|
inline void MemoryPool::Delete(T* ptr)
|
|
{
|
|
///DOC: Va appeler le destructeur de l'objet avant de le libérer
|
|
if (ptr)
|
|
{
|
|
ptr->~T();
|
|
Free(ptr);
|
|
}
|
|
}
|
|
|
|
inline void MemoryPool::Free(void* ptr)
|
|
{
|
|
///DOC: Si appelé avec un pointeur ne faisant pas partie du pool, l'opérateur delete est utilisé
|
|
if (ptr)
|
|
{
|
|
// Le pointeur nous appartient-il ?
|
|
UInt8* freePtr = static_cast<UInt8*>(ptr);
|
|
UInt8* poolPtr = m_pool.get();
|
|
if (freePtr >= poolPtr && freePtr < poolPtr + m_blockSize*m_size)
|
|
{
|
|
#if NAZARA_CORE_SAFE
|
|
if ((freePtr - poolPtr) % m_blockSize != 0)
|
|
throw std::runtime_error("Invalid pointer (does not point to an element of the pool)");
|
|
#endif
|
|
|
|
m_freeList[m_freeCount++] = ptr;
|
|
|
|
// Si nous sommes vide et l'extension d'un autre pool, nous nous suicidons
|
|
if (m_freeCount == m_size && m_previous && !m_next)
|
|
{
|
|
m_previous->m_next.release();
|
|
delete this; // Suicide
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_next)
|
|
m_next->Free(ptr);
|
|
else
|
|
OperatorDelete(ptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline unsigned int MemoryPool::GetBlockSize() const
|
|
{
|
|
return m_blockSize;
|
|
}
|
|
|
|
inline unsigned int MemoryPool::GetFreeBlocks() const
|
|
{
|
|
return m_freeCount;
|
|
}
|
|
|
|
inline unsigned int MemoryPool::GetSize() const
|
|
{
|
|
return m_size;
|
|
}
|
|
|
|
template<typename T, typename... Args>
|
|
inline T* MemoryPool::New(Args&&... args)
|
|
{
|
|
///DOC: Permet de construire un objet directement dans le pook
|
|
T* object = static_cast<T*>(Allocate(sizeof(T)));
|
|
PlacementNew<T>(object, std::forward<Args>(args)...);
|
|
|
|
return object;
|
|
}
|
|
|
|
inline MemoryPool& MemoryPool::operator=(MemoryPool&& pool) noexcept
|
|
{
|
|
m_blockSize = pool.m_blockSize;
|
|
m_canGrow = pool.m_canGrow;
|
|
m_freeCount = pool.m_freeCount.load(std::memory_order_relaxed);
|
|
m_freeList = std::move(pool.m_freeList);
|
|
m_pool = std::move(pool.m_pool);
|
|
m_previous = pool.m_previous;
|
|
m_next = std::move(pool.m_next);
|
|
m_size = pool.m_size;
|
|
|
|
// Si nous avons été créés par un autre pool, nous devons le faire pointer vers nous de nouveau
|
|
if (m_previous)
|
|
{
|
|
m_previous->m_next.release();
|
|
m_previous->m_next.reset(this);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
}
|
|
|
|
#include <Nazara/Core/DebugOff.hpp>
|