| /* |
| * Copyright (c) 2012-2019 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" |
| #include <stdlib.h> |
| #include <string.h> |
| |
| // Platform APIs |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetPlatformIDs(cl_uint num_entries, |
| cl_platform_id * platforms, |
| cl_uint * num_platforms) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHRicdVendor* vendor = NULL; |
| cl_uint i; |
| |
| // initialize the platforms (in case they have not been already) |
| khrIcdInitialize(); |
| |
| if (!num_entries && platforms) |
| { |
| return CL_INVALID_VALUE; |
| } |
| if (!platforms && !num_platforms) |
| { |
| return CL_INVALID_VALUE; |
| } |
| // set num_platforms to 0 and set all platform pointers to NULL |
| if (num_platforms) |
| { |
| *num_platforms = 0; |
| } |
| for (i = 0; i < num_entries && platforms; ++i) |
| { |
| platforms[i] = NULL; |
| } |
| // return error if we have no platforms |
| if (!khrIcdVendors) |
| { |
| return CL_PLATFORM_NOT_FOUND_KHR; |
| } |
| // otherwise enumerate all platforms |
| for (vendor = khrIcdVendors; vendor; vendor = vendor->next) |
| { |
| if (num_entries && platforms) |
| { |
| *(platforms++) = vendor->platform; |
| --num_entries; |
| } |
| if (num_platforms) |
| { |
| ++(*num_platforms); |
| } |
| } |
| return CL_SUCCESS; |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetPlatformInfo(cl_platform_id platform, |
| cl_platform_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| // initialize the platforms (in case they have not been already) |
| khrIcdInitialize(); |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clGetPlatformInfo( |
| platform, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Device APIs |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetDeviceIDs(cl_platform_id platform, |
| cl_device_type device_type, |
| cl_uint num_entries, |
| cl_device_id * devices, |
| cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_0 |
| { |
| // initialize the platforms (in case they have not been already) |
| khrIcdInitialize(); |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clGetDeviceIDs( |
| platform, |
| device_type, |
| num_entries, |
| devices, |
| num_devices); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetDeviceInfo( |
| cl_device_id device, |
| cl_device_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clGetDeviceInfo( |
| device, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clCreateSubDevices(cl_device_id in_device, |
| const cl_device_partition_property * properties, |
| cl_uint num_entries, |
| cl_device_id * out_devices, |
| cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); |
| return in_device->dispatch->clCreateSubDevices( |
| in_device, |
| properties, |
| num_entries, |
| out_devices, |
| num_devices); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clRetainDevice(device); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clReleaseDevice(device); |
| } |
| |
| // Context APIs |
| CL_API_ENTRY cl_context CL_API_CALL |
| clCreateContext(const cl_context_properties * properties, |
| cl_uint num_devices, |
| const cl_device_id * devices, |
| void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *), |
| void * user_data, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| // initialize the platforms (in case they have not been already) |
| khrIcdInitialize(); |
| if (!num_devices || !devices) |
| { |
| if (errcode_ret) |
| { |
| *errcode_ret = CL_INVALID_VALUE; |
| } |
| return NULL; |
| } |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE); |
| return devices[0]->dispatch->clCreateContext( |
| properties, |
| num_devices, |
| devices, |
| pfn_notify, |
| user_data, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_context CL_API_CALL |
| clCreateContextFromType(const cl_context_properties * properties, |
| cl_device_type device_type, |
| void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *), |
| void * user_data, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| cl_platform_id platform = NULL; |
| |
| // initialize the platforms (in case they have not been already) |
| khrIcdInitialize(); |
| |
| // determine the platform to use from the properties specified |
| khrIcdContextPropertiesGetPlatform(properties, &platform); |
| |
| // validate the platform handle and dispatch |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clCreateContextFromType( |
| properties, |
| device_type, |
| pfn_notify, |
| user_data, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clRetainContext(context); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clReleaseContext(context); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetContextInfo(cl_context context, |
| cl_context_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clGetContextInfo( |
| context, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Command Queue APIs |
| CL_API_ENTRY cl_command_queue CL_API_CALL |
| clCreateCommandQueue(cl_context context, |
| cl_device_id device, |
| cl_command_queue_properties properties, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateCommandQueue( |
| context, |
| device, |
| properties, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clRetainCommandQueue(command_queue); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clReleaseCommandQueue(command_queue); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetCommandQueueInfo(cl_command_queue command_queue, |
| cl_command_queue_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clGetCommandQueueInfo( |
| command_queue, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Memory Object APIs |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateBuffer(cl_context context, |
| cl_mem_flags flags, |
| size_t size, |
| void * host_ptr, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateBuffer( |
| context, |
| flags, |
| size, |
| host_ptr, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateImage(cl_context context, |
| cl_mem_flags flags, |
| const cl_image_format * image_format, |
| const cl_image_desc * image_desc, |
| void * host_ptr, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateImage( |
| context, |
| flags, |
| image_format, |
| image_desc, |
| host_ptr, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clRetainMemObject(memobj); |
| } |
| |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clReleaseMemObject(memobj); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetSupportedImageFormats(cl_context context, |
| cl_mem_flags flags, |
| cl_mem_object_type image_type, |
| cl_uint num_entries, |
| cl_image_format * image_formats, |
| cl_uint * num_image_formats) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clGetSupportedImageFormats( |
| context, |
| flags, |
| image_type, |
| num_entries, |
| image_formats, |
| num_image_formats); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetMemObjectInfo(cl_mem memobj, |
| cl_mem_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clGetMemObjectInfo( |
| memobj, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetImageInfo(cl_mem image, |
| cl_image_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT); |
| return image->dispatch->clGetImageInfo( |
| image, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Sampler APIs |
| CL_API_ENTRY cl_sampler CL_API_CALL |
| clCreateSampler(cl_context context, |
| cl_bool normalized_coords, |
| cl_addressing_mode addressing_mode, |
| cl_filter_mode filter_mode, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateSampler( |
| context, |
| normalized_coords, |
| addressing_mode, |
| filter_mode, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); |
| return sampler->dispatch->clRetainSampler(sampler); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); |
| return sampler->dispatch->clReleaseSampler(sampler); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetSamplerInfo(cl_sampler sampler, |
| cl_sampler_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); |
| return sampler->dispatch->clGetSamplerInfo( |
| sampler, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Program Object APIs |
| CL_API_ENTRY cl_program CL_API_CALL |
| clCreateProgramWithSource(cl_context context, |
| cl_uint count, |
| const char ** strings, |
| const size_t * lengths, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateProgramWithSource( |
| context, |
| count, |
| strings, |
| lengths, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_program CL_API_CALL |
| clCreateProgramWithBinary(cl_context context, |
| cl_uint num_devices, |
| const cl_device_id * device_list, |
| const size_t * lengths, |
| const unsigned char ** binaries, |
| cl_int * binary_status, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateProgramWithBinary( |
| context, |
| num_devices, |
| device_list, |
| lengths, |
| binaries, |
| binary_status, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_program CL_API_CALL |
| clCreateProgramWithBuiltInKernels(cl_context context, |
| cl_uint num_devices, |
| const cl_device_id * device_list, |
| const char * kernel_names, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateProgramWithBuiltInKernels( |
| context, |
| num_devices, |
| device_list, |
| kernel_names, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clRetainProgram(program); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clReleaseProgram(program); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clBuildProgram(cl_program program, |
| cl_uint num_devices, |
| const cl_device_id * device_list, |
| const char * options, |
| void (CL_CALLBACK *pfn_notify)(cl_program program, void * user_data), |
| void * user_data) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clBuildProgram( |
| program, |
| num_devices, |
| device_list, |
| options, |
| pfn_notify, |
| user_data); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clCompileProgram(cl_program program, |
| cl_uint num_devices, |
| const cl_device_id * device_list, |
| const char * options, |
| cl_uint num_input_headers, |
| const cl_program * input_headers, |
| const char ** header_include_names, |
| void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), |
| void * user_data) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clCompileProgram( |
| program, |
| num_devices, |
| device_list, |
| options, |
| num_input_headers, |
| input_headers, |
| header_include_names, |
| pfn_notify, |
| user_data); |
| } |
| |
| CL_API_ENTRY cl_program CL_API_CALL |
| clLinkProgram(cl_context context, |
| cl_uint num_devices, |
| const cl_device_id * device_list, |
| const char * options, |
| cl_uint num_input_programs, |
| const cl_program * input_programs, |
| void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), |
| void * user_data, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clLinkProgram( |
| context, |
| num_devices, |
| device_list, |
| options, |
| num_input_programs, |
| input_programs, |
| pfn_notify, |
| user_data, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetProgramSpecializationConstant(cl_program program, |
| cl_uint spec_id, |
| size_t spec_size, |
| const void* spec_value) CL_API_SUFFIX__VERSION_2_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clSetProgramSpecializationConstant( |
| program, |
| spec_id, |
| spec_size, |
| spec_value); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetProgramReleaseCallback(cl_program program, |
| void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), |
| void * user_data) CL_API_SUFFIX__VERSION_2_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clSetProgramReleaseCallback( |
| program, |
| pfn_notify, |
| user_data); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2 |
| { |
| // initialize the platforms (in case they have not been already) |
| khrIcdInitialize(); |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clUnloadPlatformCompiler(platform); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetProgramInfo(cl_program program, |
| cl_program_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clGetProgramInfo( |
| program, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetProgramBuildInfo(cl_program program, |
| cl_device_id device, |
| cl_program_build_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clGetProgramBuildInfo( |
| program, |
| device, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Kernel Object APIs |
| CL_API_ENTRY cl_kernel CL_API_CALL |
| clCreateKernel(cl_program program, |
| const char * kernel_name, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clCreateKernel( |
| program, |
| kernel_name, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clCreateKernelsInProgram(cl_program program, |
| cl_uint num_kernels, |
| cl_kernel * kernels, |
| cl_uint * num_kernels_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); |
| return program->dispatch->clCreateKernelsInProgram( |
| program, |
| num_kernels, |
| kernels, |
| num_kernels_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clRetainKernel(kernel); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clReleaseKernel(kernel); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetKernelArg(cl_kernel kernel, |
| cl_uint arg_index, |
| size_t arg_size, |
| const void * arg_value) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clSetKernelArg( |
| kernel, |
| arg_index, |
| arg_size, |
| arg_value); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetKernelInfo(cl_kernel kernel, |
| cl_kernel_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clGetKernelInfo( |
| kernel, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetKernelArgInfo(cl_kernel kernel, |
| cl_uint arg_indx, |
| cl_kernel_arg_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clGetKernelArgInfo( |
| kernel, |
| arg_indx, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetKernelWorkGroupInfo(cl_kernel kernel, |
| cl_device_id device, |
| cl_kernel_work_group_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clGetKernelWorkGroupInfo( |
| kernel, |
| device, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Event Object APIs |
| CL_API_ENTRY cl_int CL_API_CALL |
| clWaitForEvents(cl_uint num_events, |
| const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0 |
| { |
| if (!num_events || !event_list) |
| { |
| return CL_INVALID_VALUE; |
| } |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT); |
| return event_list[0]->dispatch->clWaitForEvents( |
| num_events, |
| event_list); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetEventInfo(cl_event event, |
| cl_event_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clGetEventInfo( |
| event, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clRetainEvent(event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clReleaseEvent(event); |
| } |
| |
| // Profiling APIs |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetEventProfilingInfo(cl_event event, |
| cl_profiling_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clGetEventProfilingInfo( |
| event, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| // Flush and Finish APIs |
| CL_API_ENTRY cl_int CL_API_CALL |
| clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clFlush(command_queue); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clFinish(command_queue); |
| } |
| |
| // Enqueued Commands APIs |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueReadBuffer(cl_command_queue command_queue, |
| cl_mem buffer, |
| cl_bool blocking_read, |
| size_t offset, |
| size_t cb, |
| void * ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReadBuffer( |
| command_queue, |
| buffer, |
| blocking_read, |
| offset, |
| cb, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueReadBufferRect( |
| cl_command_queue command_queue, |
| cl_mem buffer, |
| cl_bool blocking_read, |
| const size_t * buffer_origin, |
| const size_t * host_origin, |
| const size_t * region, |
| size_t buffer_row_pitch, |
| size_t buffer_slice_pitch, |
| size_t host_row_pitch, |
| size_t host_slice_pitch, |
| void * ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReadBufferRect( |
| command_queue, |
| buffer, |
| blocking_read, |
| buffer_origin, |
| host_origin, |
| region, |
| buffer_row_pitch, |
| buffer_slice_pitch, |
| host_row_pitch, |
| host_slice_pitch, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueWriteBuffer(cl_command_queue command_queue, |
| cl_mem buffer, |
| cl_bool blocking_write, |
| size_t offset, |
| size_t cb, |
| const void * ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueWriteBuffer( |
| command_queue, |
| buffer, |
| blocking_write, |
| offset, |
| cb, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueWriteBufferRect( |
| cl_command_queue command_queue, |
| cl_mem buffer, |
| cl_bool blocking_read, |
| const size_t * buffer_origin, |
| const size_t * host_origin, |
| const size_t * region, |
| size_t buffer_row_pitch, |
| size_t buffer_slice_pitch, |
| size_t host_row_pitch, |
| size_t host_slice_pitch, |
| const void * ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueWriteBufferRect( |
| command_queue, |
| buffer, |
| blocking_read, |
| buffer_origin, |
| host_origin, |
| region, |
| buffer_row_pitch, |
| buffer_slice_pitch, |
| host_row_pitch, |
| host_slice_pitch, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueFillBuffer(cl_command_queue command_queue, |
| cl_mem buffer, |
| const void * pattern, |
| size_t pattern_size, |
| size_t offset, |
| size_t cb, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueFillBuffer( |
| command_queue, |
| buffer, |
| pattern, |
| pattern_size, |
| offset, |
| cb, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueCopyBuffer(cl_command_queue command_queue, |
| cl_mem src_buffer, |
| cl_mem dst_buffer, |
| size_t src_offset, |
| size_t dst_offset, |
| size_t cb, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueCopyBuffer( |
| command_queue, |
| src_buffer, |
| dst_buffer, |
| src_offset, |
| dst_offset, |
| cb, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueCopyBufferRect( |
| cl_command_queue command_queue, |
| cl_mem src_buffer, |
| cl_mem dst_buffer, |
| const size_t * src_origin, |
| const size_t * dst_origin, |
| const size_t * region, |
| size_t src_row_pitch, |
| size_t src_slice_pitch, |
| size_t dst_row_pitch, |
| size_t dst_slice_pitch, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueCopyBufferRect( |
| command_queue, |
| src_buffer, |
| dst_buffer, |
| src_origin, |
| dst_origin, |
| region, |
| src_row_pitch, |
| src_slice_pitch, |
| dst_row_pitch, |
| dst_slice_pitch, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueReadImage(cl_command_queue command_queue, |
| cl_mem image, |
| cl_bool blocking_read, |
| const size_t * origin, |
| const size_t * region, |
| size_t row_pitch, |
| size_t slice_pitch, |
| void * ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReadImage( |
| command_queue, |
| image, |
| blocking_read, |
| origin, |
| region, |
| row_pitch, |
| slice_pitch, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueWriteImage(cl_command_queue command_queue, |
| cl_mem image, |
| cl_bool blocking_write, |
| const size_t * origin, |
| const size_t * region, |
| size_t input_row_pitch, |
| size_t input_slice_pitch, |
| const void * ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueWriteImage( |
| command_queue, |
| image, |
| blocking_write, |
| origin, |
| region, |
| input_row_pitch, |
| input_slice_pitch, |
| ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueFillImage(cl_command_queue command_queue, |
| cl_mem image, |
| const void * fill_color, |
| const size_t origin[3], |
| const size_t region[3], |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueFillImage( |
| command_queue, |
| image, |
| fill_color, |
| origin, |
| region, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueCopyImage(cl_command_queue command_queue, |
| cl_mem src_image, |
| cl_mem dst_image, |
| const size_t * src_origin, |
| const size_t * dst_origin, |
| const size_t * region, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueCopyImage( |
| command_queue, |
| src_image, |
| dst_image, |
| src_origin, |
| dst_origin, |
| region, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueCopyImageToBuffer(cl_command_queue command_queue, |
| cl_mem src_image, |
| cl_mem dst_buffer, |
| const size_t * src_origin, |
| const size_t * region, |
| size_t dst_offset, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueCopyImageToBuffer( |
| command_queue, |
| src_image, |
| dst_buffer, |
| src_origin, |
| region, |
| dst_offset, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueCopyBufferToImage(cl_command_queue command_queue, |
| cl_mem src_buffer, |
| cl_mem dst_image, |
| size_t src_offset, |
| const size_t * dst_origin, |
| const size_t * region, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueCopyBufferToImage( |
| command_queue, |
| src_buffer, |
| dst_image, |
| src_offset, |
| dst_origin, |
| region, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY void * CL_API_CALL |
| clEnqueueMapBuffer(cl_command_queue command_queue, |
| cl_mem buffer, |
| cl_bool blocking_map, |
| cl_map_flags map_flags, |
| size_t offset, |
| size_t cb, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueMapBuffer( |
| command_queue, |
| buffer, |
| blocking_map, |
| map_flags, |
| offset, |
| cb, |
| num_events_in_wait_list, |
| event_wait_list, |
| event, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY void * CL_API_CALL |
| clEnqueueMapImage(cl_command_queue command_queue, |
| cl_mem image, |
| cl_bool blocking_map, |
| cl_map_flags map_flags, |
| const size_t * origin, |
| const size_t * region, |
| size_t * image_row_pitch, |
| size_t * image_slice_pitch, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueMapImage( |
| command_queue, |
| image, |
| blocking_map, |
| map_flags, |
| origin, |
| region, |
| image_row_pitch, |
| image_slice_pitch, |
| num_events_in_wait_list, |
| event_wait_list, |
| event, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueUnmapMemObject(cl_command_queue command_queue, |
| cl_mem memobj, |
| void * mapped_ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueUnmapMemObject( |
| command_queue, |
| memobj, |
| mapped_ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueMigrateMemObjects(cl_command_queue command_queue, |
| cl_uint num_mem_objects, |
| const cl_mem * mem_objects, |
| cl_mem_migration_flags flags, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueMigrateMemObjects( |
| command_queue, |
| num_mem_objects, |
| mem_objects, |
| flags, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueNDRangeKernel(cl_command_queue command_queue, |
| cl_kernel kernel, |
| cl_uint work_dim, |
| const size_t * global_work_offset, |
| const size_t * global_work_size, |
| const size_t * local_work_size, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueNDRangeKernel( |
| command_queue, |
| kernel, |
| work_dim, |
| global_work_offset, |
| global_work_size, |
| local_work_size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueTask(cl_command_queue command_queue, |
| cl_kernel kernel, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueTask( |
| command_queue, |
| kernel, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueNativeKernel(cl_command_queue command_queue, |
| void (CL_CALLBACK * user_func)(void *), |
| void * args, |
| size_t cb_args, |
| cl_uint num_mem_objects, |
| const cl_mem * mem_list, |
| const void ** args_mem_loc, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueNativeKernel( |
| command_queue, |
| user_func, |
| args, |
| cb_args, |
| num_mem_objects, |
| mem_list, |
| args_mem_loc, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueMarkerWithWaitList(cl_command_queue command_queue, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueMarkerWithWaitList( |
| command_queue, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueBarrierWithWaitList(cl_command_queue command_queue, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueBarrierWithWaitList( |
| command_queue, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY void * CL_API_CALL |
| clGetExtensionFunctionAddressForPlatform(cl_platform_id platform, |
| const char * function_name) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL); |
| |
| // make sure the ICD is initialized |
| khrIcdInitialize(); |
| |
| // return any ICD-aware extensions |
| |
| // Most extensions, including multi-vendor KHR and EXT extensions, |
| // do not need to be ICD-aware and do not require any ICD loader |
| // modifications. The KHR and EXT extensions below were added for |
| // backwards compatibility only. |
| #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name |
| |
| // Functions supporting the creation of OpenCL Memory Objects |
| // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing) |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects); |
| |
| // cl_khr_gl_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR); |
| |
| // cl_khr_gl_event |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR); |
| |
| #if defined(_WIN32) |
| // cl_khr_d3d10_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR); |
| // cl_khr_d3d11_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR); |
| // cl_khr_dx9_media_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR); |
| #endif |
| |
| // cl_ext_device_fission |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT); |
| |
| /* cl_khr_egl_image */ |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR); |
| |
| /* cl_khr_egl_event */ |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR); |
| |
| /* cl_khr_sub_groups */ |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR); |
| |
| #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD |
| |
| // This is not an ICD-aware extension, so call into the implementation |
| // to get the extension function address. |
| |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL); |
| return platform->dispatch->clGetExtensionFunctionAddressForPlatform( |
| platform, |
| function_name); |
| } |
| |
| // Deprecated APIs |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetCommandQueueProperty(cl_command_queue command_queue, |
| cl_command_queue_properties properties, |
| cl_bool enable, |
| cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clSetCommandQueueProperty( |
| command_queue, |
| properties, |
| enable, |
| old_properties); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clCreateSubDevicesEXT( |
| cl_device_id in_device, |
| const cl_device_partition_property_ext * partition_properties, |
| cl_uint num_entries, |
| cl_device_id * out_devices, |
| cl_uint * num_devices) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); |
| return in_device->dispatch->clCreateSubDevicesEXT( |
| in_device, |
| partition_properties, |
| num_entries, |
| out_devices, |
| num_devices); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clRetainDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clRetainDeviceEXT(device); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clReleaseDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clReleaseDeviceEXT(device); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateImage2D(cl_context context, |
| cl_mem_flags flags, |
| const cl_image_format * image_format, |
| size_t image_width, |
| size_t image_height, |
| size_t image_row_pitch, |
| void * host_ptr, |
| cl_int * errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateImage2D( |
| context, |
| flags, |
| image_format, |
| image_width, |
| image_height, |
| image_row_pitch, |
| host_ptr, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateImage3D(cl_context context, |
| cl_mem_flags flags, |
| const cl_image_format * image_format, |
| size_t image_width, |
| size_t image_height, |
| size_t image_depth, |
| size_t image_row_pitch, |
| size_t image_slice_pitch, |
| void * host_ptr, |
| cl_int * errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateImage3D( |
| context, |
| flags, |
| image_format, |
| image_width, |
| image_height, |
| image_depth, |
| image_row_pitch, |
| image_slice_pitch, |
| host_ptr, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| return CL_SUCCESS; |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueMarker(cl_command_queue command_queue, |
| cl_event * event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueMarker( |
| command_queue, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueWaitForEvents(cl_command_queue command_queue, |
| cl_uint num_events, |
| const cl_event * event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueWaitForEvents( |
| command_queue, |
| num_events, |
| event_list); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueBarrier(cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueBarrier(command_queue); |
| } |
| |
| CL_API_ENTRY void * CL_API_CALL |
| clGetExtensionFunctionAddress(const char *function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED |
| { |
| size_t function_name_length = 0; |
| KHRicdVendor* vendor = NULL; |
| |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL); |
| |
| // make sure the ICD is initialized |
| khrIcdInitialize(); |
| function_name_length = strlen(function_name); |
| |
| // return any ICD-aware extensions |
| |
| // Most extensions, including multi-vendor KHR and EXT extensions, |
| // do not need to be ICD-aware and do not require any ICD loader |
| // modifications. The KHR and EXT extensions below were added for |
| // backwards compatibility only. |
| #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name |
| |
| // Functions supporting the creation of OpenCL Memory Objects |
| // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing) |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects); |
| |
| // cl_khr_gl_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR); |
| |
| // cl_khr_gl_event |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR); |
| |
| #if defined(_WIN32) |
| // cl_khr_d3d10_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR); |
| // cl_khr_d3d11_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR); |
| // cl_khr_dx9_media_sharing |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR); |
| #endif |
| |
| // cl_ext_device_fission |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT); |
| |
| /* cl_khr_egl_image */ |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR); |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR); |
| |
| /* cl_khr_egl_event */ |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR); |
| |
| /* cl_khr_sub_groups */ |
| CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR); |
| |
| #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD |
| |
| // fall back to vendor extension detection |
| for (vendor = khrIcdVendors; vendor; vendor = vendor->next) |
| { |
| size_t vendor_suffix_length = strlen(vendor->suffix); |
| if (vendor_suffix_length <= function_name_length && vendor_suffix_length > 0) |
| { |
| const char *function_suffix = function_name+function_name_length-vendor_suffix_length; |
| if (!strcmp(function_suffix, vendor->suffix) ) |
| { |
| return vendor->clGetExtensionFunctionAddress(function_name); |
| } |
| } |
| } |
| return NULL; |
| } |
| |
| // GL and other APIs |
| CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer( |
| cl_context context, |
| cl_mem_flags flags, |
| cl_GLuint bufobj, |
| int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLBuffer( |
| context, |
| flags, |
| bufobj, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture( |
| cl_context context, |
| cl_mem_flags flags, |
| cl_GLenum target, |
| cl_GLint miplevel, |
| cl_GLuint texture, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLTexture( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D( |
| cl_context context, |
| cl_mem_flags flags, |
| cl_GLenum target, |
| cl_GLint miplevel, |
| cl_GLuint texture, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLTexture2D( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D( |
| cl_context context, |
| cl_mem_flags flags, |
| cl_GLenum target, |
| cl_GLint miplevel, |
| cl_GLuint texture, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLTexture3D( |
| context, |
| flags, |
| target, |
| miplevel, |
| texture, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer( |
| cl_context context, |
| cl_mem_flags flags, |
| cl_GLuint renderbuffer, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromGLRenderbuffer( |
| context, |
| flags, |
| renderbuffer, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo( |
| cl_mem memobj, |
| cl_gl_object_type * gl_object_type, |
| cl_GLuint * gl_object_name) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clGetGLObjectInfo( |
| memobj, |
| gl_object_type, |
| gl_object_name); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo( |
| cl_mem memobj, |
| cl_gl_texture_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clGetGLTextureInfo( |
| memobj, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem * mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueAcquireGLObjects( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem * mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_1_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReleaseGLObjects( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR( |
| const cl_context_properties *properties, |
| cl_gl_context_info param_name, |
| size_t param_value_size, |
| void *param_value, |
| size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 |
| { |
| cl_platform_id platform = NULL; |
| |
| // initialize the platforms (in case they have not been already) |
| khrIcdInitialize(); |
| |
| // determine the platform to use from the properties specified |
| khrIcdContextPropertiesGetPlatform(properties, &platform); |
| |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clGetGLContextInfoKHR( |
| properties, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR( |
| cl_context context, |
| cl_GLsync sync, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateEventFromGLsyncKHR( |
| context, |
| sync, |
| errcode_ret); |
| } |
| |
| #if defined(_WIN32) |
| /* |
| * |
| * cl_d3d10_sharing_khr |
| * |
| */ |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetDeviceIDsFromD3D10KHR( |
| cl_platform_id platform, |
| cl_d3d10_device_source_khr d3d_device_source, |
| void *d3d_object, |
| cl_d3d10_device_set_khr d3d_device_set, |
| cl_uint num_entries, |
| cl_device_id *devices, |
| cl_uint *num_devices) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clGetDeviceIDsFromD3D10KHR( |
| platform, |
| d3d_device_source, |
| d3d_object, |
| d3d_device_set, |
| num_entries, |
| devices, |
| num_devices); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromD3D10BufferKHR( |
| cl_context context, |
| cl_mem_flags flags, |
| ID3D10Buffer *resource, |
| cl_int *errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D10BufferKHR( |
| context, |
| flags, |
| resource, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromD3D10Texture2DKHR( |
| cl_context context, |
| cl_mem_flags flags, |
| ID3D10Texture2D * resource, |
| UINT subresource, |
| cl_int * errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D10Texture2DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromD3D10Texture3DKHR( |
| cl_context context, |
| cl_mem_flags flags, |
| ID3D10Texture3D *resource, |
| UINT subresource, |
| cl_int *errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D10Texture3DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueAcquireD3D10ObjectsKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueReleaseD3D10ObjectsKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| /* |
| * |
| * cl_d3d11_sharing_khr |
| * |
| */ |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetDeviceIDsFromD3D11KHR( |
| cl_platform_id platform, |
| cl_d3d11_device_source_khr d3d_device_source, |
| void * d3d_object, |
| cl_d3d11_device_set_khr d3d_device_set, |
| cl_uint num_entries, |
| cl_device_id * devices, |
| cl_uint * num_devices) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clGetDeviceIDsFromD3D11KHR( |
| platform, |
| d3d_device_source, |
| d3d_object, |
| d3d_device_set, |
| num_entries, |
| devices, |
| num_devices); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromD3D11BufferKHR( |
| cl_context context, |
| cl_mem_flags flags, |
| ID3D11Buffer * resource, |
| cl_int * errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D11BufferKHR( |
| context, |
| flags, |
| resource, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromD3D11Texture2DKHR( |
| cl_context context, |
| cl_mem_flags flags, |
| ID3D11Texture2D * resource, |
| UINT subresource, |
| cl_int * errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D11Texture2DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromD3D11Texture3DKHR( |
| cl_context context, |
| cl_mem_flags flags, |
| ID3D11Texture3D * resource, |
| UINT subresource, |
| cl_int * errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromD3D11Texture3DKHR( |
| context, |
| flags, |
| resource, |
| subresource, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueAcquireD3D11ObjectsKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem * mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueReleaseD3D11ObjectsKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem * mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| /* |
| * |
| * cl_khr_dx9_media_sharing |
| * |
| */ |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetDeviceIDsFromDX9MediaAdapterKHR( |
| cl_platform_id platform, |
| cl_uint num_media_adapters, |
| cl_dx9_media_adapter_type_khr * media_adapters_type, |
| void * media_adapters, |
| cl_dx9_media_adapter_set_khr media_adapter_set, |
| cl_uint num_entries, |
| cl_device_id * devices, |
| cl_uint * num_devices) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); |
| return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR( |
| platform, |
| num_media_adapters, |
| media_adapters_type, |
| media_adapters, |
| media_adapter_set, |
| num_entries, |
| devices, |
| num_devices); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromDX9MediaSurfaceKHR( |
| cl_context context, |
| cl_mem_flags flags, |
| cl_dx9_media_adapter_type_khr adapter_type, |
| void * surface_info, |
| cl_uint plane, |
| cl_int * errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromDX9MediaSurfaceKHR( |
| context, |
| flags, |
| adapter_type, |
| surface_info, |
| plane, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueAcquireDX9MediaSurfacesKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem * mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueReleaseDX9MediaSurfacesKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem * mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| #endif |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetEventCallback( |
| cl_event event, |
| cl_int command_exec_callback_type, |
| void (CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *), |
| void *user_data) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clSetEventCallback( |
| event, |
| command_exec_callback_type, |
| pfn_notify, |
| user_data); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateSubBuffer( |
| cl_mem buffer, |
| cl_mem_flags flags, |
| cl_buffer_create_type buffer_create_type, |
| const void * buffer_create_info, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT); |
| return buffer->dispatch->clCreateSubBuffer( |
| buffer, |
| flags, |
| buffer_create_type, |
| buffer_create_info, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetMemObjectDestructorCallback( |
| cl_mem memobj, |
| void (CL_CALLBACK * pfn_notify)( cl_mem, void*), |
| void * user_data ) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); |
| return memobj->dispatch->clSetMemObjectDestructorCallback( |
| memobj, |
| pfn_notify, |
| user_data); |
| } |
| |
| CL_API_ENTRY cl_event CL_API_CALL |
| clCreateUserEvent( |
| cl_context context, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateUserEvent( |
| context, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetUserEventStatus( |
| cl_event event, |
| cl_int execution_status) CL_API_SUFFIX__VERSION_1_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); |
| return event->dispatch->clSetUserEventStatus( |
| event, |
| execution_status); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreateFromEGLImageKHR( |
| cl_context context, |
| CLeglDisplayKHR display, |
| CLeglImageKHR image, |
| cl_mem_flags flags, |
| const cl_egl_image_properties_khr *properties, |
| cl_int *errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateFromEGLImageKHR( |
| context, |
| display, |
| image, |
| flags, |
| properties, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueAcquireEGLObjectsKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueReleaseEGLObjectsKHR( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR( |
| command_queue, |
| num_objects, |
| mem_objects, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| /* cl_khr_egl_event */ |
| CL_API_ENTRY cl_event CL_API_CALL |
| clCreateEventFromEGLSyncKHR( |
| cl_context context, |
| CLeglSyncKHR sync, |
| CLeglDisplayKHR display, |
| cl_int *errcode_ret) |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateEventFromEGLSyncKHR( |
| context, |
| sync, |
| display, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_command_queue CL_API_CALL |
| clCreateCommandQueueWithProperties( |
| cl_context context, |
| cl_device_id device, |
| const cl_queue_properties * properties, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateCommandQueueWithProperties( |
| context, |
| device, |
| properties, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_mem CL_API_CALL |
| clCreatePipe( |
| cl_context context, |
| cl_mem_flags flags, |
| cl_uint pipe_packet_size, |
| cl_uint pipe_max_packets, |
| const cl_pipe_properties * properties, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreatePipe( |
| context, |
| flags, |
| pipe_packet_size, |
| pipe_max_packets, |
| properties, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetPipeInfo( |
| cl_mem pipe, |
| cl_pipe_info param_name, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT); |
| return pipe->dispatch->clGetPipeInfo( |
| pipe, |
| param_name, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY void * CL_API_CALL |
| clSVMAlloc( |
| cl_context context, |
| cl_svm_mem_flags flags, |
| size_t size, |
| cl_uint alignment) CL_API_SUFFIX__VERSION_2_0 |
| { |
| if (!context) { |
| return NULL; |
| } |
| return context->dispatch->clSVMAlloc( |
| context, |
| flags, |
| size, |
| alignment); |
| } |
| |
| CL_API_ENTRY void CL_API_CALL |
| clSVMFree( |
| cl_context context, |
| void * svm_pointer) CL_API_SUFFIX__VERSION_2_0 |
| { |
| if (!context || !svm_pointer) { |
| return; |
| } |
| context->dispatch->clSVMFree( |
| context, |
| svm_pointer); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueSVMFree( |
| cl_command_queue command_queue, |
| cl_uint num_svm_pointers, |
| void* svm_pointers[], |
| void (CL_CALLBACK* pfn_free_func)( |
| cl_command_queue queue, |
| cl_uint num_svm_pointers, |
| void* svm_pointers[], |
| void* user_data), |
| void* user_data, |
| cl_uint num_events_in_wait_list, |
| const cl_event* event_wait_list, |
| cl_event* event) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueSVMFree( |
| command_queue, |
| num_svm_pointers, |
| svm_pointers, |
| pfn_free_func, |
| user_data, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueSVMMemcpy( |
| cl_command_queue command_queue, |
| cl_bool blocking_copy, |
| void * dst_ptr, |
| const void * src_ptr, |
| size_t size, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueSVMMemcpy( |
| command_queue, |
| blocking_copy, |
| dst_ptr, |
| src_ptr, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueSVMMemFill( |
| cl_command_queue command_queue, |
| void * svm_ptr, |
| const void * pattern, |
| size_t pattern_size, |
| size_t size, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueSVMMemFill( |
| command_queue, |
| svm_ptr, |
| pattern, |
| pattern_size, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueSVMMap( |
| cl_command_queue command_queue, |
| cl_bool blocking_map, |
| cl_map_flags flags, |
| void * svm_ptr, |
| size_t size, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueSVMMap( |
| command_queue, |
| blocking_map, |
| flags, |
| svm_ptr, |
| size, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueSVMUnmap( |
| cl_command_queue command_queue, |
| void * svm_ptr, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueSVMUnmap( |
| command_queue, |
| svm_ptr, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_sampler CL_API_CALL |
| clCreateSamplerWithProperties( |
| cl_context context, |
| const cl_sampler_properties * sampler_properties, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateSamplerWithProperties( |
| context, |
| sampler_properties, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetKernelArgSVMPointer( |
| cl_kernel kernel, |
| cl_uint arg_index, |
| const void * arg_value) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clSetKernelArgSVMPointer( |
| kernel, |
| arg_index, |
| arg_value); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetKernelExecInfo( |
| cl_kernel kernel, |
| cl_kernel_exec_info param_name, |
| size_t param_value_size, |
| const void * param_value) CL_API_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| return kernel->dispatch->clSetKernelExecInfo( |
| kernel, |
| param_name, |
| param_value_size, |
| param_value); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetKernelSubGroupInfoKHR( |
| cl_kernel in_kernel, |
| cl_device_id in_device, |
| cl_kernel_sub_group_info param_name, |
| size_t input_value_size, |
| const void * input_value, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL); |
| return in_kernel->dispatch->clGetKernelSubGroupInfoKHR( |
| in_kernel, |
| in_device, |
| param_name, |
| input_value_size, |
| input_value, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clSetDefaultDeviceCommandQueue( |
| cl_context context, |
| cl_device_id device, |
| cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return context->dispatch->clSetDefaultDeviceCommandQueue( |
| context, |
| device, |
| command_queue); |
| } |
| |
| CL_API_ENTRY cl_program CL_API_CALL |
| clCreateProgramWithIL( |
| cl_context context, |
| const void * il, |
| size_t length, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); |
| return context->dispatch->clCreateProgramWithIL( |
| context, |
| il, |
| length, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetKernelSubGroupInfo( |
| cl_kernel kernel, |
| cl_device_id device, |
| cl_kernel_sub_group_info param_name, |
| size_t input_value_size, |
| const void * input_value, |
| size_t param_value_size, |
| void * param_value, |
| size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return kernel->dispatch->clGetKernelSubGroupInfo( |
| kernel, |
| device, |
| param_name, |
| input_value_size, |
| input_value, |
| param_value_size, |
| param_value, |
| param_value_size_ret); |
| } |
| |
| CL_API_ENTRY cl_kernel CL_API_CALL |
| clCloneKernel( |
| cl_kernel source_kernel, |
| cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL); |
| return source_kernel->dispatch->clCloneKernel( |
| source_kernel, |
| errcode_ret); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clEnqueueSVMMigrateMem( |
| cl_command_queue command_queue, |
| cl_uint num_svm_pointers, |
| const void ** svm_pointers, |
| const size_t * sizes, |
| cl_mem_migration_flags flags, |
| cl_uint num_events_in_wait_list, |
| const cl_event * event_wait_list, |
| cl_event * event) CL_API_SUFFIX__VERSION_2_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); |
| return command_queue->dispatch->clEnqueueSVMMigrateMem( |
| command_queue, |
| num_svm_pointers, |
| svm_pointers, |
| sizes, |
| flags, |
| num_events_in_wait_list, |
| event_wait_list, |
| event); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetDeviceAndHostTimer( |
| cl_device_id device, |
| cl_ulong * device_timestamp, |
| cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clGetDeviceAndHostTimer( |
| device, |
| device_timestamp, |
| host_timestamp); |
| } |
| |
| CL_API_ENTRY cl_int CL_API_CALL |
| clGetHostTimer( |
| cl_device_id device, |
| cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1 |
| { |
| KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); |
| return device->dispatch->clGetHostTimer( |
| device, |
| host_timestamp); |
| } |
| |
| |
