Switch from Nz prefix to namespace Nz
What a huge commit Former-commit-id: 38ac5eebf70adc1180f571f6006192d28fb99897
This commit is contained in:
Lynix
@@ -6,140 +6,143 @@
|
||||
#include <utility>
|
||||
#include <Nazara/Core/Debug.hpp>
|
||||
|
||||
inline NzMemoryPool::NzMemoryPool(unsigned int blockSize, unsigned int size, bool canGrow) :
|
||||
m_freeCount(size),
|
||||
m_previous(nullptr),
|
||||
m_canGrow(canGrow),
|
||||
m_blockSize(blockSize),
|
||||
m_size(size)
|
||||
namespace Nz
|
||||
{
|
||||
m_pool.reset(new nzUInt8[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 NzMemoryPool::NzMemoryPool(NzMemoryPool&& pool) noexcept
|
||||
{
|
||||
operator=(std::move(pool));
|
||||
}
|
||||
|
||||
inline NzMemoryPool::NzMemoryPool(NzMemoryPool* pool) :
|
||||
NzMemoryPool(pool->m_blockSize, pool->m_size, pool->m_canGrow)
|
||||
{
|
||||
m_previous = pool;
|
||||
}
|
||||
|
||||
inline void* NzMemoryPool::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)
|
||||
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)
|
||||
{
|
||||
if (m_freeCount > 0)
|
||||
return m_freeList[--m_freeCount];
|
||||
else if (m_canGrow)
|
||||
{
|
||||
if (!m_next)
|
||||
m_next.reset(new NzMemoryPool(this));
|
||||
m_pool.reset(new UInt8[blockSize * size]);
|
||||
m_freeList.reset(new void*[size]);
|
||||
|
||||
return m_next->Allocate(size);
|
||||
}
|
||||
// Remplissage de la free list
|
||||
for (unsigned int i = 0; i < size; ++i)
|
||||
m_freeList[i] = &m_pool[m_blockSize * (size-i-1)];
|
||||
}
|
||||
|
||||
return NzOperatorNew(size);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void NzMemoryPool::Delete(T* ptr)
|
||||
{
|
||||
///DOC: Va appeler le destructeur de l'objet avant de le libérer
|
||||
if (ptr)
|
||||
inline MemoryPool::MemoryPool(MemoryPool&& pool) noexcept
|
||||
{
|
||||
ptr->~T();
|
||||
Free(ptr);
|
||||
operator=(std::move(pool));
|
||||
}
|
||||
}
|
||||
|
||||
inline void NzMemoryPool::Free(void* ptr)
|
||||
{
|
||||
///DOC: Si appelé avec un pointeur ne faisant pas partie du pool, l'opérateur delete est utilisé
|
||||
if (ptr)
|
||||
inline MemoryPool::MemoryPool(MemoryPool* pool) :
|
||||
MemoryPool(pool->m_blockSize, pool->m_size, pool->m_canGrow)
|
||||
{
|
||||
// Le pointeur nous appartient-il ?
|
||||
nzUInt8* freePtr = static_cast<nzUInt8*>(ptr);
|
||||
nzUInt8* poolPtr = m_pool.get();
|
||||
if (freePtr >= poolPtr && freePtr < poolPtr + m_blockSize*m_size)
|
||||
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 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)
|
||||
if (m_freeCount > 0)
|
||||
return m_freeList[--m_freeCount];
|
||||
else if (m_canGrow)
|
||||
{
|
||||
m_previous->m_next.release();
|
||||
delete this; // Suicide
|
||||
if (!m_next)
|
||||
m_next.reset(new MemoryPool(this));
|
||||
|
||||
return m_next->Allocate(size);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
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)
|
||||
{
|
||||
if (m_next)
|
||||
m_next->Free(ptr);
|
||||
else
|
||||
NzOperatorDelete(ptr);
|
||||
ptr->~T();
|
||||
Free(ptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline unsigned int NzMemoryPool::GetBlockSize() const
|
||||
{
|
||||
return m_blockSize;
|
||||
}
|
||||
|
||||
inline unsigned int NzMemoryPool::GetFreeBlocks() const
|
||||
{
|
||||
return m_freeCount;
|
||||
}
|
||||
|
||||
inline unsigned int NzMemoryPool::GetSize() const
|
||||
{
|
||||
return m_size;
|
||||
}
|
||||
|
||||
template<typename T, typename... Args>
|
||||
inline T* NzMemoryPool::New(Args&&... args)
|
||||
{
|
||||
///DOC: Permet de construire un objet directement dans le pook
|
||||
T* object = static_cast<T*>(Allocate(sizeof(T)));
|
||||
NzPlacementNew<T>(object, std::forward<Args>(args)...);
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
inline NzMemoryPool& NzMemoryPool::operator=(NzMemoryPool&& 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)
|
||||
inline void MemoryPool::Free(void* ptr)
|
||||
{
|
||||
m_previous->m_next.release();
|
||||
m_previous->m_next.reset(this);
|
||||
///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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return *this;
|
||||
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>
|
||||
|
||||
Reference in New Issue
Block a user