CUDAStdVector.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.

#ifndef CUBBYFLOW_CUDA_STD_VECTOR_HPP
#define CUBBYFLOW_CUDA_STD_VECTOR_HPP

#ifdef CUBBYFLOW_USE_CUDA

#include <Core/CUDA/CUDAAlgorithms.hpp>

#include <vector>

namespace CubbyFlow
{
template <typename T>
class CUDAStdVector final
{
 public:
    using ValueType = T;
    using Reference = T&;
    using ConstReference = const T&;
    using Pointer = ValueType*;
    using ConstPointer = const ValueType*;

    class ReferenceType
    {
     public:
        CUBBYFLOW_CUDA_HOST_DEVICE ReferenceType(Pointer p) : m_ptr(p)
        {
            // Do nothing
        }

        CUBBYFLOW_CUDA_HOST_DEVICE ReferenceType(const ReferenceType& other)
            : m_ptr(other.m_ptr)
        {
            // Do nothing
        }

        CUBBYFLOW_CUDA_HOST_DEVICE ReferenceType(ReferenceType&& other) noexcept
            : m_ptr(std::move(other.m_ptr))
        {
            // Do nothing
        }

        ~ReferenceType() = default;

        CUBBYFLOW_CUDA_HOST_DEVICE ReferenceType& operator=(
            const ReferenceType& other)
        {
            m_ptr = other.m_ptr;
            return *this;
        }

        CUBBYFLOW_CUDA_HOST_DEVICE ReferenceType& operator=(
            ReferenceType&& other) noexcept
        {
            m_ptr = std::move(other.m_ptr);
            return *this;
        }

#ifdef __CUDA_ARCH__
        __device__ ReferenceType& operator=(const ValueType& val)
        {
            *m_ptr = val;
            return *this;
        }

        __device__ operator ValueType() const
        {
            return *m_ptr;
        }
#else
        CUBBYFLOW_CUDA_HOST ReferenceType& operator=(const ValueType& val)
        {
            CUDACopyHostToDevice(&val, 1, m_ptr);
            return *this;
        }

        CUBBYFLOW_CUDA_HOST operator ValueType() const
        {
            std::remove_const_t<ValueType> tmp{};
            CUDACopyDeviceToHost(m_ptr, 1, &tmp);
            return tmp;
        }
#endif

     private:
        Pointer m_ptr;
    };

    CUDAStdVector() = default;

    CUDAStdVector(size_t n, const ValueType& initVal = ValueType{});

    template <typename A>
    CUDAStdVector(const std::vector<T, A>& other);

    CUDAStdVector(const CUDAStdVector& other);

    CUDAStdVector(CUDAStdVector&& other) noexcept;

    ~CUDAStdVector();

    template <typename A>
    CUDAStdVector& operator=(const std::vector<T, A>& other);

    CUDAStdVector& operator=(const CUDAStdVector& other);

    CUDAStdVector& operator=(CUDAStdVector&& other) noexcept;

    Pointer data();

    ConstPointer data() const;

    size_t Size() const;

#ifdef __CUDA_ARCH__
    __device__ Reference At(size_t i);

    __device__ ConstReference At(size_t i) const;
#else
    CUBBYFLOW_CUDA_HOST ReferenceType At(size_t i);

    CUBBYFLOW_CUDA_HOST T At(size_t i) const;
#endif

    void Clear();

    void Fill(const ValueType& val);

    void Resize(size_t n, const ValueType& initVal = ValueType{});

    void ResizeUninitialized(size_t n);

    void Swap(CUDAStdVector& other);

    void PushBack(const ValueType& val);

    void Append(const ValueType& val);

    void Append(const CUDAStdVector& other);

    template <typename A>
    void CopyFrom(const std::vector<T, A>& other);

    void CopyFrom(const CUDAStdVector& other);

    template <typename A>
    void CopyTo(std::vector<T, A>& other);

#ifdef __CUDA_ARCH__
    Reference operator[](size_t i);

    ConstReference operator[](size_t i) const;
#else
    ReferenceType operator[](size_t i);

    T operator[](size_t i) const;
#endif

 private:
    Pointer m_ptr = nullptr;
    size_t m_size = 0;
};
}  // namespace CubbyFlow

#include <Core/CUDA/CUDAStdVector-Impl.hpp>

#endif

#endif