A class managing a memory pool. More...

#include <BulkAllocator.h>

Inheritance diagram for lar::details::bulk_allocator::BulkAllocatorBase< T >:

Classes
class	MemoryChunk_t
	Internal memory chunk; like a std::vector, but does not construct. More...

Public Types
typedef size_t	size_type

typedef T	value_type

typedef T *	pointer

Public Types inherited from lar::details::bulk_allocator::ReferenceCounter
typedef unsigned int	Counter_t
	type of user counter More...

Public Member Functions
	BulkAllocatorBase (size_type NewChunkSize=DefaultChunkSize, bool bPreallocate=false)
	Constructor; preallocates memory if explicitly requested. More...

	~BulkAllocatorBase ()
	Destructor: releases all the memory pool (. More...

void	Free ()
	Releases the pool of memory; all pointer to it become invalid. More...

pointer	Get (size_type n)
	Returns a pointer to memory for n new values of type T. More...

void	Release (pointer)
	Releases memory pointed by the specified pointer (but it does not). More...

void	AddUser ()
	Add a new pool user with the current parameters. More...

void	AddUser (size_type NewChunkSize, bool bPreallocate=false)
	Add a new pool user with new parameters. More...

bool	RemoveUser ()
	Removed a user to the users count; if no user is left, free the pool. More...

size_type	AllocatedCount () const
	Returns the total number of entries in the pool. More...

size_type	UsedCount () const
	Returns the total number of used entries in the pool. More...

size_type	FreeCount () const
	Returns the total number of unused entries in the pool. More...

size_type	NChunks () const
	Returns the number of memory pool chunks allocated. More...

std::array< size_type, 2 >	GetCounts () const
	Returns an array equivalent to { UsedCount(), FreeCount() }. More...

void	SetChunkSize (size_type NewChunkSize, bool force=false)
	Sets the chunk size for the future allocations. More...

size_type	GetChunkSize () const
	Returns the current chunk size. More...

void	Preallocate ()

Public Member Functions inherited from lar::details::bulk_allocator::ReferenceCounter
bool	hasUsers () const
	Returns whether there are currently users. More...

Counter_t	Count () const
	Returns the number of registered users. More...

void	AddUser ()
	Adds a user to the users count. More...

bool	RemoveUser ()
	Removed a user to the users count; returns false if no user yet. More...

Private Types
typedef std::allocator< T >	Allocator_t

typedef Allocator_t::difference_type	difference_type

typedef std::vector < MemoryChunk_t >	MemoryPool_t

Private Member Functions
void	Preallocate (size_type n)
	Preallocates a chunk of the given size; allocates if free space < n. More...

Private Attributes
Allocator_t	allocator
	the actual allocator we use More...

size_type	ChunkSize
	size of the chunks to add More...

MemoryPool_t	MemoryPool
	list of all memory chunks; first is free More...

Static Private Attributes
static size_type	DefaultChunkSize = 10000
	Default chunk size (default: 10000) More...

Detailed Description

template<typename T>
class lar::details::bulk_allocator::BulkAllocatorBase< T >

A class managing a memory pool.

The management policy is to allocate big chunks of memory. Memory is never freed, until the last user is removed (which is responsibility of the caller), this object is destroyed of Free() is explicitly called. The amount of memory on

This class has a users counter. The count must be explicitly handled by the caller.

Definition at line 31 of file BulkAllocator.h.

Member Typedef Documentation

template<typename T>

typedef std::allocator<T> lar::details::bulk_allocator::BulkAllocatorBase< T >::Allocator_t

private

Definition at line 318 of file BulkAllocator.h.

template<typename T>

typedef Allocator_t::difference_type lar::details::bulk_allocator::BulkAllocatorBase< T >::difference_type

private

Definition at line 319 of file BulkAllocator.h.

template<typename T>

typedef std::vector<MemoryChunk_t> lar::details::bulk_allocator::BulkAllocatorBase< T >::MemoryPool_t

private

Definition at line 378 of file BulkAllocator.h.

template<typename T>

typedef T* lar::details::bulk_allocator::BulkAllocatorBase< T >::pointer

Definition at line 264 of file BulkAllocator.h.

template<typename T>

typedef size_t lar::details::bulk_allocator::BulkAllocatorBase< T >::size_type

Definition at line 262 of file BulkAllocator.h.

template<typename T>

typedef T lar::details::bulk_allocator::BulkAllocatorBase< T >::value_type

Definition at line 263 of file BulkAllocator.h.

Constructor & Destructor Documentation

template<typename T >

lar::details::bulk_allocator::BulkAllocatorBase< T >::BulkAllocatorBase	(	size_type	NewChunkSize = `DefaultChunkSize`,
		bool	bPreallocate = `false`
	)

Constructor; preallocates memory if explicitly requested.

Definition at line 418 of file BulkAllocator.h.

                                                      :
         ChunkSize(NewChunkSize), MemoryPool()
       {
         Preallocate(bPreallocate? ChunkSize: 0);
         if (bDebug) {
           std::cout << "BulkAllocatorBase[" << ((void*) this)
             << "] created for type " << demangle<value_type>()
             << " with chunk size " << GetChunkSize()
             << " x" << sizeof(value_type) << " byte => "
             << (GetChunkSize()*sizeof(value_type)) << " bytes/chunk"
             << std::endl;
         } // if debug
       } // BulkAllocatorBase<T>::BulkAllocatorBase()

template<typename T>

lar::details::bulk_allocator::BulkAllocatorBase< T >::~BulkAllocatorBase ( )

inline

Destructor: releases all the memory pool (.

See Also: Free())

Definition at line 272 of file BulkAllocator.h.

272 { Free(); }

lar::details::bulk_allocator::BulkAllocatorBase::Free

void Free()

Releases the pool of memory; all pointer to it become invalid.

Definition: BulkAllocator.h:434

Member Function Documentation

template<typename T>

void lar::details::bulk_allocator::BulkAllocatorBase< T >::AddUser ( )

inline

Add a new pool user with the current parameters.

Definition at line 284 of file BulkAllocator.h.

284 { ReferenceCounter::AddUser(); }

lar::details::bulk_allocator::ReferenceCounter::AddUser

void AddUser()

Adds a user to the users count.

Definition: BulkAllocator.h:236

template<typename T >

void lar::details::bulk_allocator::BulkAllocatorBase< T >::AddUser	(	size_type	NewChunkSize,
		bool	bPreallocate = `false`
	)

Add a new pool user with new parameters.

Definition at line 455 of file BulkAllocator.h.

       {
         AddUser();
         SetChunkSize(NewChunkSize);
         Preallocate(bPreallocate? ChunkSize: 0);
       } // BulkAllocatorBase<T>::AddUser(size_type, bool )

template<typename T >

BulkAllocatorBase< T >::size_type lar::details::bulk_allocator::BulkAllocatorBase< T >::AllocatedCount ( ) const

Returns the total number of entries in the pool.

Definition at line 472 of file BulkAllocator.h.

       {
         size_type n = 0;
         for (const auto& chunk: MemoryPool) n += chunk.size();
         return n;
       } // AllocatedCount()

template<typename T >

void lar::details::bulk_allocator::BulkAllocatorBase< T >::Free ( )

Releases the pool of memory; all pointer to it become invalid.

Definition at line 434 of file BulkAllocator.h.

                                       {
         if (bDebug) {
           std::cout << "BulkAllocatorBase[" << ((void*) this) << "] freeing "
             << NChunks() << " memory chunks with " << AllocatedCount()
             << " elements" << std::endl;
         } // if debug
         MemoryPool.clear();
       } // BulkAllocatorBase<T>::Free()

template<typename T>

size_type lar::details::bulk_allocator::BulkAllocatorBase< T >::FreeCount ( ) const

Returns the total number of unused entries in the pool.

template<typename T >

BulkAllocatorBase< T >::pointer lar::details::bulk_allocator::BulkAllocatorBase< T >::Get ( size_type n )

inline

Returns a pointer to memory for n new values of type T.

Definition at line 523 of file BulkAllocator.h.

       {
         if (n == 0) return nullptr;
         // get the free pointer from the latest chunk (#0)
         pointer ptr = MemoryPool.front().get(n);
         if (ptr) return ptr;
         // no free element left in that chunk:
         // - create a new one in the first position of the pool (move the rest)
         // - return the pointer from the new pool
         //   (if it fails, it fails... but how could that happen?)
         if (bDebug) {
           std::array<size_type, 2> stats = GetCounts();
           std::cout << "BulkAllocatorBase[" << ((void*) this)
             << "] allocating " << std::max(ChunkSize, n)
             << " more elements (on top of the current " << (stats[0] + stats[1])
             << " elements, " << stats[1] << " unused)" << std::endl;
         } // if debug
         return MemoryPool.emplace
           (MemoryPool.begin(), allocator, std::max(ChunkSize, n))->get(n);
       } // BulkAllocatorBase<T>::Get()

template<typename T>

size_type lar::details::bulk_allocator::BulkAllocatorBase< T >::GetChunkSize ( ) const

inline

Returns the current chunk size.

Definition at line 311 of file BulkAllocator.h.

311 { return ChunkSize; }

lar::details::bulk_allocator::BulkAllocatorBase::ChunkSize

size_type ChunkSize

size of the chunks to add

Definition: BulkAllocator.h:380

template<typename T >

std::array< typename BulkAllocatorBase< T >::size_type, 2 > lar::details::bulk_allocator::BulkAllocatorBase< T >::GetCounts ( ) const

Returns an array equivalent to { UsedCount(), FreeCount() }.

Definition at line 492 of file BulkAllocator.h.

       {
         // BUG the double brace syntax is required to work around clang bug 21629
         // (https://bugs.llvm.org/show_bug.cgi?id=21629)
         std::array<BulkAllocatorBase<T>::size_type, 2> stats = {{ 0U, 0U }};
         for (const auto& chunk: MemoryPool) {
           stats[0] += chunk.used();
           stats[1] += chunk.available();
         } // for
         return stats;
       } // BulkAllocatorBase<T>::GetCounts()

template<typename T>

size_type lar::details::bulk_allocator::BulkAllocatorBase< T >::NChunks ( ) const

inline

Returns the number of memory pool chunks allocated.

Definition at line 302 of file BulkAllocator.h.

302 { return MemoryPool.size(); }

lar::details::bulk_allocator::BulkAllocatorBase::MemoryPool

MemoryPool_t MemoryPool

list of all memory chunks; first is free

Definition: BulkAllocator.h:381

template<typename T>

void lar::details::bulk_allocator::BulkAllocatorBase< T >::Preallocate ( )

inline

Preallocates a chunk of the current ChunkSize;

See Also: Preallocate(size_type)

Definition at line 315 of file BulkAllocator.h.

315 { Preallocate(ChunkSize); }

lar::details::bulk_allocator::BulkAllocatorBase::ChunkSize

size_type ChunkSize

size of the chunks to add

Definition: BulkAllocator.h:380

lar::details::bulk_allocator::BulkAllocatorBase::Preallocate

void Preallocate()

Definition: BulkAllocator.h:315

template<typename T >

void lar::details::bulk_allocator::BulkAllocatorBase< T >::Preallocate ( size_type n )

private

Preallocates a chunk of the given size; allocates if free space < n.

Definition at line 464 of file BulkAllocator.h.

                                                         {
         if (MemoryPool.empty() || (MemoryPool.front().available() < n))
           MemoryPool.emplace_back(allocator, n);
       } // BulkAllocatorBase<T>::RemoveUser()

template<typename T>

void lar::details::bulk_allocator::BulkAllocatorBase< T >::Release ( pointer )

inline

Releases memory pointed by the specified pointer (but it does not).

Definition at line 281 of file BulkAllocator.h.

281 {}

template<typename T >

bool lar::details::bulk_allocator::BulkAllocatorBase< T >::RemoveUser ( )

Removed a user to the users count; if no user is left, free the pool.

Definition at line 445 of file BulkAllocator.h.

                                             {
         ReferenceCounter::RemoveUser();
         if (hasUsers()) return true;
         Free();
         return false;
       } // BulkAllocatorBase<T>::RemoveUser()

template<typename T >

void lar::details::bulk_allocator::BulkAllocatorBase< T >::SetChunkSize	(	size_type	NewChunkSize,
		bool	force = `false`
	)

Sets the chunk size for the future allocations.

Definition at line 507 of file BulkAllocator.h.

       {
         if ((GetChunkSize() == NewChunkSize) && !force) return;
         if (bDebug) {
           std::cout << "BulkAllocatorBase[" << ((void*) this) << "]"
             << " changing chunk size: " << GetChunkSize() << " => "
             << NewChunkSize << ": x" << sizeof(value_type) << " byte => "
             << (NewChunkSize*sizeof(value_type)) << " bytes/chunk"
             << std::endl;
         }
         ChunkSize = NewChunkSize;
       } // BulkAllocatorBase<T>::SetChunkSize()

template<typename T >

BulkAllocatorBase< T >::size_type lar::details::bulk_allocator::BulkAllocatorBase< T >::UsedCount ( ) const

Returns the total number of used entries in the pool.

Definition at line 482 of file BulkAllocator.h.

       {
         size_type n = 0;
         for (const auto& chunk: MemoryPool) n += chunk.used();
         return n;
       } // BulkAllocatorBase<T>::UsedCount()