Common functionality for block-oriented allocators. More...

#include <ArenaBlockAllocatorBase.h>

Inheritance diagram for SG::ArenaBlockAllocatorBase:

Collaboration diagram for SG::ArenaBlockAllocatorBase:

Public Types
typedef char *	pointer
	Type for pointers to elements. More...

typedef const char *	const_pointer
	And a const version of the pointer. More...

typedef void	func_t(pointer)
	Type of functions for `constructor`, etc. More...

Public Member Functions
	ArenaBlockAllocatorBase (const Params &params)
	Constructor. More...

virtual	~ArenaBlockAllocatorBase ()
	Destructor. More...

	ArenaBlockAllocatorBase (const ArenaBlockAllocatorBase &)=delete
	Don't allow copy construction or assignment. More...

ArenaBlockAllocatorBase &	operator= (const ArenaBlockAllocatorBase &)=delete

	ArenaBlockAllocatorBase (ArenaBlockAllocatorBase &&other)
	Move constructor. More...

ArenaBlockAllocatorBase &	operator= (ArenaBlockAllocatorBase &&other)
	Move assignment. More...

void	swap (ArenaBlockAllocatorBase &other)
	Swap. More...

virtual void	reserve (size_t size) override
	Set the total number of elements cached by the allocator. More...

virtual void	erase () override
	Free all allocated elements and release memory back to the system. More...

virtual Stats	stats () const override
	Return the statistics block for this allocator. More...

virtual const std::string &	name () const override
	Return the name of this allocator. More...

const Params &	params () const
	Return this Allocator's parameters. More...

void	protect ()
	Write-protect the memory managed by this allocator. More...

void	unprotect ()
	Write-enable the memory managed by this allocator. More...

virtual void	reset ()=0
	Free all allocated elements. More...

virtual void	report (std::ostream &os) const
	Generate a report on the memory usage of this allocator. More...

Static Public Member Functions
template<class T >
static func_t *	makeConstructor (const std::false_type &)
	Make a constructor function pointer for a non-trivial constructor. More...

template<class T >
static func_t *	makeConstructor (const std::true_type &)
	Make a constructor function pointer for a trivial constructor. More...

template<class T >
static func_t *	makeDestructor (const std::false_type &)
	Make a constructor function pointer for a non-trivial destructor. More...

template<class T >
static func_t *	makeDestructor (const std::true_type &)
	Make a constructor function pointer for a trivial destructor. More...

template<class T >
static func_t *	makeClear (const std::false_type &)
	Make a function pointer for a `clear` function. More...

template<class T >
static func_t *	makeClear (const std::true_type &)
	Make a dummy `clear` function pointer. More...

Protected Member Functions
ArenaBlock *	getBlock ()
	Return an empty block, either newly-allocated or from the free list. More...

Protected Attributes
Params	m_params
	The parameters for this allocator. More...

ArenaBlock *	m_blocks
	The list of blocks currently in use. More...

ArenaBlock *	m_freeblocks
	The list of free blocks. More...

ArenaAllocatorBase::Stats	m_stats
	The statistics structure. More...

bool	m_protected
	Flag whether the arena has been protected. More...

Static Private Member Functions
template<typename T >
static void	construct_fcn (pointer p)
	Call `T's` default constructor on the object at `p`. More...

template<typename T >
static void	destroy_fcn (pointer p)
	Call `T's` destructor on the object at `p`. More...

template<typename T >
static void	clear_fcn (pointer p)
	Call `T::clear` on the object at `p`. More...

Detailed Description

Common functionality for block-oriented allocators.

See Arena.h for an overview of the arena-based memory allocators.

This class factors out some common functionality for allocators that use ArenaBlock.

Definition at line 33 of file ArenaBlockAllocatorBase.h.

Member Typedef Documentation

◆ const_pointer

typedef const char* SG::ArenaAllocatorBase::const_pointer

inherited

And a const version of the pointer.

Definition at line 140 of file ArenaAllocatorBase.h.

◆ func_t

typedef void SG::ArenaAllocatorBase::func_t(pointer)

inherited

Type of functions for constructor, etc.

Definition at line 143 of file ArenaAllocatorBase.h.

◆ pointer

typedef char* SG::ArenaAllocatorBase::pointer

inherited

Type for pointers to elements.

Definition at line 137 of file ArenaAllocatorBase.h.

Constructor & Destructor Documentation

◆ ArenaBlockAllocatorBase() [1/3]

SG::ArenaBlockAllocatorBase::ArenaBlockAllocatorBase ( const Params & params )

Constructor.

Parameters

params The parameters structure for this allocator. See ArenaAllocatorBase.h for the contents.

Definition at line 25 of file ArenaBlockAllocatorBase.cxx.

   : m_params (params),
     m_blocks (nullptr),
     m_freeblocks (nullptr),
     m_stats(),
     m_protected (false)
 {
 }

◆ ~ArenaBlockAllocatorBase()

SG::ArenaBlockAllocatorBase::~ArenaBlockAllocatorBase ( )

virtual

Destructor.

Definition at line 38 of file ArenaBlockAllocatorBase.cxx.

 {
   // Should be called by the derived class dtor.
   // Can't do it from here since it may call reset(), which is
   // pure virtual in this class.
   //erase();
 }

◆ ArenaBlockAllocatorBase() [2/3]

SG::ArenaBlockAllocatorBase::ArenaBlockAllocatorBase ( const ArenaBlockAllocatorBase & )

delete

Don't allow copy construction or assignment.

◆ ArenaBlockAllocatorBase() [3/3]

SG::ArenaBlockAllocatorBase::ArenaBlockAllocatorBase ( ArenaBlockAllocatorBase && other )

Move constructor.

Definition at line 50 of file ArenaBlockAllocatorBase.cxx.

     : m_params (other.m_params),
       m_blocks (other.m_blocks),
       m_freeblocks (other.m_freeblocks),
       m_stats (other.m_stats),
       m_protected (other.m_protected)
 {
   other.m_blocks = nullptr;
   other.m_freeblocks = nullptr;
   other.m_stats.clear();
   other.m_protected = false;
 }

Member Function Documentation

◆ clear_fcn()

template<typename T >

static void SG::ArenaAllocatorBase::clear_fcn ( pointer p )

staticprivateinherited

Call T::clear on the object at p.

Parameters

p	The object on which to run the `clear`.

◆ construct_fcn()

template<typename T >

static void SG::ArenaAllocatorBase::construct_fcn ( pointer p )

staticprivateinherited

Call T's default constructor on the object at p.

Parameters

p	The object on which to run the constructor.

◆ destroy_fcn()

template<typename T >

static void SG::ArenaAllocatorBase::destroy_fcn ( pointer p )

staticprivateinherited

Call T's destructor on the object at p.

Parameters

p	The object on which to run the destructor.

◆ erase()

void SG::ArenaBlockAllocatorBase::erase ( )

overridevirtual

Free all allocated elements and release memory back to the system.

All elements allocated are freed, and all allocated blocks of memory are released back to the system. destructor should be called on them if it was provided (preceded by clear if provided and mustClear was set).

Implements SG::ArenaAllocatorBase.

Reimplemented in SG::ArenaPoolAllocator, and SG::ArenaHeapAllocator.

Definition at line 172 of file ArenaBlockAllocatorBase.cxx.

 {
   if (m_protected) {
     throw SG::ExcProtected();
   }
   // Do we need to run clear() on the allocated elements?
   // If so, do so via reset().
   if (m_params.mustClear && m_params.clear) {
     reset();
   }
  
   // Kill the block lists (both free and in use).
   ArenaBlock::destroyList (m_blocks, m_params.destructor);
   ArenaBlock::destroyList (m_freeblocks, m_params.destructor);
   m_blocks = m_freeblocks = nullptr;
  
   // Reset statistics.
   m_stats.clear();
 }

◆ getBlock()

ArenaBlock * SG::ArenaBlockAllocatorBase::getBlock ( )

protected

Return an empty block, either newly-allocated or from the free list.

Update statistics appropriately.

Definition at line 234 of file ArenaBlockAllocatorBase.cxx.

 {
   if (m_protected) {
     throw SG::ExcProtected();
   }
  
   ArenaBlock* newblock = m_freeblocks;
   if (newblock) {
     // There's something on the free list.  Remove it and update statistics.
     m_freeblocks = newblock->link();
     --m_stats.blocks.free;
   }
   else {
     // Otherwise, we need to make a new block.
     newblock = ArenaBlock::newBlock (m_params.nblock, m_params.eltSize,
                                      m_params.constructor);
     m_stats.elts.total += newblock->size();
     ++m_stats.blocks.total;
   }
   // Finish updating statistics.
   // (Remaining ones are computed in stats().)
   ++m_stats.blocks.inuse;
  
   // Link it into the in-use list and return.
   newblock->link() = m_blocks;
   m_blocks = newblock;
   return newblock;
 }

◆ makeClear() [1/2]

template<class T >

static func_t* SG::ArenaAllocatorBase::makeClear ( const std::false_type & )

staticinherited

Make a function pointer for a clear function.

◆ makeClear() [2/2]

template<class T >

static func_t* SG::ArenaAllocatorBase::makeClear ( const std::true_type & )

staticinherited

Make a dummy clear function pointer.

◆ makeConstructor() [1/2]

template<class T >

static func_t* SG::ArenaAllocatorBase::makeConstructor ( const std::false_type & )

staticinherited

Make a constructor function pointer for a non-trivial constructor.

◆ makeConstructor() [2/2]

template<class T >

static func_t* SG::ArenaAllocatorBase::makeConstructor ( const std::true_type & )

staticinherited

Make a constructor function pointer for a trivial constructor.

◆ makeDestructor() [1/2]

template<class T >

static func_t* SG::ArenaAllocatorBase::makeDestructor ( const std::false_type & )

staticinherited

Make a constructor function pointer for a non-trivial destructor.

◆ makeDestructor() [2/2]

template<class T >

static func_t* SG::ArenaAllocatorBase::makeDestructor ( const std::true_type & )

staticinherited

Make a constructor function pointer for a trivial destructor.

◆ name()

const std::string & SG::ArenaBlockAllocatorBase::name ( ) const

overridevirtual

Return the name of this allocator.

Implements SG::ArenaAllocatorBase.

Definition at line 214 of file ArenaBlockAllocatorBase.cxx.

 {
   return m_params.name;
 }

◆ operator=() [1/2]

ArenaBlockAllocatorBase & SG::ArenaBlockAllocatorBase::operator= ( ArenaBlockAllocatorBase && other )

Move assignment.

Definition at line 69 of file ArenaBlockAllocatorBase.cxx.

 {
   if (this != &other) {
     erase();
     m_params = other.m_params;
     m_blocks = other.m_blocks;
     m_freeblocks = other.m_freeblocks;
     m_stats = other.m_stats;
     m_protected = other.m_protected;
     other.m_blocks = nullptr;
     other.m_freeblocks = nullptr;
     other.m_stats.clear();
     other.m_protected = false;
   }
   return *this;
 }

◆ operator=() [2/2]

ArenaBlockAllocatorBase& SG::ArenaBlockAllocatorBase::operator= ( const ArenaBlockAllocatorBase & )

delete

◆ params()

const ArenaAllocatorBase::Params & SG::ArenaBlockAllocatorBase::params ( ) const

Return this Allocator's parameters.

Return this allocator's parameters.

Definition at line 224 of file ArenaBlockAllocatorBase.cxx.

 {
   return m_params;
 }

◆ protect()

void SG::ArenaBlockAllocatorBase::protect ( )

Write-protect the memory managed by this allocator.

Adjust protection on the memory managed by this allocator to disallow writes.

Definition at line 270 of file ArenaBlockAllocatorBase.cxx.

 {
   SG::ArenaBlock::protectList (m_blocks);
   m_protected = true;
 }

◆ report()

void SG::ArenaAllocatorBase::report ( std::ostream & os ) const

virtualinherited

Generate a report on the memory usage of this allocator.

Parameters

os	Stream to which the report should be written.

Definition at line 131 of file ArenaAllocatorBase.cxx.

 {
   os << " " << stats() << "  " << name() << std::endl;
 }

◆ reserve()

void SG::ArenaBlockAllocatorBase::reserve ( size_t size )

overridevirtual

Set the total number of elements cached by the allocator.

Parameters

size	The desired pool size.

This allows changing the number of elements that are currently free but cached. Any allocated elements are not affected by this call.

If size is greater than the total number of elements currently cached, then more will be allocated. This will preferably done with a single block, but that is not guaranteed; in addition, the allocator may allocate more elements than is requested.

If size is smaller than the total number of elements currently cached, as many blocks as possible will be released back to the system. It may not be possible to release the number of elements requested; this should be implemented on a best-effort basis.

Implements SG::ArenaAllocatorBase.

Definition at line 120 of file ArenaBlockAllocatorBase.cxx.

 {
   if (m_protected) {
     throw SG::ExcProtected();
   }
   if (size > m_stats.elts.total) {
     // Growing the pool.
     // Make a new block of the required size.
     size_t sz = size - m_stats.elts.total;
     ArenaBlock* newblock = ArenaBlock::newBlock (sz, m_params.eltSize,
                                                  m_params.constructor);
  
     // Update statistics (others are derived in stats()).
     ++m_stats.blocks.free;
     ++m_stats.blocks.total;
     m_stats.elts.total += newblock->size();
  
     // Add to the free list.
     newblock->link() = m_freeblocks;
     m_freeblocks = newblock;
   }
   else {
     // Shrinking the pool.
     // Loop while we can get rid of the first free block.
     while (size < m_stats.elts.total &&
            m_freeblocks &&
            m_freeblocks->size() <= (m_stats.elts.total - size))
     {
       // Remove it from the free list.
       ArenaBlock* p = m_freeblocks;
       m_freeblocks = m_freeblocks->link();
  
       // Update statistics (others are derived in stats()).
       m_stats.elts.total -= p->size();
       --m_stats.blocks.free;
       --m_stats.blocks.total;
  
       // Free the block.
       ArenaBlock::destroy (p, m_params.destructor);
     }
   }
 }

◆ reset()

virtual void SG::ArenaAllocatorBase::reset ( )

pure virtualinherited

Free all allocated elements.

All elements allocated are returned to the free state. clear should be called on them if it was provided. The elements may continue to be cached internally, without returning to the system.

Implemented in SG::ArenaPoolAllocator, and SG::ArenaHeapAllocator.

◆ stats()

ArenaAllocatorBase::Stats SG::ArenaBlockAllocatorBase::stats ( ) const

overridevirtual

Return the statistics block for this allocator.

Implements SG::ArenaAllocatorBase.

Definition at line 196 of file ArenaBlockAllocatorBase.cxx.

 {
   // Calculate derived statistics.
   Stats stats = m_stats;
   stats.elts.free = stats.elts.total - stats.elts.inuse;
   stats.bytes.inuse = stats.elts.inuse   * m_params.eltSize +
                       stats.blocks.inuse * ArenaBlock::overhead();
   stats.bytes.total = stats.elts.total   * m_params.eltSize +
                       stats.blocks.total * ArenaBlock::overhead();
   stats.bytes.free  = stats.elts.free   * m_params.eltSize +
                       stats.blocks.free * ArenaBlock::overhead();
   return stats;
 }

◆ swap()

void SG::ArenaBlockAllocatorBase::swap ( ArenaBlockAllocatorBase & other )

Swap.

Definition at line 91 of file ArenaBlockAllocatorBase.cxx.

 {
   if (this != &other) {
     std::swap (m_params, other.m_params);
     std::swap (m_blocks, other.m_blocks);
     std::swap (m_freeblocks, other.m_freeblocks);
     std::swap (m_stats, other.m_stats);
     std::swap (m_protected, other.m_protected);
   }
 }

◆ unprotect()

void SG::ArenaBlockAllocatorBase::unprotect ( )

Write-enable the memory managed by this allocator.

Adjust protection on the memory managed by this allocator to allow writes.

Definition at line 283 of file ArenaBlockAllocatorBase.cxx.

 {
   if (m_protected) {
     SG::ArenaBlock::unprotectList (m_blocks);
     m_protected = false;
   }
 }

Member Data Documentation

◆ m_blocks

ArenaBlock* SG::ArenaBlockAllocatorBase::m_blocks

protected

The list of blocks currently in use.

Definition at line 153 of file ArenaBlockAllocatorBase.h.

◆ m_freeblocks

ArenaBlock* SG::ArenaBlockAllocatorBase::m_freeblocks

protected

The list of free blocks.

Definition at line 156 of file ArenaBlockAllocatorBase.h.

◆ m_params

Params SG::ArenaBlockAllocatorBase::m_params

protected

The parameters for this allocator.

Definition at line 150 of file ArenaBlockAllocatorBase.h.

◆ m_protected

bool SG::ArenaBlockAllocatorBase::m_protected

protected

Flag whether the arena has been protected.

Definition at line 162 of file ArenaBlockAllocatorBase.h.

◆ m_stats

ArenaAllocatorBase::Stats SG::ArenaBlockAllocatorBase::m_stats

protected

The statistics structure.

Definition at line 159 of file ArenaBlockAllocatorBase.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Private Member Functions

Detailed Description

Member Typedef Documentation

◆ const_pointer

◆ func_t

◆ pointer

Constructor & Destructor Documentation

◆ ArenaBlockAllocatorBase() [1/3]

◆ ~ArenaBlockAllocatorBase()

◆ ArenaBlockAllocatorBase() [2/3]

◆ ArenaBlockAllocatorBase() [3/3]

Member Function Documentation

◆ clear_fcn()

◆ construct_fcn()

◆ destroy_fcn()

◆ erase()

◆ getBlock()

◆ makeClear() [1/2]

◆ makeClear() [2/2]

◆ makeConstructor() [1/2]

◆ makeConstructor() [2/2]

◆ makeDestructor() [1/2]

◆ makeDestructor() [2/2]

◆ name()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ params()

◆ protect()

◆ report()

◆ reserve()

◆ reset()

◆ stats()

◆ swap()

◆ unprotect()

Member Data Documentation

◆ m_blocks

◆ m_freeblocks

◆ m_params

◆ m_protected

◆ m_stats