EBGeometry_Pool.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_POOL_HPP
#define EBGEOMETRY_POOL_HPP
 
// Std includes
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <type_traits>
 
// Our includes
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_MemoryResource.hpp"
 
namespace EBGeometry {
 
struct PoolControl
{
  void* m_base = nullptr;
 
  uint64_t m_id = 0;
 
  uint64_t m_rootId = 0;
};
 
class Pool;
 
struct PoolLocation
{
  const PoolControl* m_control = nullptr;
 
  void* m_base = nullptr;
 
  bool m_hostAccessible = false;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline void*
  base() const noexcept
  {
#if defined(EBGEOMETRY_DEVICE_COMPILE)
    EBGEOMETRY_EXPECT(m_control == nullptr);
 
    return m_base;
#else
    if (m_control != nullptr) {
      return m_control->m_base;
    }
 
    // Unset, or a snapshot of memory the host cannot reach (a device-only mirror).
    EBGEOMETRY_EXPECT(m_hostAccessible);
 
    return m_base;
#endif
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline bool
  isAttachedTo(const Pool& a_pool) const noexcept;
 
  EBGEOMETRY_HOST
  inline void
  attach(const Pool& a_pool, const char* a_who) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline PoolLocation
  rebasedOnto(const Pool& a_pool, uint64_t a_endByte, const char* a_who) const noexcept;
};
class Pool
{
public:
  EBGEOMETRY_HOST
  explicit Pool(MemoryResource& a_resource, size_t a_initialBytes = 0);
 
  EBGEOMETRY_HOST
  ~Pool() noexcept;
 
  Pool(const Pool&) = delete;
 
  Pool&
  operator=(const Pool&) = delete;
 
  EBGEOMETRY_HOST
  Pool(Pool&& a_other) noexcept;
 
  EBGEOMETRY_HOST
  Pool&
  operator=(Pool&& a_other) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  uint64_t
  reserve(size_t a_count, size_t a_elemSize, size_t a_alignment);
 
  EBGEOMETRY_HOST
  void
  freeze() noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  void*
  base() const noexcept
  {
    return (m_control != nullptr) ? m_control->m_base : nullptr;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  const PoolControl*
  control() const noexcept
  {
    return m_control.get();
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  uint64_t
  id() const noexcept
  {
    return (m_control != nullptr) ? m_control->m_id : 0;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  uint64_t
  mirrorOf() const noexcept
  {
    return m_mirrorOf;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  uint64_t
  rootId() const noexcept
  {
    return (m_control != nullptr) ? m_control->m_rootId : 0;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  size_t
  usedBytes() const noexcept
  {
    return m_size;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  size_t
  capacityBytes() const noexcept
  {
    return m_capacity;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  bool
  isFrozen() const noexcept
  {
    return m_frozen;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  MemoryResource&
  resource() const noexcept
  {
    return *m_resource;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  static Pool
  mirror(const Pool& a_src, MemoryResource& a_dstResource);
 
private:
  static constexpr size_t s_maxBytes = SIZE_MAX & ~(PoolBaseAlign - 1);
 
  struct MirrorTag
  {
  };
 
  EBGEOMETRY_HOST
  Pool(MemoryResource& a_resource, MirrorTag) : m_resource(&a_resource), m_control(makeControl())
  {}
 
  [[nodiscard]] EBGEOMETRY_HOST
  static std::unique_ptr<PoolControl>
  makeControl()
  {
    static std::atomic<uint64_t> s_nextID{1};
 
    auto control = std::make_unique<PoolControl>();
 
    control->m_id     = s_nextID.fetch_add(1, std::memory_order_relaxed);
    control->m_rootId = control->m_id;
 
    return control;
  }
 
  MemoryResource* m_resource = nullptr;
 
  std::unique_ptr<PoolControl> m_control;
 
  size_t m_size = 0;
 
  size_t m_capacity = 0;
 
  uint64_t m_mirrorOf = 0;
 
  bool m_frozen = false;
 
  EBGEOMETRY_HOST
  void
  grow(size_t a_need);
};
 
class PoolHandle
{
public:
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline PoolLocation
  location() const noexcept
  {
    return m_location;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline bool
  isAttachedTo(const Pool& a_pool) const noexcept
  {
    return m_location.isAttachedTo(a_pool);
  }
 
protected:
  PoolHandle() noexcept = default;
 
  EBGEOMETRY_HOST_DEVICE
  explicit PoolHandle(const PoolLocation& a_location) noexcept : m_location(a_location)
  {}
 
  PoolHandle(const PoolHandle&) noexcept = default;
 
  PoolHandle(PoolHandle&&) noexcept = default;
 
  PoolHandle&
  operator=(const PoolHandle&) noexcept = default;
 
  PoolHandle&
  operator=(PoolHandle&&) noexcept = default;
 
  ~PoolHandle() noexcept = default;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline void*
  base() noexcept
  {
    return m_location.base();
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const void*
  base() const noexcept
  {
    return m_location.base();
  }
 
  EBGEOMETRY_HOST
  inline void
  attach(const Pool& a_pool, const char* a_who) noexcept
  {
    m_location.attach(a_pool, a_who);
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline PoolLocation
  rebasedLocation(const Pool& a_pool, uint64_t a_endByte, const char* a_who) const noexcept
  {
    return m_location.rebasedOnto(a_pool, a_endByte, a_who);
  }
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  setLocation(const PoolLocation& a_location) noexcept
  {
    m_location = a_location;
  }
 
private:
  PoolLocation m_location;
};
 
template <class P>
inline constexpr bool isPoolHandle = std::is_base_of_v<PoolHandle, P>;
 
} // namespace EBGeometry
 
#include "EBGeometry_PoolImplem.hpp"
 
#endif // EBGEOMETRY_POOL_HPP