fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS > Class Template Reference

#include <MemoryPool.h>

Public Types
using	Handle = unsigned int

Public Member Functions
	MemoryPool ()
	~MemoryPool ()
TYPE &	operator[] (Handle h)
	Return the object for handle h.
const TYPE &	operator[] (Handle h) const
	Return the object for handle h.
Handle	allocateRaw ()
void	freeRaw (Handle h)
template<typename... Args>
Handle	allocate (Args &&... args)
void	free (Handle h)
void	clearRaw ()

Static Public Attributes
static constexpr Handle	nullhandle = -1U

Protected Attributes
size_t	_objectSize
size_t	_blockSize
	The size of one object, in bytes.
std::vector< TYPE * >	_blocks
	The number of object to store in one block.
Handle	_firstFree = nullhandle
	The list of blocks.
size_t	_currentBlock = 0
	The first free object in the allocated segment. Forms a linked list.
size_t	_end
	The block containing the end of the allocated segment.
LOCKPOLICY::lock_type	_mutex
	The index of the past-the-end object in the current segment.

Detailed Description

template<class TYPE, class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>
class fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >

A simple memory pool.

Allocate memory by block, thus reducing malloc overhead. Memory is allocated and freed in O(1) (except when a new block is allocated).

As long as no object is freed, memory is allocated sequentially, except at block boundaries. If a few objects have been freed, they will be recycled the next time some memory is allocated. In some sense, when an object is freed it is pushed on top of a stack of available objects. When alloc is called, the top-most freed object is recycled. It means that objects are reallocated in the reverse order they are freed. It might be important to take this into consideration if you want to allocate objects sequentially.

The memory pool store the stack of freed objects as a linked-list. Pointers to the next object in the stack are stored directly in the freed object memory. It means that the minimum object size is sizeof(void*), so MemoryPool will waste memory if you try to store objects smaller than that.

It is safe to delete the memory pool without calling free() on all the object as long as you don't need to call their destructors.

Handles are 32-bit integers. The pool can store at most 4G-1 objects.

BLOCKBITS defnes the number of objects per block: 1 << BLOCKBITS. The default is 10 which gives 1024 objects per block.

Constructor & Destructor Documentation

MemoryPool()

template<class TYPE , class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>

fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::MemoryPool ( )

inline

Create a memory pool that allocate fixed-size objects of size objectSize. Allocate memory by blocks of blockSize objects.

~MemoryPool()

template<class TYPE , class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>

fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::~MemoryPool ( )

inline

Destroy the memory pool and free memory. Do not call destructors on allocated objects !

References fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_blocks, and fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::free().

Member Function Documentation

allocateRaw()

template<class TYPE , class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>

Handle fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::allocateRaw ( )

inline

Allocate memory for an object of type TYPE and returns it. Do not call a constructor !

Returns nullhandle if out-of-memory.

References fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_blockSize, fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_currentBlock, fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_end, fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_firstFree, and fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_mutex.

Referenced by fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::allocate().

freeRaw()

template<class TYPE , class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>

void fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::freeRaw ( Handle  h )

inline

Free memory pointed by ptr. Do *not* call the destructor.ptr*must* have been allocated bythis` !

References fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_firstFree, and fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_mutex.

Referenced by fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::free().

allocate()

template<class TYPE , class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>

template<typename... Args>

Handle fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::allocate ( Args &&...  args )

inline

Allocate and construct an object of type TYPE. Note that you must destroy the object with free so that the destructor is called. clear() and ~MemoryPool won't call the destructor !

References fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::allocateRaw().

free()

template<class TYPE , class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>

void fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::free ( Handle  h )

inline

Destroy and free ptr. Should be called on object allocated with allocate();

References fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::freeRaw().

Referenced by fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::~MemoryPool().

clearRaw()

template<class TYPE , class LOCKPOLICY = SpinLockPool, int BLOCKBITS = 10>

void fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::clearRaw ( )

inline

Free all objects allocated by this memory pool, but do not release the memory, so the pool can be reused. Do not call any destructor.

References fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_currentBlock, and fdk::MemoryPool< TYPE, LOCKPOLICY, BLOCKBITS >::_end.