From af6b5d6be3ce24329f082c12cb3dc5bb3b8ebb1d Mon Sep 17 00:00:00 2001 From: rbegam Date: Tue, 11 Feb 2020 16:46:13 -0800 Subject: [PATCH] [SYCL] Replaces some of the CL_* enums with PI_* enums. Signed-off-by: rbegam --- sycl/include/CL/sycl/detail/event_info.hpp | 2 +- sycl/include/CL/sycl/detail/kernel_info.hpp | 10 +- sycl/include/CL/sycl/detail/pi.h | 235 ++++++++++++++++-- sycl/include/CL/sycl/detail/queue_impl.hpp | 2 +- sycl/include/CL/sycl/queue.hpp | 2 +- .../detail/error_handling/enqueue_kernel.cpp | 2 +- sycl/source/detail/event_impl.cpp | 2 +- sycl/source/detail/kernel_impl.cpp | 2 +- sycl/source/detail/program_impl.cpp | 20 +- .../program_manager/program_manager.cpp | 12 +- sycl/source/detail/queue_impl.cpp | 2 +- sycl/source/detail/scheduler/commands.cpp | 4 +- sycl/source/queue.cpp | 2 +- sycl/test/usm/memadvise.cpp | 4 +- 14 files changed, 248 insertions(+), 53 deletions(-) diff --git a/sycl/include/CL/sycl/detail/event_info.hpp b/sycl/include/CL/sycl/detail/event_info.hpp index 3863f9ab7f277..1db9edb142984 100644 --- a/sycl/include/CL/sycl/detail/event_info.hpp +++ b/sycl/include/CL/sycl/detail/event_info.hpp @@ -36,7 +36,7 @@ template struct get_event_info { static RetType get(RT::PiEvent Event, const plugin &Plugin) { RetType Result = (RetType)0; // TODO catch an exception and put it to list of asynchronous exceptions - Plugin.call(Event, cl_profiling_info(Param), + Plugin.call(Event, pi_event_info(Param), sizeof(Result), &Result, nullptr); return Result; } diff --git a/sycl/include/CL/sycl/detail/kernel_info.hpp b/sycl/include/CL/sycl/detail/kernel_info.hpp index 3ce376b461a79..ae714f5e34cdc 100644 --- a/sycl/include/CL/sycl/detail/kernel_info.hpp +++ b/sycl/include/CL/sycl/detail/kernel_info.hpp @@ -26,14 +26,14 @@ template struct get_kernel_info { size_t ResultSize; // TODO catch an exception and put it to list of asynchronous exceptions - Plugin.call(Kernel, cl_kernel_info(Param), 0, + Plugin.call(Kernel, pi_kernel_info(Param), 0, nullptr, &ResultSize); if (ResultSize == 0) { return ""; } vector_class Result(ResultSize); // TODO catch an exception and put it to list of asynchronous exceptions - Plugin.call(Kernel, cl_kernel_info(Param), + Plugin.call(Kernel, pi_kernel_info(Param), ResultSize, Result.data(), nullptr); return string_class(Result.data()); } @@ -41,11 +41,11 @@ template struct get_kernel_info { template struct get_kernel_info { static cl_uint get(RT::PiKernel Kernel, const plugin &Plugin) { - cl_uint Result; + pi_uint32 Result; // TODO catch an exception and put it to list of asynchronous exceptions - Plugin.call(Kernel, cl_kernel_info(Param), - sizeof(cl_uint), &Result, nullptr); + Plugin.call(Kernel, pi_kernel_info(Param), + sizeof(pi_uint32), &Result, nullptr); return Result; } }; diff --git a/sycl/include/CL/sycl/detail/pi.h b/sycl/include/CL/sycl/detail/pi.h index d5797c5b81ebc..4e53883a414fb 100644 --- a/sycl/include/CL/sycl/detail/pi.h +++ b/sycl/include/CL/sycl/detail/pi.h @@ -84,28 +84,122 @@ typedef enum : pi_uint64 { PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR } _pi_device_type; -// TODO: populate and sync with cl::sycl::info::device typedef enum { - PI_DEVICE_INFO_TYPE = CL_DEVICE_TYPE, - PI_DEVICE_INFO_PARENT = CL_DEVICE_PARENT_DEVICE, - PI_DEVICE_INFO_PLATFORM = CL_DEVICE_PLATFORM, - PI_DEVICE_INFO_PARTITION_TYPE = CL_DEVICE_PARTITION_TYPE, - PI_DEVICE_INFO_NAME = CL_DEVICE_NAME, - PI_DEVICE_INFO_VERSION = CL_DEVICE_VERSION, - PI_DEVICE_INFO_MAX_WORK_GROUP_SIZE = CL_DEVICE_MAX_WORK_GROUP_SIZE, - PI_DEVICE_INFO_EXTENSIONS = CL_DEVICE_EXTENSIONS + PI_DEVICE_MEM_CACHE_TYPE_NONE = CL_NONE, + PI_DEVICE_MEM_CACHE_TYPE_READ_ONLY_CACHE = CL_READ_ONLY_CACHE, + PI_DEVICE_MEM_CACHE_TYPE_READ_WRITE_CACHE = CL_READ_WRITE_CACHE +} _pi_device_mem_cache_type; + +typedef enum { + PI_DEVICE_LOCAL_MEM_TYPE_LOCAL = CL_LOCAL, + PI_DEVICE_LOCAL_MEM_TYPE_GLOBAL = CL_GLOBAL +} _pi_device_local_mem_type; + +typedef enum { + PI_DEVICE_INFO_TYPE = CL_DEVICE_TYPE, + PI_DEVICE_INFO_PARENT = CL_DEVICE_PARENT_DEVICE, + PI_DEVICE_INFO_PLATFORM = CL_DEVICE_PLATFORM, + PI_DEVICE_INFO_VENDOR_ID = CL_DEVICE_VENDOR_ID, + PI_DEVICE_INFO_VENDOR = CL_DEVICE_VENDOR, + PI_DEVICE_INFO_DRIVER_VERSION = CL_DRIVER_VERSION, + PI_DEVICE_INFO_PROFILE = CL_DEVICE_PROFILE, + PI_DEVICE_INFO_VERSION = CL_DEVICE_VERSION, + PI_DEVICE_INFO_OPENCL_C_VERSION = CL_DEVICE_OPENCL_C_VERSION, + PI_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC = CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, + PI_DEVICE_INFO_PRINTF_BUFFER_SIZE = CL_DEVICE_PRINTF_BUFFER_SIZE, + PI_DEVICE_INFO_PARTITION_PROPERTIES = CL_DEVICE_PARTITION_PROPERTIES, + PI_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES = CL_DEVICE_PARTITION_MAX_SUB_DEVICES, + PI_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN = CL_DEVICE_PARTITION_AFFINITY_DOMAIN, + PI_DEVICE_INFO_PARTITION_TYPE = CL_DEVICE_PARTITION_TYPE, + PI_DEVICE_INFO_REFERENCE_COUNT = CL_DEVICE_REFERENCE_COUNT, + PI_DEVICE_INFO_EXTENSIONS = CL_DEVICE_EXTENSIONS, + PI_DEVICE_INFO_COMPILER_AVAILABLE = CL_DEVICE_COMPILER_AVAILABLE, + PI_DEVICE_INFO_LINKER_AVAILABLE = CL_DEVICE_LINKER_AVAILABLE, + PI_DEVICE_INFO_MAX_COMPUTE_UNITS = CL_DEVICE_MAX_COMPUTE_UNITS, + PI_DEVICE_INFO_NAME = CL_DEVICE_NAME, + PI_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS = CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, + PI_DEVICE_INFO_MAX_WORK_GROUP_SIZE = CL_DEVICE_MAX_WORK_GROUP_SIZE, + PI_DEVICE_INFO_MAX_WORK_ITEM_SIZES = CL_DEVICE_MAX_WORK_ITEM_SIZES, + PI_DEVICE_INFO_SINGLE_FP_CONFIG = CL_DEVICE_SINGLE_FP_CONFIG, + PI_DEVICE_INFO_HALF_FP_CONFIG = CL_DEVICE_HALF_FP_CONFIG, + PI_DEVICE_INFO_DOUBLE_FP_CONFIG = CL_DEVICE_DOUBLE_FP_CONFIG, + PI_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE = CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, + PI_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE = CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, + PI_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE = CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, + PI_DEVICE_INFO_GLOBAL_MEM_SIZE = CL_DEVICE_GLOBAL_MEM_SIZE, + PI_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE = CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, + PI_DEVICE_INFO_MAX_CONSTANT_ARGS = CL_DEVICE_MAX_CONSTANT_ARGS, + PI_DEVICE_INFO_LOCAL_MEM_TYPE = CL_DEVICE_LOCAL_MEM_TYPE, + PI_DEVICE_INFO_LOCAL_MEM_SIZE = CL_DEVICE_LOCAL_MEM_SIZE, + PI_DEVICE_INFO_ERROR_CORRECTION_SUPPORT = CL_DEVICE_ERROR_CORRECTION_SUPPORT, + PI_DEVICE_INFO_PROFILING_TIMER_RESOLUTION = CL_DEVICE_PROFILING_TIMER_RESOLUTION, + PI_DEVICE_INFO_HOST_UNIFIED_MEMORY = CL_DEVICE_HOST_UNIFIED_MEMORY, + PI_DEVICE_INFO_BUILT_IN_KERNELS = CL_DEVICE_BUILT_IN_KERNELS, + PI_DEVICE_INFO_ENDIAN_LITTLE = CL_DEVICE_ENDIAN_LITTLE, + PI_DEVICE_INFO_AVAILABLE = CL_DEVICE_AVAILABLE, + PI_DEVICE_INFO_EXECUTION_CAPABILITIES = CL_DEVICE_EXECUTION_CAPABILITIES, + PI_DEVICE_INFO_QUEUE_PROPERTIES = CL_DEVICE_QUEUE_PROPERTIES, + PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR = CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, + PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT = CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, + PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT = CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, + PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG = CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, + PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT = CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, + PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE = CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, + PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF = CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, + PI_DEVICE_INFO_MAX_CLOCK_FREQUENCY = CL_DEVICE_MAX_CLOCK_FREQUENCY, + PI_DEVICE_INFO_ADDRESS_BITS = CL_DEVICE_ADDRESS_BITS, + PI_DEVICE_INFO_MAX_READ_IMAGE_ARGS = CL_DEVICE_MAX_READ_IMAGE_ARGS, + PI_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS = CL_DEVICE_MAX_WRITE_IMAGE_ARGS, + PI_DEVICE_INFO_IMAGE2D_MAX_WIDTH = CL_DEVICE_IMAGE2D_MAX_WIDTH, + PI_DEVICE_INFO_IMAGE2D_MAX_HEIGHT = CL_DEVICE_IMAGE2D_MAX_HEIGHT, + PI_DEVICE_INFO_IMAGE3D_MAX_WIDTH = CL_DEVICE_IMAGE3D_MAX_WIDTH, + PI_DEVICE_INFO_IMAGE3D_MAX_HEIGHT = CL_DEVICE_IMAGE3D_MAX_HEIGHT, + PI_DEVICE_INFO_IMAGE3D_MAX_DEPTH = CL_DEVICE_IMAGE3D_MAX_DEPTH, + PI_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE = CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, + PI_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE = CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, + PI_DEVICE_INFO_MAX_MEM_ALLOC_SIZE = CL_DEVICE_MAX_MEM_ALLOC_SIZE, + PI_DEVICE_INFO_IMAGE_SUPPORT = CL_DEVICE_IMAGE_SUPPORT, + PI_DEVICE_INFO_MAX_PARAMETER_SIZE = CL_DEVICE_MAX_PARAMETER_SIZE, + PI_DEVICE_INFO_MAX_SAMPLERS = CL_DEVICE_MAX_SAMPLERS, + PI_DEVICE_INFO_MEM_BASE_ADDR_ALIGN = CL_DEVICE_MEM_BASE_ADDR_ALIGN, + PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR = CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, + PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT = CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, + PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT = CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, + PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG = CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, + PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT = CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, + PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE = CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, + PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF = CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, + PI_DEVICE_INFO_USM_HOST_SUPPORT = CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL, + PI_DEVICE_INFO_USM_DEVICE_SUPPORT = CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL, + PI_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT = CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, + PI_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT = CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, + PI_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT = CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL } _pi_device_info; -// TODO: populate typedef enum { - PI_CONTEXT_INFO_DEVICES = CL_CONTEXT_DEVICES, - PI_CONTEXT_INFO_NUM_DEVICES = CL_CONTEXT_NUM_DEVICES + PI_PROGRAM_INFO_REFERENCE_COUNT = CL_PROGRAM_REFERENCE_COUNT, + PI_PROGRAM_INFO_NUM_DEVICES = CL_PROGRAM_NUM_DEVICES, + PI_PROGRAM_INFO_DEVICES = CL_PROGRAM_DEVICES, + PI_PROGRAM_INFO_BINARY_SIZES = CL_PROGRAM_BINARY_SIZES, + PI_PROGRAM_INFO_BINARIES = CL_PROGRAM_BINARIES, + PI_PROGRAM_INFO_NUM_KERNELS = CL_PROGRAM_NUM_KERNELS, + PI_PROGRAM_INFO_KERNEL_NAMES = CL_PROGRAM_KERNEL_NAMES +} _pi_program_info; + +typedef enum { + PI_CONTEXT_INFO_DEVICES = CL_CONTEXT_DEVICES, + PI_CONTEXT_INFO_NUM_DEVICES = CL_CONTEXT_NUM_DEVICES, + PI_CONTEXT_INFO_PROPERTIES = CL_CONTEXT_PROPERTIES, + PI_CONTEXT_INFO_REFERENCE_COUNT = CL_CONTEXT_REFERENCE_COUNT, } _pi_context_info; -// TODO: populate typedef enum { + PI_QUEUE_INFO_CONTEXT = CL_QUEUE_CONTEXT, PI_QUEUE_INFO_DEVICE = CL_QUEUE_DEVICE, - PI_QUEUE_INFO_REFERENCE_COUNT = CL_QUEUE_REFERENCE_COUNT + PI_QUEUE_INFO_DEVICE_DEFAULT = CL_QUEUE_DEVICE_DEFAULT, + PI_QUEUE_INFO_PROPERTIES = CL_QUEUE_PROPERTIES, + PI_QUEUE_INFO_REFERENCE_COUNT = CL_QUEUE_REFERENCE_COUNT, + PI_QUEUE_INFO_SIZE = CL_QUEUE_SIZE } _pi_queue_info; typedef enum { @@ -118,6 +212,64 @@ typedef enum { PI_IMAGE_INFO_DEPTH = CL_IMAGE_DEPTH } _pi_image_info; +typedef enum { + PI_KERNEL_INFO_FUNCTION_NAME = CL_KERNEL_FUNCTION_NAME, + PI_KERNEL_INFO_NUM_ARGS = CL_KERNEL_NUM_ARGS, + PI_KERNEL_INFO_REFERENCE_COUNT = CL_KERNEL_REFERENCE_COUNT, + PI_KERNEL_INFO_CONTEXT = CL_KERNEL_CONTEXT, + PI_KERNEL_INFO_PROGRAM = CL_KERNEL_PROGRAM, + PI_KERNEL_INFO_ATTRIBUTES = CL_KERNEL_ATTRIBUTES +} _pi_kernel_info; + +typedef enum { + PI_KERNEL_GLOBAL_WORK_SIZE = CL_KERNEL_GLOBAL_WORK_SIZE, + PI_KERNEL_WORK_GROUP_SIZE = CL_KERNEL_WORK_GROUP_SIZE, + PI_KERNEL_COMPILE_WORK_GROUP_SIZE = CL_KERNEL_COMPILE_WORK_GROUP_SIZE, + PI_KERNEL_LOCAL_MEM_SIZE = CL_KERNEL_LOCAL_MEM_SIZE, + PI_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE = CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + PI_KERNEL_PRIVATE_MEM_SIZE = CL_KERNEL_PRIVATE_MEM_SIZE +} _pi_kernel_group_info; + +typedef enum { + PI_EVENT_INFO_COMMAND_QUEUE = CL_EVENT_COMMAND_QUEUE, + PI_EVENT_INFO_CONTEXT = CL_EVENT_CONTEXT, + PI_EVENT_INFO_COMMAND_TYPE = CL_EVENT_COMMAND_TYPE, + PI_EVENT_INFO_COMMAND_EXECUTION_STATUS = CL_EVENT_COMMAND_EXECUTION_STATUS, + PI_EVENT_INFO_REFERENCE_COUNT = CL_EVENT_REFERENCE_COUNT +} _pi_event_info; + +typedef enum { + PI_COMMAND_TYPE_NDRANGE_KERNEL = CL_COMMAND_NDRANGE_KERNEL, + PI_COMMAND_TYPE_MEM_BUFFER_READ = CL_COMMAND_READ_BUFFER, + PI_COMMAND_TYPE_MEM_BUFFER_WRITE = CL_COMMAND_WRITE_BUFFER, + PI_COMMAND_TYPE_MEM_BUFFER_COPY = CL_COMMAND_COPY_BUFFER, + PI_COMMAND_TYPE_MEM_BUFFER_MAP = CL_COMMAND_MAP_BUFFER, + PI_COMMAND_TYPE_MEM_BUFFER_UNMAP = CL_COMMAND_UNMAP_MEM_OBJECT, + PI_COMMAND_TYPE_MEM_BUFFER_READ_RECT = CL_COMMAND_READ_BUFFER_RECT, + PI_COMMAND_TYPE_MEM_BUFFER_WRITE_RECT = CL_COMMAND_WRITE_BUFFER_RECT, + PI_COMMAND_TYPE_MEM_BUFFER_COPY_RECT = CL_COMMAND_COPY_BUFFER_RECT, + PI_COMMAND_TYPE_USER = CL_COMMAND_USER, + PI_COMMAND_TYPE_MEM_BUFFER_FILL = CL_COMMAND_FILL_BUFFER, + PI_COMMAND_TYPE_IMAGE_READ = CL_COMMAND_READ_IMAGE, + PI_COMMAND_TYPE_IMAGE_WRITE = CL_COMMAND_WRITE_IMAGE, + PI_COMMAND_TYPE_IMAGE_COPY = CL_COMMAND_COPY_IMAGE, + PI_COMMAND_TYPE_NATIVE_KERNEL = CL_COMMAND_NATIVE_KERNEL, + PI_COMMAND_TYPE_COPY_BUFFER_TO_IMAGE = CL_COMMAND_COPY_BUFFER_TO_IMAGE, + PI_COMMAND_TYPE_COPY_IMAGE_TO_BUFFER = CL_COMMAND_COPY_IMAGE_TO_BUFFER, + PI_COMMAND_TYPE_MAP_IMAGE = CL_COMMAND_MAP_IMAGE, + PI_COMMAND_TYPE_MARKER = CL_COMMAND_MARKER, + PI_COMMAND_TYPE_ACQUIRE_GL_OBJECTS = CL_COMMAND_ACQUIRE_GL_OBJECTS, + PI_COMMAND_TYPE_RELEASE_GL_OBJECTS = CL_COMMAND_RELEASE_GL_OBJECTS, + PI_COMMAND_TYPE_BARRIER = CL_COMMAND_BARRIER, + PI_COMMAND_TYPE_MIGRATE_MEM_OBJECTS = CL_COMMAND_MIGRATE_MEM_OBJECTS, + PI_COMMAND_TYPE_FILL_IMAGE = CL_COMMAND_FILL_IMAGE, + PI_COMMAND_TYPE_SVM_FREE = CL_COMMAND_SVM_FREE, + PI_COMMAND_TYPE_SVM_MEMCPY = CL_COMMAND_SVM_MEMCPY, + PI_COMMAND_TYPE_SVM_MEMFILL = CL_COMMAND_SVM_MEMFILL, + PI_COMMAND_TYPE_SVM_MAP = CL_COMMAND_SVM_MAP, + PI_COMMAND_TYPE_SVM_UNMAP = CL_COMMAND_SVM_UNMAP +} _pi_command_type; + typedef enum { PI_MEM_TYPE_BUFFER = CL_MEM_OBJECT_BUFFER, PI_MEM_TYPE_IMAGE2D = CL_MEM_OBJECT_IMAGE2D, @@ -128,6 +280,19 @@ typedef enum { PI_MEM_TYPE_IMAGE1D_BUFFER = CL_MEM_OBJECT_IMAGE1D_BUFFER } _pi_mem_type; +typedef enum { + PI_MEM_ADVICE_SET_READ_MOSTLY = 0, // hints that memory will be read from frequently and written to rarely + PI_MEM_ADVICE_CLEAR_READ_MOSTLY, // removes the affect of PI_MEM_ADVICE_SET_READ_MOSTLY + PI_MEM_ADVICE_SET_PREFERRED_LOCATION, // hints that the preferred memory location is the specified device + PI_MEM_ADVICE_CLEAR_PREFERRED_LOCATION, // removes the affect of PI_MEM_ADVICE_SET_PREFERRED_LOCATION + PI_MEM_ADVICE_SET_ACCESSED_BY, // hints that memory will be accessed by the specified device + PI_MEM_ADVICE_CLEAR_ACCESSED_BY, // removes the affect of PI_MEM_ADVICE_SET_ACCESSED_BY + PI_MEM_ADVICE_SET_NON_ATOMIC_MOSTLY, // hints that memory will mostly be accessed non-atomically + PI_MEM_ADVICE_CLEAR_NON_ATOMIC_MOSTLY, // removes the affect of PI_MEM_ADVICE_SET_NON_ATOMIC_MOSTLY + PI_MEM_ADVICE_BIAS_CACHED, // hints that memory should be cached + PI_MEM_ADVICE_BIAS_UNCACHED // hints that memory should not be cached +} _pi_mem_advice; + typedef enum { PI_IMAGE_CHANNEL_ORDER_A = CL_A, PI_IMAGE_CHANNEL_ORDER_R = CL_R, @@ -167,7 +332,6 @@ typedef enum { PI_BUFFER_CREATE_TYPE_REGION = CL_BUFFER_CREATE_TYPE_REGION } _pi_buffer_create_type; -typedef pi_bitfield pi_sampler_properties; const pi_bool PI_TRUE = CL_TRUE; const pi_bool PI_FALSE = CL_FALSE; @@ -195,6 +359,15 @@ typedef enum { PI_SAMPLER_FILTER_MODE_LINEAR = CL_FILTER_LINEAR, } _pi_sampler_filter_mode; +typedef pi_bitfield pi_device_exec_capabilities; +const pi_device_exec_capabilities PI_DEVICE_EXEC_CAPABILITIES_KERNEL = CL_EXEC_KERNEL; +const pi_device_exec_capabilities PI_DEVICE_EXEC_CAPABILITIES_NATIVE_KERNEL = CL_EXEC_NATIVE_KERNEL; + +typedef pi_bitfield pi_sampler_properties; +const pi_sampler_properties PI_SAMPLER_PROPERTIES_NORMALIZED_COORDS = CL_SAMPLER_NORMALIZED_COORDS; +const pi_sampler_properties PI_SAMPLER_PROPERTIES_ADDRESSING_MODE = CL_SAMPLER_ADDRESSING_MODE; +const pi_sampler_properties PI_SAMPLER_PROPERTIES_FILTER_MODE = CL_SAMPLER_FILTER_MODE; + // NOTE: this is made 64-bit to match the size of cl_mem_flags to // make the translation to OpenCL transparent. // TODO: populate @@ -219,11 +392,19 @@ const pi_queue_properties PI_QUEUE_ON_DEVICE_DEFAULT = typedef _pi_result pi_result; typedef _pi_platform_info pi_platform_info; typedef _pi_device_type pi_device_type; +typedef _pi_device_mem_cache_type pi_device_mem_cache_type; +typedef _pi_device_local_mem_type pi_device_local_mem_type; typedef _pi_device_info pi_device_info; +typedef _pi_program_info pi_program_info; typedef _pi_context_info pi_context_info; typedef _pi_queue_info pi_queue_info; typedef _pi_image_info pi_image_info; +typedef _pi_kernel_info pi_kernel_info; +typedef _pi_kernel_group_info pi_kernel_group_info; +typedef _pi_event_info pi_event_info; +typedef _pi_command_type pi_command_type; typedef _pi_mem_type pi_mem_type; +typedef _pi_mem_advice pi_mem_advice; typedef _pi_image_channel_order pi_image_channel_order; typedef _pi_image_channel_type pi_image_channel_type; typedef _pi_buffer_create_type pi_buffer_create_type; @@ -231,6 +412,20 @@ typedef _pi_sampler_addressing_mode pi_sampler_addressing_mode; typedef _pi_sampler_filter_mode pi_sampler_filter_mode; typedef _pi_sampler_info pi_sampler_info; +// For compatibility with OpenCL define this not as enum. +typedef intptr_t pi_device_partition_property; +static const pi_device_partition_property + PI_DEVICE_PARTITION_EQUALLY = CL_DEVICE_PARTITION_EQUALLY; +static const pi_device_partition_property + PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN = CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN; + +// For compatibility with OpenCL define this not as enum. +typedef pi_bitfield pi_device_affinity_domain; +static const pi_device_affinity_domain + PI_DEVICE_AFFINITY_DOMAIN_NUMA = CL_DEVICE_AFFINITY_DOMAIN_NUMA; +static const pi_device_affinity_domain + PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE = CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE; + // Entry type, matches OpenMP for compatibility struct _pi_offload_entry_struct { void *addr; @@ -445,7 +640,7 @@ pi_result piDeviceRelease(pi_device device); pi_result piDevicePartition( pi_device device, - const cl_device_partition_property * properties, // TODO: untie from OpenCL + const pi_device_partition_property * properties, pi_uint32 num_devices, pi_device * out_devices, pi_uint32 * out_num_devices); @@ -592,7 +787,7 @@ pi_result piclProgramCreateWithBinary( pi_result piProgramGetInfo( pi_program program, - cl_program_info param_name, // TODO: untie from OpenCL + pi_program_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret); @@ -666,7 +861,7 @@ pi_result piKernelSetArg( pi_result piKernelGetInfo( pi_kernel kernel, - cl_kernel_info param_name, // TODO: change to pi_kernel_info + pi_kernel_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret); @@ -729,7 +924,7 @@ pi_result piEventCreate( pi_result piEventGetInfo( pi_event event, - cl_event_info param_name, // TODO: untie from OpenCL + pi_event_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret); @@ -1142,7 +1337,7 @@ pi_result piextUSMEnqueueMemAdvise( pi_queue queue, const void * ptr, size_t length, - int advice, + pi_mem_advice advice, pi_event * event); /// API to query information about USM allocated pointers diff --git a/sycl/include/CL/sycl/detail/queue_impl.hpp b/sycl/include/CL/sycl/detail/queue_impl.hpp index a6040a41e5267..9c04bcd52c980 100644 --- a/sycl/include/CL/sycl/detail/queue_impl.hpp +++ b/sycl/include/CL/sycl/detail/queue_impl.hpp @@ -328,7 +328,7 @@ class queue_impl { /// @param Ptr is a USM pointer to the allocation. /// @param Length is a number of bytes in the allocation. /// @param Advice is a device-defined advice for the specified allocation. - event mem_advise(const void *Ptr, size_t Length, int Advice); + event mem_advise(const void *Ptr, size_t Length, pi_mem_advice Advice); /// Puts exception to the list of asynchronous ecxeptions. /// diff --git a/sycl/include/CL/sycl/queue.hpp b/sycl/include/CL/sycl/queue.hpp index 4233e6474d05f..8d5e9fe691678 100644 --- a/sycl/include/CL/sycl/queue.hpp +++ b/sycl/include/CL/sycl/queue.hpp @@ -218,7 +218,7 @@ class queue { /// @param Length is a number of bytes in the allocation. /// @param Advice is a device-defined advice for the specified allocation. /// @return an event representing advice operation. - event mem_advise(const void *Ptr, size_t Length, int Advice); + event mem_advise(const void *Ptr, size_t Length, pi_mem_advice Advice); /// Provides hints to the runtime library that data should be made available /// on a device earlier than Unified Shared Memory would normally require it diff --git a/sycl/source/detail/error_handling/enqueue_kernel.cpp b/sycl/source/detail/error_handling/enqueue_kernel.cpp index eda04af33c10b..e7c8cf620cc99 100644 --- a/sycl/source/detail/error_handling/enqueue_kernel.cpp +++ b/sycl/source/detail/error_handling/enqueue_kernel.cpp @@ -133,7 +133,7 @@ bool handleInvalidWorkGroupSize(const device_impl &DeviceImpl, pi_kernel Kernel, pi_program Program = nullptr; Plugin.call( - Kernel, CL_KERNEL_PROGRAM, sizeof(pi_program), &Program, nullptr); + Kernel, PI_KERNEL_INFO_PROGRAM, sizeof(pi_program), &Program, nullptr); size_t OptsSize = 0; Plugin.call( Program, Device, CL_PROGRAM_BUILD_OPTIONS, 0, nullptr, &OptsSize); diff --git a/sycl/source/detail/event_impl.cpp b/sycl/source/detail/event_impl.cpp index 6bd4f49f2ffdb..6746312dcc0b4 100644 --- a/sycl/source/detail/event_impl.cpp +++ b/sycl/source/detail/event_impl.cpp @@ -72,7 +72,7 @@ event_impl::event_impl(RT::PiEvent Event, const context &SyclContext) RT::PiContext TempContext; getPlugin().call( - MEvent, CL_EVENT_CONTEXT, sizeof(RT::PiContext), &TempContext, nullptr); + MEvent, PI_EVENT_INFO_CONTEXT, sizeof(RT::PiContext), &TempContext, nullptr); if (MContext->getHandleRef() != TempContext) { throw cl::sycl::invalid_parameter_error( "The syclContext must match the OpenCL context associated with the " diff --git a/sycl/source/detail/kernel_impl.cpp b/sycl/source/detail/kernel_impl.cpp index 5e1f3e9a8fb81..4ea25ae8deefc 100644 --- a/sycl/source/detail/kernel_impl.cpp +++ b/sycl/source/detail/kernel_impl.cpp @@ -34,7 +34,7 @@ kernel_impl::kernel_impl(RT::PiKernel Kernel, ContextImplPtr ContextImpl, RT::PiContext Context = nullptr; // Using the plugin from the passed ContextImpl getPlugin().call( - MKernel, CL_KERNEL_CONTEXT, sizeof(Context), &Context, nullptr); + MKernel, PI_KERNEL_INFO_CONTEXT, sizeof(Context), &Context, nullptr); if (ContextImpl->getHandleRef() != Context) throw cl::sycl::invalid_parameter_error( "Input context must be the same as the context of cl_kernel"); diff --git a/sycl/source/detail/program_impl.cpp b/sycl/source/detail/program_impl.cpp index abb5f1dca04dd..9546fe112a430 100644 --- a/sycl/source/detail/program_impl.cpp +++ b/sycl/source/detail/program_impl.cpp @@ -81,12 +81,12 @@ program_impl::program_impl(ContextImplPtr Context, RT::PiProgram Program) : MProgram(Program), MContext(Context), MLinkable(true) { // TODO handle the case when cl_program build is in progress - cl_uint NumDevices; + pi_uint32 NumDevices; const detail::plugin &Plugin = getPlugin(); Plugin.call( - Program, CL_PROGRAM_NUM_DEVICES, sizeof(cl_uint), &NumDevices, nullptr); + Program, PI_PROGRAM_INFO_NUM_DEVICES, sizeof(pi_uint32), &NumDevices, nullptr); vector_class PiDevices(NumDevices); - Plugin.call(Program, CL_PROGRAM_DEVICES, + Plugin.call(Program, PI_PROGRAM_INFO_DEVICES, sizeof(RT::PiDevice) * NumDevices, PiDevices.data(), nullptr); vector_class SyclContextDevices = @@ -262,7 +262,7 @@ vector_class> program_impl::get_binaries() const { if (!is_host()) { vector_class BinarySizes(MDevices.size()); Plugin.call( - MProgram, CL_PROGRAM_BINARY_SIZES, sizeof(size_t) * BinarySizes.size(), + MProgram, PI_PROGRAM_INFO_BINARY_SIZES, sizeof(size_t) * BinarySizes.size(), BinarySizes.data(), nullptr); vector_class Pointers; @@ -270,7 +270,7 @@ vector_class> program_impl::get_binaries() const { Result.emplace_back(BinarySizes[I]); Pointers.push_back(Result[I].data()); } - Plugin.call(MProgram, CL_PROGRAM_BINARIES, + Plugin.call(MProgram, PI_PROGRAM_INFO_BINARIES, sizeof(char *) * Pointers.size(), Pointers.data(), nullptr); } @@ -330,10 +330,10 @@ vector_class program_impl::get_pi_devices() const { bool program_impl::has_cl_kernel(const string_class &KernelName) const { size_t Size; const detail::plugin &Plugin = getPlugin(); - Plugin.call(MProgram, CL_PROGRAM_KERNEL_NAMES, 0, + Plugin.call(MProgram, PI_PROGRAM_INFO_KERNEL_NAMES, 0, nullptr, &Size); string_class ClResult(Size, ' '); - Plugin.call(MProgram, CL_PROGRAM_KERNEL_NAMES, + Plugin.call(MProgram, PI_PROGRAM_INFO_KERNEL_NAMES, ClResult.size(), &ClResult[0], nullptr); // Get rid of the null terminator @@ -402,10 +402,10 @@ cl_uint program_impl::get_info() const { if (is_host()) { throw invalid_object_error("This instance of program is a host instance"); } - cl_uint Result; + pi_uint32 Result; const detail::plugin &Plugin = getPlugin(); - Plugin.call(MProgram, CL_PROGRAM_REFERENCE_COUNT, - sizeof(cl_uint), &Result, nullptr); + Plugin.call(MProgram, PI_PROGRAM_INFO_REFERENCE_COUNT, + sizeof(pi_uint32), &Result, nullptr); return Result; } diff --git a/sycl/source/detail/program_manager/program_manager.cpp b/sycl/source/detail/program_manager/program_manager.cpp index 8e9bb45b3313d..25568440fe6ab 100644 --- a/sycl/source/detail/program_manager/program_manager.cpp +++ b/sycl/source/detail/program_manager/program_manager.cpp @@ -46,7 +46,7 @@ ProgramManager &ProgramManager::getInstance() { } static RT::PiDevice getFirstDevice(const ContextImplPtr &Context) { - cl_uint NumDevices = 0; + pi_uint32 NumDevices = 0; const detail::plugin &Plugin = Context->getPlugin(); Plugin.call(Context->getHandleRef(), PI_CONTEXT_INFO_NUM_DEVICES, @@ -70,7 +70,7 @@ static RT::PiProgram createBinaryProgram(const ContextImplPtr Context, // FIXME: we don't yet support multiple devices with a single binary. const detail::plugin &Plugin = Context->getPlugin(); #ifndef _NDEBUG - cl_uint NumDevices = 0; + pi_uint32 NumDevices = 0; Plugin.call(Context->getHandleRef(), PI_CONTEXT_INFO_NUM_DEVICES, sizeof(NumDevices), &NumDevices, @@ -382,7 +382,7 @@ ProgramManager::getClProgramFromClKernel(RT::PiKernel Kernel, RT::PiProgram Program; const detail::plugin &Plugin = Context->getPlugin(); Plugin.call( - Kernel, CL_KERNEL_PROGRAM, sizeof(cl_program), &Program, nullptr); + Kernel, PI_KERNEL_INFO_PROGRAM, sizeof(RT::PiProgram), &Program, nullptr); return Program; } @@ -390,11 +390,11 @@ string_class ProgramManager::getProgramBuildLog(const RT::PiProgram &Program, const ContextImplPtr Context) { size_t Size = 0; const detail::plugin &Plugin = Context->getPlugin(); - Plugin.call(Program, CL_PROGRAM_DEVICES, 0, + Plugin.call(Program, PI_PROGRAM_INFO_DEVICES, 0, nullptr, &Size); vector_class PIDevices(Size / sizeof(RT::PiDevice)); - Plugin.call(Program, CL_PROGRAM_DEVICES, Size, - PIDevices.data(), nullptr); + Plugin.call(Program, PI_PROGRAM_INFO_DEVICES, + Size, PIDevices.data(), nullptr); string_class Log = "The program was built for " + std::to_string(PIDevices.size()) + " devices"; for (RT::PiDevice &Device : PIDevices) { diff --git a/sycl/source/detail/queue_impl.cpp b/sycl/source/detail/queue_impl.cpp index bcd82d62ac58d..7d4f9da413507 100644 --- a/sycl/source/detail/queue_impl.cpp +++ b/sycl/source/detail/queue_impl.cpp @@ -60,7 +60,7 @@ event queue_impl::memcpy(shared_ptr_class Impl, void *Dest, return event(pi::cast(Event), Context); } -event queue_impl::mem_advise(const void *Ptr, size_t Length, int Advice) { +event queue_impl::mem_advise(const void *Ptr, size_t Length, pi_mem_advice Advice) { context Context = get_context(); if (Context.is_host()) { return event(); diff --git a/sycl/source/detail/scheduler/commands.cpp b/sycl/source/detail/scheduler/commands.cpp index 5fb547215d773..d7fd383ba330b 100644 --- a/sycl/source/detail/scheduler/commands.cpp +++ b/sycl/source/detail/scheduler/commands.cpp @@ -930,9 +930,9 @@ cl_int ExecCGCommand::enqueueImp() { case kernel_param_kind_t::kind_accessor: { Requirement *Req = (Requirement *)(Arg.MPtr); AllocaCommandBase *AllocaCmd = getAllocaForReq(Req); - cl_mem MemArg = (cl_mem)AllocaCmd->getMemAllocation(); + RT::PiMem MemArg = (RT::PiMem)AllocaCmd->getMemAllocation(); Plugin.call(Kernel, Arg.MIndex, - sizeof(cl_mem), &MemArg); + sizeof(RT::PiMem), &MemArg); break; } case kernel_param_kind_t::kind_std_layout: { diff --git a/sycl/source/queue.cpp b/sycl/source/queue.cpp index 30de214675d02..92d8e88b8952a 100644 --- a/sycl/source/queue.cpp +++ b/sycl/source/queue.cpp @@ -87,7 +87,7 @@ event queue::memcpy(void *dest, const void *src, size_t count) { return impl->memcpy(impl, dest, src, count); } -event queue::mem_advise(const void *ptr, size_t length, int advice) { +event queue::mem_advise(const void *ptr, size_t length, pi_mem_advice advice) { return impl->mem_advise(ptr, length, advice); } diff --git a/sycl/test/usm/memadvise.cpp b/sycl/test/usm/memadvise.cpp index b258a4751263a..434bdffa39b62 100644 --- a/sycl/test/usm/memadvise.cpp +++ b/sycl/test/usm/memadvise.cpp @@ -36,7 +36,7 @@ int main() { if (s_head == nullptr) { return -1; } - q.mem_advise(s_head, sizeof(Node), 42); + q.mem_advise(s_head, sizeof(Node), PI_MEM_ADVICE_SET_READ_MOSTLY); Node *s_cur = s_head; for (int i = 0; i < numNodes; i++) { @@ -47,7 +47,7 @@ int main() { if (s_cur->pNext == nullptr) { return -1; } - q.mem_advise(s_cur->pNext, sizeof(Node), 42); + q.mem_advise(s_cur->pNext, sizeof(Node), PI_MEM_ADVICE_SET_READ_MOSTLY); } else { s_cur->pNext = nullptr; }