diff --git a/sycl/plugins/cuda/CMakeLists.txt b/sycl/plugins/cuda/CMakeLists.txt index 701b6bc4e6555..e0a4e67fe27c4 100644 --- a/sycl/plugins/cuda/CMakeLists.txt +++ b/sycl/plugins/cuda/CMakeLists.txt @@ -55,6 +55,8 @@ add_sycl_plugin(cuda "../unified_runtime/ur/ur.cpp" "../unified_runtime/ur/usm_allocator.cpp" "../unified_runtime/ur/usm_allocator.hpp" + "../unified_runtime/ur/adapters/cuda/command_buffer.cpp" + "../unified_runtime/ur/adapters/cuda/command_buffer.hpp" "../unified_runtime/ur/adapters/cuda/common.cpp" "../unified_runtime/ur/adapters/cuda/common.hpp" "../unified_runtime/ur/adapters/cuda/context.cpp" @@ -81,8 +83,6 @@ add_sycl_plugin(cuda "../unified_runtime/ur/adapters/cuda/tracing.cpp" "../unified_runtime/ur/adapters/cuda/ur_interface_loader.cpp" "../unified_runtime/ur/adapters/cuda/usm.cpp" - "../unified_runtime/ur/adapters/cuda/command_buffer.hpp" - "../unified_runtime/ur/adapters/cuda/command_buffer.cpp" "../unified_runtime/ur/adapters/cuda/usm_p2p.cpp" # --- "${sycl_inc_dir}/sycl/detail/pi.h" diff --git a/sycl/plugins/cuda/pi_cuda.cpp b/sycl/plugins/cuda/pi_cuda.cpp index 0e8a2f8a3d336..94a39137ec4f7 100644 --- a/sycl/plugins/cuda/pi_cuda.cpp +++ b/sycl/plugins/cuda/pi_cuda.cpp @@ -22,6 +22,1165 @@ void enableCUDATracing(); //-- PI API implementation extern "C" { +pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, + pi_uint32 *NumPlatforms) { + return pi2ur::piPlatformsGet(NumEntries, Platforms, NumPlatforms); +} + +pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piPlatformGetInfo(Platform, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piextPlatformGetNativeHandle(pi_platform Platform, + pi_native_handle *NativeHandle) { + return pi2ur::piextPlatformGetNativeHandle(Platform, NativeHandle); +} + +pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_platform *Platform) { + return pi2ur::piextPlatformCreateWithNativeHandle(NativeHandle, Platform); +} + +pi_result piPluginGetLastError(char **message) { + return pi2ur::piPluginGetLastError(message); +} + +pi_result piPluginGetBackendOption(pi_platform platform, + const char *frontend_option, + const char **backend_option) { + return pi2ur::piPluginGetBackendOption(platform, frontend_option, + backend_option); +} + +pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, + pi_uint32 NumEntries, pi_device *Devices, + pi_uint32 *NumDevices) { + return pi2ur::piDevicesGet(Platform, DeviceType, NumEntries, Devices, + NumDevices); +} + +pi_result piDeviceRetain(pi_device Device) { + return pi2ur::piDeviceRetain(Device); +} + +pi_result piDeviceRelease(pi_device Device) { + return pi2ur::piDeviceRelease(Device); +} + +pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piDeviceGetInfo(Device, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piDevicePartition(pi_device Device, + const pi_device_partition_property *Properties, + pi_uint32 NumDevices, pi_device *OutDevices, + pi_uint32 *OutNumDevices) { + return pi2ur::piDevicePartition(Device, Properties, NumDevices, OutDevices, + OutNumDevices); +} + +pi_result piextDeviceSelectBinary(pi_device Device, pi_device_binary *Binaries, + pi_uint32 NumBinaries, + pi_uint32 *SelectedBinaryInd) { + return pi2ur::piextDeviceSelectBinary(Device, Binaries, NumBinaries, + SelectedBinaryInd); +} + +pi_result piextDeviceGetNativeHandle(pi_device Device, + pi_native_handle *NativeHandle) { + + return pi2ur::piextDeviceGetNativeHandle(Device, NativeHandle); +} + +pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_platform Platform, + pi_device *Device) { + + return pi2ur::piextDeviceCreateWithNativeHandle(NativeHandle, Platform, + Device); +} + +pi_result piContextCreate(const pi_context_properties *Properties, + pi_uint32 NumDevices, const pi_device *Devices, + void (*PFnNotify)(const char *ErrInfo, + const void *PrivateInfo, size_t CB, + void *UserData), + void *UserData, pi_context *RetContext) { + return pi2ur::piContextCreate(Properties, NumDevices, Devices, PFnNotify, + UserData, RetContext); +} + +pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piContextGetInfo(Context, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piextContextSetExtendedDeleter(pi_context Context, + pi_context_extended_deleter Function, + void *UserData) { + return pi2ur::piextContextSetExtendedDeleter(Context, Function, UserData); +} + +pi_result piextContextGetNativeHandle(pi_context Context, + pi_native_handle *NativeHandle) { + return pi2ur::piextContextGetNativeHandle(Context, NativeHandle); +} + +pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_uint32 NumDevices, + const pi_device *Devices, + bool OwnNativeHandle, + pi_context *RetContext) { + return pi2ur::piextContextCreateWithNativeHandle( + NativeHandle, NumDevices, Devices, OwnNativeHandle, RetContext); +} + +pi_result piContextRetain(pi_context Context) { + + return pi2ur::piContextRetain(Context); +} + +pi_result piContextRelease(pi_context Context) { + return pi2ur::piContextRelease(Context); +} + +pi_result piQueueCreate(pi_context Context, pi_device Device, + pi_queue_properties Flags, pi_queue *Queue) { + pi_queue_properties Properties[] = {PI_QUEUE_FLAGS, Flags, 0}; + return piextQueueCreate(Context, Device, Properties, Queue); +} + +pi_result piextQueueCreate(pi_context Context, pi_device Device, + pi_queue_properties *Properties, pi_queue *Queue) { + return pi2ur::piextQueueCreate(Context, Device, Properties, Queue); +} + +pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piQueueGetInfo(Queue, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piQueueRetain(pi_queue Queue) { return pi2ur::piQueueRetain(Queue); } + +pi_result piQueueRelease(pi_queue Queue) { + return pi2ur::piQueueRelease(Queue); +} + +pi_result piQueueFinish(pi_queue Queue) { return pi2ur::piQueueFinish(Queue); } + +pi_result piQueueFlush(pi_queue Queue) { return pi2ur::piQueueFlush(Queue); } + +pi_result piextQueueGetNativeHandle(pi_queue Queue, + pi_native_handle *NativeHandle, + int32_t *NativeHandleDesc) { + + return pi2ur::piextQueueGetNativeHandle(Queue, NativeHandle, + NativeHandleDesc); +} + +pi_result piextQueueCreateWithNativeHandle(pi_native_handle NativeHandle, + int32_t NativeHandleDesc, + pi_context Context, pi_device Device, + bool OwnNativeHandle, + pi_queue_properties *Properties, + pi_queue *Queue) { + + return pi2ur::piextQueueCreateWithNativeHandle( + NativeHandle, NativeHandleDesc, Context, Device, OwnNativeHandle, + Properties, Queue); +} + +pi_result piMemBufferCreate(pi_context Context, pi_mem_flags Flags, size_t Size, + void *HostPtr, pi_mem *RetMem, + const pi_mem_properties *properties) { + return pi2ur::piMemBufferCreate(Context, Flags, Size, HostPtr, RetMem, + properties); +} + +pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, + void *ParamValue, size_t *ParamValueSizeRet) { + return pi2ur::piMemGetInfo(Mem, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piMemRetain(pi_mem Mem) { return pi2ur::piMemRetain(Mem); } + +pi_result piMemRelease(pi_mem Mem) { return pi2ur::piMemRelease(Mem); } + +pi_result piMemImageCreate(pi_context Context, pi_mem_flags Flags, + const pi_image_format *ImageFormat, + const pi_image_desc *ImageDesc, void *HostPtr, + pi_mem *RetImage) { + + return pi2ur::piMemImageCreate(Context, Flags, ImageFormat, ImageDesc, + HostPtr, RetImage); +} + +pi_result piextMemGetNativeHandle(pi_mem Mem, pi_native_handle *NativeHandle) { + return pi2ur::piextMemGetNativeHandle(Mem, NativeHandle); +} + +pi_result piextMemCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + bool ownNativeHandle, pi_mem *Mem) { + return pi2ur::piextMemCreateWithNativeHandle(NativeHandle, Context, + ownNativeHandle, Mem); +} + +pi_result piProgramCreate(pi_context Context, const void *ILBytes, + size_t Length, pi_program *Program) { + return pi2ur::piProgramCreate(Context, ILBytes, Length, Program); +} + +pi_result piProgramCreateWithBinary( + pi_context Context, pi_uint32 NumDevices, const pi_device *DeviceList, + const size_t *Lengths, const unsigned char **Binaries, + size_t NumMetadataEntries, const pi_device_binary_property *Metadata, + pi_int32 *BinaryStatus, pi_program *Program) { + + return pi2ur::piProgramCreateWithBinary(Context, NumDevices, DeviceList, + Lengths, Binaries, NumMetadataEntries, + Metadata, BinaryStatus, Program); +} + +pi_result piextMemImageCreateWithNativeHandle( + pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, + const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc, + pi_mem *Img) { + return pi2ur::piextMemImageCreateWithNativeHandle( + NativeHandle, Context, OwnNativeHandle, ImageFormat, ImageDesc, Img); +} + +pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piProgramGetInfo(Program, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piProgramLink(pi_context Context, pi_uint32 NumDevices, + const pi_device *DeviceList, const char *Options, + pi_uint32 NumInputPrograms, + const pi_program *InputPrograms, + void (*PFnNotify)(pi_program Program, void *UserData), + void *UserData, pi_program *RetProgram) { + return pi2ur::piProgramLink(Context, NumDevices, DeviceList, Options, + NumInputPrograms, InputPrograms, PFnNotify, + UserData, RetProgram); +} + +pi_result piProgramCompile( + pi_program Program, pi_uint32 NumDevices, const pi_device *DeviceList, + const char *Options, pi_uint32 NumInputHeaders, + const pi_program *InputHeaders, const char **HeaderIncludeNames, + void (*PFnNotify)(pi_program Program, void *UserData), void *UserData) { + + return pi2ur::piProgramCompile(Program, NumDevices, DeviceList, Options, + NumInputHeaders, InputHeaders, + HeaderIncludeNames, PFnNotify, UserData); +} + +pi_result piProgramBuild(pi_program Program, pi_uint32 NumDevices, + const pi_device *DeviceList, const char *Options, + void (*PFnNotify)(pi_program Program, void *UserData), + void *UserData) { + return pi2ur::piProgramBuild(Program, NumDevices, DeviceList, Options, + PFnNotify, UserData); +} + +pi_result piProgramGetBuildInfo(pi_program Program, pi_device Device, + pi_program_build_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piProgramGetBuildInfo(Program, Device, ParamName, + ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piProgramRetain(pi_program Program) { + return pi2ur::piProgramRetain(Program); +} + +pi_result piProgramRelease(pi_program Program) { + return pi2ur::piProgramRelease(Program); +} + +pi_result piextProgramGetNativeHandle(pi_program Program, + pi_native_handle *NativeHandle) { + return pi2ur::piextProgramGetNativeHandle(Program, NativeHandle); +} + +pi_result piextProgramCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + bool OwnNativeHandle, + pi_program *Program) { + return pi2ur::piextProgramCreateWithNativeHandle(NativeHandle, Context, + OwnNativeHandle, Program); +} + +pi_result piKernelCreate(pi_program Program, const char *KernelName, + pi_kernel *RetKernel) { + + return pi2ur::piKernelCreate(Program, KernelName, RetKernel); +} + +pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, + const void *ArgValue) { + + return pi2ur::piKernelSetArg(Kernel, ArgIndex, ArgSize, ArgValue); +} + +pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, + const pi_mem_obj_property *ArgProperties, + const pi_mem *ArgValue) { + return pi2ur::piextKernelSetArgMemObj(Kernel, ArgIndex, ArgProperties, + ArgValue); +} + +pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, + const pi_sampler *ArgValue) { + + return pi2ur::piextKernelSetArgSampler(Kernel, ArgIndex, ArgValue); +} + +pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piKernelGetInfo(Kernel, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +__SYCL_EXPORT pi_result piextMemImageAllocate(pi_context Context, + pi_device Device, + pi_image_format *ImageFormat, + pi_image_desc *ImageDesc, + pi_image_mem_handle *RetMem) { + return pi2ur::piextMemImageAllocate(Context, Device, ImageFormat, ImageDesc, + RetMem); +} + +__SYCL_EXPORT pi_result piextMemUnsampledImageCreate( + pi_context Context, pi_device Device, pi_image_mem_handle ImgMem, + pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_mem *RetMem, + pi_image_handle *RetHandle) { + return pi2ur::piextMemUnsampledImageCreate( + Context, Device, ImgMem, ImageFormat, ImageDesc, RetMem, RetHandle); +} + +__SYCL_EXPORT pi_result piextMemSampledImageCreate( + pi_context Context, pi_device Device, pi_image_mem_handle ImgMem, + pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_sampler Sampler, + pi_mem *RetMem, pi_image_handle *RetHandle) { + return pi2ur::piextMemSampledImageCreate(Context, Device, ImgMem, ImageFormat, + ImageDesc, Sampler, RetMem, + RetHandle); +} + +__SYCL_EXPORT pi_result piextBindlessImageSamplerCreate( + pi_context Context, const pi_sampler_properties *SamplerProperties, + float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy, + pi_sampler *RetSampler) { + return pi2ur::piextBindlessImageSamplerCreate( + Context, SamplerProperties, MinMipmapLevelClamp, MaxMipmapLevelClamp, + MaxAnisotropy, RetSampler); +} + +__SYCL_EXPORT pi_result piextMemMipmapGetLevel(pi_context Context, + pi_device Device, + pi_image_mem_handle MipMem, + unsigned int Level, + pi_image_mem_handle *RetMem) { + return pi2ur::piextMemMipmapGetLevel(Context, Device, MipMem, Level, RetMem); +} + +__SYCL_EXPORT pi_result piextMemImageFree(pi_context Context, pi_device Device, + pi_image_mem_handle MemoryHandle) { + return pi2ur::piextMemImageFree(Context, Device, MemoryHandle); +} + +__SYCL_EXPORT pi_result piextMemMipmapFree(pi_context Context, pi_device Device, + pi_image_mem_handle MemoryHandle) { + return pi2ur::piextMemMipmapFree(Context, Device, MemoryHandle); +} + +__SYCL_EXPORT pi_result piextMemImageCopy( + pi_queue Queue, void *DstPtr, void *SrcPtr, + const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc, + const pi_image_copy_flags Flags, pi_image_offset SrcOffset, + pi_image_offset DstOffset, pi_image_region CopyExtent, + pi_image_region HostExtent, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *Event) { + return pi2ur::piextMemImageCopy(Queue, DstPtr, SrcPtr, ImageFormat, ImageDesc, + Flags, SrcOffset, DstOffset, CopyExtent, + HostExtent, NumEventsInWaitList, + EventWaitList, Event); +} + +__SYCL_EXPORT pi_result piextMemUnsampledImageHandleDestroy( + pi_context Context, pi_device Device, pi_image_handle Handle) { + return pi2ur::piextMemUnsampledImageHandleDestroy(Context, Device, Handle); +} + +__SYCL_EXPORT pi_result piextMemSampledImageHandleDestroy( + pi_context Context, pi_device Device, pi_image_handle Handle) { + return pi2ur::piextMemSampledImageHandleDestroy(Context, Device, Handle); +} + +__SYCL_EXPORT pi_result piextMemImageGetInfo(pi_image_mem_handle MemHandle, + pi_image_info ParamName, + void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piextMemImageGetInfo(MemHandle, ParamName, ParamValue, + ParamValueSizeRet); +} + +__SYCL_EXPORT pi_result +piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size, + int FileDescriptor, pi_interop_mem_handle *RetHandle) { + return pi2ur::piextMemImportOpaqueFD(Context, Device, Size, FileDescriptor, + RetHandle); +} + +__SYCL_EXPORT pi_result piextMemMapExternalArray( + pi_context Context, pi_device Device, pi_image_format *ImageFormat, + pi_image_desc *ImageDesc, pi_interop_mem_handle MemHandle, + pi_image_mem_handle *RetMem) { + return pi2ur::piextMemMapExternalArray(Context, Device, ImageFormat, + ImageDesc, MemHandle, RetMem); +} + +__SYCL_EXPORT pi_result piextMemReleaseInterop(pi_context Context, + pi_device Device, + pi_interop_mem_handle ExtMem) { + return pi2ur::piextMemReleaseInterop(Context, Device, ExtMem); +} + +__SYCL_EXPORT pi_result piextImportExternalSemaphoreOpaqueFD( + pi_context Context, pi_device Device, int FileDescriptor, + pi_interop_semaphore_handle *RetHandle) { + return pi2ur::piextImportExternalSemaphoreOpaqueFD(Context, Device, + FileDescriptor, RetHandle); +} + +__SYCL_EXPORT pi_result +piextDestroyExternalSemaphore(pi_context Context, pi_device Device, + pi_interop_semaphore_handle SemHandle) { + return pi2ur::piextDestroyExternalSemaphore(Context, Device, SemHandle); +} + +__SYCL_EXPORT pi_result piextWaitExternalSemaphore( + pi_queue Queue, pi_interop_semaphore_handle SemHandle, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piextWaitExternalSemaphore( + Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event); +} + +__SYCL_EXPORT pi_result piextSignalExternalSemaphore( + pi_queue Queue, pi_interop_semaphore_handle SemHandle, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piextSignalExternalSemaphore( + Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piKernelGetGroupInfo(pi_kernel Kernel, pi_device Device, + pi_kernel_group_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piKernelGetGroupInfo(Kernel, Device, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piKernelGetSubGroupInfo(pi_kernel Kernel, pi_device Device, + pi_kernel_sub_group_info ParamName, + size_t InputValueSize, const void *InputValue, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piKernelGetSubGroupInfo( + Kernel, Device, ParamName, InputValueSize, InputValue, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piKernelRetain(pi_kernel Kernel) { + + return pi2ur::piKernelRetain(Kernel); +} + +pi_result piKernelRelease(pi_kernel Kernel) { + + return pi2ur::piKernelRelease(Kernel); +} + +pi_result +piEnqueueKernelLaunch(pi_queue Queue, pi_kernel Kernel, pi_uint32 WorkDim, + const size_t *GlobalWorkOffset, + const size_t *GlobalWorkSize, const size_t *LocalWorkSize, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *OutEvent) { + return pi2ur::piEnqueueKernelLaunch( + Queue, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, LocalWorkSize, + NumEventsInWaitList, EventWaitList, OutEvent); +} + +pi_result piextKernelCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + pi_program Program, + bool OwnNativeHandle, + pi_kernel *Kernel) { + + return pi2ur::piextKernelCreateWithNativeHandle( + NativeHandle, Context, Program, OwnNativeHandle, Kernel); +} + +pi_result piextKernelGetNativeHandle(pi_kernel Kernel, + pi_native_handle *NativeHandle) { + return pi2ur::piextKernelGetNativeHandle(Kernel, NativeHandle); +} + +pi_result piEventCreate(pi_context Context, pi_event *RetEvent) { + return pi2ur::piEventCreate(Context, RetEvent); +} + +pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piEventGetInfo(Event, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piEventGetProfilingInfo(Event, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList) { + return pi2ur::piEventsWait(NumEvents, EventList); +} + +pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, + void (*PFnNotify)(pi_event Event, + pi_int32 EventCommandStatus, + void *UserData), + void *UserData) { + return pi2ur::piEventSetCallback(Event, CommandExecCallbackType, PFnNotify, + UserData); +} + +pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus) { + return pi2ur::piEventSetStatus(Event, ExecutionStatus); +} + +pi_result piEventRetain(pi_event Event) { return pi2ur::piEventRetain(Event); } + +pi_result piEventRelease(pi_event Event) { + return pi2ur::piEventRelease(Event); +} + +pi_result piextEventGetNativeHandle(pi_event Event, + pi_native_handle *NativeHandle) { + + return pi2ur::piextEventGetNativeHandle(Event, NativeHandle); +} + +pi_result piextEventCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + bool OwnNativeHandle, + pi_event *Event) { + return pi2ur::piextEventCreateWithNativeHandle(NativeHandle, Context, + OwnNativeHandle, Event); +} + +pi_result piSamplerCreate(pi_context Context, + const pi_sampler_properties *SamplerProperties, + pi_sampler *RetSampler) { + return pi2ur::piSamplerCreate(Context, SamplerProperties, RetSampler); +} + +pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piSamplerGetInfo(Sampler, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piSamplerRetain(pi_sampler Sampler) { + return pi2ur::piSamplerRetain(Sampler); +} + +pi_result piSamplerRelease(pi_sampler Sampler) { + return pi2ur::piSamplerRelease(Sampler); +} + +pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent) { + + return pi2ur::piEnqueueEventsWait(Queue, NumEventsInWaitList, EventWaitList, + OutEvent); +} + +pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent) { + + return pi2ur::piEnqueueEventsWaitWithBarrier(Queue, NumEventsInWaitList, + EventWaitList, OutEvent); +} + +pi_result piEnqueueMemBufferRead(pi_queue Queue, pi_mem Src, + pi_bool BlockingRead, size_t Offset, + size_t Size, void *Dst, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferRead(Queue, Src, BlockingRead, Offset, Size, + Dst, NumEventsInWaitList, EventWaitList, + Event); +} + +pi_result piEnqueueMemBufferReadRect( + pi_queue Queue, pi_mem Buffer, pi_bool BlockingRead, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, void *Ptr, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferReadRect( + Queue, Buffer, BlockingRead, BufferOffset, HostOffset, Region, + BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piEnqueueMemBufferWrite(pi_queue Queue, pi_mem Buffer, + pi_bool BlockingWrite, size_t Offset, + size_t Size, const void *Ptr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferWrite(Queue, Buffer, BlockingWrite, Offset, + Size, Ptr, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferWriteRect( + pi_queue Queue, pi_mem Buffer, pi_bool BlockingWrite, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferWriteRect( + Queue, Buffer, BlockingWrite, BufferOffset, HostOffset, Region, + BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piEnqueueMemBufferCopy(pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, + size_t SrcOffset, size_t DstOffset, + size_t Size, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferCopy(Queue, SrcMem, DstMem, SrcOffset, + DstOffset, Size, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferCopyRect( + pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, pi_buff_rect_offset SrcOrigin, + pi_buff_rect_offset DstOrigin, pi_buff_rect_region Region, + size_t SrcRowPitch, size_t SrcSlicePitch, size_t DstRowPitch, + size_t DstSlicePitch, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *Event) { + + return pi2ur::piEnqueueMemBufferCopyRect( + Queue, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch, + SrcSlicePitch, DstRowPitch, DstSlicePitch, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferFill(pi_queue Queue, pi_mem Buffer, + const void *Pattern, size_t PatternSize, + size_t Offset, size_t Size, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferFill(Queue, Buffer, Pattern, PatternSize, + Offset, Size, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferMap(pi_queue Queue, pi_mem Mem, pi_bool BlockingMap, + pi_map_flags MapFlags, size_t Offset, + size_t Size, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent, void **RetMap) { + + return pi2ur::piEnqueueMemBufferMap(Queue, Mem, BlockingMap, MapFlags, Offset, + Size, NumEventsInWaitList, EventWaitList, + OutEvent, RetMap); +} + +pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *OutEvent) { + + return pi2ur::piEnqueueMemUnmap(Queue, Mem, MappedPtr, NumEventsInWaitList, + EventWaitList, OutEvent); +} + +pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piMemImageGetInfo(Image, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piEnqueueMemImageRead(pi_queue Queue, pi_mem Image, + pi_bool BlockingRead, pi_image_offset Origin, + pi_image_region Region, size_t RowPitch, + size_t SlicePitch, void *Ptr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piEnqueueMemImageRead( + Queue, Image, BlockingRead, Origin, Region, RowPitch, SlicePitch, Ptr, + NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piEnqueueMemImageWrite(pi_queue Queue, pi_mem Image, + pi_bool BlockingWrite, pi_image_offset Origin, + pi_image_region Region, size_t InputRowPitch, + size_t InputSlicePitch, const void *Ptr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemImageWrite( + Queue, Image, BlockingWrite, Origin, Region, InputRowPitch, + InputSlicePitch, Ptr, NumEventsInWaitList, EventWaitList, Event); +} + +pi_result +piEnqueueMemImageCopy(pi_queue Queue, pi_mem SrcImage, pi_mem DstImage, + pi_image_offset SrcOrigin, pi_image_offset DstOrigin, + pi_image_region Region, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *Event) { + return pi2ur::piEnqueueMemImageCopy(Queue, SrcImage, DstImage, SrcOrigin, + DstOrigin, Region, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemImageFill(pi_queue Queue, pi_mem Image, + const void *FillColor, const size_t *Origin, + const size_t *Region, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemImageFill(Queue, Image, FillColor, Origin, Region, + NumEventsInWaitList, EventWaitList, + Event); +} + +pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, + pi_buffer_create_type BufferCreateType, + void *BufferCreateInfo, pi_mem *RetMem) { + + return pi2ur::piMemBufferPartition(Buffer, Flags, BufferCreateType, + BufferCreateInfo, RetMem); +} + +pi_result piextGetDeviceFunctionPointer(pi_device Device, pi_program Program, + const char *FunctionName, + pi_uint64 *FunctionPointerRet) { + return pi2ur::piextGetDeviceFunctionPointer(Device, Program, FunctionName, + FunctionPointerRet); +} + +pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context, + pi_device Device, + pi_usm_mem_properties *Properties, size_t Size, + pi_uint32 Alignment) { + + return pi2ur::piextUSMDeviceAlloc(ResultPtr, Context, Device, Properties, + Size, Alignment); +} + +pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context, + pi_device Device, + pi_usm_mem_properties *Properties, size_t Size, + pi_uint32 Alignment) { + + return pi2ur::piextUSMSharedAlloc(ResultPtr, Context, Device, Properties, + Size, Alignment); +} + +__SYCL_EXPORT pi_result piextUSMPitchedAlloc( + void **ResultPtr, size_t *ResultPitch, pi_context Context, pi_device Device, + pi_usm_mem_properties *Properties, size_t WidthInBytes, size_t Height, + unsigned int ElementSizeBytes) { + + return pi2ur::piextUSMPitchedAlloc(ResultPtr, ResultPitch, Context, Device, + Properties, WidthInBytes, Height, + ElementSizeBytes); +} + +pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context, + pi_usm_mem_properties *Properties, size_t Size, + pi_uint32 Alignment) { + return pi2ur::piextUSMHostAlloc(ResultPtr, Context, Properties, Size, + Alignment); +} + +pi_result piextUSMFree(pi_context Context, void *Ptr) { + + return pi2ur::piextUSMFree(Context, Ptr); +} + +pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, + size_t ArgSize, const void *ArgValue) { + return pi2ur::piextKernelSetArgPointer(Kernel, ArgIndex, ArgSize, ArgValue); +} + +pi_result piextUSMEnqueueMemset(pi_queue Queue, void *Ptr, pi_int32 Value, + size_t Count, pi_uint32 NumEventsInWaitlist, + const pi_event *EventsWaitlist, + pi_event *Event) { + return pi2ur::piextUSMEnqueueMemset( + Queue, Ptr, Value, Count, NumEventsInWaitlist, EventsWaitlist, Event); +} + +pi_result piextUSMEnqueueMemcpy(pi_queue Queue, pi_bool Blocking, void *DstPtr, + const void *SrcPtr, size_t Size, + pi_uint32 NumEventsInWaitlist, + const pi_event *EventsWaitlist, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueMemcpy(Queue, Blocking, DstPtr, SrcPtr, Size, + NumEventsInWaitlist, EventsWaitlist, + Event); +} + +pi_result piextUSMEnqueuePrefetch(pi_queue Queue, const void *Ptr, size_t Size, + pi_usm_migration_flags Flags, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent) { + + return pi2ur::piextUSMEnqueuePrefetch( + Queue, Ptr, Size, Flags, NumEventsInWaitList, EventWaitList, OutEvent); +} + +pi_result piextUSMEnqueueMemAdvise(pi_queue Queue, const void *Ptr, + size_t Length, pi_mem_advice Advice, + pi_event *OutEvent) { + + return pi2ur::piextUSMEnqueueMemAdvise(Queue, Ptr, Length, Advice, OutEvent); +} + +__SYCL_EXPORT pi_result piextUSMEnqueueFill2D(pi_queue Queue, void *Ptr, + size_t Pitch, size_t PatternSize, + const void *Pattern, size_t Width, + size_t Height, + pi_uint32 NumEventsWaitList, + const pi_event *EventsWaitList, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueFill2D(Queue, Ptr, Pitch, PatternSize, Pattern, + Width, Height, NumEventsWaitList, + EventsWaitList, Event); +} + +__SYCL_EXPORT pi_result piextUSMEnqueueMemset2D(pi_queue Queue, void *Ptr, + size_t Pitch, int Value, + size_t Width, size_t Height, + pi_uint32 NumEventsWaitList, + const pi_event *EventsWaitlist, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueMemset2D(Queue, Ptr, Pitch, Value, Width, Height, + NumEventsWaitList, EventsWaitlist, + Event); +} + +__SYCL_EXPORT pi_result piextUSMEnqueueMemcpy2D( + pi_queue Queue, pi_bool Blocking, void *DstPtr, size_t DstPitch, + const void *SrcPtr, size_t SrcPitch, size_t Width, size_t Height, + pi_uint32 NumEventsInWaitlist, const pi_event *EventWaitlist, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueMemcpy2D( + Queue, Blocking, DstPtr, DstPitch, SrcPtr, SrcPitch, Width, Height, + NumEventsInWaitlist, EventWaitlist, Event); +} + +pi_result piextUSMGetMemAllocInfo(pi_context Context, const void *Ptr, + pi_mem_alloc_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piextUSMGetMemAllocInfo(Context, Ptr, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context) { + return pi2ur::piextUSMImport(HostPtr, Size, Context); +} + +pi_result piextUSMRelease(const void *HostPtr, pi_context Context) { + return pi2ur::piextUSMRelease(HostPtr, Context); +} + +pi_result piextEnqueueDeviceGlobalVariableWrite( + pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite, + size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, pi_event *Event) { + return pi2ur::piextEnqueueDeviceGlobalVariableWrite( + Queue, Program, Name, BlockingWrite, Count, Offset, Src, + NumEventsInWaitList, EventsWaitList, Event); +} + +pi_result piextEnqueueDeviceGlobalVariableRead( + pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingRead, + size_t Count, size_t Offset, void *Dst, pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, pi_event *Event) { + return pi2ur::piextEnqueueDeviceGlobalVariableRead( + Queue, Program, Name, BlockingRead, Count, Offset, Dst, + NumEventsInWaitList, EventsWaitList, Event); + + return PI_SUCCESS; +} + +pi_result piextEnqueueReadHostPipe(pi_queue Queue, pi_program Program, + const char *PipeSymbol, pi_bool Blocking, + void *Ptr, size_t Size, + pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, + pi_event *Event) { + (void)Queue; + (void)Program; + (void)PipeSymbol; + (void)Blocking; + (void)Ptr; + (void)Size; + (void)NumEventsInWaitList; + (void)EventsWaitList; + (void)Event; + PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE); + die("piextEnqueueReadHostPipe: not implemented"); + return {}; +} + +pi_result piextEnqueueWriteHostPipe(pi_queue Queue, pi_program Program, + const char *PipeSymbol, pi_bool Blocking, + void *Ptr, size_t Size, + pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, + pi_event *Event) { + (void)Queue; + (void)Program; + (void)PipeSymbol; + (void)Blocking; + (void)Ptr; + (void)Size; + (void)NumEventsInWaitList; + (void)EventsWaitList; + (void)Event; + PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE); + die("piextEnqueueWriteHostPipe: not implemented"); + return {}; +} + +pi_result piKernelSetExecInfo(pi_kernel Kernel, pi_kernel_exec_info ParamName, + size_t ParamValueSize, const void *ParamValue) { + + return pi2ur::piKernelSetExecInfo(Kernel, ParamName, ParamValueSize, + ParamValue); +} + +pi_result piextProgramSetSpecializationConstant(pi_program Prog, + pi_uint32 SpecID, size_t Size, + const void *SpecValue) { + return pi2ur::piextProgramSetSpecializationConstant(Prog, SpecID, Size, + SpecValue); +} + +// Command buffer extension +pi_result piextCommandBufferCreate(pi_context Context, pi_device Device, + const pi_ext_command_buffer_desc *Desc, + pi_ext_command_buffer *RetCommandBuffer) { + return pi2ur::piextCommandBufferCreate(Context, Device, Desc, + RetCommandBuffer); +} + +pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer) { + return pi2ur::piextCommandBufferRetain(CommandBuffer); +} + +pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer) { + return pi2ur::piextCommandBufferRelease(CommandBuffer); +} + +pi_result piextCommandBufferFinalize(pi_ext_command_buffer CommandBuffer) { + return pi2ur::piextCommandBufferFinalize(CommandBuffer); +} + +pi_result piextCommandBufferNDRangeKernel( + pi_ext_command_buffer CommandBuffer, pi_kernel Kernel, pi_uint32 WorkDim, + const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize, + const size_t *LocalWorkSize, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferNDRangeKernel( + CommandBuffer, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, + LocalWorkSize, NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemcpyUSM( + pi_ext_command_buffer CommandBuffer, void *DstPtr, const void *SrcPtr, + size_t Size, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemcpyUSM(CommandBuffer, DstPtr, SrcPtr, Size, + NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferCopy( + pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem, + size_t SrcOffset, size_t DstOffset, size_t Size, + pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferCopy( + CommandBuffer, SrcMem, DstMem, SrcOffset, DstOffset, Size, + NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferCopyRect( + pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem, + pi_buff_rect_offset SrcOrigin, pi_buff_rect_offset DstOrigin, + pi_buff_rect_region Region, size_t SrcRowPitch, size_t SrcSlicePitch, + size_t DstRowPitch, size_t DstSlicePitch, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferCopyRect( + CommandBuffer, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch, + SrcSlicePitch, DstRowPitch, DstSlicePitch, NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferRead( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset, + size_t Size, void *Dst, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferRead( + CommandBuffer, Buffer, Offset, Size, Dst, NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferReadRect( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, void *Ptr, + pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferReadRect( + CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch, + BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferWrite( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset, + size_t Size, const void *Ptr, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferWrite( + CommandBuffer, Buffer, Offset, Size, Ptr, NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferWriteRect( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr, + pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferWriteRect( + CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch, + BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextEnqueueCommandBuffer(pi_ext_command_buffer CommandBuffer, + pi_queue Queue, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piextEnqueueCommandBuffer( + CommandBuffer, Queue, NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piextPluginGetOpaqueData(void *opaque_data_param, + void **opaque_data_return) { + return pi2ur::piextPluginGetOpaqueData(opaque_data_param, opaque_data_return); +} + +pi_result piTearDown(void *PluginParameter) { + return pi2ur::piTearDown(PluginParameter); +} + +pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime, + uint64_t *HostTime) { + return pi2ur::piGetDeviceAndHostTimer(Device, DeviceTime, HostTime); +} + +pi_result piextEnablePeerAccess(pi_device command_device, + pi_device peer_device) { + + return pi2ur::piextEnablePeerAccess(command_device, peer_device); +} + +pi_result piextDisablePeerAccess(pi_device command_device, + pi_device peer_device) { + + return pi2ur::piextDisablePeerAccess(command_device, peer_device); +} + +pi_result piextPeerAccessGetInfo(pi_device command_device, + pi_device peer_device, pi_peer_attr attr, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piextPeerAccessGetInfo(command_device, peer_device, attr, + ParamValueSize, ParamValue, + ParamValueSizeRet); +} + const char SupportedVersion[] = _PI_CUDA_PLUGIN_VERSION_STRING; pi_result piPluginInit(pi_plugin *PluginInit) { @@ -42,196 +1201,10 @@ pi_result piPluginInit(pi_plugin *PluginInit) { enableCUDATracing(); // Forward calls to CUDA RT. -#define _PI_CL(pi_api, cuda_api) \ - (PluginInit->PiFunctionTable).pi_api = (decltype(&::pi_api))(&cuda_api); - - // Platform - _PI_CL(piPlatformsGet, pi2ur::piPlatformsGet) - _PI_CL(piPlatformGetInfo, pi2ur::piPlatformGetInfo) - // Device - _PI_CL(piDevicesGet, pi2ur::piDevicesGet) - _PI_CL(piDeviceGetInfo, pi2ur::piDeviceGetInfo) - _PI_CL(piDevicePartition, pi2ur::piDevicePartition) - _PI_CL(piDeviceRetain, pi2ur::piDeviceRetain) - _PI_CL(piDeviceRelease, pi2ur::piDeviceRelease) - _PI_CL(piextDeviceSelectBinary, pi2ur::piextDeviceSelectBinary) - _PI_CL(piextGetDeviceFunctionPointer, pi2ur::piextGetDeviceFunctionPointer) - _PI_CL(piextDeviceGetNativeHandle, pi2ur::piextDeviceGetNativeHandle) - _PI_CL(piextDeviceCreateWithNativeHandle, - pi2ur::piextDeviceCreateWithNativeHandle) - // Context - _PI_CL(piextContextSetExtendedDeleter, pi2ur::piextContextSetExtendedDeleter) - _PI_CL(piContextCreate, pi2ur::piContextCreate) - _PI_CL(piContextGetInfo, pi2ur::piContextGetInfo) - _PI_CL(piContextRetain, pi2ur::piContextRetain) - _PI_CL(piContextRelease, pi2ur::piContextRelease) - _PI_CL(piextContextGetNativeHandle, pi2ur::piextContextGetNativeHandle) - _PI_CL(piextContextCreateWithNativeHandle, - pi2ur::piextContextCreateWithNativeHandle) - // Queue - _PI_CL(piQueueCreate, pi2ur::piQueueCreate) - _PI_CL(piextQueueCreate, pi2ur::piextQueueCreate) - _PI_CL(piQueueGetInfo, pi2ur::piQueueGetInfo) - _PI_CL(piQueueFinish, pi2ur::piQueueFinish) - _PI_CL(piQueueFlush, pi2ur::piQueueFlush) - _PI_CL(piQueueRetain, pi2ur::piQueueRetain) - _PI_CL(piQueueRelease, pi2ur::piQueueRelease) - _PI_CL(piextQueueGetNativeHandle, pi2ur::piextQueueGetNativeHandle) - _PI_CL(piextQueueCreateWithNativeHandle, - pi2ur::piextQueueCreateWithNativeHandle) - // Memory - _PI_CL(piMemBufferCreate, pi2ur::piMemBufferCreate) - _PI_CL(piMemImageCreate, pi2ur::piMemImageCreate) - _PI_CL(piMemGetInfo, pi2ur::piMemGetInfo) - _PI_CL(piMemImageGetInfo, pi2ur::piMemImageGetInfo) - _PI_CL(piMemRetain, pi2ur::piMemRetain) - _PI_CL(piMemRelease, pi2ur::piMemRelease) - _PI_CL(piMemBufferPartition, pi2ur::piMemBufferPartition) - _PI_CL(piextMemGetNativeHandle, pi2ur::piextMemGetNativeHandle) - _PI_CL(piextMemCreateWithNativeHandle, pi2ur::piextMemCreateWithNativeHandle) - - // Program - _PI_CL(piProgramCreate, pi2ur::piProgramCreate) - _PI_CL(piProgramCreateWithBinary, pi2ur::piProgramCreateWithBinary) - _PI_CL(piProgramGetInfo, pi2ur::piProgramGetInfo) - _PI_CL(piProgramCompile, pi2ur::piProgramCompile) - _PI_CL(piProgramBuild, pi2ur::piProgramBuild) - _PI_CL(piProgramLink, pi2ur::piProgramLink) - _PI_CL(piProgramGetBuildInfo, pi2ur::piProgramGetBuildInfo) - _PI_CL(piProgramRetain, pi2ur::piProgramRetain) - _PI_CL(piProgramRelease, pi2ur::piProgramRelease) - _PI_CL(piextProgramGetNativeHandle, pi2ur::piextProgramGetNativeHandle) - _PI_CL(piextProgramCreateWithNativeHandle, - pi2ur::piextProgramCreateWithNativeHandle) - _PI_CL(piextProgramSetSpecializationConstant, - pi2ur::piextProgramSetSpecializationConstant) - // Kernel - _PI_CL(piKernelCreate, pi2ur::piKernelCreate) - _PI_CL(piKernelSetArg, pi2ur::piKernelSetArg) - _PI_CL(piKernelGetInfo, pi2ur::piKernelGetInfo) - _PI_CL(piKernelGetGroupInfo, pi2ur::piKernelGetGroupInfo) - _PI_CL(piKernelGetSubGroupInfo, pi2ur::piKernelGetSubGroupInfo) - _PI_CL(piKernelRetain, pi2ur::piKernelRetain) - _PI_CL(piKernelRelease, pi2ur::piKernelRelease) - _PI_CL(piextKernelGetNativeHandle, pi2ur::piextKernelGetNativeHandle) - _PI_CL(piKernelSetExecInfo, pi2ur::piKernelSetExecInfo) - _PI_CL(piextKernelSetArgPointer, pi2ur::piKernelSetArgPointer) - _PI_CL(piextKernelCreateWithNativeHandle, - pi2ur::piextKernelCreateWithNativeHandle) - - // Event - _PI_CL(piEventCreate, pi2ur::piEventCreate) - _PI_CL(piEventGetInfo, pi2ur::piEventGetInfo) - _PI_CL(piEventGetProfilingInfo, pi2ur::piEventGetProfilingInfo) - _PI_CL(piEventsWait, pi2ur::piEventsWait) - _PI_CL(piEventSetCallback, pi2ur::piEventSetCallback) - _PI_CL(piEventSetStatus, pi2ur::piEventSetStatus) - _PI_CL(piEventRetain, pi2ur::piEventRetain) - _PI_CL(piEventRelease, pi2ur::piEventRelease) - _PI_CL(piextEventGetNativeHandle, pi2ur::piextEventGetNativeHandle) - _PI_CL(piextEventCreateWithNativeHandle, - pi2ur::piextEventCreateWithNativeHandle) - // Sampler - _PI_CL(piSamplerCreate, pi2ur::piSamplerCreate) - _PI_CL(piSamplerGetInfo, pi2ur::piSamplerGetInfo) - _PI_CL(piSamplerRetain, pi2ur::piSamplerRetain) - _PI_CL(piSamplerRelease, pi2ur::piSamplerRelease) - // Queue commands - _PI_CL(piEnqueueKernelLaunch, pi2ur::piEnqueueKernelLaunch) - _PI_CL(piEnqueueEventsWait, pi2ur::piEnqueueEventsWait) - _PI_CL(piEnqueueEventsWaitWithBarrier, pi2ur::piEnqueueEventsWaitWithBarrier) - _PI_CL(piEnqueueMemBufferRead, pi2ur::piEnqueueMemBufferRead) - _PI_CL(piEnqueueMemBufferReadRect, pi2ur::piEnqueueMemBufferReadRect) - _PI_CL(piEnqueueMemBufferWrite, pi2ur::piEnqueueMemBufferWrite) - _PI_CL(piEnqueueMemBufferWriteRect, pi2ur::piEnqueueMemBufferWriteRect) - _PI_CL(piEnqueueMemBufferCopy, pi2ur::piEnqueueMemBufferCopy) - _PI_CL(piEnqueueMemBufferCopyRect, pi2ur::piEnqueueMemBufferCopyRect) - _PI_CL(piEnqueueMemBufferFill, pi2ur::piEnqueueMemBufferFill) - _PI_CL(piEnqueueMemImageRead, pi2ur::piEnqueueMemImageRead) - _PI_CL(piEnqueueMemImageWrite, pi2ur::piEnqueueMemImageWrite) - _PI_CL(piEnqueueMemImageCopy, pi2ur::piEnqueueMemImageCopy) - _PI_CL(piEnqueueMemImageFill, pi2ur::piEnqueueMemImageFill) - _PI_CL(piEnqueueMemBufferMap, pi2ur::piEnqueueMemBufferMap) - _PI_CL(piEnqueueMemUnmap, pi2ur::piEnqueueMemUnmap) - - // USM - _PI_CL(piextUSMHostAlloc, pi2ur::piextUSMHostAlloc) - _PI_CL(piextUSMDeviceAlloc, pi2ur::piextUSMDeviceAlloc) - _PI_CL(piextUSMSharedAlloc, pi2ur::piextUSMSharedAlloc) - _PI_CL(piextUSMPitchedAlloc, pi2ur::piextUSMPitchedAlloc) - _PI_CL(piextUSMFree, pi2ur::piextUSMFree) - _PI_CL(piextUSMEnqueueMemset, pi2ur::piextUSMEnqueueMemset) - _PI_CL(piextUSMEnqueueMemcpy, pi2ur::piextUSMEnqueueMemcpy) - _PI_CL(piextUSMEnqueuePrefetch, pi2ur::piextUSMEnqueuePrefetch) - _PI_CL(piextUSMEnqueueMemAdvise, pi2ur::piextUSMEnqueueMemAdvise) - _PI_CL(piextUSMEnqueueFill2D, pi2ur::piextUSMEnqueueFill2D) - _PI_CL(piextUSMEnqueueMemset2D, pi2ur::piextUSMEnqueueMemset2D) - _PI_CL(piextUSMEnqueueMemcpy2D, pi2ur::piextUSMEnqueueMemcpy2D) - _PI_CL(piextUSMGetMemAllocInfo, pi2ur::piextUSMGetMemAllocInfo) - _PI_CL(piextUSMImport, pi2ur::piextUSMImport) - _PI_CL(piextUSMRelease, pi2ur::piextUSMRelease) - // Device global variable - _PI_CL(piextEnqueueDeviceGlobalVariableWrite, - pi2ur::piextEnqueueDeviceGlobalVariableWrite) - _PI_CL(piextEnqueueDeviceGlobalVariableRead, - pi2ur::piextEnqueueDeviceGlobalVariableRead) - - // Host Pipe - _PI_CL(piextEnqueueReadHostPipe, pi2ur::piextEnqueueReadHostPipe) - _PI_CL(piextEnqueueWriteHostPipe, pi2ur::piextEnqueueWriteHostPipe) - - _PI_CL(piextKernelSetArgMemObj, pi2ur::piextKernelSetArgMemObj) - _PI_CL(piextKernelSetArgSampler, pi2ur::piextKernelSetArgSampler) - _PI_CL(piPluginGetLastError, pi2ur::piPluginGetLastError) - _PI_CL(piTearDown, pi2ur::piTearDown) - _PI_CL(piGetDeviceAndHostTimer, pi2ur::piGetDeviceAndHostTimer) - _PI_CL(piPluginGetBackendOption, pi2ur::piPluginGetBackendOption) - - // command-buffer - _PI_CL(piextCommandBufferCreate, pi2ur::piextCommandBufferCreate) - _PI_CL(piextCommandBufferRetain, pi2ur::piextCommandBufferRetain) - _PI_CL(piextCommandBufferRelease, pi2ur::piextCommandBufferRelease) - _PI_CL(piextCommandBufferNDRangeKernel, - pi2ur::piextCommandBufferNDRangeKernel) - _PI_CL(piextCommandBufferMemcpyUSM, pi2ur::piextCommandBufferMemcpyUSM) - _PI_CL(piextCommandBufferMemBufferCopy, - pi2ur::piextCommandBufferMemBufferCopy) - _PI_CL(piextCommandBufferMemBufferCopyRect, - pi2ur::piextCommandBufferMemBufferCopyRect) - _PI_CL(piextEnqueueCommandBuffer, pi2ur::piextEnqueueCommandBuffer) - - // Peer to Peer - _PI_CL(piextEnablePeerAccess, pi2ur::piextEnablePeerAccess) - _PI_CL(piextDisablePeerAccess, pi2ur::piextDisablePeerAccess) - _PI_CL(piextPeerAccessGetInfo, pi2ur::piextPeerAccessGetInfo) - - // Bindless Images - _PI_CL(piextMemUnsampledImageHandleDestroy, - pi2ur::piextMemUnsampledImageHandleDestroy) - _PI_CL(piextMemSampledImageHandleDestroy, - pi2ur::piextMemSampledImageHandleDestroy) - _PI_CL(piextMemImageAllocate, pi2ur::piextMemImageAllocate) - _PI_CL(piextMemImageFree, pi2ur::piextMemImageFree) - _PI_CL(piextMemUnsampledImageCreate, pi2ur::piextMemUnsampledImageCreate) - _PI_CL(piextMemSampledImageCreate, pi2ur::piextMemSampledImageCreate) - _PI_CL(piextBindlessImageSamplerCreate, - pi2ur::piextBindlessImageSamplerCreate) - _PI_CL(piextMemImageCopy, pi2ur::piextMemImageCopy) - _PI_CL(piextMemImageGetInfo, pi2ur::piextMemImageGetInfo) - - _PI_CL(piextMemMipmapGetLevel, pi2ur::piextMemMipmapGetLevel) - _PI_CL(piextMemMipmapFree, pi2ur::piextMemMipmapFree) - - _PI_CL(piextMemImportOpaqueFD, pi2ur::piextMemImportOpaqueFD) - _PI_CL(piextMemReleaseInterop, pi2ur::piextMemReleaseInterop) - _PI_CL(piextMemMapExternalArray, pi2ur::piextMemMapExternalArray) - _PI_CL(piextImportExternalSemaphoreOpaqueFD, - pi2ur::piextImportExternalSemaphoreOpaqueFD) - _PI_CL(piextDestroyExternalSemaphore, pi2ur::piextDestroyExternalSemaphore) - _PI_CL(piextWaitExternalSemaphore, pi2ur::piextWaitExternalSemaphore) - _PI_CL(piextSignalExternalSemaphore, pi2ur::piextSignalExternalSemaphore) - -#undef _PI_CL +#define _PI_API(api) \ + (PluginInit->PiFunctionTable).api = (decltype(&::api))(&api); +#include +#undef _PI_API return PI_SUCCESS; } diff --git a/sycl/plugins/hip/CMakeLists.txt b/sycl/plugins/hip/CMakeLists.txt index 6f9bcbcd71818..a75de97f4b118 100644 --- a/sycl/plugins/hip/CMakeLists.txt +++ b/sycl/plugins/hip/CMakeLists.txt @@ -92,6 +92,8 @@ add_sycl_plugin(hip "../unified_runtime/pi2ur.cpp" "../unified_runtime/ur/ur.hpp" "../unified_runtime/ur/ur.cpp" + "../unified_runtime/ur/adapters/hip/command_buffer.cpp" + "../unified_runtime/ur/adapters/hip/command_buffer.hpp" "../unified_runtime/ur/adapters/hip/common.cpp" "../unified_runtime/ur/adapters/hip/common.hpp" "../unified_runtime/ur/adapters/hip/context.cpp" @@ -101,23 +103,22 @@ add_sycl_plugin(hip "../unified_runtime/ur/adapters/hip/enqueue.cpp" "../unified_runtime/ur/adapters/hip/event.cpp" "../unified_runtime/ur/adapters/hip/event.hpp" - "../unified_runtime/ur/adapters/hip/platform.cpp" - "../unified_runtime/ur/adapters/hip/platform.hpp" + "../unified_runtime/ur/adapters/hip/image.cpp" + "../unified_runtime/ur/adapters/hip/kernel.cpp" + "../unified_runtime/ur/adapters/hip/kernel.hpp" "../unified_runtime/ur/adapters/hip/memory.cpp" "../unified_runtime/ur/adapters/hip/memory.hpp" - "../unified_runtime/ur/adapters/hip/sampler.cpp" - "../unified_runtime/ur/adapters/hip/sampler.hpp" - "../unified_runtime/ur/adapters/hip/usm.cpp" + "../unified_runtime/ur/adapters/hip/platform.cpp" + "../unified_runtime/ur/adapters/hip/platform.hpp" "../unified_runtime/ur/adapters/hip/program.cpp" "../unified_runtime/ur/adapters/hip/program.hpp" - "../unified_runtime/ur/adapters/hip/kernel.cpp" - "../unified_runtime/ur/adapters/hip/kernel.hpp" "../unified_runtime/ur/adapters/hip/queue.cpp" "../unified_runtime/ur/adapters/hip/queue.hpp" - "../unified_runtime/ur/adapters/hip/command_buffer.cpp" - "../unified_runtime/ur/adapters/hip/command_buffer.hpp" - "../unified_runtime/ur/adapters/hip/usm_p2p.cpp" + "../unified_runtime/ur/adapters/hip/sampler.cpp" + "../unified_runtime/ur/adapters/hip/sampler.hpp" "../unified_runtime/ur/adapters/hip/ur_interface_loader.cpp" + "../unified_runtime/ur/adapters/hip/usm.cpp" + "../unified_runtime/ur/adapters/hip/usm_p2p.cpp" "${sycl_inc_dir}/sycl/detail/pi.h" "${sycl_inc_dir}/sycl/detail/pi.hpp" "pi_hip.hpp" diff --git a/sycl/plugins/hip/pi_hip.cpp b/sycl/plugins/hip/pi_hip.cpp index 9cda2ae64061c..7095526dc1d34 100644 --- a/sycl/plugins/hip/pi_hip.cpp +++ b/sycl/plugins/hip/pi_hip.cpp @@ -30,6 +30,1165 @@ //-- PI API implementation extern "C" { +pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, + pi_uint32 *NumPlatforms) { + return pi2ur::piPlatformsGet(NumEntries, Platforms, NumPlatforms); +} + +pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piPlatformGetInfo(Platform, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piextPlatformGetNativeHandle(pi_platform Platform, + pi_native_handle *NativeHandle) { + return pi2ur::piextPlatformGetNativeHandle(Platform, NativeHandle); +} + +pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_platform *Platform) { + return pi2ur::piextPlatformCreateWithNativeHandle(NativeHandle, Platform); +} + +pi_result piPluginGetLastError(char **message) { + return pi2ur::piPluginGetLastError(message); +} + +pi_result piPluginGetBackendOption(pi_platform platform, + const char *frontend_option, + const char **backend_option) { + return pi2ur::piPluginGetBackendOption(platform, frontend_option, + backend_option); +} + +pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, + pi_uint32 NumEntries, pi_device *Devices, + pi_uint32 *NumDevices) { + return pi2ur::piDevicesGet(Platform, DeviceType, NumEntries, Devices, + NumDevices); +} + +pi_result piDeviceRetain(pi_device Device) { + return pi2ur::piDeviceRetain(Device); +} + +pi_result piDeviceRelease(pi_device Device) { + return pi2ur::piDeviceRelease(Device); +} + +pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piDeviceGetInfo(Device, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piDevicePartition(pi_device Device, + const pi_device_partition_property *Properties, + pi_uint32 NumDevices, pi_device *OutDevices, + pi_uint32 *OutNumDevices) { + return pi2ur::piDevicePartition(Device, Properties, NumDevices, OutDevices, + OutNumDevices); +} + +pi_result piextDeviceSelectBinary(pi_device Device, pi_device_binary *Binaries, + pi_uint32 NumBinaries, + pi_uint32 *SelectedBinaryInd) { + return pi2ur::piextDeviceSelectBinary(Device, Binaries, NumBinaries, + SelectedBinaryInd); +} + +pi_result piextDeviceGetNativeHandle(pi_device Device, + pi_native_handle *NativeHandle) { + + return pi2ur::piextDeviceGetNativeHandle(Device, NativeHandle); +} + +pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_platform Platform, + pi_device *Device) { + + return pi2ur::piextDeviceCreateWithNativeHandle(NativeHandle, Platform, + Device); +} + +pi_result piContextCreate(const pi_context_properties *Properties, + pi_uint32 NumDevices, const pi_device *Devices, + void (*PFnNotify)(const char *ErrInfo, + const void *PrivateInfo, size_t CB, + void *UserData), + void *UserData, pi_context *RetContext) { + return pi2ur::piContextCreate(Properties, NumDevices, Devices, PFnNotify, + UserData, RetContext); +} + +pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piContextGetInfo(Context, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piextContextSetExtendedDeleter(pi_context Context, + pi_context_extended_deleter Function, + void *UserData) { + return pi2ur::piextContextSetExtendedDeleter(Context, Function, UserData); +} + +pi_result piextContextGetNativeHandle(pi_context Context, + pi_native_handle *NativeHandle) { + return pi2ur::piextContextGetNativeHandle(Context, NativeHandle); +} + +pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_uint32 NumDevices, + const pi_device *Devices, + bool OwnNativeHandle, + pi_context *RetContext) { + return pi2ur::piextContextCreateWithNativeHandle( + NativeHandle, NumDevices, Devices, OwnNativeHandle, RetContext); +} + +pi_result piContextRetain(pi_context Context) { + + return pi2ur::piContextRetain(Context); +} + +pi_result piContextRelease(pi_context Context) { + return pi2ur::piContextRelease(Context); +} + +pi_result piQueueCreate(pi_context Context, pi_device Device, + pi_queue_properties Flags, pi_queue *Queue) { + pi_queue_properties Properties[] = {PI_QUEUE_FLAGS, Flags, 0}; + return piextQueueCreate(Context, Device, Properties, Queue); +} + +pi_result piextQueueCreate(pi_context Context, pi_device Device, + pi_queue_properties *Properties, pi_queue *Queue) { + return pi2ur::piextQueueCreate(Context, Device, Properties, Queue); +} + +pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piQueueGetInfo(Queue, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piQueueRetain(pi_queue Queue) { return pi2ur::piQueueRetain(Queue); } + +pi_result piQueueRelease(pi_queue Queue) { + return pi2ur::piQueueRelease(Queue); +} + +pi_result piQueueFinish(pi_queue Queue) { return pi2ur::piQueueFinish(Queue); } + +pi_result piQueueFlush(pi_queue Queue) { return pi2ur::piQueueFlush(Queue); } + +pi_result piextQueueGetNativeHandle(pi_queue Queue, + pi_native_handle *NativeHandle, + int32_t *NativeHandleDesc) { + + return pi2ur::piextQueueGetNativeHandle(Queue, NativeHandle, + NativeHandleDesc); +} + +pi_result piextQueueCreateWithNativeHandle(pi_native_handle NativeHandle, + int32_t NativeHandleDesc, + pi_context Context, pi_device Device, + bool OwnNativeHandle, + pi_queue_properties *Properties, + pi_queue *Queue) { + + return pi2ur::piextQueueCreateWithNativeHandle( + NativeHandle, NativeHandleDesc, Context, Device, OwnNativeHandle, + Properties, Queue); +} + +pi_result piMemBufferCreate(pi_context Context, pi_mem_flags Flags, size_t Size, + void *HostPtr, pi_mem *RetMem, + const pi_mem_properties *properties) { + return pi2ur::piMemBufferCreate(Context, Flags, Size, HostPtr, RetMem, + properties); +} + +pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, + void *ParamValue, size_t *ParamValueSizeRet) { + return pi2ur::piMemGetInfo(Mem, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piMemRetain(pi_mem Mem) { return pi2ur::piMemRetain(Mem); } + +pi_result piMemRelease(pi_mem Mem) { return pi2ur::piMemRelease(Mem); } + +pi_result piMemImageCreate(pi_context Context, pi_mem_flags Flags, + const pi_image_format *ImageFormat, + const pi_image_desc *ImageDesc, void *HostPtr, + pi_mem *RetImage) { + + return pi2ur::piMemImageCreate(Context, Flags, ImageFormat, ImageDesc, + HostPtr, RetImage); +} + +pi_result piextMemGetNativeHandle(pi_mem Mem, pi_native_handle *NativeHandle) { + return pi2ur::piextMemGetNativeHandle(Mem, NativeHandle); +} + +pi_result piextMemCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + bool ownNativeHandle, pi_mem *Mem) { + return pi2ur::piextMemCreateWithNativeHandle(NativeHandle, Context, + ownNativeHandle, Mem); +} + +pi_result piProgramCreate(pi_context Context, const void *ILBytes, + size_t Length, pi_program *Program) { + return pi2ur::piProgramCreate(Context, ILBytes, Length, Program); +} + +pi_result piProgramCreateWithBinary( + pi_context Context, pi_uint32 NumDevices, const pi_device *DeviceList, + const size_t *Lengths, const unsigned char **Binaries, + size_t NumMetadataEntries, const pi_device_binary_property *Metadata, + pi_int32 *BinaryStatus, pi_program *Program) { + + return pi2ur::piProgramCreateWithBinary(Context, NumDevices, DeviceList, + Lengths, Binaries, NumMetadataEntries, + Metadata, BinaryStatus, Program); +} + +pi_result piextMemImageCreateWithNativeHandle( + pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, + const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc, + pi_mem *Img) { + return pi2ur::piextMemImageCreateWithNativeHandle( + NativeHandle, Context, OwnNativeHandle, ImageFormat, ImageDesc, Img); +} + +pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piProgramGetInfo(Program, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piProgramLink(pi_context Context, pi_uint32 NumDevices, + const pi_device *DeviceList, const char *Options, + pi_uint32 NumInputPrograms, + const pi_program *InputPrograms, + void (*PFnNotify)(pi_program Program, void *UserData), + void *UserData, pi_program *RetProgram) { + return pi2ur::piProgramLink(Context, NumDevices, DeviceList, Options, + NumInputPrograms, InputPrograms, PFnNotify, + UserData, RetProgram); +} + +pi_result piProgramCompile( + pi_program Program, pi_uint32 NumDevices, const pi_device *DeviceList, + const char *Options, pi_uint32 NumInputHeaders, + const pi_program *InputHeaders, const char **HeaderIncludeNames, + void (*PFnNotify)(pi_program Program, void *UserData), void *UserData) { + + return pi2ur::piProgramCompile(Program, NumDevices, DeviceList, Options, + NumInputHeaders, InputHeaders, + HeaderIncludeNames, PFnNotify, UserData); +} + +pi_result piProgramBuild(pi_program Program, pi_uint32 NumDevices, + const pi_device *DeviceList, const char *Options, + void (*PFnNotify)(pi_program Program, void *UserData), + void *UserData) { + return pi2ur::piProgramBuild(Program, NumDevices, DeviceList, Options, + PFnNotify, UserData); +} + +pi_result piProgramGetBuildInfo(pi_program Program, pi_device Device, + pi_program_build_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piProgramGetBuildInfo(Program, Device, ParamName, + ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piProgramRetain(pi_program Program) { + return pi2ur::piProgramRetain(Program); +} + +pi_result piProgramRelease(pi_program Program) { + return pi2ur::piProgramRelease(Program); +} + +pi_result piextProgramGetNativeHandle(pi_program Program, + pi_native_handle *NativeHandle) { + return pi2ur::piextProgramGetNativeHandle(Program, NativeHandle); +} + +pi_result piextProgramCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + bool OwnNativeHandle, + pi_program *Program) { + return pi2ur::piextProgramCreateWithNativeHandle(NativeHandle, Context, + OwnNativeHandle, Program); +} + +pi_result piKernelCreate(pi_program Program, const char *KernelName, + pi_kernel *RetKernel) { + + return pi2ur::piKernelCreate(Program, KernelName, RetKernel); +} + +pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, + const void *ArgValue) { + + return pi2ur::piKernelSetArg(Kernel, ArgIndex, ArgSize, ArgValue); +} + +pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, + const pi_mem_obj_property *ArgProperties, + const pi_mem *ArgValue) { + return pi2ur::piextKernelSetArgMemObj(Kernel, ArgIndex, ArgProperties, + ArgValue); +} + +pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, + const pi_sampler *ArgValue) { + + return pi2ur::piextKernelSetArgSampler(Kernel, ArgIndex, ArgValue); +} + +pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piKernelGetInfo(Kernel, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +__SYCL_EXPORT pi_result piextMemImageAllocate(pi_context Context, + pi_device Device, + pi_image_format *ImageFormat, + pi_image_desc *ImageDesc, + pi_image_mem_handle *RetMem) { + return pi2ur::piextMemImageAllocate(Context, Device, ImageFormat, ImageDesc, + RetMem); +} + +__SYCL_EXPORT pi_result piextMemUnsampledImageCreate( + pi_context Context, pi_device Device, pi_image_mem_handle ImgMem, + pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_mem *RetMem, + pi_image_handle *RetHandle) { + return pi2ur::piextMemUnsampledImageCreate( + Context, Device, ImgMem, ImageFormat, ImageDesc, RetMem, RetHandle); +} + +__SYCL_EXPORT pi_result piextMemSampledImageCreate( + pi_context Context, pi_device Device, pi_image_mem_handle ImgMem, + pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_sampler Sampler, + pi_mem *RetMem, pi_image_handle *RetHandle) { + return pi2ur::piextMemSampledImageCreate(Context, Device, ImgMem, ImageFormat, + ImageDesc, Sampler, RetMem, + RetHandle); +} + +__SYCL_EXPORT pi_result piextBindlessImageSamplerCreate( + pi_context Context, const pi_sampler_properties *SamplerProperties, + float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy, + pi_sampler *RetSampler) { + return pi2ur::piextBindlessImageSamplerCreate( + Context, SamplerProperties, MinMipmapLevelClamp, MaxMipmapLevelClamp, + MaxAnisotropy, RetSampler); +} + +__SYCL_EXPORT pi_result piextMemMipmapGetLevel(pi_context Context, + pi_device Device, + pi_image_mem_handle MipMem, + unsigned int Level, + pi_image_mem_handle *RetMem) { + return pi2ur::piextMemMipmapGetLevel(Context, Device, MipMem, Level, RetMem); +} + +__SYCL_EXPORT pi_result piextMemImageFree(pi_context Context, pi_device Device, + pi_image_mem_handle MemoryHandle) { + return pi2ur::piextMemImageFree(Context, Device, MemoryHandle); +} + +__SYCL_EXPORT pi_result piextMemMipmapFree(pi_context Context, pi_device Device, + pi_image_mem_handle MemoryHandle) { + return pi2ur::piextMemMipmapFree(Context, Device, MemoryHandle); +} + +__SYCL_EXPORT pi_result piextMemImageCopy( + pi_queue Queue, void *DstPtr, void *SrcPtr, + const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc, + const pi_image_copy_flags Flags, pi_image_offset SrcOffset, + pi_image_offset DstOffset, pi_image_region CopyExtent, + pi_image_region HostExtent, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *Event) { + return pi2ur::piextMemImageCopy(Queue, DstPtr, SrcPtr, ImageFormat, ImageDesc, + Flags, SrcOffset, DstOffset, CopyExtent, + HostExtent, NumEventsInWaitList, + EventWaitList, Event); +} + +__SYCL_EXPORT pi_result piextMemUnsampledImageHandleDestroy( + pi_context Context, pi_device Device, pi_image_handle Handle) { + return pi2ur::piextMemUnsampledImageHandleDestroy(Context, Device, Handle); +} + +__SYCL_EXPORT pi_result piextMemSampledImageHandleDestroy( + pi_context Context, pi_device Device, pi_image_handle Handle) { + return pi2ur::piextMemSampledImageHandleDestroy(Context, Device, Handle); +} + +__SYCL_EXPORT pi_result piextMemImageGetInfo(pi_image_mem_handle MemHandle, + pi_image_info ParamName, + void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piextMemImageGetInfo(MemHandle, ParamName, ParamValue, + ParamValueSizeRet); +} + +__SYCL_EXPORT pi_result +piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size, + int FileDescriptor, pi_interop_mem_handle *RetHandle) { + return pi2ur::piextMemImportOpaqueFD(Context, Device, Size, FileDescriptor, + RetHandle); +} + +__SYCL_EXPORT pi_result piextMemMapExternalArray( + pi_context Context, pi_device Device, pi_image_format *ImageFormat, + pi_image_desc *ImageDesc, pi_interop_mem_handle MemHandle, + pi_image_mem_handle *RetMem) { + return pi2ur::piextMemMapExternalArray(Context, Device, ImageFormat, + ImageDesc, MemHandle, RetMem); +} + +__SYCL_EXPORT pi_result piextMemReleaseInterop(pi_context Context, + pi_device Device, + pi_interop_mem_handle ExtMem) { + return pi2ur::piextMemReleaseInterop(Context, Device, ExtMem); +} + +__SYCL_EXPORT pi_result piextImportExternalSemaphoreOpaqueFD( + pi_context Context, pi_device Device, int FileDescriptor, + pi_interop_semaphore_handle *RetHandle) { + return pi2ur::piextImportExternalSemaphoreOpaqueFD(Context, Device, + FileDescriptor, RetHandle); +} + +__SYCL_EXPORT pi_result +piextDestroyExternalSemaphore(pi_context Context, pi_device Device, + pi_interop_semaphore_handle SemHandle) { + return pi2ur::piextDestroyExternalSemaphore(Context, Device, SemHandle); +} + +__SYCL_EXPORT pi_result piextWaitExternalSemaphore( + pi_queue Queue, pi_interop_semaphore_handle SemHandle, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piextWaitExternalSemaphore( + Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event); +} + +__SYCL_EXPORT pi_result piextSignalExternalSemaphore( + pi_queue Queue, pi_interop_semaphore_handle SemHandle, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piextSignalExternalSemaphore( + Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piKernelGetGroupInfo(pi_kernel Kernel, pi_device Device, + pi_kernel_group_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piKernelGetGroupInfo(Kernel, Device, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piKernelGetSubGroupInfo(pi_kernel Kernel, pi_device Device, + pi_kernel_sub_group_info ParamName, + size_t InputValueSize, const void *InputValue, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piKernelGetSubGroupInfo( + Kernel, Device, ParamName, InputValueSize, InputValue, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piKernelRetain(pi_kernel Kernel) { + + return pi2ur::piKernelRetain(Kernel); +} + +pi_result piKernelRelease(pi_kernel Kernel) { + + return pi2ur::piKernelRelease(Kernel); +} + +pi_result +piEnqueueKernelLaunch(pi_queue Queue, pi_kernel Kernel, pi_uint32 WorkDim, + const size_t *GlobalWorkOffset, + const size_t *GlobalWorkSize, const size_t *LocalWorkSize, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *OutEvent) { + return pi2ur::piEnqueueKernelLaunch( + Queue, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, LocalWorkSize, + NumEventsInWaitList, EventWaitList, OutEvent); +} + +pi_result piextKernelCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + pi_program Program, + bool OwnNativeHandle, + pi_kernel *Kernel) { + + return pi2ur::piextKernelCreateWithNativeHandle( + NativeHandle, Context, Program, OwnNativeHandle, Kernel); +} + +pi_result piextKernelGetNativeHandle(pi_kernel Kernel, + pi_native_handle *NativeHandle) { + return pi2ur::piextKernelGetNativeHandle(Kernel, NativeHandle); +} + +pi_result piEventCreate(pi_context Context, pi_event *RetEvent) { + return pi2ur::piEventCreate(Context, RetEvent); +} + +pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piEventGetInfo(Event, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piEventGetProfilingInfo(Event, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList) { + return pi2ur::piEventsWait(NumEvents, EventList); +} + +pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, + void (*PFnNotify)(pi_event Event, + pi_int32 EventCommandStatus, + void *UserData), + void *UserData) { + return pi2ur::piEventSetCallback(Event, CommandExecCallbackType, PFnNotify, + UserData); +} + +pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus) { + return pi2ur::piEventSetStatus(Event, ExecutionStatus); +} + +pi_result piEventRetain(pi_event Event) { return pi2ur::piEventRetain(Event); } + +pi_result piEventRelease(pi_event Event) { + return pi2ur::piEventRelease(Event); +} + +pi_result piextEventGetNativeHandle(pi_event Event, + pi_native_handle *NativeHandle) { + + return pi2ur::piextEventGetNativeHandle(Event, NativeHandle); +} + +pi_result piextEventCreateWithNativeHandle(pi_native_handle NativeHandle, + pi_context Context, + bool OwnNativeHandle, + pi_event *Event) { + return pi2ur::piextEventCreateWithNativeHandle(NativeHandle, Context, + OwnNativeHandle, Event); +} + +pi_result piSamplerCreate(pi_context Context, + const pi_sampler_properties *SamplerProperties, + pi_sampler *RetSampler) { + return pi2ur::piSamplerCreate(Context, SamplerProperties, RetSampler); +} + +pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piSamplerGetInfo(Sampler, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piSamplerRetain(pi_sampler Sampler) { + return pi2ur::piSamplerRetain(Sampler); +} + +pi_result piSamplerRelease(pi_sampler Sampler) { + return pi2ur::piSamplerRelease(Sampler); +} + +pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent) { + + return pi2ur::piEnqueueEventsWait(Queue, NumEventsInWaitList, EventWaitList, + OutEvent); +} + +pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent) { + + return pi2ur::piEnqueueEventsWaitWithBarrier(Queue, NumEventsInWaitList, + EventWaitList, OutEvent); +} + +pi_result piEnqueueMemBufferRead(pi_queue Queue, pi_mem Src, + pi_bool BlockingRead, size_t Offset, + size_t Size, void *Dst, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferRead(Queue, Src, BlockingRead, Offset, Size, + Dst, NumEventsInWaitList, EventWaitList, + Event); +} + +pi_result piEnqueueMemBufferReadRect( + pi_queue Queue, pi_mem Buffer, pi_bool BlockingRead, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, void *Ptr, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferReadRect( + Queue, Buffer, BlockingRead, BufferOffset, HostOffset, Region, + BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piEnqueueMemBufferWrite(pi_queue Queue, pi_mem Buffer, + pi_bool BlockingWrite, size_t Offset, + size_t Size, const void *Ptr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferWrite(Queue, Buffer, BlockingWrite, Offset, + Size, Ptr, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferWriteRect( + pi_queue Queue, pi_mem Buffer, pi_bool BlockingWrite, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr, + pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferWriteRect( + Queue, Buffer, BlockingWrite, BufferOffset, HostOffset, Region, + BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piEnqueueMemBufferCopy(pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, + size_t SrcOffset, size_t DstOffset, + size_t Size, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferCopy(Queue, SrcMem, DstMem, SrcOffset, + DstOffset, Size, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferCopyRect( + pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, pi_buff_rect_offset SrcOrigin, + pi_buff_rect_offset DstOrigin, pi_buff_rect_region Region, + size_t SrcRowPitch, size_t SrcSlicePitch, size_t DstRowPitch, + size_t DstSlicePitch, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *Event) { + + return pi2ur::piEnqueueMemBufferCopyRect( + Queue, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch, + SrcSlicePitch, DstRowPitch, DstSlicePitch, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferFill(pi_queue Queue, pi_mem Buffer, + const void *Pattern, size_t PatternSize, + size_t Offset, size_t Size, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemBufferFill(Queue, Buffer, Pattern, PatternSize, + Offset, Size, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemBufferMap(pi_queue Queue, pi_mem Mem, pi_bool BlockingMap, + pi_map_flags MapFlags, size_t Offset, + size_t Size, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent, void **RetMap) { + + return pi2ur::piEnqueueMemBufferMap(Queue, Mem, BlockingMap, MapFlags, Offset, + Size, NumEventsInWaitList, EventWaitList, + OutEvent, RetMap); +} + +pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *OutEvent) { + + return pi2ur::piEnqueueMemUnmap(Queue, Mem, MappedPtr, NumEventsInWaitList, + EventWaitList, OutEvent); +} + +pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + + return pi2ur::piMemImageGetInfo(Image, ParamName, ParamValueSize, ParamValue, + ParamValueSizeRet); +} + +pi_result piEnqueueMemImageRead(pi_queue Queue, pi_mem Image, + pi_bool BlockingRead, pi_image_offset Origin, + pi_image_region Region, size_t RowPitch, + size_t SlicePitch, void *Ptr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piEnqueueMemImageRead( + Queue, Image, BlockingRead, Origin, Region, RowPitch, SlicePitch, Ptr, + NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piEnqueueMemImageWrite(pi_queue Queue, pi_mem Image, + pi_bool BlockingWrite, pi_image_offset Origin, + pi_image_region Region, size_t InputRowPitch, + size_t InputSlicePitch, const void *Ptr, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemImageWrite( + Queue, Image, BlockingWrite, Origin, Region, InputRowPitch, + InputSlicePitch, Ptr, NumEventsInWaitList, EventWaitList, Event); +} + +pi_result +piEnqueueMemImageCopy(pi_queue Queue, pi_mem SrcImage, pi_mem DstImage, + pi_image_offset SrcOrigin, pi_image_offset DstOrigin, + pi_image_region Region, pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, pi_event *Event) { + return pi2ur::piEnqueueMemImageCopy(Queue, SrcImage, DstImage, SrcOrigin, + DstOrigin, Region, NumEventsInWaitList, + EventWaitList, Event); +} + +pi_result piEnqueueMemImageFill(pi_queue Queue, pi_mem Image, + const void *FillColor, const size_t *Origin, + const size_t *Region, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + + return pi2ur::piEnqueueMemImageFill(Queue, Image, FillColor, Origin, Region, + NumEventsInWaitList, EventWaitList, + Event); +} + +pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, + pi_buffer_create_type BufferCreateType, + void *BufferCreateInfo, pi_mem *RetMem) { + + return pi2ur::piMemBufferPartition(Buffer, Flags, BufferCreateType, + BufferCreateInfo, RetMem); +} + +pi_result piextGetDeviceFunctionPointer(pi_device Device, pi_program Program, + const char *FunctionName, + pi_uint64 *FunctionPointerRet) { + return pi2ur::piextGetDeviceFunctionPointer(Device, Program, FunctionName, + FunctionPointerRet); +} + +pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context, + pi_device Device, + pi_usm_mem_properties *Properties, size_t Size, + pi_uint32 Alignment) { + + return pi2ur::piextUSMDeviceAlloc(ResultPtr, Context, Device, Properties, + Size, Alignment); +} + +pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context, + pi_device Device, + pi_usm_mem_properties *Properties, size_t Size, + pi_uint32 Alignment) { + + return pi2ur::piextUSMSharedAlloc(ResultPtr, Context, Device, Properties, + Size, Alignment); +} + +__SYCL_EXPORT pi_result piextUSMPitchedAlloc( + void **ResultPtr, size_t *ResultPitch, pi_context Context, pi_device Device, + pi_usm_mem_properties *Properties, size_t WidthInBytes, size_t Height, + unsigned int ElementSizeBytes) { + + return pi2ur::piextUSMPitchedAlloc(ResultPtr, ResultPitch, Context, Device, + Properties, WidthInBytes, Height, + ElementSizeBytes); +} + +pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context, + pi_usm_mem_properties *Properties, size_t Size, + pi_uint32 Alignment) { + return pi2ur::piextUSMHostAlloc(ResultPtr, Context, Properties, Size, + Alignment); +} + +pi_result piextUSMFree(pi_context Context, void *Ptr) { + + return pi2ur::piextUSMFree(Context, Ptr); +} + +pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, + size_t ArgSize, const void *ArgValue) { + return pi2ur::piextKernelSetArgPointer(Kernel, ArgIndex, ArgSize, ArgValue); +} + +pi_result piextUSMEnqueueMemset(pi_queue Queue, void *Ptr, pi_int32 Value, + size_t Count, pi_uint32 NumEventsInWaitlist, + const pi_event *EventsWaitlist, + pi_event *Event) { + return pi2ur::piextUSMEnqueueMemset( + Queue, Ptr, Value, Count, NumEventsInWaitlist, EventsWaitlist, Event); +} + +pi_result piextUSMEnqueueMemcpy(pi_queue Queue, pi_bool Blocking, void *DstPtr, + const void *SrcPtr, size_t Size, + pi_uint32 NumEventsInWaitlist, + const pi_event *EventsWaitlist, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueMemcpy(Queue, Blocking, DstPtr, SrcPtr, Size, + NumEventsInWaitlist, EventsWaitlist, + Event); +} + +pi_result piextUSMEnqueuePrefetch(pi_queue Queue, const void *Ptr, size_t Size, + pi_usm_migration_flags Flags, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *OutEvent) { + + return pi2ur::piextUSMEnqueuePrefetch( + Queue, Ptr, Size, Flags, NumEventsInWaitList, EventWaitList, OutEvent); +} + +pi_result piextUSMEnqueueMemAdvise(pi_queue Queue, const void *Ptr, + size_t Length, pi_mem_advice Advice, + pi_event *OutEvent) { + + return pi2ur::piextUSMEnqueueMemAdvise(Queue, Ptr, Length, Advice, OutEvent); +} + +__SYCL_EXPORT pi_result piextUSMEnqueueFill2D(pi_queue Queue, void *Ptr, + size_t Pitch, size_t PatternSize, + const void *Pattern, size_t Width, + size_t Height, + pi_uint32 NumEventsWaitList, + const pi_event *EventsWaitList, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueFill2D(Queue, Ptr, Pitch, PatternSize, Pattern, + Width, Height, NumEventsWaitList, + EventsWaitList, Event); +} + +__SYCL_EXPORT pi_result piextUSMEnqueueMemset2D(pi_queue Queue, void *Ptr, + size_t Pitch, int Value, + size_t Width, size_t Height, + pi_uint32 NumEventsWaitList, + const pi_event *EventsWaitlist, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueMemset2D(Queue, Ptr, Pitch, Value, Width, Height, + NumEventsWaitList, EventsWaitlist, + Event); +} + +__SYCL_EXPORT pi_result piextUSMEnqueueMemcpy2D( + pi_queue Queue, pi_bool Blocking, void *DstPtr, size_t DstPitch, + const void *SrcPtr, size_t SrcPitch, size_t Width, size_t Height, + pi_uint32 NumEventsInWaitlist, const pi_event *EventWaitlist, + pi_event *Event) { + + return pi2ur::piextUSMEnqueueMemcpy2D( + Queue, Blocking, DstPtr, DstPitch, SrcPtr, SrcPitch, Width, Height, + NumEventsInWaitlist, EventWaitlist, Event); +} + +pi_result piextUSMGetMemAllocInfo(pi_context Context, const void *Ptr, + pi_mem_alloc_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piextUSMGetMemAllocInfo(Context, Ptr, ParamName, ParamValueSize, + ParamValue, ParamValueSizeRet); +} + +pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context) { + return pi2ur::piextUSMImport(HostPtr, Size, Context); +} + +pi_result piextUSMRelease(const void *HostPtr, pi_context Context) { + return pi2ur::piextUSMRelease(HostPtr, Context); +} + +pi_result piextEnqueueDeviceGlobalVariableWrite( + pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite, + size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, pi_event *Event) { + return pi2ur::piextEnqueueDeviceGlobalVariableWrite( + Queue, Program, Name, BlockingWrite, Count, Offset, Src, + NumEventsInWaitList, EventsWaitList, Event); +} + +pi_result piextEnqueueDeviceGlobalVariableRead( + pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingRead, + size_t Count, size_t Offset, void *Dst, pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, pi_event *Event) { + return pi2ur::piextEnqueueDeviceGlobalVariableRead( + Queue, Program, Name, BlockingRead, Count, Offset, Dst, + NumEventsInWaitList, EventsWaitList, Event); + + return PI_SUCCESS; +} + +pi_result piextEnqueueReadHostPipe(pi_queue Queue, pi_program Program, + const char *PipeSymbol, pi_bool Blocking, + void *Ptr, size_t Size, + pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, + pi_event *Event) { + (void)Queue; + (void)Program; + (void)PipeSymbol; + (void)Blocking; + (void)Ptr; + (void)Size; + (void)NumEventsInWaitList; + (void)EventsWaitList; + (void)Event; + PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE); + die("piextEnqueueReadHostPipe: not implemented"); + return {}; +} + +pi_result piextEnqueueWriteHostPipe(pi_queue Queue, pi_program Program, + const char *PipeSymbol, pi_bool Blocking, + void *Ptr, size_t Size, + pi_uint32 NumEventsInWaitList, + const pi_event *EventsWaitList, + pi_event *Event) { + (void)Queue; + (void)Program; + (void)PipeSymbol; + (void)Blocking; + (void)Ptr; + (void)Size; + (void)NumEventsInWaitList; + (void)EventsWaitList; + (void)Event; + PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE); + die("piextEnqueueWriteHostPipe: not implemented"); + return {}; +} + +pi_result piKernelSetExecInfo(pi_kernel Kernel, pi_kernel_exec_info ParamName, + size_t ParamValueSize, const void *ParamValue) { + + return pi2ur::piKernelSetExecInfo(Kernel, ParamName, ParamValueSize, + ParamValue); +} + +pi_result piextProgramSetSpecializationConstant(pi_program Prog, + pi_uint32 SpecID, size_t Size, + const void *SpecValue) { + return pi2ur::piextProgramSetSpecializationConstant(Prog, SpecID, Size, + SpecValue); +} + +// Command buffer extension +pi_result piextCommandBufferCreate(pi_context Context, pi_device Device, + const pi_ext_command_buffer_desc *Desc, + pi_ext_command_buffer *RetCommandBuffer) { + return pi2ur::piextCommandBufferCreate(Context, Device, Desc, + RetCommandBuffer); +} + +pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer) { + return pi2ur::piextCommandBufferRetain(CommandBuffer); +} + +pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer) { + return pi2ur::piextCommandBufferRelease(CommandBuffer); +} + +pi_result piextCommandBufferFinalize(pi_ext_command_buffer CommandBuffer) { + return pi2ur::piextCommandBufferFinalize(CommandBuffer); +} + +pi_result piextCommandBufferNDRangeKernel( + pi_ext_command_buffer CommandBuffer, pi_kernel Kernel, pi_uint32 WorkDim, + const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize, + const size_t *LocalWorkSize, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferNDRangeKernel( + CommandBuffer, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, + LocalWorkSize, NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemcpyUSM( + pi_ext_command_buffer CommandBuffer, void *DstPtr, const void *SrcPtr, + size_t Size, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemcpyUSM(CommandBuffer, DstPtr, SrcPtr, Size, + NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferCopy( + pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem, + size_t SrcOffset, size_t DstOffset, size_t Size, + pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferCopy( + CommandBuffer, SrcMem, DstMem, SrcOffset, DstOffset, Size, + NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferCopyRect( + pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem, + pi_buff_rect_offset SrcOrigin, pi_buff_rect_offset DstOrigin, + pi_buff_rect_region Region, size_t SrcRowPitch, size_t SrcSlicePitch, + size_t DstRowPitch, size_t DstSlicePitch, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferCopyRect( + CommandBuffer, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch, + SrcSlicePitch, DstRowPitch, DstSlicePitch, NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferRead( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset, + size_t Size, void *Dst, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferRead( + CommandBuffer, Buffer, Offset, Size, Dst, NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferReadRect( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, void *Ptr, + pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferReadRect( + CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch, + BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferWrite( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset, + size_t Size, const void *Ptr, pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferWrite( + CommandBuffer, Buffer, Offset, Size, Ptr, NumSyncPointsInWaitList, + SyncPointWaitList, SyncPoint); +} + +pi_result piextCommandBufferMemBufferWriteRect( + pi_ext_command_buffer CommandBuffer, pi_mem Buffer, + pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset, + pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch, + size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr, + pi_uint32 NumSyncPointsInWaitList, + const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) { + return pi2ur::piextCommandBufferMemBufferWriteRect( + CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch, + BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr, + NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint); +} + +pi_result piextEnqueueCommandBuffer(pi_ext_command_buffer CommandBuffer, + pi_queue Queue, + pi_uint32 NumEventsInWaitList, + const pi_event *EventWaitList, + pi_event *Event) { + return pi2ur::piextEnqueueCommandBuffer( + CommandBuffer, Queue, NumEventsInWaitList, EventWaitList, Event); +} + +pi_result piextPluginGetOpaqueData(void *opaque_data_param, + void **opaque_data_return) { + return pi2ur::piextPluginGetOpaqueData(opaque_data_param, opaque_data_return); +} + +pi_result piTearDown(void *PluginParameter) { + return pi2ur::piTearDown(PluginParameter); +} + +pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime, + uint64_t *HostTime) { + return pi2ur::piGetDeviceAndHostTimer(Device, DeviceTime, HostTime); +} + +pi_result piextEnablePeerAccess(pi_device command_device, + pi_device peer_device) { + + return pi2ur::piextEnablePeerAccess(command_device, peer_device); +} + +pi_result piextDisablePeerAccess(pi_device command_device, + pi_device peer_device) { + + return pi2ur::piextDisablePeerAccess(command_device, peer_device); +} + +pi_result piextPeerAccessGetInfo(pi_device command_device, + pi_device peer_device, pi_peer_attr attr, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { + return pi2ur::piextPeerAccessGetInfo(command_device, peer_device, attr, + ParamValueSize, ParamValue, + ParamValueSizeRet); +} + const char SupportedVersion[] = _PI_HIP_PLUGIN_VERSION_STRING; pi_result piPluginInit(pi_plugin *PluginInit) { @@ -48,171 +1207,10 @@ pi_result piPluginInit(pi_plugin *PluginInit) { sizeof(PluginInit->PiFunctionTable)); // Forward calls to HIP RT. -#define _PI_CL(pi_api, hip_api) \ - (PluginInit->PiFunctionTable).pi_api = (decltype(&::pi_api))(&hip_api); - - // Platform - _PI_CL(piPlatformsGet, pi2ur::piPlatformsGet) - _PI_CL(piPlatformGetInfo, pi2ur::piPlatformGetInfo) - // Device - _PI_CL(piDevicesGet, pi2ur::piDevicesGet) - _PI_CL(piDeviceGetInfo, pi2ur::piDeviceGetInfo) - _PI_CL(piDevicePartition, pi2ur::piDevicePartition) - _PI_CL(piDeviceRetain, pi2ur::piDeviceRetain) - _PI_CL(piDeviceRelease, pi2ur::piDeviceRelease) - _PI_CL(piextDeviceSelectBinary, pi2ur::piextDeviceSelectBinary) - _PI_CL(piextGetDeviceFunctionPointer, pi2ur::piextGetDeviceFunctionPointer) - _PI_CL(piextDeviceGetNativeHandle, pi2ur::piextDeviceGetNativeHandle) - _PI_CL(piextDeviceCreateWithNativeHandle, - pi2ur::piextDeviceCreateWithNativeHandle) - // Context - _PI_CL(piextContextSetExtendedDeleter, pi2ur::piextContextSetExtendedDeleter) - _PI_CL(piContextCreate, pi2ur::piContextCreate) - _PI_CL(piContextGetInfo, pi2ur::piContextGetInfo) - _PI_CL(piContextRetain, pi2ur::piContextRetain) - _PI_CL(piContextRelease, pi2ur::piContextRelease) - _PI_CL(piextContextGetNativeHandle, pi2ur::piextContextGetNativeHandle) - _PI_CL(piextContextCreateWithNativeHandle, - pi2ur::piextContextCreateWithNativeHandle) - // Queue - _PI_CL(piQueueCreate, pi2ur::piQueueCreate) - _PI_CL(piextQueueCreate, pi2ur::piextQueueCreate) - _PI_CL(piQueueGetInfo, pi2ur::piQueueGetInfo) - _PI_CL(piQueueFinish, pi2ur::piQueueFinish) - _PI_CL(piQueueFlush, pi2ur::piQueueFlush) - _PI_CL(piQueueRetain, pi2ur::piQueueRetain) - _PI_CL(piQueueRelease, pi2ur::piQueueRelease) - _PI_CL(piextQueueGetNativeHandle, pi2ur::piextQueueGetNativeHandle) - _PI_CL(piextQueueCreateWithNativeHandle, - pi2ur::piextQueueCreateWithNativeHandle) - // Memory - _PI_CL(piMemBufferCreate, pi2ur::piMemBufferCreate) - _PI_CL(piMemImageCreate, pi2ur::piMemImageCreate) - _PI_CL(piMemGetInfo, pi2ur::piMemGetInfo) - _PI_CL(piMemImageGetInfo, pi2ur::piMemImageGetInfo) - _PI_CL(piMemRetain, pi2ur::piMemRetain) - _PI_CL(piMemRelease, pi2ur::piMemRelease) - _PI_CL(piMemBufferPartition, pi2ur::piMemBufferPartition) - _PI_CL(piextMemGetNativeHandle, pi2ur::piextMemGetNativeHandle) - _PI_CL(piextMemCreateWithNativeHandle, pi2ur::piextMemCreateWithNativeHandle) - // Program - _PI_CL(piProgramCreate, pi2ur::piProgramCreate) - _PI_CL(piProgramCreateWithBinary, pi2ur::piProgramCreateWithBinary) - _PI_CL(piProgramGetInfo, pi2ur::piProgramGetInfo) - _PI_CL(piProgramCompile, pi2ur::piProgramCompile) - _PI_CL(piProgramBuild, pi2ur::piProgramBuild) - _PI_CL(piProgramLink, pi2ur::piProgramLink) - _PI_CL(piProgramGetBuildInfo, pi2ur::piProgramGetBuildInfo) - _PI_CL(piProgramRetain, pi2ur::piProgramRetain) - _PI_CL(piProgramRelease, pi2ur::piProgramRelease) - _PI_CL(piextProgramGetNativeHandle, pi2ur::piextProgramGetNativeHandle) - _PI_CL(piextProgramCreateWithNativeHandle, - pi2ur::piextProgramCreateWithNativeHandle) - _PI_CL(piextProgramSetSpecializationConstant, - pi2ur::piextProgramSetSpecializationConstant) - // Kernel - _PI_CL(piKernelCreate, pi2ur::piKernelCreate) - _PI_CL(piKernelSetArg, pi2ur::piKernelSetArg) - _PI_CL(piKernelGetInfo, pi2ur::piKernelGetInfo) - _PI_CL(piKernelGetGroupInfo, pi2ur::piKernelGetGroupInfo) - _PI_CL(piKernelGetSubGroupInfo, pi2ur::piKernelGetSubGroupInfo) - _PI_CL(piKernelRetain, pi2ur::piKernelRetain) - _PI_CL(piKernelRelease, pi2ur::piKernelRelease) - _PI_CL(piKernelSetExecInfo, pi2ur::piKernelSetExecInfo) - _PI_CL(piextKernelSetArgPointer, pi2ur::piKernelSetArgPointer) - // Event - _PI_CL(piEventCreate, pi2ur::piEventCreate) - _PI_CL(piEventGetInfo, pi2ur::piEventGetInfo) - _PI_CL(piEventGetProfilingInfo, pi2ur::piEventGetProfilingInfo) - _PI_CL(piEventsWait, pi2ur::piEventsWait) - _PI_CL(piEventSetCallback, pi2ur::piEventSetCallback) - _PI_CL(piEventSetStatus, pi2ur::piEventSetStatus) - _PI_CL(piEventRetain, pi2ur::piEventRetain) - _PI_CL(piEventRelease, pi2ur::piEventRelease) - _PI_CL(piextEventGetNativeHandle, pi2ur::piextEventGetNativeHandle) - _PI_CL(piextEventCreateWithNativeHandle, - pi2ur::piextEventCreateWithNativeHandle) - // Sampler - _PI_CL(piSamplerCreate, pi2ur::piSamplerCreate) - _PI_CL(piSamplerGetInfo, pi2ur::piSamplerGetInfo) - _PI_CL(piSamplerRetain, pi2ur::piSamplerRetain) - _PI_CL(piSamplerRelease, pi2ur::piSamplerRelease) - // Enqueue commands - _PI_CL(piEnqueueKernelLaunch, pi2ur::piEnqueueKernelLaunch) - _PI_CL(piEnqueueEventsWait, pi2ur::piEnqueueEventsWait) - _PI_CL(piEnqueueEventsWaitWithBarrier, pi2ur::piEnqueueEventsWaitWithBarrier) - _PI_CL(piEnqueueMemBufferRead, pi2ur::piEnqueueMemBufferRead) - _PI_CL(piEnqueueMemBufferReadRect, pi2ur::piEnqueueMemBufferReadRect) - _PI_CL(piEnqueueMemBufferWrite, pi2ur::piEnqueueMemBufferWrite) - _PI_CL(piEnqueueMemBufferWriteRect, pi2ur::piEnqueueMemBufferWriteRect) - _PI_CL(piEnqueueMemBufferCopy, pi2ur::piEnqueueMemBufferCopy) - _PI_CL(piEnqueueMemBufferCopyRect, pi2ur::piEnqueueMemBufferCopyRect) - _PI_CL(piEnqueueMemBufferFill, pi2ur::piEnqueueMemBufferFill) - _PI_CL(piEnqueueMemImageRead, pi2ur::piEnqueueMemImageRead) - _PI_CL(piEnqueueMemImageWrite, pi2ur::piEnqueueMemImageWrite) - _PI_CL(piEnqueueMemImageCopy, pi2ur::piEnqueueMemImageCopy) - _PI_CL(piEnqueueMemImageFill, pi2ur::piEnqueueMemImageFill) - _PI_CL(piEnqueueMemBufferMap, pi2ur::piEnqueueMemBufferMap) - _PI_CL(piEnqueueMemUnmap, pi2ur::piEnqueueMemUnmap) - // USM - _PI_CL(piextUSMHostAlloc, pi2ur::piextUSMHostAlloc) - _PI_CL(piextUSMDeviceAlloc, pi2ur::piextUSMDeviceAlloc) - _PI_CL(piextUSMSharedAlloc, pi2ur::piextUSMSharedAlloc) - _PI_CL(piextUSMFree, pi2ur::piextUSMFree) - _PI_CL(piextUSMEnqueueMemset, pi2ur::piextUSMEnqueueMemset) - _PI_CL(piextUSMEnqueueMemcpy, pi2ur::piextUSMEnqueueMemcpy) - _PI_CL(piextUSMEnqueuePrefetch, pi2ur::piextUSMEnqueuePrefetch) - _PI_CL(piextUSMEnqueueMemAdvise, pi2ur::piextUSMEnqueueMemAdvise) - _PI_CL(piextUSMEnqueueMemcpy2D, pi2ur::piextUSMEnqueueMemcpy2D) - _PI_CL(piextUSMEnqueueFill2D, pi2ur::piextUSMEnqueueFill2D) - _PI_CL(piextUSMEnqueueMemset2D, pi2ur::piextUSMEnqueueMemset2D) - _PI_CL(piextUSMGetMemAllocInfo, pi2ur::piextUSMGetMemAllocInfo) - _PI_CL(piextUSMImport, pi2ur::piextUSMImport) - _PI_CL(piextUSMRelease, pi2ur::piextUSMRelease) - // Device global variable - _PI_CL(piextEnqueueDeviceGlobalVariableWrite, - pi2ur::piextEnqueueDeviceGlobalVariableWrite) - _PI_CL(piextEnqueueDeviceGlobalVariableRead, - pi2ur::piextEnqueueDeviceGlobalVariableRead) - - // Host Pipe - _PI_CL(piextEnqueueReadHostPipe, pi2ur::piextEnqueueReadHostPipe) - _PI_CL(piextEnqueueWriteHostPipe, pi2ur::piextEnqueueWriteHostPipe) - - _PI_CL(piextKernelSetArgMemObj, pi2ur::piextKernelSetArgMemObj) - _PI_CL(piextKernelSetArgSampler, pi2ur::piextKernelSetArgSampler) - _PI_CL(piPluginGetLastError, pi2ur::piPluginGetLastError) - _PI_CL(piTearDown, pi2ur::piTearDown) - _PI_CL(piGetDeviceAndHostTimer, pi2ur::piGetDeviceAndHostTimer) - _PI_CL(piPluginGetBackendOption, pi2ur::piPluginGetBackendOption) - - // command-buffer - _PI_CL(piextCommandBufferCreate, pi2ur::piextCommandBufferCreate) - _PI_CL(piextCommandBufferRetain, pi2ur::piextCommandBufferRetain) - _PI_CL(piextCommandBufferRelease, pi2ur::piextCommandBufferRelease) - _PI_CL(piextCommandBufferNDRangeKernel, - pi2ur::piextCommandBufferNDRangeKernel) - _PI_CL(piextCommandBufferMemcpyUSM, pi2ur::piextCommandBufferMemcpyUSM) - _PI_CL(piextCommandBufferMemBufferCopy, - pi2ur::piextCommandBufferMemBufferCopy) - _PI_CL(piextCommandBufferMemBufferCopyRect, - pi2ur::piextCommandBufferMemBufferCopyRect) - _PI_CL(piextCommandBufferMemBufferRead, - pi2ur::piextCommandBufferMemBufferRead) - _PI_CL(piextCommandBufferMemBufferReadRect, - pi2ur::piextCommandBufferMemBufferReadRect) - _PI_CL(piextCommandBufferMemBufferWrite, - pi2ur::piextCommandBufferMemBufferWrite) - _PI_CL(piextCommandBufferMemBufferWriteRect, - pi2ur::piextCommandBufferMemBufferWriteRect) - _PI_CL(piextEnqueueCommandBuffer, pi2ur::piextEnqueueCommandBuffer) - - // Peer to Peer - _PI_CL(piextEnablePeerAccess, pi2ur::piextEnablePeerAccess) - _PI_CL(piextDisablePeerAccess, pi2ur::piextDisablePeerAccess) - _PI_CL(piextPeerAccessGetInfo, pi2ur::piextPeerAccessGetInfo) - -#undef _PI_CL +#define _PI_API(api) \ + (PluginInit->PiFunctionTable).api = (decltype(&::api))(&api); +#include +#undef _PI_API return PI_SUCCESS; } diff --git a/sycl/plugins/unified_runtime/CMakeLists.txt b/sycl/plugins/unified_runtime/CMakeLists.txt index b0922c12eabd1..69ab0e5bc56a8 100755 --- a/sycl/plugins/unified_runtime/CMakeLists.txt +++ b/sycl/plugins/unified_runtime/CMakeLists.txt @@ -135,6 +135,8 @@ if ("cuda" IN_LIST SYCL_ENABLE_PLUGINS) "ur/ur.cpp" "ur/usm_allocator.cpp" "ur/usm_allocator.hpp" + "ur/adapters/cuda/command_buffer.cpp" + "ur/adapters/cuda/command_buffer.hpp" "ur/adapters/cuda/common.cpp" "ur/adapters/cuda/common.hpp" "ur/adapters/cuda/context.cpp" @@ -161,8 +163,6 @@ if ("cuda" IN_LIST SYCL_ENABLE_PLUGINS) "ur/adapters/cuda/tracing.cpp" "ur/adapters/cuda/ur_interface_loader.cpp" "ur/adapters/cuda/usm.cpp" - "ur/adapters/cuda/command_buffer.hpp" - "ur/adapters/cuda/command_buffer.cpp" "ur/adapters/cuda/usm_p2p.cpp" INCLUDE_DIRS ${sycl_inc_dir} @@ -186,6 +186,8 @@ if ("hip" IN_LIST SYCL_ENABLE_PLUGINS) "ur/ur.cpp" "ur/usm_allocator.cpp" "ur/usm_allocator.hpp" + "ur/adapters/hip/command_buffer.cpp" + "ur/adapters/hip/command_buffer.hpp" "ur/adapters/hip/common.cpp" "ur/adapters/hip/common.hpp" "ur/adapters/hip/context.cpp" @@ -195,23 +197,22 @@ if ("hip" IN_LIST SYCL_ENABLE_PLUGINS) "ur/adapters/hip/enqueue.cpp" "ur/adapters/hip/event.cpp" "ur/adapters/hip/event.hpp" - "ur/adapters/hip/platform.cpp" - "ur/adapters/hip/platform.hpp" + "ur/adapters/hip/image.cpp" + "ur/adapters/hip/kernel.cpp" + "ur/adapters/hip/kernel.hpp" "ur/adapters/hip/memory.cpp" "ur/adapters/hip/memory.hpp" - "ur/adapters/hip/sampler.cpp" - "ur/adapters/hip/sampler.hpp" - "ur/adapters/hip/usm.cpp" + "ur/adapters/hip/platform.cpp" + "ur/adapters/hip/platform.hpp" "ur/adapters/hip/program.cpp" "ur/adapters/hip/program.hpp" - "ur/adapters/hip/kernel.cpp" - "ur/adapters/hip/kernel.hpp" "ur/adapters/hip/queue.cpp" "ur/adapters/hip/queue.hpp" - "ur/adapters/hip/command_buffer.hpp" - "ur/adapters/hip/command_buffer.cpp" - "ur/adapters/hip/usm_p2p.cpp" + "ur/adapters/hip/sampler.cpp" + "ur/adapters/hip/sampler.hpp" "ur/adapters/hip/ur_interface_loader.cpp" + "ur/adapters/hip/usm.cpp" + "ur/adapters/hip/usm_p2p.cpp" INCLUDE_DIRS ${sycl_inc_dir} LIBRARIES diff --git a/sycl/plugins/unified_runtime/ur/adapters/cuda/platform.cpp b/sycl/plugins/unified_runtime/ur/adapters/cuda/platform.cpp index 8d6d59df738e8..410b0436d5233 100644 --- a/sycl/plugins/unified_runtime/ur/adapters/cuda/platform.cpp +++ b/sycl/plugins/unified_runtime/ur/adapters/cuda/platform.cpp @@ -171,6 +171,23 @@ UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetApiVersion( return UR_RESULT_SUCCESS; } +UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetNativeHandle( + ur_platform_handle_t hPlatform, ur_native_handle_t *phNativePlatform) { + std::ignore = hPlatform; + std::ignore = phNativePlatform; + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urPlatformCreateWithNativeHandle( + ur_native_handle_t hNativePlatform, + const ur_platform_native_properties_t *pProperties, + ur_platform_handle_t *phPlatform) { + std::ignore = hNativePlatform; + std::ignore = pProperties; + std::ignore = phPlatform; + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + UR_APIEXPORT ur_result_t UR_APICALL urInit(ur_device_init_flags_t) { enableCUDATracing(); return UR_RESULT_SUCCESS; diff --git a/sycl/plugins/unified_runtime/ur/adapters/hip/image.cpp b/sycl/plugins/unified_runtime/ur/adapters/hip/image.cpp new file mode 100644 index 0000000000000..c756235c2ea34 --- /dev/null +++ b/sycl/plugins/unified_runtime/ur/adapters/hip/image.cpp @@ -0,0 +1,173 @@ +//===--------- image.cpp - CUDA Adapter ------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===-----------------------------------------------------------------===// + +#include "ur/ur.hpp" + +UR_APIEXPORT ur_result_t UR_APICALL urUSMPitchedAllocExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] const ur_usm_desc_t *pUSMDesc, + [[maybe_unused]] ur_usm_pool_handle_t pool, + [[maybe_unused]] size_t widthInBytes, [[maybe_unused]] size_t height, + [[maybe_unused]] size_t elementSizeBytes, [[maybe_unused]] void **ppMem, + [[maybe_unused]] size_t *pResultPitch) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL +urBindlessImagesUnsampledImageHandleDestroyExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_image_handle_t hImage) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL +urBindlessImagesSampledImageHandleDestroyExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_image_handle_t hImage) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageAllocateExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] const ur_image_format_t *pImageFormat, + [[maybe_unused]] const ur_image_desc_t *pImageDesc, + [[maybe_unused]] ur_exp_image_mem_handle_t *phImageMem) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageFreeExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_image_mem_handle_t hImageMem) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_image_mem_handle_t hImageMem, + [[maybe_unused]] const ur_image_format_t *pImageFormat, + [[maybe_unused]] const ur_image_desc_t *pImageDesc, + [[maybe_unused]] ur_mem_handle_t *phMem, + [[maybe_unused]] ur_exp_image_handle_t *phImage) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_image_mem_handle_t hImageMem, + [[maybe_unused]] const ur_image_format_t *pImageFormat, + [[maybe_unused]] const ur_image_desc_t *pImageDesc, + [[maybe_unused]] ur_sampler_handle_t hSampler, + [[maybe_unused]] ur_mem_handle_t *phMem, + [[maybe_unused]] ur_exp_image_handle_t *phImage) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageCopyExp( + [[maybe_unused]] ur_queue_handle_t hQueue, [[maybe_unused]] void *pDst, + [[maybe_unused]] void *pSrc, + [[maybe_unused]] const ur_image_format_t *pImageFormat, + [[maybe_unused]] const ur_image_desc_t *pImageDesc, + [[maybe_unused]] ur_exp_image_copy_flags_t imageCopyFlags, + [[maybe_unused]] ur_rect_offset_t srcOffset, + [[maybe_unused]] ur_rect_offset_t dstOffset, + [[maybe_unused]] ur_rect_region_t copyExtent, + [[maybe_unused]] ur_rect_region_t hostExtent, + [[maybe_unused]] uint32_t numEventsInWaitList, + [[maybe_unused]] const ur_event_handle_t *phEventWaitList, + [[maybe_unused]] ur_event_handle_t *phEvent) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp( + [[maybe_unused]] ur_exp_image_mem_handle_t hImageMem, + [[maybe_unused]] ur_image_info_t propName, + [[maybe_unused]] void *pPropValue, [[maybe_unused]] size_t *pPropSizeRet) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_image_mem_handle_t hImageMem, + [[maybe_unused]] uint32_t mipmapLevel, + [[maybe_unused]] ur_exp_image_mem_handle_t *phImageMem) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL +urBindlessImagesMipmapFreeExp([[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_image_mem_handle_t hMem) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImportOpaqueFDExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, [[maybe_unused]] size_t size, + [[maybe_unused]] ur_exp_interop_mem_desc_t *pInteropMemDesc, + [[maybe_unused]] ur_exp_interop_mem_handle_t *phInteropMem) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] const ur_image_format_t *pImageFormat, + [[maybe_unused]] const ur_image_desc_t *pImageDesc, + [[maybe_unused]] ur_exp_interop_mem_handle_t hInteropMem, + [[maybe_unused]] ur_exp_image_mem_handle_t *phImageMem) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesReleaseInteropExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_interop_mem_handle_t hInteropMem) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL +urBindlessImagesImportExternalSemaphoreOpaqueFDExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_interop_semaphore_desc_t *pInteropSemaphoreDesc, + [[maybe_unused]] ur_exp_interop_semaphore_handle_t *phInteropSemaphore) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesDestroyExternalSemaphoreExp( + [[maybe_unused]] ur_context_handle_t hContext, + [[maybe_unused]] ur_device_handle_t hDevice, + [[maybe_unused]] ur_exp_interop_semaphore_handle_t hInteropSemaphore) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp( + [[maybe_unused]] ur_queue_handle_t hQueue, + [[maybe_unused]] ur_exp_interop_semaphore_handle_t hSemaphore, + [[maybe_unused]] uint32_t numEventsInWaitList, + [[maybe_unused]] const ur_event_handle_t *phEventWaitList, + [[maybe_unused]] ur_event_handle_t *phEvent) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesSignalExternalSemaphoreExp( + [[maybe_unused]] ur_queue_handle_t hQueue, + [[maybe_unused]] ur_exp_interop_semaphore_handle_t hSemaphore, + [[maybe_unused]] uint32_t numEventsInWaitList, + [[maybe_unused]] const ur_event_handle_t *phEventWaitList, + [[maybe_unused]] ur_event_handle_t *phEvent) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} diff --git a/sycl/plugins/unified_runtime/ur/adapters/hip/platform.cpp b/sycl/plugins/unified_runtime/ur/adapters/hip/platform.cpp index 11f8fc55d44ce..0be379296380d 100644 --- a/sycl/plugins/unified_runtime/ur/adapters/hip/platform.cpp +++ b/sycl/plugins/unified_runtime/ur/adapters/hip/platform.cpp @@ -135,6 +135,23 @@ UR_APIEXPORT ur_result_t UR_APICALL urTearDown(void *) { return UR_RESULT_SUCCESS; } +UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetNativeHandle( + ur_platform_handle_t hPlatform, ur_native_handle_t *phNativePlatform) { + std::ignore = hPlatform; + std::ignore = phNativePlatform; + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +UR_APIEXPORT ur_result_t UR_APICALL urPlatformCreateWithNativeHandle( + ur_native_handle_t hNativePlatform, + const ur_platform_native_properties_t *pProperties, + ur_platform_handle_t *phPlatform) { + std::ignore = hNativePlatform; + std::ignore = pProperties; + std::ignore = phPlatform; + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + // Get CUDA plugin specific backend option. // Current support is only for optimization options. // Return empty string for cuda. diff --git a/sycl/test/abi/pi_cuda_symbol_check.dump b/sycl/test/abi/pi_cuda_symbol_check.dump new file mode 100644 index 0000000000000..abf73cce97bd0 --- /dev/null +++ b/sycl/test/abi/pi_cuda_symbol_check.dump @@ -0,0 +1,161 @@ +################################################################################ +# This file is automatically generated by abi_check.py tool. +# DO NOT EDIT IT MANUALLY. Refer to sycl/doc/developer/ABIPolicyGuide.md for more info. +################################################################################ + +# RUN: env LLVM_BIN_PATH=%llvm_build_bin_dir %python %sycl_tools_src_dir/abi_check.py --mode check_symbols --reference %s %sycl_libs_dir/libpi_cuda.so +# REQUIRES: linux +# REQUIRES: cuda_be +# UNSUPPORTED: libcxx + +piContextCreate +piContextGetInfo +piContextRelease +piContextRetain +piDeviceGetInfo +piDevicePartition +piDeviceRelease +piDeviceRetain +piDevicesGet +piEnqueueEventsWait +piEnqueueEventsWaitWithBarrier +piEnqueueKernelLaunch +piEnqueueMemBufferCopy +piEnqueueMemBufferCopyRect +piEnqueueMemBufferFill +piEnqueueMemBufferMap +piEnqueueMemBufferRead +piEnqueueMemBufferReadRect +piEnqueueMemBufferWrite +piEnqueueMemBufferWriteRect +piEnqueueMemImageCopy +piEnqueueMemImageFill +piEnqueueMemImageRead +piEnqueueMemImageWrite +piEnqueueMemUnmap +piEventCreate +piEventGetInfo +piEventGetProfilingInfo +piEventRelease +piEventRetain +piEventSetCallback +piEventSetStatus +piEventsWait +piGetDeviceAndHostTimer +piKernelCreate +piKernelGetGroupInfo +piKernelGetInfo +piKernelGetSubGroupInfo +piKernelRelease +piKernelRetain +piKernelSetArg +piKernelSetExecInfo +piMemBufferCreate +piMemBufferPartition +piMemGetInfo +piMemImageCreate +piMemImageGetInfo +piMemRelease +piMemRetain +piPlatformGetInfo +piPlatformsGet +piPluginGetBackendOption +piPluginGetLastError +piPluginInit +piProgramBuild +piProgramCompile +piProgramCreate +piProgramCreateWithBinary +piProgramGetBuildInfo +piProgramGetInfo +piProgramLink +piProgramRelease +piProgramRetain +piQueueCreate +piQueueFinish +piQueueFlush +piQueueGetInfo +piQueueRelease +piQueueRetain +piSamplerCreate +piSamplerGetInfo +piSamplerRelease +piSamplerRetain +piTearDown +piextBindlessImageSamplerCreate +piextCommandBufferCreate +piextCommandBufferFinalize +piextCommandBufferMemBufferCopy +piextCommandBufferMemBufferCopyRect +piextCommandBufferMemBufferRead +piextCommandBufferMemBufferReadRect +piextCommandBufferMemBufferWrite +piextCommandBufferMemBufferWriteRect +piextCommandBufferMemcpyUSM +piextCommandBufferNDRangeKernel +piextCommandBufferRelease +piextCommandBufferRetain +piextContextCreateWithNativeHandle +piextContextGetNativeHandle +piextContextSetExtendedDeleter +piextDestroyExternalSemaphore +piextDeviceCreateWithNativeHandle +piextDeviceGetNativeHandle +piextDeviceSelectBinary +piextDisablePeerAccess +piextEnablePeerAccess +piextEnqueueCommandBuffer +piextEnqueueReadHostPipe +piextEnqueueWriteHostPipe +piextEventCreateWithNativeHandle +piextEventGetNativeHandle +piextGetDeviceFunctionPointer +piextImportExternalSemaphoreOpaqueFD +piextKernelCreateWithNativeHandle +piextKernelGetNativeHandle +piextKernelSetArgMemObj +piextKernelSetArgPointer +piextKernelSetArgSampler +piextMemCreateWithNativeHandle +piextMemGetNativeHandle +piextMemImageAllocate +piextMemImageCopy +piextMemImageCreateWithNativeHandle +piextMemImageFree +piextMemImageGetInfo +piextMemImportOpaqueFD +piextMemMapExternalArray +piextMemMipmapFree +piextMemMipmapGetLevel +piextMemReleaseInterop +piextMemSampledImageCreate +piextMemSampledImageHandleDestroy +piextMemUnsampledImageCreate +piextMemUnsampledImageHandleDestroy +piextPeerAccessGetInfo +piextPlatformCreateWithNativeHandle +piextPlatformGetNativeHandle +piextPluginGetOpaqueData +piextProgramCreateWithNativeHandle +piextProgramGetNativeHandle +piextProgramSetSpecializationConstant +piextQueueCreate +piextQueueCreateWithNativeHandle +piextQueueGetNativeHandle +piextSignalExternalSemaphore +piextUSMDeviceAlloc +piextUSMEnqueueFill2D +piextUSMEnqueueMemAdvise +piextUSMEnqueueMemcpy +piextUSMEnqueueMemcpy2D +piextUSMEnqueueMemset +piextUSMEnqueueMemset2D +piextUSMEnqueuePrefetch +piextUSMFree +piextUSMGetMemAllocInfo +piextUSMHostAlloc +piextUSMImport +piextUSMPitchedAlloc +piextUSMRelease +piextUSMSharedAlloc +piextWaitExternalSemaphore diff --git a/sycl/test/abi/pi_hip_symbol_check.dump b/sycl/test/abi/pi_hip_symbol_check.dump new file mode 100644 index 0000000000000..3940b6d80677a --- /dev/null +++ b/sycl/test/abi/pi_hip_symbol_check.dump @@ -0,0 +1,161 @@ +################################################################################ +# This file is automatically generated by abi_check.py tool. +# DO NOT EDIT IT MANUALLY. Refer to sycl/doc/developer/ABIPolicyGuide.md for more info. +################################################################################ + +# RUN: env LLVM_BIN_PATH=%llvm_build_bin_dir %python %sycl_tools_src_dir/abi_check.py --mode check_symbols --reference %s %sycl_libs_dir/libpi_hip.so +# REQUIRES: linux +# REQUIRES: hip_be +# UNSUPPORTED: libcxx + +piContextCreate +piContextGetInfo +piContextRelease +piContextRetain +piDeviceGetInfo +piDevicePartition +piDeviceRelease +piDeviceRetain +piDevicesGet +piEnqueueEventsWait +piEnqueueEventsWaitWithBarrier +piEnqueueKernelLaunch +piEnqueueMemBufferCopy +piEnqueueMemBufferCopyRect +piEnqueueMemBufferFill +piEnqueueMemBufferMap +piEnqueueMemBufferRead +piEnqueueMemBufferReadRect +piEnqueueMemBufferWrite +piEnqueueMemBufferWriteRect +piEnqueueMemImageCopy +piEnqueueMemImageFill +piEnqueueMemImageRead +piEnqueueMemImageWrite +piEnqueueMemUnmap +piEventCreate +piEventGetInfo +piEventGetProfilingInfo +piEventRelease +piEventRetain +piEventSetCallback +piEventSetStatus +piEventsWait +piGetDeviceAndHostTimer +piKernelCreate +piKernelGetGroupInfo +piKernelGetInfo +piKernelGetSubGroupInfo +piKernelRelease +piKernelRetain +piKernelSetArg +piKernelSetExecInfo +piMemBufferCreate +piMemBufferPartition +piMemGetInfo +piMemImageCreate +piMemImageGetInfo +piMemRelease +piMemRetain +piPlatformGetInfo +piPlatformsGet +piPluginGetBackendOption +piPluginGetLastError +piPluginInit +piProgramBuild +piProgramCompile +piProgramCreate +piProgramCreateWithBinary +piProgramGetBuildInfo +piProgramGetInfo +piProgramLink +piProgramRelease +piProgramRetain +piQueueCreate +piQueueFinish +piQueueFlush +piQueueGetInfo +piQueueRelease +piQueueRetain +piSamplerCreate +piSamplerGetInfo +piSamplerRelease +piSamplerRetain +piTearDown +piextBindlessImageSamplerCreate +piextCommandBufferCreate +piextCommandBufferFinalize +piextCommandBufferMemBufferCopy +piextCommandBufferMemBufferCopyRect +piextCommandBufferMemBufferRead +piextCommandBufferMemBufferReadRect +piextCommandBufferMemBufferWrite +piextCommandBufferMemBufferWriteRect +piextCommandBufferMemcpyUSM +piextCommandBufferNDRangeKernel +piextCommandBufferRelease +piextCommandBufferRetain +piextContextCreateWithNativeHandle +piextContextGetNativeHandle +piextContextSetExtendedDeleter +piextDestroyExternalSemaphore +piextDeviceCreateWithNativeHandle +piextDeviceGetNativeHandle +piextDeviceSelectBinary +piextDisablePeerAccess +piextEnablePeerAccess +piextEnqueueCommandBuffer +piextEnqueueReadHostPipe +piextEnqueueWriteHostPipe +piextEventCreateWithNativeHandle +piextEventGetNativeHandle +piextGetDeviceFunctionPointer +piextImportExternalSemaphoreOpaqueFD +piextKernelCreateWithNativeHandle +piextKernelGetNativeHandle +piextKernelSetArgMemObj +piextKernelSetArgPointer +piextKernelSetArgSampler +piextMemCreateWithNativeHandle +piextMemGetNativeHandle +piextMemImageAllocate +piextMemImageCopy +piextMemImageCreateWithNativeHandle +piextMemImageFree +piextMemImageGetInfo +piextMemImportOpaqueFD +piextMemMapExternalArray +piextMemMipmapFree +piextMemMipmapGetLevel +piextMemReleaseInterop +piextMemSampledImageCreate +piextMemSampledImageHandleDestroy +piextMemUnsampledImageCreate +piextMemUnsampledImageHandleDestroy +piextPeerAccessGetInfo +piextPlatformCreateWithNativeHandle +piextPlatformGetNativeHandle +piextPluginGetOpaqueData +piextProgramCreateWithNativeHandle +piextProgramGetNativeHandle +piextProgramSetSpecializationConstant +piextQueueCreate +piextQueueCreateWithNativeHandle +piextQueueGetNativeHandle +piextSignalExternalSemaphore +piextUSMDeviceAlloc +piextUSMEnqueueFill2D +piextUSMEnqueueMemAdvise +piextUSMEnqueueMemcpy +piextUSMEnqueueMemcpy2D +piextUSMEnqueueMemset +piextUSMEnqueueMemset2D +piextUSMEnqueuePrefetch +piextUSMFree +piextUSMGetMemAllocInfo +piextUSMHostAlloc +piextUSMImport +piextUSMPitchedAlloc +piextUSMRelease +piextUSMSharedAlloc +piextWaitExternalSemaphore