ArenaBlock.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "AthAllocators/ArenaBlock.h"
#include "AthAllocators/exceptions.h"
#include <cstdlib>
#include <unistd.h>
#include <cassert>
#include <new>
#include <sys/mman.h>
 
 
namespace SG {
 

std::atomic<size_t> ArenaBlock::s_nactive;
 

ArenaBlock*
ArenaBlock::newBlock (size_t n, size_t elt_size, func_t* ctor)
{
  static const size_t pageSize = sysconf (_SC_PAGESIZE);
  size_t tot_size = n*elt_size + ArenaBlockBodyOffset;
  // Round up to a multiple of pageSize.
  size_t tot_size_rounded = (tot_size + (pageSize-1)) & ~(pageSize-1);
  // Number of elements after rounding up.
  size_t n_rounded = (tot_size_rounded - ArenaBlockBodyOffset) / elt_size;
  assert (n_rounded >= n);
  ArenaBlock* p = reinterpret_cast<ArenaBlock*>
    (std::aligned_alloc (pageSize, tot_size_rounded));
  if (!p) throw std::bad_alloc();
  ++s_nactive;
  p->m_link = nullptr;
  p->m_elt_size = elt_size;
  p->m_size = n_rounded;
  if (ctor) {
    for (size_t i = 0; i < n_rounded; i++)
      ctor (p->index (i, elt_size));
  }
  return p;
}
 

void ArenaBlock::destroy (ArenaBlock* p, func_t* dtor)
{
  if (dtor) {
    size_t elt_size = p->eltSize();
    size_t n = p->size();
    for (size_t i = 0; i < n; i++) {
      dtor (p->index (i, elt_size));
    }
  }
  --s_nactive;
  std::free (p);
}
 

void
ArenaBlock::destroyList (ArenaBlock* p, func_t* dtor)
{
  while (p) {
    ArenaBlock* next = p->link();
    destroy (p, dtor);
    p = next;
  }
}
 

void ArenaBlock::appendList (ArenaBlock** link, ArenaBlock* tail)
{
  while (*link) {
    link = &(*link)->link();
  }
  *link = tail;
}
 

void ArenaBlock::applyList (ArenaBlock* p,
                            func_t* func,
                            size_t n)
{
  if (!p) return;
  size_t elt_size = p->eltSize();
  if (n > p->size()) {
    n = p->size();
  }
  while (1) {
    for (size_t i = 0; i < n; i++) {
      func (p->index (i, elt_size));
    }
    p = p->link();
    if (!p) break;
    n = p->size();
  }
}
 

size_t ArenaBlock::overhead()
{
  // The extra size_t is a guesstimate of malloc overhead.
  return ArenaBlockBodyOffset + sizeof (size_t);
}
 

void ArenaBlock::protect()
{
  int stat = mprotect (this, m_size*m_elt_size+ArenaBlockBodyOffset,
                       PROT_READ);
  if (stat) {
    throw SG::ExcProtection (errno);
  }
}
 

void ArenaBlock::unprotect()
{
  int stat = mprotect (this, m_size*m_elt_size+ArenaBlockBodyOffset,
                       PROT_READ + PROT_WRITE);
  if (stat) {
    throw SG::ExcProtection (errno);
  }
}
 

void ArenaBlock::protectList (ArenaBlock* p)
{
  for (; p; p = p->link()) {
    p->protect();
  }
}
 

void ArenaBlock::unprotectList (ArenaBlock* p)
{
  for (; p; p = p->link()) {
    p->unprotect();
  }
}
 
 
} // namespace SG