ah-arena.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef AH_ARENA_H
# define AH_ARENA_H
 
# include <cstdlib>
# include <cstddef>
# include <utility>
# include <new>
# include <aleph.H>
# include <ah-errors.H>
 
namespace Aleph
{
 
class AhArenaAllocator
{
  char* base_addr_ = nullptr;
  char* curr_addr_ = nullptr;
  char* end_addr_ = nullptr;
  bool owns_memory_ = false;
 
public:
  enum class TemplateType { TEMPLATE };
 
  static constexpr size_t DEFAULT_SIZE = 1024 * 1024;
 
  AhArenaAllocator(void* buffer, const size_t size) noexcept
    : base_addr_(static_cast<char*>(buffer)),
      curr_addr_(base_addr_),
      end_addr_(base_addr_ + size)
  {}
 
  AhArenaAllocator(const char* buffer, const size_t size) noexcept
    : base_addr_(const_cast<char*>(buffer)),
      curr_addr_(base_addr_),
      end_addr_(base_addr_ + size)
  {}
 
  explicit AhArenaAllocator(const size_t size = DEFAULT_SIZE)
  {
    base_addr_ = static_cast<char*>(std::malloc(size));
    ah_runtime_error_if(base_addr_ == nullptr)
      << "AhArenaAllocator: cannot allocate " << size << " bytes";
 
    curr_addr_ = base_addr_;
    end_addr_ = base_addr_ + size;
    owns_memory_ = true;
  }
 
  ~AhArenaAllocator()
  {
    if (owns_memory_ and base_addr_ != nullptr)
      std::free(base_addr_);
  }
 
  // === Move semantics ===
 
  AhArenaAllocator(AhArenaAllocator&& other) noexcept
    : base_addr_(other.base_addr_),
      curr_addr_(other.curr_addr_),
      end_addr_(other.end_addr_),
      owns_memory_(other.owns_memory_)
  {
    other.base_addr_ = nullptr;
    other.curr_addr_ = nullptr;
    other.end_addr_ = nullptr;
    other.owns_memory_ = false;
  }
 
  AhArenaAllocator& operator=(AhArenaAllocator&& other) noexcept
  {
    if (this != &other)
      {
        // Free current memory if we own it
        if (owns_memory_ && base_addr_ != nullptr)
          std::free(base_addr_);
 
        // Take ownership from other
        base_addr_ = other.base_addr_;
        curr_addr_ = other.curr_addr_;
        end_addr_ = other.end_addr_;
        owns_memory_ = other.owns_memory_;
 
        // Invalidate other
        other.base_addr_ = nullptr;
        other.curr_addr_ = nullptr;
        other.end_addr_ = nullptr;
        other.owns_memory_ = false;
      }
    return *this;
  }
 
  // Non-copyable (owns raw memory)
  AhArenaAllocator(const AhArenaAllocator&) = delete;
  AhArenaAllocator& operator=(const AhArenaAllocator&) = delete;
 
  // === Allocation interface ===
 
  void reset() noexcept { curr_addr_ = base_addr_; }
 
  [[nodiscard]] void* alloc(const size_t size) noexcept
  {
    if (size == 0)
      return nullptr;
 
    if (const auto avail = static_cast<size_t>(end_addr_ - curr_addr_); size > avail)
      return nullptr;
 
    char* result = curr_addr_;
    curr_addr_ += size;
    return result;
  }
 
  [[nodiscard]] void* alloc_aligned(const size_t size, const size_t alignment) noexcept
  {
    if (size == 0 or alignment == 0)
      return nullptr;
 
    // Calculate aligned address
    const auto current = reinterpret_cast<uintptr_t>(curr_addr_);
    const uintptr_t aligned = (current + alignment - 1) & ~(alignment - 1);
 
    const auto padding = aligned - current;
    const auto avail = static_cast<size_t>(end_addr_ - curr_addr_);
    if (padding > avail)
      return nullptr;
    if (size > (avail - padding))
      return nullptr;
 
    curr_addr_ = reinterpret_cast<char*>(aligned) + size;
    return reinterpret_cast<void*>(aligned);
  }
 
  void dealloc(const void* addr, const size_t size) noexcept
  {
    if (size == 0 or addr == nullptr)
      return;
 
    // Only deallocate if this was the last allocation (LIFO)
    if (static_cast<const char*>(addr) + size == curr_addr_)
      curr_addr_ -= size;
  }
 
  // === Typed allocation ===
 
  template <typename T, typename... Args>
  [[nodiscard]] T* alloc([[maybe_unused]] TemplateType tag, Args&&... args)
  {
    void* ptr = alloc_aligned(sizeof(T), alignof(T));
    if (ptr == nullptr)
      return nullptr;
    return new (ptr) T(std::forward<Args>(args)...);
  }
 
  template <typename T>
  void dealloc([[maybe_unused]] TemplateType tag, void* ptr) noexcept
  {
    if (ptr == nullptr)
      return;
    static_cast<T*>(ptr)->~T();
    dealloc(ptr, sizeof(T));
  }
 
  // === Query interface ===
 
  [[nodiscard]] bool is_valid() const noexcept
  {
    return base_addr_ != nullptr;
  }
 
  [[nodiscard]] bool owns_memory() const noexcept
  {
    return owns_memory_;
  }
 
  [[nodiscard]] size_t allocated_size() const noexcept
  {
    return static_cast<size_t>(curr_addr_ - base_addr_);
  }
 
  [[nodiscard]] size_t available_size() const noexcept
  {
    return static_cast<size_t>(end_addr_ - curr_addr_);
  }
 
  [[nodiscard]] size_t capacity() const noexcept
  {
    return static_cast<size_t>(end_addr_ - base_addr_);
  }
 
  [[nodiscard]] bool empty() const noexcept
  {
    return curr_addr_ == base_addr_;
  }
 
  [[nodiscard]] bool full() const noexcept
  {
    return curr_addr_ == end_addr_;
  }
 
  [[nodiscard]] const void* base_addr() const noexcept { return base_addr_; }
 
  [[nodiscard]] const void* next_avail_addr() const noexcept { return curr_addr_; }
 
  [[nodiscard]] const void* end_addr() const noexcept { return end_addr_; }
 
  [[nodiscard]] bool contains(const void* ptr) const noexcept
  {
    const auto p = static_cast<const char*>(ptr);
    return p >= base_addr_ and p < end_addr_;
  }
 
  // === Backward compatibility aliases ===
 
  [[nodiscard]] void* allocate(size_t size) noexcept { return alloc(size); }
 
  void deallocate(const void* addr, size_t size) noexcept { dealloc(addr, size); }
};
 
// === Free function interface ===
 
template <class T, typename... Args>
[[nodiscard]] T* allocate(AhArenaAllocator& arena, Args&&... args)
{
  return arena.alloc<T>(AhArenaAllocator::TemplateType::TEMPLATE,
                        std::forward<Args>(args)...);
}
 
template <class T>
void deallocate(AhArenaAllocator& arena, T* ptr) noexcept
{
  arena.dealloc<T>(AhArenaAllocator::TemplateType::TEMPLATE, ptr);
}
 
template <class T>
void dealloc(AhArenaAllocator& arena, T* ptr) noexcept
{
  deallocate<T>(arena, ptr);
}
 
} // end namespace Aleph
 
# endif // AH_ARENA_H