device_cl.h

Go to the documentation of this file.

#ifndef DEVICE_CL_H
#define DEVICE_CL_H

#ifdef SKEPU_OPENCL

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

#include "deviceprop_cl.h"

namespace skepu
{

class Device_CL
{

private:

    cl_device_type m_type;
    openclDeviceProp m_deviceProp;

    cl_device_id m_device;
    cl_context m_context;
    cl_command_queue m_queue;

    int m_maxThreads;
    size_t m_maxBlocks;

    void getDeviceProps(cl_device_id device)
    {
        for(std::vector<openclGenProp>::iterator it = m_deviceProp.propertyList.begin(); it != m_deviceProp.propertyList.end(); ++it)
        {
            cl_int err;
            err = clGetDeviceInfo(device, it->param_name, it->param_value_size, it->param_value, NULL);
            if(err != CL_SUCCESS){std::cerr<<"Error adding property value CL!!\n";}
        }
    }


public:

    Device_CL(cl_device_id id, cl_device_type type, cl_context context, cl_command_queue queue)
    {
        m_device = id;
        m_type = type;
        m_context = context;
        m_queue = queue;

        getDeviceProps(id);

        m_maxThreads = getMaxBlockSize()>>1;
        m_maxBlocks = (size_t)((size_t)1<<(m_deviceProp.DEVICE_ADDRESS_BITS-1))*2-1;
    }

    Device_CL(cl_device_id id, cl_device_type type, cl_context context)
    {
        m_device = id;
        m_type = type;
        m_context = context;

        getDeviceProps(id);

        m_maxThreads = getMaxBlockSize()>>1;
        m_maxBlocks = (size_t)((size_t)1<<(m_deviceProp.DEVICE_ADDRESS_BITS-1))*2-1;

        cl_int err;

        //Create a command-queue on the GPU device
        m_queue = clCreateCommandQueue(m_context, m_device, 0, &err);
        if(err != CL_SUCCESS){std::cerr<<"Error creating queue!!\n" <<err <<"\n";}
    }

    ~Device_CL()
    {
        clReleaseCommandQueue(m_queue);
        clReleaseContext(m_context);
        std::cout<<"Release Device_cl\n";
    }

    size_t getMaxBlockSize() const {return m_deviceProp.DEVICE_MAX_WORK_GROUP_SIZE;}

    cl_uint getNumComputeUnits() const {return m_deviceProp.DEVICE_MAX_COMPUTE_UNITS;}

    cl_ulong getGlobalMemSize() const {return m_deviceProp.DEVICE_GLOBAL_MEM_SIZE;}

    cl_ulong getSharedMemPerBlock() const {return m_deviceProp.DEVICE_LOCAL_MEM_SIZE;}

    int getMaxThreads() const 
    {
        #ifdef SKEPU_MAX_GPU_THREADS
            return SKEPU_MAX_GPU_THREADS;
        #else   
            return m_maxThreads;
        #endif
    }

    size_t getMaxBlocks() const {return m_maxBlocks;}

    const cl_context& getContext() const {return m_context;}

    const cl_command_queue& getQueue() const {return m_queue;}
    
//    cl_command_queue* getQueuePointer() const {return &m_queue;}

    cl_device_type getType() const {return m_type;}

    cl_device_id getDeviceID() const {return m_device;}

};


}

#endif

#endif