Google Git
Sign in
fuchsia / third_party / github.com / KhronosGroup / OpenCL-ICD-Loader / 6e02d3584bfca75bb4da66a20f27cfe8f637e700 / . / loader / icd_dispatch_generated.c
blob: 8498563b8a0950279acabf071f8b372f0d079146 [file] [log] [blame]
/*
* Copyright (c) 2012-2020 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* OpenCL is a trademark of Apple Inc. used under license by Khronos.
*/
#include "icd_dispatch.h"
#include "icd.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////
// Core APIs:
CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(
cl_platform_id platform,
cl_platform_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clGetPlatformInfo(
platform,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(
cl_platform_id platform,
cl_device_type device_type,
cl_uint num_entries,
cl_device_id* devices,
cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clGetDeviceIDs(
platform,
device_type,
num_entries,
devices,
num_devices);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo(
cl_device_id device,
cl_device_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
return device->dispatch->clGetDeviceInfo(
device,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_context CL_API_CALL clCreateContext(
const cl_context_properties* properties,
cl_uint num_devices,
const cl_device_id* devices,
void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
void* user_data,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
if (num_devices == 0 || devices == NULL) {
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE);
}
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
return devices[0]->dispatch->clCreateContext(
properties,
num_devices,
devices,
pfn_notify,
user_data,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType(
const cl_context_properties* properties,
cl_device_type device_type,
void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
void* user_data,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
cl_platform_id platform = NULL;
khrIcdInitialize();
khrIcdContextPropertiesGetPlatform(properties, &platform);
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clCreateContextFromType(
properties,
device_type,
pfn_notify,
user_data,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainContext(
cl_context context) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
return context->dispatch->clRetainContext(
context);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseContext(
cl_context context) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
return context->dispatch->clReleaseContext(
context);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo(
cl_context context,
cl_context_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
return context->dispatch->clGetContextInfo(
context,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue(
cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clRetainCommandQueue(
command_queue);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue(
cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clReleaseCommandQueue(
command_queue);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(
cl_command_queue command_queue,
cl_command_queue_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clGetCommandQueueInfo(
command_queue,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(
cl_context context,
cl_mem_flags flags,
size_t size,
void* host_ptr,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateBuffer(
context,
flags,
size,
host_ptr,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(
cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
return memobj->dispatch->clRetainMemObject(
memobj);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject(
cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
return memobj->dispatch->clReleaseMemObject(
memobj);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(
cl_context context,
cl_mem_flags flags,
cl_mem_object_type image_type,
cl_uint num_entries,
cl_image_format* image_formats,
cl_uint* num_image_formats) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
return context->dispatch->clGetSupportedImageFormats(
context,
flags,
image_type,
num_entries,
image_formats,
num_image_formats);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo(
cl_mem memobj,
cl_mem_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
return memobj->dispatch->clGetMemObjectInfo(
memobj,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo(
cl_mem image,
cl_image_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
return image->dispatch->clGetImageInfo(
image,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainSampler(
cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
return sampler->dispatch->clRetainSampler(
sampler);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler(
cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
return sampler->dispatch->clReleaseSampler(
sampler);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo(
cl_sampler sampler,
cl_sampler_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
return sampler->dispatch->clGetSamplerInfo(
sampler,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(
cl_context context,
cl_uint count,
const char** strings,
const size_t* lengths,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateProgramWithSource(
context,
count,
strings,
lengths,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary(
cl_context context,
cl_uint num_devices,
const cl_device_id* device_list,
const size_t* lengths,
const unsigned char** binaries,
cl_int* binary_status,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateProgramWithBinary(
context,
num_devices,
device_list,
lengths,
binaries,
binary_status,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainProgram(
cl_program program) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clRetainProgram(
program);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram(
cl_program program) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clReleaseProgram(
program);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(
cl_program program,
cl_uint num_devices,
const cl_device_id* device_list,
const char* options,
void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
void* user_data) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clBuildProgram(
program,
num_devices,
device_list,
options,
pfn_notify,
user_data);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo(
cl_program program,
cl_program_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clGetProgramInfo(
program,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo(
cl_program program,
cl_device_id device,
cl_program_build_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clGetProgramBuildInfo(
program,
device,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(
cl_program program,
const char* kernel_name,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
return program->dispatch->clCreateKernel(
program,
kernel_name,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram(
cl_program program,
cl_uint num_kernels,
cl_kernel* kernels,
cl_uint* num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clCreateKernelsInProgram(
program,
num_kernels,
kernels,
num_kernels_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainKernel(
cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clRetainKernel(
kernel);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel(
cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clReleaseKernel(
kernel);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(
cl_kernel kernel,
cl_uint arg_index,
size_t arg_size,
const void* arg_value) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clSetKernelArg(
kernel,
arg_index,
arg_size,
arg_value);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo(
cl_kernel kernel,
cl_kernel_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clGetKernelInfo(
kernel,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(
cl_kernel kernel,
cl_device_id device,
cl_kernel_work_group_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clGetKernelWorkGroupInfo(
kernel,
device,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(
cl_uint num_events,
const cl_event* event_list) CL_API_SUFFIX__VERSION_1_0
{
if (num_events == 0 || event_list == NULL) {
return CL_INVALID_VALUE;
}
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT);
return event_list[0]->dispatch->clWaitForEvents(
num_events,
event_list);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo(
cl_event event,
cl_event_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
return event->dispatch->clGetEventInfo(
event,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainEvent(
cl_event event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
return event->dispatch->clRetainEvent(
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(
cl_event event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
return event->dispatch->clReleaseEvent(
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(
cl_event event,
cl_profiling_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
return event->dispatch->clGetEventProfilingInfo(
event,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clFlush(
cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clFlush(
command_queue);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clFinish(
cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clFinish(
command_queue);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_read,
size_t offset,
size_t size,
void* ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReadBuffer(
command_queue,
buffer,
blocking_read,
offset,
size,
ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
size_t offset,
size_t size,
const void* ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueWriteBuffer(
command_queue,
buffer,
blocking_write,
offset,
size,
ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
size_t src_offset,
size_t dst_offset,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueCopyBuffer(
command_queue,
src_buffer,
dst_buffer,
src_offset,
dst_offset,
size,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_read,
const size_t* origin,
const size_t* region,
size_t row_pitch,
size_t slice_pitch,
void* ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReadImage(
command_queue,
image,
blocking_read,
origin,
region,
row_pitch,
slice_pitch,
ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_write,
const size_t* origin,
const size_t* region,
size_t input_row_pitch,
size_t input_slice_pitch,
const void* ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueWriteImage(
command_queue,
image,
blocking_write,
origin,
region,
input_row_pitch,
input_slice_pitch,
ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(
cl_command_queue command_queue,
cl_mem src_image,
cl_mem dst_image,
const size_t* src_origin,
const size_t* dst_origin,
const size_t* region,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueCopyImage(
command_queue,
src_image,
dst_image,
src_origin,
dst_origin,
region,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(
cl_command_queue command_queue,
cl_mem src_image,
cl_mem dst_buffer,
const size_t* src_origin,
const size_t* region,
size_t dst_offset,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueCopyImageToBuffer(
command_queue,
src_image,
dst_buffer,
src_origin,
region,
dst_offset,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_image,
size_t src_offset,
const size_t* dst_origin,
const size_t* region,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueCopyBufferToImage(
command_queue,
src_buffer,
dst_image,
src_offset,
dst_origin,
region,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_map,
cl_map_flags map_flags,
size_t offset,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueMapBuffer(
command_queue,
buffer,
blocking_map,
map_flags,
offset,
size,
num_events_in_wait_list,
event_wait_list,
event,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_map,
cl_map_flags map_flags,
const size_t* origin,
const size_t* region,
size_t* image_row_pitch,
size_t* image_slice_pitch,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueMapImage(
command_queue,
image,
blocking_map,
map_flags,
origin,
region,
image_row_pitch,
image_slice_pitch,
num_events_in_wait_list,
event_wait_list,
event,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject(
cl_command_queue command_queue,
cl_mem memobj,
void* mapped_ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueUnmapMemObject(
command_queue,
memobj,
mapped_ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(
cl_command_queue command_queue,
cl_kernel kernel,
cl_uint work_dim,
const size_t* global_work_offset,
const size_t* global_work_size,
const size_t* local_work_size,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueNDRangeKernel(
command_queue,
kernel,
work_dim,
global_work_offset,
global_work_size,
local_work_size,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel(
cl_command_queue command_queue,
void (CL_CALLBACK* user_func)(void*),
void* args,
size_t cb_args,
cl_uint num_mem_objects,
const cl_mem* mem_list,
const void** args_mem_loc,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueNativeKernel(
command_queue,
user_func,
args,
cb_args,
num_mem_objects,
mem_list,
args_mem_loc,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty(
cl_command_queue command_queue,
cl_command_queue_properties properties,
cl_bool enable,
cl_command_queue_properties* old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clSetCommandQueueProperty(
command_queue,
properties,
enable,
old_properties);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D(
cl_context context,
cl_mem_flags flags,
const cl_image_format* image_format,
size_t image_width,
size_t image_height,
size_t image_row_pitch,
void* host_ptr,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateImage2D(
context,
flags,
image_format,
image_width,
image_height,
image_row_pitch,
host_ptr,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D(
cl_context context,
cl_mem_flags flags,
const cl_image_format* image_format,
size_t image_width,
size_t image_height,
size_t image_depth,
size_t image_row_pitch,
size_t image_slice_pitch,
void* host_ptr,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateImage3D(
context,
flags,
image_format,
image_width,
image_height,
image_depth,
image_row_pitch,
image_slice_pitch,
host_ptr,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker(
cl_command_queue command_queue,
cl_event* event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueMarker(
command_queue,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents(
cl_command_queue command_queue,
cl_uint num_events,
const cl_event* event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueWaitForEvents(
command_queue,
num_events,
event_list);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier(
cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueBarrier(
command_queue);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler(
void ) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
// Nothing!
return CL_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(
cl_context context,
cl_device_id device,
cl_command_queue_properties properties,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateCommandQueue(
context,
device,
properties,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler(
cl_context context,
cl_bool normalized_coords,
cl_addressing_mode addressing_mode,
cl_filter_mode filter_mode,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateSampler(
context,
normalized_coords,
addressing_mode,
filter_mode,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask(
cl_command_queue command_queue,
cl_kernel kernel,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueTask(
command_queue,
kernel,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(
cl_mem buffer,
cl_mem_flags flags,
cl_buffer_create_type buffer_create_type,
const void* buffer_create_info,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
return buffer->dispatch->clCreateSubBuffer(
buffer,
flags,
buffer_create_type,
buffer_create_info,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback(
cl_mem memobj,
void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data),
void* user_data) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
return memobj->dispatch->clSetMemObjectDestructorCallback(
memobj,
pfn_notify,
user_data);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent(
cl_context context,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateUserEvent(
context,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus(
cl_event event,
cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
return event->dispatch->clSetUserEventStatus(
event,
execution_status);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(
cl_event event,
cl_int command_exec_callback_type,
void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data),
void* user_data) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
return event->dispatch->clSetEventCallback(
event,
command_exec_callback_type,
pfn_notify,
user_data);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_read,
const size_t* buffer_offset,
const size_t* host_offset,
const size_t* region,
size_t buffer_row_pitch,
size_t buffer_slice_pitch,
size_t host_row_pitch,
size_t host_slice_pitch,
void* ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReadBufferRect(
command_queue,
buffer,
blocking_read,
buffer_offset,
host_offset,
region,
buffer_row_pitch,
buffer_slice_pitch,
host_row_pitch,
host_slice_pitch,
ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
const size_t* buffer_offset,
const size_t* host_offset,
const size_t* region,
size_t buffer_row_pitch,
size_t buffer_slice_pitch,
size_t host_row_pitch,
size_t host_slice_pitch,
const void* ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueWriteBufferRect(
command_queue,
buffer,
blocking_write,
buffer_offset,
host_offset,
region,
buffer_row_pitch,
buffer_slice_pitch,
host_row_pitch,
host_slice_pitch,
ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
const size_t* src_origin,
const size_t* dst_origin,
const size_t* region,
size_t src_row_pitch,
size_t src_slice_pitch,
size_t dst_row_pitch,
size_t dst_slice_pitch,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueCopyBufferRect(
command_queue,
src_buffer,
dst_buffer,
src_origin,
dst_origin,
region,
src_row_pitch,
src_slice_pitch,
dst_row_pitch,
dst_slice_pitch,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(
cl_device_id in_device,
const cl_device_partition_property* properties,
cl_uint num_devices,
cl_device_id* out_devices,
cl_uint* num_devices_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
return in_device->dispatch->clCreateSubDevices(
in_device,
properties,
num_devices,
out_devices,
num_devices_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clRetainDevice(
cl_device_id device) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
return device->dispatch->clRetainDevice(
device);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice(
cl_device_id device) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
return device->dispatch->clReleaseDevice(
device);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(
cl_context context,
cl_mem_flags flags,
const cl_image_format* image_format,
const cl_image_desc* image_desc,
void* host_ptr,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateImage(
context,
flags,
image_format,
image_desc,
host_ptr,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(
cl_context context,
cl_uint num_devices,
const cl_device_id* device_list,
const char* kernel_names,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateProgramWithBuiltInKernels(
context,
num_devices,
device_list,
kernel_names,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clCompileProgram(
cl_program program,
cl_uint num_devices,
const cl_device_id* device_list,
const char* options,
cl_uint num_input_headers,
const cl_program* input_headers,
const char** header_include_names,
void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
void* user_data) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clCompileProgram(
program,
num_devices,
device_list,
options,
num_input_headers,
input_headers,
header_include_names,
pfn_notify,
user_data);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(
cl_context context,
cl_uint num_devices,
const cl_device_id* device_list,
const char* options,
cl_uint num_input_programs,
const cl_program* input_programs,
void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
void* user_data,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clLinkProgram(
context,
num_devices,
device_list,
options,
num_input_programs,
input_programs,
pfn_notify,
user_data,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler(
cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clUnloadPlatformCompiler(
platform);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(
cl_kernel kernel,
cl_uint arg_index,
cl_kernel_arg_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clGetKernelArgInfo(
kernel,
arg_index,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(
cl_command_queue command_queue,
cl_mem buffer,
const void* pattern,
size_t pattern_size,
size_t offset,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueFillBuffer(
command_queue,
buffer,
pattern,
pattern_size,
offset,
size,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(
cl_command_queue command_queue,
cl_mem image,
const void* fill_color,
const size_t* origin,
const size_t* region,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueFillImage(
command_queue,
image,
fill_color,
origin,
region,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(
cl_command_queue command_queue,
cl_uint num_mem_objects,
const cl_mem* mem_objects,
cl_mem_migration_flags flags,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueMigrateMemObjects(
command_queue,
num_mem_objects,
mem_objects,
flags,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(
cl_command_queue command_queue,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueMarkerWithWaitList(
command_queue,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(
cl_command_queue command_queue,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueBarrierWithWaitList(
command_queue,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(
cl_context context,
cl_device_id device,
const cl_queue_properties* properties,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateCommandQueueWithProperties(
context,
device,
properties,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(
cl_context context,
cl_mem_flags flags,
cl_uint pipe_packet_size,
cl_uint pipe_max_packets,
const cl_pipe_properties* properties,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreatePipe(
context,
flags,
pipe_packet_size,
pipe_max_packets,
properties,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo(
cl_mem pipe,
cl_pipe_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
return pipe->dispatch->clGetPipeInfo(
pipe,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY void* CL_API_CALL clSVMAlloc(
cl_context context,
cl_svm_mem_flags flags,
size_t size,
cl_uint alignment) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, NULL);
return context->dispatch->clSVMAlloc(
context,
flags,
size,
alignment);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY void CL_API_CALL clSVMFree(
cl_context context,
void* svm_pointer) CL_API_SUFFIX__VERSION_2_0
{
if (context == NULL) return;
context->dispatch->clSVMFree(
context,
svm_pointer);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties(
cl_context context,
const cl_sampler_properties* sampler_properties,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateSamplerWithProperties(
context,
sampler_properties,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(
cl_kernel kernel,
cl_uint arg_index,
const void* arg_value) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clSetKernelArgSVMPointer(
kernel,
arg_index,
arg_value);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo(
cl_kernel kernel,
cl_kernel_exec_info param_name,
size_t param_value_size,
const void* param_value) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clSetKernelExecInfo(
kernel,
param_name,
param_value_size,
param_value);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree(
cl_command_queue command_queue,
cl_uint num_svm_pointers,
void* svm_pointers[],
void (CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers, void* svm_pointers[], void* user_data),
void* user_data,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueSVMFree(
command_queue,
num_svm_pointers,
svm_pointers,
pfn_free_func,
user_data,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy(
cl_command_queue command_queue,
cl_bool blocking_copy,
void* dst_ptr,
const void* src_ptr,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueSVMMemcpy(
command_queue,
blocking_copy,
dst_ptr,
src_ptr,
size,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(
cl_command_queue command_queue,
void* svm_ptr,
const void* pattern,
size_t pattern_size,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueSVMMemFill(
command_queue,
svm_ptr,
pattern,
pattern_size,
size,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(
cl_command_queue command_queue,
cl_bool blocking_map,
cl_map_flags flags,
void* svm_ptr,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueSVMMap(
command_queue,
blocking_map,
flags,
svm_ptr,
size,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap(
cl_command_queue command_queue,
void* svm_ptr,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_2_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueSVMUnmap(
command_queue,
svm_ptr,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(
cl_context context,
cl_device_id device,
cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
return context->dispatch->clSetDefaultDeviceCommandQueue(
context,
device,
command_queue);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer(
cl_device_id device,
cl_ulong* device_timestamp,
cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
return device->dispatch->clGetDeviceAndHostTimer(
device,
device_timestamp,
host_timestamp);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer(
cl_device_id device,
cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
return device->dispatch->clGetHostTimer(
device,
host_timestamp);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL(
cl_context context,
const void* il,
size_t length,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateProgramWithIL(
context,
il,
length,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel(
cl_kernel source_kernel,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
return source_kernel->dispatch->clCloneKernel(
source_kernel,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo(
cl_kernel kernel,
cl_device_id device,
cl_kernel_sub_group_info param_name,
size_t input_value_size,
const void* input_value,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
return kernel->dispatch->clGetKernelSubGroupInfo(
kernel,
device,
param_name,
input_value_size,
input_value,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem(
cl_command_queue command_queue,
cl_uint num_svm_pointers,
const void** svm_pointers,
const size_t* sizes,
cl_mem_migration_flags flags,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_2_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueSVMMigrateMem(
command_queue,
num_svm_pointers,
svm_pointers,
sizes,
flags,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant(
cl_program program,
cl_uint spec_id,
size_t spec_size,
const void* spec_value) CL_API_SUFFIX__VERSION_2_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clSetProgramSpecializationConstant(
program,
spec_id,
spec_size,
spec_value);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback(
cl_program program,
void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
void* user_data) CL_EXT_SUFFIX__VERSION_2_2_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
return program->dispatch->clSetProgramReleaseCallback(
program,
pfn_notify,
user_data);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback(
cl_context context,
void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data),
void* user_data) CL_API_SUFFIX__VERSION_3_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
return context->dispatch->clSetContextDestructorCallback(
context,
pfn_notify,
user_data);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties(
cl_context context,
const cl_mem_properties* properties,
cl_mem_flags flags,
size_t size,
void* host_ptr,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateBufferWithProperties(
context,
properties,
flags,
size,
host_ptr,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties(
cl_context context,
const cl_mem_properties* properties,
cl_mem_flags flags,
const cl_image_format* image_format,
const cl_image_desc* image_desc,
void* host_ptr,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateImageWithProperties(
context,
properties,
flags,
image_format,
image_desc,
host_ptr,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
// cl_ext_device_fission
CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT(
cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
return device->dispatch->clReleaseDeviceEXT(
device);
}
CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT(
cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
return device->dispatch->clRetainDeviceEXT(
device);
}
CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT(
cl_device_id in_device,
const cl_device_partition_property_ext* properties,
cl_uint num_entries,
cl_device_id* out_devices,
cl_uint* num_devices) CL_EXT_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
return in_device->dispatch->clCreateSubDevicesEXT(
in_device,
properties,
num_entries,
out_devices,
num_devices);
}
///////////////////////////////////////////////////////////////////////////////
// cl_khr_d3d10_sharing
#if defined(_WIN32)
CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR(
cl_platform_id platform,
cl_d3d10_device_source_khr d3d_device_source,
void* d3d_object,
cl_d3d10_device_set_khr d3d_device_set,
cl_uint num_entries,
cl_device_id* devices,
cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
platform,
d3d_device_source,
d3d_object,
d3d_device_set,
num_entries,
devices,
num_devices);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(
cl_context context,
cl_mem_flags flags,
ID3D10Buffer* resource,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromD3D10BufferKHR(
context,
flags,
resource,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(
cl_context context,
cl_mem_flags flags,
ID3D10Texture2D* resource,
UINT subresource,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromD3D10Texture2DKHR(
context,
flags,
resource,
subresource,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(
cl_context context,
cl_mem_flags flags,
ID3D10Texture3D* resource,
UINT subresource,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromD3D10Texture3DKHR(
context,
flags,
resource,
subresource,
errcode_ret);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
#endif // defined(_WIN32)
///////////////////////////////////////////////////////////////////////////////
// cl_khr_d3d11_sharing
#if defined(_WIN32)
CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR(
cl_platform_id platform,
cl_d3d11_device_source_khr d3d_device_source,
void* d3d_object,
cl_d3d11_device_set_khr d3d_device_set,
cl_uint num_entries,
cl_device_id* devices,
cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
platform,
d3d_device_source,
d3d_object,
d3d_device_set,
num_entries,
devices,
num_devices);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(
cl_context context,
cl_mem_flags flags,
ID3D11Buffer* resource,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromD3D11BufferKHR(
context,
flags,
resource,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(
cl_context context,
cl_mem_flags flags,
ID3D11Texture2D* resource,
UINT subresource,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromD3D11Texture2DKHR(
context,
flags,
resource,
subresource,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(
cl_context context,
cl_mem_flags flags,
ID3D11Texture3D* resource,
UINT subresource,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromD3D11Texture3DKHR(
context,
flags,
resource,
subresource,
errcode_ret);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
#endif // defined(_WIN32)
///////////////////////////////////////////////////////////////////////////////
// cl_khr_dx9_media_sharing
#if defined(_WIN32)
CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR(
cl_platform_id platform,
cl_uint num_media_adapters,
cl_dx9_media_adapter_type_khr* media_adapter_type,
void* media_adapters,
cl_dx9_media_adapter_set_khr media_adapter_set,
cl_uint num_entries,
cl_device_id* devices,
cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
platform,
num_media_adapters,
media_adapter_type,
media_adapters,
media_adapter_set,
num_entries,
devices,
num_devices);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(
cl_context context,
cl_mem_flags flags,
cl_dx9_media_adapter_type_khr adapter_type,
void* surface_info,
cl_uint plane,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromDX9MediaSurfaceKHR(
context,
flags,
adapter_type,
surface_info,
plane,
errcode_ret);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
#endif // defined(_WIN32)
///////////////////////////////////////////////////////////////////////////////
// cl_khr_egl_event
CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR(
cl_context context,
CLeglSyncKHR sync,
CLeglDisplayKHR display,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateEventFromEGLSyncKHR(
context,
sync,
display,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
// cl_khr_egl_image
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR(
cl_context context,
CLeglDisplayKHR egldisplay,
CLeglImageKHR eglimage,
cl_mem_flags flags,
const cl_egl_image_properties_khr* properties,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromEGLImageKHR(
context,
egldisplay,
eglimage,
flags,
properties,
errcode_ret);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
// cl_khr_gl_event
CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
cl_context context,
cl_GLsync sync,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateEventFromGLsyncKHR(
context,
sync,
errcode_ret);
}
///////////////////////////////////////////////////////////////////////////////
// cl_khr_gl_sharing
CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR(
const cl_context_properties* properties,
cl_gl_context_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
cl_platform_id platform = NULL;
khrIcdInitialize();
khrIcdContextPropertiesGetPlatform(properties, &platform);
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
return platform->dispatch->clGetGLContextInfoKHR(
properties,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(
cl_context context,
cl_mem_flags flags,
cl_GLuint bufobj,
int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromGLBuffer(
context,
flags,
bufobj,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
cl_context context,
cl_mem_flags flags,
cl_GLenum target,
cl_GLint miplevel,
cl_GLuint texture,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromGLTexture(
context,
flags,
target,
miplevel,
texture,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
cl_context context,
cl_mem_flags flags,
cl_GLenum target,
cl_GLint miplevel,
cl_GLuint texture,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromGLTexture2D(
context,
flags,
target,
miplevel,
texture,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
cl_context context,
cl_mem_flags flags,
cl_GLenum target,
cl_GLint miplevel,
cl_GLuint texture,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromGLTexture3D(
context,
flags,
target,
miplevel,
texture,
errcode_ret);
}
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(
cl_context context,
cl_mem_flags flags,
cl_GLuint renderbuffer,
cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
return context->dispatch->clCreateFromGLRenderbuffer(
context,
flags,
renderbuffer,
errcode_ret);
}
CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(
cl_mem memobj,
cl_gl_object_type* gl_object_type,
cl_GLuint* gl_object_name) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
return memobj->dispatch->clGetGLObjectInfo(
memobj,
gl_object_type,
gl_object_name);
}
CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
cl_mem memobj,
cl_gl_texture_info param_name,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
return memobj->dispatch->clGetGLTextureInfo(
memobj,
param_name,
param_value_size,
param_value,
param_value_size_ret);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueAcquireGLObjects(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem* mem_objects,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list,
cl_event* event) CL_API_SUFFIX__VERSION_1_0
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
return command_queue->dispatch->clEnqueueReleaseGLObjects(
command_queue,
num_objects,
mem_objects,
num_events_in_wait_list,
event_wait_list,
event);
}
///////////////////////////////////////////////////////////////////////////////
// cl_khr_subgroups
CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR(
cl_kernel in_kernel,
cl_device_id in_device,
cl_kernel_sub_group_info param_name,
size_t input_value_size,
const void* input_value,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0_DEPRECATED
{
KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
in_kernel,
in_device,
param_name,
input_value_size,
input_value,
param_value_size,
param_value,
param_value_size_ret);
}
///////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif