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;
}