Struct OpenCl 

pub struct OpenCl { /* private fields */ }

Wrapper for the OpenCL API functions. These functions are marked as optional to avoid library load failure if a function is not present in the library.

Implementations

impl OpenCl

pub fn clGetPlatformIDs( &self, num_entries: cl_uint, platforms: *mut cl_platform_id, num_platforms: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetPlatformIDs(&self) -> bool

pub fn clGetPlatformInfo( &self, platform: cl_platform_id, param_name: cl_platform_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetPlatformInfo(&self) -> bool

pub fn clGetDeviceIDs( &self, platform: cl_platform_id, device_type: cl_device_type, num_entries: cl_uint, devices: *mut cl_device_id, num_devices: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetDeviceIDs(&self) -> bool

pub fn clGetDeviceInfo( &self, device: cl_device_id, param_name: cl_device_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetDeviceInfo(&self) -> bool

pub fn clCreateSubDevices( &self, in_device: cl_device_id, properties: *const cl_device_partition_property, num_devices: cl_uint, out_devices: *mut cl_device_id, num_devices_ret: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clCreateSubDevices(&self) -> bool

pub fn clRetainDevice(&self, device: cl_device_id) -> Option<cl_int>

pub fn has_clRetainDevice(&self) -> bool

pub fn clReleaseDevice(&self, device: cl_device_id) -> Option<cl_int>

pub fn has_clReleaseDevice(&self) -> bool

pub fn clSetDefaultDeviceCommandQueue( &self, context: cl_context, device: cl_device_id, command_queue: cl_command_queue, ) -> Option<cl_int>

pub fn has_clSetDefaultDeviceCommandQueue(&self) -> bool

pub fn clGetDeviceAndHostTimer( &self, device: cl_device_id, device_timestamp: *mut cl_ulong, host_timestamp: *mut cl_ulong, ) -> Option<cl_int>

pub fn has_clGetDeviceAndHostTimer(&self) -> bool

pub fn clGetHostTimer( &self, device: cl_device_id, host_timestamp: *mut cl_ulong, ) -> Option<cl_int>

pub fn has_clGetHostTimer(&self) -> bool

pub fn clCreateContext( &self, properties: *const cl_context_properties, num_devices: cl_uint, devices: *const cl_device_id, pfn_notify: Option<unsafe extern "C" fn(errinfo: *const c_char, private_info: *const c_void, cb: size_t, user_data: *mut c_void)>, user_data: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_context>

pub fn has_clCreateContext(&self) -> bool

pub fn clCreateContextFromType( &self, properties: *const cl_context_properties, device_type: cl_device_type, pfn_notify: Option<unsafe extern "C" fn(errinfo: *const c_char, private_info: *const c_void, cb: size_t, user_data: *mut c_void)>, user_data: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_context>

pub fn has_clCreateContextFromType(&self) -> bool

pub fn clRetainContext(&self, context: cl_context) -> Option<cl_int>

pub fn has_clRetainContext(&self) -> bool

pub fn clReleaseContext(&self, context: cl_context) -> Option<cl_int>

pub fn has_clReleaseContext(&self) -> bool

pub fn clGetContextInfo( &self, context: cl_context, param_name: cl_context_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetContextInfo(&self) -> bool

pub fn clSetContextDestructorCallback( &self, context: cl_context, pfn_notify: Option<unsafe extern "C" fn(context: cl_context, user_data: *mut c_void)>, user_data: *mut c_void, ) -> Option<cl_int>

pub fn has_clSetContextDestructorCallback(&self) -> bool

pub fn clCreateCommandQueueWithProperties( &self, context: cl_context, device: cl_device_id, properties: *const cl_queue_properties, errcode_ret: *mut cl_int, ) -> Option<cl_command_queue>

pub fn has_clCreateCommandQueueWithProperties(&self) -> bool

pub fn clRetainCommandQueue( &self, command_queue: cl_command_queue, ) -> Option<cl_int>

pub fn has_clRetainCommandQueue(&self) -> bool

pub fn clReleaseCommandQueue( &self, command_queue: cl_command_queue, ) -> Option<cl_int>

pub fn has_clReleaseCommandQueue(&self) -> bool

pub fn clGetCommandQueueInfo( &self, command_queue: cl_command_queue, param_name: cl_command_queue_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetCommandQueueInfo(&self) -> bool

pub fn clCreateBuffer( &self, context: cl_context, flags: cl_mem_flags, size: size_t, host_ptr: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateBuffer(&self) -> bool

pub fn clCreateSubBuffer( &self, buffer: cl_mem, flags: cl_mem_flags, buffer_create_type: cl_buffer_create_type, buffer_create_info: *const c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateSubBuffer(&self) -> bool

pub fn clCreateImage( &self, context: cl_context, flags: cl_mem_flags, image_format: *const cl_image_format, image_desc: *const cl_image_desc, host_ptr: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateImage(&self) -> bool

pub fn clCreatePipe( &self, context: cl_context, flags: cl_mem_flags, pipe_packet_size: cl_uint, pipe_max_packets: cl_uint, properties: *const cl_pipe_properties, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreatePipe(&self) -> bool

pub fn clCreateBufferWithProperties( &self, context: cl_context, properties: *const cl_mem_properties, flags: cl_mem_flags, size: size_t, host_ptr: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateBufferWithProperties(&self) -> bool

pub fn clCreateImageWithProperties( &self, context: cl_context, properties: *const cl_mem_properties, flags: cl_mem_flags, image_format: *const cl_image_format, image_desc: *const cl_image_desc, host_ptr: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateImageWithProperties(&self) -> bool

pub fn clRetainMemObject(&self, memobj: cl_mem) -> Option<cl_int>

pub fn has_clRetainMemObject(&self) -> bool

pub fn clReleaseMemObject(&self, memobj: cl_mem) -> Option<cl_int>

pub fn has_clReleaseMemObject(&self) -> bool

pub fn clGetSupportedImageFormats( &self, context: cl_context, flags: cl_mem_flags, image_type: cl_mem_object_type, num_entries: cl_uint, image_formats: *mut cl_image_format, num_image_formats: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetSupportedImageFormats(&self) -> bool

pub fn clGetMemObjectInfo( &self, memobj: cl_mem, param_name: cl_mem_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetMemObjectInfo(&self) -> bool

pub fn clGetImageInfo( &self, image: cl_mem, param_name: cl_image_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetImageInfo(&self) -> bool

pub fn clGetPipeInfo( &self, pipe: cl_mem, param_name: cl_pipe_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetPipeInfo(&self) -> bool

pub fn clSetMemObjectDestructorCallback( &self, memobj: cl_mem, pfn_notify: Option<unsafe extern "C" fn(memobj: cl_mem, user_data: *mut c_void)>, user_data: *mut c_void, ) -> Option<cl_int>

pub fn has_clSetMemObjectDestructorCallback(&self) -> bool

pub fn clSVMAlloc( &self, context: cl_context, flags: cl_svm_mem_flags, size: size_t, alignment: cl_uint, ) -> Option<*mut c_void>

pub fn has_clSVMAlloc(&self) -> bool

pub fn clSVMFree( &self, context: cl_context, svm_pointer: *mut c_void, ) -> Option<()>

pub fn has_clSVMFree(&self) -> bool

pub fn clCreateSamplerWithProperties( &self, context: cl_context, normalized_coords: *const cl_sampler_properties, errcode_ret: *mut cl_int, ) -> Option<cl_sampler>

pub fn has_clCreateSamplerWithProperties(&self) -> bool

pub fn clRetainSampler(&self, sampler: cl_sampler) -> Option<cl_int>

pub fn has_clRetainSampler(&self) -> bool

pub fn clReleaseSampler(&self, sampler: cl_sampler) -> Option<cl_int>

pub fn has_clReleaseSampler(&self) -> bool

pub fn clGetSamplerInfo( &self, sampler: cl_sampler, param_name: cl_sampler_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetSamplerInfo(&self) -> bool

pub fn clCreateProgramWithSource( &self, context: cl_context, count: cl_uint, strings: *const *const c_char, lengths: *const size_t, errcode_ret: *mut cl_int, ) -> Option<cl_program>

pub fn has_clCreateProgramWithSource(&self) -> bool

pub fn clCreateProgramWithBinary( &self, context: cl_context, num_devices: cl_uint, device_list: *const cl_device_id, lengths: *const size_t, binaries: *const *const c_uchar, binary_status: *mut cl_int, errcode_ret: *mut cl_int, ) -> Option<cl_program>

pub fn has_clCreateProgramWithBinary(&self) -> bool

pub fn clCreateProgramWithBuiltInKernels( &self, context: cl_context, num_devices: cl_uint, device_list: *const cl_device_id, kernel_names: *const c_char, errcode_ret: *mut cl_int, ) -> Option<cl_program>

pub fn has_clCreateProgramWithBuiltInKernels(&self) -> bool

pub fn clCreateProgramWithIL( &self, context: cl_context, il: *const c_void, length: size_t, errcode_ret: *mut cl_int, ) -> Option<cl_program>

pub fn has_clCreateProgramWithIL(&self) -> bool

pub fn clRetainProgram(&self, program: cl_program) -> Option<cl_int>

pub fn has_clRetainProgram(&self) -> bool

pub fn clReleaseProgram(&self, program: cl_program) -> Option<cl_int>

pub fn has_clReleaseProgram(&self) -> bool

pub fn clBuildProgram( &self, program: cl_program, num_devices: cl_uint, device_list: *const cl_device_id, options: *const c_char, pfn_notify: Option<unsafe extern "C" fn(program: cl_program, user_data: *mut c_void)>, user_data: *mut c_void, ) -> Option<cl_int>

pub fn has_clBuildProgram(&self) -> bool

pub fn clCompileProgram( &self, program: cl_program, num_devices: cl_uint, device_list: *const cl_device_id, options: *const c_char, num_input_headers: cl_uint, input_headers: *const cl_program, header_include_names: *const *const c_char, pfn_notify: Option<unsafe extern "C" fn(program: cl_program, user_data: *mut c_void)>, user_data: *mut c_void, ) -> Option<cl_int>

pub fn has_clCompileProgram(&self) -> bool

pub fn clLinkProgram( &self, context: cl_context, num_devices: cl_uint, device_list: *const cl_device_id, options: *const c_char, num_input_programs: cl_uint, input_programs: *const cl_program, pfn_notify: Option<unsafe extern "C" fn(program: cl_program, user_data: *mut c_void)>, user_data: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_program>

pub fn has_clLinkProgram(&self) -> bool

pub fn clSetProgramReleaseCallback( &self, program: cl_program, pfn_notify: Option<unsafe extern "C" fn(program: cl_program, user_data: *mut c_void)>, user_data: *mut c_void, ) -> Option<cl_int>

pub fn has_clSetProgramReleaseCallback(&self) -> bool

pub fn clSetProgramSpecializationConstant( &self, program: cl_program, spec_id: cl_uint, spec_size: size_t, spec_value: *const c_void, ) -> Option<cl_int>

pub fn has_clSetProgramSpecializationConstant(&self) -> bool

pub fn clUnloadPlatformCompiler( &self, platform: cl_platform_id, ) -> Option<cl_int>

pub fn has_clUnloadPlatformCompiler(&self) -> bool

pub fn clGetProgramInfo( &self, program: cl_program, param_name: cl_program_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetProgramInfo(&self) -> bool

pub fn clGetProgramBuildInfo( &self, program: cl_program, device: cl_device_id, param_name: cl_program_build_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetProgramBuildInfo(&self) -> bool

pub fn clCreateKernel( &self, program: cl_program, kernel_name: *const c_char, errcode_ret: *mut cl_int, ) -> Option<cl_kernel>

pub fn has_clCreateKernel(&self) -> bool

pub fn clCreateKernelsInProgram( &self, program: cl_program, num_kernels: cl_uint, kernels: *mut cl_kernel, num_kernels_ret: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clCreateKernelsInProgram(&self) -> bool

pub fn clCloneKernel( &self, source_kernel: cl_kernel, errcode_ret: *mut cl_int, ) -> Option<cl_kernel>

pub fn has_clCloneKernel(&self) -> bool

pub fn clRetainKernel(&self, kernel: cl_kernel) -> Option<cl_int>

pub fn has_clRetainKernel(&self) -> bool

pub fn clReleaseKernel(&self, kernel: cl_kernel) -> Option<cl_int>

pub fn has_clReleaseKernel(&self) -> bool

pub fn clSetKernelArg( &self, kernel: cl_kernel, arg_index: cl_uint, arg_size: size_t, arg_value: *const c_void, ) -> Option<cl_int>

pub fn has_clSetKernelArg(&self) -> bool

pub fn clSetKernelArgSVMPointer( &self, kernel: cl_kernel, arg_index: cl_uint, arg_value: *const c_void, ) -> Option<cl_int>

pub fn has_clSetKernelArgSVMPointer(&self) -> bool

pub fn clSetKernelExecInfo( &self, kernel: cl_kernel, param_name: cl_kernel_exec_info, param_value_size: size_t, param_value: *const c_void, ) -> Option<cl_int>

pub fn has_clSetKernelExecInfo(&self) -> bool

pub fn clGetKernelInfo( &self, kernel: cl_kernel, param_name: cl_kernel_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetKernelInfo(&self) -> bool

pub fn clGetKernelArgInfo( &self, kernel: cl_kernel, arg_indx: cl_uint, param_name: cl_kernel_arg_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetKernelArgInfo(&self) -> bool

pub fn clGetKernelWorkGroupInfo( &self, kernel: cl_kernel, device: cl_device_id, param_name: cl_kernel_work_group_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetKernelWorkGroupInfo(&self) -> bool

pub fn clGetKernelSubGroupInfo( &self, kernel: cl_kernel, device: cl_device_id, param_name: cl_kernel_sub_group_info, input_value_size: size_t, input_value: *const c_void, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetKernelSubGroupInfo(&self) -> bool

pub fn clWaitForEvents( &self, num_events: cl_uint, event_list: *const cl_event, ) -> Option<cl_int>

pub fn has_clWaitForEvents(&self) -> bool

pub fn clGetEventInfo( &self, event: cl_event, param_name: cl_event_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetEventInfo(&self) -> bool

pub fn clCreateUserEvent( &self, context: cl_context, errcode_ret: *mut cl_int, ) -> Option<cl_event>

pub fn has_clCreateUserEvent(&self) -> bool

pub fn clRetainEvent(&self, event: cl_event) -> Option<cl_int>

pub fn has_clRetainEvent(&self) -> bool

pub fn clReleaseEvent(&self, event: cl_event) -> Option<cl_int>

pub fn has_clReleaseEvent(&self) -> bool

pub fn clSetUserEventStatus( &self, event: cl_event, execution_status: cl_int, ) -> Option<cl_int>

pub fn has_clSetUserEventStatus(&self) -> bool

pub fn clSetEventCallback( &self, event: cl_event, command_exec_callback_type: cl_int, pfn_notify: Option<unsafe extern "C" fn(event: cl_event, event_command_status: cl_int, user_data: *mut c_void)>, user_data: *mut c_void, ) -> Option<cl_int>

pub fn has_clSetEventCallback(&self) -> bool

pub fn clGetEventProfilingInfo( &self, event: cl_event, param_name: cl_profiling_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetEventProfilingInfo(&self) -> bool

pub fn clFlush(&self, command_queue: cl_command_queue) -> Option<cl_int>

pub fn has_clFlush(&self) -> bool

pub fn clFinish(&self, command_queue: cl_command_queue) -> Option<cl_int>

pub fn has_clFinish(&self) -> bool

pub fn clEnqueueReadBuffer( &self, command_queue: cl_command_queue, buffer: cl_mem, blocking_read: cl_bool, offset: size_t, cb: size_t, ptr: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReadBuffer(&self) -> bool

pub fn clEnqueueReadBufferRect( &self, command_queue: cl_command_queue, buffer: cl_mem, blocking_read: cl_bool, buffer_origin: *const size_t, host_origin: *const size_t, region: *const size_t, buffer_row_pitch: size_t, buffer_slc_pitch: size_t, host_row_pitch: size_t, host_slc_pitch: size_t, ptr: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReadBufferRect(&self) -> bool

pub fn clEnqueueWriteBuffer( &self, command_queue: cl_command_queue, buffer: cl_mem, blocking_write: cl_bool, offset: size_t, cb: size_t, ptr: *const c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueWriteBuffer(&self) -> bool

pub fn clEnqueueWriteBufferRect( &self, command_queue: cl_command_queue, buffer: cl_mem, blocking_write: cl_bool, buffer_origin: *const size_t, host_origin: *const size_t, region: *const size_t, buffer_row_pitch: size_t, buffer_slc_pitch: size_t, host_row_pitch: size_t, host_slc_pitch: size_t, ptr: *const c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueWriteBufferRect(&self) -> bool

pub fn clEnqueueFillBuffer( &self, command_queue: cl_command_queue, buffer: cl_mem, pattern: *const c_void, pattern_size: size_t, offset: size_t, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueFillBuffer(&self) -> bool

pub fn clEnqueueCopyBuffer( &self, command_queue: cl_command_queue, src_buffer: cl_mem, dst_buffer: cl_mem, src_offset: size_t, dst_offset: size_t, cb: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueCopyBuffer(&self) -> bool

pub fn clEnqueueCopyBufferRect( &self, command_queue: cl_command_queue, src_buffer: cl_mem, dst_buffer: cl_mem, src_origin: *const size_t, dst_origin: *const size_t, region: *const size_t, src_row_pitch: size_t, src_slice_pitch: size_t, dst_row_pitch: size_t, dst_slice_pitch: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueCopyBufferRect(&self) -> bool

pub fn clEnqueueReadImage( &self, command_queue: cl_command_queue, image: cl_mem, blocking_read: cl_bool, origin: *const size_t, region: *const size_t, row_pitch: size_t, slice_pitch: size_t, ptr: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReadImage(&self) -> bool

pub fn clEnqueueWriteImage( &self, command_queue: cl_command_queue, image: cl_mem, blocking_write: cl_bool, origin: *const size_t, region: *const size_t, input_row_pitch: size_t, input_slice_pitch: size_t, ptr: *const c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueWriteImage(&self) -> bool

pub fn clEnqueueFillImage( &self, command_queue: cl_command_queue, image: cl_mem, fill_color: *const c_void, origin: *const size_t, region: *const size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueFillImage(&self) -> bool

pub fn clEnqueueCopyImage( &self, command_queue: cl_command_queue, src_image: cl_mem, dst_image: cl_mem, src_origin: *const size_t, dst_origin: *const size_t, region: *const size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueCopyImage(&self) -> bool

pub fn clEnqueueCopyImageToBuffer( &self, command_queue: cl_command_queue, src_image: cl_mem, dst_buffer: cl_mem, src_origin: *const size_t, region: *const size_t, dst_offset: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueCopyImageToBuffer(&self) -> bool

pub fn clEnqueueCopyBufferToImage( &self, command_queue: cl_command_queue, src_buffer: cl_mem, dst_image: cl_mem, src_offset: size_t, dst_origin: *const size_t, region: *const size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueCopyBufferToImage(&self) -> bool

pub fn clEnqueueMapBuffer( &self, command_queue: cl_command_queue, buffer: cl_mem, blocking_map: cl_bool, map_flags: cl_map_flags, offset: size_t, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, errcode_ret: *mut cl_int, ) -> Option<*mut c_void>

pub fn has_clEnqueueMapBuffer(&self) -> bool

pub fn clEnqueueMapImage( &self, command_queue: cl_command_queue, image: cl_mem, blocking_map: cl_bool, map_flags: cl_map_flags, origin: *const size_t, region: *const size_t, image_row_pitch: *mut size_t, image_slice_pitch: *mut size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, errcode_ret: *mut cl_int, ) -> Option<*mut c_void>

pub fn has_clEnqueueMapImage(&self) -> bool

pub fn clEnqueueUnmapMemObject( &self, command_queue: cl_command_queue, memobj: cl_mem, mapped_ptr: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueUnmapMemObject(&self) -> bool

pub fn clEnqueueMigrateMemObjects( &self, command_queue: cl_command_queue, num_mem_objects: cl_uint, mem_objects: *const cl_mem, flags: cl_mem_migration_flags, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMigrateMemObjects(&self) -> bool

pub fn clEnqueueNDRangeKernel( &self, command_queue: cl_command_queue, kernel: cl_kernel, work_dim: cl_uint, global_work_offset: *const size_t, global_work_dims: *const size_t, local_work_dims: *const size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueNDRangeKernel(&self) -> bool

pub fn clEnqueueNativeKernel( &self, command_queue: cl_command_queue, user_func: Option<unsafe extern "C" fn(arg1: *mut c_void)>, args: *mut c_void, cb_args: size_t, num_mem_objects: cl_uint, mem_list: *const cl_mem, args_mem_loc: *const *const c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueNativeKernel(&self) -> bool

pub fn clEnqueueMarkerWithWaitList( &self, command_queue: cl_command_queue, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMarkerWithWaitList(&self) -> bool

pub fn clEnqueueBarrierWithWaitList( &self, command_queue: cl_command_queue, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueBarrierWithWaitList(&self) -> bool

pub fn clEnqueueSVMFree( &self, command_queue: cl_command_queue, num_svm_pointers: cl_uint, svm_pointers: *const *const c_void, pfn_free_func: Option<unsafe extern "C" fn(queue: cl_command_queue, num_svm_pointers: cl_uint, svm_pointers: *mut *mut c_void, user_data: *mut c_void)>, user_data: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMFree(&self) -> bool

pub fn clEnqueueSVMMemcpy( &self, command_queue: cl_command_queue, blocking_copy: cl_bool, dst_ptr: *mut c_void, src_ptr: *const c_void, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMMemcpy(&self) -> bool

pub fn clEnqueueSVMMemFill( &self, command_queue: cl_command_queue, svm_ptr: *mut c_void, pattern: *const c_void, pattern_size: size_t, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMMemFill(&self) -> bool

pub fn clEnqueueSVMMap( &self, command_queue: cl_command_queue, blocking_map: cl_bool, flags: cl_map_flags, svm_ptr: *mut c_void, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMMap(&self) -> bool

pub fn clEnqueueSVMUnmap( &self, command_queue: cl_command_queue, svm_ptr: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMUnmap(&self) -> bool

pub fn clEnqueueSVMMigrateMem( &self, command_queue: cl_command_queue, num_svm_pointers: cl_uint, svm_pointers: *const *const c_void, sizes: *const size_t, flags: cl_mem_migration_flags, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMMigrateMem(&self) -> bool

pub fn clGetExtensionFunctionAddressForPlatform( &self, platform: cl_platform_id, func_name: *const c_char, ) -> Option<*mut c_void>

pub fn has_clGetExtensionFunctionAddressForPlatform(&self) -> bool

pub fn clCreateImage2D( &self, context: cl_context, flags: cl_mem_flags, image_format: *mut cl_image_format, image_width: size_t, image_depth: size_t, image_row_pitch: size_t, host_ptr: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateImage2D(&self) -> bool

pub fn clCreateImage3D( &self, context: cl_context, flags: cl_mem_flags, image_format: *mut cl_image_format, image_width: size_t, image_height: size_t, image_depth: size_t, image_row_pitch: size_t, image_slice_pitch: size_t, host_ptr: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateImage3D(&self) -> bool

pub fn clEnqueueMarker( &self, command_queue: cl_command_queue, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMarker(&self) -> bool

pub fn clEnqueueWaitForEvents( &self, command_queue: cl_command_queue, num_events: cl_uint, event_list: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueWaitForEvents(&self) -> bool

pub fn clEnqueueBarrier( &self, command_queue: cl_command_queue, ) -> Option<cl_int>

pub fn has_clEnqueueBarrier(&self) -> bool

pub fn clUnloadCompiler(&self) -> Option<cl_int>

pub fn has_clUnloadCompiler(&self) -> bool

pub fn clGetExtensionFunctionAddress( &self, func_name: *const c_char, ) -> Option<()>

pub fn has_clGetExtensionFunctionAddress(&self) -> bool

pub fn clCreateCommandQueue( &self, context: cl_context, device: cl_device_id, properties: cl_command_queue_properties, errcode_ret: *mut cl_int, ) -> Option<cl_command_queue>

pub fn has_clCreateCommandQueue(&self) -> bool

pub fn clCreateSampler( &self, context: cl_context, normalize_coords: cl_bool, addressing_mode: cl_addressing_mode, filter_mode: cl_filter_mode, errcode_ret: *mut cl_int, ) -> Option<cl_sampler>

pub fn has_clCreateSampler(&self) -> bool

pub fn clEnqueueTask( &self, command_queue: cl_command_queue, kernel: cl_kernel, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueTask(&self) -> bool

pub fn clGetSupportedD3D10TextureFormatsINTEL( &self, context: cl_context, flags: cl_mem_flags, image_type: cl_mem_object_type, num_entries: cl_uint, d3d10_formats: *mut DXGI_FORMAT, num_surface_formats: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetSupportedD3D10TextureFormatsINTEL(&self) -> bool

pub fn clGetSupportedD3D11TextureFormatsINTEL( &self, context: cl_context, flags: cl_mem_flags, image_type: cl_mem_object_type, plane: cl_uint, num_entries: cl_uint, d3d11_formats: *mut DXGI_FORMAT, num_surface_formats: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetSupportedD3D11TextureFormatsINTEL(&self) -> bool

pub fn clGetDeviceIDsFromDX9INTEL( &self, platform: cl_platform_id, dx9_device_source: cl_dx9_device_source_intel, dx9_object: *mut c_void, dx9_device_set: cl_dx9_device_set_intel, num_entries: cl_uint, devices: *mut cl_device_id, num_devices: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetDeviceIDsFromDX9INTEL(&self) -> bool

pub fn clCreateFromDX9MediaSurfaceINTEL( &self, context: cl_context, flags: cl_mem_flags, resource: IDirect3DSurface9_ptr, sharedHandle: HANDLE, plane: cl_uint, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateFromDX9MediaSurfaceINTEL(&self) -> bool

pub fn clEnqueueAcquireDX9ObjectsINTEL( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueAcquireDX9ObjectsINTEL(&self) -> bool

pub fn clEnqueueReleaseDX9ObjectsINTEL( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReleaseDX9ObjectsINTEL(&self) -> bool

pub fn clGetSupportedDX9MediaSurfaceFormatsINTEL( &self, context: cl_context, flags: cl_mem_flags, image_type: cl_mem_object_type, plane: cl_uint, num_entries: cl_uint, dx9_formats: *mut D3DFORMAT, num_surface_formats: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetSupportedDX9MediaSurfaceFormatsINTEL(&self) -> bool

pub fn clCreateFromEGLImageKHR( &self, context: cl_context, display: CLeglDisplayKHR, image: CLeglImageKHR, flags: cl_mem_flags, properties: *const cl_egl_image_properties_khr, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateFromEGLImageKHR(&self) -> bool

pub fn clEnqueueAcquireEGLObjectsKHR( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueAcquireEGLObjectsKHR(&self) -> bool

pub fn clEnqueueReleaseEGLObjectsKHR( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReleaseEGLObjectsKHR(&self) -> bool

pub fn clCreateEventFromEGLSyncKHR( &self, context: cl_context, sync: CLeglSyncKHR, display: CLeglDisplayKHR, errcode_ret: *mut cl_int, ) -> Option<cl_event>

pub fn has_clCreateEventFromEGLSyncKHR(&self) -> bool

pub fn clCreateCommandBufferKHR( &self, num_queues: cl_uint, queues: *const cl_command_queue, properties: *const cl_command_buffer_properties_khr, errcode_ret: *mut cl_int, ) -> Option<cl_command_buffer_khr>

pub fn has_clCreateCommandBufferKHR(&self) -> bool

pub fn clFinalizeCommandBufferKHR( &self, command_buffer: cl_command_buffer_khr, ) -> Option<cl_int>

pub fn has_clFinalizeCommandBufferKHR(&self) -> bool

pub fn clRetainCommandBufferKHR( &self, command_buffer: cl_command_buffer_khr, ) -> Option<cl_int>

pub fn has_clRetainCommandBufferKHR(&self) -> bool

pub fn clReleaseCommandBufferKHR( &self, command_buffer: cl_command_buffer_khr, ) -> Option<cl_int>

pub fn has_clReleaseCommandBufferKHR(&self) -> bool

pub fn clEnqueueCommandBufferKHR( &self, num_queues: cl_uint, queues: *mut cl_command_queue, command_buffer: cl_command_buffer_khr, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueCommandBufferKHR(&self) -> bool

pub fn clCommandBarrierWithWaitListKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandBarrierWithWaitListKHR(&self) -> bool

pub fn clCommandCopyBufferKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, src_buffer: cl_mem, dst_buffer: cl_mem, src_offset: size_t, dst_offset: size_t, size: size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandCopyBufferKHR(&self) -> bool

pub fn clCommandCopyBufferRectKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, src_buffer: cl_mem, dst_buffer: cl_mem, src_origin: *const size_t, dst_origin: *const size_t, region: *const size_t, src_row_pitch: size_t, src_slice_pitch: size_t, dst_row_pitch: size_t, dst_slice_pitch: size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandCopyBufferRectKHR(&self) -> bool

pub fn clCommandCopyBufferToImageKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, src_buffer: cl_mem, dst_image: cl_mem, src_offset: size_t, dst_origin: *const size_t, region: *const size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandCopyBufferToImageKHR(&self) -> bool

pub fn clCommandCopyImageKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, src_image: cl_mem, dst_image: cl_mem, src_origin: *const size_t, dst_origin: *const size_t, region: *const size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandCopyImageKHR(&self) -> bool

pub fn clCommandCopyImageToBufferKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, src_image: cl_mem, dst_buffer: cl_mem, src_origin: *const size_t, region: *const size_t, dst_offset: size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandCopyImageToBufferKHR(&self) -> bool

pub fn clCommandFillBufferKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, buffer: cl_mem, pattern: *const c_void, pattern_size: size_t, offset: size_t, size: size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandFillBufferKHR(&self) -> bool

pub fn clCommandFillImageKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, image: cl_mem, fill_color: *const c_void, origin: *const size_t, region: *const size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandFillImageKHR(&self) -> bool

pub fn clCommandNDRangeKernelKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, properties: *const cl_ndrange_kernel_command_properties_khr, kernel: cl_kernel, work_dim: cl_uint, global_work_offset: *const size_t, global_work_size: *const size_t, local_work_size: *const size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandNDRangeKernelKHR(&self) -> bool

pub fn clCommandSVMMemcpyKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, dst_ptr: *mut c_void, src_ptr: *const c_void, size: size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandSVMMemcpyKHR(&self) -> bool

pub fn clCommandSVMMemFillKHR( &self, command_buffer: cl_command_buffer_khr, command_queue: cl_command_queue, svm_ptr: *mut c_void, pattern: *const c_void, pattern_size: size_t, size: size_t, num_sync_points_in_wait_list: cl_uint, sync_point_wait_list: *const cl_sync_point_khr, sync_point: *mut cl_sync_point_khr, mutable_handle: *mut cl_mutable_command_khr, ) -> Option<cl_int>

pub fn has_clCommandSVMMemFillKHR(&self) -> bool

pub fn clGetCommandBufferInfoKHR( &self, command_buffer: cl_command_buffer_khr, param_name: cl_command_buffer_info_khr, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetCommandBufferInfoKHR(&self) -> bool

pub fn clRemapCommandBufferKHR( &self, command_buffer: cl_command_buffer_khr, automatic: cl_bool, num_queues: cl_uint, queues: *const cl_command_queue, num_handles: cl_uint, handles: *const cl_mutable_command_khr, handles_ret: *mut cl_mutable_command_khr, errcode_ret: *mut cl_int, ) -> Option<cl_command_buffer_khr>

pub fn has_clRemapCommandBufferKHR(&self) -> bool

pub fn clUpdateMutableCommandsKHR( &self, command_buffer: cl_command_buffer_khr, mutable_config: *const cl_mutable_base_config_khr, ) -> Option<cl_int>

pub fn has_clUpdateMutableCommandsKHR(&self) -> bool

pub fn clGetMutableCommandInfoKHR( &self, command: cl_mutable_command_khr, param_name: cl_mutable_command_info_khr, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetMutableCommandInfoKHR(&self) -> bool

pub fn clSetMemObjectDestructorAPPLE( &self, memobj: cl_mem, pfn_notify: Option<unsafe extern "C" fn(memobj: cl_mem, user_data: *mut c_void)>, user_data: *mut c_void, ) -> Option<cl_int>

pub fn has_clSetMemObjectDestructorAPPLE(&self) -> bool

pub fn clLogMessagesToSystemLogAPPLE( &self, errstr: *const c_char, private_info: *const c_void, cb: size_t, user_data: *mut c_void, ) -> Option<()>

pub fn has_clLogMessagesToSystemLogAPPLE(&self) -> bool

pub fn clLogMessagesToStdoutAPPLE( &self, errstr: *const c_char, private_info: *const c_void, cb: size_t, user_data: *mut c_void, ) -> Option<()>

pub fn has_clLogMessagesToStdoutAPPLE(&self) -> bool

pub fn clLogMessagesToStderrAPPLE( &self, errstr: *const c_char, private_info: *const c_void, cb: size_t, user_data: *mut c_void, ) -> Option<()>

pub fn has_clLogMessagesToStderrAPPLE(&self) -> bool

pub fn clIcdGetPlatformIDsKHR( &self, num_entries: cl_uint, platforms: *mut cl_platform_id, num_platforms: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clIcdGetPlatformIDsKHR(&self) -> bool

pub fn clCreateProgramWithILKHR( &self, context: cl_context, il: *const c_void, length: size_t, errcode_ret: *mut cl_int, ) -> Option<cl_program>

pub fn has_clCreateProgramWithILKHR(&self) -> bool

pub fn clTerminateContextKHR(&self, context: cl_context) -> Option<cl_int>

pub fn has_clTerminateContextKHR(&self) -> bool

pub fn clCreateCommandQueueWithPropertiesKHR( &self, context: cl_context, device: cl_device_id, properties: *const cl_queue_properties_khr, errcode_ret: *mut cl_int, ) -> Option<cl_command_queue>

pub fn has_clCreateCommandQueueWithPropertiesKHR(&self) -> bool

pub fn clReleaseDeviceEXT(&self, device: cl_device_id) -> Option<cl_int>

pub fn has_clReleaseDeviceEXT(&self) -> bool

pub fn clRetainDeviceEXT(&self, device: cl_device_id) -> Option<cl_int>

pub fn has_clRetainDeviceEXT(&self) -> bool

pub fn clCreateSubDevicesEXT( &self, in_device: cl_device_id, properties: *const cl_device_partition_property_ext, num_entries: cl_uint, out_devices: *mut cl_device_id, num_devices: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clCreateSubDevicesEXT(&self) -> bool

pub fn clEnqueueMigrateMemObjectEXT( &self, command_queue: cl_command_queue, num_mem_objects: cl_uint, mem_objects: *const cl_mem, flags: cl_mem_migration_flags_ext, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMigrateMemObjectEXT(&self) -> bool

pub fn clGetDeviceImageInfoQCOM( &self, device: cl_device_id, image_width: size_t, image_height: size_t, image_format: *const cl_image_format, param_name: cl_image_pitch_info_qcom, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetDeviceImageInfoQCOM(&self) -> bool

pub fn clEnqueueAcquireGrallocObjectsIMG( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueAcquireGrallocObjectsIMG(&self) -> bool

pub fn clEnqueueReleaseGrallocObjectsIMG( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReleaseGrallocObjectsIMG(&self) -> bool

pub fn clEnqueueGenerateMipmapIMG( &self, command_queue: cl_command_queue, src_image: cl_mem, dst_image: cl_mem, mipmap_filter_mode: cl_mipmap_filter_mode_img, array_region: *const size_t, mip_region: *const size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueGenerateMipmapIMG(&self) -> bool

pub fn clGetKernelSubGroupInfoKHR( &self, in_kernel: cl_kernel, in_device: cl_device_id, param_name: cl_kernel_sub_group_info, input_value_size: size_t, input_value: *const c_void, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetKernelSubGroupInfoKHR(&self) -> bool

pub fn clGetKernelSuggestedLocalWorkSizeKHR( &self, command_queue: cl_command_queue, kernel: cl_kernel, work_dim: cl_uint, global_work_offset: *const size_t, global_work_size: *const size_t, suggested_local_work_size: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetKernelSuggestedLocalWorkSizeKHR(&self) -> bool

pub fn clEnqueueAcquireExternalMemObjectsKHR( &self, command_queue: cl_command_queue, num_mem_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueAcquireExternalMemObjectsKHR(&self) -> bool

pub fn clEnqueueReleaseExternalMemObjectsKHR( &self, command_queue: cl_command_queue, num_mem_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReleaseExternalMemObjectsKHR(&self) -> bool

pub fn clGetSemaphoreHandleForTypeKHR( &self, sema_object: cl_semaphore_khr, device: cl_device_id, handle_type: cl_external_semaphore_handle_type_khr, handle_size: size_t, handle_ptr: *mut c_void, handle_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetSemaphoreHandleForTypeKHR(&self) -> bool

pub fn clReImportSemaphoreSyncFdKHR( &self, sema_object: cl_semaphore_khr, reimport_props: *mut cl_semaphore_reimport_properties_khr, fd: c_int, ) -> Option<cl_int>

pub fn has_clReImportSemaphoreSyncFdKHR(&self) -> bool

pub fn clCreateSemaphoreWithPropertiesKHR( &self, context: cl_context, sema_props: *const cl_semaphore_properties_khr, errcode_ret: *mut cl_int, ) -> Option<cl_semaphore_khr>

pub fn has_clCreateSemaphoreWithPropertiesKHR(&self) -> bool

pub fn clEnqueueWaitSemaphoresKHR( &self, command_queue: cl_command_queue, num_sema_objects: cl_uint, sema_objects: *const cl_semaphore_khr, sema_payload_list: *const cl_semaphore_payload_khr, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueWaitSemaphoresKHR(&self) -> bool

pub fn clEnqueueSignalSemaphoresKHR( &self, command_queue: cl_command_queue, num_sema_objects: cl_uint, sema_objects: *const cl_semaphore_khr, sema_payload_list: *const cl_semaphore_payload_khr, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSignalSemaphoresKHR(&self) -> bool

pub fn clGetSemaphoreInfoKHR( &self, sema_object: cl_semaphore_khr, param_name: cl_semaphore_info_khr, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetSemaphoreInfoKHR(&self) -> bool

pub fn clReleaseSemaphoreKHR( &self, sema_object: cl_semaphore_khr, ) -> Option<cl_int>

pub fn has_clReleaseSemaphoreKHR(&self) -> bool

pub fn clRetainSemaphoreKHR( &self, sema_object: cl_semaphore_khr, ) -> Option<cl_int>

pub fn has_clRetainSemaphoreKHR(&self) -> bool

pub fn clImportMemoryARM( &self, context: cl_context, flags: cl_mem_flags, properties: *const cl_import_properties_arm, memory: *mut c_void, size: size_t, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clImportMemoryARM(&self) -> bool

pub fn clSVMAllocARM( &self, context: cl_context, flags: cl_svm_mem_flags_arm, size: size_t, alignment: cl_uint, ) -> Option<*mut c_void>

pub fn has_clSVMAllocARM(&self) -> bool

pub fn clSVMFreeARM( &self, context: cl_context, svm_pointer: *mut c_void, ) -> Option<()>

pub fn has_clSVMFreeARM(&self) -> bool

pub fn clEnqueueSVMFreeARM( &self, command_queue: cl_command_queue, num_svm_pointers: cl_uint, svm_pointers: *mut *mut c_void, pfn_free_func: Option<unsafe extern "C" fn(queue: cl_command_queue, num_svm_pointers: cl_uint, svm_pointers: *mut *mut c_void, user_data: *mut c_void)>, user_data: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMFreeARM(&self) -> bool

pub fn clEnqueueSVMMemcpyARM( &self, command_queue: cl_command_queue, blocking_copy: cl_bool, dst_ptr: *mut c_void, src_ptr: *const c_void, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMMemcpyARM(&self) -> bool

pub fn clEnqueueSVMMemFillARM( &self, command_queue: cl_command_queue, svm_ptr: *mut c_void, pattern: *const c_void, pattern_size: size_t, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMMemFillARM(&self) -> bool

pub fn clEnqueueSVMMapARM( &self, command_queue: cl_command_queue, blocking_map: cl_bool, flags: cl_map_flags, svm_ptr: *mut c_void, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMMapARM(&self) -> bool

pub fn clEnqueueSVMUnmapARM( &self, command_queue: cl_command_queue, svm_ptr: *mut c_void, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueSVMUnmapARM(&self) -> bool

pub fn clSetKernelArgSVMPointerARM( &self, kernel: cl_kernel, arg_index: cl_uint, arg_value: *const c_void, ) -> Option<cl_int>

pub fn has_clSetKernelArgSVMPointerARM(&self) -> bool

pub fn clSetKernelExecInfoARM( &self, kernel: cl_kernel, param_name: cl_kernel_exec_info_arm, param_value_size: size_t, param_value: *const c_void, ) -> Option<cl_int>

pub fn has_clSetKernelExecInfoARM(&self) -> bool

pub fn clCreateAcceleratorINTEL( &self, context: cl_context, accelerator_type: cl_accelerator_type_intel, descriptor_size: size_t, descriptor: *const c_void, errcode_ret: *mut cl_int, ) -> Option<cl_accelerator_intel>

pub fn has_clCreateAcceleratorINTEL(&self) -> bool

pub fn clGetAcceleratorInfoINTEL( &self, accelerator: cl_accelerator_intel, param_name: cl_accelerator_info_intel, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetAcceleratorInfoINTEL(&self) -> bool

pub fn clRetainAcceleratorINTEL( &self, accelerator: cl_accelerator_intel, ) -> Option<cl_int>

pub fn has_clRetainAcceleratorINTEL(&self) -> bool

pub fn clReleaseAcceleratorINTEL( &self, accelerator: cl_accelerator_intel, ) -> Option<cl_int>

pub fn has_clReleaseAcceleratorINTEL(&self) -> bool

pub fn clHostMemAllocINTEL( &self, context: cl_context, properties: *const cl_mem_properties_intel, size: size_t, alignment: cl_uint, errcode_ret: *mut cl_int, ) -> Option<*mut c_void>

pub fn has_clHostMemAllocINTEL(&self) -> bool

pub fn clDeviceMemAllocINTEL( &self, context: cl_context, device: cl_device_id, properties: *const cl_mem_properties_intel, size: size_t, alignment: cl_uint, errcode_ret: *mut cl_int, ) -> Option<*mut c_void>

pub fn has_clDeviceMemAllocINTEL(&self) -> bool

pub fn clSharedMemAllocINTEL( &self, context: cl_context, device: cl_device_id, properties: *const cl_mem_properties_intel, size: size_t, alignment: cl_uint, errcode_ret: *mut cl_int, ) -> Option<*mut c_void>

pub fn has_clSharedMemAllocINTEL(&self) -> bool

pub fn clMemFreeINTEL( &self, context: cl_context, ptr: *mut c_void, ) -> Option<cl_int>

pub fn has_clMemFreeINTEL(&self) -> bool

pub fn clMemBlockingFreeINTEL( &self, context: cl_context, ptr: *mut c_void, ) -> Option<cl_int>

pub fn has_clMemBlockingFreeINTEL(&self) -> bool

pub fn clGetMemAllocInfoINTEL( &self, context: cl_context, ptr: *const c_void, param_name: cl_mem_info_intel, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetMemAllocInfoINTEL(&self) -> bool

pub fn clSetKernelArgMemPointerINTEL( &self, kernel: cl_kernel, arg_index: cl_uint, arg_value: *const c_void, ) -> Option<cl_int>

pub fn has_clSetKernelArgMemPointerINTEL(&self) -> bool

pub fn clEnqueueMemFillINTEL( &self, command_queue: cl_command_queue, dst_ptr: *mut c_void, pattern: *const c_void, pattern_size: size_t, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMemFillINTEL(&self) -> bool

pub fn clEnqueueMemcpyINTEL( &self, command_queue: cl_command_queue, blocking: cl_bool, dst_ptr: *mut c_void, src_ptr: *const c_void, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMemcpyINTEL(&self) -> bool

pub fn clEnqueueMemAdviseINTEL( &self, command_queue: cl_command_queue, ptr: *const c_void, size: size_t, advice: cl_mem_advice_intel, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMemAdviseINTEL(&self) -> bool

pub fn clEnqueueMigrateMemINTEL( &self, command_queue: cl_command_queue, ptr: *const c_void, size: size_t, flags: cl_mem_migration_flags, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMigrateMemINTEL(&self) -> bool

pub fn clEnqueueMemsetINTEL( &self, command_queue: cl_command_queue, dst_ptr: *mut c_void, value: cl_int, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueMemsetINTEL(&self) -> bool

pub fn clCreateBufferWithPropertiesINTEL( &self, context: cl_context, properties: *const cl_mem_properties_intel, flags: cl_mem_flags, size: size_t, host_ptr: *mut c_void, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateBufferWithPropertiesINTEL(&self) -> bool

pub fn clEnqueueReadHostPipeINTEL( &self, queue: cl_command_queue, program: cl_program, pipe_symbol: *const c_char, blocking_read: cl_bool, ptr: *mut c_void, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReadHostPipeINTEL(&self) -> bool

pub fn clEnqueueWriteHostPipeINTEL( &self, queue: cl_command_queue, program: cl_program, pipe_symbol: *const c_char, blocking_write: cl_bool, ptr: *const c_void, size: size_t, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueWriteHostPipeINTEL(&self) -> bool

pub fn clGetImageRequirementsInfoEXT( &self, context: cl_context, properties: *const cl_mem_properties, flags: cl_mem_flags, image_format: *const cl_image_format, image_desc: *const cl_image_desc, param_name: cl_image_requirements_info_ext, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetImageRequirementsInfoEXT(&self) -> bool

pub fn clGetICDLoaderInfoOCLICD( &self, param_name: cl_icdl_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetICDLoaderInfoOCLICD(&self) -> bool

pub fn clSetContentSizeBufferPoCL( &self, buffer: cl_mem, content_size_buffer: cl_mem, ) -> Option<cl_int>

pub fn has_clSetContentSizeBufferPoCL(&self) -> bool

pub fn clCreateFromGLBuffer( &self, context: cl_context, flags: cl_mem_flags, bufobj: cl_GLuint, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateFromGLBuffer(&self) -> bool

pub fn clCreateFromGLTexture( &self, context: cl_context, flags: cl_mem_flags, target: cl_GLenum, miplevel: cl_GLint, texture: cl_GLuint, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateFromGLTexture(&self) -> bool

pub fn clCreateFromGLRenderbuffer( &self, context: cl_context, flags: cl_mem_flags, renderbuffer: cl_GLuint, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateFromGLRenderbuffer(&self) -> bool

pub fn clGetGLObjectInfo( &self, memobj: cl_mem, gl_object_type: *mut cl_gl_object_type, gl_object_name: *mut cl_GLuint, ) -> Option<cl_int>

pub fn has_clGetGLObjectInfo(&self) -> bool

pub fn clGetGLTextureInfo( &self, memobj: cl_mem, param_name: cl_gl_texture_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetGLTextureInfo(&self) -> bool

pub fn clEnqueueAcquireGLObjects( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueAcquireGLObjects(&self) -> bool

pub fn clEnqueueReleaseGLObjects( &self, command_queue: cl_command_queue, num_objects: cl_uint, mem_objects: *const cl_mem, num_events_in_wait_list: cl_uint, event_wait_list: *const cl_event, event: *mut cl_event, ) -> Option<cl_int>

pub fn has_clEnqueueReleaseGLObjects(&self) -> bool

pub fn clCreateFromGLTexture2D( &self, context: cl_context, flags: cl_mem_flags, texture_target: cl_GLenum, miplevel: cl_GLint, texture: cl_GLuint, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateFromGLTexture2D(&self) -> bool

pub fn clCreateFromGLTexture3D( &self, context: cl_context, flags: cl_mem_flags, texture_target: cl_GLenum, miplevel: cl_GLint, texture: cl_GLuint, errcode_ret: *mut cl_int, ) -> Option<cl_mem>

pub fn has_clCreateFromGLTexture3D(&self) -> bool

pub fn clGetGLContextInfoKHR( &self, properties: *const cl_context_properties, param_name: cl_gl_context_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetGLContextInfoKHR(&self) -> bool

pub fn clCreateEventFromGLsyncKHR( &self, context: cl_context, sync: cl_GLsync, errcode_ret: *mut cl_int, ) -> Option<cl_event>

pub fn has_clCreateEventFromGLsyncKHR(&self) -> bool

pub fn clGetSupportedGLTextureFormatsINTEL( &self, context: cl_context, flags: cl_mem_flags, image_type: cl_mem_object_type, num_entries: cl_uint, gl_formats: *mut cl_GLenum, num_texture_formats: *mut cl_uint, ) -> Option<cl_int>

pub fn has_clGetSupportedGLTextureFormatsINTEL(&self) -> bool

pub fn clGetLayerInfo( &self, param_name: cl_layer_info, param_value_size: size_t, param_value: *mut c_void, param_value_size_ret: *mut size_t, ) -> Option<cl_int>

pub fn has_clGetLayerInfo(&self) -> bool

pub fn clInitLayer( &self, num_entries: cl_uint, target_dispatch: *const cl_icd_dispatch, num_entries_ret: *mut cl_uint, layer_dispatch_ret: *mut *const cl_icd_dispatch, ) -> Option<cl_int>

pub fn has_clInitLayer(&self) -> bool

Trait Implementations

impl WrapperApi for OpenCl

unsafe fn load(lib: &Library) -> Result<Self, Error>

Load symbols from provided library.