vector.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 NeoN authors
#pragma once
 
#include <Kokkos_Core.hpp>
 
#include "NeoN/core/error.hpp"
#include "NeoN/core/executor/executor.hpp"
#include "NeoN/core/primitives/label.hpp"
#include "NeoN/core/primitives/scalar.hpp"
#include "NeoN/core/vector/vectorFreeFunctions.hpp"
#include "NeoN/core/view.hpp"
 
#include <vector>
 
 
namespace NeoN
{
 
template<typename ValueType>
class Vector
{
 
public:
 
    using VectorValueType = ValueType;
 
    Vector(const Executor& exec, localIdx size);
 
    Vector(
        const Executor& exec,
        const ValueType* in,
        localIdx size,
        Executor hostExec = SerialExecutor()
    );
 
    Vector(const Executor& exec, localIdx size, ValueType value);
 
    Vector(const Executor& exec, std::vector<ValueType> in);
 
    Vector(const Executor& exec, const Vector<ValueType>& in);
 
    Vector(const Vector<ValueType>& rhs);
 
    Vector(Vector<ValueType>&& rhs) noexcept;
 
    ~Vector();
 
    template<typename func>
    void apply(func f)
    {
        map(*this, f);
    }
 
    [[nodiscard]] Vector<ValueType> copyToExecutor(Executor dstExec) const;
 
    [[nodiscard]] Vector<ValueType> copyToHost() const;
 
    void copyToHost(Vector<ValueType>& result);
 
    // ensures no return of device address on host --> invalid memory access
    ValueType& operator[](const localIdx i) = delete;
 
    // ensures no return of device address on host --> invalid memory access
    const ValueType& operator[](const localIdx i) const = delete;
 
    void operator=(const ValueType& rhs);
 
    void operator=(const Vector<ValueType>& rhs);
 
    Vector<ValueType>& operator+=(const Vector<ValueType>& rhs);
 
    Vector<ValueType>& operator-=(const Vector<ValueType>& rhs);
 
    [[nodiscard]] Vector<ValueType> operator*(const Vector<ValueType>& rhs)
        requires requires(ValueType a, ValueType b) { a* b; };
 
    [[nodiscard]] Vector<ValueType> operator*(const scalar rhs)
        requires requires(ValueType a, scalar b) { a* b; };
 
    Vector<ValueType>& operator*=(const Vector<ValueType>& rhs)
        requires requires(ValueType a, ValueType b) { a *= b; };
 
    Vector<ValueType>& operator*=(const scalar rhs)
        requires requires(ValueType a, scalar b) { a *= b; };
 
    void resize(const localIdx size);
 
    [[nodiscard]] ValueType* data() { return data_; }
 
    [[nodiscard]] const ValueType* data() const { return data_; }
 
    [[nodiscard]] const Executor& exec() const { return exec_; }
 
    [[nodiscard]] localIdx size() const { return size_; }
 
    [[nodiscard]] label ssize() const { return static_cast<label>(size_); }
 
    [[nodiscard]] bool empty() const { return size() == 0; }
 
    // return of a temporary --> invalid memory access
    View<ValueType> view() && = delete;
 
    // return of a temporary --> invalid memory access
    View<const ValueType> view() const&& = delete;
 
    [[nodiscard]] View<ValueType> view() &
    {
        return View<ValueType>(data_, static_cast<size_t>(size_));
    }
 
    [[nodiscard]] View<const ValueType> view() const&
    {
        return View<const ValueType>(data_, static_cast<size_t>(size_));
    }
 
    // return of a temporary --> invalid memory access
    [[nodiscard]] View<ValueType> view(std::pair<localIdx, localIdx> range) && = delete;
 
    // return of a temporary --> invalid memory access
    [[nodiscard]] View<const ValueType> view(std::pair<localIdx, localIdx> range) const&& = delete;
 
    [[nodiscard]] View<ValueType> view(std::pair<localIdx, localIdx> range) &
    {
        return View<ValueType>(
            data_ + range.first, static_cast<size_t>(range.second - range.first)
        );
    }
 
    [[nodiscard]] View<const ValueType> view(std::pair<localIdx, localIdx> range) const&
    {
        return View<const ValueType>(
            data_ + range.first, static_cast<size_t>(range.second - range.first)
        );
    }
 
    [[nodiscard]] std::pair<localIdx, localIdx> range() const { return {0, size()}; }
 
private:
 
    localIdx size_ {0};         
    ValueType* data_ {nullptr}; 
    const Executor exec_;       
 
    void validateOtherVector(const Vector<ValueType>& rhs) const;
};
 
template<typename ValueType>
[[nodiscard]] Vector<ValueType> operator+(Vector<ValueType> lhs, const Vector<ValueType>& rhs);
 
template<typename ValueType>
[[nodiscard]] Vector<ValueType> operator-(Vector<ValueType> lhs, const Vector<ValueType>& rhs);
 
} // namespace NeoN