Monotonic.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 2019-2022 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Allocator/Arena.h>
#include <GaudiKernel/Kernel.h>
#include <boost/container/small_vector.hpp>
#include <cstddef>
#include <gsl/span>
#include <numeric>
#include <utility>
 
namespace Gaudi::Arena {
  namespace details {
    template <std::size_t Alignment>
    constexpr std::size_t align_up( std::size_t n ) {
      return ( n + ( Alignment - 1 ) ) & ~( Alignment - 1 );
    }
  } // namespace details

  template <std::size_t Alignment = alignof( std::max_align_t ), typename UpstreamAllocator = std::allocator<std::byte>>
  class Monotonic {
    // Restriction could be lifted, see @todo above.
    static_assert( std::is_empty_v<UpstreamAllocator>, "Stateful upstream allocators are not yet supported." );

    std::size_t m_next_block_size{};

    std::size_t m_allocations{ 0 };

    std::byte* m_current{ nullptr };

    std::byte* m_current_end{ nullptr };

    boost::container::small_vector<gsl::span<std::byte>, 1> m_all_blocks;

    static constexpr std::size_t growth_factor = 2;
 
  public:
    static constexpr std::size_t alignment = Alignment;

    Monotonic( std::size_t next_block_size ) noexcept
        : m_next_block_size{ details::align_up<Alignment>( next_block_size ) } {}
 
    ~Monotonic() noexcept {
      for ( auto block : m_all_blocks ) { UpstreamAllocator{}.deallocate( block.data(), block.size() ); }
    }
 
    // Allocators will hold pointers to instances of this class, deleting these
    // methods makes it harder to accidentally invalidate those pointers...
    Monotonic( Monotonic&& )                 = delete;
    Monotonic( Monotonic const& )            = delete;
    Monotonic& operator=( Monotonic&& )      = delete;
    Monotonic& operator=( Monotonic const& ) = delete;

    template <std::size_t ReqAlign>
    std::byte* allocate( std::size_t n ) {
      // If the requested alignment was larger we would need to round up
      // m_current -- instead of implementing that, just assert it's not
      // the case.
      static_assert( ReqAlign <= alignment, "Requested alignment too large for this Gaudi::Arena::Monotonic!" );
      // Figure out how many bytes we need to allocate
      std::size_t const aligned_n = details::align_up<Alignment>( n );
      // Check that we have a current block and this request fits inside it
      if ( !m_current || m_current + aligned_n > m_current_end ) {
        // Calculate our next block size
        auto next_block_size = std::max( m_next_block_size, aligned_n );
        // And update the estimate of what comes after that, following a geometric series
        m_next_block_size = details::align_up<Alignment>( growth_factor * next_block_size );
        // Allocate the new block and mark it as the current one
        m_current     = UpstreamAllocator{}.allocate( next_block_size );
        m_current_end = m_current + next_block_size;
        // Add it to the list of blocks that we'll eventually deallocate
        m_all_blocks.emplace_back( m_current, next_block_size );
      }
      m_allocations++;
      return std::exchange( m_current, m_current + aligned_n );
    }

    constexpr void deallocate( std::byte*, std::size_t ) noexcept {}

    void reset() noexcept {
      m_allocations = 0;
      if ( !m_all_blocks.empty() ) {
        // Only re-use the first block, deallocate any others
        if ( m_all_blocks.size() > 1 ) {
          for ( std::size_t i = 1; i < m_all_blocks.size(); ++i ) {
            UpstreamAllocator{}.deallocate( m_all_blocks[i].data(), m_all_blocks[i].size() );
          }
          m_all_blocks.resize( 1 );
        }
        auto reused_block = m_all_blocks.front();
        m_current         = reused_block.data();
        m_current_end     = m_current + reused_block.size();
        m_next_block_size = details::align_up<Alignment>( growth_factor * reused_block.size() );
      }
    }

    [[nodiscard]] std::size_t capacity() const noexcept {
      return std::accumulate( m_all_blocks.begin(), m_all_blocks.end(), 0ul,
                              []( std::size_t sum, auto block ) { return sum + block.size(); } );
    }

    [[nodiscard]] std::size_t size() const noexcept { return capacity() - ( m_current_end - m_current ); }

    [[nodiscard]] std::size_t num_blocks() const noexcept { return m_all_blocks.size(); }

    [[nodiscard]] std::size_t num_allocations() const noexcept { return m_allocations; }
  };
} // namespace Gaudi::Arena
 
namespace Gaudi::Allocator {
  template <typename T, typename DefaultResource = void, std::size_t Alignment = alignof( std::max_align_t ),
            typename UpstreamAllocator = std::allocator<std::byte>>
  using MonotonicArena =
      ::Gaudi::Allocator::Arena<::Gaudi::Arena::Monotonic<Alignment, UpstreamAllocator>, T, DefaultResource>;
} // namespace Gaudi::Allocator