/*! \file clinfo.h
 *
 * \author John Reppy
 */

/*
 * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
 *
 * COPYRIGHT (c) 2015 The University of Chicago
 * All rights reserved.
 */

#ifndef _CLINFO_H_
#define _CLINFO_H_

#include "Diderot/config.h"
# ifdef HAVE_CL_CL_H
#   include <CL/cl.h>
# elif defined(HAVE_OPENCL_CL_H)
#   include <OpenCL/cl.h>
# else
#   error no cl.h
# endif
#include <stdio.h>
#include <stdbool.h>

typedef struct {
    unsigned short  index[2];		//!< the platform/device index of the device
    char            *name;              //!< name of device
    char            *vendor;            //!< device vendor
    int             majorVersion;       //!< major OpenCL version number supported by the device
    int             minorVersion;       //!< minor OpenCL version number supported by the device
    cl_device_id    id;                 //!< the device ID
    cl_device_type  ty;                 //!< the type of the device
    cl_bool         isAvail;            //!< true, if the device is available
    cl_uint         addrBits;           //!< number of address bits on device (32 or 64)
    cl_bool         littleEndian;       //!< true if device is little endian
    cl_uint         numCUs;             //!< number of compute units
    cl_uint         cuWidth;            //!< width of a compute unit; this value is determined
                                        //!  by looking at the device type and vendor string.
    cl_uint         maxConstArgs;       //!< maximum number of __constant arguments
    cl_uint         maxWIDims;          //!< maximum number of work item dimensions
    size_t          maxWGSize;          //!< maximum workgroup size
    size_t          *maxWISize;         //!< maximum number of work items in each dimension
    cl_ulong        globalMemSzb;       //!< the size of the device's global memory
    cl_ulong        localMemSzb;        //!< the size of the device's local memory
    size_t          maxParamSzb;        //!< the maximum size in bytes of the kernel arguments
    cl_ulong        maxConstBufSzb;     //!< maximum size of a constant buffer
    cl_ulong        maxAllocSzb;        //!< maximum allocation size in bytes
    size_t          maxImg2D[2];        //!< maximum width and height of 2D images
    size_t          maxImg3D[3];        //!< maximim width, height, and depthe of 3D images
                                        // prefered vector widths by type:
    cl_uint         charWid;            //!< prefered width of char vectors
    cl_uint         shortWid;           //!< prefered width of short vectors
    cl_uint         intWid;             //!< prefered width of int vectors
    cl_uint         longWid;            //!< prefered width of long vectors
    cl_uint         floatWid;           //!< prefered width of float vectors
    cl_uint         doubleWid;          //!< prefered width of double vectors
                                        //!  (0 if doubles are not supported)
} DeviceInfo_t;

typedef struct {
    char            *name;              //!< name of platform
    cl_platform_id  id;                 //! the platform ID
    int             numDevices;         //!< number of devices supported by platform
    DeviceInfo_t    *devices;           //!< array of devices
} PlatformInfo_t;

typedef struct {
    int             numPlatforms;       //!< number of platforms supported by system
    PlatformInfo_t  *platforms;         //!< array of supported platforms.
} CLInfo_t;

/*! \brief return information about the OpenCL support of the system.
 *  \return pointer to a CLInfo_t structure or 0 if there is an error.
 */
CLInfo_t *Diderot_GetCLInfo ();

/*! \brief return the device with the given index.
 */
DeviceInfo_t *Diderot_GetDeviceByIndex (CLInfo_t *clinfo, unsigned int platIdx, unsigned int devIdx);

/*! \brief return the default device for the system.
 */
DeviceInfo_t *Diderot_DefaultCLDevice (CLInfo_t *clinfo);

/*! \brief print the CL profile information to an output stream.
 */
void Diderot_PrintCLInfo (FILE *outS, CLInfo_t *clinfo);

/*! \brief check to see if a device is a GPU */
STATIC_INLINE bool isGPUDevice (DeviceInfo_t *dev)
{
    return ((dev->ty & CL_DEVICE_TYPE_GPU) != 0);
}

/*! \brief check to see if a device is a CPU */
STATIC_INLINE bool isCPUDevice (DeviceInfo_t *dev)
{
    return ((dev->ty & CL_DEVICE_TYPE_CPU) != 0);
}

#endif /* !_CLINFO_H_ */