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