device_mem_pointer_matrix_cu.h

#ifndef DEVICE_MEM_POINTER_MATRIX_CU_H
#define DEVICE_MEM_POINTER_MATRIX_CU_H

#ifdef SKEPU_CUDA

#include <iostream>
#include <cuda.h>

#include "debug.h"

namespace skepu
{

template <typename T>
class DeviceMemPointer_Matrix_CU
{

public:
    DeviceMemPointer_Matrix_CU(T* start, int rows, int cols, int deviceID);
    ~DeviceMemPointer_Matrix_CU();

    void copyHostToDevice(int rows=-1, int cols=-1) const;
    void copyDeviceToHost(int rows=-1, int cols=-1) const;
    T* getDeviceDataPointer() const;
    int getDeviceID() const;
    void changeDeviceData();

private:
    T* m_hostDataPointer;
    T* m_deviceDataPointer;
    int m_rows;
    int m_cols;
    int m_deviceID;
    
    inline int size() { return m_rows * m_cols; }

    mutable bool deviceDataHasChanged;
};

template <typename T>
DeviceMemPointer_Matrix_CU<T>::DeviceMemPointer_Matrix_CU(T* start, int rows, int cols, int deviceID) : m_hostDataPointer(start), m_rows(rows), m_cols(cols), m_deviceID(deviceID)
{
    cudaError_t err;
    size_t sizeVec = rows*cols*sizeof(T);

    DEBUG_TEXT_LEVEL2("Alloc: " <<numElements <<"\n")

    err = cudaMalloc((void**)&m_deviceDataPointer, sizeVec);
    if(err != cudaSuccess){std::cerr<<"Error allocating memory on device\n";}

    deviceDataHasChanged = false;
}

template <typename T>
DeviceMemPointer_Matrix_CU<T>::~DeviceMemPointer_Matrix_CU()
{
    DEBUG_TEXT_LEVEL2("DeAlloc: " <<m_numElements <<"\n")

    cudaFree(m_deviceDataPointer);
}

template <typename T>
void DeviceMemPointer_Matrix_CU<T>::copyHostToDevice(int rows, int cols) const
{
    if(m_hostDataPointer != NULL)
    {
        DEBUG_TEXT_LEVEL2("HOST_TO_DEVICE!!!\n")

        cudaError_t err;
        size_t sizeVec;
    int _rows, _cols;

     _rows = ((rows == -1) ? m_rows : rows);
     _cols = ((cols == -1) ? m_cols : cols);
     
         sizeVec = _rows * _cols * sizeof(T);

        err = cudaMemcpy(m_deviceDataPointer, m_hostDataPointer, sizeVec, cudaMemcpyHostToDevice);
        if(err != cudaSuccess){std::cerr<<"Error copying data to device\n" <<cudaGetErrorString(err) <<"\n";}

        deviceDataHasChanged = false;
    }
}

template <typename T>
void DeviceMemPointer_Matrix_CU<T>::copyDeviceToHost(int rows, int cols) const
{
    if(deviceDataHasChanged && m_hostDataPointer != NULL)
    {
        DEBUG_TEXT_LEVEL2("DEVICE_TO_HOST!!!\n")

        cudaError_t err;
        size_t sizeVec;

        int _rows, _cols;

    _rows = ((rows == -1) ? m_rows : rows);
    _cols = ((cols == -1) ? m_cols : cols);
     
        sizeVec = _rows * _cols * sizeof(T);

        err = cudaMemcpy(m_hostDataPointer, m_deviceDataPointer, sizeVec, cudaMemcpyDeviceToHost);
        if(err != cudaSuccess){std::cerr<<"Error copying data from device: " <<cudaGetErrorString(err) <<"\n";}

        deviceDataHasChanged = false;
    }
}

template <typename T>
T* DeviceMemPointer_Matrix_CU<T>::getDeviceDataPointer() const
{
    return m_deviceDataPointer;
}

template <typename T>
int DeviceMemPointer_Matrix_CU<T>::getDeviceID() const
{
    return m_deviceID;
}

template <typename T>
void DeviceMemPointer_Matrix_CU<T>::changeDeviceData()
{
    deviceDataHasChanged = true;
}

}

#endif

#endif