view.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Kokkos_Core.hpp>
 
#include <limits>
#include <span>
#include <type_traits>
 
#include "NeoN/core/primitives/label.hpp"
 
namespace NeoN
{
 
/* @class View
 *
 * @brief A wrapper class for std::span which allows to check whether the index access is in range
 * The View can be initialized like a regular std::span or from an existing std::span
 *
 * @ingroup core
 *
 */
template<typename ValueType>
class View : public std::span<ValueType>
{
public:
 
    using base = std::span<ValueType>;
 
    /* A flag to control whether the program should terminate on invalid memory access or throw.
     * Kokkos prefers to terminate, but for testing purpose the failureIndex is preferred
     */
    bool abortOnFail = true;
 
    /* a member to store the first out of range data access. This assumes a span has
     * at least a size of 1. A value of zero signals success. This is required we cannot
     * throw from a device function.
     */
    mutable localIdx failureIndex = 0;
 
    using std::span<ValueType>::span; // Inherit constructors from std::span
 
    /* Constructor from existing std::span
     */
    KOKKOS_INLINE_FUNCTION
    View(std::span<ValueType> in) : View(in.begin(), in.end()) {}
 
    // KOKKOS_INLINE_FUNCTION (i.e. __host__ __device__) so element access is valid inside device
    // kernels, consistent with the other accessors below. NOTE: this forwards to
    // std::span::operator[], itself a bare constexpr __host__ function, so on CUDA correctness
    // still relies on --expt-relaxed-constexpr (enabled via Kokkos_ENABLE_CUDA_CONSTEXPR=ON in
    // cmake/AutoEnableDevice.cmake). Without that flag nvcc miscompiles the device write silently
    // (warning 20013); the build promotes that warning to an error to prevent shipping it.
    KOKKOS_INLINE_FUNCTION
    constexpr ValueType& operator[](localIdx index) const
    {
#ifdef NF_DEBUG
        if (index < 0 || index >= this->size())
        {
            if (abortOnFail)
            {
                Kokkos::abort("Index is out of range.");
            }
            else
            {
                return std::span<ValueType>::operator[](static_cast<size_t>(index));
            }
        }
#endif
        return std::span<ValueType>::operator[](static_cast<size_t>(index));
    }
 
    KOKKOS_INLINE_FUNCTION
    localIdx size() const { return static_cast<localIdx>(base::size()); }
 
    KOKKOS_INLINE_FUNCTION
    View<ValueType> subview(localIdx start, localIdx length) const
    {
        return base::subspan(static_cast<size_t>(start), static_cast<size_t>(length));
    }
 
    KOKKOS_INLINE_FUNCTION
    View<ValueType> subview(localIdx start) const
    {
        return base::subspan(static_cast<size_t>(start));
    }
};
 
template<class Type>
concept hasView =
    requires(Type& inst) { inst.view(); } || requires(const Type& inst) { inst.view(); };
 
template<typename... Types>
    requires(hasView<std::remove_reference_t<Types>> && ...)
auto views(Types&... args)
{
    return std::tuple(args.view()...);
}
 
} // namespace NeoN