[PATCH v3 1/3] opencl: Add OpenCL 1.0 function pointer loader.
Roderick Colenbrander
thunderbird2k at gmail.com
Mon Mar 11 23:28:02 CDT 2019
Hi Nakarin,
Thanks for sharing your opencl work. I shared a brief reply earlier as
well, though I must admit I was brief and not very clear (we just had
a baby and was super tired).
Anyway my main concern is more about how our current OpenCL
implementation works and its maintainability. I'm not too familiar,
with opencl, but as a Khronos standard it has a lot of similarities
with OpenGL and Vulkan on which I worked on the Wine implementations.
The current OpenCL 1.0 implementation in Wine was probably
handwritten. I'm not sure if there was a "cl.xml" back then from which
the code could have been generated, but at least there is now. That is
what we do for OpenGL and Vulkan as well. The bulk of the code is just
autogenerated (make_vulkan or make_opengl), while the few calls which
need special handling are implemented by hand. Any of these scripts
can probably modified easily, vulkan probably a tad easier.
This is very handy as we can re-run the scripts and we get the latest
OpenGL / Vulkan. OpenCL is now at 2.2 and with little work, we would
have gotten the support. In addition there are a lot of extensions as
well for which we can then add wrappers too (and deal with
clGetExtensionFunctionAddress).
My personal vote would be for OpenCL to be automatically generated.
Just have the few calls which need manual work in "opencl.c" and
anything else similar to opengl/vulkan in like "opencl_thunks.c".
Long-term we should maybe even consider to move to the OpenCL ICD
standards. If you are not familiar opencl dll is really a loader for
the vendor supplied opencl Installable Client Driver. We would maybe
have a wineopencl.dll and opencl.dll. Since OpenCL is not that
commonly used in consumer applications, it is probably not worth any
of the effort right now.
Thanks,
Roderick
On Mon, Mar 11, 2019 at 5:13 AM Nakarin Khankham <garuda2550 at gmail.com> wrote:
>
> Signed-off-by: Nakarin Khankham <garuda2550 at gmail.com>
> ---
> v2: Use function pointer instead of call the function directly.
> v3: Remove WINAPI from function pointer prototype, SIZE_T => size_t.
> ---
> configure | 56 ++++++++
> configure.ac | 1 +
> dlls/opencl/opencl.c | 321 +++++++++++++++++++++++++++++++++++++++++++
> include/config.h.in | 3 +
> 4 files changed, 381 insertions(+)
>
> diff --git a/configure b/configure
> index 1d80c01f3f..003e0739a9 100755
> --- a/configure
> +++ b/configure
> @@ -11810,6 +11810,62 @@ if test "x$ac_cv_lib_OpenCL_clGetPlatformInfo" = xyes; then :
>
> fi
>
> + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -lOpenCL" >&5
> +$as_echo_n "checking for -lOpenCL... " >&6; }
> +if ${ac_cv_lib_soname_OpenCL+:} false; then :
> + $as_echo_n "(cached) " >&6
> +else
> + ac_check_soname_save_LIBS=$LIBS
> +LIBS="-lOpenCL $LIBS"
> + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
> +/* end confdefs.h. */
> +
> +/* Override any GCC internal prototype to avoid an error.
> + Use char because int might match the return type of a GCC
> + builtin and then its argument prototype would still apply. */
> +#ifdef __cplusplus
> +extern "C"
> +#endif
> +char clGetPlatformInfo ();
> +int
> +main ()
> +{
> +return clGetPlatformInfo ();
> + ;
> + return 0;
> +}
> +_ACEOF
> +if ac_fn_c_try_link "$LINENO"; then :
> + case "$LIBEXT" in
> + dll) ac_cv_lib_soname_OpenCL=`$ac_cv_path_LDD conftest.exe | grep "OpenCL" | sed -e "s/dll.*/dll/"';2,$d'` ;;
> + dylib) ac_cv_lib_soname_OpenCL=`$OTOOL -L conftest$ac_exeext | grep "libOpenCL\\.[0-9A-Za-z.]*dylib" | sed -e "s/^.*\/\(libOpenCL\.[0-9A-Za-z.]*dylib\).*$/\1/"';2,$d'` ;;
> + *) ac_cv_lib_soname_OpenCL=`$READELF -d conftest$ac_exeext | grep "NEEDED.*libOpenCL\\.$LIBEXT" | sed -e "s/^.*\\[\\(libOpenCL\\.$LIBEXT[^ ]*\\)\\].*$/\1/"';2,$d'`
> + if ${ac_cv_lib_soname_OpenCL:+false} :; then :
> + ac_cv_lib_soname_OpenCL=`$LDD conftest$ac_exeext | grep "libOpenCL\\.$LIBEXT" | sed -e "s/^.*\(libOpenCL\.$LIBEXT[^ ]*\).*$/\1/"';2,$d'`
> +fi ;;
> + esac
> +fi
> +rm -f core conftest.err conftest.$ac_objext \
> + conftest$ac_exeext conftest.$ac_ext
> + LIBS=$ac_check_soname_save_LIBS
> +fi
> +if ${ac_cv_lib_soname_OpenCL:+false} :; then :
> + { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
> +$as_echo "not found" >&6; }
> + cat >>confdefs.h <<_ACEOF
> +#define SONAME_LIBOPENCL "libOpenCL.$LIBEXT"
> +_ACEOF
> +
> +else
> + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_soname_OpenCL" >&5
> +$as_echo "$ac_cv_lib_soname_OpenCL" >&6; }
> +
> +cat >>confdefs.h <<_ACEOF
> +#define SONAME_LIBOPENCL "$ac_cv_lib_soname_OpenCL"
> +_ACEOF
> +
> +
> +fi
> fi
> if test "x$ac_cv_lib_OpenCL_clGetPlatformInfo" != xyes; then :
> case "x$with_opencl" in
> diff --git a/configure.ac b/configure.ac
> index 71e8606e7c..137b7302d8 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -1264,6 +1264,7 @@ dnl **** Check for OpenCL ****
> if test "$ac_cv_header_CL_cl_h" = "yes"
> then
> AC_CHECK_LIB(OpenCL,clGetPlatformInfo,[AC_SUBST(OPENCL_LIBS,["-lOpenCL"])])
> + WINE_CHECK_SONAME(OpenCL,clGetPlatformInfo,,[AC_DEFINE_UNQUOTED(SONAME_LIBOPENCL,["libOpenCL.$LIBEXT"])])
> fi
> WINE_NOTICE_WITH(opencl,[test "x$ac_cv_lib_OpenCL_clGetPlatformInfo" != xyes],
> [OpenCL ${notice_platform}development files not found, OpenCL won't be supported.],
> diff --git a/dlls/opencl/opencl.c b/dlls/opencl/opencl.c
> index 2d145bf25c..7d292c03be 100644
> --- a/dlls/opencl/opencl.c
> +++ b/dlls/opencl/opencl.c
> @@ -43,6 +43,327 @@ WINE_DEFAULT_DEBUG_CHANNEL(opencl);
> #define OPENCL_WITH_GL 0
>
>
> +/* Platform API */
> +static cl_int (*pclGetPlatformIDs)(cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms);
> +static cl_int (*pclGetPlatformInfo)(cl_platform_id platform, cl_platform_info param_name,
> + size_t param_value_size, void * param_value, size_t * param_value_size_ret);
> +
> +/* Device APIs */
> +static cl_int (*pclGetDeviceIDs)(cl_platform_id platform, cl_device_type device_type,
> + cl_uint num_entries, cl_device_id * devices, cl_uint * num_devices);
> +static cl_int (*pclGetDeviceInfo)(cl_device_id device, cl_device_info param_name,
> + size_t param_value_size, void * param_value, size_t * param_value_size_ret);
> +
> +/* Context APIs */
> +static cl_context (*pclCreateContext)(const cl_context_properties * properties, cl_uint num_devices, const cl_device_id * devices,
> + void (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
> + void * user_data, cl_int * errcode_ret);
> +static cl_context (*pclCreateContextFromType)(const cl_context_properties * properties, cl_device_type device_type,
> + void (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
> + void * user_data, cl_int * errcode_ret);
> +static cl_int (*pclRetainContext)(cl_context context);
> +static cl_int (*pclReleaseContext)(cl_context context);
> +static cl_int (*pclGetContextInfo)(cl_context context, cl_context_info param_name,
> + size_t param_value_size, void * param_value, size_t * param_value_size_ret);
> +
> +/* Command Queue APIs */
> +static cl_command_queue (*pclCreateCommandQueue)(cl_context context, cl_device_id device,
> + cl_command_queue_properties properties, cl_int * errcode_ret);
> +static cl_int (*pclRetainCommandQueue)(cl_command_queue command_queue);
> +static cl_int (*pclReleaseCommandQueue)(cl_command_queue command_queue);
> +static cl_int (*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);
> +static cl_int (*pclSetCommandQueueProperty)(cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable,
> + cl_command_queue_properties * old_properties);
> +
> +/* Memory Object APIs */
> +static cl_mem (*pclCreateBuffer)(cl_context context, cl_mem_flags flags, size_t size, void * host_ptr, cl_int * errcode_ret);
> +static cl_mem (*pclCreateImage2D)(cl_context context, cl_mem_flags flags, 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);
> +static cl_mem (*pclCreateImage3D)(cl_context context, cl_mem_flags flags, 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);
> +static cl_int (*pclRetainMemObject)(cl_mem memobj);
> +static cl_int (*pclReleaseMemObject)(cl_mem memobj);
> +static cl_int (*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);
> +static cl_int (*pclGetMemObjectInfo)(cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret);
> +static cl_int (*pclGetImageInfo)(cl_mem image, cl_image_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret);
> +
> +/* Sampler APIs */
> +static cl_sampler (*pclCreateSampler)(cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode,
> + cl_filter_mode filter_mode, cl_int * errcode_ret);
> +static cl_int (*pclRetainSampler)(cl_sampler sampler);
> +static cl_int (*pclReleaseSampler)(cl_sampler sampler);
> +static cl_int (*pclGetSamplerInfo)(cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size,
> + void * param_value, size_t * param_value_size_ret);
> +
> +/* Program Object APIs */
> +static cl_program (*pclCreateProgramWithSource)(cl_context context, cl_uint count, const char ** strings,
> + const size_t * lengths, cl_int * errcode_ret);
> +static cl_program (*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);
> +static cl_int (*pclRetainProgram)(cl_program program);
> +static cl_int (*pclReleaseProgram)(cl_program program);
> +static cl_int (*pclBuildProgram)(cl_program program, cl_uint num_devices, const cl_device_id * device_list, const char * options,
> + void (*pfn_notify)(cl_program program, void * user_data),
> + void * user_data);
> +static cl_int (*pclUnloadCompiler)(void);
> +static cl_int (*pclGetProgramInfo)(cl_program program, cl_program_info param_name,
> + size_t param_value_size, void * param_value, size_t * param_value_size_ret);
> +static cl_int (*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);
> +
> +/* Kernel Object APIs */
> +static cl_kernel (*pclCreateKernel)(cl_program program, char * kernel_name, cl_int * errcode_ret);
> +static cl_int (*pclCreateKernelsInProgram)(cl_program program, cl_uint num_kernels,
> + cl_kernel * kernels, cl_uint * num_kernels_ret);
> +static cl_int (*pclRetainKernel)(cl_kernel kernel);
> +static cl_int (*pclReleaseKernel)(cl_kernel kernel);
> +static cl_int (*pclSetKernelArg)(cl_kernel kernel, cl_uint arg_index, size_t arg_size, void * arg_value);
> +static cl_int (*pclGetKernelInfo)(cl_kernel kernel, cl_kernel_info param_name,
> + size_t param_value_size, void * param_value, size_t * param_value_size_ret);
> +static cl_int (*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);
> +/* Event Object APIs */
> +static cl_int (*pclWaitForEvents)(cl_uint num_events, cl_event * event_list);
> +static cl_int (*pclGetEventInfo)(cl_event event, cl_event_info param_name, size_t param_value_size,
> + void * param_value, size_t * param_value_size_ret);
> +static cl_int (*pclRetainEvent)(cl_event event);
> +static cl_int (*pclReleaseEvent)(cl_event event);
> +
> +/* Profiling APIs */
> +static cl_int (*pclGetEventProfilingInfo)(cl_event event, cl_profiling_info param_name, size_t param_value_size,
> + void * param_value, size_t * param_value_size_ret);
> +
> +/* Flush and Finish APIs */
> +static cl_int (*pclFlush)(cl_command_queue command_queue);
> +static cl_int (*pclFinish)(cl_command_queue command_queue);
> +
> +/* Enqueued Commands APIs */
> +static cl_int (*pclEnqueueReadBuffer)(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
> + size_t offset, size_t cb, void * ptr,
> + cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event);
> +static cl_int (*pclEnqueueWriteBuffer)(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write,
> + size_t offset, size_t cb, const void * ptr,
> + cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event);
> +static cl_int (*pclEnqueueCopyBuffer)(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer,
> + size_t src_offset, size_t dst_offset, size_t cb,
> + cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event);
> +static cl_int (*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);
> +static cl_int (*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);
> +static cl_int (*pclEnqueueCopyImage)(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image,
> + size_t * src_origin, size_t * dst_origin, size_t * region,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
> +static cl_int (*pclEnqueueCopyImageToBuffer)(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer,
> + size_t * src_origin, size_t * region, size_t dst_offset,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
> +static cl_int (*pclEnqueueCopyBufferToImage)(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image,
> + size_t src_offset, size_t * dst_origin, size_t * region,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
> +static void * (*pclEnqueueMapBuffer)(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map,
> + cl_map_flags map_flags, size_t offset, size_t cb,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event, cl_int * errcode_ret);
> +static void * (*pclEnqueueMapImage)(cl_command_queue command_queue, cl_mem image, cl_bool blocking_map,
> + cl_map_flags map_flags, size_t * origin, size_t * region,
> + size_t * image_row_pitch, size_t * image_slice_pitch,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event, cl_int * errcode_ret);
> +static cl_int (*pclEnqueueUnmapMemObject)(cl_command_queue command_queue, cl_mem memobj, void * mapped_ptr,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
> +static cl_int (*pclEnqueueNDRangeKernel)(cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim,
> + size_t * global_work_offset, size_t * global_work_size, size_t * local_work_size,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
> +static cl_int (*pclEnqueueTask)(cl_command_queue command_queue, cl_kernel kernel,
> + cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
> +static cl_int (*pclEnqueueNativeKernel)(cl_command_queue command_queue,
> + void (*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);
> +static cl_int (*pclEnqueueMarker)(cl_command_queue command_queue, cl_event * event);
> +static cl_int (*pclEnqueueWaitForEvents)(cl_command_queue command_queue, cl_uint num_events, cl_event * event_list);
> +static cl_int (*pclEnqueueBarrier)(cl_command_queue command_queue);
> +
> +/* Extension function access */
> +static void * (*pclGetExtensionFunctionAddress)(const char * func_name);
> +
> +
> +static BOOL init_opencl(void);
> +static BOOL load_opencl_func(void);
> +
> +static void * opencl_handle = NULL;
> +
> +
> +/***********************************************************************
> + * DllMain [Internal]
> + *
> + * Initializes the internal 'opencl.dll'.
> + */
> +BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID reserved)
> +{
> + TRACE("opencl.dll: %p,%x,%p\n", hinstDLL, reason, reserved);
> +
> + switch (reason)
> + {
> + case DLL_PROCESS_ATTACH:
> + DisableThreadLibraryCalls(hinstDLL);
> + if (init_opencl())
> + load_opencl_func();
> + break;
> +
> + case DLL_PROCESS_DETACH:
> + if (reserved) break;
> + if (opencl_handle) wine_dlclose(opencl_handle, NULL, 0);
> + }
> +
> + return TRUE;
> +}
> +
> +
> +/***********************************************************************
> + * init_opencl [Internal]
> + *
> + * Initializes OpenCL library.
> + *
> + * RETURNS
> + * Success: TRUE
> + * Failure: FALSE
> + */
> +static BOOL init_opencl(void)
> +{
> +#ifdef SONAME_LIBOPENCL
> + char error[256];
> +
> + opencl_handle = wine_dlopen(SONAME_LIBOPENCL, RTLD_NOW, error, sizeof(error));
> + if (opencl_handle != NULL)
> + {
> + TRACE("Opened library %s\n", SONAME_LIBOPENCL);
> + return TRUE;
> + }
> + else
> + ERR("Failed to open library %s: %s\n", SONAME_LIBOPENCL, error);
> +#else
> + ERR("OpenCL is needed but support was not included at build time\n");
> +#endif
> + return FALSE;
> +}
> +
> +
> +/***********************************************************************
> + * load_opencl_func [Internal]
> + *
> + * Populate function table.
> + *
> + * RETURNS
> + * Success: TRUE
> + * Failure: FALSE
> + */
> +static BOOL load_opencl_func(void)
> +{
> + char error[256];
> +
> + if (opencl_handle == NULL)
> + return FALSE;
> +
> +#define LOAD_FUNCPTR(f) \
> + if (!(p##f = wine_dlsym(opencl_handle, #f, error, sizeof(error)))) \
> + WARN("%s not found in %s (%s)\n", #f, SONAME_LIBOPENCL, error);
> +
> + /* Platform API */
> + LOAD_FUNCPTR(clGetPlatformIDs);
> + LOAD_FUNCPTR(clGetPlatformInfo);
> + /* Device APIs */
> + LOAD_FUNCPTR(clGetDeviceIDs);
> + LOAD_FUNCPTR(clGetDeviceInfo);
> + /* Context APIs */
> + LOAD_FUNCPTR(clCreateContext);
> + LOAD_FUNCPTR(clCreateContextFromType);
> + LOAD_FUNCPTR(clRetainContext);
> + LOAD_FUNCPTR(clReleaseContext);
> + LOAD_FUNCPTR(clGetContextInfo);
> + /* Command Queue APIs */
> + LOAD_FUNCPTR(clCreateCommandQueue);
> + LOAD_FUNCPTR(clRetainCommandQueue);
> + LOAD_FUNCPTR(clReleaseCommandQueue);
> + LOAD_FUNCPTR(clGetCommandQueueInfo);
> + LOAD_FUNCPTR(clSetCommandQueueProperty);
> + /* Memory Object APIs */
> + LOAD_FUNCPTR(clCreateBuffer);
> + LOAD_FUNCPTR(clCreateImage2D);
> + LOAD_FUNCPTR(clCreateImage3D);
> + LOAD_FUNCPTR(clRetainMemObject);
> + LOAD_FUNCPTR(clReleaseMemObject);
> + LOAD_FUNCPTR(clGetSupportedImageFormats);
> + LOAD_FUNCPTR(clGetMemObjectInfo);
> + LOAD_FUNCPTR(clGetImageInfo);
> + /* Sampler APIs */
> + LOAD_FUNCPTR(clCreateSampler);
> + LOAD_FUNCPTR(clRetainSampler);
> + LOAD_FUNCPTR(clReleaseSampler);
> + LOAD_FUNCPTR(clGetSamplerInfo);
> + /* Program Object APIs */
> + LOAD_FUNCPTR(clCreateProgramWithSource);
> + LOAD_FUNCPTR(clCreateProgramWithBinary);
> + LOAD_FUNCPTR(clRetainProgram);
> + LOAD_FUNCPTR(clReleaseProgram);
> + LOAD_FUNCPTR(clBuildProgram);
> + LOAD_FUNCPTR(clUnloadCompiler);
> + LOAD_FUNCPTR(clGetProgramInfo);
> + LOAD_FUNCPTR(clGetProgramBuildInfo);
> + /* Kernel Object APIs */
> + LOAD_FUNCPTR(clCreateKernel);
> + LOAD_FUNCPTR(clCreateKernelsInProgram);
> + LOAD_FUNCPTR(clRetainKernel);
> + LOAD_FUNCPTR(clReleaseKernel);
> + LOAD_FUNCPTR(clSetKernelArg);
> + LOAD_FUNCPTR(clGetKernelInfo);
> + LOAD_FUNCPTR(clGetKernelWorkGroupInfo);
> + /* Event Object APIs */
> + LOAD_FUNCPTR(clWaitForEvents);
> + LOAD_FUNCPTR(clGetEventInfo);
> + LOAD_FUNCPTR(clRetainEvent);
> + LOAD_FUNCPTR(clReleaseEvent);
> + /* Profiling APIs */
> + LOAD_FUNCPTR(clGetEventProfilingInfo);
> + /* Flush and Finish APIs */
> + LOAD_FUNCPTR(clFlush);
> + LOAD_FUNCPTR(clFinish);
> + /* Enqueued Commands APIs */
> + LOAD_FUNCPTR(clEnqueueReadBuffer);
> + LOAD_FUNCPTR(clEnqueueWriteBuffer);
> + LOAD_FUNCPTR(clEnqueueCopyBuffer);
> + LOAD_FUNCPTR(clEnqueueReadImage);
> + LOAD_FUNCPTR(clEnqueueWriteImage);
> + LOAD_FUNCPTR(clEnqueueCopyImage);
> + LOAD_FUNCPTR(clEnqueueCopyImageToBuffer);
> + LOAD_FUNCPTR(clEnqueueCopyBufferToImage);
> + LOAD_FUNCPTR(clEnqueueMapBuffer);
> + LOAD_FUNCPTR(clEnqueueMapImage);
> + LOAD_FUNCPTR(clEnqueueUnmapMemObject);
> + LOAD_FUNCPTR(clEnqueueNDRangeKernel);
> + LOAD_FUNCPTR(clEnqueueTask);
> + LOAD_FUNCPTR(clEnqueueNativeKernel);
> + LOAD_FUNCPTR(clEnqueueMarker);
> + LOAD_FUNCPTR(clEnqueueWaitForEvents);
> + LOAD_FUNCPTR(clEnqueueBarrier);
> + /* Extension function access */
> + LOAD_FUNCPTR(clGetExtensionFunctionAddress);
> +
> +#undef LOAD_FUNCPTR
> +
> + return TRUE;
> +}
> +
> +
> /*---------------------------------------------------------------*/
> /* Platform API */
>
> diff --git a/include/config.h.in b/include/config.h.in
> index 999f4a6130..a08e81c86e 100644
> --- a/include/config.h.in
> +++ b/include/config.h.in
> @@ -1548,6 +1548,9 @@
> /* Define to the soname of the libopenal library. */
> #undef SONAME_LIBOPENAL
>
> +/* Define to the soname of the libOpenCL library. */
> +#undef SONAME_LIBOPENCL
> +
> /* Define to the soname of the libOSMesa library. */
> #undef SONAME_LIBOSMESA
>
> --
> 2.17.1
>
>
>
>
More information about the wine-devel
mailing list