/// Returns the address of the \p function_name extension
/// function. Returns \c 0 if \p function_name is invalid.
void* get_extension_function_address(const char *function_name) const
{
#ifdef BOOST_COMPUTE_CL_VERSION_1_2
return clGetExtensionFunctionAddressForPlatform(m_platform,
function_name);
#else
return clGetExtensionFunctionAddress(function_name);
#endif
}
void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name)
{
void * ret = 0;
TRACE("(%s)\n",func_name);
#if 0
ret = clGetExtensionFunctionAddress(func_name);
#else
FIXME("extensions not implemented\n");
#endif
TRACE("(%s)=%p\n",func_name, ret);
return ret;
}
void *
CLDevice::get_extension_function (const char *func_name)
{
XCAM_ASSERT (func_name);
void *ext_func = NULL;
#if defined (CL_VERSION_1_2) && (CL_VERSION_1_2 == 1)
ext_func = (void *) clGetExtensionFunctionAddressForPlatform (_platform_id, func_name);
#else
ext_func = (void *) clGetExtensionFunctionAddress (func_name);
#endif
if (!ext_func)
XCAM_LOG_ERROR ("ocl driver get extension function (%s) failed", func_name);
return ext_func;
}
int OCL_Environment::OCL_LoadLibrary()
{
// EXTENSIONS
// OCL D3D10 interop functions
clGetDeviceIDsFromD3D10KHRFunc = (clGetDeviceIDsFromD3D10KHRFuncType) clGetExtensionFunctionAddress("clGetDeviceIDsFromD3D10KHR");
clCreateFromD3D10BufferKHRFunc = (clCreateFromD3D10BufferKHRFuncType) clGetExtensionFunctionAddress("clCreateFromD3D10BufferKHR");
clCreateFromD3D10Texture2DKHRFunc = (clCreateFromD3D10Texture2DKHRFuncType) clGetExtensionFunctionAddress("clCreateFromD3D10Texture2DKHR");
clCreateFromD3D10Texture3DKHRFunc = (clCreateFromD3D10Texture3DKHRFuncType) clGetExtensionFunctionAddress("clCreateFromD3D10Texture3DKHR");
clEnqueueAcquireD3D10ObjectsKHRFunc = (clEnqueueAcquireD3D10ObjectsKHRFuncType) clGetExtensionFunctionAddress("clEnqueueAcquireD3D10ObjectsKHR");
clEnqueueReleaseD3D10ObjectsKHRFunc = (clEnqueueReleaseD3D10ObjectsKHRFuncType) clGetExtensionFunctionAddress("clEnqueueReleaseD3D10ObjectsKHR");
return 0;
}
void initCL(cl::Context& _context, std::vector<cl::Device>& _devices, cl::CommandQueue& _queue)
{
cl_int err = CL_SUCCESS;
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
if (platforms.size() == 0)
{
throw std::exception("No OpenCL platform found.");
}
HGLRC glCtx = wglGetCurrentContext();
cl_context_properties properties[] = {
CL_CONTEXT_PLATFORM, (cl_context_properties) platforms[0](),
CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
CL_GL_CONTEXT_KHR, (cl_context_properties)glCtx,
0
};
static clGetGLContextInfoKHR_fn clGetGLContextInfoKHR;
if (!clGetGLContextInfoKHR)
{
clGetGLContextInfoKHR = (clGetGLContextInfoKHR_fn) clGetExtensionFunctionAddress("clGetGLContextInfoKHR");
if (!clGetGLContextInfoKHR)
{
throw std::exception("Failed to query proc address for clGetGLContextInfoKHR.");
}
}
cl_device_id interopDevice;
cl_int status = clGetGLContextInfoKHR(properties, CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, sizeof(cl_device_id), &interopDevice, nullptr);
cl::Device dev(interopDevice);
_devices.push_back(dev);
_context = cl::Context(_devices, properties);
_queue = cl::CommandQueue(_context, dev, CL_QUEUE_PROFILING_ENABLE, &err);
}
CL::CL() {
cl_int err;
std::vector<cl::Platform> platforms;
if(cl::Platform::get(&platforms) == CL_INVALID_VALUE) {
fprintf(stderr, "[OpenCL] No platforms available\n");
util_abort();
}
platform_ = platforms[0]; //Just select the first platform
std::string name, version, extensions;
platform_.getInfo(CL_PLATFORM_NAME, &name);
platform_.getInfo(CL_PLATFORM_VERSION, &version);
platform_.getInfo(CL_PLATFORM_EXTENSIONS, &extensions);
fprintf(verbose, "[OpenCL] Platform: %s %s\n"
" Extensions: %s\n", name.c_str(), version.c_str() ,extensions.c_str());
#if defined (__APPLE__) || defined(MACOSX)
CGLContextObj kCGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
cl_context_properties properties[] =
{
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)kCGLShareGroup,
0
};
#elif defined WIN32
HGLRC current_context = wglGetCurrentContext();
HDC current_dc = wglGetCurrentDC();
if(current_dc == NULL || current_context == NULL) {
fprintf(stderr,"[OpenCL] No OpenGL context active\n");
util_abort();
}
cl_context_properties properties[] = {
CL_CONTEXT_PLATFORM, (cl_context_properties)platform_(),
CL_WGL_HDC_KHR, (intptr_t) current_dc,
CL_GL_CONTEXT_KHR, (intptr_t) current_context,
0
};
#else
if(glXGetCurrentContext() == NULL) {
fprintf(stderr, "[OpenCL] glXGetCurrentContex() return NULL. Make sure to create OpenGL context before create the CL-context\n");
util_abort();
}
cl_context_properties properties[] =
{
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
CL_CONTEXT_PLATFORM, (cl_context_properties)(platform_)(),
0
};
#endif
static CL_API_ENTRY cl_int (CL_API_CALL
*clGetGLContextInfoKHR)(const cl_context_properties *properties,
cl_gl_context_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret)=NULL;
clGetGLContextInfoKHR = (clGetGLContextInfoKHR_fn) clGetExtensionFunctionAddress("clGetGLContextInfoKHR");
cl_device_id devices[32];
size_t deviceSize = 0;
err = clGetGLContextInfoKHR(properties,
CL_DEVICES_FOR_GL_CONTEXT_KHR,
32 * sizeof(cl_device_id),
devices,
&deviceSize);
if(deviceSize == 0) {
fprintf(stderr, "[OpenCL] Interop not possible\n");
util_abort();
}
cl_bool image_support, available;
size_t max_width, max_height;
cl_uint num_cores, frequency;
cl_device_type _type;
std::string type;
fprintf(verbose, "[OpenCL] Available devices: \n");
for(int i=0; i< (deviceSize / sizeof(cl_device_id)); ++i) {
cl::Device device(devices[i]);
device.getInfo(CL_DEVICE_VENDOR, &name);
device.getInfo(CL_DEVICE_VERSION, &version);
device.getInfo(CL_DEVICE_EXTENSIONS, &extensions);
device.getInfo(CL_DEVICE_AVAILABLE, &available);
device.getInfo(CL_DEVICE_IMAGE_SUPPORT, &image_support);
device.getInfo(CL_DEVICE_IMAGE2D_MAX_WIDTH, &max_width);
device.getInfo(CL_DEVICE_IMAGE2D_MAX_HEIGHT, &max_height);
device.getInfo( CL_DEVICE_MAX_COMPUTE_UNITS , &num_cores);
device.getInfo(CL_DEVICE_MAX_CLOCK_FREQUENCY, &frequency);
device.getInfo(CL_DEVICE_TYPE, &_type);
switch(_type) {
case CL_DEVICE_TYPE_GPU:
type = "GPU";
break;
case CL_DEVICE_TYPE_CPU:
type = "CPU";
break;
case CL_DEVICE_TYPE_ACCELERATOR:
type = "Accelerator";
break;
}
fprintf(verbose, "[OpenCL] Device (%p): %s %s (%s)\n"
" Cores: %u, Frequency: %u MHz, Available: %s,"
" Image support: %s, max size: %lux%lu\n"
" Extensions: %s\n --- \n", (device)(), name.c_str(), version.c_str(), type.c_str(), num_cores, frequency,available?"YES":"NO",image_support?"YES":"NO", max_width, max_height, extensions.c_str());
devices_.push_back(device);
}
fprintf(verbose, "\n-------------------\n");
cl_device_id device_id;
context_ = cl::Context(devices_, properties, &CL::cl_error_callback, nullptr, &err);
if(err != CL_SUCCESS) {
fprintf(stderr, "[OpenCL] Failed to create context: %s\n", errorString(err));
util_abort();
}
err = clGetGLContextInfoKHR(properties, CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, sizeof(device_id), &device_id, NULL);
if(err != CL_SUCCESS) {
fprintf(stderr, "[OpenCL] Failed to get current device for context: %s\n", errorString(err));
util_abort();
}
context_device_ = cl::Device(device_id);
context_device_.getInfo(CL_DEVICE_VENDOR, &name);
context_device_.getInfo(CL_DEVICE_VERSION, &version);
fprintf(verbose, "[OpenCL] Context Device (%p): %s %s\n",(context_device_)(), name.c_str(), version.c_str());
queue_ = cl::CommandQueue(context_, context_device_, 0, &err);
if(err != CL_SUCCESS) {
fprintf(stderr, "[OpenCL] Failed to create a command queue: %s\n", errorString(err));
util_abort();
}
}
CLContext::CLContext() {
#if defined(__APPLE__)
CGLContextObj kCGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
cl_context_properties properties[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
(cl_context_properties)kCGLShareGroup, 0
};
context_ = clCreateContext(properties, 0, 0, clLogMessagesToStdoutAPPLE, 0, 0);
if (!context_)
crash("failed to create context");
uint device_count;
cl_device_id device_ids[16];
size_t returned_size;
int err = clGetContextInfo(context_, CL_CONTEXT_DEVICES, sizeof(device_ids), device_ids, &returned_size);
if (err != CL_SUCCESS)
crash("failed to get devices");
device_count = (int)returned_size / sizeof(cl_device_id);
int i = 0;
bool device_found = false;
cl_device_type device_type;
for (i = 0; i < device_count; i++)
{
clGetDeviceInfo(device_ids[i], CL_DEVICE_TYPE, sizeof(cl_device_type), &device_type, NULL);
if (device_type == CL_DEVICE_TYPE_GPU)
{
device_id_ = device_ids[i];
device_found = true;
break;
}
}
if (!device_found)
crash("no GPU device found");
#elif defined(WIN32)
HGLRC hrc = wglGetCurrentContext();
HDC hdc = wglGetCurrentDC();
if (!hrc || !hdc)
crash("failed to get HDC or HGLRC");
cl_platform_id platform_ids[16];
size_t platform_count;
int err = clGetPlatformIDs(sizeof(platform_ids) / sizeof(platform_ids[0]), platform_ids, &platform_count);
if (err != CL_SUCCESS || !platform_count)
crash("failed to get platforms");
for (uint i = 0; i < platform_count; ++i) {
char platform_name[100];
char platform_version[100];
char platform_vendor[100];
char platform_extensions[1000];
err = clGetPlatformInfo(platform_ids[i],
CL_PLATFORM_NAME,
sizeof(platform_name),
platform_name,
NULL);
if (err != CL_SUCCESS)
crash("failed to get platform name");
err = clGetPlatformInfo(platform_ids[i],
CL_PLATFORM_VERSION,
sizeof(platform_version),
platform_version,
NULL);
if (err != CL_SUCCESS)
crash("failed to get platform version");
err = clGetPlatformInfo(platform_ids[i],
CL_PLATFORM_VENDOR,
sizeof(platform_vendor),
platform_vendor,
NULL);
if (err != CL_SUCCESS)
crash("failed to get platform vendor");
err = clGetPlatformInfo(platform_ids[i],
CL_PLATFORM_EXTENSIONS,
sizeof(platform_extensions),
platform_extensions,
NULL);
if (err != CL_SUCCESS)
crash("failed to get platform extensions");
cout << "platform name: " << platform_name << endl;
cout << "platform version: " << platform_version << endl;
cout << "platform vendor: " << platform_vendor << endl;
cout << "platform extensions: " << platform_extensions << endl;
cout << endl;
}
cl_platform_id platform_id = platform_ids[0];
typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetGLContextInfoKHR_fn)(
const cl_context_properties *properties,
cl_gl_context_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
clGetGLContextInfoKHR_fn clGetGLContextInfoKHR;
clGetGLContextInfoKHR = (clGetGLContextInfoKHR_fn) clGetExtensionFunctionAddress("clGetGLContextInfoKHR");
if (!clGetGLContextInfoKHR)
crash("failed to query proc address for clGetGLContextInfoKHR");
#ifndef NO_OPENGL_SHARING
cl_context_properties properties[] =
{
CL_CONTEXT_PLATFORM, (cl_context_properties) platform_id,
CL_GL_CONTEXT_KHR, (cl_context_properties) hrc,
CL_WGL_HDC_KHR, (cl_context_properties) hdc,
0
};
size_t device_count;
err = clGetGLContextInfoKHR(properties,
CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR,
sizeof(device_id_),
&device_id_,
&device_count);
if (err != CL_SUCCESS || !device_count)
crash("failed to get CL device from GL context");
char device_name[100];
char device_version[100];
cl_device_type device_type;
cl_bool device_image_support;
err = clGetDeviceInfo(device_id_, CL_DEVICE_NAME, sizeof(device_name), device_name, NULL);
if (err != CL_SUCCESS)
crash("failed to get device name");
err = clGetDeviceInfo(device_id_, CL_DEVICE_VERSION, sizeof(device_version), device_version, NULL);
if (err != CL_SUCCESS)
crash("failed to get device version");
err = clGetDeviceInfo(device_id_, CL_DEVICE_TYPE, sizeof(device_type), &device_type, NULL);
if (err != CL_SUCCESS)
crash("failed to get device type");
err = clGetDeviceInfo(device_id_, CL_DEVICE_IMAGE_SUPPORT, sizeof(device_image_support), &device_image_support, NULL);
if (err != CL_SUCCESS)
crash("failed to get device image support");
cout << "device name: " << device_name << endl;
cout << "device version: " << device_version << endl;
cout << "device type: " << ((device_type & CL_DEVICE_TYPE_GPU) ? "GPU" : "not GPU") << endl;
cout << "device image support: " << (device_image_support ? "yes" : "no") << endl;
cout << endl;
context_ = clCreateContext(properties,
1,
&device_id_,
0,
0,
&err);
#else
cl_int error = 0;
cl_platform_id platform;
// Platform
error = clGetPlatformIDs(1, &platform, NULL);
if (error != CL_SUCCESS) {
cout << "Error getting platform id: " << error << endl;
exit(error);
}
// Device
error = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device_id_, NULL);
if (err != CL_SUCCESS) {
cout << "Error getting device ids: " << error << endl;
exit(error);
}
// Context
context_ = clCreateContext(0, 1, &device_id_, NULL, NULL, &error);
if (error != CL_SUCCESS) {
cout << "Error creating context: " << error << endl;
exit(error);
}
#endif
#endif
cl_command_queue_properties queue_properties = 0;
queue_properties |= CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
#ifdef PROFILING_ENABLED
queue_properties |= CL_QUEUE_PROFILING_ENABLE;
#endif
queue_ = clCreateCommandQueue(context_, device_id_, queue_properties, NULL);
if (!queue_)
crash("failed to create command queue");
}
bool selectGLDeviceAndPlatform(cl_device_id *device, cl_platform_id *platform)
{
assert(device != nullptr);
assert(platform != nullptr);
/* first try to get the necessary extension */
clGetGLContextInfoKHR_fn clGetGLContextInfoKHR = (clGetGLContextInfoKHR_fn) clGetExtensionFunctionAddress("clGetGLContextInfoKHR");
if (clGetGLContextInfoKHR == nullptr)
{
ERRORM("clGetGLContextInfoKHR extension function not supproted.");
return false;
}
#if defined(FLUIDSIM_OS_MAC)
cl_context_properties props[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
(cl_context_properties) CGLGetShareGroup(CGLGetCurrentContext()),
0
};
cl_int err = clGetGLContextInfoKHR(props, // the OpenGL context
CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, // get the id of the device currently executing OpenGL
sizeof(*device),
device,
nullptr);
if (err != CL_SUCCESS)
{
ERRORM("Failed to retrieve the OpenCL id of the device executing OpenGL: " << errorToStr(err));
return false;
}
/* get the platform associated with the device */
err = clGetDeviceInfo(*device, CL_DEVICE_PLATFORM, sizeof(*platform), platform, nullptr);
if (err != CL_SUCCESS)
{
ERRORM("Failed to retirieve platform id for the device executing OpenGL: " << errorToStr(err));
return false;
}
#else
cl_context_properties props[] = {
#if defined(FLUIDSIM_OS_UNIX)
CL_GL_CONTEXT_KHR, (cl_context_properties) glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties) glXGetCurrentDisplay(),
CL_CONTEXT_PLATFORM, (cl_context_properties) nullptr,
#elif defined(FLUIDSIM_OS_WIN)
CL_GL_CONTEXT_KHR, (cl_context_properties) wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties) wglGetCurrentDC(),
CL_CONTEXT_PLATFORM, (cl_context_properties) nullptr,
#else
# error "Unsupported OS platform"
#endif
0
};
std::vector<boost::compute::platform> platform_list = boost::compute::system::platforms();
for (const boost::compute::platform & p : platform_list)
{
WARNM("platform: " << p.name());
props[5] = (cl_context_properties) p.id();
cl_int err = clGetGLContextInfoKHR(props, // the OpenGL context
CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, // get the id of the device currently executing OpenGL
sizeof(*device),
device,
nullptr);
if ((err == CL_SUCCESS) && (boost::compute::device(*device).type() == CL_DEVICE_TYPE_GPU))
{
*platform = (cl_platform_id) props[5];
return true;
}
else
{
WARNM("clGetGLContextInfoKHR: " << errorToStr(err));
}
}
#endif
return false;
}
/*!
Creates an OpenCL context that is compatible with the current
QGLContext and \a platform. Returns false if there is no OpenGL
context current or the OpenCL context could not be created for
some reason.
This function will first try to create a QCLDevice::GPU device,
and will then fall back to QCLDevice::Default if a GPU is not found.
If \a platform is null, then the first platform that has a GPU
will be used. If there is no GPU, then the first platform with a
default device will be used.
\sa supportsObjectSharing()
*/
bool QCLContextGL::create(const QCLPlatform &platform)
{
Q_D(QCLContextGL);
// Bail out if the context already exists.
if (isCreated())
return true;
// Bail out if we don't have an OpenGL context.
if (!QGLContext::currentContext()) {
qWarning() << "QCLContextGL::create: needs a current GL context";
setLastError(CL_INVALID_CONTEXT);
return false;
}
// Find the first gpu device.
QList<QCLDevice> devices;
cl_device_type deviceType = CL_DEVICE_TYPE_GPU;
devices = QCLDevice::devices(QCLDevice::GPU, platform);
if (devices.isEmpty()) {
// Find the first default device.
devices = QCLDevice::devices(QCLDevice::Default, platform);
deviceType = CL_DEVICE_TYPE_DEFAULT;
}
if (devices.isEmpty()) {
qWarning() << "QCLContextGL::create: no gpu devices found";
setLastError(CL_DEVICE_NOT_FOUND);
return false;
}
QCLDevice gpu = devices[0];
QVarLengthArray<cl_device_id> devs;
foreach (QCLDevice dev, devices)
devs.append(dev.deviceId());
// Add the platform identifier to the properties.
QVarLengthArray<cl_context_properties> properties;
properties.append(CL_CONTEXT_PLATFORM);
properties.append(cl_context_properties(gpu.platform().platformId()));
bool hasSharing = false;
#ifndef QT_NO_CL_OPENGL
// Determine what kind of OpenCL-OpenGL sharing we have and enable it.
#if defined(__APPLE__) || defined(__MACOSX)
bool appleSharing = gpu.hasExtension("cl_apple_gl_sharing");
if (appleSharing) {
CGLContextObj cglContext = CGLGetCurrentContext();
CGLShareGroupObj cglShareGroup = CGLGetShareGroup(cglContext);
properties.append(CL_CGL_SHAREGROUP_KHR);
properties.append(cl_context_properties(cglShareGroup));
hasSharing = true;
}
#else
bool khrSharing = gpu.hasExtension("cl_khr_gl_sharing");
#if defined(QT_OPENGL_ES_2) || defined(QT_OPENGL_ES)
if (khrSharing) {
properties.append(CL_EGL_DISPLAY_KHR);
properties.append(cl_context_properties(eglGetCurrentDisplay()));
#ifdef EGL_OPENGL_ES_API
eglBindAPI(EGL_OPENGL_ES_API);
#endif
properties.append(CL_GL_CONTEXT_KHR);
properties.append(cl_context_properties(eglGetCurrentContext()));
hasSharing = true;
}
#elif defined(Q_WS_X11)
if (khrSharing) {
properties.append(CL_GLX_DISPLAY_KHR);
properties.append(cl_context_properties(glXGetCurrentDisplay()));
properties.append(CL_GL_CONTEXT_KHR);
properties.append(cl_context_properties(glXGetCurrentContext()));
hasSharing = true;
}
#else
// Needs to be ported to other platforms.
if (khrSharing)
qWarning() << "QCLContextGL::create: do not know how to enable sharing";
#endif
#endif
#endif // !QT_NO_CL_OPENGL
properties.append(0);
#ifndef QT_NO_CL_OPENGL
// Query the actual OpenCL devices we should use with the OpenGL context.
typedef cl_int (*q_PFNCLGETGLCONTEXTINFOKHR)
(const cl_context_properties *, cl_uint, size_t, void *, size_t *);
q_PFNCLGETGLCONTEXTINFOKHR getGLContextInfo =
(q_PFNCLGETGLCONTEXTINFOKHR)clGetExtensionFunctionAddress
("clGetGLContextInfoKHR");
if (getGLContextInfo && hasSharing) {
size_t size;
cl_device_id currentDev;
if(getGLContextInfo(properties.data(),
CL_DEVICES_FOR_GL_CONTEXT_KHR,
0, 0, &size) == CL_SUCCESS && size > 0) {
QVarLengthArray<cl_device_id> buf(size / sizeof(cl_device_id));
getGLContextInfo(properties.data(),
CL_DEVICES_FOR_GL_CONTEXT_KHR,
size, buf.data(), 0);
devs = buf;
gpu = QCLDevice(devs[0]);
}
if (getGLContextInfo(properties.data(),
CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR,
sizeof(currentDev), ¤tDev, 0)
== CL_SUCCESS) {
gpu = QCLDevice(currentDev);
}
}
#endif
// Create the OpenCL context.
cl_context id;
cl_int error;
id = clCreateContext
(properties.data(), devs.size(), devs.data(),
qt_clgl_context_notify, 0, &error);
if (!id && hasSharing) {
// Try again without the sharing parameters.
properties.resize(2);
properties.append(0);
hasSharing = false;
id = clCreateContext
(properties.data(), devs.size(), devs.data(),
qt_clgl_context_notify, 0, &error);
}
setLastError(error);
if (id == 0) {
qWarning() << "QCLContextGL::create:" << errorName(error);
d->supportsSharing = false;
} else {
setContextId(id);
clReleaseContext(id); // setContextId() adds an extra reference.
setDefaultDevice(gpu);
d->supportsSharing = hasSharing;
}
return id != 0;
}
oclContext* oclContext::create(const char* iVendor, int iDeviceType)
{
/*
cl_int status = CL_SUCCESS;
cl_device_type dType = CL_DEVICE_TYPE_GPU;
cl_uint numPlatforms;
cl_platform_id platform = NULL;
status = clGetPlatformIDs(0, NULL, &numPlatforms);
if (0 < numPlatforms)
{
cl_platform_id* platforms = new cl_platform_id[numPlatforms];
status = clGetPlatformIDs(numPlatforms, platforms, NULL);
for (unsigned i = 0; i < numPlatforms; ++i)
{
char pbuf[100];
status = clGetPlatformInfo(platforms[i],
CL_PLATFORM_VENDOR,
sizeof(pbuf),
pbuf,
NULL);
platform = platforms[i];
if (!strcmp(pbuf, "Advanced Micro Devices, Inc."))
{
break;
}
}
delete[] platforms;
}
#ifdef _WIN32
HGLRC glCtx = wglGetCurrentContext();
#else //!_WIN32
GLXContext glCtx = glXGetCurrentContext();
#endif //!_WIN32
cl_context_properties cpsGL[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform,
#ifdef _WIN32
CL_WGL_HDC_KHR, (intptr_t) wglGetCurrentDC(),
#else //!_WIN32
CL_GLX_DISPLAY_KHR, (intptr_t) glXGetCurrentDisplay(),
#endif //!_WIN32
CL_GL_CONTEXT_KHR, (intptr_t) glCtx, 0};
cl_context context = clCreateContextFromType(
cpsGL,
dType,
NULL,
NULL,
&status);
return new oclContext(context, "Advanced Micro Devices, Inc.");
*/
cl_uint lPlatformCount = 0;
sStatusCL = clGetPlatformIDs(0, NULL, &lPlatformCount);
oclSuccess("clGetPlatformIDs");
clGetGLContextInfoKHR_fn _clGetGLContextInfoKHR = (clGetGLContextInfoKHR_fn)clGetExtensionFunctionAddress("clGetGLContextInfoKHR");
cl_platform_id lPlatform[100];
sStatusCL = clGetPlatformIDs(lPlatformCount, lPlatform, NULL);
oclSuccess("clGetPlatformIDs");
char lBuffer[200];
for (cl_uint i=0; i < lPlatformCount; i++)
{
sStatusCL = clGetPlatformInfo(lPlatform[i],
CL_PLATFORM_VENDOR,
sizeof(lBuffer),
lBuffer,
NULL);
oclSuccess("clGetPlatformInfo");
cl_context_properties GL_PROPS[] =
{
#ifdef WIN32
CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
#else
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (intptr_t) glXGetCurrentDisplay(),
#endif
CL_CONTEXT_PLATFORM, (cl_context_properties)lPlatform[i],
0
};
cl_context_properties CL_PROPS[] =
{
CL_CONTEXT_PLATFORM, (cl_context_properties)lPlatform[i],
0
};
if (!strncmp(lBuffer, iVendor, 5)) // compare only first 5 letters -- Intel starts with "Intel" and "Intel(R)"
{
switch (iDeviceType)
{
case CL_DEVICE_TYPE_GPU:
// gpu context
cl_device_id lDevices[100];
cl_uint lDeviceCount;
sStatusCL = clGetDeviceIDs(lPlatform[i], CL_DEVICE_TYPE_GPU, 100, lDevices, &lDeviceCount);
if (!oclSuccess("clGetDeviceIDs"))
{
continue;
}
if (lDeviceCount)
{
size_t lDeviceGLCount = 0;
cl_device_id lDeviceGL;
sStatusCL = _clGetGLContextInfoKHR(GL_PROPS, CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, sizeof(cl_device_id), &lDeviceGL, &lDeviceGLCount);
if (!oclSuccess("clGetDeviceIDs"))
{
//continue; AMD drivers produce an error here if not OpenGL context is present
}
if (lDeviceGLCount)
{
// gpu context with sharing enabled
cl_context lContextCL = clCreateContext(GL_PROPS, lDeviceCount, lDevices, NULL, NULL, &sStatusCL);
if (!oclSuccess("clCreateContext"))
{
continue;
}
return new oclContext(lContextCL, lPlatform[i], lBuffer);
}
else
{
// gpu context without sharing
cl_context lContextCL = clCreateContext(CL_PROPS, lDeviceCount, lDevices, NULL, NULL, &sStatusCL);
if (!oclSuccess("clCreateContext"))
{
continue;
}
return new oclContext(lContextCL, lPlatform[i], lBuffer);
}
}
break;
case CL_DEVICE_TYPE_CPU:
// cpu context
cl_context lContextCL = clCreateContextFromType(CL_PROPS, CL_DEVICE_TYPE_CPU, NULL, NULL, &sStatusCL);
if (!oclSuccess("clCreateContextFromType"))
{
continue;
}
return new oclContext(lContextCL, lPlatform[i], lBuffer);
break;
}
}
}
return 0;
}
