ArenaAllocatorBase.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
 
#ifndef ATLALLOCATORS_ARENAALLOCATORBASE_H
#define ATLALLOCATORS_ARENAALLOCATORBASE_H
 
 
#include <cstdlib>
#include <new>
#include <string>
#include <iosfwd>
#include <type_traits>
#include <format>
#include "AthAllocators/ArenaBlockAlignDetail.h"
 
namespace SG {
 

class ArenaAllocatorBase
{
public:
  typedef char* pointer;

  typedef const char* const_pointer;

  typedef void func_t (pointer);
 

  struct Params
  {
    std::string name;

    size_t eltSize = 0;

    size_t minSize = 0;

    size_t nblock = 0;

    size_t linkOffset = 0;

 
    func_t* constructor = nullptr;
    func_t* destructor = nullptr;

    func_t* clear = nullptr;

    bool canReclear = false;

    bool mustClear = false;
  };
 

  struct Stats {
    // Strictly unneeded, but without it we get a cppcheck false positive.
    Stats() = default;

    struct Stat {
      Stat();
      void clear();
      Stat& operator+= (const Stat& other);

      size_t inuse;
      size_t free;
      size_t total;
    };

    void clear();
    Stats& operator+= (const Stats& other);
    static void header (std::ostream& os);

    Stat blocks;
    Stat elts;
    Stat bytes;
  };
 

  virtual ~ArenaAllocatorBase() {}
 

  virtual void reset() = 0;
 

  virtual void erase() = 0;
 

  virtual void reserve (size_t size) = 0;
 

  virtual Stats stats() const = 0;
 

  virtual const std::string& name() const = 0;
 

  virtual void report (std::ostream& os) const;
 
 
  //=========================================================================
  template <typename T,
            bool clear = false,
            bool no_ctor = false,
            bool no_dtor = false>
  struct initParams
  {
 
    static_assert(
        std::alignment_of<T>::value <= SG::ArenaBlockAlignDetail::alignment,
        "Requested Alignment larger than the one that can be provided");
    initParams (size_t nblock = 1000, const std::string& name = "");

    Params params() const;

    // Note: gcc 3.2.3 doesn't allow defining this out-of-line.
    operator Params() const { return params(); }
 
 
  private:
    size_t m_nblock;

    std::string m_name;
  };
 

  template <class T>
  static func_t* makeConstructor (const std::false_type&);

  template <class T>
  static func_t* makeConstructor (const std::true_type&);

  template <class T>
  static func_t* makeDestructor (const std::false_type&);

  template <class T>
  static func_t* makeDestructor (const std::true_type&);

  template <class T>
  static func_t* makeClear (const std::false_type&);

  template <class T>
  static func_t* makeClear (const std::true_type&);
 
private:
  template <typename T>
  static void construct_fcn (pointer p);
 

  template <typename T>
  static void destroy_fcn (pointer p);
 

  template <typename T>
  static void clear_fcn (pointer p);
};
 

std::ostream& operator<< (std::ostream& os,
                          const ArenaAllocatorBase::Stats::Stat& stat);
 

std::ostream& operator<< (std::ostream& os,
                          const ArenaAllocatorBase::Stats& stats);
 
} // namespace SG
 

namespace std {
template <>
struct formatter<SG::ArenaAllocatorBase::Stats::Stat>
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format(const SG::ArenaAllocatorBase::Stats::Stat& stat, FmtContext& ctx) const;
};
 
template <>
struct formatter<SG::ArenaAllocatorBase::Stats>
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format(const SG::ArenaAllocatorBase::Stats& stats, FmtContext& ctx) const;
};
} // namespace std
 
 
#include "AthAllocators/ArenaAllocatorBase.icc"
 
 
#endif // not ATLALLOCATORS_ARENAALLOCATORBASE_H