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

Constructor & Destructor Documentation

◆ ThreadSpecificPool()

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

inline

Definition at line 81 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 91 of file ThreadSpecificPool.hpp.

                 {
                     // The documentation isn't particularly clear if delete needs to be called manually
                     // or if the thread specific pointer will call delete for me.  Looking through the 
                     // boost code doesn't make it any clearer. 
                 }

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

                 {
 #ifdef NEKTAR_USE_THREAD_SAFETY
                     boost::mutex::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 118 of file ThreadSpecificPool.hpp.

                 {
 #ifdef NEKTAR_USE_THREAD_SAFETY
                     boost::mutex::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));
                 }