Skip to content

W
wine-winehq
Commit 6b15f4d6 authored by Zebediah Figura's avatar Zebediah Figura Committed by Alexandre Julliard
Browse files
Options

opencl: Move libOpenCL support to a new Unix library.

Signed-off-by: 's avatarZebediah Figura <z.figura12@gmail.com> Signed-off-by: 's avatarAlexandre Julliard <julliard@winehq.org>
parent 4d582411
Hide whitespace changes
Inline Side-by-side
Showing with 858 additions and 203 deletions
dlls/opencl/Makefile.in
View file @ 6b15f4d6
......@@ -2,5 +2,7 @@ MODULE = opencl.dll
EXTRALIBS = $(OPENCL_LIBS)
C_SRCS = \
opencl.c \
opencl_thunks.c
pe_thunks.c \
pe_wrappers.c \
unix_thunks.c \
unix_wrappers.c
dlls/opencl/make_opencl
View file @ 6b15f4d6
......@@ -20,7 +20,9 @@ use XML::LibXML;
# Files to generate
my $spec_file = "opencl.spec";
my $thunks_file = "opencl_thunks.c";
my $pe_file = "pe_thunks.c";
my $unix_file = "unix_thunks.c";
my $unixheader_file = "unixlib.h";
# If set to 1, generate TRACEs for each OpenGL function
my $gen_traces = 1;
......@@ -49,7 +51,7 @@ my %arg_types =
"unsigned int" => [ "long", "%u" ],
);
sub generate_thunk($$)
sub generate_pe_thunk($$)
{
my ($name, $func_ref) = @_;
my $call_arg = "";
......@@ -86,6 +88,28 @@ sub generate_thunk($$)
$ret .= " TRACE( \"($trace_arg)\\n\"$trace_call_arg );\n" if $gen_traces;
$ret .= " ";
$ret .= "return " unless is_void_func( $func_ref );
$ret .= "opencl_funcs->p$name($call_arg);\n";
$ret .= "}\n";
return $ret;
}
sub generate_unix_thunk($$)
{
my ($name, $func_ref) = @_;
my $call_arg = "";
my $ret = get_func_proto( "static %s WINAPI wrap_%s(%s)", $name, $func_ref );
foreach my $arg (@{$func_ref->[1]})
{
my $ptype = get_arg_type( $arg );
next unless $arg->findnodes("./name");
my $pname = get_arg_name( $arg );
my $param = $arg->textContent();
$call_arg .= " " . $pname . ",";
}
$call_arg =~ s/,$/ /;
$ret .= "\n{\n ";
$ret .= "return " unless is_void_func( $func_ref );
$ret .= "$name($call_arg);\n";
$ret .= "}\n";
return $ret;
......@@ -122,6 +146,7 @@ sub get_func_proto($$$)
foreach my $arg (@{$func->[1]})
{
(my $argtext = $arg->textContent()) =~ s/ +/ /g;
$argtext =~ s/CL_CALLBACK/WINAPI/g;
$args .= " " . $argtext . ",";
}
$args =~ s/,$/ /;
......@@ -180,16 +205,10 @@ my %cl_enums;
my (%cl_types, @cl_types); # also use an array to preserve declaration order
# some functions need a hand-written wrapper
sub needs_wrapper($)
sub needs_pe_wrapper($)
{
my %funcs =
(
# need callback conversion
"clBuildProgram" => 1,
"clCreateContext" => 1,
"clCreateContextFromType" => 1,
"clEnqueueNativeKernel" => 1,
# need extension filtering
"clGetDeviceInfo" => 1,
"clGetPlatformInfo" => 1,
......@@ -202,6 +221,22 @@ sub needs_wrapper($)
return defined $funcs{$name};
}
# some functions need a hand-written wrapper
sub needs_unix_wrapper($)
{
my %funcs =
(
# need callback conversion
"clBuildProgram" => 1,
"clCreateContext" => 1,
"clCreateContextFromType" => 1,
"clEnqueueNativeKernel" => 1,
);
my $name = shift;
return defined $funcs{$name};
}
sub parse_file($)
{
my $file = shift;
......@@ -279,21 +314,66 @@ foreach (sort keys %core_functions)
close(SPEC);
my $file_header =
"/* Automatically generated from OpenCL registry files; DO NOT EDIT! */\n\n" .
"#include \"config.h\"\n" .
"#include \"opencl_private.h\"\n\n";
# generate the PE thunks
open(PE, ">$pe_file") or die "cannot create $pe_file";
print PE "/* Automatically generated from OpenCL registry files; DO NOT EDIT! */\n\n";
print PE "#include \"config.h\"\n";
print PE "#include \"opencl_private.h\"\n\n";
print PE "WINE_DEFAULT_DEBUG_CHANNEL(opencl);\n" if $gen_traces;
foreach (sort keys %core_functions)
{
next if needs_pe_wrapper( $_ );
print PE "\n", generate_pe_thunk( $_, $core_functions{$_} );
}
close(PE);
# generate the unix library thunks
open(UNIX, ">$unix_file") or die "cannot create $unix_file";
print UNIX <<EOF
/* Automatically generated from OpenCL registry files; DO NOT EDIT! */
#if 0
#pragma makedep unix
#endif
$file_header .= "WINE_DEFAULT_DEBUG_CHANNEL(opencl);\n" if $gen_traces;
#include "config.h"
#include "unix_private.h"
EOF
;
# generate the thunks file
open(THUNKS, ">$thunks_file") or die "cannot create $thunks_file";
print THUNKS $file_header;
foreach (sort keys %core_functions)
{
next if needs_unix_wrapper( $_ );
print UNIX "\n", generate_unix_thunk( $_, $core_functions{$_} );
}
print UNIX "\nconst struct opencl_funcs funcs =\n{\n";
foreach (sort keys %core_functions)
{
next if needs_wrapper( $_ );
print THUNKS "\n", generate_thunk( $_, $core_functions{$_} );
print UNIX " wrap_" . $_ . ",\n";
}
print UNIX "};\n";
close(UNIX);
# generate the unix library header
open(UNIXHEADER, ">$unixheader_file") or die "cannot create $unixheader_file";
print UNIXHEADER "/* Automatically generated from OpenCL registry files; DO NOT EDIT! */\n\n";
print UNIXHEADER "struct opencl_funcs\n{\n";
foreach (sort keys %core_functions)
{
print UNIXHEADER get_func_proto( " %s (WINAPI *p%s)(%s);\n", $_, $core_functions{$_} );
}
print UNIXHEADER "};\n\n";
print UNIXHEADER "extern const struct opencl_funcs *opencl_funcs;\n";
close(THUNKS);
close(UNIXHEADER);
dlls/opencl/opencl_private.h
View file @ 6b15f4d6
......@@ -21,8 +21,11 @@
#include <stdarg.h>
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winbase.h"
#include "winternl.h"
#include "wine/debug.h"
......@@ -38,4 +41,6 @@
#include <OpenCL/opencl.h>
#endif
#include "unixlib.h"
#endif
dlls/opencl/opencl_thunks.c → dlls/opencl/pe_thunks.c
View file @ 6b15f4d6
......@@ -5,356 +5,380 @@
WINE_DEFAULT_DEBUG_CHANNEL(opencl);
cl_int WINAPI wine_clBuildProgram( cl_program program, cl_uint num_devices, const cl_device_id* device_list, const char* options, void (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data )
{
TRACE( "(%p, %u, %p, %p, %p, %p)\n", program, num_devices, device_list, options, pfn_notify, user_data );
return opencl_funcs->pclBuildProgram( program, num_devices, device_list, options, pfn_notify, user_data );
}
cl_mem WINAPI wine_clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret )
{
TRACE( "(%p, %s, %zu, %p, %p)\n", context, wine_dbgstr_longlong(flags), size, host_ptr, errcode_ret );
return clCreateBuffer( context, flags, size, host_ptr, errcode_ret );
return opencl_funcs->pclCreateBuffer( context, flags, size, host_ptr, errcode_ret );
}
cl_command_queue WINAPI wine_clCreateCommandQueue( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret )
{
TRACE( "(%p, %p, %s, %p)\n", context, device, wine_dbgstr_longlong(properties), errcode_ret );
return clCreateCommandQueue( context, device, properties, errcode_ret );
return opencl_funcs->pclCreateCommandQueue( context, device, properties, errcode_ret );
}
cl_context WINAPI wine_clCreateContext( const cl_context_properties* properties, cl_uint num_devices, const cl_device_id* devices, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret )
{
TRACE( "(%p, %u, %p, %p, %p, %p)\n", properties, num_devices, devices, pfn_notify, user_data, errcode_ret );
return opencl_funcs->pclCreateContext( properties, num_devices, devices, pfn_notify, user_data, errcode_ret );
}
cl_context WINAPI wine_clCreateContextFromType( const cl_context_properties* properties, cl_device_type device_type, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret )
{
TRACE( "(%p, %s, %p, %p, %p)\n", properties, wine_dbgstr_longlong(device_type), pfn_notify, user_data, errcode_ret );
return opencl_funcs->pclCreateContextFromType( properties, device_type, pfn_notify, user_data, errcode_ret );
}
cl_mem WINAPI wine_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 )
{
TRACE( "(%p, %s, %p, %zu, %zu, %zu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
return clCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
return opencl_funcs->pclCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
}
cl_mem WINAPI wine_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 )
{
TRACE( "(%p, %s, %p, %zu, %zu, %zu, %zu, %zu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
return clCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
return opencl_funcs->pclCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
}
cl_kernel WINAPI wine_clCreateKernel( cl_program program, const char* kernel_name, cl_int* errcode_ret )
{
TRACE( "(%p, %p, %p)\n", program, kernel_name, errcode_ret );
return clCreateKernel( program, kernel_name, errcode_ret );
return opencl_funcs->pclCreateKernel( program, kernel_name, errcode_ret );
}
cl_int WINAPI wine_clCreateKernelsInProgram( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret )
{
TRACE( "(%p, %u, %p, %p)\n", program, num_kernels, kernels, num_kernels_ret );
return clCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
return opencl_funcs->pclCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
}
cl_program WINAPI wine_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 )
{
TRACE( "(%p, %u, %p, %p, %p, %p, %p)\n", context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
return clCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
return opencl_funcs->pclCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
}
cl_program WINAPI wine_clCreateProgramWithSource( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret )
{
TRACE( "(%p, %u, %p, %p, %p)\n", context, count, strings, lengths, errcode_ret );
return clCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
return opencl_funcs->pclCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
}
cl_sampler WINAPI wine_clCreateSampler( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret )
{
TRACE( "(%p, %u, %u, %u, %p)\n", context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
return clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
return opencl_funcs->pclCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
}
cl_int WINAPI wine_clEnqueueBarrier( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
return clEnqueueBarrier( command_queue );
return opencl_funcs->pclEnqueueBarrier( command_queue );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %p, %zu, %zu, %zu, %u, %p, %p)\n", command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
return clEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %p, %zu, %p, %p, %u, %p, %p)\n", command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
return clEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %p, %p, %p, %p, %u, %p, %p)\n", command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
return clEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %p, %p, %p, %zu, %u, %p, %p)\n", command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
return clEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
}
void* WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %s, %zu, %zu, %u, %p, %p, %p)\n", command_queue, buffer, blocking_map, wine_dbgstr_longlong(map_flags), offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
return clEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
return opencl_funcs->pclEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
}
void* WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %s, %p, %p, %p, %p, %u, %p, %p, %p)\n", command_queue, image, blocking_map, wine_dbgstr_longlong(map_flags), origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret );
return 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 );
return opencl_funcs->pclEnqueueMapImage( 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_int WINAPI wine_clEnqueueMarker( cl_command_queue command_queue, cl_event* event )
{
TRACE( "(%p, %p)\n", command_queue, event );
return clEnqueueMarker( command_queue, event );
return opencl_funcs->pclEnqueueMarker( command_queue, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %p, %p, %p, %u, %p, %p)\n", command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
return clEnqueueNDRangeKernel( command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueNDRangeKernel( command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueNativeKernel( cl_command_queue command_queue, void (WINAPI* 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 )
{
TRACE( "(%p, %p, %p, %zu, %u, %p, %p, %u, %p, %p)\n", command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueNativeKernel( 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_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %zu, %zu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
return clEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %p, %p, %zu, %zu, %p, %u, %p, %p)\n", command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
return clEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %p, %p)\n", command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
return clEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %p, %u, %p, %p)\n", command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
return clEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueWaitForEvents( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list )
{
TRACE( "(%p, %u, %p)\n", command_queue, num_events, event_list );
return clEnqueueWaitForEvents( command_queue, num_events, event_list );
return opencl_funcs->pclEnqueueWaitForEvents( command_queue, num_events, event_list );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %zu, %zu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
return clEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %p, %p, %zu, %zu, %p, %u, %p, %p)\n", command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
return clEnqueueWriteImage( command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
return opencl_funcs->pclEnqueueWriteImage( command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clFinish( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
return clFinish( command_queue );
return opencl_funcs->pclFinish( command_queue );
}
cl_int WINAPI wine_clFlush( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
return clFlush( command_queue );
return opencl_funcs->pclFlush( command_queue );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", command_queue, param_name, param_value_size, param_value, param_value_size_ret );
return clGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetContextInfo( cl_context context, cl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", context, param_name, param_value_size, param_value, param_value_size_ret );
return clGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetDeviceIDs( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices )
{
TRACE( "(%p, %s, %u, %p, %p)\n", platform, wine_dbgstr_longlong(device_type), num_entries, devices, num_devices );
return clGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
return opencl_funcs->pclGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
}
cl_int WINAPI wine_clGetEventInfo( cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", event, param_name, param_value_size, param_value, param_value_size_ret );
return clGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetEventProfilingInfo( cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", event, param_name, param_value_size, param_value, param_value_size_ret );
return clGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetImageInfo( cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", image, param_name, param_value_size, param_value, param_value_size_ret );
return clGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetKernelInfo( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", kernel, param_name, param_value_size, param_value, param_value_size_ret );
return clGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %zu, %p, %p)\n", kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
return clGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetMemObjectInfo( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", memobj, param_name, param_value_size, param_value, param_value_size_ret );
return clGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms )
{
TRACE( "(%u, %p, %p)\n", num_entries, platforms, num_platforms );
return clGetPlatformIDs( num_entries, platforms, num_platforms );
return opencl_funcs->pclGetPlatformIDs( num_entries, platforms, num_platforms );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %p, %u, %zu, %p, %p)\n", program, device, param_name, param_value_size, param_value, param_value_size_ret );
return clGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetProgramInfo( cl_program program, cl_program_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", program, param_name, param_value_size, param_value, param_value_size_ret );
return clGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetSamplerInfo( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", sampler, param_name, param_value_size, param_value, param_value_size_ret );
return clGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
return opencl_funcs->pclGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_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 )
{
TRACE( "(%p, %s, %u, %u, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_type, num_entries, image_formats, num_image_formats );
return clGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
return opencl_funcs->pclGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
}
cl_int WINAPI wine_clReleaseCommandQueue( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
return clReleaseCommandQueue( command_queue );
return opencl_funcs->pclReleaseCommandQueue( command_queue );
}
cl_int WINAPI wine_clReleaseContext( cl_context context )
{
TRACE( "(%p)\n", context );
return clReleaseContext( context );
return opencl_funcs->pclReleaseContext( context );
}
cl_int WINAPI wine_clReleaseEvent( cl_event event )
{
TRACE( "(%p)\n", event );
return clReleaseEvent( event );
return opencl_funcs->pclReleaseEvent( event );
}
cl_int WINAPI wine_clReleaseKernel( cl_kernel kernel )
{
TRACE( "(%p)\n", kernel );
return clReleaseKernel( kernel );
return opencl_funcs->pclReleaseKernel( kernel );
}
cl_int WINAPI wine_clReleaseMemObject( cl_mem memobj )
{
TRACE( "(%p)\n", memobj );
return clReleaseMemObject( memobj );
return opencl_funcs->pclReleaseMemObject( memobj );
}
cl_int WINAPI wine_clReleaseProgram( cl_program program )
{
TRACE( "(%p)\n", program );
return clReleaseProgram( program );
return opencl_funcs->pclReleaseProgram( program );
}
cl_int WINAPI wine_clReleaseSampler( cl_sampler sampler )
{
TRACE( "(%p)\n", sampler );
return clReleaseSampler( sampler );
return opencl_funcs->pclReleaseSampler( sampler );
}
cl_int WINAPI wine_clRetainCommandQueue( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
return clRetainCommandQueue( command_queue );
return opencl_funcs->pclRetainCommandQueue( command_queue );
}
cl_int WINAPI wine_clRetainContext( cl_context context )
{
TRACE( "(%p)\n", context );
return clRetainContext( context );
return opencl_funcs->pclRetainContext( context );
}
cl_int WINAPI wine_clRetainEvent( cl_event event )
{
TRACE( "(%p)\n", event );
return clRetainEvent( event );
return opencl_funcs->pclRetainEvent( event );
}
cl_int WINAPI wine_clRetainKernel( cl_kernel kernel )
{
TRACE( "(%p)\n", kernel );
return clRetainKernel( kernel );
return opencl_funcs->pclRetainKernel( kernel );
}
cl_int WINAPI wine_clRetainMemObject( cl_mem memobj )
{
TRACE( "(%p)\n", memobj );
return clRetainMemObject( memobj );
return opencl_funcs->pclRetainMemObject( memobj );
}
cl_int WINAPI wine_clRetainProgram( cl_program program )
{
TRACE( "(%p)\n", program );
return clRetainProgram( program );
return opencl_funcs->pclRetainProgram( program );
}
cl_int WINAPI wine_clRetainSampler( cl_sampler sampler )
{
TRACE( "(%p)\n", sampler );
return clRetainSampler( sampler );
return opencl_funcs->pclRetainSampler( sampler );
}
cl_int WINAPI wine_clSetCommandQueueProperty( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, cl_command_queue_properties* old_properties )
{
TRACE( "(%p, %s, %u, %p)\n", command_queue, wine_dbgstr_longlong(properties), enable, old_properties );
return clSetCommandQueueProperty( command_queue, properties, enable, old_properties );
return opencl_funcs->pclSetCommandQueueProperty( command_queue, properties, enable, old_properties );
}
cl_int WINAPI wine_clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value )
{
TRACE( "(%p, %u, %zu, %p)\n", kernel, arg_index, arg_size, arg_value );
return clSetKernelArg( kernel, arg_index, arg_size, arg_value );
return opencl_funcs->pclSetKernelArg( kernel, arg_index, arg_size, arg_value );
}
cl_int WINAPI wine_clUnloadCompiler( void )
{
TRACE( "()\n" );
return clUnloadCompiler();
return opencl_funcs->pclUnloadCompiler();
}
cl_int WINAPI wine_clWaitForEvents( cl_uint num_events, const cl_event* event_list )
{
TRACE( "(%u, %p)\n", num_events, event_list );
return clWaitForEvents( num_events, event_list );
return opencl_funcs->pclWaitForEvents( num_events, event_list );
}
dlls/opencl/opencl.c → dlls/opencl/pe_wrappers.c
View file @ 6b15f4d6
......@@ -23,6 +23,8 @@
WINE_DEFAULT_DEBUG_CHANNEL(opencl);
const struct opencl_funcs *opencl_funcs = NULL;
cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info param_name,
SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret)
{
......@@ -51,7 +53,7 @@ cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info p
}
else
{
ret = clGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
ret = opencl_funcs->pclGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
}
TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n", platform, param_name, param_value_size, param_value, param_value_size_ret, ret);
......@@ -87,7 +89,7 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
}
else
{
ret = clGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
ret = opencl_funcs->pclGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
}
/* Filter out the CL_EXEC_NATIVE_KERNEL flag */
......@@ -102,126 +104,6 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
}
typedef struct
{
void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data);
void *user_data;
} CONTEXT_CALLBACK;
static void context_fn_notify(const char *errinfo, const void *private_info, size_t cb, void *user_data)
{
CONTEXT_CALLBACK *ccb;
TRACE("(%s, %p, %ld, %p)\n", errinfo, private_info, (SIZE_T)cb, user_data);
ccb = (CONTEXT_CALLBACK *) user_data;
if(ccb->pfn_notify) ccb->pfn_notify(errinfo, private_info, cb, ccb->user_data);
TRACE("Callback COMPLETED\n");
}
cl_context WINAPI wine_clCreateContext(const cl_context_properties * properties, cl_uint num_devices, const cl_device_id * devices,
void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
void * user_data, cl_int * errcode_ret)
{
cl_context ret;
CONTEXT_CALLBACK *ccb;
TRACE("(%p, %d, %p, %p, %p, %p)\n", properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
/* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
* Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
* The problem is determining when a context is being destroyed. clReleaseContext only decrements
* the use count for a context, its destruction can come much later and therefore there is a risk
* that the callback could be invoked after the user_data memory has been free()d.
*/
ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
ccb->pfn_notify = pfn_notify;
ccb->user_data = user_data;
ret = clCreateContext(properties, num_devices, devices, context_fn_notify, ccb, errcode_ret);
TRACE("(%p, %d, %p, %p, %p, %p (%d)))=%p\n", properties, num_devices, devices, &pfn_notify, user_data, errcode_ret, errcode_ret ? *errcode_ret : 0, ret);
return ret;
}
cl_context WINAPI wine_clCreateContextFromType(const cl_context_properties * properties, cl_device_type device_type,
void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
void * user_data, cl_int * errcode_ret)
{
cl_context ret;
CONTEXT_CALLBACK *ccb;
TRACE("(%p, 0x%lx, %p, %p, %p)\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret);
/* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
* Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
* The problem is determining when a context is being destroyed. clReleaseContext only decrements
* the use count for a context, its destruction can come much later and therefore there is a risk
* that the callback could be invoked after the user_data memory has been free()d.
*/
ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
ccb->pfn_notify = pfn_notify;
ccb->user_data = user_data;
ret = clCreateContextFromType(properties, device_type, context_fn_notify, ccb, errcode_ret);
TRACE("(%p, 0x%lx, %p, %p, %p (%d)))=%p\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret, errcode_ret ? *errcode_ret : 0, ret);
return ret;
}
typedef struct
{
void WINAPI (*pfn_notify)(cl_program program, void * user_data);
void *user_data;
} PROGRAM_CALLBACK;
static void program_fn_notify(cl_program program, void * user_data)
{
PROGRAM_CALLBACK *pcb;
TRACE("(%p, %p)\n", program, user_data);
pcb = (PROGRAM_CALLBACK *) user_data;
pcb->pfn_notify(program, pcb->user_data);
HeapFree(GetProcessHeap(), 0, pcb);
TRACE("Callback COMPLETED\n");
}
cl_int WINAPI wine_clBuildProgram(cl_program program, cl_uint num_devices, const cl_device_id * device_list, const char * options,
void WINAPI (*pfn_notify)(cl_program program, void * user_data),
void * user_data)
{
cl_int ret;
TRACE("\n");
if(pfn_notify)
{
/* When pfn_notify is provided, clBuildProgram is asynchronous */
PROGRAM_CALLBACK *pcb;
pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PROGRAM_CALLBACK));
pcb->pfn_notify = pfn_notify;
pcb->user_data = user_data;
ret = clBuildProgram(program, num_devices, device_list, options, program_fn_notify, pcb);
}
else
{
/* When pfn_notify is NULL, clBuildProgram is synchronous */
ret = clBuildProgram(program, num_devices, device_list, options, NULL, user_data);
}
return ret;
}
cl_int WINAPI wine_clEnqueueNativeKernel(cl_command_queue command_queue,
void WINAPI (*user_func)(void *args),
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_int ret = CL_INVALID_OPERATION;
/* FIXME: There appears to be no obvious method for translating the ABI for user_func.
* There is no opaque user_data structure passed, that could encapsulate the return address.
* The OpenCL specification seems to indicate that args has an implementation specific
* structure that cannot be used to stash away a return address for the WINAPI user_func.
*/
#if 0
ret = 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);
#else
FIXME("not supported due to user_func ABI mismatch\n");
#endif
return ret;
}
void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name)
{
void * ret = 0;
......@@ -234,3 +116,13 @@ void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name)
TRACE("(%s)=%p\n",func_name, ret);
return ret;
}
BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
{
if (reason == DLL_PROCESS_ATTACH)
{
DisableThreadLibraryCalls( instance );
return __wine_init_unix_lib( instance, reason, NULL, &opencl_funcs );
}
return TRUE;
}
dlls/opencl/unix_private.h 0 → 100644
View file @ 6b15f4d6
/*
* Copyright 2021 Zebediah Figura
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef __WINE_UNIX_PRIVATE_H
#define __WINE_UNIX_PRIVATE_H
#include "opencl_private.h"
cl_int WINAPI wrap_clBuildProgram( cl_program program, cl_uint num_devices,
const cl_device_id *device_list, const char *options,
void (WINAPI *pfn_notify)(cl_program program, void *user_data),
void *user_data ) DECLSPEC_HIDDEN;
cl_context WINAPI wrap_clCreateContext( const cl_context_properties *properties,
cl_uint num_devices, const cl_device_id *devices,
void (WINAPI *pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
void *user_data, cl_int *errcode_ret ) DECLSPEC_HIDDEN;
cl_context WINAPI wrap_clCreateContextFromType( const cl_context_properties *properties, cl_device_type device_type,
void (WINAPI *pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
void *user_data, cl_int *errcode_ret ) DECLSPEC_HIDDEN;
cl_int WINAPI wrap_clEnqueueNativeKernel( cl_command_queue command_queue,
void (WINAPI *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 ) DECLSPEC_HIDDEN;
extern const struct opencl_funcs funcs;
#endif
dlls/opencl/unix_thunks.c 0 → 100644
View file @ 6b15f4d6
/* Automatically generated from OpenCL registry files; DO NOT EDIT! */
#if 0
#pragma makedep unix
#endif
#include "config.h"
#include "unix_private.h"
static cl_mem WINAPI wrap_clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret )
{
return clCreateBuffer( context, flags, size, host_ptr, errcode_ret );
}
static cl_command_queue WINAPI wrap_clCreateCommandQueue( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret )
{
return clCreateCommandQueue( context, device, properties, errcode_ret );
}
static cl_mem WINAPI wrap_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 )
{
return clCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
}
static cl_mem WINAPI wrap_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 )
{
return clCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
}
static cl_kernel WINAPI wrap_clCreateKernel( cl_program program, const char* kernel_name, cl_int* errcode_ret )
{
return clCreateKernel( program, kernel_name, errcode_ret );
}
static cl_int WINAPI wrap_clCreateKernelsInProgram( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret )
{
return clCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
}
static cl_program WINAPI wrap_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 )
{
return clCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
}
static cl_program WINAPI wrap_clCreateProgramWithSource( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret )
{
return clCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
}
static cl_sampler WINAPI wrap_clCreateSampler( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret )
{
return clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
}
static cl_int WINAPI wrap_clEnqueueBarrier( cl_command_queue command_queue )
{
return clEnqueueBarrier( command_queue );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
}
static void* WINAPI wrap_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 )
{
return clEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
}
static void* WINAPI wrap_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 )
{
return 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 );
}
static cl_int WINAPI wrap_clEnqueueMarker( cl_command_queue command_queue, cl_event* event )
{
return clEnqueueMarker( command_queue, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueNDRangeKernel( command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_clEnqueueWaitForEvents( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list )
{
return clEnqueueWaitForEvents( command_queue, num_events, event_list );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_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 )
{
return clEnqueueWriteImage( command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
}
static cl_int WINAPI wrap_clFinish( cl_command_queue command_queue )
{
return clFinish( command_queue );
}
static cl_int WINAPI wrap_clFlush( cl_command_queue command_queue )
{
return clFlush( command_queue );
}
static cl_int WINAPI wrap_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 )
{
return clGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetContextInfo( cl_context context, cl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetDeviceIDs( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices )
{
return clGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
}
static cl_int WINAPI wrap_clGetDeviceInfo( cl_device_id device, cl_device_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetDeviceInfo( device, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetEventInfo( cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetEventProfilingInfo( cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
}
static void* WINAPI wrap_clGetExtensionFunctionAddress( const char* func_name )
{
return clGetExtensionFunctionAddress( func_name );
}
static cl_int WINAPI wrap_clGetImageInfo( cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetKernelInfo( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_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 )
{
return clGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetMemObjectInfo( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms )
{
return clGetPlatformIDs( num_entries, platforms, num_platforms );
}
static cl_int WINAPI wrap_clGetPlatformInfo( cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetPlatformInfo( platform, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_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 )
{
return clGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetProgramInfo( cl_program program, cl_program_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_clGetSamplerInfo( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
return clGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
}
static cl_int WINAPI wrap_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 )
{
return clGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
}
static cl_int WINAPI wrap_clReleaseCommandQueue( cl_command_queue command_queue )
{
return clReleaseCommandQueue( command_queue );
}
static cl_int WINAPI wrap_clReleaseContext( cl_context context )
{
return clReleaseContext( context );
}
static cl_int WINAPI wrap_clReleaseEvent( cl_event event )
{
return clReleaseEvent( event );
}
static cl_int WINAPI wrap_clReleaseKernel( cl_kernel kernel )
{
return clReleaseKernel( kernel );
}
static cl_int WINAPI wrap_clReleaseMemObject( cl_mem memobj )
{
return clReleaseMemObject( memobj );
}
static cl_int WINAPI wrap_clReleaseProgram( cl_program program )
{
return clReleaseProgram( program );
}
static cl_int WINAPI wrap_clReleaseSampler( cl_sampler sampler )
{
return clReleaseSampler( sampler );
}
static cl_int WINAPI wrap_clRetainCommandQueue( cl_command_queue command_queue )
{
return clRetainCommandQueue( command_queue );
}
static cl_int WINAPI wrap_clRetainContext( cl_context context )
{
return clRetainContext( context );
}
static cl_int WINAPI wrap_clRetainEvent( cl_event event )
{
return clRetainEvent( event );
}
static cl_int WINAPI wrap_clRetainKernel( cl_kernel kernel )
{
return clRetainKernel( kernel );
}
static cl_int WINAPI wrap_clRetainMemObject( cl_mem memobj )
{
return clRetainMemObject( memobj );
}
static cl_int WINAPI wrap_clRetainProgram( cl_program program )
{
return clRetainProgram( program );
}
static cl_int WINAPI wrap_clRetainSampler( cl_sampler sampler )
{
return clRetainSampler( sampler );
}
static cl_int WINAPI wrap_clSetCommandQueueProperty( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, cl_command_queue_properties* old_properties )
{
return clSetCommandQueueProperty( command_queue, properties, enable, old_properties );
}
static cl_int WINAPI wrap_clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value )
{
return clSetKernelArg( kernel, arg_index, arg_size, arg_value );
}
static cl_int WINAPI wrap_clUnloadCompiler( void )
{
return clUnloadCompiler();
}
static cl_int WINAPI wrap_clWaitForEvents( cl_uint num_events, const cl_event* event_list )
{
return clWaitForEvents( num_events, event_list );
}
const struct opencl_funcs funcs =
{
wrap_clBuildProgram,
wrap_clCreateBuffer,
wrap_clCreateCommandQueue,
wrap_clCreateContext,
wrap_clCreateContextFromType,
wrap_clCreateImage2D,
wrap_clCreateImage3D,
wrap_clCreateKernel,
wrap_clCreateKernelsInProgram,
wrap_clCreateProgramWithBinary,
wrap_clCreateProgramWithSource,
wrap_clCreateSampler,
wrap_clEnqueueBarrier,
wrap_clEnqueueCopyBuffer,
wrap_clEnqueueCopyBufferToImage,
wrap_clEnqueueCopyImage,
wrap_clEnqueueCopyImageToBuffer,
wrap_clEnqueueMapBuffer,
wrap_clEnqueueMapImage,
wrap_clEnqueueMarker,
wrap_clEnqueueNDRangeKernel,
wrap_clEnqueueNativeKernel,
wrap_clEnqueueReadBuffer,
wrap_clEnqueueReadImage,
wrap_clEnqueueTask,
wrap_clEnqueueUnmapMemObject,
wrap_clEnqueueWaitForEvents,
wrap_clEnqueueWriteBuffer,
wrap_clEnqueueWriteImage,
wrap_clFinish,
wrap_clFlush,
wrap_clGetCommandQueueInfo,
wrap_clGetContextInfo,
wrap_clGetDeviceIDs,
wrap_clGetDeviceInfo,
wrap_clGetEventInfo,
wrap_clGetEventProfilingInfo,
wrap_clGetExtensionFunctionAddress,
wrap_clGetImageInfo,
wrap_clGetKernelInfo,
wrap_clGetKernelWorkGroupInfo,
wrap_clGetMemObjectInfo,
wrap_clGetPlatformIDs,
wrap_clGetPlatformInfo,
wrap_clGetProgramBuildInfo,
wrap_clGetProgramInfo,
wrap_clGetSamplerInfo,
wrap_clGetSupportedImageFormats,
wrap_clReleaseCommandQueue,
wrap_clReleaseContext,
wrap_clReleaseEvent,
wrap_clReleaseKernel,
wrap_clReleaseMemObject,
wrap_clReleaseProgram,
wrap_clReleaseSampler,
wrap_clRetainCommandQueue,
wrap_clRetainContext,
wrap_clRetainEvent,
wrap_clRetainKernel,
wrap_clRetainMemObject,
wrap_clRetainProgram,
wrap_clRetainSampler,
wrap_clSetCommandQueueProperty,
wrap_clSetKernelArg,
wrap_clUnloadCompiler,
wrap_clWaitForEvents,
};
dlls/opencl/unix_wrappers.c 0 → 100644
View file @ 6b15f4d6
/*
* Copyright 2021 Zebediah Figura
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if 0
#pragma makedep unix
#endif
#include "config.h"
#include <stdlib.h>
#include "unix_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(opencl);
struct program_callback
{
void (WINAPI *pfn_notify)(cl_program program, void *user_data);
void *user_data;
};
static void CL_CALLBACK program_callback_wrapper(cl_program program, void *user_data)
{
struct program_callback *callback = user_data;
TRACE("(%p, %p)\n", program, user_data);
callback->pfn_notify(program, callback->user_data);
free(callback);
}
cl_int WINAPI wrap_clBuildProgram( cl_program program, cl_uint num_devices,
const cl_device_id *device_list, const char *options,
void (WINAPI *pfn_notify)(cl_program program, void *user_data),
void *user_data )
{
if (pfn_notify)
{
struct program_callback *callback;
cl_int ret;
if (!(callback = malloc(sizeof(*callback))))
return CL_OUT_OF_HOST_MEMORY;
callback->pfn_notify = pfn_notify;
callback->user_data = user_data;
if ((ret = clBuildProgram( program, num_devices, device_list, options,
program_callback_wrapper, callback )) != CL_SUCCESS)
free( callback );
return ret;
}
return clBuildProgram( program, num_devices, device_list, options, NULL, NULL );
}
struct context_callback
{
void (WINAPI *pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data);
void *user_data;
};
static void CL_CALLBACK context_callback_wrapper(const char *errinfo,
const void *private_info, size_t cb, void *user_data)
{
struct context_callback *callback = user_data;
TRACE("(%s, %p, %zu, %p)\n", debugstr_a(errinfo), private_info, cb, user_data);
callback->pfn_notify(errinfo, private_info, cb, callback->user_data);
}
cl_context WINAPI wrap_clCreateContext( const cl_context_properties *properties,
cl_uint num_devices, const cl_device_id *devices,
void (WINAPI *pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
void *user_data, cl_int *errcode_ret )
{
if (pfn_notify)
{
struct context_callback *callback;
cl_context ret;
/* FIXME: the callback structure is currently leaked */
if (!(callback = malloc(sizeof(*callback))))
{
*errcode_ret = CL_OUT_OF_HOST_MEMORY;
return NULL;
}
callback->pfn_notify = pfn_notify;
callback->user_data = user_data;
if (!(ret = clCreateContext( properties, num_devices, devices, context_callback_wrapper, callback, errcode_ret )))
free( callback );
return ret;
}
return clCreateContext( properties, num_devices, devices, NULL, NULL, errcode_ret );
}
cl_context WINAPI wrap_clCreateContextFromType( const cl_context_properties *properties, cl_device_type device_type,
void (WINAPI *pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
void *user_data, cl_int *errcode_ret )
{
if (pfn_notify)
{
struct context_callback *callback;
cl_context ret;
/* FIXME: the callback structure is currently leaked */
if (!(callback = malloc(sizeof(*callback))))
{
*errcode_ret = CL_OUT_OF_HOST_MEMORY;
return NULL;
}
callback->pfn_notify = pfn_notify;
callback->user_data = user_data;
if (!(ret = clCreateContextFromType( properties, device_type, context_callback_wrapper, callback, errcode_ret )))
free( callback );
return ret;
}
return clCreateContextFromType( properties, device_type, NULL, NULL, errcode_ret );
}
cl_int WINAPI wrap_clEnqueueNativeKernel( cl_command_queue command_queue,
void (WINAPI *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 )
{
/* we have no clear way to wrap user_func */
FIXME( "not implemented\n" );
return CL_INVALID_OPERATION;
}
NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
{
if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
*(const struct opencl_funcs **)ptr_out = &funcs;
return STATUS_SUCCESS;
}
dlls/opencl/unixlib.h 0 → 100644
View file @ 6b15f4d6
/* Automatically generated from OpenCL registry files; DO NOT EDIT! */
struct opencl_funcs
{
cl_int (WINAPI *pclBuildProgram)( cl_program program, cl_uint num_devices, const cl_device_id* device_list, const char* options, void (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data );
cl_mem (WINAPI *pclCreateBuffer)( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret );
cl_command_queue (WINAPI *pclCreateCommandQueue)( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret );
cl_context (WINAPI *pclCreateContext)( const cl_context_properties* properties, cl_uint num_devices, const cl_device_id* devices, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret );
cl_context (WINAPI *pclCreateContextFromType)( const cl_context_properties* properties, cl_device_type device_type, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret );
cl_mem (WINAPI *pclCreateImage2D)( 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_mem (WINAPI *pclCreateImage3D)( 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_kernel (WINAPI *pclCreateKernel)( cl_program program, const char* kernel_name, cl_int* errcode_ret );
cl_int (WINAPI *pclCreateKernelsInProgram)( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret );
cl_program (WINAPI *pclCreateProgramWithBinary)( 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_program (WINAPI *pclCreateProgramWithSource)( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret );
cl_sampler (WINAPI *pclCreateSampler)( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret );
cl_int (WINAPI *pclEnqueueBarrier)( cl_command_queue command_queue );
cl_int (WINAPI *pclEnqueueCopyBuffer)( 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_int (WINAPI *pclEnqueueCopyBufferToImage)( 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_int (WINAPI *pclEnqueueCopyImage)( 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_int (WINAPI *pclEnqueueCopyImageToBuffer)( 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 );
void* (WINAPI *pclEnqueueMapBuffer)( 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 );
void* (WINAPI *pclEnqueueMapImage)( 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_int (WINAPI *pclEnqueueMarker)( cl_command_queue command_queue, cl_event* event );
cl_int (WINAPI *pclEnqueueNDRangeKernel)( 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_int (WINAPI *pclEnqueueNativeKernel)( cl_command_queue command_queue, void (WINAPI* 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_int (WINAPI *pclEnqueueReadBuffer)( 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_int (WINAPI *pclEnqueueReadImage)( 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_int (WINAPI *pclEnqueueTask)( 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_int (WINAPI *pclEnqueueUnmapMemObject)( 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_int (WINAPI *pclEnqueueWaitForEvents)( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list );
cl_int (WINAPI *pclEnqueueWriteBuffer)( 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_int (WINAPI *pclEnqueueWriteImage)( 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_int (WINAPI *pclFinish)( cl_command_queue command_queue );
cl_int (WINAPI *pclFlush)( cl_command_queue command_queue );
cl_int (WINAPI *pclGetCommandQueueInfo)( 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_int (WINAPI *pclGetContextInfo)( cl_context context, cl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetDeviceIDs)( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices );
cl_int (WINAPI *pclGetDeviceInfo)( cl_device_id device, cl_device_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetEventInfo)( cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetEventProfilingInfo)( cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
void* (WINAPI *pclGetExtensionFunctionAddress)( const char* func_name );
cl_int (WINAPI *pclGetImageInfo)( cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetKernelInfo)( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetKernelWorkGroupInfo)( 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_int (WINAPI *pclGetMemObjectInfo)( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetPlatformIDs)( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms );
cl_int (WINAPI *pclGetPlatformInfo)( cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetProgramBuildInfo)( 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_int (WINAPI *pclGetProgramInfo)( cl_program program, cl_program_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetSamplerInfo)( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
cl_int (WINAPI *pclGetSupportedImageFormats)( 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_int (WINAPI *pclReleaseCommandQueue)( cl_command_queue command_queue );
cl_int (WINAPI *pclReleaseContext)( cl_context context );
cl_int (WINAPI *pclReleaseEvent)( cl_event event );
cl_int (WINAPI *pclReleaseKernel)( cl_kernel kernel );
cl_int (WINAPI *pclReleaseMemObject)( cl_mem memobj );
cl_int (WINAPI *pclReleaseProgram)( cl_program program );
cl_int (WINAPI *pclReleaseSampler)( cl_sampler sampler );
cl_int (WINAPI *pclRetainCommandQueue)( cl_command_queue command_queue );
cl_int (WINAPI *pclRetainContext)( cl_context context );
cl_int (WINAPI *pclRetainEvent)( cl_event event );
cl_int (WINAPI *pclRetainKernel)( cl_kernel kernel );
cl_int (WINAPI *pclRetainMemObject)( cl_mem memobj );
cl_int (WINAPI *pclRetainProgram)( cl_program program );
cl_int (WINAPI *pclRetainSampler)( cl_sampler sampler );
cl_int (WINAPI *pclSetCommandQueueProperty)( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, cl_command_queue_properties* old_properties );
cl_int (WINAPI *pclSetKernelArg)( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value );
cl_int (WINAPI *pclUnloadCompiler)( void );
cl_int (WINAPI *pclWaitForEvents)( cl_uint num_events, const cl_event* event_list );
};
extern const struct opencl_funcs *opencl_funcs;
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment