tklb::memory::MemoryPool Class Reference

Memory pool interface. More...

#include <TMemoryPool.hpp>

Inheritance diagram for tklb::memory::MemoryPool:

Collaboration diagram for tklb::memory::MemoryPool:

Classes
struct	Block
	Struct used to mark every allocation;. More...
struct	SharedPool
	Pools can share the same space, but use it differently. More...

Public Member Functions
	MemoryPool (void *pool, Size size)
	Construct a pool from memory provided. More...
	~MemoryPool ()
Size	getAllocated () const
Size	getTotalSize () const
virtual void *	allocate (Size size)=0
virtual void	deallocate (void *ptr)=0
virtual void *	reallocate (void *ptr, size_t size)=0
void *	clearallocate (size_t num, size_t size)
	Allocates space for num of structs with size size and clears the memory. More...
template<class T , typename ... Args>
T *	create (Args &&... args)
	Acts like new. More...
template<class T , typename ... Args>
T *	createArray (size_t count, Args &&... args)
template<class T >
void	dispose (T *ptr)
	Acts like delete. More...
template<class T >
void	disposeArray (size_t count, T *ptr)
	Acts like delete. More...
void	deallocateAligned (void *ptr)
void *	allocateAligned (const Size size, const Size align=DEFAULT_ALIGN)
	Allocate aligned if simd is enabled. More...

Protected Types
using	Size = uintptr_t
using	Byte = unsigned char
using	Mutex = SpinLock
using	Lock = LockGuard< Mutex >

Protected Attributes
SharedPool &	mPool

Static Protected Attributes
static constexpr Size	DEFAULT_ALIGN = xsimd::default_arch::alignment()

Detailed Description

Memory pool interface.

Definition at line 22 of file TMemoryPool.hpp.

Member Typedef Documentation

Byte

using tklb::memory::MemoryPool::Byte = unsigned char

protected

Definition at line 28 of file TMemoryPool.hpp.

Lock

using tklb::memory::MemoryPool::Lock = LockGuard<Mutex>

protected

Definition at line 30 of file TMemoryPool.hpp.

Mutex

using tklb::memory::MemoryPool::Mutex = SpinLock

protected

Definition at line 29 of file TMemoryPool.hpp.

Size

using tklb::memory::MemoryPool::Size = uintptr_t

protected

Definition at line 27 of file TMemoryPool.hpp.

Constructor & Destructor Documentation

MemoryPool()

tklb::memory::MemoryPool::MemoryPool ( void *  pool, Size  size  )

inline

Construct a pool from memory provided.

The first few bytes need to be zero to indicate when the pool needs to be initialized.

Definition at line 76 of file TMemoryPool.hpp.

                                          : mPool(*static_cast<SharedPool*>(pool)) {
            if (mPool.size == 0) { // New pool
                TKLB_ASSERT(sizeof(SharedPool) <= size)
                // Initialize pool
                SharedPool* p = new (pool) SharedPool();
                mPool.size = size - sizeof(SharedPool);
                mPool.memory = reinterpret_cast<Byte*>(p + 1);
            }
            TKLB_ASSERT(size == (mPool.size + sizeof(SharedPool)))
            mPool.users++;
        }

~MemoryPool()

tklb::memory::MemoryPool::~MemoryPool ( )

inline

Definition at line 88 of file TMemoryPool.hpp.

                      {
            TKLB_ASSERT(mPool.users != 0)
            mPool.users--;
            if (mPool.users == 0) {
                TKLB_ASSERT(mPool.allocated == 0)
            }
        }

Member Function Documentation

allocate()

virtual void * tklb::memory::MemoryPool::allocate ( Size  size )

pure virtual

Implemented in tklb::memory::MemoryPoolStack, and tklb::memory::MemoryPoolStd.

Here is the caller graph for this function:

allocateAligned()

void * tklb::memory::MemoryPool::allocateAligned ( const Size  size, const Size  align = DEFAULT_ALIGN  )

inline

Allocate aligned if simd is enabled.

Does a normal allocation otherwise.

Definition at line 173 of file TMemoryPool.hpp.

                                                                                 {
            // malloc is already already aligned to sizeof(size_t)
            void* result = allocate(size + align);
            if (result != nullptr && align != 0) {
                // Mask with zeroes at the end to floor the pointer to an aligned block
                const Size mask = ~(Size(align - 1));
                const Size pointer = reinterpret_cast<Size>(result);
                const Size floored = pointer & mask;
                const Size aligned = floored + align;
 
                // Not enough space before aligned memory to store original ptr
                // This only happens when malloc doesn't align to sizeof(size_t)
                TKLB_ASSERT(sizeof(Size) <= (aligned - pointer))
 
                result = reinterpret_cast<void*>(aligned);
                Size* original = reinterpret_cast<Size*>(result) - 1;
                *(original) = pointer;
            }
            TKLB_ASSERT(Size(result) % align == 0)
            return result;
        }

Here is the call graph for this function:

clearallocate()

void * tklb::memory::MemoryPool::clearallocate ( size_t  num, size_t  size  )

inline

Allocates space for num of structs with size size and clears the memory.

Parameters

num	Number of structs
size	Size of a single struct

Definition at line 111 of file TMemoryPool.hpp.

                                                     {
            const size_t total = size * num;
            void* ptr = allocate(total);
            if (ptr == nullptr) { return nullptr; }
            set(ptr, 0, total);
            return ptr;
        }

Here is the call graph for this function:

create()

template<class T , typename ... Args>

T * tklb::memory::MemoryPool::create ( Args &&...  args )

inline

Acts like new.

Allocate and construct object.

Parameters

args	Arguments passed to class contructor

Definition at line 124 of file TMemoryPool.hpp.

                                   {
            void* ptr = allocate(sizeof(T));
            if (ptr == nullptr) { return nullptr; }
            new (ptr) T(std::forward<Args>(args)...);
            return reinterpret_cast<T*>(ptr);
        }

Here is the call graph for this function:

createArray()

template<class T , typename ... Args>

T * tklb::memory::MemoryPool::createArray ( size_t  count, Args &&...  args  )

inline

Definition at line 132 of file TMemoryPool.hpp.

                                                      {
            unsigned char* ptr = reinterpret_cast<unsigned char*>(allocate(sizeof(T) * count));
            if (ptr == nullptr) { return nullptr; }
            for (size_t i = 0; i < count; i++) {
                new (ptr + i * sizeof(T)) T(std::forward<Args>(args)...);
            }
            return reinterpret_cast<T*>(ptr);
        }

Here is the call graph for this function:

deallocate()

virtual void tklb::memory::MemoryPool::deallocate ( void *  ptr )

pure virtual

Implemented in tklb::memory::MemoryPoolStack, and tklb::memory::MemoryPoolStd.

Here is the caller graph for this function:

deallocateAligned()

void tklb::memory::MemoryPool::deallocateAligned ( void *  ptr )

inline

Definition at line 163 of file TMemoryPool.hpp.

                                          {
            if (ptr == nullptr) { return; }
            // Get the orignal allocation address to free the memory
            deallocate(*(reinterpret_cast<void**>(ptr) - 1));
        }

Here is the call graph for this function:

dispose()

template<class T >

void tklb::memory::MemoryPool::dispose ( T *  ptr )

inline

Acts like delete.

Destroy the object and dispose the memory.

Definition at line 145 of file TMemoryPool.hpp.

                             {
            if (ptr == nullptr) { return; }
            ptr->~T();
            deallocate(ptr);
        }

Here is the call graph for this function:

disposeArray()

template<class T >

void tklb::memory::MemoryPool::disposeArray ( size_t  count, T *  ptr  )

inline

Acts like delete.

Destroy the object and dispose the memory.

Definition at line 155 of file TMemoryPool.hpp.

                                                {
            if (ptr == nullptr) { return; }
            for (size_t i = 0; i < count; i++) {
                (ptr + i * sizeof(T))->~T();
            }
            deallocate(ptr);
        }

Here is the call graph for this function:

getAllocated()

Size tklb::memory::MemoryPool::getAllocated ( ) const

inline

Definition at line 96 of file TMemoryPool.hpp.

{ return mPool.allocated; }

getTotalSize()

Size tklb::memory::MemoryPool::getTotalSize ( ) const

inline

Definition at line 98 of file TMemoryPool.hpp.

{ return mPool.size; }

reallocate()

virtual void * tklb::memory::MemoryPool::reallocate ( void *  ptr, size_t  size  )

pure virtual

Implemented in tklb::memory::MemoryPoolStack, and tklb::memory::MemoryPoolStd.

Member Data Documentation

DEFAULT_ALIGN

constexpr Size tklb::memory::MemoryPool::DEFAULT_ALIGN = xsimd::default_arch::alignment()

staticconstexprprotected

Definition at line 33 of file TMemoryPool.hpp.

mPool

SharedPool& tklb::memory::MemoryPool::mPool

protected

Definition at line 68 of file TMemoryPool.hpp.

---

The documentation for this class was generated from the following file:

• TMemoryPool.hpp