EBGeometry_PODVector.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_PODVECTOR_HPP
#define EBGEOMETRY_PODVECTOR_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <type_traits>
 
// Our includes
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_Pool.hpp"
 
namespace EBGeometry {
 
template <class T>
struct PODSpan
{
  T* m_ptr = nullptr;
 
  uint32_t m_size = 0;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T&
  operator[](uint32_t a_i) const noexcept
  {
    EBGEOMETRY_EXPECT(a_i < m_size);
 
    return m_ptr[a_i];
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T*
  begin() const noexcept
  {
    return m_ptr;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T*
  end() const noexcept
  {
    return m_ptr + m_size;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  uint32_t
  size() const noexcept
  {
    return m_size;
  }
};
 
static_assert(std::is_trivially_copyable_v<PODSpan<float>>, "PODSpan<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PODSpan<double>>, "PODSpan<double> must be trivially copyable");
 
template <class T>
struct PODVector
{
  static_assert(std::is_trivially_copyable_v<T>, "PODVector<T>: T must be trivially copyable (device-visible storage)");
  static_assert(alignof(T) <= PoolBaseAlign,
                "PODVector<T>: T's alignment exceeds the Pool's base alignment, so no reservation can align it");
 
  uint64_t m_offset = 0;
 
  uint32_t m_size = 0;
 
  uint32_t m_capacity = 0;
 
  EBGEOMETRY_HOST
  void
  reserveFrom(Pool& a_pool, uint32_t a_capacity)
  {
    m_offset   = a_pool.reserve(a_capacity, sizeof(T), alignof(T));
    m_size     = 0;
    m_capacity = a_capacity;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T*
  data(void* a_base) const noexcept
  {
    return reinterpret_cast<T*>(static_cast<unsigned char*>(a_base) + m_offset);
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  const T*
  data(const void* a_base) const noexcept
  {
    return reinterpret_cast<const T*>(static_cast<const unsigned char*>(a_base) + m_offset);
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T&
  at(void* a_base, uint32_t a_i) const noexcept
  {
    EBGEOMETRY_EXPECT(a_i < m_size);
 
    return this->data(a_base)[a_i];
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  const T&
  at(const void* a_base, uint32_t a_i) const noexcept
  {
    EBGEOMETRY_EXPECT(a_i < m_size);
 
    return this->data(a_base)[a_i];
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  uint32_t
  size() const noexcept
  {
    return m_size;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  uint64_t
  endByte() const noexcept
  {
    return m_offset + static_cast<uint64_t>(m_capacity) * sizeof(T);
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  bool
  empty() const noexcept
  {
    return m_size == 0;
  }
 
  EBGEOMETRY_HOST
  void
  push_back(void* a_base, const T& a_value)
  {
    EBGEOMETRY_EXPECT(m_size < m_capacity); // the no-realloc invariant
 
    this->data(a_base)[m_size++] = a_value;
  }
 
  EBGEOMETRY_HOST
  void
  assign(void* a_base, const T* a_src, uint32_t a_count)
  {
    EBGEOMETRY_REQUIRE(a_count <= m_capacity,
                       "PODVector::assign: the element count must not exceed the reserved capacity (%u > %u)",
                       unsigned(a_count),
                       unsigned(m_capacity));
 
    // Guard the zero-element case: an empty build reserves nothing, so both this->data(a_base) and
    // a_src are null, and memcpy's parameters are declared nonnull -- UBSan's nonnull check flags
    // memcpy(nullptr, nullptr, 0) even though it copies nothing.
    if (a_count > 0) {
      std::memcpy(this->data(a_base), a_src, static_cast<size_t>(a_count) * sizeof(T));
    }
 
    m_size = a_count;
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  PODSpan<T>
  bind(void* a_base) const noexcept
  {
    return PODSpan<T>{this->data(a_base), m_size};
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  PODSpan<const T>
  bind(const void* a_base) const noexcept
  {
    return PODSpan<const T>{this->data(a_base), m_size};
  }
};
 
static_assert(sizeof(PODVector<float>) == 16, "PODVector layout must be 8 (offset) + 4 (size) + 4 (capacity)");
static_assert(sizeof(PODVector<double>) == 16, "PODVector layout must be 8 (offset) + 4 (size) + 4 (capacity)");
static_assert(std::is_trivially_copyable_v<PODVector<float>>, "PODVector<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PODVector<double>>, "PODVector<double> must be trivially copyable");
 
} // namespace EBGeometry
 
#endif // EBGEOMETRY_PODVECTOR_HPP