scratch_allocator.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "detail/compat.hpp"
#include "reloco.hpp"
#include <cstddef>
#include <cstdint>
#include <new>
#include <type_traits>
#include <utility>
 
// Alignment and bump allocation require audited pointer arithmetic inside this
// checked allocation boundary.
RELOCO_BEGIN_UNSAFE_BUFFER_USAGE
 
namespace microfmt {
 
class MICROFMT_API_CLASS RELOCO_POINTER scratch_allocator {
public:
  explicit constexpr scratch_allocator(
      span<std::byte> buffer RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS) noexcept
      : m_buf(buffer) {}
 
  // decodes raw bytes of a target address space; casts, pointers and offsets are bounded by the explicit lengths
  // checked here.
  RELOCO_BEGIN_UNSAFE_CODE
  explicit scratch_allocator(span<char> buffer RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS) noexcept
      : m_buf(reinterpret_cast<std::byte *>(buffer.data()), buffer.size()) {}
  RELOCO_END_UNSAFE_CODE
 
  // decodes raw bytes of a target address space; casts, pointers and offsets are bounded by the explicit lengths
  // checked here.
  RELOCO_BEGIN_UNSAFE_CODE
  template <typename T>
  [[nodiscard]] RELOCO_ASSUME_ALIGNED(alignof(T)) T *allocate(size_t count = 1) noexcept RELOCO_LIFETIMEBOUND {
    if (count == 0 || count > available() / sizeof(T)) {
      return nullptr;
    }
 
    const size_t size = count * sizeof(T);
    std::byte *current_ptr = m_buf.data() + m_pos;
    const uintptr_t addr = reinterpret_cast<uintptr_t>(current_ptr);
    const size_t alignment_offset = static_cast<size_t>((alignof(T) - (addr % alignof(T))) % alignof(T));
 
    if (alignment_offset > available() || size > available() - alignment_offset) {
      return nullptr;
    }
 
    m_pos += alignment_offset + size;
    return static_cast<T *>(static_cast<void *>(current_ptr + alignment_offset));
  }
  RELOCO_END_UNSAFE_CODE
 
  template <typename T, typename... Args>
  [[nodiscard]] RELOCO_ASSUME_ALIGNED(alignof(T)) T *create(Args &&...args) noexcept RELOCO_LIFETIMEBOUND {
    static_assert(std::is_trivially_destructible_v<T>, "scratch_allocator only permits trivially destructible types");
 
    T *storage = allocate<T>();
    if (storage == nullptr) {
      return nullptr;
    }
    return ::new (static_cast<void *>(storage)) T(std::forward<Args>(args)...);
  }
 
  [[nodiscard]] constexpr scratch_allocator rest() const noexcept RELOCO_LIFETIMEBOUND {
    return scratch_allocator{remaining_span()};
  }
 
  [[nodiscard]] constexpr span<std::byte> remaining_span() const noexcept RELOCO_LIFETIMEBOUND {
    if (m_pos >= m_buf.size()) {
      return {};
    }
    return {m_buf.data() + m_pos, m_buf.size() - m_pos};
  }
 
  constexpr void reset() noexcept { m_pos = 0; }
 
  [[nodiscard]] constexpr size_t size() const noexcept { return m_pos; }
  [[nodiscard]] constexpr size_t capacity() const noexcept { return m_buf.size(); }
  [[nodiscard]] constexpr size_t available() const noexcept {
    return (m_pos < m_buf.size()) ? (m_buf.size() - m_pos) : 0;
  }
 
private:
  span<std::byte> m_buf;
  size_t m_pos{0};
};
 
} // namespace microfmt
 
RELOCO_END_UNSAFE_BUFFER_USAGE