bdlma::ConcurrentMultipool Class Reference

#include <bdlma_concurrentmultipool.h>

Detailed Description

This class implements a memory manager that maintains a configurable number of bdlma::Pool objects, each dispensing memory blocks of a unique size. The Pool objects are placed in an array, with each successive pool managing memory blocks of size twice that of the previous pool. Each multipool allocation (deallocation) request allocates memory from (returns memory to) the internal pool having the smallest block size not less than the requested size, or, if no pool manages memory blocks of sufficient sized, from a separately managed list of memory blocks. Both the release method and the destructor of a bdema::Multipool release all memory currently allocated via the object.

See bdlma_concurrentmultipool

Public Member Functions
	ConcurrentMultipool (bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (int numPools, bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (bsls::BlockGrowth::Strategy growthStrategy, bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (int numPools, bsls::BlockGrowth::Strategy growthStrategy, bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (int numPools, bsls::BlockGrowth::Strategy growthStrategy, int maxBlocksPerChunk, bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (int numPools, const bsls::BlockGrowth::Strategy *growthStrategyArray, bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (int numPools, const bsls::BlockGrowth::Strategy *growthStrategyArray, int maxBlocksPerChunk, bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (int numPools, bsls::BlockGrowth::Strategy growthStrategy, const int *maxBlocksPerChunkArray, bslma::Allocator *basicAllocator=0)
	ConcurrentMultipool (int numPools, const bsls::BlockGrowth::Strategy *growthStrategyArray, const int *maxBlocksPerChunkArray, bslma::Allocator *basicAllocator=0)
	~ConcurrentMultipool ()
void *	allocate (bsls::Types::size_type size)
void	deallocate (void *address)
template<class TYPE >
void	deleteObject (const TYPE *object)
template<class TYPE >
void	deleteObjectRaw (const TYPE *object)
void	release ()
void	reserveCapacity (bsls::Types::size_type size, int numBlocks)
int	numPools () const
bsls::Types::size_type	maxPooledBlockSize () const
bslma::Allocator *	allocator () const

Constructor & Destructor Documentation

ConcurrentMultipool() [1/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool ( bslma::Allocator *  basicAllocator = 0 )

explicit

Create a multipool memory manager. Optionally specify numPools, indicating the number of internally created Pool objects; the block size of the first pool is 8 bytes, with the block size of each additional pool successively doubling. If numPools is not specified, an implementation-defined number of pools N – covering memory blocks ranging in size from 2^3 = 8 to 2^(N+2) – are created. Optionally specify a growthStrategy indicating whether the number of blocks allocated at once for every internally created Pool should be either fixed or grow geometrically, starting with

1. If growthStrategy is not specified, the allocation strategy for each internally created Pool object is geometric, starting from 1. If numPools is specified, optionally specify a maxBlocksPerChunk, indicating the maximum number of blocks to be allocated at once when a pool must be replenished. If maxBlocksPerChunk is not specified, an implementation-defined value is used. Optionally specify a basicAllocator used to supply memory. If basicAllocator is 0, the currently installed default allocator is used. Memory allocation (and deallocation) requests will be satisfied using the internally maintained pool managing memory blocks of the smallest size not less than the requested size, or directly from the underlying allocator (supplied at construction), if no internally pool managing memory block of sufficient size exists.
   

Precondition

The behavior is undefined unless 1 <= numPools and 1 <= maxBlocksPerChunk.

Note

Note that, on platforms where 8 < bsls::AlignmentUtil::BSLS_MAX_ALIGNMENT, excess memory may be allocated for pools managing smaller blocks. Also note that maxBlocksPerChunk need not be an integral power of 2; if geometric growth would exceed the maximum value, the chunk size is capped at that value).

ConcurrentMultipool() [2/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool ( int  numPools, bslma::Allocator *  basicAllocator = 0  )

explicit

ConcurrentMultipool() [3/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool ( bsls::BlockGrowth::Strategy  growthStrategy, bslma::Allocator *  basicAllocator = 0  )

explicit

ConcurrentMultipool() [4/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool	(	int	numPools,
		bsls::BlockGrowth::Strategy	growthStrategy,
		bslma::Allocator *	basicAllocator = 0
	)

ConcurrentMultipool() [5/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool	(	int	numPools,
		bsls::BlockGrowth::Strategy	growthStrategy,
		int	maxBlocksPerChunk,
		bslma::Allocator *	basicAllocator = 0
	)

ConcurrentMultipool() [6/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool	(	int	numPools,
		const bsls::BlockGrowth::Strategy *	growthStrategyArray,
		bslma::Allocator *	basicAllocator = 0
	)

Create a multipool memory manager having the specified numPools, indicating the number of internally created Pool objects; the block size of the first pool is 8 bytes, with the block size of each additional pool successively doubling. Optionally specify a growthStrategy indicating whether the number of blocks allocated at once for every internally created Pool should be either fixed or grow geometrically, starting with 1. If growthStrategy is not specified, optionally specify growthStrategyArray, indicating the strategies for each individual Pool created by this object. If neither growthStrategy nor growthStrategyArray are specified, the allocation strategy for each internally created Pool object will grow geometrically, starting from 1. Optionally specify a maxBlocksPerChunk, indicating the maximum number of blocks to be allocated at once when a pool must be replenished. If maxBlocksPerChunk is not specified, optionally specify maxBlocksPerChunkArray, indicating the maximum number of blocks to allocate at once for each individually created Pool object. If neither maxBlocksPerChunk nor maxBlocksPerChunkArray are specified, an implementation-defined value is used. Optionally specify a basicAllocator used to supply memory. If basicAllocator is 0, the currently installed default allocator is used. Memory allocation (and deallocation) requests will be satisfied using the internally maintained pool managing memory blocks of the smallest size not less than the requested size, or directly from the underlying allocator (supplied at construction), if no internally pool managing memory block of sufficient size exists.

Precondition

The behavior is undefined unless 1 <= numPools, growthStrategyArray has at least numPools strategies, 1 <= maxBlocksPerChunk and maxBlocksPerChunkArray have at least numPools positive values.

Note

Note that, on platforms where 8 < bsls::AlignmentUtil::BSLS_MAX_ALIGNMENT, excess memory may be allocated for pools managing smaller blocks. Also note that the maximum need not be an integral power of 2; if geometric growth would exceed a maximum value, the chunk size is capped at that value).

ConcurrentMultipool() [7/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool	(	int	numPools,
		const bsls::BlockGrowth::Strategy *	growthStrategyArray,
		int	maxBlocksPerChunk,
		bslma::Allocator *	basicAllocator = 0
	)

ConcurrentMultipool() [8/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool	(	int	numPools,
		bsls::BlockGrowth::Strategy	growthStrategy,
		const int *	maxBlocksPerChunkArray,
		bslma::Allocator *	basicAllocator = 0
	)

ConcurrentMultipool() [9/9]

bdlma::ConcurrentMultipool::ConcurrentMultipool	(	int	numPools,
		const bsls::BlockGrowth::Strategy *	growthStrategyArray,
		const int *	maxBlocksPerChunkArray,
		bslma::Allocator *	basicAllocator = 0
	)

~ConcurrentMultipool()

bdlma::ConcurrentMultipool::~ConcurrentMultipool

(

)

Destroy this multipool. All memory allocated from this memory pool is released.

Member Function Documentation

allocate()

void * bdlma::ConcurrentMultipool::allocate

(

bsls::Types::size_type

size

)

Return the address of a contiguous block of maximally-aligned memory of (at least) the specified size (in bytes). If size > maxPooledBlockSize(), the memory allocation is managed directly by the underlying allocator, and will not be pooled, but will be deallocated when the release method is called, or when this object is destroyed. If size is 0, no memory is allocated and 0 is returned.

allocator()

bslma::Allocator * bdlma::ConcurrentMultipool::allocator ( ) const

inline

Return the allocator used by this object to allocate memory.

Note

Note that this allocator can not be used to deallocate memory allocated through this pool.

deallocate()

void bdlma::ConcurrentMultipool::deallocate

(

void *

address

)

Relinquish the memory block at the specified address back to this multipool object for reuse.

Precondition

The behavior is undefined unless address is non-zero, was allocated by this multipool object, and has not already been deallocated.

deleteObject()

template<class TYPE >

void bdlma::ConcurrentMultipool::deleteObject ( const TYPE *  object )

inline

Destroy the specified object based on its dynamic type and then use this multipool object to deallocate its memory footprint. This method has no effect if object is 0.

Precondition

The behavior is undefined unless object, when cast appropriately to void *, was allocated using this multipool object and has not already been deallocated.

Note

Note that dynamic_cast<void *>(object) is applied if TYPE is polymorphic, and static_cast<void *>(object) is applied otherwise.

deleteObjectRaw()

template<class TYPE >

void bdlma::ConcurrentMultipool::deleteObjectRaw ( const TYPE *  object )

inline

Destroy the specified object and then use this multipool to deallocate its memory footprint. This method has no effect if object is 0.

Precondition

The behavior is undefined unless object is not a secondary base class pointer (i.e., the address is (numerically) the same as when it was originally dispensed by this multipool), was allocated using this multipool, and has not already been deallocated.

maxPooledBlockSize()

bsls::Types::size_type bdlma::ConcurrentMultipool::maxPooledBlockSize ( ) const

inline

Return the maximum size of memory blocks that are pooled by this multipool object.

Note

Note that the maximum value is defined as:

2 ^ (numPools + 2)

where numPools is either specified at construction, or an implementation-defined value.

numPools()

int bdlma::ConcurrentMultipool::numPools ( ) const

inline

Return the number of pools managed by this multipool object.

release()

void bdlma::ConcurrentMultipool::release

(

)

Relinquish all memory currently allocated via this multipool object.

reserveCapacity()

void bdlma::ConcurrentMultipool::reserveCapacity	(	bsls::Types::size_type	size,
		int	numBlocks
	)

Reserve memory from this multipool to satisfy memory requests for at least the specified numBlocks having the specified size (in bytes) before the pool replenishes. If size is 0, this method has no effect.

Precondition

The behavior is undefined unless size <= maxPooledBlockSize() and 0 <= numBlocks.

---

The documentation for this class was generated from the following file:

• bdlma_concurrentmultipool.h