Nektar::MemPool Class Reference

#include <ThreadSpecificPool.hpp>

Public Types
typedef std::map< size_t, std::shared_ptr< detail::ThreadSpecificPool > >	PoolMapType

Public Member Functions
	MemPool ()
	~MemPool ()
void *	Allocate (size_t bytes)
	Allocate a block of memory of size ByteSize.
void	Deallocate (void *p, size_t bytes)
	Deallocate memory claimed by an earlier call to allocate.

Private Attributes
detail::ThreadSpecificPool	m_fourBytePool
std::map< size_t, std::shared_ptr< detail::ThreadSpecificPool > >	m_pools
size_t	m_upperBound

Detailed Description

Definition at line 149 of file ThreadSpecificPool.hpp.

Member Typedef Documentation

PoolMapType

typedef std::map<size_t, std::shared_ptr<detail::ThreadSpecificPool> > Nektar::MemPool::PoolMapType

Definition at line 153 of file ThreadSpecificPool.hpp.

Constructor & Destructor Documentation

MemPool()

Nektar::MemPool::MemPool ( )

inline

Definition at line 156 of file ThreadSpecificPool.hpp.

              : m_fourBytePool(4), m_pools(), m_upperBound(1024)
    {
        // The m_pools data member stores a collection of thread specific pools
        // of varying size.  All memory requests up to and including the largest
        // pool size will be allocated from a pool (note that this means you may
        // receive more memory than you asked for).  For example, if there is a
        // pool for 8 bytes and the next largest pool is 32 bytes, then a
        // request for 10 bytes will return a 32 byte chunk of memory from the
        // 32 byte pool.
 
        typedef PoolMapType::value_type PairType;
        m_pools.insert(PairType(8, std::shared_ptr<detail::ThreadSpecificPool>(
                                       new detail::ThreadSpecificPool(8))));
        m_pools.insert(PairType(16, std::shared_ptr<detail::ThreadSpecificPool>(
                                        new detail::ThreadSpecificPool(16))));
        m_pools.insert(PairType(32, std::shared_ptr<detail::ThreadSpecificPool>(
                                        new detail::ThreadSpecificPool(32))));
        m_pools.insert(PairType(64, std::shared_ptr<detail::ThreadSpecificPool>(
                                        new detail::ThreadSpecificPool(64))));
        m_pools.insert(
            PairType(128, std::shared_ptr<detail::ThreadSpecificPool>(
                              new detail::ThreadSpecificPool(128))));
        m_pools.insert(
            PairType(256, std::shared_ptr<detail::ThreadSpecificPool>(
                              new detail::ThreadSpecificPool(256))));
        m_pools.insert(
            PairType(512, std::shared_ptr<detail::ThreadSpecificPool>(
                              new detail::ThreadSpecificPool(512))));
        m_pools.insert(
            PairType(1024, std::shared_ptr<detail::ThreadSpecificPool>(
                               new detail::ThreadSpecificPool(1024))));
    }

References m_pools.

~MemPool()

Nektar::MemPool::~MemPool ( )

inline

Definition at line 189 of file ThreadSpecificPool.hpp.

    {
    }

Member Function Documentation

Allocate()

void * Nektar::MemPool::Allocate ( size_t  bytes )

inline

Allocate a block of memory of size ByteSize.

Exceptions

std::bad_alloc

if memory is exhausted.

Parameters

bytes

The number of bytes to allocate.

If the bytes parameter specifies a size that is handled by memory pools then the memory is allocated from the pool. Otherwise the memory is allocated with a call to new.

Important: All memory allocated from this method must be returned to the pool via the Deallocate method. Deleting pointers allocated from the memory pool with the delete operator will result in undefined behavior.

Definition at line 204 of file ThreadSpecificPool.hpp.

    {
        if (bytes <= 4)
        {
            return m_fourBytePool.Allocate();
        }
        else if (bytes > m_upperBound)
        {
#ifdef NEKTAR_USE_ALIGNED_MEM
            return aligned_alloc(tinysimd::simd<NekDouble>::alignment, bytes);
#else
            return ::operator new(bytes);
#endif
        }
        else
        {
            PoolMapType::iterator iter = m_pools.lower_bound(bytes);
            ASSERTL1(iter != m_pools.end(),
                     "The memory manager is mishandling a memory request for " +
                         std::to_string(bytes) + " bytes of memory.");
 
            return (*iter).second->Allocate();
        }
    }

References Nektar::detail::ThreadSpecificPool::Allocate(), ASSERTL1, m_fourBytePool, m_pools, and m_upperBound.

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

Deallocate()

void Nektar::MemPool::Deallocate ( void *  p, size_t  bytes  )

inline

Deallocate memory claimed by an earlier call to allocate.

Attention

It is an error to deallocate memory not allocated from this pool. Doing this will result in undefined behavior.

Definition at line 233 of file ThreadSpecificPool.hpp.

    {
        if (bytes <= 4)
        {
            m_fourBytePool.Deallocate(p);
        }
        else if (bytes > m_upperBound)
        {
#ifdef NEKTAR_USE_ALIGNED_MEM
            free(p);
#else
            ::operator delete(p);
#endif
        }
        else
        {
            PoolMapType::iterator iter = m_pools.lower_bound(bytes);
            ASSERTL1(iter != m_pools.end(),
                     "The memory manager is mishandling a memory request for " +
                         std::to_string(bytes) + " bytes of memory.");
 
            (*iter).second->Deallocate(p);
        }
    }

References ASSERTL1, Nektar::detail::ThreadSpecificPool::Deallocate(), m_fourBytePool, m_pools, and m_upperBound.

Referenced by Nektar::MemoryManager< DataType >::Deallocate(), and Nektar::MemoryManager< DataType >::RawDeallocate().

Member Data Documentation

m_fourBytePool

detail::ThreadSpecificPool Nektar::MemPool::m_fourBytePool

private

Definition at line 259 of file ThreadSpecificPool.hpp.

Referenced by Allocate(), and Deallocate().

m_pools

std::map<size_t, std::shared_ptr<detail::ThreadSpecificPool> > Nektar::MemPool::m_pools

private

Definition at line 260 of file ThreadSpecificPool.hpp.

Referenced by Allocate(), Deallocate(), and MemPool().

m_upperBound

size_t Nektar::MemPool::m_upperBound

private

Definition at line 261 of file ThreadSpecificPool.hpp.

Referenced by Allocate(), and Deallocate().