Nektar::detail::ThreadSpecificPool Class Reference

#include <ThreadSpecificPool.hpp>

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

Private Attributes
boost::pool *	m_pool
size_t	m_blockSize

Detailed Description

Definition at line 84 of file ThreadSpecificPool.hpp.

Constructor & Destructor Documentation

ThreadSpecificPool()

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

inline

Definition at line 87 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 95 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 103 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 121 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));
    }

References m_pool.

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

Member Data Documentation

m_blockSize

size_t Nektar::detail::ThreadSpecificPool::m_blockSize

private

Definition at line 142 of file ThreadSpecificPool.hpp.

Referenced by Allocate(), and ThreadSpecificPool().

m_pool

boost::pool* Nektar::detail::ThreadSpecificPool::m_pool

private

Definition at line 141 of file ThreadSpecificPool.hpp.

Referenced by Allocate(), Deallocate(), ThreadSpecificPool(), and ~ThreadSpecificPool().