ArenaPoolAllocator.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#include "AthAllocators/ArenaPoolAllocator.h"
#include "AthAllocators/ArenaBlock.h"
#include "AthAllocators/exceptions.h"
#include <cassert>
 
 
namespace SG {
 
 
inline
ArenaPoolAllocator::pointer
ArenaPoolAllocator_iterator_increment (ArenaPoolAllocator::pointer base,
                                       ArenaBlock* & block)
{
  // If we haven't yet reached the start of this block, move the iterator
  // back one.
  if (base > block->index(0,0)) {
    return base - block->eltSize();
  }
 
  // Move to the previous block.
  block = block->link();
  if (block) {
    return block->index (block->size()-1, block->eltSize());
  }
  return nullptr;
}
 
 
inline
ArenaPoolAllocator::const_pointer
ArenaPoolAllocator_iterator_increment (ArenaPoolAllocator::const_pointer base,
                                       const ArenaBlock* & block)
{
  // If we haven't yet reached the start of this block, move the iterator
  // back one.
  if (base > block->index(0,0)) {
    return base - block->eltSize();
  }
 
  // Move to the previous block.
  block = block->link();
  if (block) {
    return block->index (block->size()-1, block->eltSize());
  }
  return nullptr;
}
 
 
void ArenaPoolAllocator::iterator::increment()
{
  this->base_reference() =
    ArenaPoolAllocator_iterator_increment (this->base_reference(), m_block);
}
 
 
void ArenaPoolAllocator::const_iterator::increment()
{
  ArenaPoolAllocator::const_pointer base = this->base_reference();
  base = ArenaPoolAllocator_iterator_increment (base, m_block);
  this->base_reference() = base;
}
 
 
ArenaPoolAllocator::ArenaPoolAllocator (const Params& params)
  : ArenaBlockAllocatorBase (params),
    m_ptr (nullptr),
    m_end (nullptr)
{
}
 
 
ArenaPoolAllocator::~ArenaPoolAllocator()
{
  if (m_protected) {
    try {
      unprotect();
    }
    catch (const SG::ExcProtection&) {
      // Got an error from mprotect...
      std::abort();
    }
  }
  ArenaBlockAllocatorBase::eraseUnprotected();
}
 
 
ArenaPoolAllocator::ArenaPoolAllocator
  (ArenaPoolAllocator&& other)
    : 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;
}
 
 
ArenaPoolAllocator&
ArenaPoolAllocator::operator=
  (ArenaPoolAllocator&& other)
{
  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;
}
 
 
void ArenaPoolAllocator::swap (ArenaPoolAllocator& other)
{
  if (this != &other) {
    ArenaBlockAllocatorBase::swap (other);
    std::swap (m_ptr, other.m_ptr);
    std::swap (m_end, other.m_end);
  }
}
 
 
void ArenaPoolAllocator::reset()
{
  // 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);
}
 
 
void ArenaPoolAllocator::erase()
{
  // Delete all the blocks.
  ArenaBlockAllocatorBase::erase();
 
  // Reset pointers.
  m_ptr = m_end = nullptr;
}
 
 
void ArenaPoolAllocator::resetTo (pointer blk)
{
  // 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;
    }
  }
}
 
 
ArenaPoolAllocator::iterator ArenaPoolAllocator::begin()
{
  // 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);
}
 
 
ArenaPoolAllocator::const_iterator ArenaPoolAllocator::begin() const
{
  // 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);
}
 
 
ArenaPoolAllocator::iterator ArenaPoolAllocator::end()
{
  // Use a null iterator to signal the end.
  return iterator ();
}
 
 
ArenaPoolAllocator::const_iterator ArenaPoolAllocator::end() const
{
  // Use a null iterator to signal the end.
  return const_iterator ();
}
 
 
void ArenaPoolAllocator::refill()
{
  // 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);
}
 
 
void ArenaPoolAllocator::clearBlock()
{
  // 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;
  }
}
 
 
} // namespace SG