loader/icd.h
loader/icd_dispatch.c
loader/icd_dispatch.h
+ loader/icd_dispatch_generated.c
loader/icd_envvars.h
loader/icd_platform.h)
/*
- * Copyright (c) 2012-2019 The Khronos Group Inc.
+ * Copyright (c) 2012-2020 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <stdlib.h>
#include <string.h>
-// Platform APIs
-CL_API_ENTRY cl_int CL_API_CALL
-clGetPlatformIDs(cl_uint num_entries,
- cl_platform_id * platforms,
- cl_uint * num_platforms) CL_API_SUFFIX__VERSION_1_0
+static void* khrIcdGetExtensionFunctionAddress(const char* function_name)
+{
+// Most extensions, including multi-vendor KHR and EXT extensions,
+// do not need to be ICD-aware and do not require any ICD loader
+// modifications. The KHR and EXT extensions below were added for
+// backwards compatibility only.
+#define KHR_ICD_CHECK_EXTENSION_FUNCTION(name) \
+ do \
+ { \
+ if (!strcmp(function_name, #name)) \
+ { \
+ return (void*)(size_t)&name; \
+ } \
+ } while (0)
+
+ // Functions supporting the creation of OpenCL Memory Objects
+ // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLBuffer);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLTexture);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLTexture2D);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLTexture3D);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLRenderbuffer);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetGLObjectInfo);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetGLTextureInfo);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireGLObjects);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseGLObjects);
+
+ // cl_khr_gl_sharing
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetGLContextInfoKHR);
+
+ // cl_khr_gl_event
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateEventFromGLsyncKHR);
+
+#if defined(_WIN32)
+ // cl_khr_d3d10_sharing
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetDeviceIDsFromD3D10KHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D10BufferKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D10Texture2DKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D10Texture3DKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireD3D10ObjectsKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseD3D10ObjectsKHR);
+ // cl_khr_d3d11_sharing
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetDeviceIDsFromD3D11KHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D11BufferKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D11Texture2DKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D11Texture3DKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireD3D11ObjectsKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseD3D11ObjectsKHR);
+ // cl_khr_dx9_media_sharing
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetDeviceIDsFromDX9MediaAdapterKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromDX9MediaSurfaceKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireDX9MediaSurfacesKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseDX9MediaSurfacesKHR);
+#endif
+
+ // cl_ext_device_fission
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateSubDevicesEXT);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clRetainDeviceEXT);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clReleaseDeviceEXT);
+
+ // cl_khr_egl_image
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromEGLImageKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireEGLObjectsKHR);
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseEGLObjectsKHR);
+
+ // cl_khr_egl_event
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateEventFromEGLSyncKHR);
+
+ // cl_khr_sub_groups
+ KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetKernelSubGroupInfoKHR);
+
+#undef KHR_ICD_CHECK_EXTENSION_FUNCTION
+
+ return NULL;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(
+ cl_uint num_entries,
+ cl_platform_id* platforms,
+ cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0
{
KHRicdVendor* vendor = NULL;
cl_uint i;
return CL_INVALID_VALUE;
}
// set num_platforms to 0 and set all platform pointers to NULL
- if (num_platforms)
+ if (num_platforms)
{
*num_platforms = 0;
}
- for (i = 0; i < num_entries && platforms; ++i)
+ for (i = 0; i < num_entries && platforms; ++i)
{
platforms[i] = NULL;
}
return CL_SUCCESS;
}
-CL_API_ENTRY cl_int CL_API_CALL
-clGetPlatformInfo(cl_platform_id platform,
- cl_platform_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- // initialize the platforms (in case they have not been already)
- khrIcdInitialize();
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clGetPlatformInfo(
- platform,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-// Device APIs
-CL_API_ENTRY cl_int CL_API_CALL
-clGetDeviceIDs(cl_platform_id platform,
- cl_device_type device_type,
- cl_uint num_entries,
- cl_device_id * devices,
- cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_0
+CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress(
+ const char* function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
- // initialize the platforms (in case they have not been already)
- khrIcdInitialize();
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clGetDeviceIDs(
- platform,
- device_type,
- num_entries,
- devices,
- num_devices);
-}
+ void* function_address = NULL;
+ size_t function_name_length = 0;
+ KHRicdVendor* vendor = NULL;
-CL_API_ENTRY cl_int CL_API_CALL
-clGetDeviceInfo(
- cl_device_id device,
- cl_device_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return device->dispatch->clGetDeviceInfo(
- device,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
-CL_API_ENTRY cl_int CL_API_CALL
-clCreateSubDevices(cl_device_id in_device,
- const cl_device_partition_property * properties,
- cl_uint num_entries,
- cl_device_id * out_devices,
- cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
- return in_device->dispatch->clCreateSubDevices(
- in_device,
- properties,
- num_entries,
- out_devices,
- num_devices);
-}
+ // make sure the ICD is initialized
+ khrIcdInitialize();
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return device->dispatch->clRetainDevice(device);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return device->dispatch->clReleaseDevice(device);
-}
+ // check if this is an ICD-aware extension
+ function_address = khrIcdGetExtensionFunctionAddress(function_name);
+ if (function_address)
+ {
+ return function_address;
+ }
-// Context APIs
-CL_API_ENTRY cl_context CL_API_CALL
-clCreateContext(const cl_context_properties * properties,
- cl_uint num_devices,
- const cl_device_id * devices,
- void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
- void * user_data,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- // initialize the platforms (in case they have not been already)
- khrIcdInitialize();
- if (!num_devices || !devices)
+ // fall back to vendor extension detection
+ function_name_length = strlen(function_name);
+ for (vendor = khrIcdVendors; vendor; vendor = vendor->next)
{
- if (errcode_ret)
+ size_t vendor_suffix_length = strlen(vendor->suffix);
+ if (vendor_suffix_length <= function_name_length &&
+ vendor_suffix_length > 0)
{
- *errcode_ret = CL_INVALID_VALUE;
+ const char* function_suffix =
+ function_name + function_name_length - vendor_suffix_length;
+ if (!strcmp(function_suffix, vendor->suffix))
+ {
+ return vendor->clGetExtensionFunctionAddress(function_name);
+ }
}
- return NULL;
}
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
- return devices[0]->dispatch->clCreateContext(
- properties,
- num_devices,
- devices,
- pfn_notify,
- user_data,
- errcode_ret);
+
+ return NULL;
}
-CL_API_ENTRY cl_context CL_API_CALL
-clCreateContextFromType(const cl_context_properties * properties,
- cl_device_type device_type,
- void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
- void * user_data,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
+CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform(
+ cl_platform_id platform,
+ const char* function_name) CL_API_SUFFIX__VERSION_1_2
{
- cl_platform_id platform = NULL;
+ void* function_address = NULL;
- // initialize the platforms (in case they have not been already)
- khrIcdInitialize();
-
- // determine the platform to use from the properties specified
- khrIcdContextPropertiesGetPlatform(properties, &platform);
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
- // validate the platform handle and dispatch
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clCreateContextFromType(
- properties,
- device_type,
- pfn_notify,
- user_data,
- errcode_ret);
-}
+ // make sure the ICD is initialized
+ khrIcdInitialize();
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
- return context->dispatch->clRetainContext(context);
-}
+ // check if this is an ICD-aware extension
+ function_address = khrIcdGetExtensionFunctionAddress(function_name);
+ if (function_address)
+ {
+ return function_address;
+ }
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
- return context->dispatch->clReleaseContext(context);
-}
+ // This is not an ICD-aware extension, so call into the implementation
+ // to get the extension function address.
-CL_API_ENTRY cl_int CL_API_CALL
-clGetContextInfo(cl_context context,
- cl_context_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
- return context->dispatch->clGetContextInfo(
- context,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL);
+ return platform->dispatch->clGetExtensionFunctionAddressForPlatform(
+ platform,
+ function_name);
}
#ifdef CL_VERSION_3_0
* OpenCL 3.0 provisional entry points from being in general builds before the
* specification is finalized. */
-CL_API_ENTRY cl_int CL_API_CALL
-clSetContextDestructorCallback(cl_context context,
- void (CL_CALLBACK* pfn_notify)(cl_context context,
- void* user_data),
- void* user_data) CL_API_SUFFIX__VERSION_3_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
- return context->dispatch->clSetContextDestructorCallback(
- context,
- pfn_notify,
- user_data);
-}
-
-#endif // CL_VERSION_3_0
-
-// Command Queue APIs
-CL_API_ENTRY cl_command_queue CL_API_CALL
-clCreateCommandQueue(cl_context context,
- cl_device_id device,
- cl_command_queue_properties properties,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateCommandQueue(
- context,
- device,
- properties,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clRetainCommandQueue(command_queue);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clReleaseCommandQueue(command_queue);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetCommandQueueInfo(cl_command_queue command_queue,
- cl_command_queue_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clGetCommandQueueInfo(
- command_queue,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-// Memory Object APIs
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateBuffer(cl_context context,
- cl_mem_flags flags,
- size_t size,
- void * host_ptr,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
+CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties(
+ cl_context context,
+ const cl_mem_properties* properties,
+ cl_mem_flags flags,
+ size_t size,
+ void* host_ptr,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateBuffer(
+ return context->dispatch->clCreateBufferWithProperties(
context,
+ properties,
flags,
size,
host_ptr,
errcode_ret);
}
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateImage(cl_context context,
- cl_mem_flags flags,
- const cl_image_format * image_format,
- const cl_image_desc * image_desc,
- void * host_ptr,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2
+CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties(
+ cl_context context,
+ const cl_mem_properties* properties,
+ cl_mem_flags flags,
+ const cl_image_format* image_format,
+ const cl_image_desc* image_desc,
+ void* host_ptr,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateImage(
+ return context->dispatch->clCreateImageWithProperties(
context,
+ properties,
flags,
image_format,
image_desc,
errcode_ret);
}
-#ifdef CL_VERSION_3_0
-/* ICD loader entry points should not normally be ifdef'ed, but prevent
- * OpenCL 3.0 provisional entry points from being in general builds before the
- * specification is finalized. */
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateBufferWithProperties(cl_context context,
- const cl_mem_properties * properties,
- cl_mem_flags flags,
- size_t size,
- void * host_ptr,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_3_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateBufferWithProperties(
- context,
- properties,
- flags,
- size,
- host_ptr,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateImageWithProperties(cl_context context,
- const cl_mem_properties * properties,
- cl_mem_flags flags,
- const cl_image_format * image_format,
- const cl_image_desc * image_desc,
- void * host_ptr,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_3_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateImageWithProperties(
- context,
- properties,
- flags,
- image_format,
- image_desc,
- host_ptr,
- errcode_ret);
-}
-
-#endif // CL_VERSION_3_0
-
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
- return memobj->dispatch->clRetainMemObject(memobj);
-}
-
-
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
- return memobj->dispatch->clReleaseMemObject(memobj);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetSupportedImageFormats(cl_context context,
- cl_mem_flags flags,
- cl_mem_object_type image_type,
- cl_uint num_entries,
- cl_image_format * image_formats,
- cl_uint * num_image_formats) CL_API_SUFFIX__VERSION_1_0
+CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback(
+ cl_context context,
+ void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data),
+ void* user_data) CL_API_SUFFIX__VERSION_3_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
- return context->dispatch->clGetSupportedImageFormats(
- context,
- flags,
- image_type,
- num_entries,
- image_formats,
- num_image_formats);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetMemObjectInfo(cl_mem memobj,
- cl_mem_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
- return memobj->dispatch->clGetMemObjectInfo(
- memobj,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetImageInfo(cl_mem image,
- cl_image_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
- return image->dispatch->clGetImageInfo(
- image,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-// Sampler APIs
-CL_API_ENTRY cl_sampler CL_API_CALL
-clCreateSampler(cl_context context,
- cl_bool normalized_coords,
- cl_addressing_mode addressing_mode,
- cl_filter_mode filter_mode,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateSampler(
- context,
- normalized_coords,
- addressing_mode,
- filter_mode,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
- return sampler->dispatch->clRetainSampler(sampler);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
- return sampler->dispatch->clReleaseSampler(sampler);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetSamplerInfo(cl_sampler sampler,
- cl_sampler_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
- return sampler->dispatch->clGetSamplerInfo(
- sampler,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-// Program Object APIs
-CL_API_ENTRY cl_program CL_API_CALL
-clCreateProgramWithSource(cl_context context,
- cl_uint count,
- const char ** strings,
- const size_t * lengths,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateProgramWithSource(
- context,
- count,
- strings,
- lengths,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_program CL_API_CALL
-clCreateProgramWithBinary(cl_context context,
- cl_uint num_devices,
- const cl_device_id * device_list,
- const size_t * lengths,
- const unsigned char ** binaries,
- cl_int * binary_status,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateProgramWithBinary(
- context,
- num_devices,
- device_list,
- lengths,
- binaries,
- binary_status,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_program CL_API_CALL
-clCreateProgramWithBuiltInKernels(cl_context context,
- cl_uint num_devices,
- const cl_device_id * device_list,
- const char * kernel_names,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateProgramWithBuiltInKernels(
- context,
- num_devices,
- device_list,
- kernel_names,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clRetainProgram(program);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clReleaseProgram(program);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clBuildProgram(cl_program program,
- cl_uint num_devices,
- const cl_device_id * device_list,
- const char * options,
- void (CL_CALLBACK *pfn_notify)(cl_program program, void * user_data),
- void * user_data) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clBuildProgram(
- program,
- num_devices,
- device_list,
- options,
- pfn_notify,
- user_data);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clCompileProgram(cl_program program,
- cl_uint num_devices,
- const cl_device_id * device_list,
- const char * options,
- cl_uint num_input_headers,
- const cl_program * input_headers,
- const char ** header_include_names,
- void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data),
- void * user_data) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clCompileProgram(
- program,
- num_devices,
- device_list,
- options,
- num_input_headers,
- input_headers,
- header_include_names,
- pfn_notify,
- user_data);
-}
-
-CL_API_ENTRY cl_program CL_API_CALL
-clLinkProgram(cl_context context,
- cl_uint num_devices,
- const cl_device_id * device_list,
- const char * options,
- cl_uint num_input_programs,
- const cl_program * input_programs,
- void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data),
- void * user_data,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clLinkProgram(
+ return context->dispatch->clSetContextDestructorCallback(
context,
- num_devices,
- device_list,
- options,
- num_input_programs,
- input_programs,
- pfn_notify,
- user_data,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetProgramSpecializationConstant(cl_program program,
- cl_uint spec_id,
- size_t spec_size,
- const void* spec_value) CL_API_SUFFIX__VERSION_2_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clSetProgramSpecializationConstant(
- program,
- spec_id,
- spec_size,
- spec_value);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetProgramReleaseCallback(cl_program program,
- void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data),
- void * user_data) CL_API_SUFFIX__VERSION_2_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clSetProgramReleaseCallback(
- program,
pfn_notify,
- user_data);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
-{
- // initialize the platforms (in case they have not been already)
- khrIcdInitialize();
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clUnloadPlatformCompiler(platform);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetProgramInfo(cl_program program,
- cl_program_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clGetProgramInfo(
- program,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetProgramBuildInfo(cl_program program,
- cl_device_id device,
- cl_program_build_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clGetProgramBuildInfo(
- program,
- device,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-// Kernel Object APIs
-CL_API_ENTRY cl_kernel CL_API_CALL
-clCreateKernel(cl_program program,
- const char * kernel_name,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
- return program->dispatch->clCreateKernel(
- program,
- kernel_name,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clCreateKernelsInProgram(cl_program program,
- cl_uint num_kernels,
- cl_kernel * kernels,
- cl_uint * num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
- return program->dispatch->clCreateKernelsInProgram(
- program,
- num_kernels,
- kernels,
- num_kernels_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clRetainKernel(kernel);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clReleaseKernel(kernel);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetKernelArg(cl_kernel kernel,
- cl_uint arg_index,
- size_t arg_size,
- const void * arg_value) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clSetKernelArg(
- kernel,
- arg_index,
- arg_size,
- arg_value);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetKernelInfo(cl_kernel kernel,
- cl_kernel_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clGetKernelInfo(
- kernel,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetKernelArgInfo(cl_kernel kernel,
- cl_uint arg_indx,
- cl_kernel_arg_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clGetKernelArgInfo(
- kernel,
- arg_indx,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetKernelWorkGroupInfo(cl_kernel kernel,
- cl_device_id device,
- cl_kernel_work_group_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clGetKernelWorkGroupInfo(
- kernel,
- device,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-// Event Object APIs
-CL_API_ENTRY cl_int CL_API_CALL
-clWaitForEvents(cl_uint num_events,
- const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0
-{
- if (!num_events || !event_list)
- {
- return CL_INVALID_VALUE;
- }
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT);
- return event_list[0]->dispatch->clWaitForEvents(
- num_events,
- event_list);
+ user_data);
}
-CL_API_ENTRY cl_int CL_API_CALL
-clGetEventInfo(cl_event event,
- cl_event_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
- return event->dispatch->clGetEventInfo(
- event,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
- return event->dispatch->clRetainEvent(event);
-}
+#endif // CL_VERSION_3_0
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
- return event->dispatch->clReleaseEvent(event);
+#ifdef __cplusplus
}
-
-// Profiling APIs
-CL_API_ENTRY cl_int CL_API_CALL
-clGetEventProfilingInfo(cl_event event,
- cl_profiling_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
- return event->dispatch->clGetEventProfilingInfo(
- event,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-// Flush and Finish APIs
-CL_API_ENTRY cl_int CL_API_CALL
-clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clFlush(command_queue);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clFinish(command_queue);
-}
-
-// Enqueued Commands APIs
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReadBuffer(cl_command_queue command_queue,
- cl_mem buffer,
- cl_bool blocking_read,
- size_t offset,
- size_t cb,
- void * ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReadBuffer(
- command_queue,
- buffer,
- blocking_read,
- offset,
- cb,
- ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReadBufferRect(
- cl_command_queue command_queue,
- cl_mem buffer,
- cl_bool blocking_read,
- const size_t * buffer_origin,
- const size_t * host_origin,
- const size_t * region,
- size_t buffer_row_pitch,
- size_t buffer_slice_pitch,
- size_t host_row_pitch,
- size_t host_slice_pitch,
- void * ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReadBufferRect(
- command_queue,
- buffer,
- blocking_read,
- buffer_origin,
- host_origin,
- region,
- buffer_row_pitch,
- buffer_slice_pitch,
- host_row_pitch,
- host_slice_pitch,
- ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueWriteBuffer(cl_command_queue command_queue,
- cl_mem buffer,
- cl_bool blocking_write,
- size_t offset,
- size_t cb,
- const void * ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueWriteBuffer(
- command_queue,
- buffer,
- blocking_write,
- offset,
- cb,
- ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueWriteBufferRect(
- cl_command_queue command_queue,
- cl_mem buffer,
- cl_bool blocking_read,
- const size_t * buffer_origin,
- const size_t * host_origin,
- const size_t * region,
- size_t buffer_row_pitch,
- size_t buffer_slice_pitch,
- size_t host_row_pitch,
- size_t host_slice_pitch,
- const void * ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueWriteBufferRect(
- command_queue,
- buffer,
- blocking_read,
- buffer_origin,
- host_origin,
- region,
- buffer_row_pitch,
- buffer_slice_pitch,
- host_row_pitch,
- host_slice_pitch,
- ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueFillBuffer(cl_command_queue command_queue,
- cl_mem buffer,
- const void * pattern,
- size_t pattern_size,
- size_t offset,
- size_t cb,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueFillBuffer(
- command_queue,
- buffer,
- pattern,
- pattern_size,
- offset,
- cb,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueCopyBuffer(cl_command_queue command_queue,
- cl_mem src_buffer,
- cl_mem dst_buffer,
- size_t src_offset,
- size_t dst_offset,
- size_t cb,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueCopyBuffer(
- command_queue,
- src_buffer,
- dst_buffer,
- src_offset,
- dst_offset,
- cb,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueCopyBufferRect(
- cl_command_queue command_queue,
- cl_mem src_buffer,
- cl_mem dst_buffer,
- const size_t * src_origin,
- const size_t * dst_origin,
- const size_t * region,
- size_t src_row_pitch,
- size_t src_slice_pitch,
- size_t dst_row_pitch,
- size_t dst_slice_pitch,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueCopyBufferRect(
- command_queue,
- src_buffer,
- dst_buffer,
- src_origin,
- dst_origin,
- region,
- src_row_pitch,
- src_slice_pitch,
- dst_row_pitch,
- dst_slice_pitch,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReadImage(cl_command_queue command_queue,
- cl_mem image,
- cl_bool blocking_read,
- const size_t * origin,
- const size_t * region,
- size_t row_pitch,
- size_t slice_pitch,
- void * ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReadImage(
- command_queue,
- image,
- blocking_read,
- origin,
- region,
- row_pitch,
- slice_pitch,
- ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueWriteImage(cl_command_queue command_queue,
- cl_mem image,
- cl_bool blocking_write,
- const size_t * origin,
- const size_t * region,
- size_t input_row_pitch,
- size_t input_slice_pitch,
- const void * ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueWriteImage(
- command_queue,
- image,
- blocking_write,
- origin,
- region,
- input_row_pitch,
- input_slice_pitch,
- ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueFillImage(cl_command_queue command_queue,
- cl_mem image,
- const void * fill_color,
- const size_t origin[3],
- const size_t region[3],
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueFillImage(
- command_queue,
- image,
- fill_color,
- origin,
- region,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueCopyImage(cl_command_queue command_queue,
- cl_mem src_image,
- cl_mem dst_image,
- const size_t * src_origin,
- const size_t * dst_origin,
- const size_t * region,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueCopyImage(
- command_queue,
- src_image,
- dst_image,
- src_origin,
- dst_origin,
- region,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueCopyImageToBuffer(cl_command_queue command_queue,
- cl_mem src_image,
- cl_mem dst_buffer,
- const size_t * src_origin,
- const size_t * region,
- size_t dst_offset,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueCopyImageToBuffer(
- command_queue,
- src_image,
- dst_buffer,
- src_origin,
- region,
- dst_offset,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueCopyBufferToImage(cl_command_queue command_queue,
- cl_mem src_buffer,
- cl_mem dst_image,
- size_t src_offset,
- const size_t * dst_origin,
- const size_t * region,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueCopyBufferToImage(
- command_queue,
- src_buffer,
- dst_image,
- src_offset,
- dst_origin,
- region,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY void * CL_API_CALL
-clEnqueueMapBuffer(cl_command_queue command_queue,
- cl_mem buffer,
- cl_bool blocking_map,
- cl_map_flags map_flags,
- size_t offset,
- size_t cb,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueMapBuffer(
- command_queue,
- buffer,
- blocking_map,
- map_flags,
- offset,
- cb,
- num_events_in_wait_list,
- event_wait_list,
- event,
- errcode_ret);
-}
-
-CL_API_ENTRY void * CL_API_CALL
-clEnqueueMapImage(cl_command_queue command_queue,
- cl_mem image,
- cl_bool blocking_map,
- cl_map_flags map_flags,
- const size_t * origin,
- const size_t * region,
- size_t * image_row_pitch,
- size_t * image_slice_pitch,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueMapImage(
- command_queue,
- image,
- blocking_map,
- map_flags,
- origin,
- region,
- image_row_pitch,
- image_slice_pitch,
- num_events_in_wait_list,
- event_wait_list,
- event,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueUnmapMemObject(cl_command_queue command_queue,
- cl_mem memobj,
- void * mapped_ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueUnmapMemObject(
- command_queue,
- memobj,
- mapped_ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueMigrateMemObjects(cl_command_queue command_queue,
- cl_uint num_mem_objects,
- const cl_mem * mem_objects,
- cl_mem_migration_flags flags,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueMigrateMemObjects(
- command_queue,
- num_mem_objects,
- mem_objects,
- flags,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueNDRangeKernel(cl_command_queue command_queue,
- cl_kernel kernel,
- cl_uint work_dim,
- const size_t * global_work_offset,
- const size_t * global_work_size,
- const size_t * local_work_size,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueNDRangeKernel(
- command_queue,
- kernel,
- work_dim,
- global_work_offset,
- global_work_size,
- local_work_size,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueTask(cl_command_queue command_queue,
- cl_kernel kernel,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueTask(
- command_queue,
- kernel,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueNativeKernel(cl_command_queue command_queue,
- void (CL_CALLBACK * user_func)(void *),
- void * args,
- size_t cb_args,
- cl_uint num_mem_objects,
- const cl_mem * mem_list,
- const void ** args_mem_loc,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueNativeKernel(
- command_queue,
- user_func,
- args,
- cb_args,
- num_mem_objects,
- mem_list,
- args_mem_loc,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueMarkerWithWaitList(cl_command_queue command_queue,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueMarkerWithWaitList(
- command_queue,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueBarrierWithWaitList(cl_command_queue command_queue,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueBarrierWithWaitList(
- command_queue,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY void * CL_API_CALL
-clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,
- const char * function_name) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
-
- // make sure the ICD is initialized
- khrIcdInitialize();
-
- // return any ICD-aware extensions
-
- // Most extensions, including multi-vendor KHR and EXT extensions,
- // do not need to be ICD-aware and do not require any ICD loader
- // modifications. The KHR and EXT extensions below were added for
- // backwards compatibility only.
- #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
-
- // Functions supporting the creation of OpenCL Memory Objects
- // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
-
- // cl_khr_gl_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
-
- // cl_khr_gl_event
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
-
-#if defined(_WIN32)
- // cl_khr_d3d10_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
- // cl_khr_d3d11_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
- // cl_khr_dx9_media_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
-#endif
-
- // cl_ext_device_fission
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
-
- /* cl_khr_egl_image */
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
-
- /* cl_khr_egl_event */
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
-
- /* cl_khr_sub_groups */
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
-
- #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD
-
- // This is not an ICD-aware extension, so call into the implementation
- // to get the extension function address.
-
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL);
- return platform->dispatch->clGetExtensionFunctionAddressForPlatform(
- platform,
- function_name);
-}
-
-// Deprecated APIs
-CL_API_ENTRY cl_int CL_API_CALL
-clSetCommandQueueProperty(cl_command_queue command_queue,
- cl_command_queue_properties properties,
- cl_bool enable,
- cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clSetCommandQueueProperty(
- command_queue,
- properties,
- enable,
- old_properties);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clCreateSubDevicesEXT(
- cl_device_id in_device,
- const cl_device_partition_property_ext * partition_properties,
- cl_uint num_entries,
- cl_device_id * out_devices,
- cl_uint * num_devices) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
- return in_device->dispatch->clCreateSubDevicesEXT(
- in_device,
- partition_properties,
- num_entries,
- out_devices,
- num_devices);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clRetainDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return device->dispatch->clRetainDeviceEXT(device);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clReleaseDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return device->dispatch->clReleaseDeviceEXT(device);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateImage2D(cl_context context,
- cl_mem_flags flags,
- const cl_image_format * image_format,
- size_t image_width,
- size_t image_height,
- size_t image_row_pitch,
- void * host_ptr,
- cl_int * errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateImage2D(
- context,
- flags,
- image_format,
- image_width,
- image_height,
- image_row_pitch,
- host_ptr,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateImage3D(cl_context context,
- cl_mem_flags flags,
- const cl_image_format * image_format,
- size_t image_width,
- size_t image_height,
- size_t image_depth,
- size_t image_row_pitch,
- size_t image_slice_pitch,
- void * host_ptr,
- cl_int * errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateImage3D(
- context,
- flags,
- image_format,
- image_width,
- image_height,
- image_depth,
- image_row_pitch,
- image_slice_pitch,
- host_ptr,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- return CL_SUCCESS;
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueMarker(cl_command_queue command_queue,
- cl_event * event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueMarker(
- command_queue,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueWaitForEvents(cl_command_queue command_queue,
- cl_uint num_events,
- const cl_event * event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueWaitForEvents(
- command_queue,
- num_events,
- event_list);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueBarrier(cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueBarrier(command_queue);
-}
-
-CL_API_ENTRY void * CL_API_CALL
-clGetExtensionFunctionAddress(const char *function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
-{
- size_t function_name_length = 0;
- KHRicdVendor* vendor = NULL;
-
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
-
- // make sure the ICD is initialized
- khrIcdInitialize();
- function_name_length = strlen(function_name);
-
- // return any ICD-aware extensions
-
- // Most extensions, including multi-vendor KHR and EXT extensions,
- // do not need to be ICD-aware and do not require any ICD loader
- // modifications. The KHR and EXT extensions below were added for
- // backwards compatibility only.
- #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
-
- // Functions supporting the creation of OpenCL Memory Objects
- // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
-
- // cl_khr_gl_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
-
- // cl_khr_gl_event
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
-
-#if defined(_WIN32)
- // cl_khr_d3d10_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
- // cl_khr_d3d11_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
- // cl_khr_dx9_media_sharing
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
-#endif
-
- // cl_ext_device_fission
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
-
- /* cl_khr_egl_image */
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
-
- /* cl_khr_egl_event */
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
-
- /* cl_khr_sub_groups */
- CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
-
- #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD
-
- // fall back to vendor extension detection
- for (vendor = khrIcdVendors; vendor; vendor = vendor->next)
- {
- size_t vendor_suffix_length = strlen(vendor->suffix);
- if (vendor_suffix_length <= function_name_length && vendor_suffix_length > 0)
- {
- const char *function_suffix = function_name+function_name_length-vendor_suffix_length;
- if (!strcmp(function_suffix, vendor->suffix) )
- {
- return vendor->clGetExtensionFunctionAddress(function_name);
- }
- }
- }
- return NULL;
-}
-
-// GL and other APIs
-CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(
- cl_context context,
- cl_mem_flags flags,
- cl_GLuint bufobj,
- int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromGLBuffer(
- context,
- flags,
- bufobj,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
- cl_context context,
- cl_mem_flags flags,
- cl_GLenum target,
- cl_GLint miplevel,
- cl_GLuint texture,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromGLTexture(
- context,
- flags,
- target,
- miplevel,
- texture,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
- cl_context context,
- cl_mem_flags flags,
- cl_GLenum target,
- cl_GLint miplevel,
- cl_GLuint texture,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromGLTexture2D(
- context,
- flags,
- target,
- miplevel,
- texture,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
- cl_context context,
- cl_mem_flags flags,
- cl_GLenum target,
- cl_GLint miplevel,
- cl_GLuint texture,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromGLTexture3D(
- context,
- flags,
- target,
- miplevel,
- texture,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(
- cl_context context,
- cl_mem_flags flags,
- cl_GLuint renderbuffer,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromGLRenderbuffer(
- context,
- flags,
- renderbuffer,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(
- cl_mem memobj,
- cl_gl_object_type * gl_object_type,
- cl_GLuint * gl_object_name) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
- return memobj->dispatch->clGetGLObjectInfo(
- memobj,
- gl_object_type,
- gl_object_name);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
- cl_mem memobj,
- cl_gl_texture_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
- return memobj->dispatch->clGetGLTextureInfo(
- memobj,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem * mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueAcquireGLObjects(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem * mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_1_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReleaseGLObjects(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-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) CL_API_SUFFIX__VERSION_1_0
-{
- cl_platform_id platform = NULL;
-
- // initialize the platforms (in case they have not been already)
- khrIcdInitialize();
-
- // determine the platform to use from the properties specified
- khrIcdContextPropertiesGetPlatform(properties, &platform);
-
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clGetGLContextInfoKHR(
- properties,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
- cl_context context,
- cl_GLsync sync,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateEventFromGLsyncKHR(
- context,
- sync,
- errcode_ret);
-}
-
-#if defined(_WIN32)
-/*
- *
- * cl_d3d10_sharing_khr
- *
- */
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetDeviceIDsFromD3D10KHR(
- cl_platform_id platform,
- cl_d3d10_device_source_khr d3d_device_source,
- void *d3d_object,
- cl_d3d10_device_set_khr d3d_device_set,
- cl_uint num_entries,
- cl_device_id *devices,
- cl_uint *num_devices)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
- platform,
- d3d_device_source,
- d3d_object,
- d3d_device_set,
- num_entries,
- devices,
- num_devices);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromD3D10BufferKHR(
- cl_context context,
- cl_mem_flags flags,
- ID3D10Buffer *resource,
- cl_int *errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromD3D10BufferKHR(
- context,
- flags,
- resource,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromD3D10Texture2DKHR(
- cl_context context,
- cl_mem_flags flags,
- ID3D10Texture2D * resource,
- UINT subresource,
- cl_int * errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromD3D10Texture2DKHR(
- context,
- flags,
- resource,
- subresource,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromD3D10Texture3DKHR(
- cl_context context,
- cl_mem_flags flags,
- ID3D10Texture3D *resource,
- UINT subresource,
- cl_int *errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromD3D10Texture3DKHR(
- context,
- flags,
- resource,
- subresource,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueAcquireD3D10ObjectsKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem *mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event *event_wait_list,
- cl_event *event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReleaseD3D10ObjectsKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem *mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event *event_wait_list,
- cl_event *event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-/*
- *
- * cl_d3d11_sharing_khr
- *
- */
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetDeviceIDsFromD3D11KHR(
- cl_platform_id platform,
- cl_d3d11_device_source_khr d3d_device_source,
- void * d3d_object,
- cl_d3d11_device_set_khr d3d_device_set,
- cl_uint num_entries,
- cl_device_id * devices,
- cl_uint * num_devices)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
- platform,
- d3d_device_source,
- d3d_object,
- d3d_device_set,
- num_entries,
- devices,
- num_devices);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromD3D11BufferKHR(
- cl_context context,
- cl_mem_flags flags,
- ID3D11Buffer * resource,
- cl_int * errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromD3D11BufferKHR(
- context,
- flags,
- resource,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromD3D11Texture2DKHR(
- cl_context context,
- cl_mem_flags flags,
- ID3D11Texture2D * resource,
- UINT subresource,
- cl_int * errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromD3D11Texture2DKHR(
- context,
- flags,
- resource,
- subresource,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromD3D11Texture3DKHR(
- cl_context context,
- cl_mem_flags flags,
- ID3D11Texture3D * resource,
- UINT subresource,
- cl_int * errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromD3D11Texture3DKHR(
- context,
- flags,
- resource,
- subresource,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueAcquireD3D11ObjectsKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem * mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReleaseD3D11ObjectsKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem * mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-/*
- *
- * cl_khr_dx9_media_sharing
- *
- */
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetDeviceIDsFromDX9MediaAdapterKHR(
- cl_platform_id platform,
- cl_uint num_media_adapters,
- cl_dx9_media_adapter_type_khr * media_adapters_type,
- void * media_adapters,
- cl_dx9_media_adapter_set_khr media_adapter_set,
- cl_uint num_entries,
- cl_device_id * devices,
- cl_uint * num_devices)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
- return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
- platform,
- num_media_adapters,
- media_adapters_type,
- media_adapters,
- media_adapter_set,
- num_entries,
- devices,
- num_devices);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromDX9MediaSurfaceKHR(
- cl_context context,
- cl_mem_flags flags,
- cl_dx9_media_adapter_type_khr adapter_type,
- void * surface_info,
- cl_uint plane,
- cl_int * errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromDX9MediaSurfaceKHR(
- context,
- flags,
- adapter_type,
- surface_info,
- plane,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueAcquireDX9MediaSurfacesKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem * mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReleaseDX9MediaSurfacesKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem * mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
#endif
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetEventCallback(
- cl_event event,
- cl_int command_exec_callback_type,
- void (CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *),
- void *user_data) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
- return event->dispatch->clSetEventCallback(
- event,
- command_exec_callback_type,
- pfn_notify,
- user_data);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateSubBuffer(
- cl_mem buffer,
- cl_mem_flags flags,
- cl_buffer_create_type buffer_create_type,
- const void * buffer_create_info,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
- return buffer->dispatch->clCreateSubBuffer(
- buffer,
- flags,
- buffer_create_type,
- buffer_create_info,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetMemObjectDestructorCallback(
- cl_mem memobj,
- void (CL_CALLBACK * pfn_notify)( cl_mem, void*),
- void * user_data ) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
- return memobj->dispatch->clSetMemObjectDestructorCallback(
- memobj,
- pfn_notify,
- user_data);
-}
-
-CL_API_ENTRY cl_event CL_API_CALL
-clCreateUserEvent(
- cl_context context,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateUserEvent(
- context,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetUserEventStatus(
- cl_event event,
- cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
- return event->dispatch->clSetUserEventStatus(
- event,
- execution_status);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreateFromEGLImageKHR(
- cl_context context,
- CLeglDisplayKHR display,
- CLeglImageKHR image,
- cl_mem_flags flags,
- const cl_egl_image_properties_khr *properties,
- cl_int *errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateFromEGLImageKHR(
- context,
- display,
- image,
- flags,
- properties,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueAcquireEGLObjectsKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem *mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event *event_wait_list,
- cl_event *event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueReleaseEGLObjectsKHR(
- cl_command_queue command_queue,
- cl_uint num_objects,
- const cl_mem *mem_objects,
- cl_uint num_events_in_wait_list,
- const cl_event *event_wait_list,
- cl_event *event)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
- command_queue,
- num_objects,
- mem_objects,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-/* cl_khr_egl_event */
-CL_API_ENTRY cl_event CL_API_CALL
-clCreateEventFromEGLSyncKHR(
- cl_context context,
- CLeglSyncKHR sync,
- CLeglDisplayKHR display,
- cl_int *errcode_ret)
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateEventFromEGLSyncKHR(
- context,
- sync,
- display,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_command_queue CL_API_CALL
-clCreateCommandQueueWithProperties(
- cl_context context,
- cl_device_id device,
- const cl_queue_properties * properties,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateCommandQueueWithProperties(
- context,
- device,
- properties,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_mem CL_API_CALL
-clCreatePipe(
- cl_context context,
- cl_mem_flags flags,
- cl_uint pipe_packet_size,
- cl_uint pipe_max_packets,
- const cl_pipe_properties * properties,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreatePipe(
- context,
- flags,
- pipe_packet_size,
- pipe_max_packets,
- properties,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetPipeInfo(
- cl_mem pipe,
- cl_pipe_info param_name,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
- return pipe->dispatch->clGetPipeInfo(
- pipe,
- param_name,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY void * CL_API_CALL
-clSVMAlloc(
- cl_context context,
- cl_svm_mem_flags flags,
- size_t size,
- cl_uint alignment) CL_API_SUFFIX__VERSION_2_0
-{
- if (!context) {
- return NULL;
- }
- return context->dispatch->clSVMAlloc(
- context,
- flags,
- size,
- alignment);
-}
-
-CL_API_ENTRY void CL_API_CALL
-clSVMFree(
- cl_context context,
- void * svm_pointer) CL_API_SUFFIX__VERSION_2_0
-{
- if (!context || !svm_pointer) {
- return;
- }
- context->dispatch->clSVMFree(
- context,
- svm_pointer);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueSVMFree(
- cl_command_queue command_queue,
- cl_uint num_svm_pointers,
- void* svm_pointers[],
- void (CL_CALLBACK* pfn_free_func)(
- cl_command_queue queue,
- cl_uint num_svm_pointers,
- void* svm_pointers[],
- void* user_data),
- void* user_data,
- cl_uint num_events_in_wait_list,
- const cl_event* event_wait_list,
- cl_event* event) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueSVMFree(
- command_queue,
- num_svm_pointers,
- svm_pointers,
- pfn_free_func,
- user_data,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueSVMMemcpy(
- cl_command_queue command_queue,
- cl_bool blocking_copy,
- void * dst_ptr,
- const void * src_ptr,
- size_t size,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueSVMMemcpy(
- command_queue,
- blocking_copy,
- dst_ptr,
- src_ptr,
- size,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueSVMMemFill(
- cl_command_queue command_queue,
- void * svm_ptr,
- const void * pattern,
- size_t pattern_size,
- size_t size,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueSVMMemFill(
- command_queue,
- svm_ptr,
- pattern,
- pattern_size,
- size,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueSVMMap(
- cl_command_queue command_queue,
- cl_bool blocking_map,
- cl_map_flags flags,
- void * svm_ptr,
- size_t size,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueSVMMap(
- command_queue,
- blocking_map,
- flags,
- svm_ptr,
- size,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueSVMUnmap(
- cl_command_queue command_queue,
- void * svm_ptr,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueSVMUnmap(
- command_queue,
- svm_ptr,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_sampler CL_API_CALL
-clCreateSamplerWithProperties(
- cl_context context,
- const cl_sampler_properties * sampler_properties,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateSamplerWithProperties(
- context,
- sampler_properties,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetKernelArgSVMPointer(
- cl_kernel kernel,
- cl_uint arg_index,
- const void * arg_value) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clSetKernelArgSVMPointer(
- kernel,
- arg_index,
- arg_value);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetKernelExecInfo(
- cl_kernel kernel,
- cl_kernel_exec_info param_name,
- size_t param_value_size,
- const void * param_value) CL_API_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- return kernel->dispatch->clSetKernelExecInfo(
- kernel,
- param_name,
- param_value_size,
- param_value);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetKernelSubGroupInfoKHR(
- cl_kernel in_kernel,
- cl_device_id in_device,
- cl_kernel_sub_group_info param_name,
- size_t input_value_size,
- const void * input_value,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
- return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
- in_kernel,
- in_device,
- param_name,
- input_value_size,
- input_value,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clSetDefaultDeviceCommandQueue(
- cl_context context,
- cl_device_id device,
- cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return context->dispatch->clSetDefaultDeviceCommandQueue(
- context,
- device,
- command_queue);
-}
-
-CL_API_ENTRY cl_program CL_API_CALL
-clCreateProgramWithIL(
- cl_context context,
- const void * il,
- size_t length,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
- return context->dispatch->clCreateProgramWithIL(
- context,
- il,
- length,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetKernelSubGroupInfo(
- cl_kernel kernel,
- cl_device_id device,
- cl_kernel_sub_group_info param_name,
- size_t input_value_size,
- const void * input_value,
- size_t param_value_size,
- void * param_value,
- size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return kernel->dispatch->clGetKernelSubGroupInfo(
- kernel,
- device,
- param_name,
- input_value_size,
- input_value,
- param_value_size,
- param_value,
- param_value_size_ret);
-}
-
-CL_API_ENTRY cl_kernel CL_API_CALL
-clCloneKernel(
- cl_kernel source_kernel,
- cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
- return source_kernel->dispatch->clCloneKernel(
- source_kernel,
- errcode_ret);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clEnqueueSVMMigrateMem(
- cl_command_queue command_queue,
- cl_uint num_svm_pointers,
- const void ** svm_pointers,
- const size_t * sizes,
- cl_mem_migration_flags flags,
- cl_uint num_events_in_wait_list,
- const cl_event * event_wait_list,
- cl_event * event) CL_API_SUFFIX__VERSION_2_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
- return command_queue->dispatch->clEnqueueSVMMigrateMem(
- command_queue,
- num_svm_pointers,
- svm_pointers,
- sizes,
- flags,
- num_events_in_wait_list,
- event_wait_list,
- event);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetDeviceAndHostTimer(
- cl_device_id device,
- cl_ulong * device_timestamp,
- cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return device->dispatch->clGetDeviceAndHostTimer(
- device,
- device_timestamp,
- host_timestamp);
-}
-
-CL_API_ENTRY cl_int CL_API_CALL
-clGetHostTimer(
- cl_device_id device,
- cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1
-{
- KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
- return device->dispatch->clGetHostTimer(
- device,
- host_timestamp);
-}
-
-
--- /dev/null
+/*
+ * Copyright (c) 2012-2020 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+#include "icd_dispatch.h"
+#include "icd.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Core APIs:
+
+CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(
+ cl_platform_id platform,
+ cl_platform_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clGetPlatformInfo(
+ platform,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(
+ cl_platform_id platform,
+ cl_device_type device_type,
+ cl_uint num_entries,
+ cl_device_id* devices,
+ cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clGetDeviceIDs(
+ platform,
+ device_type,
+ num_entries,
+ devices,
+ num_devices);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo(
+ cl_device_id device,
+ cl_device_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+ return device->dispatch->clGetDeviceInfo(
+ device,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_context CL_API_CALL clCreateContext(
+ const cl_context_properties* properties,
+ cl_uint num_devices,
+ const cl_device_id* devices,
+ void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
+ void* user_data,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ if (num_devices == 0 || devices == NULL) {
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE);
+ }
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
+ return devices[0]->dispatch->clCreateContext(
+ properties,
+ num_devices,
+ devices,
+ pfn_notify,
+ user_data,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType(
+ const cl_context_properties* properties,
+ cl_device_type device_type,
+ void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
+ void* user_data,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ cl_platform_id platform = NULL;
+ khrIcdInitialize();
+ khrIcdContextPropertiesGetPlatform(properties, &platform);
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clCreateContextFromType(
+ properties,
+ device_type,
+ pfn_notify,
+ user_data,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainContext(
+ cl_context context) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clRetainContext(
+ context);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseContext(
+ cl_context context) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clReleaseContext(
+ context);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo(
+ cl_context context,
+ cl_context_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clGetContextInfo(
+ context,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue(
+ cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clRetainCommandQueue(
+ command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue(
+ cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clReleaseCommandQueue(
+ command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(
+ cl_command_queue command_queue,
+ cl_command_queue_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clGetCommandQueueInfo(
+ command_queue,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(
+ cl_context context,
+ cl_mem_flags flags,
+ size_t size,
+ void* host_ptr,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateBuffer(
+ context,
+ flags,
+ size,
+ host_ptr,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(
+ cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+ return memobj->dispatch->clRetainMemObject(
+ memobj);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject(
+ cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+ return memobj->dispatch->clReleaseMemObject(
+ memobj);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_mem_object_type image_type,
+ cl_uint num_entries,
+ cl_image_format* image_formats,
+ cl_uint* num_image_formats) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clGetSupportedImageFormats(
+ context,
+ flags,
+ image_type,
+ num_entries,
+ image_formats,
+ num_image_formats);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo(
+ cl_mem memobj,
+ cl_mem_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+ return memobj->dispatch->clGetMemObjectInfo(
+ memobj,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo(
+ cl_mem image,
+ cl_image_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
+ return image->dispatch->clGetImageInfo(
+ image,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainSampler(
+ cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
+ return sampler->dispatch->clRetainSampler(
+ sampler);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler(
+ cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
+ return sampler->dispatch->clReleaseSampler(
+ sampler);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo(
+ cl_sampler sampler,
+ cl_sampler_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
+ return sampler->dispatch->clGetSamplerInfo(
+ sampler,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(
+ cl_context context,
+ cl_uint count,
+ const char** strings,
+ const size_t* lengths,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateProgramWithSource(
+ context,
+ count,
+ strings,
+ lengths,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary(
+ cl_context context,
+ cl_uint num_devices,
+ const cl_device_id* device_list,
+ const size_t* lengths,
+ const unsigned char** binaries,
+ cl_int* binary_status,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateProgramWithBinary(
+ context,
+ num_devices,
+ device_list,
+ lengths,
+ binaries,
+ binary_status,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainProgram(
+ cl_program program) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clRetainProgram(
+ program);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram(
+ cl_program program) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clReleaseProgram(
+ program);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(
+ cl_program program,
+ cl_uint num_devices,
+ const cl_device_id* device_list,
+ const char* options,
+ void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+ void* user_data) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clBuildProgram(
+ program,
+ num_devices,
+ device_list,
+ options,
+ pfn_notify,
+ user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo(
+ cl_program program,
+ cl_program_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clGetProgramInfo(
+ program,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo(
+ cl_program program,
+ cl_device_id device,
+ cl_program_build_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clGetProgramBuildInfo(
+ program,
+ device,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(
+ cl_program program,
+ const char* kernel_name,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clCreateKernel(
+ program,
+ kernel_name,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram(
+ cl_program program,
+ cl_uint num_kernels,
+ cl_kernel* kernels,
+ cl_uint* num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clCreateKernelsInProgram(
+ program,
+ num_kernels,
+ kernels,
+ num_kernels_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainKernel(
+ cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clRetainKernel(
+ kernel);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel(
+ cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clReleaseKernel(
+ kernel);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(
+ cl_kernel kernel,
+ cl_uint arg_index,
+ size_t arg_size,
+ const void* arg_value) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clSetKernelArg(
+ kernel,
+ arg_index,
+ arg_size,
+ arg_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo(
+ cl_kernel kernel,
+ cl_kernel_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clGetKernelInfo(
+ kernel,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(
+ cl_kernel kernel,
+ cl_device_id device,
+ cl_kernel_work_group_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clGetKernelWorkGroupInfo(
+ kernel,
+ device,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(
+ cl_uint num_events,
+ const cl_event* event_list) CL_API_SUFFIX__VERSION_1_0
+{
+ if (num_events == 0 || event_list == NULL) {
+ return CL_INVALID_VALUE;
+ }
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT);
+ return event_list[0]->dispatch->clWaitForEvents(
+ num_events,
+ event_list);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo(
+ cl_event event,
+ cl_event_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+ return event->dispatch->clGetEventInfo(
+ event,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainEvent(
+ cl_event event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+ return event->dispatch->clRetainEvent(
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(
+ cl_event event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+ return event->dispatch->clReleaseEvent(
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(
+ cl_event event,
+ cl_profiling_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+ return event->dispatch->clGetEventProfilingInfo(
+ event,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clFlush(
+ cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clFlush(
+ command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clFinish(
+ cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clFinish(
+ command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(
+ cl_command_queue command_queue,
+ cl_mem buffer,
+ cl_bool blocking_read,
+ size_t offset,
+ size_t size,
+ void* ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReadBuffer(
+ command_queue,
+ buffer,
+ blocking_read,
+ offset,
+ size,
+ ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(
+ cl_command_queue command_queue,
+ cl_mem buffer,
+ cl_bool blocking_write,
+ size_t offset,
+ size_t size,
+ const void* ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueWriteBuffer(
+ command_queue,
+ buffer,
+ blocking_write,
+ offset,
+ size,
+ ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(
+ cl_command_queue command_queue,
+ cl_mem src_buffer,
+ cl_mem dst_buffer,
+ size_t src_offset,
+ size_t dst_offset,
+ size_t size,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueCopyBuffer(
+ command_queue,
+ src_buffer,
+ dst_buffer,
+ src_offset,
+ dst_offset,
+ size,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(
+ cl_command_queue command_queue,
+ cl_mem image,
+ cl_bool blocking_read,
+ const size_t* origin,
+ const size_t* region,
+ size_t row_pitch,
+ size_t slice_pitch,
+ void* ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReadImage(
+ command_queue,
+ image,
+ blocking_read,
+ origin,
+ region,
+ row_pitch,
+ slice_pitch,
+ ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(
+ cl_command_queue command_queue,
+ cl_mem image,
+ cl_bool blocking_write,
+ const size_t* origin,
+ const size_t* region,
+ size_t input_row_pitch,
+ size_t input_slice_pitch,
+ const void* ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueWriteImage(
+ command_queue,
+ image,
+ blocking_write,
+ origin,
+ region,
+ input_row_pitch,
+ input_slice_pitch,
+ ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(
+ cl_command_queue command_queue,
+ cl_mem src_image,
+ cl_mem dst_image,
+ const size_t* src_origin,
+ const size_t* dst_origin,
+ const size_t* region,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueCopyImage(
+ command_queue,
+ src_image,
+ dst_image,
+ src_origin,
+ dst_origin,
+ region,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(
+ cl_command_queue command_queue,
+ cl_mem src_image,
+ cl_mem dst_buffer,
+ const size_t* src_origin,
+ const size_t* region,
+ size_t dst_offset,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueCopyImageToBuffer(
+ command_queue,
+ src_image,
+ dst_buffer,
+ src_origin,
+ region,
+ dst_offset,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(
+ cl_command_queue command_queue,
+ cl_mem src_buffer,
+ cl_mem dst_image,
+ size_t src_offset,
+ const size_t* dst_origin,
+ const size_t* region,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueCopyBufferToImage(
+ command_queue,
+ src_buffer,
+ dst_image,
+ src_offset,
+ dst_origin,
+ region,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer(
+ cl_command_queue command_queue,
+ cl_mem buffer,
+ cl_bool blocking_map,
+ cl_map_flags map_flags,
+ size_t offset,
+ size_t size,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueMapBuffer(
+ command_queue,
+ buffer,
+ blocking_map,
+ map_flags,
+ offset,
+ size,
+ num_events_in_wait_list,
+ event_wait_list,
+ event,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage(
+ cl_command_queue command_queue,
+ cl_mem image,
+ cl_bool blocking_map,
+ cl_map_flags map_flags,
+ const size_t* origin,
+ const size_t* region,
+ size_t* image_row_pitch,
+ size_t* image_slice_pitch,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueMapImage(
+ command_queue,
+ image,
+ blocking_map,
+ map_flags,
+ origin,
+ region,
+ image_row_pitch,
+ image_slice_pitch,
+ num_events_in_wait_list,
+ event_wait_list,
+ event,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject(
+ cl_command_queue command_queue,
+ cl_mem memobj,
+ void* mapped_ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueUnmapMemObject(
+ command_queue,
+ memobj,
+ mapped_ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(
+ cl_command_queue command_queue,
+ cl_kernel kernel,
+ cl_uint work_dim,
+ const size_t* global_work_offset,
+ const size_t* global_work_size,
+ const size_t* local_work_size,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueNDRangeKernel(
+ command_queue,
+ kernel,
+ work_dim,
+ global_work_offset,
+ global_work_size,
+ local_work_size,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel(
+ cl_command_queue command_queue,
+ void (CL_CALLBACK* user_func)(void*),
+ void* args,
+ size_t cb_args,
+ cl_uint num_mem_objects,
+ const cl_mem* mem_list,
+ const void** args_mem_loc,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueNativeKernel(
+ command_queue,
+ user_func,
+ args,
+ cb_args,
+ num_mem_objects,
+ mem_list,
+ args_mem_loc,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty(
+ cl_command_queue command_queue,
+ cl_command_queue_properties properties,
+ cl_bool enable,
+ cl_command_queue_properties* old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clSetCommandQueueProperty(
+ command_queue,
+ properties,
+ enable,
+ old_properties);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D(
+ cl_context context,
+ cl_mem_flags flags,
+ const cl_image_format* image_format,
+ size_t image_width,
+ size_t image_height,
+ size_t image_row_pitch,
+ void* host_ptr,
+ cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateImage2D(
+ context,
+ flags,
+ image_format,
+ image_width,
+ image_height,
+ image_row_pitch,
+ host_ptr,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D(
+ cl_context context,
+ cl_mem_flags flags,
+ const cl_image_format* image_format,
+ size_t image_width,
+ size_t image_height,
+ size_t image_depth,
+ size_t image_row_pitch,
+ size_t image_slice_pitch,
+ void* host_ptr,
+ cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateImage3D(
+ context,
+ flags,
+ image_format,
+ image_width,
+ image_height,
+ image_depth,
+ image_row_pitch,
+ image_slice_pitch,
+ host_ptr,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker(
+ cl_command_queue command_queue,
+ cl_event* event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueMarker(
+ command_queue,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents(
+ cl_command_queue command_queue,
+ cl_uint num_events,
+ const cl_event* event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueWaitForEvents(
+ command_queue,
+ num_events,
+ event_list);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier(
+ cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueBarrier(
+ command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler(
+ void ) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ // Nothing!
+ return CL_SUCCESS;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(
+ cl_context context,
+ cl_device_id device,
+ cl_command_queue_properties properties,
+ cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateCommandQueue(
+ context,
+ device,
+ properties,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler(
+ cl_context context,
+ cl_bool normalized_coords,
+ cl_addressing_mode addressing_mode,
+ cl_filter_mode filter_mode,
+ cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateSampler(
+ context,
+ normalized_coords,
+ addressing_mode,
+ filter_mode,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask(
+ cl_command_queue command_queue,
+ cl_kernel kernel,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueTask(
+ command_queue,
+ kernel,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(
+ cl_mem buffer,
+ cl_mem_flags flags,
+ cl_buffer_create_type buffer_create_type,
+ const void* buffer_create_info,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
+ return buffer->dispatch->clCreateSubBuffer(
+ buffer,
+ flags,
+ buffer_create_type,
+ buffer_create_info,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback(
+ cl_mem memobj,
+ void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data),
+ void* user_data) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+ return memobj->dispatch->clSetMemObjectDestructorCallback(
+ memobj,
+ pfn_notify,
+ user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent(
+ cl_context context,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateUserEvent(
+ context,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus(
+ cl_event event,
+ cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+ return event->dispatch->clSetUserEventStatus(
+ event,
+ execution_status);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(
+ cl_event event,
+ cl_int command_exec_callback_type,
+ void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data),
+ void* user_data) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+ return event->dispatch->clSetEventCallback(
+ event,
+ command_exec_callback_type,
+ pfn_notify,
+ user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect(
+ cl_command_queue command_queue,
+ cl_mem buffer,
+ cl_bool blocking_read,
+ const size_t* buffer_offset,
+ const size_t* host_offset,
+ const size_t* region,
+ size_t buffer_row_pitch,
+ size_t buffer_slice_pitch,
+ size_t host_row_pitch,
+ size_t host_slice_pitch,
+ void* ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReadBufferRect(
+ command_queue,
+ buffer,
+ blocking_read,
+ buffer_offset,
+ host_offset,
+ region,
+ buffer_row_pitch,
+ buffer_slice_pitch,
+ host_row_pitch,
+ host_slice_pitch,
+ ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect(
+ cl_command_queue command_queue,
+ cl_mem buffer,
+ cl_bool blocking_write,
+ const size_t* buffer_offset,
+ const size_t* host_offset,
+ const size_t* region,
+ size_t buffer_row_pitch,
+ size_t buffer_slice_pitch,
+ size_t host_row_pitch,
+ size_t host_slice_pitch,
+ const void* ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueWriteBufferRect(
+ command_queue,
+ buffer,
+ blocking_write,
+ buffer_offset,
+ host_offset,
+ region,
+ buffer_row_pitch,
+ buffer_slice_pitch,
+ host_row_pitch,
+ host_slice_pitch,
+ ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect(
+ cl_command_queue command_queue,
+ cl_mem src_buffer,
+ cl_mem dst_buffer,
+ const size_t* src_origin,
+ const size_t* dst_origin,
+ const size_t* region,
+ size_t src_row_pitch,
+ size_t src_slice_pitch,
+ size_t dst_row_pitch,
+ size_t dst_slice_pitch,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueCopyBufferRect(
+ command_queue,
+ src_buffer,
+ dst_buffer,
+ src_origin,
+ dst_origin,
+ region,
+ src_row_pitch,
+ src_slice_pitch,
+ dst_row_pitch,
+ dst_slice_pitch,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(
+ cl_device_id in_device,
+ const cl_device_partition_property* properties,
+ cl_uint num_devices,
+ cl_device_id* out_devices,
+ cl_uint* num_devices_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
+ return in_device->dispatch->clCreateSubDevices(
+ in_device,
+ properties,
+ num_devices,
+ out_devices,
+ num_devices_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainDevice(
+ cl_device_id device) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+ return device->dispatch->clRetainDevice(
+ device);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice(
+ cl_device_id device) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+ return device->dispatch->clReleaseDevice(
+ device);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(
+ cl_context context,
+ cl_mem_flags flags,
+ const cl_image_format* image_format,
+ const cl_image_desc* image_desc,
+ void* host_ptr,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateImage(
+ context,
+ flags,
+ image_format,
+ image_desc,
+ host_ptr,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(
+ cl_context context,
+ cl_uint num_devices,
+ const cl_device_id* device_list,
+ const char* kernel_names,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateProgramWithBuiltInKernels(
+ context,
+ num_devices,
+ device_list,
+ kernel_names,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clCompileProgram(
+ cl_program program,
+ cl_uint num_devices,
+ const cl_device_id* device_list,
+ const char* options,
+ cl_uint num_input_headers,
+ const cl_program* input_headers,
+ const char** header_include_names,
+ void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+ void* user_data) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clCompileProgram(
+ program,
+ num_devices,
+ device_list,
+ options,
+ num_input_headers,
+ input_headers,
+ header_include_names,
+ pfn_notify,
+ user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(
+ cl_context context,
+ cl_uint num_devices,
+ const cl_device_id* device_list,
+ const char* options,
+ cl_uint num_input_programs,
+ const cl_program* input_programs,
+ void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+ void* user_data,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clLinkProgram(
+ context,
+ num_devices,
+ device_list,
+ options,
+ num_input_programs,
+ input_programs,
+ pfn_notify,
+ user_data,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler(
+ cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clUnloadPlatformCompiler(
+ platform);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(
+ cl_kernel kernel,
+ cl_uint arg_index,
+ cl_kernel_arg_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clGetKernelArgInfo(
+ kernel,
+ arg_index,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(
+ cl_command_queue command_queue,
+ cl_mem buffer,
+ const void* pattern,
+ size_t pattern_size,
+ size_t offset,
+ size_t size,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueFillBuffer(
+ command_queue,
+ buffer,
+ pattern,
+ pattern_size,
+ offset,
+ size,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(
+ cl_command_queue command_queue,
+ cl_mem image,
+ const void* fill_color,
+ const size_t* origin,
+ const size_t* region,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueFillImage(
+ command_queue,
+ image,
+ fill_color,
+ origin,
+ region,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(
+ cl_command_queue command_queue,
+ cl_uint num_mem_objects,
+ const cl_mem* mem_objects,
+ cl_mem_migration_flags flags,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueMigrateMemObjects(
+ command_queue,
+ num_mem_objects,
+ mem_objects,
+ flags,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(
+ cl_command_queue command_queue,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueMarkerWithWaitList(
+ command_queue,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(
+ cl_command_queue command_queue,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueBarrierWithWaitList(
+ command_queue,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(
+ cl_context context,
+ cl_device_id device,
+ const cl_queue_properties* properties,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateCommandQueueWithProperties(
+ context,
+ device,
+ properties,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_uint pipe_packet_size,
+ cl_uint pipe_max_packets,
+ const cl_pipe_properties* properties,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreatePipe(
+ context,
+ flags,
+ pipe_packet_size,
+ pipe_max_packets,
+ properties,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo(
+ cl_mem pipe,
+ cl_pipe_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
+ return pipe->dispatch->clGetPipeInfo(
+ pipe,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY void* CL_API_CALL clSVMAlloc(
+ cl_context context,
+ cl_svm_mem_flags flags,
+ size_t size,
+ cl_uint alignment) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, NULL);
+ return context->dispatch->clSVMAlloc(
+ context,
+ flags,
+ size,
+ alignment);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY void CL_API_CALL clSVMFree(
+ cl_context context,
+ void* svm_pointer) CL_API_SUFFIX__VERSION_2_0
+{
+ if (context == NULL) return;
+ context->dispatch->clSVMFree(
+ context,
+ svm_pointer);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties(
+ cl_context context,
+ const cl_sampler_properties* sampler_properties,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateSamplerWithProperties(
+ context,
+ sampler_properties,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(
+ cl_kernel kernel,
+ cl_uint arg_index,
+ const void* arg_value) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clSetKernelArgSVMPointer(
+ kernel,
+ arg_index,
+ arg_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo(
+ cl_kernel kernel,
+ cl_kernel_exec_info param_name,
+ size_t param_value_size,
+ const void* param_value) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clSetKernelExecInfo(
+ kernel,
+ param_name,
+ param_value_size,
+ param_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree(
+ cl_command_queue command_queue,
+ cl_uint num_svm_pointers,
+ void* svm_pointers[],
+ void (CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers, void* svm_pointers[], void* user_data),
+ void* user_data,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueSVMFree(
+ command_queue,
+ num_svm_pointers,
+ svm_pointers,
+ pfn_free_func,
+ user_data,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy(
+ cl_command_queue command_queue,
+ cl_bool blocking_copy,
+ void* dst_ptr,
+ const void* src_ptr,
+ size_t size,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueSVMMemcpy(
+ command_queue,
+ blocking_copy,
+ dst_ptr,
+ src_ptr,
+ size,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(
+ cl_command_queue command_queue,
+ void* svm_ptr,
+ const void* pattern,
+ size_t pattern_size,
+ size_t size,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueSVMMemFill(
+ command_queue,
+ svm_ptr,
+ pattern,
+ pattern_size,
+ size,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(
+ cl_command_queue command_queue,
+ cl_bool blocking_map,
+ cl_map_flags flags,
+ void* svm_ptr,
+ size_t size,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueSVMMap(
+ command_queue,
+ blocking_map,
+ flags,
+ svm_ptr,
+ size,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap(
+ cl_command_queue command_queue,
+ void* svm_ptr,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueSVMUnmap(
+ command_queue,
+ svm_ptr,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(
+ cl_context context,
+ cl_device_id device,
+ cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clSetDefaultDeviceCommandQueue(
+ context,
+ device,
+ command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer(
+ cl_device_id device,
+ cl_ulong* device_timestamp,
+ cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+ return device->dispatch->clGetDeviceAndHostTimer(
+ device,
+ device_timestamp,
+ host_timestamp);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer(
+ cl_device_id device,
+ cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+ return device->dispatch->clGetHostTimer(
+ device,
+ host_timestamp);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL(
+ cl_context context,
+ const void* il,
+ size_t length,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateProgramWithIL(
+ context,
+ il,
+ length,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel(
+ cl_kernel source_kernel,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
+ return source_kernel->dispatch->clCloneKernel(
+ source_kernel,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo(
+ cl_kernel kernel,
+ cl_device_id device,
+ cl_kernel_sub_group_info param_name,
+ size_t input_value_size,
+ const void* input_value,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+ return kernel->dispatch->clGetKernelSubGroupInfo(
+ kernel,
+ device,
+ param_name,
+ input_value_size,
+ input_value,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem(
+ cl_command_queue command_queue,
+ cl_uint num_svm_pointers,
+ const void** svm_pointers,
+ const size_t* sizes,
+ cl_mem_migration_flags flags,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_2_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueSVMMigrateMem(
+ command_queue,
+ num_svm_pointers,
+ svm_pointers,
+ sizes,
+ flags,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant(
+ cl_program program,
+ cl_uint spec_id,
+ size_t spec_size,
+ const void* spec_value) CL_API_SUFFIX__VERSION_2_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clSetProgramSpecializationConstant(
+ program,
+ spec_id,
+ spec_size,
+ spec_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback(
+ cl_program program,
+ void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+ void* user_data) CL_EXT_SUFFIX__VERSION_2_2_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+ return program->dispatch->clSetProgramReleaseCallback(
+ program,
+ pfn_notify,
+ user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_ext_device_fission
+
+CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT(
+ cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+ return device->dispatch->clReleaseDeviceEXT(
+ device);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT(
+ cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+ return device->dispatch->clRetainDeviceEXT(
+ device);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT(
+ cl_device_id in_device,
+ const cl_device_partition_property_ext* properties,
+ cl_uint num_entries,
+ cl_device_id* out_devices,
+ cl_uint* num_devices) CL_EXT_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
+ return in_device->dispatch->clCreateSubDevicesEXT(
+ in_device,
+ properties,
+ num_entries,
+ out_devices,
+ num_devices);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_d3d10_sharing
+
+#if defined(_WIN32)
+
+CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR(
+ cl_platform_id platform,
+ cl_d3d10_device_source_khr d3d_device_source,
+ void* d3d_object,
+ cl_d3d10_device_set_khr d3d_device_set,
+ cl_uint num_entries,
+ cl_device_id* devices,
+ cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
+ platform,
+ d3d_device_source,
+ d3d_object,
+ d3d_device_set,
+ num_entries,
+ devices,
+ num_devices);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(
+ cl_context context,
+ cl_mem_flags flags,
+ ID3D10Buffer* resource,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromD3D10BufferKHR(
+ context,
+ flags,
+ resource,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(
+ cl_context context,
+ cl_mem_flags flags,
+ ID3D10Texture2D* resource,
+ UINT subresource,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromD3D10Texture2DKHR(
+ context,
+ flags,
+ resource,
+ subresource,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(
+ cl_context context,
+ cl_mem_flags flags,
+ ID3D10Texture3D* resource,
+ UINT subresource,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromD3D10Texture3DKHR(
+ context,
+ flags,
+ resource,
+ subresource,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+#endif // defined(_WIN32)
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_d3d11_sharing
+
+#if defined(_WIN32)
+
+CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR(
+ cl_platform_id platform,
+ cl_d3d11_device_source_khr d3d_device_source,
+ void* d3d_object,
+ cl_d3d11_device_set_khr d3d_device_set,
+ cl_uint num_entries,
+ cl_device_id* devices,
+ cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
+ platform,
+ d3d_device_source,
+ d3d_object,
+ d3d_device_set,
+ num_entries,
+ devices,
+ num_devices);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(
+ cl_context context,
+ cl_mem_flags flags,
+ ID3D11Buffer* resource,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromD3D11BufferKHR(
+ context,
+ flags,
+ resource,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(
+ cl_context context,
+ cl_mem_flags flags,
+ ID3D11Texture2D* resource,
+ UINT subresource,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromD3D11Texture2DKHR(
+ context,
+ flags,
+ resource,
+ subresource,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(
+ cl_context context,
+ cl_mem_flags flags,
+ ID3D11Texture3D* resource,
+ UINT subresource,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromD3D11Texture3DKHR(
+ context,
+ flags,
+ resource,
+ subresource,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+#endif // defined(_WIN32)
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_dx9_media_sharing
+
+#if defined(_WIN32)
+
+CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR(
+ cl_platform_id platform,
+ cl_uint num_media_adapters,
+ cl_dx9_media_adapter_type_khr* media_adapter_type,
+ void* media_adapters,
+ cl_dx9_media_adapter_set_khr media_adapter_set,
+ cl_uint num_entries,
+ cl_device_id* devices,
+ cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
+ platform,
+ num_media_adapters,
+ media_adapter_type,
+ media_adapters,
+ media_adapter_set,
+ num_entries,
+ devices,
+ num_devices);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_dx9_media_adapter_type_khr adapter_type,
+ void* surface_info,
+ cl_uint plane,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromDX9MediaSurfaceKHR(
+ context,
+ flags,
+ adapter_type,
+ surface_info,
+ plane,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+#endif // defined(_WIN32)
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_egl_event
+
+CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR(
+ cl_context context,
+ CLeglSyncKHR sync,
+ CLeglDisplayKHR display,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateEventFromEGLSyncKHR(
+ context,
+ sync,
+ display,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_egl_image
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR(
+ cl_context context,
+ CLeglDisplayKHR egldisplay,
+ CLeglImageKHR eglimage,
+ cl_mem_flags flags,
+ const cl_egl_image_properties_khr* properties,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromEGLImageKHR(
+ context,
+ egldisplay,
+ eglimage,
+ flags,
+ properties,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_gl_event
+
+CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
+ cl_context context,
+ cl_GLsync sync,
+ cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateEventFromGLsyncKHR(
+ context,
+ sync,
+ errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_gl_sharing
+
+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) CL_API_SUFFIX__VERSION_1_0
+{
+ cl_platform_id platform = NULL;
+ khrIcdInitialize();
+ khrIcdContextPropertiesGetPlatform(properties, &platform);
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+ return platform->dispatch->clGetGLContextInfoKHR(
+ properties,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_GLuint bufobj,
+ int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromGLBuffer(
+ context,
+ flags,
+ bufobj,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_GLenum target,
+ cl_GLint miplevel,
+ cl_GLuint texture,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromGLTexture(
+ context,
+ flags,
+ target,
+ miplevel,
+ texture,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_GLenum target,
+ cl_GLint miplevel,
+ cl_GLuint texture,
+ cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromGLTexture2D(
+ context,
+ flags,
+ target,
+ miplevel,
+ texture,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_GLenum target,
+ cl_GLint miplevel,
+ cl_GLuint texture,
+ cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromGLTexture3D(
+ context,
+ flags,
+ target,
+ miplevel,
+ texture,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(
+ cl_context context,
+ cl_mem_flags flags,
+ cl_GLuint renderbuffer,
+ cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+ return context->dispatch->clCreateFromGLRenderbuffer(
+ context,
+ flags,
+ renderbuffer,
+ errcode_ret);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(
+ cl_mem memobj,
+ cl_gl_object_type* gl_object_type,
+ cl_GLuint* gl_object_name) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+ return memobj->dispatch->clGetGLObjectInfo(
+ memobj,
+ gl_object_type,
+ gl_object_name);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
+ cl_mem memobj,
+ cl_gl_texture_info param_name,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+ return memobj->dispatch->clGetGLTextureInfo(
+ memobj,
+ param_name,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueAcquireGLObjects(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
+ cl_command_queue command_queue,
+ cl_uint num_objects,
+ const cl_mem* mem_objects,
+ cl_uint num_events_in_wait_list,
+ const cl_event* event_wait_list,
+ cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+ return command_queue->dispatch->clEnqueueReleaseGLObjects(
+ command_queue,
+ num_objects,
+ mem_objects,
+ num_events_in_wait_list,
+ event_wait_list,
+ event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_subgroups
+
+CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR(
+ cl_kernel in_kernel,
+ cl_device_id in_device,
+ cl_kernel_sub_group_info param_name,
+ size_t input_value_size,
+ const void* input_value,
+ size_t param_value_size,
+ void* param_value,
+ size_t* param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0_DEPRECATED
+{
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
+ return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
+ in_kernel,
+ in_device,
+ param_name,
+ input_value_size,
+ input_value,
+ param_value_size,
+ param_value,
+ param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
#define OPENCL_ICD_LOADER_VERSION_MAJOR 2
#define OPENCL_ICD_LOADER_VERSION_MINOR 2
-#define OPENCL_ICD_LOADER_VERSION_REV 8
+#define OPENCL_ICD_LOADER_VERSION_REV 9
#ifdef RC_INVOKED
--- /dev/null
+# OpenCL ICD Loader Code Generation
+
+## Introduction
+
+In order to ease maintenance and enable faster development of related OpenCL ICD loader features, the OpenCL ICD loader API dispatch functions are generated from the OpenCL XML machine readable grammar.
+
+## Dependencies
+
+The API dispatch functions are generated using Python [Mako Templates](https://www.makotemplates.org/).
+
+In most cases, after installing Python for your platform, Mako may be installed using:
+
+```sh
+$ pip install Mako
+```
+
+## Making Changes
+
+Most changes only require modifications to the Mako templates.
+Small changes modifying syntax or layout are simple and straightforward.
+Occasionally more complicated changes will be required, say when a new API is added that is unlike any previous API, but this should be rare.
+
+The Python script should only need to be modified if additional information needs to be propagated from the XML file into the Mako template itself.
+
+## Generating Files
+
+Files for the OpenCL ICD loader may be generated by executing the `gen_loader.py` script.
+
+The script requires the `cl.xml` machine readable grammar.
+By default, the script searches for `cl.xml` in the current directory.
+The latest version of `cl.xml` may be found in the Khronos OpenCL-Docs repo [here](https://github.com/KhronosGroup/OpenCL-Docs/blob/master/xml/cl.xml).
+
+The output from the script is placed in the current directory by default, to allow easy comparisons between the generated files and the current files.
+After the generated files are evaluated, they should be manually copied into the source tree.
+These steps may be automated in the future.
--- /dev/null
+#!/usr/bin/python3
+
+# Copyright (c) 2020 The Khronos Group Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mako.template import Template
+
+from collections import OrderedDict
+from collections import namedtuple
+
+import argparse
+import sys
+import urllib
+import xml.etree.ElementTree as etree
+import urllib.request
+
+# parse_xml - Helper function to parse the XML file from a URL or local file.
+def parse_xml(path):
+ file = urllib.request.urlopen(path) if path.startswith("http") else open(path, 'r')
+ with file:
+ tree = etree.parse(file)
+ return tree
+
+# noneStr - returns string argument, or "" if argument is None.
+def noneStr(s):
+ if s:
+ return s
+ return ""
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+
+ # To pull the latest registry file from GitHub, pass:
+ # -registry "https://raw.githubusercontent.com/KhronosGroup/OpenCL-Registry/master/xml/cl.xml"
+
+ parser.add_argument('-registry', action='store',
+ default='cl.xml',
+ help='Use specified registry file instead of cl.xml')
+ parser.add_argument('-o', action='store', dest='directory',
+ default='.',
+ help='Create target and related files in specified directory')
+
+ args = parser.parse_args()
+
+ specpath = args.registry
+
+ print('Parsing XML file from: ' + specpath)
+ spec = parse_xml(specpath)
+
+ # Generate the API function signatures dictionary:
+ apisigs = OrderedDict()
+ ApiSignature = namedtuple('ApiSignature', 'Name RetType Params Suffix')
+ ApiParam = namedtuple('ApiParam', 'Type TypeEnd Name')
+ print('Generating API signatures dictionary...')
+ for command in spec.findall('commands/command'):
+ suffix = noneStr(command.get('suffix'))
+ proto = command.find('proto')
+ ret = noneStr(proto.text)
+ name = ""
+ params = ""
+ for elem in proto:
+ if elem.tag == 'name':
+ name = noneStr(elem.text) + noneStr(elem.tail)
+ else:
+ ret = ret + noneStr(elem.text) + noneStr(elem.tail)
+ ret = ret.strip()
+ name = name.strip()
+
+ plist = []
+ for param in command.findall('param'):
+ ptype = noneStr(param.text)
+ ptypeend = ""
+ pname = ""
+ for elem in param:
+ if elem.tag == 'name':
+ pname = noneStr(elem.text)
+ ptypeend = noneStr(elem.tail)
+ else:
+ ptype = ptype + noneStr(elem.text) + noneStr(elem.tail)
+ ptype = ptype.strip()
+ ptypeend = ptypeend.strip()
+ pname = pname.strip()
+ plist.append(ApiParam(ptype, ptypeend, pname))
+ apisigs[name] = ApiSignature(name, ret, plist, suffix)
+
+ # Generate the core API dictionary:
+ coreapis = OrderedDict()
+ print('Generating core API dictionary...')
+ for feature in spec.findall('feature'):
+ version = noneStr(feature.get('name'))
+
+ alist = []
+ for function in feature.findall('require/command'):
+ name = function.get('name')
+ alist.append(apisigs[name])
+ coreapis[version] = alist
+
+ # Generate the extensions API dictionary:
+ extapis = OrderedDict()
+ print('Generating API extensions dictionary...')
+ for feature in spec.findall('extensions/extension'):
+ extension = noneStr(feature.get('name'))
+
+ alist = []
+ for function in feature.findall('require/command'):
+ name = function.get('name')
+ alist.append(apisigs[name])
+ extapis[extension] = alist
+
+ try:
+ # Create the loader cpp file from the API dictionary:
+ test = open(args.directory + '/icd_dispatch_generated.c', 'wb')
+ icd_dispatch_generated_template = Template(filename='icd_dispatch_generated.c.mako')
+ test.write(
+ icd_dispatch_generated_template.render_unicode(
+ spec=spec,
+ apisigs=apisigs,
+ coreapis=coreapis,
+ extapis=extapis).
+ encode('utf-8', 'replace'))
+ except:
+ traceback = RichTraceback()
+ for (filename, lineno, function, line) in traceback.traceback:
+ print('%s(%s) : error in %s' % (filename, lineno, function))
+ print(' ', line)
+ print('%s: %s' % (str(traceback.error.__class__.__name__), traceback.error))
--- /dev/null
+<%
+# APIs to skip - they need to be done "manually":
+apiskip = {
+ 'clGetPlatformIDs', # to query platforms
+ 'clGetExtensionFunctionAddress', # to return ICD-aware extensions
+ 'clGetExtensionFunctionAddressForPlatform', # to return ICD-aware extensions
+ 'clCreateBufferWithProperties', # only until OpenCL 3.0 is final
+ 'clCreateImageWithProperties', # only until OpenCL 3.0 is final
+ 'clSetContextDestructorCallback', # only until OpenCL 3.0 is final
+ }
+
+# Handles, and mappings to errors when handles are invalid:
+apihandles = {
+ 'cl_command_queue' : 'CL_INVALID_COMMAND_QUEUE',
+ 'cl_context' : 'CL_INVALID_CONTEXT',
+ 'cl_device_id' : 'CL_INVALID_DEVICE',
+ 'cl_event' : 'CL_INVALID_EVENT',
+ 'cl_kernel' : 'CL_INVALID_KERNEL',
+ 'cl_mem' : 'CL_INVALID_MEM_OBJECT',
+ 'cl_platform_id' : 'CL_INVALID_PLATFORM',
+ 'cl_program' : 'CL_INVALID_PROGRAM',
+ 'cl_sampler' : 'CL_INVALID_SAMPLER',
+ }
+%>/*
+ * Copyright (c) 2012-2020 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+#include "icd_dispatch.h"
+#include "icd.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Core APIs:
+%for apis in coreapis.values():
+%for api in apis:
+%if not api.Name in apiskip:
+<%
+ handle = api.Params[0]
+ if handle.Type in apihandles:
+ invalid = apihandles[handle.Type]
+ else:
+ invalid = 'NULL'
+%>
+CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
+%for i, param in enumerate(api.Params):
+% if i < len(api.Params)-1:
+ ${param.Type} ${param.Name}${param.TypeEnd},
+% else:
+ ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix}
+% endif
+%endfor
+{
+%if api.RetType in apihandles or api.RetType == "void*":
+## clCreateContext is a special case, since it calls through
+## the dispatch table via the first "device":
+% if api.Name == "clCreateContext":
+ if (${api.Params[1].Name} == 0 || ${api.Params[2].Name} == NULL) {
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE);
+ }
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(${api.Params[2].Name}[0], CL_INVALID_DEVICE);
+## clCreateContextFromType is a special case, since it calls
+## through a platform passed via properties:
+% elif api.Name == "clCreateContextFromType":
+ cl_platform_id platform = NULL;
+ khrIcdInitialize();
+ khrIcdContextPropertiesGetPlatform(properties, &platform);
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
+## These APIs are special cases because they return a void*, but
+## do not nave an errcode_ret:
+% elif api.Name == "clSVMAlloc" or api.Name == "clGetExtensionFunctionAddressForPlatform":
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${handle.Name}, NULL);
+% else:
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(${handle.Name}, ${invalid});
+% endif
+%elif api.Name == "clSVMFree":
+## clSVMFree has no return value or errcode_ret:
+ if (${handle.Name} == NULL) return;
+## clWaitForEvents is a special case, since it calls through
+## the dispatch table via the first "event":
+%elif api.Name == "clWaitForEvents":
+ if (${api.Params[0].Name} == 0 || ${api.Params[1].Name} == NULL) {
+ return CL_INVALID_VALUE;
+ }
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${api.Params[1].Name}[0], CL_INVALID_EVENT);
+%elif api.Name == "clUnloadCompiler":
+ // Nothing!
+%else:
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${handle.Name}, ${invalid});
+%endif
+%if api.Name == "clCreateContext":
+ return ${api.Params[2].Name}[0]->dispatch->${api.Name}(
+%elif api.Name == "clWaitForEvents":
+ return ${api.Params[1].Name}[0]->dispatch->${api.Name}(
+%elif api.Name == "clCreateContextFromType":
+ return platform->dispatch->${api.Name}(
+%elif api.Name == "clSVMFree":
+ ${handle.Name}->dispatch->${api.Name}(
+%elif api.Name == "clUnloadCompiler":
+ return CL_SUCCESS;
+%else:
+ return ${handle.Name}->dispatch->${api.Name}(
+%endif:
+%for i, param in enumerate(api.Params):
+% if i < len(api.Params)-1:
+ ${param.Name},
+% elif param.Name: # for clUnloadCompiler
+ ${param.Name});
+% endif
+%endfor
+}
+
+///////////////////////////////////////////////////////////////////////////////
+%endif
+%endfor
+%endfor
+<%
+icdextensions = [
+ 'cl_ext_device_fission',
+ 'cl_khr_d3d10_sharing',
+ 'cl_khr_d3d11_sharing',
+ 'cl_khr_dx9_media_sharing',
+ 'cl_khr_egl_event',
+ 'cl_khr_egl_image',
+ 'cl_khr_gl_event',
+ 'cl_khr_gl_sharing',
+ 'cl_khr_subgroups'
+ ]
+win32extensions = {
+ 'cl_khr_d3d10_sharing',
+ 'cl_khr_d3d11_sharing',
+ 'cl_khr_dx9_media_sharing',
+ }
+%>
+%for extension in icdextensions:
+<%
+ apis = extapis[extension]
+%>// ${extension}
+%if extension in win32extensions:
+
+#if defined(_WIN32)
+%endif
+%for api in apis:
+<%
+ handle = api.Params[0]
+ if handle.Type in apihandles:
+ invalid = apihandles[handle.Type]
+ else:
+ invalid = 'NULL'
+%>
+CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
+%for i, param in enumerate(api.Params):
+% if i < len(api.Params)-1:
+ ${param.Type} ${param.Name}${param.TypeEnd},
+% else:
+ ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix}
+% endif
+%endfor
+{
+%if api.RetType in apihandles or api.RetType == "void*":
+% if False:
+ // api.Name == "clXXX": # There are currently no API special cases here.
+% else:
+ KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(${handle.Name}, ${invalid});
+% endif
+%else:
+% if api.Name == "clGetGLContextInfoKHR":
+ cl_platform_id platform = NULL;
+ khrIcdInitialize();
+ khrIcdContextPropertiesGetPlatform(properties, &platform);
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+% else:
+ KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${handle.Name}, ${invalid});
+% endif
+%endif
+%if api.Name == "clGetGLContextInfoKHR":
+ return platform->dispatch->${api.Name}(
+%else:
+ return ${handle.Name}->dispatch->${api.Name}(
+%endif
+%for i, param in enumerate(api.Params):
+% if i < len(api.Params)-1:
+ ${param.Name},
+% elif param.Name: # for clUnloadCompiler
+ ${param.Name});
+% endif
+%endfor
+}
+%endfor
+
+%if extension in win32extensions:
+#endif // defined(_WIN32)
+
+%endif
+///////////////////////////////////////////////////////////////////////////////
+
+%endfor
+#ifdef __cplusplus
+}
+#endif
projects / platform / upstream / OpenCL-ICD-Loader.git / commitdiff