Pool Class Reference

Public Member Functions

• Pool (size_t elemsize, size_t block_size)
• ~Pool ()

  Checks for emptiness before destructing.
  

• void * Allocate ()

  Allocate a block from the pool (without element construction).
  

• void Deallocate (void *element)

  Deallocate a block and return to the pool (without element destruction).
  

• size_t GetElemSize () const

  Gets the pool granularity.
  

• size_t GetSize () const

  Gets the pool size in elements.
  

• size_t GetUsed () const

  Gets the number of elements allocated from pooled storage.
  

• template<typename T > T * Construct ()

  Constructs an object from the pool.
  

• template<typename T > void Destroy (T *instance)

  Destructs an object back into the pool.
  

Private Member Functions

• void AllocateNewBlock (void)

  allocate a new block from the OS
  

Private Attributes

• size_t m_elemsize

  The size in bytes of each element in the pool in bytes.
  

• size_t m_blocksize

  The number of elements in each block allocated from OS.
  

• size_t m_size

  The total capacity of the pooled storage.
  

• size_t m_used

  The number of allocated elements.
  

• std::vector< char * > m_storage

  The pool storage. Each element will hold m_blocksize elements. The vector of pointers allows the pool to grow.
  

• std::vector< void * > m_slots

  The free list.
  

---

Detailed Description

Memory pool for allocations of elements of a single fixed size. Memory is allocated from the OS in chunks, the pool grows in capacity as elements are allocated from it.

---

Constructor & Destructor Documentation

Pool::Pool	(	size_t	elemsize,
		size_t	block_size
	)			[inline]

Allocates a pool with block_size elements of elemsize bytes each. The pool will grow in increments of block_size. Memory is NOT returned to the OS.

Pool::~Pool

(

)

[inline]

References m_storage, and m_used.

---

Member Function Documentation

void* Pool::Allocate

(

)

[inline]

References AllocateNewBlock(), m_size, m_slots, and m_used.

Referenced by PooledList< T >::alloc(), PooledAllocator< T >::allocate(), and Construct().

void Pool::Deallocate

(

void *

element

)

[inline]

References m_slots, and m_used.

Referenced by PooledList< T >::dealloc(), PooledAllocator< T >::deallocate(), and Destroy().

size_t Pool::GetElemSize

(

)

const [inline]

References m_elemsize.

Referenced by PooledAllocator< T >::PooledAllocator().

size_t Pool::GetSize

(

)

const [inline]

References m_size.

size_t Pool::GetUsed

(

)

const [inline]

References m_used.

template<typename T >

T* Pool::Construct

(

)

[inline]

References Allocate().

template<typename T >

void Pool::Destroy

(

T *

instance

)

[inline]

References Deallocate().

void Pool::AllocateNewBlock

(

void

)

[inline, private]

References m_blocksize, m_elemsize, m_size, m_slots, m_storage, and m_used.

Referenced by Allocate().

---

Field Documentation

size_t Pool::m_elemsize [private]

Referenced by AllocateNewBlock(), and GetElemSize().

size_t Pool::m_blocksize [private]

Referenced by AllocateNewBlock().

size_t Pool::m_size [private]

Referenced by Allocate(), AllocateNewBlock(), and GetSize().

size_t Pool::m_used [private]

Referenced by Allocate(), AllocateNewBlock(), Deallocate(), GetUsed(), and ~Pool().

std::vector<char*> Pool::m_storage [private]

Referenced by AllocateNewBlock(), and ~Pool().

std::vector<void*> Pool::m_slots [private]

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