SG::ArenaPoolAllocator Class Reference

Pool-based allocator. More...

#include <ArenaPoolAllocator.h>

Inheritance diagram for SG::ArenaPoolAllocator:

Collaboration diagram for SG::ArenaPoolAllocator:

Classes
class	const_iterator
	Const iterator for the pool. More...
class	iterator
	Non-const iterator for the pool. More...

Public Types
typedef char *	pointer
	Type for pointers to elements.
typedef const char *	const_pointer
	And a const version of the pointer.
typedef void	func_t(pointer)
	Type of functions for constructor, etc.

Public Member Functions
	ArenaPoolAllocator (const Params &params)
	Constructor.
virtual	~ArenaPoolAllocator ()
	Destructor.
	ArenaPoolAllocator (const ArenaPoolAllocator &)=delete
	Don't allow copy construction or assignment.
ArenaPoolAllocator &	operator= (const ArenaPoolAllocator &)=delete
	ArenaPoolAllocator (ArenaPoolAllocator &&other)
	Move constructor.
ArenaPoolAllocator &	operator= (ArenaPoolAllocator &&other)
	Move assignment.
void	swap (ArenaPoolAllocator &other)
	Swap.
pointer	allocate ()
	Allocate a new element.
virtual void	reset () override
	Free all allocated elements.
virtual void	erase () override final
	Free all allocated elements and release memory back to the system.
void	resetTo (pointer p)
	Reset pool back to a previous state.
iterator	begin ()
	Starting pool iterator.
const_iterator	begin () const
	Starting pool const iterator.
iterator	end ()
	Ending pool iterator.
const_iterator	end () const
	Ending pool const iterator.
void	swap (ArenaBlockAllocatorBase &other)
	Swap.
virtual void	reserve (size_t size) override
	Set the total number of elements cached by the allocator.
virtual Stats	stats () const override
	Return the statistics block for this allocator.
virtual const std::string &	name () const override
	Return the name of this allocator.
const Params &	params () const
	Return this Allocator's parameters.
void	protect ()
	Write-protect the memory managed by this allocator.
void	unprotect ()
	Write-enable the memory managed by this allocator.
virtual void	report (std::ostream &os) const
	Generate a report on the memory usage of this allocator.

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.
template<class T>
static func_t *	makeConstructor (const std::true_type &)
	Make a constructor function pointer for a trivial constructor.
template<class T>
static func_t *	makeDestructor (const std::false_type &)
	Make a constructor function pointer for a non-trivial destructor.
template<class T>
static func_t *	makeDestructor (const std::true_type &)
	Make a constructor function pointer for a trivial destructor.
template<class T>
static func_t *	makeClear (const std::false_type &)
	Make a function pointer for a clear function.
template<class T>
static func_t *	makeClear (const std::true_type &)
	Make a dummy clear function pointer.

Protected Member Functions
ArenaBlock *	getBlock ()
	Return an empty block, either newly-allocated or from the free list.
void	eraseUnprotected ()
	Free all allocated elements and release memory back to the system.

Protected Attributes
Params	m_params
	The parameters for this allocator.
ArenaBlock *	m_blocks
	The list of blocks currently in use.
ArenaBlock *	m_freeblocks
	The list of free blocks.
ArenaAllocatorBase::Stats	m_stats
	The statistics structure.
bool	m_protected
	Flag whether the arena has been protected.

Private Member Functions
void	refill ()
	Add more free elements to the pool.
void	clearBlock ()
	Reset all elements in the topmost block, and move the block to the free list.

Static Private Member Functions
template<typename T>
static void	construct_fcn (pointer p)
	Call T's default constructor on the object at p.
template<typename T>
static void	destroy_fcn (pointer p)
	Call T's destructor on the object at p.
template<typename T>
static void	clear_fcn (pointer p)
	Call T::clear on the object at p.

Private Attributes
pointer	m_ptr
	Pointer to the next free element to allocate, or null.
pointer	m_end
	One past the last available element in the current block, of null.

Detailed Description

Pool-based allocator.

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

This is a block-based memory allocator, with stack-like behavior (like the DataPool class). We do not allow freeing individual elements; instead, we support resetTo(p), which frees and all elements allocated after it (in this allocator). We also implement an iterator over the allocated blocks.

Definition at line 38 of file ArenaPoolAllocator.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

ArenaPoolAllocator() [1/3]

SG::ArenaPoolAllocator::ArenaPoolAllocator

(

const Params &

params

)

Constructor.

Parameters

params

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

Definition at line 97 of file ArenaPoolAllocator.cxx.

  : ArenaBlockAllocatorBase (params),
    m_ptr (nullptr),
    m_end (nullptr)
{
}

~ArenaPoolAllocator()

SG::ArenaPoolAllocator::~ArenaPoolAllocator ( )

virtual

Destructor.

This will free all the Allocator's storage.

Definition at line 108 of file ArenaPoolAllocator.cxx.

{
  if (m_protected) {
    try {
      unprotect();
    }
    catch (const SG::ExcProtection&) {
      // Got an error from mprotect...
      std::abort();
    }
  }
  ArenaBlockAllocatorBase::eraseUnprotected();
}

ArenaPoolAllocator() [2/3]

SG::ArenaPoolAllocator::ArenaPoolAllocator ( const ArenaPoolAllocator & )

delete

Don't allow copy construction or assignment.

ArenaPoolAllocator() [3/3]

SG::ArenaPoolAllocator::ArenaPoolAllocator

(

ArenaPoolAllocator &&

other

)

Move constructor.

Definition at line 126 of file ArenaPoolAllocator.cxx.

    : ArenaBlockAllocatorBase (std::move (other)),
      m_ptr (other.m_ptr),
      m_end (other.m_end)
{
  // False positives
  // cppcheck-suppress useInitializationList
  other.m_ptr = nullptr;
  // cppcheck-suppress useInitializationList
  other.m_end = nullptr;
}

Member Function Documentation

allocate()

pointer SG::ArenaPoolAllocator::allocate

(

)

Allocate a new element.

The fast path of this will be completely inlined.

begin() [1/2]

ArenaPoolAllocator::iterator SG::ArenaPoolAllocator::begin

(

)

Starting pool iterator.

This will iterate over all allocated elements (in unspecified order). It is a forward_iterator.

Definition at line 271 of file ArenaPoolAllocator.cxx.

{
  // If @c m_ptr is one set, it is one more than the last allocated element.
  return iterator (m_ptr ? m_ptr - m_params.eltSize : nullptr, m_blocks);
}

begin() [2/2]

ArenaPoolAllocator::const_iterator SG::ArenaPoolAllocator::begin

(

)

const

Starting pool const iterator.

This will iterate over all allocated elements (in unspecified order). It is a forward_iterator.

Definition at line 284 of file ArenaPoolAllocator.cxx.

{
  // If @c m_ptr is one set, it is one more than the last allocated element.
  return const_iterator (m_ptr ? m_ptr - m_params.eltSize : nullptr, m_blocks);
}

clear_fcn()

template<typename T>

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.

clearBlock()

void SG::ArenaPoolAllocator::clearBlock ( )

private

Reset all elements in the topmost block, and move the block to the free list.

Definition at line 329 of file ArenaPoolAllocator.cxx.

{
  // The topmost block.
  ArenaBlock* p = m_blocks;
 
  // Nothing to do if there are no allocated blocks!
  if (!p) return;
 
  size_t elt_size = p->eltSize();
 
  // The first element of the block.
  pointer base = p->index(0, elt_size);
 
  // Do we need to call @c clear?  If so, call it on all allocated elements
  // in this block.
  func_t* clear = m_params.clear;
  if (clear) {
    pointer elt = base;
    while (elt < m_ptr) {
      clear (elt);
      elt += elt_size;
    }
  }
 
  // Update statistics.
  --m_stats.blocks.inuse;
  ++m_stats.blocks.free;
  m_stats.elts.inuse -= (m_ptr - base) / elt_size;
 
  // Move the block from the allocated to the free list.
  m_blocks = p->link();
  p->link() = m_freeblocks;
  m_freeblocks = p;
  p = m_blocks;
 
  // Reset the pointers.
  if (p) {
    m_ptr = m_end = p->index(p->size());
  }
  else {
    m_ptr = m_end = nullptr;
  }
}

construct_fcn()

template<typename T>

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>

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.

end() [1/2]

ArenaPoolAllocator::iterator SG::ArenaPoolAllocator::end

(

)

Ending pool iterator.

Definition at line 294 of file ArenaPoolAllocator.cxx.

{
  // Use a null iterator to signal the end.
  return iterator ();
}

end() [2/2]

ArenaPoolAllocator::const_iterator SG::ArenaPoolAllocator::end

(

)

const

Ending pool const iterator.

Definition at line 304 of file ArenaPoolAllocator.cxx.

{
  // Use a null iterator to signal the end.
  return const_iterator ();
}

erase()

void SG::ArenaPoolAllocator::erase ( )

finaloverridevirtual

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

Reimplemented from SG::ArenaBlockAllocatorBase.

Definition at line 201 of file ArenaPoolAllocator.cxx.

{
  // Delete all the blocks.
  ArenaBlockAllocatorBase::erase();
 
  // Reset pointers.
  m_ptr = m_end = nullptr;
}

eraseUnprotected()

void SG::ArenaBlockAllocatorBase::eraseUnprotected ( )

protectedinherited

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

Assumes that the blocks are already unprotected.

Definition at line 186 of file ArenaBlockAllocatorBase.cxx.

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

protectedinherited

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

Update statistics appropriately.

Definition at line 245 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>

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

staticinherited

Make a function pointer for a clear function.

makeClear() [2/2]

template<class T>

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

staticinherited

Make a dummy clear function pointer.

makeConstructor() [1/2]

template<class T>

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>

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>

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>

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

overridevirtualinherited

Return the name of this allocator.

Implements SG::ArenaAllocatorBase.

Definition at line 225 of file ArenaBlockAllocatorBase.cxx.

{
  return m_params.name;
}

operator=() [1/2]

ArenaPoolAllocator & SG::ArenaPoolAllocator::operator=

(

ArenaPoolAllocator &&

other

)

Move assignment.

Definition at line 144 of file ArenaPoolAllocator.cxx.

{
  if (this != &other) {
    ArenaBlockAllocatorBase::operator= (std::move (other));
    m_ptr = other.m_ptr;
    m_end = other.m_end;
    other.m_ptr = nullptr;
    other.m_end = nullptr;
  }
  return *this;
}

operator=() [2/2]

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

delete

params()

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

inherited

Return this Allocator's parameters.

Return this allocator's parameters.

Definition at line 235 of file ArenaBlockAllocatorBase.cxx.

{
  return m_params;
}

protect()

void SG::ArenaBlockAllocatorBase::protect ( )

inherited

Write-protect the memory managed by this allocator.

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

Definition at line 281 of file ArenaBlockAllocatorBase.cxx.

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

refill()

void SG::ArenaPoolAllocator::refill ( )

private

Add more free elements to the pool.

Definition at line 314 of file ArenaPoolAllocator.cxx.

{
  // Get a new block.
  ArenaBlock* newblock = getBlock();
 
  // Set the pointers.
  m_ptr = newblock->index (0,                m_params.eltSize);
  m_end = newblock->index (newblock->size(), m_params.eltSize);
}

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 130 of file ArenaAllocatorBase.cxx.

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

reserve()

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

overridevirtualinherited

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

void SG::ArenaPoolAllocator::reset ( )

overridevirtual

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.

Implements SG::ArenaAllocatorBase.

Definition at line 179 of file ArenaPoolAllocator.cxx.

{
  // Clear each block in turn.
  while (m_blocks) {
    clearBlock();
  }
 
  // Check that things are consistent.
  assert (m_stats.elts.inuse == 0);
  assert (m_ptr == nullptr);
  assert (m_end == nullptr);
}

resetTo()

void SG::ArenaPoolAllocator::resetTo

(

pointer

blk

)

Reset pool back to a previous state.

Parameters

p	The pointer back to which to reset.

This will free (a la reset) the element p and all elements that have been allocated after it from this allocator.

Parameters

blk	The pointer back to which to reset.

This will free (a la reset) the element p and all elements that have been allocated after it from this allocator.

Definition at line 218 of file ArenaPoolAllocator.cxx.

{
  // Clear the topmost block, as long as it doesn't contain the sought-after
  // pointer.
  ArenaBlock* p = m_blocks;
  assert (p != nullptr);
  size_t elt_size = p->eltSize();
  while (p && !(blk >= p->index(0, elt_size) &&
                blk < p->index(p->size(), elt_size)))
  {
    clearBlock();
    p = m_blocks;
  }
 
  // We'll trip this if the supplied pointer wasn't in any block.
  assert (p != nullptr);
 
  // If the element is at the beginning of this block, just clear the whole
  // thing.
  if (blk == p->index(0, elt_size)) {
    clearBlock();
  }
  else {
    // Otherwise, we need to clear some of the elements in this block.
    // See if we need to call @c clear.
    func_t* clear = m_params.clear;
    if (clear) {
      // Yeah, we do.  Call @c clear on each element in turn.
      while (m_ptr > blk) {
        m_ptr -= elt_size;
        clear (m_ptr);
        --m_stats.elts.inuse;
      }
      // We'll trip this if the supplied pointer wasn't on an element
      // boundary.
      assert (m_ptr == blk);
    }
    else {
      // We don't need to call @c clear.
      // So we can do it the fast way --- just reset pointers.
      m_stats.elts.inuse -= (m_ptr - blk) / elt_size;
      m_ptr = blk;
    }
  }
}

stats()

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

overridevirtualinherited

Return the statistics block for this allocator.

Implements SG::ArenaAllocatorBase.

Definition at line 207 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() [1/2]

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

inherited

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);
  }
}

swap() [2/2]

void SG::ArenaPoolAllocator::swap

(

ArenaPoolAllocator &

other

)

Swap.

Definition at line 161 of file ArenaPoolAllocator.cxx.

{
  if (this != &other) {
    ArenaBlockAllocatorBase::swap (other);
    std::swap (m_ptr, other.m_ptr);
    std::swap (m_end, other.m_end);
  }
}

unprotect()

void SG::ArenaBlockAllocatorBase::unprotect ( )

inherited

Write-enable the memory managed by this allocator.

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

Definition at line 294 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

protectedinherited

The list of blocks currently in use.

Definition at line 161 of file ArenaBlockAllocatorBase.h.

m_end

pointer SG::ArenaPoolAllocator::m_end

private

One past the last available element in the current block, of null.

Definition at line 265 of file ArenaPoolAllocator.h.

m_freeblocks

ArenaBlock* SG::ArenaBlockAllocatorBase::m_freeblocks

protectedinherited

The list of free blocks.

Definition at line 164 of file ArenaBlockAllocatorBase.h.

m_params

Params SG::ArenaBlockAllocatorBase::m_params

protectedinherited

The parameters for this allocator.

Definition at line 158 of file ArenaBlockAllocatorBase.h.

m_protected

bool SG::ArenaBlockAllocatorBase::m_protected

protectedinherited

Flag whether the arena has been protected.

Definition at line 170 of file ArenaBlockAllocatorBase.h.

m_ptr

pointer SG::ArenaPoolAllocator::m_ptr

private

Pointer to the next free element to allocate, or null.

Definition at line 262 of file ArenaPoolAllocator.h.

m_stats

ArenaAllocatorBase::Stats SG::ArenaBlockAllocatorBase::m_stats

protectedinherited

The statistics structure.

Definition at line 167 of file ArenaBlockAllocatorBase.h.

---

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

• ArenaPoolAllocator.h
• ArenaPoolAllocator.cxx