| /* |
| * 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: |
| #if defined(CL_ENABLE_LAYERS) |
| extern CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs_disp( |
| cl_uint num_entries, |
| cl_platform_id* platforms, |
| cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0; |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetPlatformInfo( |
| platform, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetDeviceIDs( |
| platform, |
| device_type, |
| num_entries, |
| devices, |
| num_devices); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clGetDeviceIDs( |
| platform, |
| device_type, |
| num_entries, |
| devices, |
| num_devices); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetDeviceInfo( |
| device, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateContext( |
| properties, |
| num_devices, |
| devices, |
| pfn_notify, |
| user_data, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_context CL_API_CALL clCreateContext_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| khrIcdInitialize(); |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateContextFromType( |
| properties, |
| device_type, |
| pfn_notify, |
| user_data, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| cl_platform_id platform = NULL; |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType_disp( |
| 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 |
| { |
| khrIcdInitialize(); |
| cl_platform_id platform = NULL; |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainContext( |
| cl_context context) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainContext( |
| context); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clRetainContext( |
| context); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainContext_disp( |
| cl_context context) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clRetainContext( |
| context); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseContext( |
| cl_context context) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseContext( |
| context); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clReleaseContext( |
| context); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseContext_disp( |
| cl_context context) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clReleaseContext( |
| context); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetContextInfo( |
| context, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue( |
| cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainCommandQueue( |
| command_queue); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clRetainCommandQueue( |
| command_queue); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue( |
| cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseCommandQueue( |
| command_queue); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clReleaseCommandQueue( |
| command_queue); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetCommandQueueInfo( |
| command_queue, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateBuffer( |
| context, |
| flags, |
| size, |
| host_ptr, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateBuffer( |
| context, |
| flags, |
| size, |
| host_ptr, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject( |
| cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainMemObject( |
| memobj); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clRetainMemObject( |
| memobj); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject( |
| cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseMemObject( |
| memobj); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clReleaseMemObject( |
| memobj); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetSupportedImageFormats( |
| context, |
| flags, |
| image_type, |
| num_entries, |
| image_formats, |
| num_image_formats); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetMemObjectInfo( |
| memobj, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetImageInfo( |
| image, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainSampler( |
| cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainSampler( |
| sampler); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); |
| return sampler->dispatch->clRetainSampler( |
| sampler); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainSampler_disp( |
| cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); |
| return sampler->dispatch->clRetainSampler( |
| sampler); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler( |
| cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseSampler( |
| sampler); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); |
| return sampler->dispatch->clReleaseSampler( |
| sampler); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler_disp( |
| cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); |
| return sampler->dispatch->clReleaseSampler( |
| sampler); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetSamplerInfo( |
| sampler, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateProgramWithSource( |
| context, |
| count, |
| strings, |
| lengths, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateProgramWithSource( |
| context, |
| count, |
| strings, |
| lengths, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateProgramWithBinary( |
| context, |
| num_devices, |
| device_list, |
| lengths, |
| binaries, |
| binary_status, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainProgram( |
| cl_program program) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainProgram( |
| program); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clRetainProgram( |
| program); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainProgram_disp( |
| cl_program program) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clRetainProgram( |
| program); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram( |
| cl_program program) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseProgram( |
| program); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clReleaseProgram( |
| program); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram_disp( |
| cl_program program) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clReleaseProgram( |
| program); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clBuildProgram( |
| program, |
| num_devices, |
| device_list, |
| options, |
| pfn_notify, |
| user_data); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clBuildProgram( |
| program, |
| num_devices, |
| device_list, |
| options, |
| pfn_notify, |
| user_data); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clBuildProgram_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetProgramInfo( |
| program, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetProgramBuildInfo( |
| program, |
| device, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateKernel( |
| program, |
| kernel_name, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clCreateKernel( |
| program, |
| kernel_name, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateKernelsInProgram( |
| program, |
| num_kernels, |
| kernels, |
| num_kernels_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clCreateKernelsInProgram( |
| program, |
| num_kernels, |
| kernels, |
| num_kernels_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainKernel( |
| cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainKernel( |
| kernel); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clRetainKernel( |
| kernel); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainKernel_disp( |
| cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clRetainKernel( |
| kernel); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel( |
| cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseKernel( |
| kernel); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clReleaseKernel( |
| kernel); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel_disp( |
| cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clReleaseKernel( |
| kernel); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetKernelArg( |
| kernel, |
| arg_index, |
| arg_size, |
| arg_value); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clSetKernelArg( |
| kernel, |
| arg_index, |
| arg_size, |
| arg_value); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetKernelInfo( |
| kernel, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetKernelWorkGroupInfo( |
| kernel, |
| device, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clWaitForEvents( |
| num_events, |
| event_list); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetEventInfo( |
| event, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainEvent( |
| cl_event event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainEvent( |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clRetainEvent( |
| event); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainEvent_disp( |
| 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 // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent( |
| cl_event event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseEvent( |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clReleaseEvent( |
| event); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent_disp( |
| cl_event event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clReleaseEvent( |
| event); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetEventProfilingInfo( |
| event, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clFlush( |
| cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clFlush( |
| command_queue); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clFlush( |
| command_queue); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clFlush_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clFinish( |
| cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clFinish( |
| command_queue); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clFinish( |
| command_queue); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clFinish_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueReadBuffer( |
| command_queue, |
| buffer, |
| blocking_read, |
| offset, |
| size, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueWriteBuffer( |
| command_queue, |
| buffer, |
| blocking_write, |
| offset, |
| size, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueCopyBuffer( |
| command_queue, |
| src_buffer, |
| dst_buffer, |
| src_offset, |
| dst_offset, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueReadImage( |
| command_queue, |
| image, |
| blocking_read, |
| origin, |
| region, |
| row_pitch, |
| slice_pitch, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->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); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueCopyImage( |
| command_queue, |
| src_image, |
| dst_image, |
| src_origin, |
| dst_origin, |
| region, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueCopyImageToBuffer( |
| command_queue, |
| src_image, |
| dst_buffer, |
| src_origin, |
| region, |
| dst_offset, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueCopyBufferToImage( |
| command_queue, |
| src_buffer, |
| dst_image, |
| src_offset, |
| dst_origin, |
| region, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueMapBuffer( |
| command_queue, |
| buffer, |
| blocking_map, |
| map_flags, |
| offset, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->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); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueUnmapMemObject( |
| command_queue, |
| memobj, |
| mapped_ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->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); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->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); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetCommandQueueProperty( |
| command_queue, |
| properties, |
| enable, |
| old_properties); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clSetCommandQueueProperty( |
| command_queue, |
| properties, |
| enable, |
| old_properties); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateImage2D( |
| context, |
| flags, |
| image_format, |
| image_width, |
| image_height, |
| image_row_pitch, |
| host_ptr, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateImage3D( |
| context, |
| flags, |
| image_format, |
| image_width, |
| image_height, |
| image_depth, |
| image_row_pitch, |
| image_slice_pitch, |
| host_ptr, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker( |
| cl_command_queue command_queue, |
| cl_event* event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueMarker( |
| command_queue, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueMarker( |
| command_queue, |
| event); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueWaitForEvents( |
| command_queue, |
| num_events, |
| event_list); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueWaitForEvents( |
| command_queue, |
| num_events, |
| event_list); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier( |
| cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueBarrier( |
| command_queue); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueBarrier( |
| command_queue); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler( |
| void ) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clUnloadCompiler( |
| ); |
| #endif // defined(CL_ENABLE_LAYERS) |
| // Nothing! |
| return CL_SUCCESS; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler_disp( |
| void ) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| // Nothing! |
| return CL_SUCCESS; |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress_disp( |
| const char* func_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateCommandQueue( |
| context, |
| device, |
| properties, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateCommandQueue( |
| context, |
| device, |
| properties, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateSampler( |
| context, |
| normalized_coords, |
| addressing_mode, |
| filter_mode, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateSampler( |
| context, |
| normalized_coords, |
| addressing_mode, |
| filter_mode, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueTask( |
| command_queue, |
| kernel, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateSubBuffer( |
| buffer, |
| flags, |
| buffer_create_type, |
| buffer_create_info, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetMemObjectDestructorCallback( |
| memobj, |
| pfn_notify, |
| user_data); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clSetMemObjectDestructorCallback( |
| memobj, |
| pfn_notify, |
| user_data); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent( |
| cl_context context, |
| cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateUserEvent( |
| context, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateUserEvent( |
| context, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus( |
| cl_event event, |
| cl_int execution_status) CL_API_SUFFIX__VERSION_1_1 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetUserEventStatus( |
| event, |
| execution_status); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clSetUserEventStatus( |
| event, |
| execution_status); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetEventCallback( |
| event, |
| command_exec_callback_type, |
| pfn_notify, |
| user_data); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clSetEventCallback( |
| event, |
| command_exec_callback_type, |
| pfn_notify, |
| user_data); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->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); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->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); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->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); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateSubDevices( |
| in_device, |
| properties, |
| num_devices, |
| out_devices, |
| num_devices_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainDevice( |
| cl_device_id device) CL_API_SUFFIX__VERSION_1_2 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainDevice( |
| device); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clRetainDevice( |
| device); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainDevice_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice( |
| cl_device_id device) CL_API_SUFFIX__VERSION_1_2 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseDevice( |
| device); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clReleaseDevice( |
| device); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateImage( |
| context, |
| flags, |
| image_format, |
| image_desc, |
| host_ptr, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateImage( |
| context, |
| flags, |
| image_format, |
| image_desc, |
| host_ptr, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateProgramWithBuiltInKernels( |
| context, |
| num_devices, |
| device_list, |
| kernel_names, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateProgramWithBuiltInKernels( |
| context, |
| num_devices, |
| device_list, |
| kernel_names, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCompileProgram( |
| program, |
| num_devices, |
| device_list, |
| options, |
| num_input_headers, |
| input_headers, |
| header_include_names, |
| pfn_notify, |
| user_data); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clCompileProgram_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clLinkProgram( |
| context, |
| num_devices, |
| device_list, |
| options, |
| num_input_programs, |
| input_programs, |
| pfn_notify, |
| user_data, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_program CL_API_CALL clLinkProgram_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler( |
| cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clUnloadPlatformCompiler( |
| platform); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clUnloadPlatformCompiler( |
| platform); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetKernelArgInfo( |
| kernel, |
| arg_index, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueFillBuffer( |
| command_queue, |
| buffer, |
| pattern, |
| pattern_size, |
| offset, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueFillImage( |
| command_queue, |
| image, |
| fill_color, |
| origin, |
| region, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueMigrateMemObjects( |
| command_queue, |
| num_mem_objects, |
| mem_objects, |
| flags, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueMarkerWithWaitList( |
| command_queue, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueBarrierWithWaitList( |
| command_queue, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp( |
| cl_platform_id platform, |
| const char* func_name) CL_API_SUFFIX__VERSION_1_2; |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateCommandQueueWithProperties( |
| context, |
| device, |
| properties, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateCommandQueueWithProperties( |
| context, |
| device, |
| properties, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreatePipe( |
| context, |
| flags, |
| pipe_packet_size, |
| pipe_max_packets, |
| properties, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetPipeInfo( |
| pipe, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSVMAlloc( |
| context, |
| flags, |
| size, |
| alignment); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, NULL); |
| return context->dispatch->clSVMAlloc( |
| context, |
| flags, |
| size, |
| alignment); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY void* CL_API_CALL clSVMAlloc_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY void CL_API_CALL clSVMFree( |
| cl_context context, |
| void* svm_pointer) CL_API_SUFFIX__VERSION_2_0 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| { |
| khrFirstLayer->dispatch.clSVMFree( |
| context, |
| svm_pointer); |
| return; |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| if (context == NULL) return; |
| context->dispatch->clSVMFree( |
| context, |
| svm_pointer); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY void CL_API_CALL clSVMFree_disp( |
| cl_context context, |
| void* svm_pointer) CL_API_SUFFIX__VERSION_2_0 |
| { |
| if (context == NULL) return; |
| context->dispatch->clSVMFree( |
| context, |
| svm_pointer); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateSamplerWithProperties( |
| context, |
| sampler_properties, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateSamplerWithProperties( |
| context, |
| sampler_properties, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetKernelArgSVMPointer( |
| kernel, |
| arg_index, |
| arg_value); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clSetKernelArgSVMPointer( |
| kernel, |
| arg_index, |
| arg_value); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetKernelExecInfo( |
| kernel, |
| param_name, |
| param_value_size, |
| param_value); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clSetKernelExecInfo( |
| kernel, |
| param_name, |
| param_value_size, |
| param_value); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueSVMFree( |
| command_queue, |
| num_svm_pointers, |
| svm_pointers, |
| pfn_free_func, |
| user_data, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueSVMMemcpy( |
| command_queue, |
| blocking_copy, |
| dst_ptr, |
| src_ptr, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueSVMMemFill( |
| command_queue, |
| svm_ptr, |
| pattern, |
| pattern_size, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueSVMMap( |
| command_queue, |
| blocking_map, |
| flags, |
| svm_ptr, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueSVMUnmap( |
| command_queue, |
| svm_ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetDefaultDeviceCommandQueue( |
| context, |
| device, |
| command_queue); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clSetDefaultDeviceCommandQueue( |
| context, |
| device, |
| command_queue); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetDeviceAndHostTimer( |
| device, |
| device_timestamp, |
| host_timestamp); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clGetDeviceAndHostTimer( |
| device, |
| device_timestamp, |
| host_timestamp); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer( |
| cl_device_id device, |
| cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetHostTimer( |
| device, |
| host_timestamp); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clGetHostTimer( |
| device, |
| host_timestamp); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateProgramWithIL( |
| context, |
| il, |
| length, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateProgramWithIL( |
| context, |
| il, |
| length, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel( |
| cl_kernel source_kernel, |
| cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCloneKernel( |
| source_kernel, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL); |
| return source_kernel->dispatch->clCloneKernel( |
| source_kernel, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetKernelSubGroupInfo( |
| kernel, |
| device, |
| param_name, |
| input_value_size, |
| input_value, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueSVMMigrateMem( |
| command_queue, |
| num_svm_pointers, |
| svm_pointers, |
| sizes, |
| flags, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetProgramSpecializationConstant( |
| program, |
| spec_id, |
| spec_size, |
| spec_value); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clSetProgramSpecializationConstant( |
| program, |
| spec_id, |
| spec_size, |
| spec_value); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetProgramReleaseCallback( |
| program, |
| pfn_notify, |
| user_data); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clSetProgramReleaseCallback( |
| program, |
| pfn_notify, |
| user_data); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clSetContextDestructorCallback( |
| context, |
| pfn_notify, |
| user_data); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clSetContextDestructorCallback( |
| context, |
| pfn_notify, |
| user_data); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback_disp( |
| 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 // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateBufferWithProperties( |
| context, |
| properties, |
| flags, |
| size, |
| host_ptr, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateBufferWithProperties( |
| context, |
| properties, |
| flags, |
| size, |
| host_ptr, |
| errcode_ret); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateImageWithProperties( |
| context, |
| properties, |
| flags, |
| image_format, |
| image_desc, |
| host_ptr, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties_disp( |
| 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 // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // cl_ext_device_fission |
| |
| CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT( |
| cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clReleaseDeviceEXT( |
| device); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clReleaseDeviceEXT( |
| device); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT( |
| cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clRetainDeviceEXT( |
| device); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clRetainDeviceEXT( |
| device); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateSubDevicesEXT( |
| in_device, |
| properties, |
| num_entries, |
| out_devices, |
| num_devices); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetDeviceIDsFromD3D10KHR( |
| platform, |
| d3d_device_source, |
| d3d_object, |
| d3d_device_set, |
| num_entries, |
| devices, |
| num_devices); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromD3D10BufferKHR( |
| context, |
| flags, |
| resource, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D10BufferKHR( |
| context, |
| flags, |
| resource, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromD3D10Texture2DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D10Texture2DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromD3D10Texture3DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D10Texture3DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueAcquireD3D10ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueReleaseD3D10ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_disp( |
| 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(CL_ENABLE_LAYERS) |
| |
| #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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetDeviceIDsFromD3D11KHR( |
| platform, |
| d3d_device_source, |
| d3d_object, |
| d3d_device_set, |
| num_entries, |
| devices, |
| num_devices); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromD3D11BufferKHR( |
| context, |
| flags, |
| resource, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D11BufferKHR( |
| context, |
| flags, |
| resource, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromD3D11Texture2DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D11Texture2DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromD3D11Texture3DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D11Texture3DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueAcquireD3D11ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueReleaseD3D11ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_disp( |
| 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(CL_ENABLE_LAYERS) |
| |
| #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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR( |
| platform, |
| num_media_adapters, |
| media_adapter_type, |
| media_adapters, |
| media_adapter_set, |
| num_entries, |
| devices, |
| num_devices); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromDX9MediaSurfaceKHR( |
| context, |
| flags, |
| adapter_type, |
| surface_info, |
| plane, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromDX9MediaSurfaceKHR( |
| context, |
| flags, |
| adapter_type, |
| surface_info, |
| plane, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueAcquireDX9MediaSurfacesKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueReleaseDX9MediaSurfacesKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_disp( |
| 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(CL_ENABLE_LAYERS) |
| |
| #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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateEventFromEGLSyncKHR( |
| context, |
| sync, |
| display, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateEventFromEGLSyncKHR( |
| context, |
| sync, |
| display, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromEGLImageKHR( |
| context, |
| egldisplay, |
| eglimage, |
| flags, |
| properties, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromEGLImageKHR( |
| context, |
| egldisplay, |
| eglimage, |
| flags, |
| properties, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueAcquireEGLObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueReleaseEGLObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateEventFromGLsyncKHR( |
| context, |
| sync, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateEventFromGLsyncKHR( |
| context, |
| sync, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetGLContextInfoKHR( |
| properties, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| cl_platform_id platform = NULL; |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR_disp( |
| 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; |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromGLBuffer( |
| context, |
| flags, |
| bufobj, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLBuffer( |
| context, |
| flags, |
| bufobj, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromGLTexture( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLTexture( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromGLTexture2D( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLTexture2D( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromGLTexture3D( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLTexture3D( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clCreateFromGLRenderbuffer( |
| context, |
| flags, |
| renderbuffer, |
| errcode_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLRenderbuffer( |
| context, |
| flags, |
| renderbuffer, |
| errcode_ret); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetGLObjectInfo( |
| memobj, |
| gl_object_type, |
| gl_object_name); |
| #endif // defined(CL_ENABLE_LAYERS) |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clGetGLObjectInfo( |
| memobj, |
| gl_object_type, |
| gl_object_name); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetGLTextureInfo( |
| memobj, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueAcquireGLObjects( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clEnqueueReleaseGLObjects( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // 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 |
| { |
| #if defined(CL_ENABLE_LAYERS) |
| if (khrFirstLayer) |
| return khrFirstLayer->dispatch.clGetKernelSubGroupInfoKHR( |
| in_kernel, |
| in_device, |
| param_name, |
| input_value_size, |
| input_value, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| #endif // defined(CL_ENABLE_LAYERS) |
| 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); |
| } |
| #if defined(CL_ENABLE_LAYERS) |
| static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_disp( |
| 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); |
| } |
| #endif // defined(CL_ENABLE_LAYERS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| #if defined(CL_ENABLE_LAYERS) |
| struct _cl_icd_dispatch khrMasterDispatch = { |
| &clGetPlatformIDs_disp, |
| &clGetPlatformInfo_disp, |
| &clGetDeviceIDs_disp, |
| &clGetDeviceInfo_disp, |
| &clCreateContext_disp, |
| &clCreateContextFromType_disp, |
| &clRetainContext_disp, |
| &clReleaseContext_disp, |
| &clGetContextInfo_disp, |
| &clCreateCommandQueue_disp, |
| &clRetainCommandQueue_disp, |
| &clReleaseCommandQueue_disp, |
| &clGetCommandQueueInfo_disp, |
| &clSetCommandQueueProperty_disp, |
| &clCreateBuffer_disp, |
| &clCreateImage2D_disp, |
| &clCreateImage3D_disp, |
| &clRetainMemObject_disp, |
| &clReleaseMemObject_disp, |
| &clGetSupportedImageFormats_disp, |
| &clGetMemObjectInfo_disp, |
| &clGetImageInfo_disp, |
| &clCreateSampler_disp, |
| &clRetainSampler_disp, |
| &clReleaseSampler_disp, |
| &clGetSamplerInfo_disp, |
| &clCreateProgramWithSource_disp, |
| &clCreateProgramWithBinary_disp, |
| &clRetainProgram_disp, |
| &clReleaseProgram_disp, |
| &clBuildProgram_disp, |
| &clUnloadCompiler_disp, |
| &clGetProgramInfo_disp, |
| &clGetProgramBuildInfo_disp, |
| &clCreateKernel_disp, |
| &clCreateKernelsInProgram_disp, |
| &clRetainKernel_disp, |
| &clReleaseKernel_disp, |
| &clSetKernelArg_disp, |
| &clGetKernelInfo_disp, |
| &clGetKernelWorkGroupInfo_disp, |
| &clWaitForEvents_disp, |
| &clGetEventInfo_disp, |
| &clRetainEvent_disp, |
| &clReleaseEvent_disp, |
| &clGetEventProfilingInfo_disp, |
| &clFlush_disp, |
| &clFinish_disp, |
| &clEnqueueReadBuffer_disp, |
| &clEnqueueWriteBuffer_disp, |
| &clEnqueueCopyBuffer_disp, |
| &clEnqueueReadImage_disp, |
| &clEnqueueWriteImage_disp, |
| &clEnqueueCopyImage_disp, |
| &clEnqueueCopyImageToBuffer_disp, |
| &clEnqueueCopyBufferToImage_disp, |
| &clEnqueueMapBuffer_disp, |
| &clEnqueueMapImage_disp, |
| &clEnqueueUnmapMemObject_disp, |
| &clEnqueueNDRangeKernel_disp, |
| &clEnqueueTask_disp, |
| &clEnqueueNativeKernel_disp, |
| &clEnqueueMarker_disp, |
| &clEnqueueWaitForEvents_disp, |
| &clEnqueueBarrier_disp, |
| &clGetExtensionFunctionAddress_disp, |
| &clCreateFromGLBuffer_disp, |
| &clCreateFromGLTexture2D_disp, |
| &clCreateFromGLTexture3D_disp, |
| &clCreateFromGLRenderbuffer_disp, |
| &clGetGLObjectInfo_disp, |
| &clGetGLTextureInfo_disp, |
| &clEnqueueAcquireGLObjects_disp, |
| &clEnqueueReleaseGLObjects_disp, |
| &clGetGLContextInfoKHR_disp, |
| |
| /* cl_khr_d3d10_sharing */ |
| #if defined(_WIN32) |
| &clGetDeviceIDsFromD3D10KHR_disp, |
| &clCreateFromD3D10BufferKHR_disp, |
| &clCreateFromD3D10Texture2DKHR_disp, |
| &clCreateFromD3D10Texture3DKHR_disp, |
| &clEnqueueAcquireD3D10ObjectsKHR_disp, |
| &clEnqueueReleaseD3D10ObjectsKHR_disp, |
| #else |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| #endif |
| |
| /* OpenCL 1.1 */ |
| &clSetEventCallback_disp, |
| &clCreateSubBuffer_disp, |
| &clSetMemObjectDestructorCallback_disp, |
| &clCreateUserEvent_disp, |
| &clSetUserEventStatus_disp, |
| &clEnqueueReadBufferRect_disp, |
| &clEnqueueWriteBufferRect_disp, |
| &clEnqueueCopyBufferRect_disp, |
| |
| /* cl_ext_device_fission */ |
| &clCreateSubDevicesEXT_disp, |
| &clRetainDeviceEXT_disp, |
| &clReleaseDeviceEXT_disp, |
| |
| /* cl_khr_gl_event */ |
| &clCreateEventFromGLsyncKHR_disp, |
| |
| /* OpenCL 1.2 */ |
| &clCreateSubDevices_disp, |
| &clRetainDevice_disp, |
| &clReleaseDevice_disp, |
| &clCreateImage_disp, |
| &clCreateProgramWithBuiltInKernels_disp, |
| &clCompileProgram_disp, |
| &clLinkProgram_disp, |
| &clUnloadPlatformCompiler_disp, |
| &clGetKernelArgInfo_disp, |
| &clEnqueueFillBuffer_disp, |
| &clEnqueueFillImage_disp, |
| &clEnqueueMigrateMemObjects_disp, |
| &clEnqueueMarkerWithWaitList_disp, |
| &clEnqueueBarrierWithWaitList_disp, |
| &clGetExtensionFunctionAddressForPlatform_disp, |
| &clCreateFromGLTexture_disp, |
| |
| /* cl_khr_d3d11_sharing */ |
| #if defined(_WIN32) |
| &clGetDeviceIDsFromD3D11KHR_disp, |
| &clCreateFromD3D11BufferKHR_disp, |
| &clCreateFromD3D11Texture2DKHR_disp, |
| &clCreateFromD3D11Texture3DKHR_disp, |
| &clCreateFromDX9MediaSurfaceKHR_disp, |
| &clEnqueueAcquireD3D11ObjectsKHR_disp, |
| &clEnqueueReleaseD3D11ObjectsKHR_disp, |
| #else |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| NULL, |
| #endif |
| |
| /* cl_khr_dx9_media_sharing */ |
| #if defined(_WIN32) |
| &clGetDeviceIDsFromDX9MediaAdapterKHR_disp, |
| &clEnqueueAcquireDX9MediaSurfacesKHR_disp, |
| &clEnqueueReleaseDX9MediaSurfacesKHR_disp, |
| #else |
| NULL, |
| NULL, |
| NULL, |
| #endif |
| |
| /* cl_khr_egl_image */ |
| &clCreateFromEGLImageKHR_disp, |
| &clEnqueueAcquireEGLObjectsKHR_disp, |
| &clEnqueueReleaseEGLObjectsKHR_disp, |
| |
| /* cl_khr_egl_event */ |
| &clCreateEventFromEGLSyncKHR_disp, |
| |
| /* OpenCL 2.0 */ |
| &clCreateCommandQueueWithProperties_disp, |
| &clCreatePipe_disp, |
| &clGetPipeInfo_disp, |
| &clSVMAlloc_disp, |
| &clSVMFree_disp, |
| &clEnqueueSVMFree_disp, |
| &clEnqueueSVMMemcpy_disp, |
| &clEnqueueSVMMemFill_disp, |
| &clEnqueueSVMMap_disp, |
| &clEnqueueSVMUnmap_disp, |
| &clCreateSamplerWithProperties_disp, |
| &clSetKernelArgSVMPointer_disp, |
| &clSetKernelExecInfo_disp, |
| |
| /* cl_khr_sub_groups */ |
| &clGetKernelSubGroupInfoKHR_disp, |
| |
| /* OpenCL 2.1 */ |
| &clCloneKernel_disp, |
| &clCreateProgramWithIL_disp, |
| &clEnqueueSVMMigrateMem_disp, |
| &clGetDeviceAndHostTimer_disp, |
| &clGetHostTimer_disp, |
| &clGetKernelSubGroupInfo_disp, |
| &clSetDefaultDeviceCommandQueue_disp, |
| |
| /* OpenCL 2.2 */ |
| &clSetProgramReleaseCallback_disp, |
| &clSetProgramSpecializationConstant_disp, |
| |
| /* OpenCL 3.0 */ |
| &clCreateBufferWithProperties_disp, |
| &clCreateImageWithProperties_disp, |
| &clSetContextDestructorCallback_disp |
| }; |
| #endif // defined(CL_ENABLE_LAYERS) |
| #ifdef __cplusplus |
| } |
| #endif |