block_pool< T, Pool, MaxBytes > Struct Template Reference

Collaboration diagram for block_pool< T, Pool, MaxBytes >:

[legend]List of all members.

---

Detailed Description

template<class T, class Pool = dynpool, size_t MaxBytes = 0>
struct block_pool< T, Pool, MaxBytes >

A factory for speedier allocation from the heap.

This allocator is intended for use in a multithreaded environment where many short-lived objects are created and released.

Allocations are not thread safe, but deallocations are. This allows each thread to allocate objects cheaply, without worrying about who will eventually deallocate them (they must still be deallocated, of course). To use: give each thread its own allocator: that provides the thread-safety.

The factory is backed by a global dynarray which manages block-level allocation; each block provides N chips to hand out to clients. The allocator maintains a cache of blocks just large enough that it can expect to recycle the oldest cached block as each active block is consumed; the cache can both grow and shrink to match demand.

PROS:

• most allocations are extremely cheap -- no malloc(), no atomic ops
• deallocations are also cheap -- one atomic op
• completely immune to the ABA problem
• memory can be redistributed among threads between bursts

CONS:

• each thread must have its own allocator, which means managing thread-local storage (if compilers ever support non-POD __thread objects, this problem would go away).

• though threads attempt to keep their caches reasonably-sized, they will only do so at allocation or thread destruction time, leading to potential hoarding

• memory leaks (or unexpectedly long-lived objects) are extremly expensive because they keep a whole block from being freed instead of just one object. However, the remaining chips of each block are at least available for reuse.

Definition at line 202 of file block_alloc.h.

Public Types
typedef memory_block::meta_block_size< sizeof(T)>	BlockSize
Public Member Functions
	block_pool ()
void *	acquire ()
	Acquire one object(chip) from the pool.
void	recycle ()
void	dump () const
size_t	freelist_size () const
Static Public Member Functions
static size_t	block_size ()
static size_t	chip_count ()
static size_t	chip_size ()
static Pool *	get_static_pool ()
	Each block_pool<T> has its own allocator, one per type T.
static void	release (void *ptr)

---

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

• src/fc/block_alloc.h

---