include/dvector.h

Go to the documentation of this file.

#ifndef DVECTOR_H
#define DVECTOR_H

//== INCLUDES =================================================================

#include <vector>

#include <alloc.h>

//== NAMESPACES ===============================================================

namespace gpufilter {

//== CLASS DEFINITION =========================================================

template< class T >
class dvector {

public:

    explicit dvector( const std::vector<T>& that ) : m_size(0), m_capacity(0), m_data(0) {
        *this = that;
    }

    dvector( const T *data,
             const size_t& size ) : m_size(0), m_capacity(0), m_data(0) {
        copy_from( data, size );
    }

    dvector( const T *data,
             const size_t& w_data,
             const size_t& h_data,
             const size_t& w,
             const size_t& h ) : m_size(0), m_capacity(0), m_data(0) {
        copy_from( data, w_data, h_data, w, h );
    }

    dvector( const dvector<T>& that ) : m_size(0), m_capacity(0), m_data(0) {
        *this = that;
    }

    dvector( const size_t& size = 0 ) : m_size(0), m_capacity(0), m_data(0) {
        resize(size);
    }

    ~dvector() {
        cuda_delete(m_data);
        m_data = 0;
        m_capacity = 0;
        m_size = 0;
    }

    void resize( const size_t& size ) {
        if( size > m_capacity )
        {
            cuda_delete(m_data);
            m_data = 0;
            m_capacity = 0;
            m_size = 0;

            m_data = cuda_new<T>(size);
            m_capacity = size;
            m_size = size;
        }
        else
            m_size = size;
    }

    void clear() {
        m_size = 0;
    }

    T operator [] ( const int& idx ) const {
        T value;
        cudaMemcpy(&value, data()+idx, sizeof(T), cudaMemcpyDeviceToHost);
        return value;
    }

    dvector& operator = ( const dvector<T>& that ) {
        resize(that.size());
        cudaMemcpy(data(), that.data(), size()*sizeof(T), cudaMemcpyDeviceToDevice);
        cuda_error("Error during memcpy from device to device");
        return *this;
    }

    dvector& operator = ( const std::vector<T>& that ) {
        resize(that.size());
        cudaMemcpy(data(), &that[0], size()*sizeof(T), cudaMemcpyHostToDevice);
        cuda_error("Error during memcpy from host to device");
        return *this;
    }

    void copy_to( T *data,
                  const size_t& s ) const {
        cudaMemcpy(data, this->data(), std::min(size(),s)*sizeof(T), cudaMemcpyDeviceToHost);
        cuda_error("Error during memcpy from device to host");
    }

    void copy_to( T *data,
                  const size_t& w,
                  const size_t& h,
                  const size_t& w_data,
                  const size_t& h_data ) const {
        cudaMemcpy2D(data, w_data*sizeof(T), this->data(), w*sizeof(T), w_data*sizeof(T), h_data, cudaMemcpyDeviceToHost);
        cuda_error("Error during memcpy2D from device to host");
    }

    void copy_from( const T *data,
                    const size_t& size ) {
        resize(size);
        cudaMemcpy(this->data(), const_cast<T *>(data),
                   size*sizeof(T), cudaMemcpyHostToDevice);
        cuda_error("Error during memcpy from host to device");
    }

    void copy_from( const T *data,
                    const size_t& w_data,
                    const size_t& h_data,
                    const size_t& w,
                    const size_t& h ) {
        resize(w*h);
        cudaMemcpy2D(this->data(), w*sizeof(T),
                     const_cast<T *>(data), w_data*sizeof(T), w_data*sizeof(T),
                     h_data, cudaMemcpyHostToDevice);
        cuda_error("Error during memcpy2D from host to device");
    }

    void fill_zero() {
       cudaMemset(m_data, 0, m_size*sizeof(T));
    }

    bool empty() const { return size()==0; }

    size_t size() const { return m_size; }

    T *data() { return m_data; }

    const T *data() const { return m_data; }

    T back() const { return operator[](size()-1); }

    operator T* () { return data(); }

    operator const T* () const { return data(); }

    friend void swap( dvector<T>& a,
                      dvector<T>& b ) {
        std::swap(a.m_data, b.m_data);
        std::swap(a.m_size, b.m_size);
        std::swap(a.m_capacity, b.m_capacity);
    }

private:

    T *m_data; 
    size_t m_size; 
    size_t m_capacity; 

};

//== IMPLEMENTATION ===========================================================

template< class T >
std::vector<T> to_cpu( const T *d_vec,
                       unsigned len ) {
    std::vector<T> out;
    out.resize(len);

    cudaMemcpy(&out[0], d_vec, len*sizeof(T), cudaMemcpyDeviceToHost);
    cuda_error("Error during memcpy from device to host");

    return out;
}

template< class T >
std::vector<T> to_cpu( const dvector<T>& v ) {
    return to_cpu(v.data(), v.size());
}

//=============================================================================
} // namespace gpufilter
//=============================================================================
#endif // DVECTOR_H
//=============================================================================
//vi: ai sw=4 ts=4