ArenaSharedHeapSTLAllocator.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-2021 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATLALLOCATORS_ARENASHAREDHEAPSTLALLOCATOR_H
#define ATLALLOCATORS_ARENASHAREDHEAPSTLALLOCATOR_H
 
 
#include "AthAllocators/ArenaHeapAllocator.h"
#include "AthAllocators/ArenaHeapSTLAllocator.h"
#include "AthAllocators/ArenaAllocatorRegistry.h"
#include "CxxUtils/concepts.h"
#include <string>
#include <vector>
 
 
namespace SG {
 
template <class T>
class ArenaSharedHeapSTLAllocator;
 
 
class ArenaSharedHeapSTLHeader
{
public:
  ArenaSharedHeapSTLHeader (const void* owner, int nblock);
 
 
  ~ArenaSharedHeapSTLHeader();
 
 
  void maybe_delete (const void* a);
 
 
  ArenaAllocatorBase::Stats totstats() const;
      
 
  template <class T>
  static std::string get_name();
    
 
  template <class T>
  ArenaHeapAllocator* get_pool();
 
 
  void update_owner (const void* old_owner, const void* new_owner);
 
 
  void report (std::ostream& os) const;
 
 
  void protect();
 
 
  void unprotect();
 
 
private:
  template <class T>
  static size_t get_index();
 
  const void* m_owner;
 
  size_t m_nblock;
 
  std::vector<ArenaHeapAllocator*> m_allocators;
};
 
 
 
 
template <class T>
class ArenaSharedHeapSTLAllocator
{
public:
  template <class U> friend class ArenaSharedHeapSTLAllocator;
 
  typedef T*        pointer;
  typedef const T*  const_pointer;
  typedef T&        reference;
  typedef const T&  const_reference;
  typedef T         value_type;
  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
 
  typedef std::false_type propagate_on_container_copy_assignment;
 
  typedef std::true_type propagate_on_container_move_assignment;
  typedef std::true_type propagate_on_container_swap;
 
  
  template <class U> struct rebind {
    typedef ArenaSharedHeapSTLAllocator<U> other;
  };
 
 
  ArenaSharedHeapSTLAllocator (size_t nblock = 1000);
 
 
  ArenaSharedHeapSTLAllocator (const ArenaSharedHeapSTLAllocator& a);
 
 
  ArenaSharedHeapSTLAllocator (ArenaSharedHeapSTLAllocator&& a) = default;
 
 
  template <class U>
  ArenaSharedHeapSTLAllocator (const ArenaSharedHeapSTLAllocator<U>& a);
 
 
  // We don't bother to supply a more general constructor --- shouldn't
  // be needed.
 
 
  ~ArenaSharedHeapSTLAllocator();
 
 
  ArenaSharedHeapSTLAllocator&
  operator= (const ArenaSharedHeapSTLAllocator& a);
 
 
  ArenaSharedHeapSTLAllocator& operator= (ArenaSharedHeapSTLAllocator&& a);
 
 
  void swap (ArenaSharedHeapSTLAllocator& a);
 
 
  bool operator== (const ArenaSharedHeapSTLAllocator& other) const;
 
 
  bool operator!= (const ArenaSharedHeapSTLAllocator& other) const;
 
 
  pointer address (reference x) const;
  ATH_MEMBER_REQUIRES(!(std::is_same_v<reference,const_reference>),
                      const_pointer)
  address (const_reference x) const { return &x; }
 
 
  pointer allocate (size_type n, const void* hint = 0);
 
 
  void deallocate (pointer, size_type n);
  ATH_MEMBER_REQUIRES(!(std::is_same_v<pointer,const_pointer>), void)
  deallocate (const_pointer p, size_type n) const
  {
    pointer p_nc ATLAS_THREAD_SAFE = const_cast<pointer>(p);
    deallocate (p_nc, n);
  }
 
 
  size_type max_size() const throw();
 
 
  template <class... Args>
  void construct (pointer p, Args&&... args);
 
 
  void destroy (pointer p);
 
 
  size_t nblock() const;
 
 
  const std::string& name() const;
 
 
  void reset();
 
 
  void erase();
 
 
  void reserve (size_t size);
 
 
  ArenaAllocatorBase::Stats stats() const;
 
 
  ArenaAllocatorBase::Stats totstats() const;
 
 
  ArenaHeapAllocator* poolptr();
 
 
  const ArenaHeapAllocator* poolptr() const;
 
 
  void report (std::ostream& os) const;
  
 
  void protect();
 
 
  void unprotect();
 
 
private:
  ArenaSharedHeapSTLHeader* m_header;
  ArenaHeapAllocator* m_pool;
};
 
 
template <class T>
void swap (ArenaSharedHeapSTLAllocator<T>& a, ArenaSharedHeapSTLAllocator<T>& b)
{
  a.swap (b);
}
 
 
template <class T>
void maybeUnprotect (ArenaSharedHeapSTLAllocator<T>& a);
 
 
} // namespace SG
 
 
#include "AthAllocators/ArenaSharedHeapSTLAllocator.icc"
 
 
#endif // not ATLALLOCATORS_ARENASHAREDHEAPSTLALLOCATOR_H