tklb::memory::MemoryPoolStd Class Reference

Pool which proxies allocations to the stdlib. More...

#include <TMemoryPoolStd.hpp>

Inheritance diagram for tklb::memory::MemoryPoolStd:

Collaboration diagram for tklb::memory::MemoryPoolStd:

Public Member Functions
void *	allocate (Size size) override
void	deallocate (void *ptr) override
void *	reallocate (void *ptr, size_t size) override
Public Member Functions inherited from tklb::memory::MemoryPool
	MemoryPool (void *pool, Size size)
	Construct a pool from memory provided. More...
	~MemoryPool ()
Size	getAllocated () const
Size	getTotalSize () const
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...

Static Public Member Functions
static MemoryPoolStd &	instance ()
	The pool uses the standard allocator So no need for multiple instances. More...

Private Member Functions
	MemoryPoolStd ()

Private Attributes
char	mDummyPool [sizeof(SharedPool)]
void *(*const	mAllocate )(size_t)

Additional Inherited Members
Protected Types inherited from tklb::memory::MemoryPool
using	Size = uintptr_t
using	Byte = unsigned char
using	Mutex = SpinLock
using	Lock = LockGuard< Mutex >
Protected Attributes inherited from tklb::memory::MemoryPool
SharedPool &	mPool
Static Protected Attributes inherited from tklb::memory::MemoryPool
static constexpr Size	DEFAULT_ALIGN = xsimd::default_arch::alignment()

Detailed Description

Pool which proxies allocations to the stdlib.

Needs to be included before the monkey patch.

Definition at line 14 of file TMemoryPoolStd.hpp.

Constructor & Destructor Documentation

MemoryPoolStd()

tklb::memory::MemoryPoolStd::MemoryPoolStd ( )

inlineprivate

Definition at line 17 of file TMemoryPoolStd.hpp.

: MemoryPool(mDummyPool, sizeof(SharedPool)) { }

Member Function Documentation

allocate()

void * tklb::memory::MemoryPoolStd::allocate ( Size  size )

inlineoverridevirtual

Implements tklb::memory::MemoryPool.

Definition at line 36 of file TMemoryPoolStd.hpp.

                                           {
            void* ptr = mAllocate(size + sizeof(Size));
            if (ptr == nullptr) { return nullptr; }
            mPool.allocated += size;
 
            SizeBlock& block = *static_cast<SizeBlock*>(ptr);
            block.size = size;
 
            return &block.ptr;
        }

Here is the caller graph for this function:

deallocate()

void tklb::memory::MemoryPoolStd::deallocate ( void *  ptr )

inlineoverridevirtual

Implements tklb::memory::MemoryPool.

Definition at line 47 of file TMemoryPoolStd.hpp.

                                            {
            if (ptr == nullptr) { return; }
            SizeBlock& block = *reinterpret_cast<SizeBlock*>(
                static_cast<char*>(ptr) - sizeof(Size)
            );
            mPool.allocated -= block.size;
            return mDeallocate(&block);
        }

instance()

static MemoryPoolStd & tklb::memory::MemoryPoolStd::instance ( )

inlinestatic

The pool uses the standard allocator So no need for multiple instances.

Definition at line 31 of file TMemoryPoolStd.hpp.

                                         {
            static MemoryPoolStd i;
            return i;
        }

reallocate()

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

inlineoverridevirtual

Implements tklb::memory::MemoryPool.

Definition at line 56 of file TMemoryPoolStd.hpp.

                                                          {
            if (ptr == nullptr) {
                return allocate(size);
            }
            void* ptrNew = mReallocate(ptr, size + sizeof(Size));
 
            SizeBlock& blockOld = *reinterpret_cast<SizeBlock*>(
                static_cast<char*>(ptr) - sizeof(Size)
            );
            mPool.allocated -= blockOld.size;
            if (ptrNew == nullptr) { return nullptr; }
 
            mPool.allocated += size;
 
            SizeBlock& blockNew = *static_cast<SizeBlock*>(ptr);
            blockNew.size = size;
 
            return &blockNew.ptr;
        }

Here is the call graph for this function:

Member Data Documentation

mAllocate

void *(*const tklb::memory::MemoryPoolStd::mAllocate) (size_t)

inlineprivate

Definition at line 18 of file TMemoryPoolStd.hpp.

                         {
            Size size;
            void* ptr;
        };

mDummyPool

char tklb::memory::MemoryPoolStd::mDummyPool[sizeof(SharedPool)]

private

Definition at line 16 of file TMemoryPoolStd.hpp.

---

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

• TMemoryPoolStd.hpp