ArenaBlockAllocatorBase.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthAllocators/ArenaBlockAllocatorBase.h"
#include "AthAllocators/ArenaBlock.h"
#include "AthAllocators/exceptions.h"
 
 
namespace SG {
 

ArenaBlockAllocatorBase::ArenaBlockAllocatorBase (const Params& params)
  : m_params (params),
    m_blocks (nullptr),
    m_freeblocks (nullptr),
    m_stats(),
    m_protected (false)
{
}
 

ArenaBlockAllocatorBase::~ArenaBlockAllocatorBase()
{
  // 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::ArenaBlockAllocatorBase
  (ArenaBlockAllocatorBase&& other)
    : 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;
}
 

ArenaBlockAllocatorBase&
ArenaBlockAllocatorBase::operator=
  (ArenaBlockAllocatorBase&& other)
{
  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;
}
 

void ArenaBlockAllocatorBase::swap (ArenaBlockAllocatorBase& other)
{
  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);
  }
}
 

void ArenaBlockAllocatorBase::reserve (size_t size)
{
  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);
    }
  }
}
 

void ArenaBlockAllocatorBase::erase()
{
  if (m_protected) {
    throw SG::ExcProtected();
  }
  eraseUnprotected();
}
 

void ArenaBlockAllocatorBase::eraseUnprotected()
{
  // 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();
}
 

ArenaAllocatorBase::Stats ArenaBlockAllocatorBase::stats() const
{
  // 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;
}
 

const std::string& ArenaBlockAllocatorBase::name() const
{
  return m_params.name;
}
 

const ArenaAllocatorBase::Params&
ArenaBlockAllocatorBase::params() const
{
  return m_params;
}
 

ArenaBlock* ArenaBlockAllocatorBase::getBlock()
{
  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;
}
 

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

void ArenaBlockAllocatorBase::unprotect()
{
  if (m_protected) {
    SG::ArenaBlock::unprotectList (m_blocks);
    m_protected = false;
  }
}
 
 
} // namespace SG