opencl.h

Go to the documentation of this file.

/*******************************************************
 * Copyright (c) 2014, ArrayFire
 * All rights reserved.
 *
 * This file is distributed under 3-clause BSD license.
 * The complete license agreement can be obtained at:
 * http://arrayfire.com/licenses/BSD-3-Clause
 ********************************************************/
 
#pragma once
#ifndef CL_TARGET_OPENCL_VERSION
#define CL_TARGET_OPENCL_VERSION 120
#endif
#if defined(__APPLE__) || defined(__MACOSX)
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
 
#include <af/defines.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if AF_API_VERSION >= 33
typedef enum
{
    AFCL_DEVICE_TYPE_CPU     = CL_DEVICE_TYPE_CPU,
    AFCL_DEVICE_TYPE_GPU     = CL_DEVICE_TYPE_GPU,
    AFCL_DEVICE_TYPE_ACC     = CL_DEVICE_TYPE_ACCELERATOR,
    AFCL_DEVICE_TYPE_UNKNOWN = -1
} afcl_device_type;
#endif
 
#if AF_API_VERSION >= 33
typedef enum
{
    AFCL_PLATFORM_AMD     = 0,
    AFCL_PLATFORM_APPLE   = 1,
    AFCL_PLATFORM_INTEL   = 2,
    AFCL_PLATFORM_NVIDIA  = 3,
    AFCL_PLATFORM_BEIGNET = 4,
    AFCL_PLATFORM_POCL    = 5,
    AFCL_PLATFORM_UNKNOWN = -1
} afcl_platform;
#endif
 
AFAPI af_err afcl_get_context(cl_context *ctx, const bool retain);
 
AFAPI af_err afcl_get_queue(cl_command_queue *queue, const bool retain);
 
AFAPI af_err afcl_get_device_id(cl_device_id *id);
 
#if AF_API_VERSION >= 32
AFAPI af_err afcl_set_device_id(cl_device_id id);
#endif
 
#if AF_API_VERSION >= 33
AFAPI af_err afcl_add_device_context(cl_device_id dev, cl_context ctx, cl_command_queue que);
#endif
 
#if AF_API_VERSION >= 33
AFAPI af_err afcl_set_device_context(cl_device_id dev, cl_context ctx);
#endif
 
#if AF_API_VERSION >= 33
AFAPI af_err afcl_delete_device_context(cl_device_id dev, cl_context ctx);
#endif
 
#if AF_API_VERSION >= 33
AFAPI af_err afcl_get_device_type(afcl_device_type *res);
#endif
 
#if AF_API_VERSION >= 33
AFAPI af_err afcl_get_platform(afcl_platform *res);
#endif
 
#ifdef __cplusplus
}
#endif
 
#ifdef __cplusplus
 
#include <af/array.h>
#include <af/dim4.hpp>
#include <af/exception.h>
#include <af/device.h>
#include <stdio.h>
 
namespace afcl
{
 
 static inline cl_context getContext(bool retain = false)
 {
     cl_context ctx;
     af_err err = afcl_get_context(&ctx, retain);
     if (err != AF_SUCCESS) throw af::exception("Failed to get OpenCL context from arrayfire");
     return ctx;
 }
 
 static inline cl_command_queue getQueue(bool retain = false)
 {
     cl_command_queue queue;
     af_err err = afcl_get_queue(&queue, retain);
     if (err != AF_SUCCESS) throw af::exception("Failed to get OpenCL command queue from arrayfire");
     return queue;
 }
 
 static inline cl_device_id getDeviceId()
 {
     cl_device_id id;
     af_err err = afcl_get_device_id(&id);
     if (err != AF_SUCCESS) throw af::exception("Failed to get OpenCL device ID");
 
     return id;
 }
 
#if AF_API_VERSION >= 32
 static inline void setDeviceId(cl_device_id id)
 {
     af_err err = afcl_set_device_id(id);
     if (err != AF_SUCCESS) throw af::exception("Failed to set OpenCL device as active device");
 }
#endif
 
#if AF_API_VERSION >= 33
static inline void addDevice(cl_device_id dev, cl_context ctx, cl_command_queue que)
{
    af_err err = afcl_add_device_context(dev, ctx, que);
    if (err!=AF_SUCCESS) throw af::exception("Failed to push user provided device/context to ArrayFire pool");
}
#endif
 
#if AF_API_VERSION >= 33
static inline void setDevice(cl_device_id dev, cl_context ctx)
{
    af_err err = afcl_set_device_context(dev, ctx);
    if (err!=AF_SUCCESS) throw af::exception("Failed to set device based on cl_device_id & cl_context");
}
#endif
 
#if AF_API_VERSION >= 33
static inline void deleteDevice(cl_device_id dev, cl_context ctx)
{
    af_err err = afcl_delete_device_context(dev, ctx);
    if (err!=AF_SUCCESS) throw af::exception("Failed to remove the requested device from ArrayFire device pool");
}
#endif
 
 
#if AF_API_VERSION >= 33
 typedef afcl_device_type deviceType;
 typedef afcl_platform platform;
#endif
 
#if AF_API_VERSION >= 33
static inline deviceType getDeviceType()
{
    afcl_device_type res = AFCL_DEVICE_TYPE_UNKNOWN;
    af_err err = afcl_get_device_type(&res);
    if (err!=AF_SUCCESS) throw af::exception("Failed to get OpenCL device type");
    return res;
}
#endif
 
#if AF_API_VERSION >= 33
static inline platform getPlatform()
{
    afcl_platform res = AFCL_PLATFORM_UNKNOWN;
    af_err err = afcl_get_platform(&res);
    if (err!=AF_SUCCESS) throw af::exception("Failed to get OpenCL platform");
    return res;
}
#endif
 
 static inline af::array array(af::dim4 idims, cl_mem buf, af::dtype type, bool retain=false)
 {
     const unsigned ndims = (unsigned)idims.ndims();
     const dim_t *dims = idims.get();
 
     cl_context context;
     cl_int clerr = clGetMemObjectInfo(buf, CL_MEM_CONTEXT, sizeof(cl_context), &context, NULL);
     if (clerr != CL_SUCCESS) {
         throw af::exception("Failed to get context from cl_mem object \"buf\" ");
     }
 
     if (context != getContext()) {
         throw(af::exception("Context mismatch between input \"buf\" and arrayfire"));
     }
 
 
     if (retain) clerr = clRetainMemObject(buf);
 
     af_array out;
     af_err err = af_device_array(&out, buf, ndims, dims, type);
 
     if (err != AF_SUCCESS || clerr != CL_SUCCESS) {
         if (retain && clerr == CL_SUCCESS) clReleaseMemObject(buf);
         throw af::exception("Failed to create device array");
     }
 
     return af::array(out);
 }
 
 static inline af::array array(dim_t dim0,
                               cl_mem buf, af::dtype type, bool retain=false)
 {
     return afcl::array(af::dim4(dim0), buf, type, retain);
 }
 
 static inline af::array array(dim_t dim0, dim_t dim1,
                               cl_mem buf, af::dtype type, bool retain=false)
 {
     return afcl::array(af::dim4(dim0, dim1), buf, type, retain);
 }
 
 static inline af::array array(dim_t dim0, dim_t dim1,
                               dim_t dim2,
                               cl_mem buf, af::dtype type, bool retain=false)
 {
     return afcl::array(af::dim4(dim0, dim1, dim2), buf, type, retain);
 }
 
 static inline af::array array(dim_t dim0, dim_t dim1,
                               dim_t dim2, dim_t dim3,
                               cl_mem buf, af::dtype type, bool retain=false)
 {
     return afcl::array(af::dim4(dim0, dim1, dim2, dim3), buf, type, retain);
 }
 
}
 
 
#endif