ArenaPoolSTLAllocator.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file  AthAllocators/ArenaPoolSTLAllocator.icc
 * @author scott snyder
 * @date Jul 2008
 * @brief STL-style allocator wrapper for @c ArenaPoolAllocator.
 */
 
 
#include <cassert>
 
 
namespace SG {
 
 
 
//****************************************************************************
// Generic specialization
//
 
 
/**
 * @brief Constructor.
 * @param nblock Value to set in the parameters structure for the
 *               number of elements to allocate per block.
 * @param name   Value to set in the parameters structure for the
 *               allocator name.
 */
template <class T>
ArenaPoolSTLAllocator_initParams<T>::ArenaPoolSTLAllocator_initParams
 (size_t nblock /*= 1000*/, const std::string& name /*= ""*/)
   : Base (nblock, name)
{
}
 
 
/**
 * @brief Return an initialized parameters structure.
 */
template <class T>
ArenaAllocatorBase::Params ArenaPoolSTLAllocator_initParams<T>::params() const
{
  // Do the base class stuff.
  ArenaAllocatorBase::Params p =
    Base::operator ArenaAllocatorBase::Params();
 
  // Disable ctor/dtor.
  p.constructor = 0;
  p.destructor = 0;
 
  return p;
}
 
 
/**
 * @brief Default constructor.
 * @param nblock Value to set in the parameters structure for the
 *               number of elements to allocate per block.
 * @param name   Value to set in the parameters structure for the
 *               allocator name.
 */
template <class T, class VETO>
// False positive --- cppcheck doesn't grok template specialization
// cppcheck-suppress uninitMemberVar
ArenaPoolSTLAllocator<T, VETO>::ArenaPoolSTLAllocator
 (size_t nblock /*= 1000*/, const std::string& name /*= ""*/)
   : m_pool (ArenaPoolSTLAllocator_initParams<T> (nblock, name))
{
}
 
 
/**
 * @brief Copy constructor.
 *
 * The @c name and @c nblock parameters are copied, but the data are not.
 */
template <class T, class VETO>
ArenaPoolSTLAllocator<T, VETO>::ArenaPoolSTLAllocator
  (const ArenaPoolSTLAllocator& a)
    : m_pool (ArenaPoolSTLAllocator_initParams<T> (a.nblock(), a.name()))
{
}
 
 
/**
 * @brief Constructor from another @c ArenaPoolSTLAllocator.
 *
 * The @c name and @c nblock parameters are copied, but the data are not.
 */
template <class T, class VETO>
template <class U, class V>
// False positive --- cppcheck doesn't grok template specialization
// cppcheck-suppress uninitMemberVar
ArenaPoolSTLAllocator<T, VETO>::ArenaPoolSTLAllocator
  (const ArenaPoolSTLAllocator<U, V>& a)
    : m_pool (ArenaPoolSTLAllocator_initParams<T> (a.nblock(), a.name()))
{
}
 
 
/**
 * @brief Move constructor.
 *
 * Move the data.
 */
template <class T, class VETO>
ArenaPoolSTLAllocator<T, VETO>::ArenaPoolSTLAllocator
  (ArenaPoolSTLAllocator&& a)
    : m_pool (std::move (a.m_pool))
{
}
 
 
/**
 * @brief Move constructor.
 *
 * Move the data.
 */
template <class T, class VETO>
ArenaPoolSTLAllocator<T, VETO>&
ArenaPoolSTLAllocator<T, VETO>::operator= (ArenaPoolSTLAllocator&& a)
{
  if (this != &a) {
    m_pool = std::move (a.m_pool);
  }
  return *this;
}
 
 
/**
 * @brief Swap.
 */
template <class T, class VETO>
void ArenaPoolSTLAllocator<T, VETO>::swap (ArenaPoolSTLAllocator& a)
{
  m_pool.swap (a.m_pool);
}
 
 
/**
 * @brief Equality test.
 *
 * Two allocators should compare equal if objects allocated by one
 * can be deallocated by the other.  We should just check if they
 * are the same object.
 */
template <class T, class VETO>
inline
bool ArenaPoolSTLAllocator<T, VETO>::operator==
  (const ArenaPoolSTLAllocator& other) const
{
  return this == &other;
}
 
 
/**
 * @brief Inequality test.
 *
 * Two allocators should compare equal if objects allocated by one
 * can be deallocated by the other.  We should just check if they
 * are the same object.
 */
template <class T, class VETO>
inline
bool ArenaPoolSTLAllocator<T, VETO>::operator!=
  (const ArenaPoolSTLAllocator& other) const
{
  return this != &other;
}
 
 
/**
 * @brief Return allocator to use for a copy-constructed container.
 *
 * When we copy-construct a container, we want the new allocator
 * to copy parameters from the old one, but not the data.
 */
template <class T, class VETO>
inline
ArenaPoolSTLAllocator<T, VETO>
ArenaPoolSTLAllocator<T, VETO>::select_on_container_copy_construction() const
{
  return ArenaPoolSTLAllocator (nblock(), name());
}
 
 
/**
 * @brief Convert a reference to an address.
 */
template <class T, class VETO>
inline
typename ArenaPoolSTLAllocator<T, VETO>::pointer
ArenaPoolSTLAllocator<T, VETO>::address (reference x) const
{
  return &x;
}
 
 
/**
 * @brief Allocate new objects.
 * @param n Number of objects to allocate.  Must be 1.
 * @param hint Allocation hint.  Not used.
 */
template <class T, class VETO>
inline
typename ArenaPoolSTLAllocator<T, VETO>::pointer
ArenaPoolSTLAllocator<T, VETO>::allocate (size_type
#if !defined(NDEBUG) && !defined(__CLING__)
                      n
#endif
                      , const void* /*hint = 0*/)
{
#if !defined(__CLING__)
  assert (n == 1);
#endif
  return reinterpret_cast<pointer> (m_pool.allocate());
}
 
 
/**
 * @brief Deallocate objects.
 * @param n Number of objects to deallocate.  Must be 1.
 *
 * This implementation doesn't do anything.
 */
template <class T, class VETO>
inline
void ArenaPoolSTLAllocator<T, VETO>::deallocate (pointer, size_type 
#if !defined(NDEBUG) && !defined(__CLING__)
                             n
#endif
                             )
{
#if !defined(__CLING__)
  assert (n == 1);
#endif
}
 
 
/**
 * @brief Return the maximum number of objects we can allocate at once.
 *
 * This always returns 1.
 */
template <class T, class VETO>
inline
typename ArenaPoolSTLAllocator<T, VETO>::size_type
ArenaPoolSTLAllocator<T, VETO>::max_size() const throw() 
{
  return 1;
}
 
 
/**
 * @brief Call the @c T constructor.
 * @param p Location of the memory.
 * @param args Arguments to pass to the constructor.
 */
template <class T, class VETO>
template <class... Args>
inline
void ArenaPoolSTLAllocator<T, VETO>::construct (pointer p, Args&&... args)
{
  new (p) T(std::forward<Args>(args)...);
}
 
 
/**
 * @brief Call the @c T destructor.
 * @param p Location of the memory.
 */
template <class T, class VETO>
inline
void ArenaPoolSTLAllocator<T, VETO>::destroy (pointer p)
{
  p->~T();
}
 
 
/**
 * @brief Return the hinted number of objects allocated per block.
 */
template <class T, class VETO>
inline
size_t ArenaPoolSTLAllocator<T, VETO>::nblock() const
{
  return m_pool.params().nblock;
}
 
 
/**
 * @brief Return the name of this allocator.
 */
template <class T, class VETO>
inline
const std::string& ArenaPoolSTLAllocator<T, VETO>::name() const
{
  return m_pool.name();
}
 
 
/**
 * @brief Free all allocated elements.
 *
 * All elements allocated are returned to the free state.
 * @c clear should be called on them if it was provided.
 * The elements may continue to be cached internally, without
 * returning to the system.
 */
template <class T, class VETO>
void ArenaPoolSTLAllocator<T, VETO>::reset()
{
  m_pool.reset();
}
 
 
/**
 * @brief Free all allocated elements and release memory back to the system.
 *
 * All elements allocated are freed, and all allocated blocks of memory
 * are released back to the system.
 * @c destructor should be called on them if it was provided
 * (preceded by @c clear if provided and @c mustClear was set).
 */
template <class T, class VETO>
void ArenaPoolSTLAllocator<T, VETO>::erase()
{
  m_pool.erase();
}
 
 
/**
 * @brief Set the total number of elements cached by the allocator.
 * @param size The desired pool size.
 *
 * This allows changing the number of elements that are currently free
 * but cached.  Any allocated elements are not affected by this call.
 *
 * If @c size is greater than the total number of elements currently
 * cached, then more will be allocated.  This will preferably done
 * with a single block, but that is not guaranteed; in addition, the
 * allocator may allocate more elements than is requested.
 *
 * If @c size is smaller than the total number of elements currently
 * cached, as many blocks as possible will be released back to the system.
 * It may not be possible to release the number of elements requested;
 * this should be implemented on a best-effort basis.
 */
template <class T, class VETO>
void ArenaPoolSTLAllocator<T, VETO>::reserve (size_t size)
{
  m_pool.reserve (size);
}
 
 
/**
 * @brief Return the statistics block for this allocator.
 */
template <class T, class VETO>
ArenaAllocatorBase::Stats ArenaPoolSTLAllocator<T, VETO>::stats() const
{
  return m_pool.stats();
}
 
 
/**
 * @brief Return a pointer to the underlying allocator (may be 0).
 */
template <class T, class VETO>
const ArenaBlockAllocatorBase* ArenaPoolSTLAllocator<T, VETO>::poolptr() const
{
  return &m_pool;
}
 
 
/**
 * @brief Write-protect the memory managed by this allocator.
 *
 * Adjust protection on the memory managed by this allocator
 * to disallow writes.
 */
template <class T, class VETO>
inline
void ArenaPoolSTLAllocator<T, VETO>::protect()
{
  m_pool.protect();
}
 
 
/**
 * @brief Write-enable the memory managed by this allocator.
 *
 * Adjust protection on the memory managed by this allocator
 * to allow writes.
 */
template <class T, class VETO>
inline
void ArenaPoolSTLAllocator<T, VETO>::unprotect()
{
  m_pool.unprotect();
}
 
 
//****************************************************************************
// Pointer specialization.
//
 
 
/**
 * @brief Default constructor.
 * @param nblock Value to set in the parameters structure for the
 *               number of elements to allocate per block.
 * @param name   Value to set in the parameters structure for the
 *               allocator name.
 */
template <class T, class VETO>
ArenaPoolSTLAllocator<T*, VETO>::ArenaPoolSTLAllocator
 (size_t nblock /*= 1000*/, const std::string& name /*= ""*/)
   : m_nblock (nblock),
     m_name (name)
{
}
 
 
/**
 * @brief Constructor from another @c ArenaPoolSTLAllocator.
 *
 * The @c name and @c nblock parameters are copied, but the data are not.
 */
template <class T, class VETO>
template <class U, class V>
ArenaPoolSTLAllocator<T*, VETO>::ArenaPoolSTLAllocator
  (const ArenaPoolSTLAllocator<U, V>&)
{
}
 
 
/**
 * @brief Return the hinted number of objects allocated per block.
 */
template <class T, class VETO>
inline
size_t ArenaPoolSTLAllocator<T*, VETO>::nblock() const
{
  return m_nblock;
}
 
 
/**
 * @brief Return the name of this allocator.
 */
template <class T, class VETO>
inline
const std::string& ArenaPoolSTLAllocator<T*, VETO>::name() const
{
  return m_name;
}
 
 
//****************************************************************************
// Vetoed specialization.
//
 
#define ATHVETO typename std::enable_if<!std::is_pointer_v<T>, T>::type
 
/**
 * @brief Default constructor.
 * @param nblock Value to set in the parameters structure for the
 *               number of elements to allocate per block.
 * @param name   Value to set in the parameters structure for the
 *               allocator name.
 */
template <class T>
ArenaPoolSTLAllocator<T, ATHVETO>::ArenaPoolSTLAllocator
 (size_t nblock /*= 1000*/, const std::string& name /*= ""*/)
    : m_nblock (nblock),
      m_name (name),
      m_poolptr (0)
{
}
 
 
/**
 * @brief Constructor from another @c ArenaPoolSTLAllocator.
 *
 * The @c name and @c nblock parameters are copied, but the data are not.
 */
template <class T>
template <class U, class V>
ArenaPoolSTLAllocator<T, ATHVETO>::ArenaPoolSTLAllocator
  (const ArenaPoolSTLAllocator<U, V>& a)
    : m_nblock (a.nblock()),
      m_name (a.name()),
      m_poolptr (a.poolptr())
{
}
 
 
/**
 * @brief Return the hinted number of objects allocated per block.
 */
template <class T>
inline
size_t ArenaPoolSTLAllocator<T, ATHVETO>::nblock() const
{
  return m_nblock;
}
 
 
/**
 * @brief Return the name of this allocator.
 */
template <class T>
inline
const std::string& ArenaPoolSTLAllocator<T, ATHVETO>::name() const
{
  return m_name;
}
 
 
/**
 * @brief Return the statistics block for this allocator.
 */
template <class T>
ArenaAllocatorBase::Stats
ArenaPoolSTLAllocator<T, ATHVETO>::stats() const
{
  if (m_poolptr) {
    return m_poolptr->stats();
  }
  return ArenaAllocatorBase::Stats();
}
 
 
/**
 * @brief Return a pointer to the underlying allocator (may be 0).
 */
template <class T>
const ArenaBlockAllocatorBase* ArenaPoolSTLAllocator<T, ATHVETO>::poolptr() const
{
  return m_poolptr;
}
 
 
//****************************************************************************
// Non-const variant.
//
 
 
/**
 * @brief Constructor.
 * @param a Allocator to reference.
 * @param poolptr_nc Non-const pointer to the underlying allocator.
 */
template <class T>
template <class U, class V>
ArenaNonConstPoolSTLAllocator<T>::ArenaNonConstPoolSTLAllocator
  (const ArenaPoolSTLAllocator<U, V>& a,
   ArenaBlockAllocatorBase* poolptr_nc)
    : ArenaPoolSTLAllocator<T, T>(a),
    m_poolptr_nc (poolptr_nc)
{
}
 
 
/**
 * @brief Free all allocated elements.
 *
 * All elements allocated are returned to the free state.
 * @c clear should be called on them if it was provided.
 * The elements may continue to be cached internally, without
 * returning to the system.
 */
template <class T>
void ArenaNonConstPoolSTLAllocator<T>::reset()
{
  if (m_poolptr_nc)
    m_poolptr_nc->reset();
}
 
 
/**
 * @brief Free all allocated elements and release memory back to the system.
 *
 * All elements allocated are freed, and all allocated blocks of memory
 * are released back to the system.
 * @c destructor should be called on them if it was provided
 * (preceded by @c clear if provided and @c mustClear was set).
 */
template <class T>
void ArenaNonConstPoolSTLAllocator<T>::erase()
{
  if (m_poolptr_nc)
    m_poolptr_nc->erase();
}
 
 
/**
 * @brief Set the total number of elements cached by the allocator.
 * @param size The desired pool size.
 *
 * This allows changing the number of elements that are currently free
 * but cached.  Any allocated elements are not affected by this call.
 *
 * If @c size is greater than the total number of elements currently
 * cached, then more will be allocated.  This will preferably done
 * with a single block, but that is not guaranteed; in addition, the
 * allocator may allocate more elements than is requested.
 *
 * If @c size is smaller than the total number of elements currently
 * cached, as many blocks as possible will be released back to the system.
 * It may not be possible to release the number of elements requested;
 * this should be implemented on a best-effort basis.
 */
template <class T>
void ArenaNonConstPoolSTLAllocator<T>::reserve (size_t size)
{
  if (m_poolptr_nc)
    m_poolptr_nc->reserve (size);
}
 
 
/**
 * @brief Write-protect the memory managed by this allocator.
 *
 * Adjust protection on the memory managed by this allocator
 * to disallow writes.
 */
template <class T>
inline
void ArenaNonConstPoolSTLAllocator<T>::protect()
{
  if (m_poolptr_nc)
    m_poolptr_nc->protect();
}
 
 
/**
 * @brief Write-enable the memory managed by this allocator.
 *
 * Adjust protection on the memory managed by this allocator
 * to allow writes.
 */
template <class T>
inline
void ArenaNonConstPoolSTLAllocator<T>::unprotect()
{
  if (m_poolptr_nc)
    m_poolptr_nc->unprotect();
}
 
 
/**
 * @brief Return an allocator supporting non-const methods from
 *        a non-const container reference.
 * @param c The (non-const) container.
 */
template <class T>
template <class CONT>
ArenaNonConstPoolSTLAllocator<T>
ArenaPoolSTLAllocator<T, ATHVETO>::get_allocator ATLAS_NOT_CONST_THREAD_SAFE (CONT& c)
{
  // Must be called with a non-const object.
  typename std::remove_const<CONT>::type& cc = c;
  ArenaPoolSTLAllocator<T, T> a (cc.get_allocator());
  return ArenaNonConstPoolSTLAllocator<T> (a,
                                           const_cast<ArenaBlockAllocatorBase*>(a.poolptr()));
}
 
 
#undef ATHVETO
 
 
/**
 * @brief Hook for unprotecting an arena.
 *
 * Sometimes we need to ensure that an arena is unprotected before we start
 * destroying an object that contains the arena.  To do that without
 * making assumptions about whether the arena supports an unprotect
 * operation, call this function.
 */
template <class T, class VETO>
void maybeUnprotect (ArenaPoolSTLAllocator<T, VETO>& a)
{
  a.unprotect();
}
 
 
} // namespace SG