device_mem_pointer_cl.h

Go to the documentation of this file.

#ifndef DEVICE_MEM_POINTER_CL_H
#define DEVICE_MEM_POINTER_CL_H

#ifdef SKEPU_OPENCL

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

#include <skepu/src/environment.h>

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

namespace skepu
{

template <typename T>
class DeviceMemPointer_CL
{

public:
    DeviceMemPointer_CL(T* start, int numElements, Device_CL* device);
    ~DeviceMemPointer_CL();

    void copyHostToDevice(int numElements = -1, bool copyLast=false) const;
    void copyDeviceToHost(int numElements = -1, bool copyLast=false) const;
    
    void copyDeviceToDevice(cl_mem copyToPointer,int numElements, int dstOffset = 0, int srcOffset = 0) const;
    
    cl_mem getDeviceDataPointer() const;
    void changeDeviceData();

private:
    void copyHostToDevice_internal(T* src, cl_mem dest, int numElements, int offset=0) const;
    
    T* m_rootHostDataPointer;
    T* m_effectiveHostDataPointer;
    T* m_hostDataPointer;
    
    
    int m_effectiveNumElements;
    
    cl_mem m_deviceDataPointer;
    cl_mem m_effectiveDeviceDataPointer;
    
    int m_numElements;
    Device_CL* m_device;

    mutable bool deviceDataHasChanged;
};

template <typename T>
DeviceMemPointer_CL<T>::DeviceMemPointer_CL(T* start, int numElements, Device_CL* device) : m_effectiveHostDataPointer(start), m_hostDataPointer(start), m_numElements(numElements), m_effectiveNumElements(numElements), m_device(device)
{
    cl_int err;
    size_t sizeVec = numElements*sizeof(T);

    DEBUG_TEXT_LEVEL2("Alloc: " <<numElements <<"\n")
#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

devMemAllocTimer.start();
#endif

    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";}
    
    m_effectiveDeviceDataPointer = m_deviceDataPointer;
    
#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

devMemAllocTimer.stop();
#endif
    deviceDataHasChanged = false;
}




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

    clReleaseMemObject(m_deviceDataPointer);
}


template <typename T>
void DeviceMemPointer_CL<T>::copyDeviceToDevice(cl_mem copyToPointer,int numElements, int dstOffset, int srcOffset) const
{
    if(m_hostDataPointer != NULL)
    {
        DEBUG_TEXT_LEVEL2("DEVICE_TO_DEVICE!!!\n")

        cl_int err;
        size_t sizeVec;

        if(numElements == -1)
            sizeVec = m_numElements*sizeof(T);
        else
            sizeVec = numElements*sizeof(T);

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyUpTimer.start();
#endif

    DEBUG_TEXT_LEVEL2("Copying Device to Device: "<<sizeVec/sizeof(T)<<" elements.\n")

    err = clEnqueueCopyBuffer ( m_device->getQueue(),m_deviceDataPointer, copyToPointer, srcOffset*sizeof(T), dstOffset*sizeof(T), sizeVec, 0, NULL, NULL);

        
    if(err != CL_SUCCESS){std::cerr<<"Error copying data to device\n";}

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyUpTimer.stop();
#endif

        deviceDataHasChanged = true;
    }
}



template <typename T>
void DeviceMemPointer_CL<T>::copyHostToDevice_internal(T* src_ptr, cl_mem dest_ptr, int numElements, int offset) const
{
    DEBUG_TEXT_LEVEL2("HOST_TO_DEVICE INTERNAL!!!\n")
    
    cl_int err;
    size_t sizeVec;
    
    sizeVec = numElements*sizeof(T);

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyUpTimer.start();
#endif

    

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

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyUpTimer.stop();
#endif
}


template <typename T>
void DeviceMemPointer_CL<T>::copyHostToDevice(int numElements, bool copyLast) const
{
    DEBUG_TEXT_LEVEL2("HOST_TO_DEVICE!!!\n")

    cl_int err;
    size_t sizeVec;
    if(numElements == -1)
        if(copyLast)
            sizeVec = m_numElements*sizeof(T);
        else
            sizeVec = m_effectiveNumElements*sizeof(T);
    else
        sizeVec = numElements*sizeof(T);

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyUpTimer.start();
#endif

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

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyUpTimer.stop();
#endif

    deviceDataHasChanged = false;
}

template <typename T>
void DeviceMemPointer_CL<T>::copyDeviceToHost(int numElements, bool copyLast) const
{
    if(deviceDataHasChanged)
    {
        DEBUG_TEXT_LEVEL2("DEVICE_TO_HOST!!!\n")

        cl_int err;
        size_t sizeVec;
        if(numElements == -1)
            if(copyLast)
                sizeVec = m_numElements*sizeof(T);
            else
                sizeVec = m_effectiveNumElements*sizeof(T);
        else
            sizeVec = numElements*sizeof(T);

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyDownTimer.start();
#endif
//        std::cerr<<"Copying Device to host: "<<sizeVec/sizeof(T)<<" elements.\n";
        if(copyLast)
            err = clEnqueueReadBuffer(m_device->getQueue(), m_deviceDataPointer, CL_TRUE, 0, sizeVec, (void*)m_hostDataPointer, 0, NULL, NULL);
        else
            err = clEnqueueReadBuffer(m_device->getQueue(), m_effectiveDeviceDataPointer, CL_TRUE, 0, sizeVec, (void*)m_effectiveHostDataPointer, 0, NULL, NULL);
            
        if(err != CL_SUCCESS){std::cerr<<"Error copying data from device   "<<sizeVec<<"\n";}

#ifdef SKEPU_MEASURE_TIME_DISTRIBUTION

#ifdef SKEPU_MEASURE_ONLY_COPY
clFinish(m_device->getQueue());
#endif

copyDownTimer.stop();
#endif
        deviceDataHasChanged = false;
    }
}

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

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

}

#endif

#endif