fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 07:28:11 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

clover: Implement support for the ICD extension.

Browse source 
Tested-by: Tom Stellard <thomas.stellard@amd.com>
This commit is contained in:
Francisco Jerez 2013-10-06 13:52:02 -07:00
parent 9a5afd0dbd
commit 6230f77232
17 changed files with 1046 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/gallium/state_trackers/clover/Makefile.sources
View file

@ -41,6 +41,8 @@ CPP_SOURCES := \
core/module.hpp \
core/module.cpp \
api/util.hpp \
api/dispatch.hpp \
api/dispatch.cpp \
api/platform.cpp \
api/device.cpp \
api/context.cpp \

10
src/gallium/state_trackers/clover/api/context.cpp
View file

@ -26,7 +26,7 @@
using namespace clover;
PUBLIC cl_context
CLOVER_API cl_context
clCreateContext(const cl_context_properties *d_props, cl_uint num_devs,
const cl_device_id *d_devs,
void (CL_CALLBACK *pfn_notify)(const char *, const void *,
@ -53,7 +53,7 @@ clCreateContext(const cl_context_properties *d_props, cl_uint num_devs,
return NULL;
}
PUBLIC cl_context
CLOVER_API cl_context
clCreateContextFromType(const cl_context_properties *d_props,
cl_device_type type,
void (CL_CALLBACK *pfn_notify)(
@ -79,7 +79,7 @@ clCreateContextFromType(const cl_context_properties *d_props,
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clRetainContext(cl_context d_ctx) try {
obj(d_ctx).retain();
return CL_SUCCESS;
@ -88,7 +88,7 @@ clRetainContext(cl_context d_ctx) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clReleaseContext(cl_context d_ctx) try {
if (obj(d_ctx).release())
delete pobj(d_ctx);
@ -99,7 +99,7 @@ clReleaseContext(cl_context d_ctx) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetContextInfo(cl_context d_ctx, cl_context_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };

4
src/gallium/state_trackers/clover/api/device.cpp
View file

@ -26,7 +26,7 @@
using namespace clover;
PUBLIC cl_int
CLOVER_API cl_int
clGetDeviceIDs(cl_platform_id d_platform, cl_device_type device_type,
cl_uint num_entries, cl_device_id *rd_devices,
cl_uint *rnum_devices) try {
@ -62,7 +62,7 @@ clGetDeviceIDs(cl_platform_id d_platform, cl_device_type device_type,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetDeviceInfo(cl_device_id d_dev, cl_device_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };

147
src/gallium/state_trackers/clover/api/dispatch.cpp Normal file
View file

@ -0,0 +1,147 @@
//
// Copyright 2013 Francisco Jerez
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
#include "api/dispatch.hpp"
namespace clover {
const _cl_icd_dispatch _dispatch = {
clGetPlatformIDs,
GetPlatformInfo,
clGetDeviceIDs,
clGetDeviceInfo,
clCreateContext,
clCreateContextFromType,
clRetainContext,
clReleaseContext,
clGetContextInfo,
clCreateCommandQueue,
clRetainCommandQueue,
clReleaseCommandQueue,
clGetCommandQueueInfo,
NULL, // clSetCommandQueueProperty
clCreateBuffer,
clCreateImage2D,
clCreateImage3D,
clRetainMemObject,
clReleaseMemObject,
clGetSupportedImageFormats,
clGetMemObjectInfo,
clGetImageInfo,
clCreateSampler,
clRetainSampler,
clReleaseSampler,
clGetSamplerInfo,
clCreateProgramWithSource,
clCreateProgramWithBinary,
clRetainProgram,
clReleaseProgram,
clBuildProgram,
clUnloadCompiler,
clGetProgramInfo,
clGetProgramBuildInfo,
clCreateKernel,
clCreateKernelsInProgram,
clRetainKernel,
clReleaseKernel,
clSetKernelArg,
clGetKernelInfo,
clGetKernelWorkGroupInfo,
clWaitForEvents,
clGetEventInfo,
clRetainEvent,
clReleaseEvent,
clGetEventProfilingInfo,
clFlush,
clFinish,
clEnqueueReadBuffer,
clEnqueueWriteBuffer,
clEnqueueCopyBuffer,
clEnqueueReadImage,
clEnqueueWriteImage,
clEnqueueCopyImage,
clEnqueueCopyImageToBuffer,
clEnqueueCopyBufferToImage,
clEnqueueMapBuffer,
clEnqueueMapImage,
clEnqueueUnmapMemObject,
clEnqueueNDRangeKernel,
clEnqueueTask,
clEnqueueNativeKernel,
clEnqueueMarker,
clEnqueueWaitForEvents,
clEnqueueBarrier,
GetExtensionFunctionAddress,
NULL, // clCreateFromGLBuffer
NULL, // clCreateFromGLTexture2D
NULL, // clCreateFromGLTexture3D
NULL, // clCreateFromGLRenderbuffer
NULL, // clGetGLObjectInfo
NULL, // clGetGLTextureInfo
NULL, // clEnqueueAcquireGLObjects
NULL, // clEnqueueReleaseGLObjects
NULL, // clGetGLContextInfoKHR
NULL, // clGetDeviceIDsFromD3D10KHR
NULL, // clCreateFromD3D10BufferKHR
NULL, // clCreateFromD3D10Texture2DKHR
NULL, // clCreateFromD3D10Texture3DKHR
NULL, // clEnqueueAcquireD3D10ObjectsKHR
NULL, // clEnqueueReleaseD3D10ObjectsKHR
clSetEventCallback,
clCreateSubBuffer,
clSetMemObjectDestructorCallback,
clCreateUserEvent,
clSetUserEventStatus,
clEnqueueReadBufferRect,
clEnqueueWriteBufferRect,
clEnqueueCopyBufferRect,
NULL, // clCreateSubDevicesEXT
NULL, // clRetainDeviceEXT
NULL, // clReleaseDeviceEXT
NULL, // clCreateEventFromGLsyncKHR
NULL, // clCreateSubDevices
NULL, // clRetainDevice
NULL, // clReleaseDevice
NULL, // clCreateImage
NULL, // clCreateProgramWithBuiltInKernels
NULL, // clCompileProgram
NULL, // clLinkProgram
NULL, // clUnloadPlatformCompiler
NULL, // clGetKernelArgInfo
NULL, // clEnqueueFillBuffer
NULL, // clEnqueueFillImage
NULL, // clEnqueueMigrateMemObjects
NULL, // clEnqueueMarkerWithWaitList
NULL, // clEnqueueBarrierWithWaitList
NULL, // clGetExtensionFunctionAddressForPlatform
NULL, // clCreateFromGLTexture
NULL, // clGetDeviceIDsFromD3D11KHR
NULL, // clCreateFromD3D11BufferKHR
NULL, // clCreateFromD3D11Texture2DKHR
NULL, // clCreateFromD3D11Texture3DKHR
NULL, // clCreateFromDX9MediaSurfaceKHR
NULL, // clEnqueueAcquireD3D11ObjectsKHR
NULL, // clEnqueueReleaseD3D11ObjectsKHR
NULL, // clGetDeviceIDsFromDX9MediaAdapterKHR
NULL, // clEnqueueAcquireDX9MediaSurfacesKHR
NULL // clEnqueueReleaseDX9MediaSurfacesKHR
};
}

759
src/gallium/state_trackers/clover/api/dispatch.hpp Normal file
View file

@ -0,0 +1,759 @@
//
// Copyright 2013 Francisco Jerez
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
#ifndef API_DISPATCH_HPP
#define API_DISPATCH_HPP
#include "CL/cl.h"
#include "CL/cl_ext.h"
#include "CL/cl_gl.h"
///
/// OpenCL ICD vendor dispatch table.
///
/// The entry point ordering should always be in agreement with
/// Khronos' ICD loader.
///
struct _cl_icd_dispatch {
CL_API_ENTRY cl_int (CL_API_CALL *clGetPlatformIDs)(
cl_uint num_entries,
cl_platform_id *platforms,
cl_uint *num_platforms);
CL_API_ENTRY cl_int (CL_API_CALL *clGetPlatformInfo)(
cl_platform_id platform,
cl_platform_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clGetDeviceIDs)(
cl_platform_id platform,
cl_device_type device_type,
cl_uint num_entries,
cl_device_id *devices,
cl_uint *num_devices);
CL_API_ENTRY cl_int (CL_API_CALL *clGetDeviceInfo)(
cl_device_id device,
cl_device_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_context (CL_API_CALL *clCreateContext)(
const cl_context_properties *properties,
cl_uint num_devices,
const cl_device_id *devices,
void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
void *user_data,
cl_int *errcode_ret);
CL_API_ENTRY cl_context (CL_API_CALL *clCreateContextFromType)(
const cl_context_properties *properties,
cl_device_type device_type,
void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
void *user_data,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainContext)(
cl_context context);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseContext)(
cl_context context);
CL_API_ENTRY cl_int (CL_API_CALL *clGetContextInfo)(
cl_context context,
cl_context_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_command_queue (CL_API_CALL *clCreateCommandQueue)(
cl_context context,
cl_device_id device,
cl_command_queue_properties properties,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainCommandQueue)(
cl_command_queue command_queue);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseCommandQueue)(
cl_command_queue command_queue);
CL_API_ENTRY cl_int (CL_API_CALL *clGetCommandQueueInfo)(
cl_command_queue command_queue,
cl_command_queue_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clSetCommandQueueProperty)(
cl_command_queue command_queue,
cl_command_queue_properties properties,
cl_bool enable,
cl_command_queue_properties *old_properties);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateBuffer)(
cl_context context,
cl_mem_flags flags,
size_t size,
void *host_ptr,
cl_int *errcode_ret);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateImage2D)(
cl_context context,
cl_mem_flags flags,
const cl_image_format *image_format,
size_t image_width,
size_t image_height,
size_t image_row_pitch,
void *host_ptr,
cl_int *errcode_ret);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateImage3D)(
cl_context context,
cl_mem_flags flags,
const cl_image_format *image_format,
size_t image_width,
size_t image_height,
size_t image_depth,
size_t image_row_pitch,
size_t image_slice_pitch,
void *host_ptr,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainMemObject)(
cl_mem memobj);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseMemObject)(
cl_mem memobj);
CL_API_ENTRY cl_int (CL_API_CALL *clGetSupportedImageFormats)(
cl_context context,
cl_mem_flags flags,
cl_mem_object_type image_type,
cl_uint num_entries,
cl_image_format *image_formats,
cl_uint *num_image_formats);
CL_API_ENTRY cl_int (CL_API_CALL *clGetMemObjectInfo)(
cl_mem memobj,
cl_mem_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clGetImageInfo)(
cl_mem image,
cl_image_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_sampler (CL_API_CALL *clCreateSampler)(
cl_context context,
cl_bool normalized_coords,
cl_addressing_mode addressing_mode,
cl_filter_mode filter_mode,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainSampler)(
cl_sampler sampler);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseSampler)(
cl_sampler sampler);
CL_API_ENTRY cl_int (CL_API_CALL *clGetSamplerInfo)(
cl_sampler sampler,
cl_sampler_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_program (CL_API_CALL *clCreateProgramWithSource)(
cl_context context,
cl_uint count,
const char **strings,
const size_t *lengths,
cl_int *errcode_ret);
CL_API_ENTRY cl_program (CL_API_CALL *clCreateProgramWithBinary)(
cl_context context,
cl_uint num_devices,
const cl_device_id *device_list,
const size_t *lengths,
const unsigned char **binaries,
cl_int *binary_status,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainProgram)(
cl_program program);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseProgram)(
cl_program program);
CL_API_ENTRY cl_int (CL_API_CALL *clBuildProgram)(
cl_program program,
cl_uint num_devices,
const cl_device_id *device_list,
const char *options,
void (CL_CALLBACK *pfn_notify)(cl_program, void *),
void *user_data);
CL_API_ENTRY cl_int (CL_API_CALL *clUnloadCompiler)(
void);
CL_API_ENTRY cl_int (CL_API_CALL *clGetProgramInfo)(
cl_program program,
cl_program_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clGetProgramBuildInfo)(
cl_program program,
cl_device_id device,
cl_program_build_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_kernel (CL_API_CALL *clCreateKernel)(
cl_program program,
const char *kernel_name,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clCreateKernelsInProgram)(
cl_program program,
cl_uint num_kernels,
cl_kernel *kernels,
cl_uint *num_kernels_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainKernel)(
cl_kernel kernel);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseKernel)(
cl_kernel kernel);
CL_API_ENTRY cl_int (CL_API_CALL *clSetKernelArg)(
cl_kernel kernel,
cl_uint arg_index,
size_t arg_size,
const void *arg_value);
CL_API_ENTRY cl_int (CL_API_CALL *clGetKernelInfo)(
cl_kernel kernel,
cl_kernel_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clGetKernelWorkGroupInfo)(
cl_kernel kernel,
cl_device_id device,
cl_kernel_work_group_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clWaitForEvents)(
cl_uint num_events,
const cl_event *event_list);
CL_API_ENTRY cl_int (CL_API_CALL *clGetEventInfo)(
cl_event event,
cl_event_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainEvent)(
cl_event event);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseEvent)(
cl_event event);
CL_API_ENTRY cl_int (CL_API_CALL *clGetEventProfilingInfo)(
cl_event event,
cl_profiling_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clFlush)(
cl_command_queue command_queue);
CL_API_ENTRY cl_int (CL_API_CALL *clFinish)(
cl_command_queue command_queue);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReadBuffer)(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_read,
size_t offset,
size_t cb,
void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueWriteBuffer)(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
size_t offset,
size_t cb,
const void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueCopyBuffer)(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
size_t src_offset,
size_t dst_offset,
size_t cb,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReadImage)(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_read,
const size_t *origin,
const size_t *region,
size_t row_pitch,
size_t slice_pitch,
void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueWriteImage)(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_write,
const size_t *origin,
const size_t *region,
size_t input_row_pitch,
size_t input_slice_pitch,
const void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueCopyImage)(
cl_command_queue command_queue,
cl_mem src_image,
cl_mem dst_image,
const size_t *src_origin,
const size_t *dst_origin,
const size_t *region,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueCopyImageToBuffer)(
cl_command_queue command_queue,
cl_mem src_image,
cl_mem dst_buffer,
const size_t *src_origin,
const size_t *region,
size_t dst_offset,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueCopyBufferToImage)(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_image,
size_t src_offset,
const size_t *dst_origin,
const size_t *region,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY void *(CL_API_CALL *clEnqueueMapBuffer)(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_map,
cl_map_flags map_flags,
size_t offset,
size_t cb,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event,
cl_int *errcode_ret);
CL_API_ENTRY void *(CL_API_CALL *clEnqueueMapImage)(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_map,
cl_map_flags map_flags,
const size_t *origin,
const size_t *region,
size_t *image_row_pitch,
size_t *image_slice_pitch,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueUnmapMemObject)(
cl_command_queue command_queue,
cl_mem memobj,
void *mapped_ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueNDRangeKernel)(
cl_command_queue command_queue,
cl_kernel kernel,
cl_uint work_dim,
const size_t *global_work_offset,
const size_t *global_work_size,
const size_t *local_work_size,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueTask)(
cl_command_queue command_queue,
cl_kernel kernel,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueNativeKernel)(
cl_command_queue command_queue,
void (CL_CALLBACK *user_func)(void *),
void *args,
size_t cb_args,
cl_uint num_mem_objects,
const cl_mem *mem_list,
const void **args_mem_loc,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueMarker)(
cl_command_queue command_queue,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueWaitForEvents)(
cl_command_queue command_queue,
cl_uint num_events,
const cl_event *event_list);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueBarrier)(
cl_command_queue command_queue);
CL_API_ENTRY void *(CL_API_CALL *clGetExtensionFunctionAddress)(
const char *function_name);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromGLBuffer)(
cl_context context,
cl_mem_flags flags,
cl_GLuint bufobj,
int *errcode_ret);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromGLTexture2D)(
cl_context context,
cl_mem_flags flags,
cl_GLenum target,
cl_GLint miplevel,
cl_GLuint texture,
cl_int *errcode_ret);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromGLTexture3D)(
cl_context context,
cl_mem_flags flags,
cl_GLenum target,
cl_GLint miplevel,
cl_GLuint texture,
cl_int *errcode_ret);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromGLRenderbuffer)(
cl_context context,
cl_mem_flags flags,
cl_GLuint renderbuffer,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clGetGLObjectInfo)(
cl_mem memobj,
cl_gl_object_type *gl_object_type,
cl_GLuint *gl_object_name);
CL_API_ENTRY cl_int (CL_API_CALL *clGetGLTextureInfo)(
cl_mem memobj,
cl_gl_texture_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueAcquireGLObjects)(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem *mem_objects,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReleaseGLObjects)(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem *mem_objects,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clGetGLContextInfoKHR)(
const cl_context_properties *properties,
cl_gl_context_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
void *clGetDeviceIDsFromD3D10KHR;
void *clCreateFromD3D10BufferKHR;
void *clCreateFromD3D10Texture2DKHR;
void *clCreateFromD3D10Texture3DKHR;
void *clEnqueueAcquireD3D10ObjectsKHR;
void *clEnqueueReleaseD3D10ObjectsKHR;
CL_API_ENTRY cl_int (CL_API_CALL *clSetEventCallback)(
cl_event event,
cl_int type,
void (CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *),
void *user_data);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateSubBuffer)(
cl_mem buffer,
cl_mem_flags flags,
cl_buffer_create_type buffer_create_type,
const void *buffer_create_info,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clSetMemObjectDestructorCallback)(
cl_mem memobj,
void (CL_CALLBACK *pfn_notify)(cl_mem, void *),
void *user_data);
CL_API_ENTRY cl_event (CL_API_CALL *clCreateUserEvent)(
cl_context context,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clSetUserEventStatus)(
cl_event event,
cl_int status);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReadBufferRect)(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_read,
const size_t *buffer_origin,
const size_t *host_origin,
const size_t *region,
size_t buffer_row_pitch,
size_t buffer_slice_pitch,
size_t host_row_pitch,
size_t host_slice_pitch,
void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueWriteBufferRect)(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_read,
const size_t *buffer_origin,
const size_t *host_origin,
const size_t *region,
size_t buffer_row_pitch,
size_t buffer_slice_pitch,
size_t host_row_pitch,
size_t host_slice_pitch,
const void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueCopyBufferRect)(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
const size_t *src_origin,
const size_t *dst_origin,
const size_t *region,
size_t src_row_pitch,
size_t src_slice_pitch,
size_t dst_row_pitch,
size_t dst_slice_pitch,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clCreateSubDevicesEXT)(
cl_device_id in_device,
const cl_device_partition_property_ext *partition_properties,
cl_uint num_entries,
cl_device_id *out_devices,
cl_uint *num_devices);
CL_API_ENTRY cl_int (CL_API_CALL *clRetainDeviceEXT)(
cl_device_id device);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseDeviceEXT)(
cl_device_id device);
CL_API_ENTRY cl_event (CL_API_CALL *clCreateEventFromGLsyncKHR)(
cl_context context,
cl_GLsync sync,
cl_int *errcode_ret);
void *clCreateSubDevices;
CL_API_ENTRY cl_int (CL_API_CALL *clRetainDevice)(
cl_device_id device);
CL_API_ENTRY cl_int (CL_API_CALL *clReleaseDevice)(
cl_device_id device);
void *clCreateImage;
CL_API_ENTRY cl_program (CL_API_CALL *clCreateProgramWithBuiltInKernels)(
cl_context context,
cl_uint num_devices,
const cl_device_id *device_list,
const char *kernel_names,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clCompileProgram)(
cl_program program,
cl_uint num_devices,
const cl_device_id *device_list,
const char *options,
cl_uint num_input_headers,
const cl_program *input_headers,
const char **header_include_names,
void (CL_CALLBACK *pfn_notify)(cl_program, void *),
void *user_data);
CL_API_ENTRY cl_program (CL_API_CALL *clLinkProgram)(
cl_context context,
cl_uint num_devices,
const cl_device_id *device_list,
const char *options,
cl_uint num_input_programs,
const cl_program *input_programs,
void (CL_CALLBACK *pfn_notify)(cl_program, void *),
void *user_data,
cl_int *errcode_ret);
CL_API_ENTRY cl_int (CL_API_CALL *clUnloadPlatformCompiler)(
cl_platform_id platform);
void *clGetKernelArgInfo;
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueFillBuffer)(
cl_command_queue command_queue,
cl_mem buffer,
const void *pattern,
size_t pattern_size,
size_t offset,
size_t cb,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueFillImage)(
cl_command_queue command_queue,
cl_mem image,
const void *fill_color,
const size_t origin[3],
const size_t region[3],
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
void *clEnqueueMigrateMemObjects;
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueMarkerWithWaitList)(
cl_command_queue command_queue,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueBarrierWithWaitList)(
cl_command_queue command_queue,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event);
CL_API_ENTRY void *(CL_API_CALL *clGetExtensionFunctionAddressForPlatform)(
cl_platform_id platform,
const char *function_name);
CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromGLTexture)(
cl_context context,
cl_mem_flags flags,
cl_GLenum target,
cl_GLint miplevel,
cl_GLuint texture,
cl_int *errcode_ret);
void *clGetDeviceIDsFromD3D11KHR;
void *clCreateFromD3D11BufferKHR;
void *clCreateFromD3D11Texture2DKHR;
void *clCreateFromD3D11Texture3DKHR;
void *clCreateFromDX9MediaSurfaceKHR;
void *clEnqueueAcquireD3D11ObjectsKHR;
void *clEnqueueReleaseD3D11ObjectsKHR;
void *clGetDeviceIDsFromDX9MediaAdapterKHR;
void *clEnqueueAcquireDX9MediaSurfacesKHR;
void *clEnqueueReleaseDX9MediaSurfacesKHR;
};
namespace clover {
extern const _cl_icd_dispatch _dispatch;
cl_int
GetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
size_t size, void *r_buf, size_t *r_size);
void *
GetExtensionFunctionAddress(const char *p_name);
cl_int
IcdGetPlatformIDsKHR(cl_uint num_entries, cl_platform_id *rd_platforms,
cl_uint *rnum_platforms);
}
#endif

24
src/gallium/state_trackers/clover/api/event.cpp
View file

@ -25,7 +25,7 @@
using namespace clover;
PUBLIC cl_event
CLOVER_API cl_event
clCreateUserEvent(cl_context d_ctx, cl_int *r_errcode) try {
auto &ctx = obj(d_ctx);
@ -37,7 +37,7 @@ clCreateUserEvent(cl_context d_ctx, cl_int *r_errcode) try {
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clSetUserEventStatus(cl_event d_ev, cl_int status) try {
auto &sev = obj<soft_event>(d_ev);
@ -58,7 +58,7 @@ clSetUserEventStatus(cl_event d_ev, cl_int status) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clWaitForEvents(cl_uint num_evs, const cl_event *d_evs) try {
auto evs = objs(d_evs, num_evs);
@ -84,7 +84,7 @@ clWaitForEvents(cl_uint num_evs, const cl_event *d_evs) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetEventInfo(cl_event d_ev, cl_event_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
@ -121,7 +121,7 @@ clGetEventInfo(cl_event d_ev, cl_event_info param,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clSetEventCallback(cl_event d_ev, cl_int type,
void (CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *),
void *user_data) try {
@ -145,7 +145,7 @@ clSetEventCallback(cl_event d_ev, cl_int type,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clRetainEvent(cl_event d_ev) try {
obj(d_ev).retain();
return CL_SUCCESS;
@ -154,7 +154,7 @@ clRetainEvent(cl_event d_ev) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clReleaseEvent(cl_event d_ev) try {
if (obj(d_ev).release())
delete pobj(d_ev);
@ -165,7 +165,7 @@ clReleaseEvent(cl_event d_ev) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueMarker(cl_command_queue d_q, cl_event *rd_ev) try {
auto &q = obj(d_q);
@ -180,7 +180,7 @@ clEnqueueMarker(cl_command_queue d_q, cl_event *rd_ev) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueBarrier(cl_command_queue d_q) try {
obj(d_q);
@ -192,7 +192,7 @@ clEnqueueBarrier(cl_command_queue d_q) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueWaitForEvents(cl_command_queue d_q, cl_uint num_evs,
const cl_event *d_evs) try {
auto &q = obj(d_q);
@ -214,7 +214,7 @@ clEnqueueWaitForEvents(cl_command_queue d_q, cl_uint num_evs,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetEventProfilingInfo(cl_event d_ev, cl_profiling_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
@ -256,7 +256,7 @@ clGetEventProfilingInfo(cl_event d_ev, cl_profiling_info param,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clFinish(cl_command_queue d_q) try {
auto &q = obj(d_q);

20
src/gallium/state_trackers/clover/api/kernel.cpp
View file

@ -26,7 +26,7 @@
using namespace clover;
PUBLIC cl_kernel
CLOVER_API cl_kernel
clCreateKernel(cl_program d_prog, const char *name, cl_int *r_errcode) try {
auto &prog = obj(d_prog);
@ -47,7 +47,7 @@ clCreateKernel(cl_program d_prog, const char *name, cl_int *r_errcode) try {
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clCreateKernelsInProgram(cl_program d_prog, cl_uint count,
cl_kernel *rd_kerns, cl_uint *r_count) try {
auto &prog = obj(d_prog);
@ -72,7 +72,7 @@ clCreateKernelsInProgram(cl_program d_prog, cl_uint count,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clRetainKernel(cl_kernel d_kern) try {
obj(d_kern).retain();
return CL_SUCCESS;
@ -81,7 +81,7 @@ clRetainKernel(cl_kernel d_kern) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clReleaseKernel(cl_kernel d_kern) try {
if (obj(d_kern).release())
delete pobj(d_kern);
@ -92,7 +92,7 @@ clReleaseKernel(cl_kernel d_kern) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clSetKernelArg(cl_kernel d_kern, cl_uint idx, size_t size,
const void *value) try {
obj(d_kern).args().at(idx).set(size, value);
@ -105,7 +105,7 @@ clSetKernelArg(cl_kernel d_kern, cl_uint idx, size_t size,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetKernelInfo(cl_kernel d_kern, cl_kernel_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
@ -142,7 +142,7 @@ clGetKernelInfo(cl_kernel d_kern, cl_kernel_info param,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetKernelWorkGroupInfo(cl_kernel d_kern, cl_device_id d_dev,
cl_kernel_work_group_info param,
size_t size, void *r_buf, size_t *r_size) try {
@ -243,7 +243,7 @@ namespace {
}
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueNDRangeKernel(cl_command_queue d_q, cl_kernel d_kern,
cl_uint dims, const size_t *d_grid_offset,
const size_t *d_grid_size, const size_t *d_block_size,
@ -272,7 +272,7 @@ clEnqueueNDRangeKernel(cl_command_queue d_q, cl_kernel d_kern,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueTask(cl_command_queue d_q, cl_kernel d_kern,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {
@ -295,7 +295,7 @@ clEnqueueTask(cl_command_queue d_q, cl_kernel d_kern,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueNativeKernel(cl_command_queue d_q, void (*func)(void *),
void *args, size_t args_size,
cl_uint num_mems, const cl_mem *d_mems,

20
src/gallium/state_trackers/clover/api/memory.cpp
View file

@ -26,7 +26,7 @@
using namespace clover;
PUBLIC cl_mem
CLOVER_API cl_mem
clCreateBuffer(cl_context d_ctx, cl_mem_flags flags, size_t size,
void *host_ptr, cl_int *r_errcode) try {
auto &ctx = obj(d_ctx);
@ -51,7 +51,7 @@ clCreateBuffer(cl_context d_ctx, cl_mem_flags flags, size_t size,
return NULL;
}
PUBLIC cl_mem
CLOVER_API cl_mem
clCreateSubBuffer(cl_mem d_mem, cl_mem_flags flags,
cl_buffer_create_type op,
const void *op_info, cl_int *r_errcode) try {
@ -87,7 +87,7 @@ clCreateSubBuffer(cl_mem d_mem, cl_mem_flags flags,
return NULL;
}
PUBLIC cl_mem
CLOVER_API cl_mem
clCreateImage2D(cl_context d_ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t row_pitch,
@ -121,7 +121,7 @@ clCreateImage2D(cl_context d_ctx, cl_mem_flags flags,
return NULL;
}
PUBLIC cl_mem
CLOVER_API cl_mem
clCreateImage3D(cl_context d_ctx, cl_mem_flags flags,
const cl_image_format *format,
size_t width, size_t height, size_t depth,
@ -156,7 +156,7 @@ clCreateImage3D(cl_context d_ctx, cl_mem_flags flags,
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clGetSupportedImageFormats(cl_context d_ctx, cl_mem_flags flags,
cl_mem_object_type type, cl_uint count,
cl_image_format *r_buf, cl_uint *r_count) try {
@ -186,7 +186,7 @@ clGetSupportedImageFormats(cl_context d_ctx, cl_mem_flags flags,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetMemObjectInfo(cl_mem d_mem, cl_mem_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
@ -241,7 +241,7 @@ clGetMemObjectInfo(cl_mem d_mem, cl_mem_info param,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetImageInfo(cl_mem d_mem, cl_image_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
@ -286,7 +286,7 @@ clGetImageInfo(cl_mem d_mem, cl_image_info param,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clRetainMemObject(cl_mem d_mem) try {
obj(d_mem).retain();
return CL_SUCCESS;
@ -295,7 +295,7 @@ clRetainMemObject(cl_mem d_mem) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clReleaseMemObject(cl_mem d_mem) try {
if (obj(d_mem).release())
delete pobj(d_mem);
@ -306,7 +306,7 @@ clReleaseMemObject(cl_mem d_mem) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clSetMemObjectDestructorCallback(cl_mem d_mem,
void (CL_CALLBACK *pfn_notify)(cl_mem, void *),
void *user_data) try {

47
src/gallium/state_trackers/clover/api/platform.cpp
View file

@ -29,7 +29,7 @@ namespace {
platform _clover_platform;
}
PUBLIC cl_int
CLOVER_API cl_int
clGetPlatformIDs(cl_uint num_entries, cl_platform_id *rd_platforms,
cl_uint *rnum_platforms) {
if ((!num_entries && rd_platforms) ||
@ -44,9 +44,9 @@ clGetPlatformIDs(cl_uint num_entries, cl_platform_id *rd_platforms,
return CL_SUCCESS;
}
PUBLIC cl_int
clGetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
size_t size, void *r_buf, size_t *r_size) try {
cl_int
clover::GetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
obj(d_platform);
@ -69,7 +69,11 @@ clGetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
break;
case CL_PLATFORM_EXTENSIONS:
buf.as_string() = "";
buf.as_string() = "cl_khr_icd";
break;
case CL_PLATFORM_ICD_SUFFIX_KHR:
buf.as_string() = "MESA";
break;
default:
@ -81,3 +85,36 @@ clGetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
} catch (error &e) {
return e.get();
}
void *
clover::GetExtensionFunctionAddress(const char *p_name) {
std::string name { p_name };
if (name == "clIcdGetPlatformIDsKHR")
return reinterpret_cast<void *>(IcdGetPlatformIDsKHR);
else
return NULL;
}
cl_int
clover::IcdGetPlatformIDsKHR(cl_uint num_entries, cl_platform_id *rd_platforms,
cl_uint *rnum_platforms) {
return clGetPlatformIDs(num_entries, rd_platforms, rnum_platforms);
}
CLOVER_ICD_API cl_int
clGetPlatformInfo(cl_platform_id d_platform, cl_platform_info param,
size_t size, void *r_buf, size_t *r_size) {
return GetPlatformInfo(d_platform, param, size, r_buf, r_size);
}
CLOVER_ICD_API void *
clGetExtensionFunctionAddress(const char *p_name) {
return GetExtensionFunctionAddress(p_name);
}
CLOVER_ICD_API cl_int
clIcdGetPlatformIDsKHR(cl_uint num_entries, cl_platform_id *rd_platforms,
cl_uint *rnum_platforms) {
return IcdGetPlatformIDsKHR(num_entries, rd_platforms, rnum_platforms);
}

16
src/gallium/state_trackers/clover/api/program.cpp
View file

@ -25,7 +25,7 @@
using namespace clover;
PUBLIC cl_program
CLOVER_API cl_program
clCreateProgramWithSource(cl_context d_ctx, cl_uint count,
const char **strings, const size_t *lengths,
cl_int *r_errcode) try {
@ -51,7 +51,7 @@ clCreateProgramWithSource(cl_context d_ctx, cl_uint count,
return NULL;
}
PUBLIC cl_program
CLOVER_API cl_program
clCreateProgramWithBinary(cl_context d_ctx, cl_uint n,
const cl_device_id *d_devs,
const size_t *lengths,
@ -106,7 +106,7 @@ clCreateProgramWithBinary(cl_context d_ctx, cl_uint n,
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clRetainProgram(cl_program d_prog) try {
obj(d_prog).retain();
return CL_SUCCESS;
@ -115,7 +115,7 @@ clRetainProgram(cl_program d_prog) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clReleaseProgram(cl_program d_prog) try {
if (obj(d_prog).release())
delete pobj(d_prog);
@ -126,7 +126,7 @@ clReleaseProgram(cl_program d_prog) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clBuildProgram(cl_program d_prog, cl_uint num_devs,
const cl_device_id *d_devs, const char *p_opts,
void (*pfn_notify)(cl_program, void *),
@ -152,12 +152,12 @@ clBuildProgram(cl_program d_prog, cl_uint num_devs,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clUnloadCompiler() {
return CL_SUCCESS;
}
PUBLIC cl_int
CLOVER_API cl_int
clGetProgramInfo(cl_program d_prog, cl_program_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
@ -214,7 +214,7 @@ clGetProgramInfo(cl_program d_prog, cl_program_info param,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetProgramBuildInfo(cl_program d_prog, cl_device_id d_dev,
cl_program_build_info param,
size_t size, void *r_buf, size_t *r_size) try {

10
src/gallium/state_trackers/clover/api/queue.cpp
View file

@ -25,7 +25,7 @@
using namespace clover;
PUBLIC cl_command_queue
CLOVER_API cl_command_queue
clCreateCommandQueue(cl_context d_ctx, cl_device_id d_dev,
cl_command_queue_properties props,
cl_int *r_errcode) try {
@ -47,7 +47,7 @@ clCreateCommandQueue(cl_context d_ctx, cl_device_id d_dev,
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clRetainCommandQueue(cl_command_queue d_q) try {
obj(d_q).retain();
return CL_SUCCESS;
@ -56,7 +56,7 @@ clRetainCommandQueue(cl_command_queue d_q) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clReleaseCommandQueue(cl_command_queue d_q) try {
if (obj(d_q).release())
delete pobj(d_q);
@ -67,7 +67,7 @@ clReleaseCommandQueue(cl_command_queue d_q) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetCommandQueueInfo(cl_command_queue d_q, cl_command_queue_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };
@ -100,7 +100,7 @@ clGetCommandQueueInfo(cl_command_queue d_q, cl_command_queue_info param,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clFlush(cl_command_queue d_q) try {
obj(d_q).flush();
return CL_SUCCESS;

8
src/gallium/state_trackers/clover/api/sampler.cpp
View file

@ -25,7 +25,7 @@
using namespace clover;
PUBLIC cl_sampler
CLOVER_API cl_sampler
clCreateSampler(cl_context d_ctx, cl_bool norm_mode,
cl_addressing_mode addr_mode, cl_filter_mode filter_mode,
cl_int *r_errcode) try {
@ -39,7 +39,7 @@ clCreateSampler(cl_context d_ctx, cl_bool norm_mode,
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clRetainSampler(cl_sampler d_s) try {
obj(d_s).retain();
return CL_SUCCESS;
@ -48,7 +48,7 @@ clRetainSampler(cl_sampler d_s) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clReleaseSampler(cl_sampler d_s) try {
if (obj(d_s).release())
delete pobj(d_s);
@ -59,7 +59,7 @@ clReleaseSampler(cl_sampler d_s) try {
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clGetSamplerInfo(cl_sampler d_s, cl_sampler_info param,
size_t size, void *r_buf, size_t *r_size) try {
property_buffer buf { r_buf, size, r_size };

28
src/gallium/state_trackers/clover/api/transfer.cpp
View file

@ -131,7 +131,7 @@ namespace {
}
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueReadBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
size_t offset, size_t size, void *ptr,
cl_uint num_deps, const cl_event *d_deps,
@ -159,7 +159,7 @@ clEnqueueReadBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueWriteBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
size_t offset, size_t size, const void *ptr,
cl_uint num_deps, const cl_event *d_deps,
@ -187,7 +187,7 @@ clEnqueueWriteBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueReadBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *obj_origin,
const size_t *host_origin,
@ -222,7 +222,7 @@ clEnqueueReadBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueWriteBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *obj_origin,
const size_t *host_origin,
@ -257,7 +257,7 @@ clEnqueueWriteBufferRect(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueCopyBuffer(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
size_t src_offset, size_t dst_offset, size_t size,
cl_uint num_deps, const cl_event *d_deps,
@ -282,7 +282,7 @@ clEnqueueCopyBuffer(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueCopyBufferRect(cl_command_queue d_q, cl_mem d_src_mem,
cl_mem d_dst_mem,
const size_t *src_origin, const size_t *dst_origin,
@ -314,7 +314,7 @@ clEnqueueCopyBufferRect(cl_command_queue d_q, cl_mem d_src_mem,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueReadImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *origin, const size_t *region,
size_t row_pitch, size_t slice_pitch, void *ptr,
@ -345,7 +345,7 @@ clEnqueueReadImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueWriteImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
const size_t *origin, const size_t *region,
size_t row_pitch, size_t slice_pitch, const void *ptr,
@ -376,7 +376,7 @@ clEnqueueWriteImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueCopyImage(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
const size_t *src_origin, const size_t *dst_origin,
const size_t *region,
@ -403,7 +403,7 @@ clEnqueueCopyImage(cl_command_queue d_q, cl_mem d_src_mem, cl_mem d_dst_mem,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueCopyImageToBuffer(cl_command_queue d_q,
cl_mem d_src_mem, cl_mem d_dst_mem,
const size_t *src_origin, const size_t *region,
@ -433,7 +433,7 @@ clEnqueueCopyImageToBuffer(cl_command_queue d_q,
return e.get();
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueCopyBufferToImage(cl_command_queue d_q,
cl_mem d_src_mem, cl_mem d_dst_mem,
size_t src_offset,
@ -463,7 +463,7 @@ clEnqueueCopyBufferToImage(cl_command_queue d_q,
return e.get();
}
PUBLIC void *
CLOVER_API void *
clEnqueueMapBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
cl_map_flags flags, size_t offset, size_t size,
cl_uint num_deps, const cl_event *d_deps,
@ -489,7 +489,7 @@ clEnqueueMapBuffer(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return NULL;
}
PUBLIC void *
CLOVER_API void *
clEnqueueMapImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
cl_map_flags flags,
const size_t *origin, const size_t *region,
@ -514,7 +514,7 @@ clEnqueueMapImage(cl_command_queue d_q, cl_mem d_mem, cl_bool blocking,
return NULL;
}
PUBLIC cl_int
CLOVER_API cl_int
clEnqueueUnmapMemObject(cl_command_queue d_q, cl_mem d_mem, void *ptr,
cl_uint num_deps, const cl_event *d_deps,
cl_event *rd_ev) try {

8
src/gallium/state_trackers/clover/api/util.hpp
View file

@ -29,6 +29,14 @@
#include "core/property.hpp"
#include "util/algorithm.hpp"
#ifdef HAVE_CLOVER_ICD
#define CLOVER_API
#define CLOVER_ICD_API PUBLIC
#else
#define CLOVER_API PUBLIC
#define CLOVER_ICD_API PUBLIC
#endif
namespace clover {
///
/// Return an error code in \a p if non-zero.

15
src/gallium/state_trackers/clover/core/object.hpp
View file

@ -31,6 +31,7 @@
#include "core/error.hpp"
#include "core/property.hpp"
#include "api/dispatch.hpp"
///
/// Main namespace of the CL state tracker.
@ -43,6 +44,13 @@ namespace clover {
struct descriptor {
typedef T object_type;
typedef S descriptor_type;
descriptor() : dispatch(&_dispatch) {
static_assert(std::is_standard_layout<descriptor_type>::value,
"ICD requires CL API objects to be standard layout.");
}
const _cl_icd_dispatch *dispatch;
};
struct default_tag;
@ -57,7 +65,8 @@ namespace clover {
static void
validate(D *d) {
auto o = static_cast<typename D::object_type *>(d);
if (!o || !dynamic_cast<object_type *>(o))
if (!o || o->dispatch != &_dispatch ||
!dynamic_cast<object_type *>(o))
throw invalid_object_error<T>();
}
@ -74,7 +83,7 @@ namespace clover {
static void
validate(D *d) {
if (!d)
if (!d || d->dispatch != &_dispatch)
throw invalid_object_error<object_type>();
}
@ -91,7 +100,7 @@ namespace clover {
static void
validate(D *d) {
if (!d)
if (!d || d->dispatch != &_dispatch)
throw invalid_wait_list_error();
}

5
src/gallium/targets/opencl/Makefile.am
View file

@ -33,6 +33,11 @@ lib@OPENCL_LIBNAME@_la_SOURCES =
# Force usage of a C++ linker
nodist_EXTRA_lib@OPENCL_LIBNAME@_la_SOURCES = dummy.cpp
if HAVE_CLOVER_ICD
icddir = /etc/OpenCL/vendors/
icd_DATA = mesa.icd
endif
# Provide compatibility with scripts for the old Mesa build system for
# a while by putting a link to the driver into /lib of the build tree.
all-local: lib@OPENCL_LIBNAME@.la

1
src/gallium/targets/opencl/mesa.icd Normal file
View file

@ -0,0 +1 @@
libMesaOpenCL.so