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-2023 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 "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;
 
    size_t minSize;
 
    size_t nblock;
 
    size_t linkOffset;
 
 
    func_t* constructor;
    func_t* destructor;
 
    func_t* clear;
 
    bool canReclear;
 
    bool mustClear;
  };
 
 
  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
 
 
#include "AthAllocators/ArenaAllocatorBase.icc"
 
 
#endif // not ATLALLOCATORS_ARENAALLOCATORBASE_H