General purpose memory allocation routines with the ability to allocate from thread specific memory pools. More...

#include <NekMemoryManager.hpp>

Classes
struct	rebind

Static Public Member Functions
static void	Deallocate (DataType *&data)
	Deallocate a pointer allocated by MemoryManager::Allocate.

template<typename... Args>
static DataType *	Allocate (const Args &...args)
	Allocates a single object from the memory pool.

template<typename... Args>
static std::shared_ptr< DataType >	AllocateSharedPtr (const Args &...args)
	Allocate a shared pointer from the memory pool.

template<typename DeallocatorType , typename... Args>
static std::shared_ptr< DataType >	AllocateSharedPtrD (const DeallocatorType &d, const Args &...args)

static DataType *	RawAllocate (size_t NumberOfElements)
	Allocates a chunk of raw, uninitialized memory, capable of holding NumberOfElements objects.

static void	RawDeallocate (DataType *array, size_t NumberOfElements)
	Deallocates memory allocated from RawAllocate.

Allocator Interface
The allocator interface allows a MemoryManager object to be used in any object that allows an allocator parameter, such as STL containers.
typedef DataType	value_type

typedef size_t	size_type

typedef ptrdiff_t	difference_type

typedef DataType *	pointer

typedef const DataType *	const_pointer

typedef DataType &	reference

typedef const DataType &	const_reference

	MemoryManager ()

template<typename T >
	MemoryManager (const MemoryManager< T > &rhs)=delete

	~MemoryManager ()

pointer	address (reference r) const

const_pointer	address (const_reference r) const

pointer	allocate (size_type n)

void	deallocate (pointer p, size_type n)

void	construct (pointer p, const_reference val)

void	destroy (pointer p)

size_type	max_size ()

Detailed Description

template<typename DataType>
class Nektar::MemoryManager< DataType >

General purpose memory allocation routines with the ability to allocate from thread specific memory pools.

If compiled with NEKTAR_MEMORY_POOL_ENABLED, the MemoryManager allocates from thread specific memory pools for small objects. Large objects are managed with the system supplied new/delete. These memory pools provide faster allocation and deallocation of small objects (particularly useful for shared pointers which allocate many 4 byte objects).

Warning: All memory allocated from the memory manager must be returned to the memory manager. Calling delete on memory allocated from the manager will likely cause undefined behavior. A particularly subtle violation of this rule occurs when giving memory allocated from the manager to a shared pointer.
std::shared_ptr<Obj> f(MemoryManager<Obj>::Allocate());

Nektar::MemoryManager
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
Definition NekMemoryManager.hpp:81

Shared pointers call delete when they go out of scope, so this line of code will cause problems. Instead, you should call the AllocateSharedPtr method:
std::shared_ptr<Obj> f = MemoryManager<Obj>::AllocateSharedPtr();

Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition NekMemoryManager.hpp:167

Definition at line 80 of file NekMemoryManager.hpp.

Member Typedef Documentation

◆ const_pointer

template<typename DataType >

typedef const DataType* Nektar::MemoryManager< DataType >::const_pointer

Definition at line 241 of file NekMemoryManager.hpp.

◆ const_reference

template<typename DataType >

typedef const DataType& Nektar::MemoryManager< DataType >::const_reference

Definition at line 243 of file NekMemoryManager.hpp.

◆ difference_type

template<typename DataType >

typedef ptrdiff_t Nektar::MemoryManager< DataType >::difference_type

Definition at line 239 of file NekMemoryManager.hpp.

◆ pointer

template<typename DataType >

typedef DataType* Nektar::MemoryManager< DataType >::pointer

Definition at line 240 of file NekMemoryManager.hpp.

◆ reference

template<typename DataType >

typedef DataType& Nektar::MemoryManager< DataType >::reference

Definition at line 242 of file NekMemoryManager.hpp.

◆ size_type

template<typename DataType >

typedef size_t Nektar::MemoryManager< DataType >::size_type

Definition at line 238 of file NekMemoryManager.hpp.

◆ value_type

template<typename DataType >

typedef DataType Nektar::MemoryManager< DataType >::value_type

Definition at line 237 of file NekMemoryManager.hpp.

Constructor & Destructor Documentation

◆ MemoryManager() [1/2]

template<typename DataType >

Nektar::MemoryManager< DataType >::MemoryManager ( )

inline

Definition at line 245 of file NekMemoryManager.hpp.

246 {

247 }

◆ MemoryManager() [2/2]

template<typename DataType >

template<typename T >

Nektar::MemoryManager< DataType >::MemoryManager ( const MemoryManager< T > & rhs )

delete

◆ ~MemoryManager()

template<typename DataType >

Nektar::MemoryManager< DataType >::~MemoryManager ( )

inline

Definition at line 249 of file NekMemoryManager.hpp.

250 {

251 }

Member Function Documentation

◆ address() [1/2]

template<typename DataType >

const_pointer Nektar::MemoryManager< DataType >::address ( const_reference r ) const

inline

Definition at line 257 of file NekMemoryManager.hpp.

    {
        return &r;
    }

◆ address() [2/2]

template<typename DataType >

pointer Nektar::MemoryManager< DataType >::address ( reference r ) const

inline

Definition at line 253 of file NekMemoryManager.hpp.

    {
        return &r;
    }

◆ Allocate()

template<typename DataType >

template<typename... Args>

static DataType * Nektar::MemoryManager< DataType >::Allocate ( const Args &... args )

inlinestatic

Allocates a single object from the memory pool.

Exceptions

unknown Any exception thrown by DataType's default constructor will propogate through this method.

The allocated object must be returned to the memory pool via Deallocate.

Definition at line 149 of file NekMemoryManager.hpp.

    {
#ifdef NEKTAR_USE_ALIGNED_MEM
        void *ptr = aligned_alloc(tinysimd::simd<NekDouble>::alignment,
                                  sizeof(DataType));
        return new (ptr) DataType(args...);
#else
        return new DataType(args...);
#endif
    }

Referenced by Nektar::MemoryManager< DataType >::AllocateSharedPtrD().

◆ allocate()

template<typename DataType >

pointer Nektar::MemoryManager< DataType >::allocate ( size_type n )

inline

Definition at line 262 of file NekMemoryManager.hpp.

    {
        return RawAllocate(n);
    }

References Nektar::MemoryManager< DataType >::RawAllocate().

◆ AllocateSharedPtr()

template<typename DataType >

template<typename... Args>

static std::shared_ptr< DataType > Nektar::MemoryManager< DataType >::AllocateSharedPtr ( const Args &... args )

inlinestatic

Allocate a shared pointer from the memory pool.

The shared pointer does not need to be returned to the memory pool. When the reference count to this object reaches 0, the shared pointer will automatically return the memory.

Definition at line 167 of file NekMemoryManager.hpp.

    {
        return AllocateSharedPtrD([](DataType *) {}, args...);
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtrD().

◆ AllocateSharedPtrD()

template<typename DataType >

template<typename DeallocatorType , typename... Args>

static std::shared_ptr< DataType > Nektar::MemoryManager< DataType >::AllocateSharedPtrD	(	const DeallocatorType &	d,
		const Args &...	args
	)

inlinestatic

Definition at line 173 of file NekMemoryManager.hpp.

    {
        DataType *data = Allocate(args...);
        return std::shared_ptr<DataType>(data, [=](DataType *ptr) {
            d(ptr);
            MemoryManager<DataType>::Deallocate(ptr);
        });
    }

References Nektar::MemoryManager< DataType >::Allocate(), and Nektar::MemoryManager< DataType >::Deallocate().

Referenced by Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::CreateStorage().

◆ construct()

template<typename DataType >

void Nektar::MemoryManager< DataType >::construct	(	pointer	p,
		const_reference	val
	)

inline

Definition at line 272 of file NekMemoryManager.hpp.

    {
        new (p) DataType(val);
    }

◆ Deallocate()

template<typename DataType >

static void Nektar::MemoryManager< DataType >::Deallocate ( DataType *& data )

inlinestatic

Deallocate a pointer allocated by MemoryManager::Allocate.

Note: Results are undefined if called with a pointer to something that was not allocated with the memory manager.

Use this method to deallocate a pointer you have allocated from the MemoryManager using the Allocate method.

Example:

CustObj* c = MemoryManager::Allocate<CustObj>();

MemoryManager::Deallocate(c);

Definition at line 96 of file NekMemoryManager.hpp.

    {
#ifdef NEKTAR_MEMORY_POOL_ENABLED
        data->~DataType();
        GetMemoryPool().Deallocate(data, sizeof(DataType));
#else
#ifdef NEKTAR_USE_ALIGNED_MEM
        data->~DataType();
        free(data);
#else
        delete data;
#endif
#endif
 
        data = nullptr;
    }

References Nektar::MemPool::Deallocate(), and Nektar::GetMemoryPool().

Referenced by Nektar::MemoryManager< DataType >::AllocateSharedPtrD().

◆ deallocate()

template<typename DataType >

void Nektar::MemoryManager< DataType >::deallocate	(	pointer	p,
		size_type	n
	)

inline

Definition at line 267 of file NekMemoryManager.hpp.

    {
        return RawDeallocate(p, n);
    }

References Nektar::MemoryManager< DataType >::RawDeallocate().

◆ destroy()

template<typename DataType >

void Nektar::MemoryManager< DataType >::destroy ( pointer p )

inline

Definition at line 277 of file NekMemoryManager.hpp.

    {
        p->~DataType();
    }

◆ max_size()

template<typename DataType >

size_type Nektar::MemoryManager< DataType >::max_size ( )

inline

Definition at line 282 of file NekMemoryManager.hpp.

    {
        return std::numeric_limits<size_type>::max() / sizeof(DataType);
    }

◆ RawAllocate()

template<typename DataType >

static DataType * Nektar::MemoryManager< DataType >::RawAllocate ( size_t NumberOfElements )

inlinestatic

Allocates a chunk of raw, uninitialized memory, capable of holding NumberOfElements objects.

Parameters

NumberOfElements The number of elements the array should be capable of holding.

This method is not meant to be called by client code. Use Array instead. Any memory allocated from this method must be returned to the memory pool via RawDeallocate. Failure to do so will result in memory leaks and undefined behavior.

Definition at line 193 of file NekMemoryManager.hpp.

    {
#ifdef NEKTAR_MEMORY_POOL_ENABLED
        return static_cast<DataType *>(
            GetMemoryPool().Allocate(NumberOfElements * sizeof(DataType)));
#else // NEKTAR_MEMORY_POOL_ENABLED
#ifdef NEKTAR_USE_ALIGNED_MEM
        return static_cast<DataType *>(
            aligned_alloc(tinysimd::simd<NekDouble>::alignment,
                          NumberOfElements * sizeof(DataType)));
#else
        return static_cast<DataType *>(
            ::operator new(NumberOfElements * sizeof(DataType)));
#endif
#endif // NEKTAR_MEMORY_POOL_ENABLED
    }

References Nektar::MemPool::Allocate(), and Nektar::GetMemoryPool().

Referenced by Nektar::MemoryManager< DataType >::allocate(), Nektar::CreateStorage(), and Nektar::Array< OneD, const DataType >::CreateStorage().

◆ RawDeallocate()

template<typename DataType >

static void Nektar::MemoryManager< DataType >::RawDeallocate	(	DataType *	array,
		size_t	NumberOfElements
	)

inlinestatic

Deallocates memory allocated from RawAllocate.

Parameters

array	A pointer to the memory returned from RawAllocate.
NumberOfElements	The number of object held in the array.

This method is not meant to be called by client code. Use Array instead. Only memory allocated via RawAllocate should be returned to the pool here.

Definition at line 217 of file NekMemoryManager.hpp.

    {
#ifdef NEKTAR_MEMORY_POOL_ENABLED
        GetMemoryPool().Deallocate(array, sizeof(DataType) * NumberOfElements);
#else // NEKTAR_MEMORY_POOL_ENABLED
#ifdef NEKTAR_USE_ALIGNED_MEM
        free(array);
#else
        ::operator delete(array);
#endif
#endif // NEKTAR_MEMORY_POOL_ENABLED
    }

References Nektar::MemPool::Deallocate(), and Nektar::GetMemoryPool().

Referenced by Nektar::CreateStorage(), Nektar::MemoryManager< DataType >::deallocate(), Nektar::Array< OneD, const DataType >::operator=(), and Nektar::Array< OneD, const DataType >::~Array().

Classes

Static Public Member Functions

Allocator Interface

Detailed Description

Member Typedef Documentation

◆ const_pointer

◆ const_reference

◆ difference_type

◆ pointer

◆ reference

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ MemoryManager() [1/2]

◆ MemoryManager() [2/2]

◆ ~MemoryManager()

Member Function Documentation

◆ address() [1/2]

◆ address() [2/2]

◆ Allocate()

◆ allocate()

◆ AllocateSharedPtr()

◆ AllocateSharedPtrD()

◆ construct()

◆ Deallocate()

◆ deallocate()

◆ destroy()

◆ max_size()

◆ RawAllocate()

◆ RawDeallocate()