device_mem_pointer_matrix_cl.h

#ifndef DEVICE_MEM_POINTER_MATRIX_CL_H
#define DEVICE_MEM_POINTER_MATRIX_CL_H

#ifdef SKEPU_OPENCL

#include <iostream>
#ifdef USE_MAC_OPENCL
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif

#include "device_cl.h"
#include "debug.h"

namespace skepu
{

template <typename T>
class DeviceMemPointer_Matrix_CL
{

public:
    DeviceMemPointer_Matrix_CL(T* start, int rows, int cols, Device_CL* device);
    ~DeviceMemPointer_Matrix_CL();

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

private:
    T* m_hostDataPointer;
    cl_mem m_deviceDataPointer;
    int m_rows;
    int m_cols;
    Device_CL* m_device;

    mutable bool deviceDataHasChanged;
};

template <typename T>
DeviceMemPointer_Matrix_CL<T>::DeviceMemPointer_Matrix_CL(T* start, int rows, int cols, Device_CL* device) : m_hostDataPointer(start), m_rows(rows), m_cols (cols), m_device(device)
{
    cl_int err;
    size_t sizeVec = rows*cols*sizeof(T);

    DEBUG_TEXT_LEVEL2("Alloc: " <<rows <<" X "<<cols <<"\n")

    m_deviceDataPointer = clCreateBuffer(m_device->getContext(), CL_MEM_READ_WRITE, sizeVec, NULL, &err);
    if(err != CL_SUCCESS){std::cerr<<"Error allocating memory on device\n";}

    deviceDataHasChanged = false;
}

template <typename T>
DeviceMemPointer_Matrix_CL<T>::~DeviceMemPointer_Matrix_CL()
{
    DEBUG_TEXT_LEVEL2("DeAlloc: " <<m_rows<<" X "<<m_cols <<"\n")

    clReleaseMemObject(m_deviceDataPointer);
}

template <typename T>
void DeviceMemPointer_Matrix_CL<T>::copyHostToDevice(int rows, int cols) const
{
    DEBUG_TEXT_LEVEL2("HOST_TO_DEVICE!!!\n")

    cl_int err;
    size_t sizeVec;
    
    int _rows, _cols;
    _rows = ((rows == -1) ? m_rows : rows);
    _cols = ((cols == -1) ? m_cols : cols);
     
    
    sizeVec = _rows * _cols * sizeof(T);

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION
copyUpTimer.start();
#endif

    err = clEnqueueWriteBuffer(m_device->getQueue(), m_deviceDataPointer, CL_TRUE, 0, sizeVec, (void*)m_hostDataPointer, 0, NULL, NULL);
    if(err != CL_SUCCESS){std::cerr<<"Error copying data to device\n";}

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION
copyUpTimer.stop();
#endif

    deviceDataHasChanged = false;
}

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

        cl_int err;
        size_t sizeVec;
        int _rows, _cols;
        _rows = ((rows == -1) ? m_rows : rows);
        _cols = ((cols == -1) ? m_cols : cols);
     
        sizeVec = _rows * _cols * sizeof(T);

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION
copyDownTimer.start();
#endif

        err = clEnqueueReadBuffer(m_device->getQueue(), m_deviceDataPointer, CL_TRUE, 0, sizeVec, (void*)m_hostDataPointer, 0, NULL, NULL);
        if(err != CL_SUCCESS){std::cerr<<"Error copying data from device\n";}
    

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION
copyDownTimer.stop();
#endif

        deviceDataHasChanged = false;
    }
}

template <typename T>
cl_mem DeviceMemPointer_Matrix_CL<T>::getDeviceDataPointer() const
{
    return m_deviceDataPointer;
}

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

}

#endif

#endif