#include <ThreadSpecificPool.hpp>

Public Member Functions
	ThreadSpecificPool (size_t ByteSize)

	~ThreadSpecificPool ()

void *	Allocate ()
	Allocate a block of memory of size ByteSize. More...

void	Deallocate (const void *p)
	Deallocate memory claimed by an earlier call to allocate. More...

Private Attributes
boost::pool *	m_pool

size_t	m_blockSize

Detailed Description

Definition at line 85 of file ThreadSpecificPool.hpp.

Constructor & Destructor Documentation

◆ ThreadSpecificPool()

Nektar::detail::ThreadSpecificPool::ThreadSpecificPool ( size_t ByteSize )

inline

Definition at line 88 of file ThreadSpecificPool.hpp.

                                        : m_pool(), m_blockSize(ByteSize)
    {
        // We can't do the new in the constructor list because the
        // thread specific pointer doesn't have a supporting
        // constructor.
        m_pool = new boost::pool<>(m_blockSize);
    }

References m_blockSize, and m_pool.

◆ ~ThreadSpecificPool()

Nektar::detail::ThreadSpecificPool::~ThreadSpecificPool ( )

inline

Definition at line 96 of file ThreadSpecificPool.hpp.

    {
        // Need to call delete manually, otherwise memory is leaking.
        delete m_pool;
    }

References m_pool.

Member Function Documentation

◆ Allocate()

void * Nektar::detail::ThreadSpecificPool::Allocate ( )

inline

Allocate a block of memory of size ByteSize.

Exceptions

std::bad_alloc if memory is exhausted.

Definition at line 104 of file ThreadSpecificPool.hpp.

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        std::scoped_lock l(m_mutex);
#endif
        void *result = m_pool->malloc();
 
#if defined(NEKTAR_DEBUG) || defined(NEKTAR_FULLDEBUG)
        memset(result, 0, m_blockSize);
#endif // defined(NEKTAR_DEBUG) || defined(NEKTAR_FULLDEBUG)
 
        return result;
    }

References m_blockSize, and m_pool.

Referenced by Nektar::MemPool::Allocate().

◆ Deallocate()

void Nektar::detail::ThreadSpecificPool::Deallocate ( const void * p )

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

    {
#ifdef NEKTAR_USE_THREAD_SAFETY
        std::scoped_lock l(m_mutex);
#endif
#if defined(NEKTAR_DEBUG) || defined(NEKTAR_FULLDEBUG)
        // The idea here is to fill the returned memory with some known
        // pattern, then detect that pattern on the allocate.  If the
        // pattern is no longer there then some memory corruption has
        // occurred.  However, I'm not sure how to distinguish between first
        // time allocations and repeat allocations.
 
        // memset(p, '+', m_pool->get_requested_size());
#endif // defined(NEKTAR_DEBUG) || defined(NEKTAR_FULLDEBUG)
 
        m_pool->free(const_cast<void *>(p));
    }