device_array.hpp

Go to the documentation of this file.

#pragma once
 
#include <kfusion/exports.hpp>
#include <kfusion/cuda/device_memory.hpp>
 
#include <vector>
 
namespace kfusion
{
    namespace cuda
    {
 
        template<class T>
        class KF_EXPORTS DeviceArray : public DeviceMemory
        {
        public:
            typedef T type;
 
            enum { elem_size = sizeof(T) };
 
            DeviceArray();
 
            DeviceArray(size_t size);
 
            DeviceArray(T *ptr, size_t size);
 
            DeviceArray(const DeviceArray& other);
 
            DeviceArray& operator = (const DeviceArray& other);
 
            void create(size_t size);
 
            void release();
 
            void copyTo(DeviceArray& other) const;
 
            void upload(const T *host_ptr, size_t size);
 
            void download(T *host_ptr) const;
 
            template<class A>
            void upload(const std::vector<T, A>& data);
 
            template<typename A>
            void download(std::vector<T, A>& data) const;
 
            void swap(DeviceArray& other_arg);
 
            T* ptr();
 
            const T* ptr() const;
 
            //using DeviceMemory::ptr;
 
            operator T*();
 
            operator const T*() const;
 
            size_t size() const;
        };
 
 
 
        template<class T>
        class KF_EXPORTS DeviceArray2D : public DeviceMemory2D
        {
        public:
            typedef T type;
 
            enum { elem_size = sizeof(T) };
 
            DeviceArray2D();
 
            DeviceArray2D(int rows, int cols);
 
            DeviceArray2D(int rows, int cols, void *data, size_t stepBytes);
 
            DeviceArray2D(const DeviceArray2D& other);
 
            DeviceArray2D& operator = (const DeviceArray2D& other);
 
            void create(int rows, int cols);
 
            void release();
 
            void copyTo(DeviceArray2D& other) const;
 
            void upload(const void *host_ptr, size_t host_step, int rows, int cols);
 
            void download(void *host_ptr, size_t host_step) const;
 
            void swap(DeviceArray2D& other_arg);
 
            template<class A>
            void upload(const std::vector<T, A>& data, int cols);
 
            template<class A>
            void download(std::vector<T, A>& data, int& cols) const;
 
            T* ptr(int y = 0);
 
            const T* ptr(int y = 0) const;
 
            //using DeviceMemory2D::ptr;
 
            operator T*();
 
            operator const T*() const;
 
            int cols() const;
 
            int rows() const;
 
            size_t elem_step() const;
        };
    }
 
    namespace device
    {
        using kfusion::cuda::DeviceArray;
        using kfusion::cuda::DeviceArray2D;
    }
}
 
 
template<class T> inline kfusion::cuda::DeviceArray<T>::DeviceArray() {}
template<class T> inline kfusion::cuda::DeviceArray<T>::DeviceArray(size_t size) : DeviceMemory(size * elem_size) {}
template<class T> inline kfusion::cuda::DeviceArray<T>::DeviceArray(T *ptr, size_t size) : DeviceMemory(ptr, size * elem_size) {}
template<class T> inline kfusion::cuda::DeviceArray<T>::DeviceArray(const DeviceArray& other) : DeviceMemory(other) {}
template<class T> inline kfusion::cuda::DeviceArray<T>& kfusion::cuda::DeviceArray<T>::operator=(const DeviceArray& other)
{ DeviceMemory::operator=(other); return *this; }
 
template<class T> inline void kfusion::cuda::DeviceArray<T>::create(size_t size)
{ DeviceMemory::create(size * elem_size); }
template<class T> inline void kfusion::cuda::DeviceArray<T>::release()
{ DeviceMemory::release(); }
 
template<class T> inline void kfusion::cuda::DeviceArray<T>::copyTo(DeviceArray& other) const
{ DeviceMemory::copyTo(other); }
template<class T> inline void kfusion::cuda::DeviceArray<T>::upload(const T *host_ptr, size_t size)
{ DeviceMemory::upload(host_ptr, size * elem_size); }
template<class T> inline void kfusion::cuda::DeviceArray<T>::download(T *host_ptr) const
{ DeviceMemory::download( host_ptr ); }
 
template<class T> void kfusion::cuda::DeviceArray<T>::swap(DeviceArray& other_arg) { DeviceMemory::swap(other_arg); }
 
template<class T> inline kfusion::cuda::DeviceArray<T>::operator T*() { return ptr(); }
template<class T> inline kfusion::cuda::DeviceArray<T>::operator const T*() const { return ptr(); }
template<class T> inline size_t kfusion::cuda::DeviceArray<T>::size() const { return sizeBytes() / elem_size; }
 
template<class T> inline       T* kfusion::cuda::DeviceArray<T>::ptr()       { return DeviceMemory::ptr<T>(); }
template<class T> inline const T* kfusion::cuda::DeviceArray<T>::ptr() const { return DeviceMemory::ptr<T>(); }
 
template<class T> template<class A> inline void kfusion::cuda::DeviceArray<T>::upload(const std::vector<T, A>& data) { upload(&data[0], data.size()); }
template<class T> template<class A> inline void kfusion::cuda::DeviceArray<T>::download(std::vector<T, A>& data) const { data.resize(size()); if (!data.empty()) download(&data[0]); }
 
 
template<class T> inline kfusion::cuda::DeviceArray2D<T>::DeviceArray2D() {}
template<class T> inline kfusion::cuda::DeviceArray2D<T>::DeviceArray2D(int rows, int cols) : DeviceMemory2D(rows, cols * elem_size) {}
template<class T> inline kfusion::cuda::DeviceArray2D<T>::DeviceArray2D(int rows, int cols, void *data, size_t stepBytes) : DeviceMemory2D(rows, cols * elem_size, data, stepBytes) {}
template<class T> inline kfusion::cuda::DeviceArray2D<T>::DeviceArray2D(const DeviceArray2D& other) : DeviceMemory2D(other) {}
template<class T> inline kfusion::cuda::DeviceArray2D<T>& kfusion::cuda::DeviceArray2D<T>::operator=(const DeviceArray2D& other)
{ DeviceMemory2D::operator=(other); return *this; }
 
template<class T> inline void kfusion::cuda::DeviceArray2D<T>::create(int rows, int cols)
{ DeviceMemory2D::create(rows, cols * elem_size); }
template<class T> inline void kfusion::cuda::DeviceArray2D<T>::release()
{ DeviceMemory2D::release(); }
 
template<class T> inline void kfusion::cuda::DeviceArray2D<T>::copyTo(DeviceArray2D& other) const
{ DeviceMemory2D::copyTo(other); }
template<class T> inline void kfusion::cuda::DeviceArray2D<T>::upload(const void *host_ptr, size_t host_step, int rows, int cols)
{ DeviceMemory2D::upload(host_ptr, host_step, rows, cols * elem_size); }
template<class T> inline void kfusion::cuda::DeviceArray2D<T>::download(void *host_ptr, size_t host_step) const
{ DeviceMemory2D::download( host_ptr, host_step ); }
 
template<class T> template<class A> inline void kfusion::cuda::DeviceArray2D<T>::upload(const std::vector<T, A>& data, int cols)
{ upload(&data[0], cols * elem_size, data.size()/cols, cols); }
 
template<class T> template<class A> inline void kfusion::cuda::DeviceArray2D<T>::download(std::vector<T, A>& data, int& elem_step) const
{ elem_step = cols(); data.resize(cols() * rows()); if (!data.empty()) download(&data[0], colsBytes());  }
 
template<class T> void  kfusion::cuda::DeviceArray2D<T>::swap(DeviceArray2D& other_arg) { DeviceMemory2D::swap(other_arg); }
 
template<class T> inline       T* kfusion::cuda::DeviceArray2D<T>::ptr(int y)       { return DeviceMemory2D::ptr<T>(y); }
template<class T> inline const T* kfusion::cuda::DeviceArray2D<T>::ptr(int y) const { return DeviceMemory2D::ptr<T>(y); }
 
template<class T> inline kfusion::cuda::DeviceArray2D<T>::operator T*() { return ptr(); }
template<class T> inline kfusion::cuda::DeviceArray2D<T>::operator const T*() const { return ptr(); }
 
template<class T> inline int kfusion::cuda::DeviceArray2D<T>::cols() const { return DeviceMemory2D::colsBytes()/elem_size; }
template<class T> inline int kfusion::cuda::DeviceArray2D<T>::rows() const { return DeviceMemory2D::rows(); }
 
template<class T> inline size_t kfusion::cuda::DeviceArray2D<T>::elem_step() const { return DeviceMemory2D::step()/elem_size; }