HeapBasedPoolAllocator< BlockSize, RaiiSynchronizer > Class Template Reference

A special-purpose implementation of a pool allocator that keeps the pool in the heap using malloc()/free(). More...

#include <heap_based_pool_allocator.hpp>

Inherits uavcan::IPoolAllocator, and uavcan::Noncopyable.

Detailed Description

template<std::size_t BlockSize, typename RaiiSynchronizer = char>
class uavcan::HeapBasedPoolAllocator< BlockSize, RaiiSynchronizer >

A special-purpose implementation of a pool allocator that keeps the pool in the heap using malloc()/free().

The pool grows dynamically, ad-hoc, thus using as little memory as possible.

Allocated blocks will not be freed back automatically, but there are two ways to force their deallocation:

• Call shrink() - this method frees all blocks that are unused at the moment.
• Destroy the object - the desctructor calls shrink().

The pool can be limited in growth with hard and soft limits. The soft limit defines the value that will be reported via IPoolAllocator::getBlockCapacity(). The hard limit defines the maximum number of blocks that can be allocated from heap. Typically, the hard limit should be equal or greater than the soft limit.

The allocator can be made thread-safe (optional) by means of providing a RAII-lock type via the second template argument. The allocator uses the lock only to access the shared state, therefore critical sections are only a few cycles long, which implies that it should be acceptable to use hardware IRQ disabling instead of a mutex for performance reasons. For example, an IRQ-based RAII-lock type can be implemented as follows: struct RaiiSynchronizer { RaiiSynchronizer() { __disable_irq(); } ~RaiiSynchronizer() { __enable_irq(); } };

Definition at line 40 of file heap_based_pool_allocator.hpp.

Constructor & Destructor Documentation

Member Function Documentation