device_memory.hpp

Go to the documentation of this file.

#pragma once

#include <kfusion/exports.hpp>
#include <kfusion/cuda/kernel_containers.hpp>

namespace kfusion
{
    namespace cuda
    {
        KF_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func = "");


        class KF_EXPORTS DeviceMemory
        {
        public:
            DeviceMemory();

            ~DeviceMemory();

            DeviceMemory(size_t sizeBytes_arg);

            DeviceMemory(void *ptr_arg, size_t sizeBytes_arg);

            DeviceMemory(const DeviceMemory& other_arg);

            DeviceMemory& operator=(const DeviceMemory& other_arg);

            void create(size_t sizeBytes_arg);

            void release();

            void copyTo(DeviceMemory& other) const;

            void upload(const void *host_ptr_arg, size_t sizeBytes_arg);

            void download(void *host_ptr_arg) const;

            void swap(DeviceMemory& other_arg);

            template<class T> T* ptr();

            template<class T> const T* ptr() const;

            template <class U> operator PtrSz<U>() const;

            bool empty() const;

            size_t sizeBytes() const;

        private:
            void *data_;

            size_t sizeBytes_;

            int* refcount_;
        };


        class KF_EXPORTS DeviceMemory2D
        {
        public:
            DeviceMemory2D();

            ~DeviceMemory2D();

            DeviceMemory2D(int rows_arg, int colsBytes_arg);


            DeviceMemory2D(int rows_arg, int colsBytes_arg, void *data_arg, size_t step_arg);

            DeviceMemory2D(const DeviceMemory2D& other_arg);

            DeviceMemory2D& operator=(const DeviceMemory2D& other_arg);

            void create(int rows_arg, int colsBytes_arg);

            void release();

            void copyTo(DeviceMemory2D& other) const;

            void upload(const void *host_ptr_arg, size_t host_step_arg, int rows_arg, int colsBytes_arg);

            void download(void *host_ptr_arg, size_t host_step_arg) const;

            void swap(DeviceMemory2D& other_arg);

            template<class T> T* ptr(int y_arg = 0);

            template<class T> const T* ptr(int y_arg = 0) const;

            template <class U> operator PtrStep<U>() const;

            template <class U> operator PtrStepSz<U>() const;

            bool empty() const;

            int colsBytes() const;

            int rows() const;

            size_t step() const;
        private:
            void *data_;

            size_t step_;

            int colsBytes_;

            int rows_;

            int* refcount_;
        };
    }

    namespace device
    {
        using kfusion::cuda::DeviceMemory;
        using kfusion::cuda::DeviceMemory2D;
    }
}


template<class T> inline       T* kfusion::cuda::DeviceMemory::ptr()       { return (      T*)data_; }
template<class T> inline const T* kfusion::cuda::DeviceMemory::ptr() const { return (const T*)data_; }

template <class U> inline kfusion::cuda::DeviceMemory::operator kfusion::cuda::PtrSz<U>() const
{
    PtrSz<U> result;
    result.data = (U*)ptr<U>();
    result.size = sizeBytes_/sizeof(U);
    return result;
}


template<class T>        T* kfusion::cuda::DeviceMemory2D::ptr(int y_arg)       { return (      T*)((      char*)data_ + y_arg * step_); }
template<class T>  const T* kfusion::cuda::DeviceMemory2D::ptr(int y_arg) const { return (const T*)((const char*)data_ + y_arg * step_); }

template <class U> kfusion::cuda::DeviceMemory2D::operator kfusion::cuda::PtrStep<U>() const
{
    PtrStep<U> result;
    result.data = (U*)ptr<U>();
    result.step = step_;
    return result;
}

template <class U> kfusion::cuda::DeviceMemory2D::operator kfusion::cuda::PtrStepSz<U>() const
{
    PtrStepSz<U> result;
    result.data = (U*)ptr<U>();
    result.step = step_;
    result.cols = colsBytes_/sizeof(U);
    result.rows = rows_;
    return result;
}