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

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 ()

bool	hasUsers () const
	Returns whether there are currently users. More...

Counter_t	Count () const
	Returns the number of registered users. 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 29 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 321 of file BulkAllocator.h.

typedef unsigned int lar::details::bulk_allocator::ReferenceCounter::Counter_t

inherited

type of user counter

Definition at line 229 of file BulkAllocator.h.

template<typename T>

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

private

Definition at line 322 of file BulkAllocator.h.

template<typename T>

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

private

Definition at line 381 of file BulkAllocator.h.

template<typename T>

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

Definition at line 269 of file BulkAllocator.h.

template<typename T>

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

Definition at line 267 of file BulkAllocator.h.

template<typename T>

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

Definition at line 268 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.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::ChunkSize, lar::details::bulk_allocator::BulkAllocatorBase< T >::GetChunkSize(), and lar::details::bulk_allocator::BulkAllocatorBase< T >::Preallocate().

         : 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 275 of file BulkAllocator.h.

References Get, and n.

275 { Free(); }

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

void Free()

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

Definition: BulkAllocator.h:432

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 287 of file BulkAllocator.h.

References lar::details::bulk_allocator::ReferenceCounter::AddUser().

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::AddUser().

287 { ReferenceCounter::AddUser(); }

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

void AddUser()

Adds a user to the users count.

Definition: BulkAllocator.h:238

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 451 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::AddUser(), lar::details::bulk_allocator::BulkAllocatorBase< T >::ChunkSize, lar::details::bulk_allocator::BulkAllocatorBase< T >::Preallocate(), and lar::details::bulk_allocator::BulkAllocatorBase< T >::SetChunkSize().

       {
         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 466 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::MemoryPool, and n.

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::Free().

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

Counter_t lar::details::bulk_allocator::ReferenceCounter::Count ( ) const

inlineinherited

Returns the number of registered users.

Definition at line 235 of file BulkAllocator.h.

References util::counter().

235 { return counter; }

lar::details::bulk_allocator::ReferenceCounter::counter

Counter_t counter

Definition: BulkAllocator.h:249

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 432 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::AllocatedCount(), lar::details::bulk_allocator::BulkAllocatorBase< T >::MemoryPool, and lar::details::bulk_allocator::BulkAllocatorBase< T >::NChunks().

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::RemoveUser().

       {
         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 511 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::allocator, lar::details::bulk_allocator::BulkAllocatorBase< T >::ChunkSize, lar::details::bulk_allocator::BulkAllocatorBase< T >::GetCounts(), and lar::details::bulk_allocator::BulkAllocatorBase< T >::MemoryPool.

       {
         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 314 of file BulkAllocator.h.

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::BulkAllocatorBase(), and lar::details::bulk_allocator::BulkAllocatorBase< T >::SetChunkSize().

314 { return ChunkSize; }

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

size_type ChunkSize

size of the chunks to add

Definition: BulkAllocator.h:383

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 484 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::MemoryPool.

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::Get().

       {
         // 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()

bool lar::details::bulk_allocator::ReferenceCounter::hasUsers ( ) const

inlineinherited

Returns whether there are currently users.

Definition at line 232 of file BulkAllocator.h.

References util::counter().

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::RemoveUser().

232 { return counter > 0; }

lar::details::bulk_allocator::ReferenceCounter::counter

Counter_t counter

Definition: BulkAllocator.h:249

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 305 of file BulkAllocator.h.

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::Free().

305 { return MemoryPool.size(); }

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

MemoryPool_t MemoryPool

list of all memory chunks; first is free

Definition: BulkAllocator.h:384

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 318 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::Preallocate().

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::AddUser(), lar::details::bulk_allocator::BulkAllocatorBase< T >::BulkAllocatorBase(), and lar::details::bulk_allocator::BulkAllocatorBase< T >::Preallocate().

318 { Preallocate(ChunkSize); }

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

size_type ChunkSize

size of the chunks to add

Definition: BulkAllocator.h:383

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

void Preallocate()

Definition: BulkAllocator.h:318

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 459 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::allocator, lar::details::bulk_allocator::BulkAllocatorBase< T >::MemoryPool, and n.

       {
         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 284 of file BulkAllocator.h.

284 {}

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 442 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::Free(), lar::details::bulk_allocator::ReferenceCounter::hasUsers(), and lar::details::bulk_allocator::ReferenceCounter::RemoveUser().

       {
         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 498 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::ChunkSize, and lar::details::bulk_allocator::BulkAllocatorBase< T >::GetChunkSize().

Referenced by lar::details::bulk_allocator::BulkAllocatorBase< T >::AddUser().

       {
         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 475 of file BulkAllocator.h.

References lar::details::bulk_allocator::BulkAllocatorBase< T >::MemoryPool, and n.

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