From: Junyan He <junyan...@intel.com> The device cl_device_id define the common content for all kinds of OpenCL device implementation. Every kind of device can derive this struct.
Signed-off-by: Junyan He <junyan...@intel.com> --- runtime/cl_device_id.c | 493 +++++++++++++++++++++++++++++++++++++++++++++++++ runtime/cl_device_id.h | 168 +++++++++++++++++ 2 files changed, 661 insertions(+) create mode 100644 runtime/cl_device_id.c create mode 100644 runtime/cl_device_id.h diff --git a/runtime/cl_device_id.c b/runtime/cl_device_id.c new file mode 100644 index 0000000..9e39e4d --- /dev/null +++ b/runtime/cl_device_id.c @@ -0,0 +1,493 @@ +/* + * Copyright © 2012 Intel Corporation + * + * 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, see <http://www.gnu.org/licenses/>. + * + * Author: Benjamin Segovia <benjamin.sego...@intel.com> + */ + +#include "cl_platform_id.h" +#include "cl_device_id.h" +#include "cl_utils.h" +#include "CL/cl_ext.h" +#include <string.h> + +#ifndef CL_VERSION_1_2 +#define CL_DEVICE_BUILT_IN_KERNELS 0x103F +#endif + +LOCAL cl_int +cl_device_get_ids(cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, + cl_device_id *devices, cl_uint *num_devices) +{ + cl_device_id device = NULL; + + if (device_type & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_DEFAULT)) + device = cl_device_get_id_gen(platform); + + /* Do we have a usable device? */ + if (device == NULL) + return CL_DEVICE_NOT_FOUND; + + if (devices) + devices[0] = device; + if (num_devices) + *num_devices = 1; + return CL_SUCCESS; +} + +LOCAL cl_int +cl_device_get_info(cl_device_id device, cl_device_info param_name, size_t param_value_size, + void *param_value, size_t *param_value_size_ret) +{ + const void *src_ptr = NULL; + size_t src_size = 0; + cl_int dev_ref; + + /* Find the correct parameter */ + switch (param_name) { + case CL_DEVICE_TYPE: + src_ptr = &device->device_type; + src_size = sizeof(device->device_type); + break; + case CL_DEVICE_VENDOR_ID: + src_ptr = &device->vendor_id; + src_size = sizeof(device->vendor_id); + break; + case CL_DEVICE_MAX_COMPUTE_UNITS: + src_ptr = &device->max_compute_unit; + src_size = sizeof(device->max_compute_unit); + break; + case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: + src_ptr = &device->max_work_item_dimensions; + src_size = sizeof(device->max_work_item_dimensions); + break; + case CL_DEVICE_MAX_WORK_ITEM_SIZES: + src_ptr = &device->max_work_item_sizes; + src_size = sizeof(device->max_work_item_sizes); + break; + case CL_DEVICE_MAX_WORK_GROUP_SIZE: + src_ptr = &device->max_work_group_size; + src_size = sizeof(device->max_work_group_size); + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: + src_ptr = &device->preferred_vector_width_char; + src_size = sizeof(device->preferred_vector_width_char); + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: + src_ptr = &device->preferred_vector_width_short; + src_size = sizeof(device->preferred_vector_width_short); + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: + src_ptr = &device->preferred_vector_width_int; + src_size = sizeof(device->preferred_vector_width_int); + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: + src_ptr = &device->preferred_vector_width_long; + src_size = sizeof(device->preferred_vector_width_long); + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: + src_ptr = &device->preferred_vector_width_float; + src_size = sizeof(device->preferred_vector_width_float); + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: + src_ptr = &device->preferred_vector_width_double; + src_size = sizeof(device->preferred_vector_width_double); + break; + case CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF: + src_ptr = &device->preferred_vector_width_half; + src_size = sizeof(device->preferred_vector_width_half); + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR: + src_ptr = &device->native_vector_width_char; + src_size = sizeof(device->native_vector_width_char); + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT: + src_ptr = &device->native_vector_width_short; + src_size = sizeof(device->native_vector_width_short); + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT: + src_ptr = &device->native_vector_width_int; + src_size = sizeof(device->native_vector_width_int); + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: + src_ptr = &device->native_vector_width_long; + src_size = sizeof(device->native_vector_width_long); + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT: + src_ptr = &device->native_vector_width_float; + src_size = sizeof(device->native_vector_width_float); + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE: + src_ptr = &device->native_vector_width_double; + src_size = sizeof(device->native_vector_width_double); + break; + case CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF: + src_ptr = &device->native_vector_width_half; + src_size = sizeof(device->native_vector_width_half); + break; + case CL_DEVICE_MAX_CLOCK_FREQUENCY: + src_ptr = &device->max_clock_frequency; + src_size = sizeof(device->max_clock_frequency); + break; + case CL_DEVICE_ADDRESS_BITS: + src_ptr = &device->address_bits; + src_size = sizeof(device->address_bits); + break; + case CL_DEVICE_MAX_MEM_ALLOC_SIZE: + src_ptr = &device->max_mem_alloc_size; + src_size = sizeof(device->max_mem_alloc_size); + break; + case CL_DEVICE_IMAGE_SUPPORT: + src_ptr = &device->image_support; + src_size = sizeof(device->image_support); + break; + case CL_DEVICE_MAX_READ_IMAGE_ARGS: + src_ptr = &device->max_read_image_args; + src_size = sizeof(device->max_read_image_args); + break; + case CL_DEVICE_MAX_WRITE_IMAGE_ARGS: + src_ptr = &device->max_write_image_args; + src_size = sizeof(device->max_write_image_args); + break; + case CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS: + src_ptr = &device->max_read_write_image_args; + src_size = sizeof(device->max_read_write_image_args); + break; + case CL_DEVICE_IMAGE_MAX_ARRAY_SIZE: + src_ptr = &device->image_max_array_size; + src_size = sizeof(device->image_max_array_size); + break; + case CL_DEVICE_IMAGE2D_MAX_WIDTH: + case CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL: + src_ptr = &device->image2d_max_width; + src_size = sizeof(device->image2d_max_width); + break; + case CL_DEVICE_IMAGE2D_MAX_HEIGHT: + case CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL: + src_ptr = &device->image2d_max_height; + src_size = sizeof(device->image2d_max_height); + break; + case CL_DEVICE_IMAGE3D_MAX_WIDTH: + src_ptr = &device->image3d_max_width; + src_size = sizeof(device->image3d_max_width); + break; + case CL_DEVICE_IMAGE3D_MAX_HEIGHT: + src_ptr = &device->image3d_max_height; + src_size = sizeof(device->image3d_max_height); + break; + case CL_DEVICE_IMAGE3D_MAX_DEPTH: + src_ptr = &device->image3d_max_depth; + src_size = sizeof(device->image3d_max_depth); + break; + case CL_DEVICE_MAX_SAMPLERS: + src_ptr = &device->max_samplers; + src_size = sizeof(device->max_samplers); + break; + case CL_DEVICE_MAX_PARAMETER_SIZE: + src_ptr = &device->max_parameter_size; + src_size = sizeof(device->max_parameter_size); + break; + case CL_DEVICE_MEM_BASE_ADDR_ALIGN: + src_ptr = &device->mem_base_addr_align; + src_size = sizeof(device->mem_base_addr_align); + break; + case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: + src_ptr = &device->min_data_type_align_size; + src_size = sizeof(device->min_data_type_align_size); + break; + case CL_DEVICE_MAX_PIPE_ARGS: + src_ptr = &device->max_pipe_args; + src_size = sizeof(device->max_pipe_args); + break; + case CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS: + src_ptr = &device->pipe_max_active_reservations; + src_size = sizeof(device->pipe_max_active_reservations); + break; + case CL_DEVICE_PIPE_MAX_PACKET_SIZE: + src_ptr = &device->pipe_max_packet_siz; + src_size = sizeof(device->pipe_max_packet_siz); + break; + case CL_DEVICE_SINGLE_FP_CONFIG: + src_ptr = &device->single_fp_config; + src_size = sizeof(device->single_fp_config); + break; + case CL_DEVICE_HALF_FP_CONFIG: + src_ptr = &device->half_fp_config; + src_size = sizeof(device->half_fp_config); + break; + case CL_DEVICE_DOUBLE_FP_CONFIG: + src_ptr = &device->double_fp_config; + src_size = sizeof(device->double_fp_config); + break; + case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: + src_ptr = &device->global_mem_cache_type; + src_size = sizeof(device->global_mem_cache_type); + break; + case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: + src_ptr = &device->global_mem_cache_line_size; + src_size = sizeof(device->global_mem_cache_line_size); + break; + case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: + src_ptr = &device->global_mem_cache_size; + src_size = sizeof(device->global_mem_cache_size); + break; + case CL_DEVICE_GLOBAL_MEM_SIZE: + src_ptr = &device->global_mem_size; + src_size = sizeof(device->global_mem_size); + break; + case CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: + src_ptr = &device->max_constant_buffer_size; + src_size = sizeof(device->max_constant_buffer_size); + break; + case CL_DEVICE_IMAGE_MAX_BUFFER_SIZE: + src_ptr = &device->image_mem_size; + src_size = sizeof(device->image_mem_size); + break; + case CL_DEVICE_MAX_CONSTANT_ARGS: + src_ptr = &device->max_constant_args; + src_size = sizeof(device->max_constant_args); + break; + case CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE: + src_ptr = &device->max_global_variable_size; + src_size = sizeof(device->max_global_variable_size); + break; + case CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE: + src_ptr = &device->global_variable_preferred_total_size; + src_size = sizeof(device->global_variable_preferred_total_size); + break; + case CL_DEVICE_LOCAL_MEM_TYPE: + src_ptr = &device->local_mem_type; + src_size = sizeof(device->local_mem_type); + break; + case CL_DEVICE_LOCAL_MEM_SIZE: + src_ptr = &device->local_mem_size; + src_size = sizeof(device->local_mem_size); + break; + case CL_DEVICE_ERROR_CORRECTION_SUPPORT: + src_ptr = &device->error_correction_support; + src_size = sizeof(device->error_correction_support); + break; + case CL_DEVICE_HOST_UNIFIED_MEMORY: + src_ptr = &device->host_unified_memory; + src_size = sizeof(device->host_unified_memory); + break; + case CL_DEVICE_PROFILING_TIMER_RESOLUTION: + src_ptr = &device->profiling_timer_resolution; + src_size = sizeof(device->profiling_timer_resolution); + break; + case CL_DEVICE_ENDIAN_LITTLE: + src_ptr = &device->endian_little; + src_size = sizeof(device->endian_little); + break; + case CL_DEVICE_AVAILABLE: + src_ptr = &device->available; + src_size = sizeof(device->available); + break; + case CL_DEVICE_COMPILER_AVAILABLE: + src_ptr = &device->compiler_available; + src_size = sizeof(device->compiler_available); + break; + case CL_DEVICE_LINKER_AVAILABLE: + src_ptr = &device->linker_available; + src_size = sizeof(device->linker_available); + break; + case CL_DEVICE_EXECUTION_CAPABILITIES: + src_ptr = &device->execution_capabilities; + src_size = sizeof(device->execution_capabilities); + break; + case CL_DEVICE_QUEUE_PROPERTIES: + src_ptr = &device->queue_properties; + src_size = sizeof(device->queue_properties); + break; + case CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES: + src_ptr = &device->queue_on_device_properties; + src_size = sizeof(device->queue_on_device_properties); + break; + case CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE: + src_ptr = &device->queue_on_device_preferred_size; + src_size = sizeof(device->queue_on_device_preferred_size); + break; + case CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE: + src_ptr = &device->queue_on_device_max_size; + src_size = sizeof(device->queue_on_device_max_size); + break; + case CL_DEVICE_MAX_ON_DEVICE_QUEUES: + src_ptr = &device->max_on_device_queues; + src_size = sizeof(device->max_on_device_queues); + break; + case CL_DEVICE_MAX_ON_DEVICE_EVENTS: + src_ptr = &device->max_on_device_events; + src_size = sizeof(device->max_on_device_events); + break; + case CL_DEVICE_PLATFORM: + src_ptr = &device->platform; + src_size = sizeof(device->platform); + break; + case CL_DEVICE_PRINTF_BUFFER_SIZE: + src_ptr = &device->printf_buffer_size; + src_size = sizeof(device->printf_buffer_size); + break; + case CL_DEVICE_PREFERRED_INTEROP_USER_SYNC: + src_ptr = &device->interop_user_sync; + src_size = sizeof(device->interop_user_sync); + break; + case CL_DEVICE_NAME: + src_ptr = device->name; + src_size = device->name_sz; + break; + case CL_DEVICE_VENDOR: + src_ptr = device->vendor; + src_size = device->vendor_sz; + break; + case CL_DEVICE_VERSION: + src_ptr = device->version; + src_size = device->version_sz; + break; + case CL_DEVICE_PROFILE: + src_ptr = device->profile; + src_size = device->profile_sz; + break; + case CL_DEVICE_OPENCL_C_VERSION: + src_ptr = device->opencl_c_version; + src_size = device->opencl_c_version_sz; + break; + case CL_DEVICE_SPIR_VERSIONS: + src_ptr = device->spir_versions; + src_size = device->spir_versions_sz; + break; + case CL_DEVICE_EXTENSIONS: + src_ptr = device->extensions; + src_size = device->extensions_sz; + break; + case CL_DEVICE_BUILT_IN_KERNELS: + src_ptr = device->built_in_kernels; + if (src_ptr) + src_size = strlen(device->built_in_kernels) + 1; + else + src_size = 0; + break; + case CL_DEVICE_PARENT_DEVICE: + src_ptr = &device->parent_device; + src_size = sizeof(device->parent_device); + break; + case CL_DEVICE_PARTITION_MAX_SUB_DEVICES: + src_ptr = &device->partition_max_sub_device; + src_size = sizeof(device->partition_max_sub_device); + break; + case CL_DEVICE_PARTITION_PROPERTIES: + src_ptr = &device->partition_property; + src_size = sizeof(device->partition_property); + break; + case CL_DEVICE_PARTITION_AFFINITY_DOMAIN: + src_ptr = &device->affinity_domain; + src_size = sizeof(device->affinity_domain); + break; + case CL_DEVICE_PARTITION_TYPE: + src_ptr = &device->partition_type; + src_size = sizeof(device->partition_type); + break; + case CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT: + src_ptr = &device->preferred_platform_atomic_alignment; + src_size = sizeof(device->preferred_platform_atomic_alignment); + break; + case CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT: + src_ptr = &device->preferred_global_atomic_alignment; + src_size = sizeof(device->preferred_global_atomic_alignment); + break; + case CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT: + src_ptr = &device->preferred_local_atomic_alignment; + src_size = sizeof(device->preferred_local_atomic_alignment); + break; + case CL_DEVICE_IMAGE_PITCH_ALIGNMENT: + src_ptr = &device->image_pitch_alignment; + src_size = sizeof(device->image_pitch_alignment); + break; + case CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT: + src_ptr = &device->image_base_address_alignment; + src_size = sizeof(device->image_base_address_alignment); + break; + case CL_DEVICE_SVM_CAPABILITIES: + src_ptr = &device->svm_capabilities; + src_size = sizeof(device->svm_capabilities); + break; + case CL_DEVICE_REFERENCE_COUNT: { + dev_ref = CL_OBJECT_GET_REF(device); + src_ptr = &dev_ref; + src_size = sizeof(cl_int); + break; + } + case CL_DRIVER_VERSION: + src_ptr = device->driver_version; + src_size = device->driver_version_sz; + break; + + default: + return CL_INVALID_VALUE; + } + + return cl_get_info_helper(src_ptr, src_size, + param_value, param_value_size, param_value_size_ret); +} + +LOCAL cl_int +cl_devices_list_check(cl_uint num_devices, const cl_device_id *devices) +{ + cl_uint i; + + if (devices == NULL) + return CL_INVALID_DEVICE; + + assert(num_devices > 0); + for (i = 0; i < num_devices; i++) { + if (!CL_OBJECT_IS_DEVICE(devices[i])) { + return CL_INVALID_DEVICE; + } + + if (devices[i]->available == CL_FALSE) { + return CL_DEVICE_NOT_AVAILABLE; + } + + // We now just support one platform. + if (devices[i]->platform != cl_get_platform_default()) { + return CL_INVALID_DEVICE; + } + + // TODO: We now just support Gen Device. + if (devices[i] != cl_device_get_id_gen(devices[i]->platform)) { + return CL_INVALID_DEVICE; + } + } + + return CL_SUCCESS; +} + +LOCAL cl_int +cl_devices_list_include_check(cl_uint num_devices, const cl_device_id *devices, + cl_uint num_to_check, const cl_device_id *devices_to_check) +{ + cl_uint i, j; + + for (i = 0; i < num_to_check; i++) { + for (j = 0; j < num_devices; j++) { + if (devices_to_check[i] == devices[j]) + break; + } + + if (j == num_devices) + return CL_INVALID_DEVICE; + } + + return CL_SUCCESS; +} diff --git a/runtime/cl_device_id.h b/runtime/cl_device_id.h new file mode 100644 index 0000000..27d8edb --- /dev/null +++ b/runtime/cl_device_id.h @@ -0,0 +1,168 @@ +/* + * Copyright © 2012 Intel Corporation + * + * 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, see <http://www.gnu.org/licenses/>. + * + * Author: Benjamin Segovia <benjamin.sego...@intel.com> + */ + +#ifndef __CL_DEVICE_ID_H__ +#define __CL_DEVICE_ID_H__ + +#define EXTENSTION_LENGTH 512 + +#include "cl_base_object.h" +#include "cl_compiler.h" +#include "cl_device_api.h" + +/* Store complete information about the device */ +typedef struct _cl_device_id { + _cl_base_object base; + cl_device_type device_type; + cl_uint device_id; + cl_uint vendor_id; + cl_uint max_compute_unit; // maximum EU number + cl_uint max_thread_per_unit; // maximum EU threads per EU. + cl_uint sub_slice_count; // Device's sub slice count + cl_uint max_work_item_dimensions; // should be 3. + size_t max_work_item_sizes[3]; // equal to maximum work group size. + size_t max_work_group_size; // maximum work group size under simd16 mode. + size_t max_1d_global_work_sizes[3]; // maximum 1d global work size for builtin kernels. + size_t max_2d_global_work_sizes[3]; // maximum 2d global work size for builtin kernels. + size_t max_3d_global_work_sizes[3]; // maximum 3d global work size for builtin kernels. + cl_uint preferred_vector_width_char; + cl_uint preferred_vector_width_short; + cl_uint preferred_vector_width_int; + cl_uint preferred_vector_width_long; + cl_uint preferred_vector_width_float; + cl_uint preferred_vector_width_double; + cl_uint preferred_vector_width_half; + cl_uint native_vector_width_char; + cl_uint native_vector_width_short; + cl_uint native_vector_width_int; + cl_uint native_vector_width_long; + cl_uint native_vector_width_float; + cl_uint native_vector_width_double; + cl_uint native_vector_width_half; + cl_uint max_clock_frequency; + cl_uint address_bits; + size_t max_mem_alloc_size; + cl_device_svm_capabilities svm_capabilities; + cl_uint preferred_platform_atomic_alignment; + cl_uint preferred_global_atomic_alignment; + cl_uint preferred_local_atomic_alignment; + cl_bool image_support; + cl_uint max_read_image_args; + cl_uint max_write_image_args; + cl_uint max_read_write_image_args; + size_t image2d_max_width; + size_t image_max_array_size; + size_t image2d_max_height; + size_t image3d_max_width; + size_t image3d_max_height; + size_t image3d_max_depth; + size_t image_mem_size; + cl_uint max_samplers; + size_t max_parameter_size; + cl_uint mem_base_addr_align; + cl_uint min_data_type_align_size; + cl_uint max_pipe_args; + cl_uint pipe_max_active_reservations; + cl_uint pipe_max_packet_siz; + cl_device_fp_config single_fp_config; + cl_device_fp_config half_fp_config; + cl_device_fp_config double_fp_config; + cl_device_mem_cache_type global_mem_cache_type; + cl_uint global_mem_cache_line_size; + cl_ulong global_mem_cache_size; + cl_ulong global_mem_size; + cl_ulong max_constant_buffer_size; + cl_uint max_constant_args; + size_t max_global_variable_size; + size_t global_variable_preferred_total_size; + cl_device_local_mem_type local_mem_type; + cl_ulong local_mem_size; + cl_ulong scratch_mem_size; + cl_bool error_correction_support; + cl_bool host_unified_memory; + size_t profiling_timer_resolution; + cl_bool endian_little; + cl_bool available; + cl_bool compiler_available; + cl_bool linker_available; + cl_device_exec_capabilities execution_capabilities; + cl_command_queue_properties queue_properties; + cl_command_queue_properties queue_on_host_properties; + cl_command_queue_properties queue_on_device_properties; + cl_uint queue_on_device_preferred_size; + cl_uint queue_on_device_max_size; + cl_uint max_on_device_queues; + cl_uint max_on_device_events; + cl_platform_id platform; + size_t printf_buffer_size; + cl_bool interop_user_sync; + const char *name; + const char *vendor; + const char *version; + const char *profile; + const char *opencl_c_version; + const char extensions[EXTENSTION_LENGTH]; + const char *driver_version; + const char *spir_versions; + size_t name_sz; + size_t vendor_sz; + size_t version_sz; + size_t profile_sz; + size_t opencl_c_version_sz; + size_t extensions_sz; + size_t driver_version_sz; + size_t spir_versions_sz; + size_t built_in_kernels_sz; + /* SubDevice specific info */ + cl_device_id parent_device; + cl_uint partition_max_sub_device; + cl_device_partition_property partition_property[3]; + cl_device_affinity_domain affinity_domain; + cl_device_partition_property partition_type[3]; + uint32_t atomic_test_result; + cl_uint image_pitch_alignment; + cl_uint image_base_address_alignment; + + _cl_device_api api; + _cl_compiler compiler; + const char *built_in_kernels; + const char *built_in_kernels_binary; + size_t built_in_kernels_binary_sz; +} _cl_device_id; + +#define CL_OBJECT_DEVICE_MAGIC 0x2acaddcca8853c52LL +#define CL_OBJECT_IS_DEVICE(obj) ((obj && \ + ((cl_base_object)obj)->magic == CL_OBJECT_DEVICE_MAGIC && \ + CL_OBJECT_GET_REF(obj) >= 1)) + +/* Get the intel GPU device we currently have in this machine (if any) */ +extern cl_device_id cl_device_get_id_gen(cl_platform_id platform); +extern cl_int cl_device_get_version_gen(cl_device_id device, cl_int *ver); +extern void cl_device_gen_cleanup(void); +/* Get a device from the given platform */ +extern cl_int cl_device_get_ids(cl_platform_id platform, cl_device_type device_type, + cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices); +/* Provide info about the device */ +extern cl_int cl_device_get_info(cl_device_id device, cl_device_info param_name, size_t param_value_size, + void *param_value, size_t *param_value_size_ret); +/* Returns the Gen device ID */ +extern cl_int cl_devices_list_check(cl_uint num_devices, const cl_device_id *devices); +extern cl_int cl_devices_list_include_check(cl_uint num_devices, const cl_device_id *devices, + cl_uint num_to_check, const cl_device_id *devices_to_check); +#endif /* __CL_DEVICE_ID_H__ */ -- 2.7.4 _______________________________________________ Beignet mailing list Beignet@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/beignet