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. More...
void	Deallocate (void *p, size_t bytes)
	Deallocate memory claimed by an earlier call to allocate. More...

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 154 of file ThreadSpecificPool.hpp.

Member Typedef Documentation

PoolMapType

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

Definition at line 157 of file ThreadSpecificPool.hpp.

Constructor & Destructor Documentation

MemPool()

Nektar::MemPool::MemPool ( )

inline

Definition at line 160 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 181 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 195 of file ThreadSpecificPool.hpp.

            {
                if( bytes <= 4 )
                {
                    return m_fourBytePool.Allocate();
                }
                else if( bytes > m_upperBound )
                {
#ifdef NEKTAR_USE_ALIGNED_MEM
                    return boost::alignment::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 223 of file ThreadSpecificPool.hpp.

            {
                if( bytes <= 4 )
                {
                    m_fourBytePool.Deallocate(p);
                }
                else if( bytes > m_upperBound )
                {
#ifdef NEKTAR_USE_ALIGNED_MEM
                    boost::alignment::aligned_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, m_upperBound, and CellMLToNektar.cellml_metadata::p.

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 248 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 249 of file ThreadSpecificPool.hpp.

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

m_upperBound

size_t Nektar::MemPool::m_upperBound

private

Definition at line 250 of file ThreadSpecificPool.hpp.

Referenced by Allocate(), and Deallocate().