DPC++ Runtime
Runtime libraries for oneAPI DPC++
pi_hip.cpp
Go to the documentation of this file.
1 //==---------- pi_hip.cpp - HIP Plugin ------------------------------------==//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
13 
14 #include <pi_hip.hpp>
15 #include <sycl/detail/defines.hpp>
17 #include <sycl/detail/pi.hpp>
18 
19 #include <algorithm>
20 #include <cassert>
21 #include <chrono>
22 #include <hip/hip_runtime.h>
23 #include <limits>
24 #include <memory>
25 #include <mutex>
26 #include <regex>
27 #include <string.h>
28 #include <string_view>
29 
30 //-- PI API implementation
31 extern "C" {
32 
34  pi_uint32 *NumPlatforms) {
35  return pi2ur::piPlatformsGet(NumEntries, Platforms, NumPlatforms);
36 }
37 
39  size_t ParamValueSize, void *ParamValue,
40  size_t *ParamValueSizeRet) {
41  return pi2ur::piPlatformGetInfo(Platform, ParamName, ParamValueSize,
42  ParamValue, ParamValueSizeRet);
43 }
44 
46  pi_native_handle *NativeHandle) {
47  return pi2ur::piextPlatformGetNativeHandle(Platform, NativeHandle);
48 }
49 
51  pi_platform *Platform) {
52  return pi2ur::piextPlatformCreateWithNativeHandle(NativeHandle, Platform);
53 }
54 
56  return pi2ur::piPluginGetLastError(message);
57 }
58 
60  const char *frontend_option,
61  const char **backend_option) {
62  return pi2ur::piPluginGetBackendOption(platform, frontend_option,
63  backend_option);
64 }
65 
67  pi_uint32 NumEntries, pi_device *Devices,
68  pi_uint32 *NumDevices) {
69  return pi2ur::piDevicesGet(Platform, DeviceType, NumEntries, Devices,
70  NumDevices);
71 }
72 
74  return pi2ur::piDeviceRetain(Device);
75 }
76 
78  return pi2ur::piDeviceRelease(Device);
79 }
80 
82  size_t ParamValueSize, void *ParamValue,
83  size_t *ParamValueSizeRet) {
84  return pi2ur::piDeviceGetInfo(Device, ParamName, ParamValueSize, ParamValue,
85  ParamValueSizeRet);
86 }
87 
89  const pi_device_partition_property *Properties,
90  pi_uint32 NumDevices, pi_device *OutDevices,
91  pi_uint32 *OutNumDevices) {
92  return pi2ur::piDevicePartition(Device, Properties, NumDevices, OutDevices,
93  OutNumDevices);
94 }
95 
97  pi_uint32 NumBinaries,
98  pi_uint32 *SelectedBinaryInd) {
99  return pi2ur::piextDeviceSelectBinary(Device, Binaries, NumBinaries,
100  SelectedBinaryInd);
101 }
102 
104  pi_native_handle *NativeHandle) {
105 
106  return pi2ur::piextDeviceGetNativeHandle(Device, NativeHandle);
107 }
108 
110  pi_platform Platform,
111  pi_device *Device) {
112 
113  return pi2ur::piextDeviceCreateWithNativeHandle(NativeHandle, Platform,
114  Device);
115 }
116 
118  pi_uint32 NumDevices, const pi_device *Devices,
119  void (*PFnNotify)(const char *ErrInfo,
120  const void *PrivateInfo, size_t CB,
121  void *UserData),
122  void *UserData, pi_context *RetContext) {
123  return pi2ur::piContextCreate(Properties, NumDevices, Devices, PFnNotify,
124  UserData, RetContext);
125 }
126 
128  size_t ParamValueSize, void *ParamValue,
129  size_t *ParamValueSizeRet) {
130 
131  return pi2ur::piContextGetInfo(Context, ParamName, ParamValueSize, ParamValue,
132  ParamValueSizeRet);
133 }
134 
137  void *UserData) {
138  return pi2ur::piextContextSetExtendedDeleter(Context, Function, UserData);
139 }
140 
142  pi_native_handle *NativeHandle) {
143  return pi2ur::piextContextGetNativeHandle(Context, NativeHandle);
144 }
145 
147  pi_uint32 NumDevices,
148  const pi_device *Devices,
149  bool OwnNativeHandle,
150  pi_context *RetContext) {
152  NativeHandle, NumDevices, Devices, OwnNativeHandle, RetContext);
153 }
154 
156 
157  return pi2ur::piContextRetain(Context);
158 }
159 
161  return pi2ur::piContextRelease(Context);
162 }
163 
165  pi_queue_properties Flags, pi_queue *Queue) {
166  pi_queue_properties Properties[] = {PI_QUEUE_FLAGS, Flags, 0};
167  return piextQueueCreate(Context, Device, Properties, Queue);
168 }
169 
171  pi_queue_properties *Properties, pi_queue *Queue) {
172  return pi2ur::piextQueueCreate(Context, Device, Properties, Queue);
173 }
174 
176  size_t ParamValueSize, void *ParamValue,
177  size_t *ParamValueSizeRet) {
178 
179  return pi2ur::piQueueGetInfo(Queue, ParamName, ParamValueSize, ParamValue,
180  ParamValueSizeRet);
181 }
182 
184 
186  return pi2ur::piQueueRelease(Queue);
187 }
188 
190 
192 
194  pi_native_handle *NativeHandle,
195  int32_t *NativeHandleDesc) {
196 
197  return pi2ur::piextQueueGetNativeHandle(Queue, NativeHandle,
198  NativeHandleDesc);
199 }
200 
202  int32_t NativeHandleDesc,
203  pi_context Context, pi_device Device,
204  bool OwnNativeHandle,
205  pi_queue_properties *Properties,
206  pi_queue *Queue) {
207 
209  NativeHandle, NativeHandleDesc, Context, Device, OwnNativeHandle,
210  Properties, Queue);
211 }
212 
214  void *HostPtr, pi_mem *RetMem,
215  const pi_mem_properties *properties) {
216  return pi2ur::piMemBufferCreate(Context, Flags, Size, HostPtr, RetMem,
217  properties);
218 }
219 
220 pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize,
221  void *ParamValue, size_t *ParamValueSizeRet) {
222  return pi2ur::piMemGetInfo(Mem, ParamName, ParamValueSize, ParamValue,
223  ParamValueSizeRet);
224 }
225 
227 
229 
231  const pi_image_format *ImageFormat,
232  const pi_image_desc *ImageDesc, void *HostPtr,
233  pi_mem *RetImage) {
234 
235  return pi2ur::piMemImageCreate(Context, Flags, ImageFormat, ImageDesc,
236  HostPtr, RetImage);
237 }
238 
240  return pi2ur::piextMemGetNativeHandle(Mem, NativeHandle);
241 }
242 
244  pi_context Context,
245  bool ownNativeHandle, pi_mem *Mem) {
246  return pi2ur::piextMemCreateWithNativeHandle(NativeHandle, Context,
247  ownNativeHandle, Mem);
248 }
249 
250 pi_result piProgramCreate(pi_context Context, const void *ILBytes,
251  size_t Length, pi_program *Program) {
252  return pi2ur::piProgramCreate(Context, ILBytes, Length, Program);
253 }
254 
256  pi_context Context, pi_uint32 NumDevices, const pi_device *DeviceList,
257  const size_t *Lengths, const unsigned char **Binaries,
258  size_t NumMetadataEntries, const pi_device_binary_property *Metadata,
259  pi_int32 *BinaryStatus, pi_program *Program) {
260 
261  return pi2ur::piProgramCreateWithBinary(Context, NumDevices, DeviceList,
262  Lengths, Binaries, NumMetadataEntries,
263  Metadata, BinaryStatus, Program);
264 }
265 
267  pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle,
268  const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc,
269  pi_mem *Img) {
271  NativeHandle, Context, OwnNativeHandle, ImageFormat, ImageDesc, Img);
272 }
273 
275  size_t ParamValueSize, void *ParamValue,
276  size_t *ParamValueSizeRet) {
277 
278  return pi2ur::piProgramGetInfo(Program, ParamName, ParamValueSize, ParamValue,
279  ParamValueSizeRet);
280 }
281 
283  const pi_device *DeviceList, const char *Options,
284  pi_uint32 NumInputPrograms,
285  const pi_program *InputPrograms,
286  void (*PFnNotify)(pi_program Program, void *UserData),
287  void *UserData, pi_program *RetProgram) {
288  return pi2ur::piProgramLink(Context, NumDevices, DeviceList, Options,
289  NumInputPrograms, InputPrograms, PFnNotify,
290  UserData, RetProgram);
291 }
292 
294  pi_program Program, pi_uint32 NumDevices, const pi_device *DeviceList,
295  const char *Options, pi_uint32 NumInputHeaders,
296  const pi_program *InputHeaders, const char **HeaderIncludeNames,
297  void (*PFnNotify)(pi_program Program, void *UserData), void *UserData) {
298 
299  return pi2ur::piProgramCompile(Program, NumDevices, DeviceList, Options,
300  NumInputHeaders, InputHeaders,
301  HeaderIncludeNames, PFnNotify, UserData);
302 }
303 
305  const pi_device *DeviceList, const char *Options,
306  void (*PFnNotify)(pi_program Program, void *UserData),
307  void *UserData) {
308  return pi2ur::piProgramBuild(Program, NumDevices, DeviceList, Options,
309  PFnNotify, UserData);
310 }
311 
313  pi_program_build_info ParamName,
314  size_t ParamValueSize, void *ParamValue,
315  size_t *ParamValueSizeRet) {
316 
317  return pi2ur::piProgramGetBuildInfo(Program, Device, ParamName,
318  ParamValueSize, ParamValue,
319  ParamValueSizeRet);
320 }
321 
323  return pi2ur::piProgramRetain(Program);
324 }
325 
327  return pi2ur::piProgramRelease(Program);
328 }
329 
331  pi_native_handle *NativeHandle) {
332  return pi2ur::piextProgramGetNativeHandle(Program, NativeHandle);
333 }
334 
336  pi_context Context,
337  bool OwnNativeHandle,
338  pi_program *Program) {
339  return pi2ur::piextProgramCreateWithNativeHandle(NativeHandle, Context,
340  OwnNativeHandle, Program);
341 }
342 
343 pi_result piKernelCreate(pi_program Program, const char *KernelName,
344  pi_kernel *RetKernel) {
345 
346  return pi2ur::piKernelCreate(Program, KernelName, RetKernel);
347 }
348 
349 pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize,
350  const void *ArgValue) {
351 
352  return pi2ur::piKernelSetArg(Kernel, ArgIndex, ArgSize, ArgValue);
353 }
354 
356  const pi_mem_obj_property *ArgProperties,
357  const pi_mem *ArgValue) {
358  return pi2ur::piextKernelSetArgMemObj(Kernel, ArgIndex, ArgProperties,
359  ArgValue);
360 }
361 
363  const pi_sampler *ArgValue) {
364 
365  return pi2ur::piextKernelSetArgSampler(Kernel, ArgIndex, ArgValue);
366 }
367 
369  size_t ParamValueSize, void *ParamValue,
370  size_t *ParamValueSizeRet) {
371 
372  return pi2ur::piKernelGetInfo(Kernel, ParamName, ParamValueSize, ParamValue,
373  ParamValueSizeRet);
374 }
375 
377  pi_device Device,
378  pi_image_format *ImageFormat,
379  pi_image_desc *ImageDesc,
380  pi_image_mem_handle *RetMem) {
381  return pi2ur::piextMemImageAllocate(Context, Device, ImageFormat, ImageDesc,
382  RetMem);
383 }
384 
386  pi_context Context, pi_device Device, pi_image_mem_handle ImgMem,
387  pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_mem *RetMem,
388  pi_image_handle *RetHandle) {
390  Context, Device, ImgMem, ImageFormat, ImageDesc, RetMem, RetHandle);
391 }
392 
394  pi_context Context, pi_device Device, pi_image_mem_handle ImgMem,
395  pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_sampler Sampler,
396  pi_mem *RetMem, pi_image_handle *RetHandle) {
397  return pi2ur::piextMemSampledImageCreate(Context, Device, ImgMem, ImageFormat,
398  ImageDesc, Sampler, RetMem,
399  RetHandle);
400 }
401 
403  pi_context Context, const pi_sampler_properties *SamplerProperties,
404  float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy,
405  pi_sampler *RetSampler) {
407  Context, SamplerProperties, MinMipmapLevelClamp, MaxMipmapLevelClamp,
408  MaxAnisotropy, RetSampler);
409 }
410 
412  pi_device Device,
413  pi_image_mem_handle MipMem,
414  unsigned int Level,
415  pi_image_mem_handle *RetMem) {
416  return pi2ur::piextMemMipmapGetLevel(Context, Device, MipMem, Level, RetMem);
417 }
418 
419 __SYCL_EXPORT pi_result piextMemImageFree(pi_context Context, pi_device Device,
420  pi_image_mem_handle MemoryHandle) {
421  return pi2ur::piextMemImageFree(Context, Device, MemoryHandle);
422 }
423 
424 __SYCL_EXPORT pi_result piextMemMipmapFree(pi_context Context, pi_device Device,
425  pi_image_mem_handle MemoryHandle) {
426  return pi2ur::piextMemMipmapFree(Context, Device, MemoryHandle);
427 }
428 
430  pi_queue Queue, void *DstPtr, void *SrcPtr,
431  const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc,
432  const pi_image_copy_flags Flags, pi_image_offset SrcOffset,
433  pi_image_offset DstOffset, pi_image_region CopyExtent,
434  pi_image_region HostExtent, pi_uint32 NumEventsInWaitList,
435  const pi_event *EventWaitList, pi_event *Event) {
436  return pi2ur::piextMemImageCopy(Queue, DstPtr, SrcPtr, ImageFormat, ImageDesc,
437  Flags, SrcOffset, DstOffset, CopyExtent,
438  HostExtent, NumEventsInWaitList,
439  EventWaitList, Event);
440 }
441 
443  pi_context Context, pi_device Device, pi_image_handle Handle) {
444  return pi2ur::piextMemUnsampledImageHandleDestroy(Context, Device, Handle);
445 }
446 
448  pi_context Context, pi_device Device, pi_image_handle Handle) {
449  return pi2ur::piextMemSampledImageHandleDestroy(Context, Device, Handle);
450 }
451 
453  pi_image_info ParamName,
454  void *ParamValue,
455  size_t *ParamValueSizeRet) {
456  return pi2ur::piextMemImageGetInfo(MemHandle, ParamName, ParamValue,
457  ParamValueSizeRet);
458 }
459 
460 __SYCL_EXPORT pi_result
461 piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size,
462  int FileDescriptor, pi_interop_mem_handle *RetHandle) {
463  return pi2ur::piextMemImportOpaqueFD(Context, Device, Size, FileDescriptor,
464  RetHandle);
465 }
466 
468  pi_context Context, pi_device Device, pi_image_format *ImageFormat,
469  pi_image_desc *ImageDesc, pi_interop_mem_handle MemHandle,
470  pi_image_mem_handle *RetMem) {
471  return pi2ur::piextMemMapExternalArray(Context, Device, ImageFormat,
472  ImageDesc, MemHandle, RetMem);
473 }
474 
476  pi_device Device,
477  pi_interop_mem_handle ExtMem) {
478  return pi2ur::piextMemReleaseInterop(Context, Device, ExtMem);
479 }
480 
482  pi_context Context, pi_device Device, int FileDescriptor,
483  pi_interop_semaphore_handle *RetHandle) {
484  return pi2ur::piextImportExternalSemaphoreOpaqueFD(Context, Device,
485  FileDescriptor, RetHandle);
486 }
487 
488 __SYCL_EXPORT pi_result
490  pi_interop_semaphore_handle SemHandle) {
491  return pi2ur::piextDestroyExternalSemaphore(Context, Device, SemHandle);
492 }
493 
495  pi_queue Queue, pi_interop_semaphore_handle SemHandle,
496  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
497  pi_event *Event) {
499  Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event);
500 }
501 
503  pi_queue Queue, pi_interop_semaphore_handle SemHandle,
504  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
505  pi_event *Event) {
507  Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event);
508 }
509 
511  pi_kernel_group_info ParamName,
512  size_t ParamValueSize, void *ParamValue,
513  size_t *ParamValueSizeRet) {
514  return pi2ur::piKernelGetGroupInfo(Kernel, Device, ParamName, ParamValueSize,
515  ParamValue, ParamValueSizeRet);
516 }
517 
519  pi_kernel_sub_group_info ParamName,
520  size_t InputValueSize, const void *InputValue,
521  size_t ParamValueSize, void *ParamValue,
522  size_t *ParamValueSizeRet) {
524  Kernel, Device, ParamName, InputValueSize, InputValue, ParamValueSize,
525  ParamValue, ParamValueSizeRet);
526 }
527 
529 
530  return pi2ur::piKernelRetain(Kernel);
531 }
532 
534 
535  return pi2ur::piKernelRelease(Kernel);
536 }
537 
538 pi_result
540  const size_t *GlobalWorkOffset,
541  const size_t *GlobalWorkSize, const size_t *LocalWorkSize,
542  pi_uint32 NumEventsInWaitList,
543  const pi_event *EventWaitList, pi_event *OutEvent) {
545  Queue, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, LocalWorkSize,
546  NumEventsInWaitList, EventWaitList, OutEvent);
547 }
548 
550  pi_context Context,
551  pi_program Program,
552  bool OwnNativeHandle,
553  pi_kernel *Kernel) {
554 
556  NativeHandle, Context, Program, OwnNativeHandle, Kernel);
557 }
558 
560  pi_native_handle *NativeHandle) {
561  return pi2ur::piextKernelGetNativeHandle(Kernel, NativeHandle);
562 }
563 
565  return pi2ur::piEventCreate(Context, RetEvent);
566 }
567 
569  size_t ParamValueSize, void *ParamValue,
570  size_t *ParamValueSizeRet) {
571  return pi2ur::piEventGetInfo(Event, ParamName, ParamValueSize, ParamValue,
572  ParamValueSizeRet);
573 }
574 
576  size_t ParamValueSize, void *ParamValue,
577  size_t *ParamValueSizeRet) {
578 
579  return pi2ur::piEventGetProfilingInfo(Event, ParamName, ParamValueSize,
580  ParamValue, ParamValueSizeRet);
581 }
582 
583 pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList) {
584  return pi2ur::piEventsWait(NumEvents, EventList);
585 }
586 
587 pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType,
588  void (*PFnNotify)(pi_event Event,
589  pi_int32 EventCommandStatus,
590  void *UserData),
591  void *UserData) {
592  return pi2ur::piEventSetCallback(Event, CommandExecCallbackType, PFnNotify,
593  UserData);
594 }
595 
596 pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus) {
597  return pi2ur::piEventSetStatus(Event, ExecutionStatus);
598 }
599 
601 
603  return pi2ur::piEventRelease(Event);
604 }
605 
607  pi_native_handle *NativeHandle) {
608 
609  return pi2ur::piextEventGetNativeHandle(Event, NativeHandle);
610 }
611 
613  pi_context Context,
614  bool OwnNativeHandle,
615  pi_event *Event) {
616  return pi2ur::piextEventCreateWithNativeHandle(NativeHandle, Context,
617  OwnNativeHandle, Event);
618 }
619 
621  const pi_sampler_properties *SamplerProperties,
622  pi_sampler *RetSampler) {
623  return pi2ur::piSamplerCreate(Context, SamplerProperties, RetSampler);
624 }
625 
627  size_t ParamValueSize, void *ParamValue,
628  size_t *ParamValueSizeRet) {
629 
630  return pi2ur::piSamplerGetInfo(Sampler, ParamName, ParamValueSize, ParamValue,
631  ParamValueSizeRet);
632 }
633 
635  return pi2ur::piSamplerRetain(Sampler);
636 }
637 
639  return pi2ur::piSamplerRelease(Sampler);
640 }
641 
642 pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList,
643  const pi_event *EventWaitList,
644  pi_event *OutEvent) {
645 
646  return pi2ur::piEnqueueEventsWait(Queue, NumEventsInWaitList, EventWaitList,
647  OutEvent);
648 }
649 
651  pi_uint32 NumEventsInWaitList,
652  const pi_event *EventWaitList,
653  pi_event *OutEvent) {
654 
655  return pi2ur::piEnqueueEventsWaitWithBarrier(Queue, NumEventsInWaitList,
656  EventWaitList, OutEvent);
657 }
658 
660  pi_bool BlockingRead, size_t Offset,
661  size_t Size, void *Dst,
662  pi_uint32 NumEventsInWaitList,
663  const pi_event *EventWaitList,
664  pi_event *Event) {
665 
666  return pi2ur::piEnqueueMemBufferRead(Queue, Src, BlockingRead, Offset, Size,
667  Dst, NumEventsInWaitList, EventWaitList,
668  Event);
669 }
670 
672  pi_queue Queue, pi_mem Buffer, pi_bool BlockingRead,
673  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
674  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
675  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
676  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
677  pi_event *Event) {
678 
680  Queue, Buffer, BlockingRead, BufferOffset, HostOffset, Region,
681  BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
682  NumEventsInWaitList, EventWaitList, Event);
683 }
684 
686  pi_bool BlockingWrite, size_t Offset,
687  size_t Size, const void *Ptr,
688  pi_uint32 NumEventsInWaitList,
689  const pi_event *EventWaitList,
690  pi_event *Event) {
691 
692  return pi2ur::piEnqueueMemBufferWrite(Queue, Buffer, BlockingWrite, Offset,
693  Size, Ptr, NumEventsInWaitList,
694  EventWaitList, Event);
695 }
696 
698  pi_queue Queue, pi_mem Buffer, pi_bool BlockingWrite,
699  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
700  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
701  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
702  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
703  pi_event *Event) {
704 
706  Queue, Buffer, BlockingWrite, BufferOffset, HostOffset, Region,
707  BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
708  NumEventsInWaitList, EventWaitList, Event);
709 }
710 
712  size_t SrcOffset, size_t DstOffset,
713  size_t Size, pi_uint32 NumEventsInWaitList,
714  const pi_event *EventWaitList,
715  pi_event *Event) {
716 
717  return pi2ur::piEnqueueMemBufferCopy(Queue, SrcMem, DstMem, SrcOffset,
718  DstOffset, Size, NumEventsInWaitList,
719  EventWaitList, Event);
720 }
721 
723  pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, pi_buff_rect_offset SrcOrigin,
724  pi_buff_rect_offset DstOrigin, pi_buff_rect_region Region,
725  size_t SrcRowPitch, size_t SrcSlicePitch, size_t DstRowPitch,
726  size_t DstSlicePitch, pi_uint32 NumEventsInWaitList,
727  const pi_event *EventWaitList, pi_event *Event) {
728 
730  Queue, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
731  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumEventsInWaitList,
732  EventWaitList, Event);
733 }
734 
736  const void *Pattern, size_t PatternSize,
737  size_t Offset, size_t Size,
738  pi_uint32 NumEventsInWaitList,
739  const pi_event *EventWaitList,
740  pi_event *Event) {
741 
742  return pi2ur::piEnqueueMemBufferFill(Queue, Buffer, Pattern, PatternSize,
743  Offset, Size, NumEventsInWaitList,
744  EventWaitList, Event);
745 }
746 
748  pi_map_flags MapFlags, size_t Offset,
749  size_t Size, pi_uint32 NumEventsInWaitList,
750  const pi_event *EventWaitList,
751  pi_event *OutEvent, void **RetMap) {
752 
753  return pi2ur::piEnqueueMemBufferMap(Queue, Mem, BlockingMap, MapFlags, Offset,
754  Size, NumEventsInWaitList, EventWaitList,
755  OutEvent, RetMap);
756 }
757 
758 pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr,
759  pi_uint32 NumEventsInWaitList,
760  const pi_event *EventWaitList, pi_event *OutEvent) {
761 
762  return pi2ur::piEnqueueMemUnmap(Queue, Mem, MappedPtr, NumEventsInWaitList,
763  EventWaitList, OutEvent);
764 }
765 
767  size_t ParamValueSize, void *ParamValue,
768  size_t *ParamValueSizeRet) {
769 
770  return pi2ur::piMemImageGetInfo(Image, ParamName, ParamValueSize, ParamValue,
771  ParamValueSizeRet);
772 }
773 
775  pi_bool BlockingRead, pi_image_offset Origin,
776  pi_image_region Region, size_t RowPitch,
777  size_t SlicePitch, void *Ptr,
778  pi_uint32 NumEventsInWaitList,
779  const pi_event *EventWaitList,
780  pi_event *Event) {
782  Queue, Image, BlockingRead, Origin, Region, RowPitch, SlicePitch, Ptr,
783  NumEventsInWaitList, EventWaitList, Event);
784 }
785 
787  pi_bool BlockingWrite, pi_image_offset Origin,
788  pi_image_region Region, size_t InputRowPitch,
789  size_t InputSlicePitch, const void *Ptr,
790  pi_uint32 NumEventsInWaitList,
791  const pi_event *EventWaitList,
792  pi_event *Event) {
793 
795  Queue, Image, BlockingWrite, Origin, Region, InputRowPitch,
796  InputSlicePitch, Ptr, NumEventsInWaitList, EventWaitList, Event);
797 }
798 
799 pi_result
800 piEnqueueMemImageCopy(pi_queue Queue, pi_mem SrcImage, pi_mem DstImage,
801  pi_image_offset SrcOrigin, pi_image_offset DstOrigin,
802  pi_image_region Region, pi_uint32 NumEventsInWaitList,
803  const pi_event *EventWaitList, pi_event *Event) {
804  return pi2ur::piEnqueueMemImageCopy(Queue, SrcImage, DstImage, SrcOrigin,
805  DstOrigin, Region, NumEventsInWaitList,
806  EventWaitList, Event);
807 }
808 
810  const void *FillColor, const size_t *Origin,
811  const size_t *Region,
812  pi_uint32 NumEventsInWaitList,
813  const pi_event *EventWaitList,
814  pi_event *Event) {
815 
816  return pi2ur::piEnqueueMemImageFill(Queue, Image, FillColor, Origin, Region,
817  NumEventsInWaitList, EventWaitList,
818  Event);
819 }
820 
822  pi_buffer_create_type BufferCreateType,
823  void *BufferCreateInfo, pi_mem *RetMem) {
824 
825  return pi2ur::piMemBufferPartition(Buffer, Flags, BufferCreateType,
826  BufferCreateInfo, RetMem);
827 }
828 
830  const char *FunctionName,
831  pi_uint64 *FunctionPointerRet) {
832  return pi2ur::piextGetDeviceFunctionPointer(Device, Program, FunctionName,
833  FunctionPointerRet);
834 }
835 
836 pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context,
837  pi_device Device,
838  pi_usm_mem_properties *Properties, size_t Size,
840 
841  return pi2ur::piextUSMDeviceAlloc(ResultPtr, Context, Device, Properties,
842  Size, Alignment);
843 }
844 
845 pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context,
846  pi_device Device,
847  pi_usm_mem_properties *Properties, size_t Size,
849 
850  return pi2ur::piextUSMSharedAlloc(ResultPtr, Context, Device, Properties,
851  Size, Alignment);
852 }
853 
855  void **ResultPtr, size_t *ResultPitch, pi_context Context, pi_device Device,
856  pi_usm_mem_properties *Properties, size_t WidthInBytes, size_t Height,
857  unsigned int ElementSizeBytes) {
858 
859  return pi2ur::piextUSMPitchedAlloc(ResultPtr, ResultPitch, Context, Device,
860  Properties, WidthInBytes, Height,
861  ElementSizeBytes);
862 }
863 
864 pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context,
865  pi_usm_mem_properties *Properties, size_t Size,
867  return pi2ur::piextUSMHostAlloc(ResultPtr, Context, Properties, Size,
868  Alignment);
869 }
870 
871 pi_result piextUSMFree(pi_context Context, void *Ptr) {
872 
873  return pi2ur::piextUSMFree(Context, Ptr);
874 }
875 
877  size_t ArgSize, const void *ArgValue) {
878  return pi2ur::piextKernelSetArgPointer(Kernel, ArgIndex, ArgSize, ArgValue);
879 }
880 
882  size_t Count, pi_uint32 NumEventsInWaitlist,
883  const pi_event *EventsWaitlist,
884  pi_event *Event) {
886  Queue, Ptr, Value, Count, NumEventsInWaitlist, EventsWaitlist, Event);
887 }
888 
889 pi_result piextUSMEnqueueMemcpy(pi_queue Queue, pi_bool Blocking, void *DstPtr,
890  const void *SrcPtr, size_t Size,
891  pi_uint32 NumEventsInWaitlist,
892  const pi_event *EventsWaitlist,
893  pi_event *Event) {
894 
895  return pi2ur::piextUSMEnqueueMemcpy(Queue, Blocking, DstPtr, SrcPtr, Size,
896  NumEventsInWaitlist, EventsWaitlist,
897  Event);
898 }
899 
900 pi_result piextUSMEnqueuePrefetch(pi_queue Queue, const void *Ptr, size_t Size,
902  pi_uint32 NumEventsInWaitList,
903  const pi_event *EventWaitList,
904  pi_event *OutEvent) {
905 
907  Queue, Ptr, Size, Flags, NumEventsInWaitList, EventWaitList, OutEvent);
908 }
909 
911  size_t Length, pi_mem_advice Advice,
912  pi_event *OutEvent) {
913 
914  return pi2ur::piextUSMEnqueueMemAdvise(Queue, Ptr, Length, Advice, OutEvent);
915 }
916 
917 __SYCL_EXPORT pi_result piextUSMEnqueueFill2D(pi_queue Queue, void *Ptr,
918  size_t Pitch, size_t PatternSize,
919  const void *Pattern, size_t Width,
920  size_t Height,
921  pi_uint32 NumEventsWaitList,
922  const pi_event *EventsWaitList,
923  pi_event *Event) {
924 
925  return pi2ur::piextUSMEnqueueFill2D(Queue, Ptr, Pitch, PatternSize, Pattern,
926  Width, Height, NumEventsWaitList,
927  EventsWaitList, Event);
928 }
929 
930 __SYCL_EXPORT pi_result piextUSMEnqueueMemset2D(pi_queue Queue, void *Ptr,
931  size_t Pitch, int Value,
932  size_t Width, size_t Height,
933  pi_uint32 NumEventsWaitList,
934  const pi_event *EventsWaitlist,
935  pi_event *Event) {
936 
937  return pi2ur::piextUSMEnqueueMemset2D(Queue, Ptr, Pitch, Value, Width, Height,
938  NumEventsWaitList, EventsWaitlist,
939  Event);
940 }
941 
943  pi_queue Queue, pi_bool Blocking, void *DstPtr, size_t DstPitch,
944  const void *SrcPtr, size_t SrcPitch, size_t Width, size_t Height,
945  pi_uint32 NumEventsInWaitlist, const pi_event *EventWaitlist,
946  pi_event *Event) {
947 
949  Queue, Blocking, DstPtr, DstPitch, SrcPtr, SrcPitch, Width, Height,
950  NumEventsInWaitlist, EventWaitlist, Event);
951 }
952 
954  pi_mem_alloc_info ParamName,
955  size_t ParamValueSize, void *ParamValue,
956  size_t *ParamValueSizeRet) {
957  return pi2ur::piextUSMGetMemAllocInfo(Context, Ptr, ParamName, ParamValueSize,
958  ParamValue, ParamValueSizeRet);
959 }
960 
961 pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context) {
962  return pi2ur::piextUSMImport(HostPtr, Size, Context);
963 }
964 
965 pi_result piextUSMRelease(const void *HostPtr, pi_context Context) {
966  return pi2ur::piextUSMRelease(HostPtr, Context);
967 }
968 
970  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite,
971  size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList,
972  const pi_event *EventsWaitList, pi_event *Event) {
974  Queue, Program, Name, BlockingWrite, Count, Offset, Src,
975  NumEventsInWaitList, EventsWaitList, Event);
976 }
977 
979  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingRead,
980  size_t Count, size_t Offset, void *Dst, pi_uint32 NumEventsInWaitList,
981  const pi_event *EventsWaitList, pi_event *Event) {
983  Queue, Program, Name, BlockingRead, Count, Offset, Dst,
984  NumEventsInWaitList, EventsWaitList, Event);
985 
986  return PI_SUCCESS;
987 }
988 
990  const char *PipeSymbol, pi_bool Blocking,
991  void *Ptr, size_t Size,
992  pi_uint32 NumEventsInWaitList,
993  const pi_event *EventsWaitList,
994  pi_event *Event) {
995  (void)Queue;
996  (void)Program;
997  (void)PipeSymbol;
998  (void)Blocking;
999  (void)Ptr;
1000  (void)Size;
1001  (void)NumEventsInWaitList;
1002  (void)EventsWaitList;
1003  (void)Event;
1004  PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE);
1005  die("piextEnqueueReadHostPipe: not implemented");
1006  return {};
1007 }
1008 
1010  const char *PipeSymbol, pi_bool Blocking,
1011  void *Ptr, size_t Size,
1012  pi_uint32 NumEventsInWaitList,
1013  const pi_event *EventsWaitList,
1014  pi_event *Event) {
1015  (void)Queue;
1016  (void)Program;
1017  (void)PipeSymbol;
1018  (void)Blocking;
1019  (void)Ptr;
1020  (void)Size;
1021  (void)NumEventsInWaitList;
1022  (void)EventsWaitList;
1023  (void)Event;
1024  PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE);
1025  die("piextEnqueueWriteHostPipe: not implemented");
1026  return {};
1027 }
1028 
1030  size_t ParamValueSize, const void *ParamValue) {
1031 
1032  return pi2ur::piKernelSetExecInfo(Kernel, ParamName, ParamValueSize,
1033  ParamValue);
1034 }
1035 
1037  pi_uint32 SpecID, size_t Size,
1038  const void *SpecValue) {
1039  return pi2ur::piextProgramSetSpecializationConstant(Prog, SpecID, Size,
1040  SpecValue);
1041 }
1042 
1043 // Command buffer extension
1045  const pi_ext_command_buffer_desc *Desc,
1046  pi_ext_command_buffer *RetCommandBuffer) {
1047  return pi2ur::piextCommandBufferCreate(Context, Device, Desc,
1048  RetCommandBuffer);
1049 }
1050 
1052  return pi2ur::piextCommandBufferRetain(CommandBuffer);
1053 }
1054 
1056  return pi2ur::piextCommandBufferRelease(CommandBuffer);
1057 }
1058 
1060  return pi2ur::piextCommandBufferFinalize(CommandBuffer);
1061 }
1062 
1064  pi_ext_command_buffer CommandBuffer, pi_kernel Kernel, pi_uint32 WorkDim,
1065  const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize,
1066  const size_t *LocalWorkSize, pi_uint32 NumSyncPointsInWaitList,
1067  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1069  CommandBuffer, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize,
1070  LocalWorkSize, NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1071 }
1072 
1074  pi_ext_command_buffer CommandBuffer, void *DstPtr, const void *SrcPtr,
1075  size_t Size, pi_uint32 NumSyncPointsInWaitList,
1076  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1077  return pi2ur::piextCommandBufferMemcpyUSM(CommandBuffer, DstPtr, SrcPtr, Size,
1078  NumSyncPointsInWaitList,
1079  SyncPointWaitList, SyncPoint);
1080 }
1081 
1083  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1084  size_t SrcOffset, size_t DstOffset, size_t Size,
1085  pi_uint32 NumSyncPointsInWaitList,
1086  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1088  CommandBuffer, SrcMem, DstMem, SrcOffset, DstOffset, Size,
1089  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1090 }
1091 
1093  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1094  pi_buff_rect_offset SrcOrigin, pi_buff_rect_offset DstOrigin,
1095  pi_buff_rect_region Region, size_t SrcRowPitch, size_t SrcSlicePitch,
1096  size_t DstRowPitch, size_t DstSlicePitch, pi_uint32 NumSyncPointsInWaitList,
1097  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1099  CommandBuffer, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
1100  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumSyncPointsInWaitList,
1101  SyncPointWaitList, SyncPoint);
1102 }
1103 
1105  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1106  size_t Size, void *Dst, pi_uint32 NumSyncPointsInWaitList,
1107  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1109  CommandBuffer, Buffer, Offset, Size, Dst, NumSyncPointsInWaitList,
1110  SyncPointWaitList, SyncPoint);
1111 }
1112 
1114  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1115  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1116  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1117  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
1118  pi_uint32 NumSyncPointsInWaitList,
1119  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1121  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1122  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1123  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1124 }
1125 
1127  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1128  size_t Size, const void *Ptr, pi_uint32 NumSyncPointsInWaitList,
1129  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1131  CommandBuffer, Buffer, Offset, Size, Ptr, NumSyncPointsInWaitList,
1132  SyncPointWaitList, SyncPoint);
1133 }
1134 
1136  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1137  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1138  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1139  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
1140  pi_uint32 NumSyncPointsInWaitList,
1141  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1143  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1144  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1145  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1146 }
1147 
1149  pi_queue Queue,
1150  pi_uint32 NumEventsInWaitList,
1151  const pi_event *EventWaitList,
1152  pi_event *Event) {
1154  CommandBuffer, Queue, NumEventsInWaitList, EventWaitList, Event);
1155 }
1156 
1157 pi_result piextPluginGetOpaqueData(void *opaque_data_param,
1158  void **opaque_data_return) {
1159  return pi2ur::piextPluginGetOpaqueData(opaque_data_param, opaque_data_return);
1160 }
1161 
1162 pi_result piTearDown(void *PluginParameter) {
1163  return pi2ur::piTearDown(PluginParameter);
1164 }
1165 
1166 pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime,
1167  uint64_t *HostTime) {
1168  return pi2ur::piGetDeviceAndHostTimer(Device, DeviceTime, HostTime);
1169 }
1170 
1172  pi_device peer_device) {
1173 
1174  return pi2ur::piextEnablePeerAccess(command_device, peer_device);
1175 }
1176 
1178  pi_device peer_device) {
1179 
1180  return pi2ur::piextDisablePeerAccess(command_device, peer_device);
1181 }
1182 
1184  pi_device peer_device, pi_peer_attr attr,
1185  size_t ParamValueSize, void *ParamValue,
1186  size_t *ParamValueSizeRet) {
1187  return pi2ur::piextPeerAccessGetInfo(command_device, peer_device, attr,
1188  ParamValueSize, ParamValue,
1189  ParamValueSizeRet);
1190 }
1191 
1193 
1195  // Check that the major version matches in PiVersion and SupportedVersion
1197 
1198  // PI interface supports higher version or the same version.
1199  size_t PluginVersionSize = sizeof(PluginInit->PluginVersion);
1200  if (strlen(SupportedVersion) >= PluginVersionSize)
1201  return PI_ERROR_INVALID_VALUE;
1202  strncpy(PluginInit->PluginVersion, SupportedVersion, PluginVersionSize);
1203 
1204  // Set whole function table to zero to make it easier to detect if
1205  // functions are not set up below.
1206  std::memset(&(PluginInit->PiFunctionTable), 0,
1207  sizeof(PluginInit->PiFunctionTable));
1208 
1209 // Forward calls to HIP RT.
1210 #define _PI_API(api) \
1211  (PluginInit->PiFunctionTable).api = (decltype(&::api))(&api);
1212 #include <sycl/detail/pi.def>
1213 #undef _PI_API
1214 
1215  return PI_SUCCESS;
1216 }
1217 
1218 #ifdef _WIN32
1219 #define __SYCL_PLUGIN_DLL_NAME "pi_hip.dll"
1220 #include "../common_win_pi_trace/common_win_pi_trace.hpp"
1221 #undef __SYCL_PLUGIN_DLL_NAME
1222 #endif
1223 
1224 } // extern "C"
pi2ur::piextUSMPitchedAlloc
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)
Allocates memory accessible on device.
Definition: pi2ur.hpp:3127
piSamplerCreate
pi_result piSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, pi_sampler *RetSampler)
Definition: pi_hip.cpp:620
piextUSMImport
pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context)
Import host system memory into USM.
Definition: pi_hip.cpp:961
piextDeviceCreateWithNativeHandle
pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform Platform, pi_device *Device)
Creates PI device object from a native handle.
Definition: pi_hip.cpp:109
pi2ur::piextCommandBufferMemBufferWriteRect
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)
API to append a rectangular mem buffer write command to the command-buffer.
Definition: pi2ur.hpp:4453
_pi_mem
Definition: pi_cuda.hpp:56
piEnqueueMemBufferFill
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)
Definition: pi_hip.cpp:735
piKernelRelease
pi_result piKernelRelease(pi_kernel Kernel)
Definition: pi_hip.cpp:533
piEnqueueKernelLaunch
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)
Definition: pi_hip.cpp:539
piSamplerRetain
pi_result piSamplerRetain(pi_sampler Sampler)
Definition: pi_hip.cpp:634
pi2ur::piKernelSetArg
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi2ur.hpp:2189
piextDisablePeerAccess
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_hip.cpp:1177
pi2ur::piextSignalExternalSemaphore
pi_result piextSignalExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
API to instruct the queue to signal the external semaphore handle once all previous commands have com...
Definition: pi2ur.hpp:5059
pi2ur::piEventGetProfilingInfo
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4023
pi2ur::piKernelGetGroupInfo
pi_result piKernelGetGroupInfo(pi_kernel Kernel, pi_device Device, pi_kernel_group_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2372
piEnqueueMemBufferMap
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)
Definition: pi_hip.cpp:747
piMemRetain
pi_result piMemRetain(pi_mem Mem)
Definition: pi_hip.cpp:226
_pi_context_info
_pi_context_info
Definition: pi.h:448
pi_buff_rect_offset_struct
Definition: pi.h:1016
pi2ur::piKernelRelease
pi_result piKernelRelease(pi_kernel Kernel)
Definition: pi2ur.hpp:2439
piDeviceGetInfo
pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Returns requested info for provided native device Return PI_DEVICE_INFO_EXTENSION_DEVICELIB_ASSERT fo...
Definition: pi_hip.cpp:81
piEnqueueMemImageWrite
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)
Definition: pi_hip.cpp:786
piextGetDeviceFunctionPointer
pi_result piextGetDeviceFunctionPointer(pi_device Device, pi_program Program, const char *FunctionName, pi_uint64 *FunctionPointerRet)
Retrieves a device function pointer to a user-defined function.
Definition: pi_hip.cpp:829
pi2ur::piPlatformGetInfo
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:854
piQueueCreate
pi_result piQueueCreate(pi_context Context, pi_device Device, pi_queue_properties Flags, pi_queue *Queue)
Definition: pi_hip.cpp:164
pi2ur::piProgramRetain
pi_result piProgramRetain(pi_program Program)
Definition: pi2ur.hpp:2238
pi_bool
pi_uint32 pi_bool
Definition: pi.h:196
pi2ur::piEventRetain
pi_result piEventRetain(pi_event Event)
Definition: pi2ur.hpp:4120
pi2ur::piextUSMGetMemAllocInfo
pi_result piextUSMGetMemAllocInfo(pi_context Context, const void *Ptr, pi_mem_alloc_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
API to query information about USM allocated pointers Valid Queries: PI_MEM_ALLOC_TYPE returns host/d...
Definition: pi2ur.hpp:3351
pi_hip.hpp
piQueueRelease
pi_result piQueueRelease(pi_queue Queue)
Definition: pi_hip.cpp:185
piMemGetInfo
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:220
piMemRelease
pi_result piMemRelease(pi_mem Mem)
Definition: pi_hip.cpp:228
pi2ur::piextCommandBufferMemcpyUSM
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)
API to append a USM memcpy command to the command-buffer.
Definition: pi2ur.hpp:4345
piextUSMDeviceAlloc
pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context, pi_device Device, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Allocates device memory.
Definition: pi_hip.cpp:836
piextMemMapExternalArray
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)
API to map an interop memory handle to an image memory handle.
Definition: pi_hip.cpp:467
pi2ur::piextCommandBufferMemBufferCopyRect
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)
API to append a rectangular mem buffer copy command to the command-buffer.
Definition: pi2ur.hpp:4377
pi2ur::piextPlatformCreateWithNativeHandle
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Creates PI platform object from a native handle.
Definition: pi2ur.hpp:837
piextDeviceGetNativeHandle
pi_result piextDeviceGetNativeHandle(pi_device Device, pi_native_handle *NativeHandle)
Gets the native handle of a PI device object.
Definition: pi_hip.cpp:103
pi2ur::piextMemImageCreateWithNativeHandle
pi_result piextMemImageCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc, pi_mem *RetImage)
Creates PI image object from a native handle.
Definition: pi2ur.hpp:2966
pi2ur::piEnqueueMemBufferMap
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 *EventsWaitList, pi_event *OutEvent, void **RetMap)
Definition: pi2ur.hpp:3588
pi2ur::piextProgramGetNativeHandle
pi_result piextProgramGetNativeHandle(pi_program Program, pi_native_handle *NativeHandle)
Gets the native handle of a PI program object.
Definition: pi2ur.hpp:2294
pi2ur::piSamplerCreate
pi_result piSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, pi_sampler *RetSampler)
Definition: pi2ur.hpp:4143
piKernelSetExecInfo
pi_result piKernelSetExecInfo(pi_kernel Kernel, pi_kernel_exec_info ParamName, size_t ParamValueSize, const void *ParamValue)
API to set attributes controlling kernel execution.
Definition: pi_hip.cpp:1029
piDeviceRelease
pi_result piDeviceRelease(pi_device Device)
Definition: pi_hip.cpp:77
_pi_plugin
Definition: pi.h:2694
pi2ur::piextDeviceGetNativeHandle
pi_result piextDeviceGetNativeHandle(pi_device Device, pi_native_handle *NativeHandle)
Gets the native handle of a PI device object.
Definition: pi2ur.hpp:1282
pi2ur::piEventsWait
pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventsWaitList)
Definition: pi2ur.hpp:3965
piKernelGetSubGroupInfo
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)
API to query information from the sub-group from a kernel.
Definition: pi_hip.cpp:518
_pi_image_copy_flags
_pi_image_copy_flags
Definition: pi.h:619
piKernelRetain
pi_result piKernelRetain(pi_kernel Kernel)
Definition: pi_hip.cpp:528
pi2ur::piextEventCreateWithNativeHandle
pi_result piextEventCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_event *Event)
Creates PI event object from a native handle.
Definition: pi2ur.hpp:4076
pi2ur::piProgramCreate
pi_result piProgramCreate(pi_context Context, const void *ILBytes, size_t Length, pi_program *Program)
Definition: pi2ur.hpp:1836
_pi_mem_advice
_pi_mem_advice
Definition: pi.h:567
piextUSMHostAlloc
pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Allocates host memory accessible by the device.
Definition: pi_hip.cpp:864
piPlatformGetInfo
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:38
pi2ur::piextEventGetNativeHandle
pi_result piextEventGetNativeHandle(pi_event Event, pi_native_handle *NativeHandle)
Gets the native handle of a PI event object.
Definition: pi2ur.hpp:4008
pi2ur::piextCommandBufferMemBufferRead
pi_result piextCommandBufferMemBufferRead(pi_ext_command_buffer CommandBuffer, pi_mem Src, size_t Offset, size_t Size, void *Dst, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
API to append a mem buffer read command to the command-buffer.
Definition: pi2ur.hpp:4436
pi2ur::piextMemMapExternalArray
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)
API to map an interop memory handle to an image memory handle.
Definition: pi2ur.hpp:4955
pi2ur::piGetDeviceAndHostTimer
pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime, uint64_t *HostTime)
Queries device for it's global timestamp in nanoseconds, and updates HostTime with the value of the h...
Definition: pi2ur.hpp:1390
syclcompat::detail::memset
static sycl::event memset(sycl::queue q, void *dev_ptr, int value, size_t size)
Set value to the first size bytes starting from dev_ptr in q.
Definition: memory.hpp:202
_pi_plugin::PluginVersion
char PluginVersion[20]
Definition: pi.h:2704
_pi_result
_pi_result
Definition: pi.h:205
piextCommandBufferMemcpyUSM
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)
API to append a USM memcpy command to the command-buffer.
Definition: pi_hip.cpp:1073
piextQueueGetNativeHandle
pi_result piextQueueGetNativeHandle(pi_queue Queue, pi_native_handle *NativeHandle, int32_t *NativeHandleDesc)
Gets the native handle of a PI queue object.
Definition: pi_hip.cpp:193
pi_context_properties
intptr_t pi_context_properties
Definition: pi.h:654
piextMemCreateWithNativeHandle
pi_result piextMemCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool ownNativeHandle, pi_mem *Mem)
Creates PI mem object from a native handle.
Definition: pi_hip.cpp:243
pi2ur::piEventSetStatus
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi2ur.hpp:4113
piextMemSampledImageHandleDestroy
pi_result piextMemSampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless sampled image handles.
Definition: pi_hip.cpp:447
piProgramCompile
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)
Definition: pi_hip.cpp:293
pi2ur::piPlatformsGet
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi2ur.hpp:800
piMemImageCreate
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)
Definition: pi_hip.cpp:230
_pi_device_type
_pi_device_type
Definition: pi.h:253
piKernelSetArg
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi_hip.cpp:349
piEnqueueMemBufferCopyRect
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)
Definition: pi_hip.cpp:722
piextUSMGetMemAllocInfo
pi_result piextUSMGetMemAllocInfo(pi_context Context, const void *Ptr, pi_mem_alloc_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
API to query information about USM allocated pointers Valid Queries: PI_MEM_ALLOC_TYPE returns host/d...
Definition: pi_hip.cpp:953
pi2ur::piProgramRelease
pi_result piProgramRelease(pi_program Program)
Definition: pi2ur.hpp:2450
pi2ur::piextUSMEnqueueMemset2D
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)
USM 2D Memset API.
Definition: pi2ur.hpp:3332
piEventRetain
pi_result piEventRetain(pi_event Event)
Definition: pi_hip.cpp:600
piProgramCreateWithBinary
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)
Creates a PI program for a context and loads the given binary into it.
Definition: pi_hip.cpp:255
piextCommandBufferCreate
pi_result piextCommandBufferCreate(pi_context Context, pi_device Device, const pi_ext_command_buffer_desc *Desc, pi_ext_command_buffer *RetCommandBuffer)
API to create a command-buffer.
Definition: pi_hip.cpp:1044
hip_definitions.hpp
pi2ur::piextDisablePeerAccess
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4538
piextImportExternalSemaphoreOpaqueFD
pi_result piextImportExternalSemaphoreOpaqueFD(pi_context Context, pi_device Device, int FileDescriptor, pi_interop_semaphore_handle *RetHandle)
API to import an external semaphore in the form of a file descriptor.
Definition: pi_hip.cpp:481
pi2ur::piextWaitExternalSemaphore
pi_result piextWaitExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
API to instruct the queue with a non-blocking wait on an external semaphore.
Definition: pi2ur.hpp:5039
piEventSetCallback
pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, void(*PFnNotify)(pi_event Event, pi_int32 EventCommandStatus, void *UserData), void *UserData)
Definition: pi_hip.cpp:587
_pi_platform
Definition: pi_cuda.hpp:44
pi2ur::piMemImageGetInfo
pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:3416
pi2ur::piProgramLink
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)
Definition: pi2ur.hpp:1966
pi_ext_command_buffer_desc
Definition: pi.h:2266
pi2ur::piKernelCreate
pi_result piKernelCreate(pi_program Program, const char *KernelName, pi_kernel *RetKernel)
Definition: pi2ur.hpp:2077
pi2ur::piEventCreate
pi_result piEventCreate(pi_context Context, pi_event *RetEvent)
Create PI event object in a signalled/completed state.
Definition: pi2ur.hpp:4061
pi2ur::piEnqueueMemImageCopy
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3056
piProgramCreate
pi_result piProgramCreate(pi_context Context, const void *ILBytes, size_t Length, pi_program *Program)
Definition: pi_hip.cpp:250
piQueueGetInfo
pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:175
pi2ur::piextKernelCreateWithNativeHandle
pi_result piextKernelCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, pi_program Program, bool OwnNativeHandle, pi_kernel *Kernel)
Creates PI kernel object from a native handle.
Definition: pi2ur.hpp:2215
piextMemMipmapGetLevel
pi_result piextMemMipmapGetLevel(pi_context Context, pi_device Device, pi_image_mem_handle MipMem, unsigned int Level, pi_image_mem_handle *RetMem)
API to retrieve individual image from mipmap.
Definition: pi_hip.cpp:411
piextUSMEnqueueMemset
pi_result piextUSMEnqueueMemset(pi_queue Queue, void *Ptr, pi_int32 Value, size_t Count, pi_uint32 NumEventsInWaitlist, const pi_event *EventsWaitlist, pi_event *Event)
USM Memset API.
Definition: pi_hip.cpp:881
pi.hpp
pi2ur::piextUSMEnqueueMemcpy2D
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 *EventsWaitList, pi_event *OutEvent)
USM 2D Memcpy API.
Definition: pi2ur.hpp:3475
piextEnqueueReadHostPipe
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)
Plugin.
Definition: pi_hip.cpp:989
piextBindlessImageSamplerCreate
pi_result piextBindlessImageSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy, pi_sampler *RetSampler)
API to create samplers for bindless images.
Definition: pi_hip.cpp:402
_pi_device_info
_pi_device_info
Definition: pi.h:285
piextKernelSetArgSampler
pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_sampler *ArgValue)
Definition: pi_hip.cpp:362
_pi_image_info
_pi_image_info
Definition: pi.h:497
piextPlatformCreateWithNativeHandle
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Creates PI platform object from a native handle.
Definition: pi_hip.cpp:50
pi2ur::piextMemSampledImageCreate
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)
API to create sampled bindless image handles.
Definition: pi2ur.hpp:4633
pi2ur::piextEnqueueDeviceGlobalVariableRead
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 *OutEvent)
API reading data from a device global variable to host.
Definition: pi2ur.hpp:2607
pi2ur::piDevicesGet
pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, pi_uint32 NumEntries, pi_device *Devices, pi_uint32 *NumDevices)
Definition: pi2ur.hpp:930
piContextRetain
pi_result piContextRetain(pi_context Context)
Definition: pi_hip.cpp:155
_PI_HIP_PLUGIN_VERSION_STRING
#define _PI_HIP_PLUGIN_VERSION_STRING
Definition: pi_hip.hpp:25
pi2ur::piTearDown
pi_result piTearDown(void *PluginParameter)
API to notify that the plugin should clean up its resources.
Definition: pi2ur.hpp:772
_pi_kernel
Definition: pi_cuda.hpp:72
piextCommandBufferMemBufferCopy
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)
API to append a mem buffer copy command to the command-buffer.
Definition: pi_hip.cpp:1082
pi2ur::piQueueFinish
pi_result piQueueFinish(pi_queue Queue)
Definition: pi2ur.hpp:1747
pi2ur::piEnqueueMemBufferWriteRect
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3768
pi2ur::piextCommandBufferMemBufferWrite
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)
API to append a mem buffer write command to the command-buffer.
Definition: pi2ur.hpp:4484
pi2ur::piextMemImageFree
pi_result piextMemImageFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free memory for bindless images.
Definition: pi2ur.hpp:4759
_pi_plugin::PiVersion
char PiVersion[20]
Definition: pi.h:2702
pi2ur::piextMemImportOpaqueFD
pi_result piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size, int FileDescriptor, pi_interop_mem_handle *RetHandle)
API to import external memory in the form of a file descriptor.
Definition: pi2ur.hpp:4930
piextProgramSetSpecializationConstant
pi_result piextProgramSetSpecializationConstant(pi_program Prog, pi_uint32 SpecID, size_t Size, const void *SpecValue)
Sets a specialization constant to a specific value.
Definition: pi_hip.cpp:1036
_pi_ext_command_buffer
Definition: pi_cuda.hpp:80
pi2ur::piextKernelGetNativeHandle
pi_result piextKernelGetNativeHandle(pi_kernel Kernel, pi_native_handle *NativeHandle)
Gets the native handle of a PI kernel object.
Definition: pi2ur.hpp:2548
_pi_queue_info
_pi_queue_info
Definition: pi.h:465
pi2ur::piEnqueueMemImageFill
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 *EventsWaitList, pi_event *Event)
Definition: pi2ur.hpp:2094
pi2ur::piQueueRetain
pi_result piQueueRetain(pi_queue Queue)
Definition: pi2ur.hpp:1808
piextEventGetNativeHandle
pi_result piextEventGetNativeHandle(pi_event Event, pi_native_handle *NativeHandle)
Gets the native handle of a PI event object.
Definition: pi_hip.cpp:606
_pi_buffer_create_type
_pi_buffer_create_type
Definition: pi.h:625
pi2ur::piextProgramSetSpecializationConstant
pi_result piextProgramSetSpecializationConstant(pi_program Program, pi_uint32 SpecID, size_t Size, const void *SpecValue)
Sets a specialization constant to a specific value.
Definition: pi2ur.hpp:2060
piextMemGetNativeHandle
pi_result piextMemGetNativeHandle(pi_mem Mem, pi_native_handle *NativeHandle)
Gets the native handle of a PI mem object.
Definition: pi_hip.cpp:239
pi2ur::piDevicePartition
pi_result piDevicePartition(pi_device Device, const pi_device_partition_property *Properties, pi_uint32 NumEntries, pi_device *SubDevices, pi_uint32 *NumSubDevices)
Definition: pi2ur.hpp:1314
pi2ur::piextUSMHostAlloc
pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Allocates host memory accessible by the device.
Definition: pi2ur.hpp:2675
pi2ur::piEnqueueMemImageWrite
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3533
piQueueRetain
pi_result piQueueRetain(pi_queue Queue)
Definition: pi_hip.cpp:183
pi2ur::piextCommandBufferRelease
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
API to decrement the reference count of the command-buffer.
Definition: pi2ur.hpp:4309
piEnqueueEventsWaitWithBarrier
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_hip.cpp:650
piextMemImageFree
pi_result piextMemImageFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free memory for bindless images.
Definition: pi_hip.cpp:419
piQueueFinish
pi_result piQueueFinish(pi_queue Queue)
Definition: pi_hip.cpp:189
piEnqueueMemImageFill
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)
Definition: pi_hip.cpp:809
pi2ur::piSamplerGetInfo
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4204
piEnqueueMemBufferRead
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)
Definition: pi_hip.cpp:659
pi2ur::piEnqueueMemBufferCopy
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3723
_pi_queue
Definition: pi_cuda.hpp:60
piextMemMipmapFree
pi_result piextMemMipmapFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free mipmap memory for bindless images.
Definition: pi_hip.cpp:424
piextCommandBufferMemBufferWrite
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)
API to append a mem buffer write command to the command-buffer.
Definition: pi_hip.cpp:1126
piextPeerAccessGetInfo
pi_result piextPeerAccessGetInfo(pi_device command_device, pi_device peer_device, pi_peer_attr attr, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:1183
pi_uint32
uint32_t pi_uint32
Definition: pi.h:194
pi2ur::piContextGetInfo
pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1520
piPlatformsGet
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi_hip.cpp:33
pi_buff_rect_region_struct
Definition: pi.h:1025
piextKernelCreateWithNativeHandle
pi_result piextKernelCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, pi_program Program, bool OwnNativeHandle, pi_kernel *Kernel)
Creates PI kernel object from a native handle.
Definition: pi_hip.cpp:549
pi2ur::piextMemGetNativeHandle
pi_result piextMemGetNativeHandle(pi_mem Mem, pi_native_handle *NativeHandle)
Gets the native handle of a PI mem object.
Definition: pi2ur.hpp:3042
pi_device_binary_struct
This struct is a record of the device binary information.
Definition: pi.h:959
piProgramGetInfo
pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:274
pi_interop_mem_handle
pi_uint64 pi_interop_mem_handle
Definition: pi.h:1093
pi2ur::piPluginGetLastError
pi_result piPluginGetLastError(char **Message)
API to get Plugin specific warning and error messages.
Definition: pi2ur.hpp:977
pi2ur::piextMemCreateWithNativeHandle
pi_result piextMemCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_mem *Mem)
Creates PI mem object from a native handle.
Definition: pi2ur.hpp:3087
pi2ur::piEnqueueEventsWait
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3903
piextProgramGetNativeHandle
pi_result piextProgramGetNativeHandle(pi_program Program, pi_native_handle *NativeHandle)
Gets the native handle of a PI program object.
Definition: pi_hip.cpp:330
_pi_kernel_exec_info
_pi_kernel_exec_info
Definition: pi.h:1530
pi2ur::piDeviceRelease
pi_result piDeviceRelease(pi_device Device)
Definition: pi2ur.hpp:969
piextUSMEnqueuePrefetch
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)
Hint to migrate memory to the device.
Definition: pi_hip.cpp:900
pi2ur::piextPluginGetOpaqueData
pi_result piextPluginGetOpaqueData(void *opaque_data_param, void **opaque_data_return)
API to get Plugin internal data, opaque to SYCL RT.
Definition: pi2ur.hpp:907
piextContextSetExtendedDeleter
pi_result piextContextSetExtendedDeleter(pi_context Context, pi_context_extended_deleter Function, void *UserData)
Definition: pi_hip.cpp:135
pi2ur::piextMemImageAllocate
pi_result piextMemImageAllocate(pi_context Context, pi_device Device, pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_image_mem_handle *RetMem)
API to allocate memory for bindless images.
Definition: pi2ur.hpp:4583
pi2ur::piEnqueueMemBufferCopyRect
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3689
pi2ur::piProgramCompile
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)
Definition: pi2ur.hpp:1996
piMemBufferPartition
pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, pi_buffer_create_type BufferCreateType, void *BufferCreateInfo, pi_mem *RetMem)
Definition: pi_hip.cpp:821
piextMemUnsampledImageHandleDestroy
pi_result piextMemUnsampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless unsampled image handles.
Definition: pi_hip.cpp:442
piextPluginGetOpaqueData
pi_result piextPluginGetOpaqueData(void *opaque_data_param, void **opaque_data_return)
API to get Plugin internal data, opaque to SYCL RT.
Definition: pi_hip.cpp:1157
piextMemImportOpaqueFD
pi_result piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size, int FileDescriptor, pi_interop_mem_handle *RetHandle)
API to import external memory in the form of a file descriptor.
Definition: pi_hip.cpp:461
pi_mem_flags
pi_bitfield pi_mem_flags
Definition: pi.h:694
piextProgramCreateWithNativeHandle
pi_result piextProgramCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_program *Program)
Creates PI program object from a native handle.
Definition: pi_hip.cpp:335
piextUSMRelease
pi_result piextUSMRelease(const void *HostPtr, pi_context Context)
Release host system memory from USM.
Definition: pi_hip.cpp:965
piextCommandBufferMemBufferReadRect
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)
API to append a rectangular mem buffer read command to the command-buffer.
Definition: pi_hip.cpp:1113
pi2ur::piextMemMipmapGetLevel
pi_result piextMemMipmapGetLevel(pi_context Context, pi_device Device, pi_image_mem_handle MipMem, unsigned int Level, pi_image_mem_handle *RetMem)
API to retrieve individual image from mipmap.
Definition: pi2ur.hpp:4740
pi2ur::piextMemUnsampledImageCreate
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)
API to create bindless image handles.
Definition: pi2ur.hpp:4606
piPluginGetBackendOption
pi_result piPluginGetBackendOption(pi_platform platform, const char *frontend_option, const char **backend_option)
API to get backend specific option.
Definition: pi_hip.cpp:59
pi2ur::piDeviceRetain
pi_result piDeviceRetain(pi_device Device)
Definition: pi2ur.hpp:961
pi2ur::piextBindlessImageSamplerCreate
pi_result piextBindlessImageSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy, pi_sampler *RetSampler)
API to create samplers for bindless images.
Definition: pi2ur.hpp:4662
pi_context_extended_deleter
void(* pi_context_extended_deleter)(void *user_data)
Definition: pi.h:1271
piextUSMEnqueueFill2D
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)
USM 2D fill API.
Definition: pi_hip.cpp:917
pi2ur::piKernelSetExecInfo
pi_result piKernelSetExecInfo(pi_kernel Kernel, pi_kernel_exec_info ParamName, size_t ParamValueSize, const void *ParamValue)
API to set attributes controlling kernel execution.
Definition: pi2ur.hpp:2249
pi2ur::piKernelGetInfo
pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2330
piKernelGetInfo
pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:368
defines.hpp
pi2ur::piextUSMFree
pi_result piextUSMFree(pi_context Context, void *Ptr)
Indicates that the allocated USM memory is no longer needed on the runtime side.
Definition: pi2ur.hpp:3196
piContextCreate
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)
Definition: pi_hip.cpp:117
pi2ur::piextCommandBufferFinalize
pi_result piextCommandBufferFinalize(pi_ext_command_buffer CommandBuffer)
API to stop command-buffer recording such that no more commands can be appended, and makes the comman...
Definition: pi2ur.hpp:4319
pi2ur::piextUSMEnqueueMemcpy
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 *OutEvent)
USM Memcpy API.
Definition: pi2ur.hpp:3748
pi2ur::piextDeviceSelectBinary
pi_result piextDeviceSelectBinary(pi_device Device, pi_device_binary *Binaries, pi_uint32 NumBinaries, pi_uint32 *SelectedBinaryInd)
Selects the most appropriate device binary based on runtime information and the IR characteristics.
Definition: pi2ur.hpp:1398
pi2ur::piextCommandBufferCreate
pi_result piextCommandBufferCreate(pi_context Context, pi_device Device, const pi_ext_command_buffer_desc *Desc, pi_ext_command_buffer *RetCommandBuffer)
API to create a command-buffer.
Definition: pi2ur.hpp:4282
pi2ur::piQueueGetInfo
pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1758
piextKernelSetArgPointer
pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Sets up pointer arguments for CL kernels.
Definition: pi_hip.cpp:876
piEventSetStatus
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi_hip.cpp:596
pi_ext_sync_point
pi_uint32 pi_ext_sync_point
Definition: pi.h:2260
pi2ur::piextQueueCreateWithNativeHandle
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)
Creates PI queue object from a native handle.
Definition: pi2ur.hpp:1671
pi2ur::piMemBufferCreate
pi_result piMemBufferCreate(pi_context Context, pi_mem_flags Flags, size_t Size, void *HostPtr, pi_mem *RetMem, const pi_mem_properties *properties)
Definition: pi2ur.hpp:2634
pi2ur::piextUSMRelease
pi_result piextUSMRelease(const void *HostPtr, pi_context Context)
Release host system memory from USM.
Definition: pi2ur.hpp:3405
pi2ur::piextUSMEnqueuePrefetch
pi_result piextUSMEnqueuePrefetch(pi_queue Queue, const void *Ptr, size_t Size, pi_usm_migration_flags Flags, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Hint to migrate memory to the device.
Definition: pi2ur.hpp:3232
piextEnqueueWriteHostPipe
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)
Write to pipe of a given name.
Definition: pi_hip.cpp:1009
sycl::_V1::ext::oneapi::experimental::detail::Alignment
@ Alignment
Definition: property.hpp:193
piDevicePartition
pi_result piDevicePartition(pi_device Device, const pi_device_partition_property *Properties, pi_uint32 NumDevices, pi_device *OutDevices, pi_uint32 *OutNumDevices)
Definition: pi_hip.cpp:88
pi2ur::piSamplerRetain
pi_result piSamplerRetain(pi_sampler Sampler)
Definition: pi2ur.hpp:4253
pi_uint64
uint64_t pi_uint64
Definition: pi.h:195
pi2ur::piextUSMDeviceAlloc
pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context, pi_device Device, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Allocates device memory.
Definition: pi2ur.hpp:3108
pi2ur::piextCommandBufferRetain
pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer)
API to increment the reference count of the command-buffer.
Definition: pi2ur.hpp:4299
piextUSMEnqueueMemcpy2D
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)
USM 2D Memcpy API.
Definition: pi_hip.cpp:942
_pi_event_info
_pi_event_info
Definition: pi.h:514
piKernelCreate
pi_result piKernelCreate(pi_program Program, const char *KernelName, pi_kernel *RetKernel)
Definition: pi_hip.cpp:343
_pi_sampler_info
_pi_sampler_info
Definition: pi.h:630
_pi_device_binary_property_struct
Definition: pi.h:855
pi_mem_properties
pi_bitfield pi_mem_properties
Definition: pi.h:710
piextCommandBufferMemBufferWriteRect
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)
API to append a rectangular mem buffer write command to the command-buffer.
Definition: pi_hip.cpp:1135
_pi_program
Definition: pi_cuda.hpp:68
pi2ur::piEnqueueMemBufferWrite
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3802
pi2ur::piextMemImageGetInfo
pi_result piextMemImageGetInfo(pi_image_mem_handle MemHandle, pi_image_info ParamName, void *ParamValue, size_t *ParamValueSizeRet)
API to query an image memory handle for specific properties.
Definition: pi2ur.hpp:4903
_pi_sampler
Definition: pi_cuda.hpp:76
pi2ur::piextDestroyExternalSemaphore
pi_result piextDestroyExternalSemaphore(pi_context Context, pi_device Device, pi_interop_semaphore_handle SemHandle)
API to destroy the external semaphore handle.
Definition: pi2ur.hpp:5022
pi2ur::piProgramGetInfo
pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1906
piContextGetInfo
pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:127
piSamplerRelease
pi_result piSamplerRelease(pi_sampler Sampler)
Definition: pi_hip.cpp:638
piextCommandBufferRelease
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
API to decrement the reference count of the command-buffer.
Definition: pi_hip.cpp:1055
piEnqueueMemImageRead
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)
Definition: pi_hip.cpp:774
piextKernelGetNativeHandle
pi_result piextKernelGetNativeHandle(pi_kernel Kernel, pi_native_handle *NativeHandle)
Gets the native handle of a PI kernel object.
Definition: pi_hip.cpp:559
pi2ur::piextQueueGetNativeHandle
pi_result piextQueueGetNativeHandle(pi_queue Queue, pi_native_handle *NativeHandle, int32_t *NativeHandleDesc)
Gets the native handle of a PI queue object.
Definition: pi2ur.hpp:1717
pi2ur::piextKernelSetArgPointer
pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, size_t, const void *ArgValue)
Sets up pointer arguments for CL kernels.
Definition: pi2ur.hpp:2462
pi2ur::piextContextGetNativeHandle
pi_result piextContextGetNativeHandle(pi_context Context, pi_native_handle *NativeHandle)
Gets the native handle of a PI context object.
Definition: pi2ur.hpp:1486
pi_native_handle
uintptr_t pi_native_handle
Definition: pi.h:198
pi2ur::piProgramGetBuildInfo
pi_result piProgramGetBuildInfo(pi_program Program, pi_device Device, pi_program_build_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2508
pi2ur::piQueueRelease
pi_result piQueueRelease(pi_queue Queue)
Definition: pi2ur.hpp:1737
pi_sampler_properties
pi_bitfield pi_sampler_properties
Definition: pi.h:662
piextMemSampledImageCreate
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)
API to create sampled bindless image handles.
Definition: pi_hip.cpp:393
piEnqueueMemUnmap
pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_hip.cpp:758
piextWaitExternalSemaphore
pi_result piextWaitExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
API to instruct the queue with a non-blocking wait on an external semaphore.
Definition: pi_hip.cpp:494
piProgramRelease
pi_result piProgramRelease(pi_program Program)
Definition: pi_hip.cpp:326
piDevicesGet
pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, pi_uint32 NumEntries, pi_device *Devices, pi_uint32 *NumDevices)
Definition: pi_hip.cpp:66
pi2ur::piEnqueueMemBufferReadRect
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3826
pi2ur::piMemImageCreate
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)
Definition: pi2ur.hpp:2924
piSamplerGetInfo
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:626
_pi_image_format
Definition: pi.h:1096
_pi_kernel_info
_pi_kernel_info
Definition: pi.h:477
piEventGetInfo
pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:568
piProgramRetain
pi_result piProgramRetain(pi_program Program)
Definition: pi_hip.cpp:322
piextKernelSetArgMemObj
pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_mem_obj_property *ArgProperties, const pi_mem *ArgValue)
Definition: pi_hip.cpp:355
piQueueFlush
pi_result piQueueFlush(pi_queue Queue)
Definition: pi_hip.cpp:191
pi2ur::piextUSMEnqueueFill2D
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)
USM 2D Fill API.
Definition: pi2ur.hpp:3313
piextSignalExternalSemaphore
pi_result piextSignalExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
API to instruct the queue to signal the external semaphore handle once all previous commands have com...
Definition: pi_hip.cpp:502
pi2ur::piEventRelease
pi_result piEventRelease(pi_event Event)
Definition: pi2ur.hpp:4129
pi2ur::piextMemSampledImageHandleDestroy
pi_result piextMemSampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless sampled image handles.
Definition: pi2ur.hpp:4866
pi2ur::piextEnqueueCommandBuffer
pi_result piextEnqueueCommandBuffer(pi_ext_command_buffer CommandBuffer, pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
API to submit the command-buffer to queue for execution, returns an error if the command-buffer is no...
Definition: pi2ur.hpp:4502
pi2ur::piextMemReleaseInterop
pi_result piextMemReleaseInterop(pi_context Context, pi_device Device, pi_interop_mem_handle ExtMem)
API to destroy interop memory.
Definition: pi2ur.hpp:4980
pi_image_mem_handle
void * pi_image_mem_handle
Definition: pi.h:1092
pi_image_handle
pi_uint64 pi_image_handle
Definition: pi.h:1091
piEnqueueMemBufferWriteRect
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)
Definition: pi_hip.cpp:697
piextUSMEnqueueMemset2D
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)
USM 2D Memset API.
Definition: pi_hip.cpp:930
pi2ur::piextCommandBufferMemBufferReadRect
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)
API to append a rectangular mem buffer read command to the command-buffer.
Definition: pi2ur.hpp:4406
piProgramLink
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)
Definition: pi_hip.cpp:282
piEnqueueMemBufferReadRect
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)
Definition: pi_hip.cpp:671
_PI_PLUGIN_VERSION_CHECK
#define _PI_PLUGIN_VERSION_CHECK(PI_API_VERSION, PI_PLUGIN_VERSION)
Definition: pi.h:171
pi2ur::piextCommandBufferNDRangeKernel
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)
API to append a kernel execution command to the command-buffer.
Definition: pi2ur.hpp:4328
piextUSMSharedAlloc
pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context, pi_device Device, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Allocates memory accessible on both host and device.
Definition: pi_hip.cpp:845
pi2ur::piMemBufferPartition
pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, pi_buffer_create_type BufferCreateType, void *BufferCreateInfo, pi_mem *RetMem)
Definition: pi2ur.hpp:2995
piextEnqueueCommandBuffer
pi_result piextEnqueueCommandBuffer(pi_ext_command_buffer CommandBuffer, pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
API to submit the command-buffer to queue for execution, returns an error if the command-buffer is no...
Definition: pi_hip.cpp:1148
piEnqueueMemBufferWrite
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)
Definition: pi_hip.cpp:685
pi2ur::piMemGetInfo
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2689
piDeviceRetain
pi_result piDeviceRetain(pi_device Device)
Definition: pi_hip.cpp:73
piextUSMPitchedAlloc
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)
Allocates memory accessible on device.
Definition: pi_hip.cpp:854
pi2ur::piMemRetain
pi_result piMemRetain(pi_mem Mem)
Definition: pi2ur.hpp:3203
pi2ur::piextQueueCreate
pi_result piextQueueCreate(pi_context Context, pi_device Device, pi_queue_properties *Properties, pi_queue *Queue)
Definition: pi2ur.hpp:1594
pi2ur::piEnqueueMemImageRead
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3562
piextEnqueueDeviceGlobalVariableWrite
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)
Device global variable.
Definition: pi_hip.cpp:969
pi_queue_properties
pi_bitfield pi_queue_properties
Definition: pi.h:729
_pi_platform_info
_pi_platform_info
Definition: pi.h:220
piPluginGetLastError
pi_result piPluginGetLastError(char **message)
API to get Plugin specific warning and error messages.
Definition: pi_hip.cpp:55
piextMemImageCreateWithNativeHandle
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)
Creates PI image object from a native handle.
Definition: pi_hip.cpp:266
pi2ur::piextGetDeviceFunctionPointer
pi_result piextGetDeviceFunctionPointer(pi_device Device, pi_program Program, const char *FunctionName, pi_uint64 *FunctionPointerRet)
Retrieves a device function pointer to a user-defined function.
Definition: pi2ur.hpp:2113
pi2ur::piextKernelSetArgMemObj
pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_mem_obj_property *ArgProperties, const pi_mem *ArgValue)
Definition: pi2ur.hpp:2134
_pi_image_desc
Definition: pi.h:1101
pi2ur::piextDeviceCreateWithNativeHandle
pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform Platform, pi_device *Device)
Creates PI device object from a native handle.
Definition: pi2ur.hpp:1296
piextCommandBufferNDRangeKernel
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)
API to append a kernel execution command to the command-buffer.
Definition: pi_hip.cpp:1063
piPluginInit
pi_result piPluginInit(pi_plugin *PluginInit)
Definition: pi_hip.cpp:1194
piextUSMEnqueueMemAdvise
pi_result piextUSMEnqueueMemAdvise(pi_queue Queue, const void *Ptr, size_t Length, pi_mem_advice Advice, pi_event *OutEvent)
USM Memadvise API.
Definition: pi_hip.cpp:910
_pi_event
Definition: pi_cuda.hpp:64
pi2ur::piContextRelease
pi_result piContextRelease(pi_context Context)
Definition: pi2ur.hpp:1583
pi2ur::piextMemImageCopy
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)
API to copy image data Host to Device or Device to Host.
Definition: pi2ur.hpp:4809
pi2ur::piextMemUnsampledImageHandleDestroy
pi_result piextMemUnsampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless unsampled image handles.
Definition: pi2ur.hpp:4850
pi2ur::piSamplerRelease
pi_result piSamplerRelease(pi_sampler Sampler)
Definition: pi2ur.hpp:4264
pi2ur::piQueueFlush
pi_result piQueueFlush(pi_queue Queue)
Definition: pi2ur.hpp:1819
pi2ur::piextImportExternalSemaphoreOpaqueFD
pi_result piextImportExternalSemaphoreOpaqueFD(pi_context Context, pi_device Device, int FileDescriptor, pi_interop_semaphore_handle *RetHandle)
API to import an external semaphore in the form of a file descriptor.
Definition: pi2ur.hpp:4996
pi2ur::piDeviceGetInfo
pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Returns requested info for provided native device Return PI_DEVICE_INFO_EXTENSION_DEVICELIB_ASSERT fo...
Definition: pi2ur.hpp:994
_pi_mem_info
_pi_mem_info
Definition: pi.h:1117
pi_image_offset_struct
Definition: pi.h:1034
pi2ur::piContextRetain
pi_result piContextRetain(pi_context Context)
Definition: pi2ur.hpp:1575
piextContextCreateWithNativeHandle
pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle, pi_uint32 NumDevices, const pi_device *Devices, bool OwnNativeHandle, pi_context *RetContext)
Creates PI context object from a native handle.
Definition: pi_hip.cpp:146
pi2ur::piProgramBuild
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)
Definition: pi2ur.hpp:2028
pi2ur::piextCommandBufferMemBufferCopy
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)
API to append a mem buffer copy command to the command-buffer.
Definition: pi2ur.hpp:4359
pi2ur::piextUSMEnqueueMemAdvise
pi_result piextUSMEnqueueMemAdvise(pi_queue Queue, const void *Ptr, size_t Length, pi_mem_advice Advice, pi_event *OutEvent)
USM memadvise API to govern behavior of automatic migration mechanisms.
Definition: pi2ur.hpp:3269
piEventRelease
pi_result piEventRelease(pi_event Event)
Definition: pi_hip.cpp:602
piextCommandBufferMemBufferRead
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)
API to append a mem buffer read command to the command-buffer.
Definition: pi_hip.cpp:1104
piEnqueueMemBufferCopy
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)
Definition: pi_hip.cpp:711
pi_image_region_struct
Definition: pi.h:1043
piextEnqueueDeviceGlobalVariableRead
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)
API reading data from a device global variable to host.
Definition: pi_hip.cpp:978
pi2ur::piEnqueueMemBufferRead
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3861
pi2ur::piextProgramCreateWithNativeHandle
pi_result piextProgramCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_program *Program)
Creates PI program object from a native handle.
Definition: pi2ur.hpp:2310
piProgramGetBuildInfo
pi_result piProgramGetBuildInfo(pi_program Program, pi_device Device, pi_program_build_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:312
piextContextGetNativeHandle
pi_result piextContextGetNativeHandle(pi_context Context, pi_native_handle *NativeHandle)
Gets the native handle of a PI context object.
Definition: pi_hip.cpp:141
piextDestroyExternalSemaphore
pi_result piextDestroyExternalSemaphore(pi_context Context, pi_device Device, pi_interop_semaphore_handle SemHandle)
API to destroy the external semaphore handle.
Definition: pi_hip.cpp:489
piextMemImageCopy
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)
API to copy image data Host to Device or Device to Host.
Definition: pi_hip.cpp:429
_pi_mem_obj_property
Definition: pi.h:1828
piKernelGetGroupInfo
pi_result piKernelGetGroupInfo(pi_kernel Kernel, pi_device Device, pi_kernel_group_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:510
_pi_usm_migration_flags
_pi_usm_migration_flags
Definition: pi.h:1886
pi2ur::piEnqueueKernelLaunch
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3508
pi2ur::piEventGetInfo
pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:3979
die
void die(const char *Message)
Definition: ur.hpp:52
_pi_program_info
_pi_program_info
Definition: pi.h:436
pi2ur::piKernelRetain
pi_result piKernelRetain(pi_kernel Kernel)
Definition: pi2ur.hpp:2428
_pi_profiling_info
_pi_profiling_info
Definition: pi.h:683
_pi_plugin::PiFunctionTable
struct _pi_plugin::FunctionPointers PiFunctionTable
pi2ur::piextMemMipmapFree
pi_result piextMemMipmapFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free mipmap memory for bindless images.
Definition: pi2ur.hpp:4775
pi_interop_semaphore_handle
pi_uint64 pi_interop_semaphore_handle
Definition: pi.h:1094
piextMemImageGetInfo
pi_result piextMemImageGetInfo(pi_image_mem_handle MemHandle, pi_image_info ParamName, void *ParamValue, size_t *ParamValueSizeRet)
API to query an image memory handle for specific properties.
Definition: pi_hip.cpp:452
pi2ur::piextPeerAccessGetInfo
pi_result piextPeerAccessGetInfo(pi_device command_device, pi_device peer_device, pi_peer_attr attr, size_t param_value_size, void *param_value, size_t *param_value_size_ret)
Definition: pi2ur.hpp:4549
pi2ur::piextPlatformGetNativeHandle
pi_result piextPlatformGetNativeHandle(pi_platform Platform, pi_native_handle *NativeHandle)
Gets the native handle of a PI platform object.
Definition: pi2ur.hpp:820
piTearDown
pi_result piTearDown(void *PluginParameter)
API to notify that the plugin should clean up its resources.
Definition: pi_hip.cpp:1162
pi2ur::piextContextSetExtendedDeleter
pi_result piextContextSetExtendedDeleter(pi_context Context, pi_context_extended_deleter Function, void *UserData)
Definition: pi2ur.hpp:1477
pi2ur::piProgramCreateWithBinary
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)
Creates a PI program for a context and loads the given binary into it.
Definition: pi2ur.hpp:1855
piEventCreate
pi_result piEventCreate(pi_context Context, pi_event *RetEvent)
Create PI event object in a signalled/completed state.
Definition: pi_hip.cpp:564
_pi_kernel_group_info
_pi_kernel_group_info
Definition: pi.h:486
SupportedVersion
const char SupportedVersion[]
Definition: pi_hip.cpp:1192
pi2ur::piPluginGetBackendOption
pi_result piPluginGetBackendOption(pi_platform Platform, const char *FrontendOption, const char **PlatformOption)
API to get backend specific option.
Definition: pi2ur.hpp:914
pi2ur::piextContextCreateWithNativeHandle
pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle, pi_uint32 NumDevices, const pi_device *Devices, bool OwnNativeHandle, pi_context *RetContext)
Creates PI context object from a native handle.
Definition: pi2ur.hpp:1497
_pi_peer_attr
_pi_peer_attr
Definition: pi.h:1119
pi2ur::piEnqueueMemBufferFill
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 *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3643
piMemBufferCreate
pi_result piMemBufferCreate(pi_context Context, pi_mem_flags Flags, size_t Size, void *HostPtr, pi_mem *RetMem, const pi_mem_properties *properties)
Definition: pi_hip.cpp:213
piMemImageGetInfo
pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:766
pi2ur::piextUSMSharedAlloc
pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context, pi_device Device, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Allocates memory accessible on both host and device.
Definition: pi2ur.hpp:3148
piProgramBuild
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)
Definition: pi_hip.cpp:304
piextCommandBufferFinalize
pi_result piextCommandBufferFinalize(pi_ext_command_buffer CommandBuffer)
API to stop command-buffer recording such that no more commands can be appended, and makes the comman...
Definition: pi_hip.cpp:1059
piextDeviceSelectBinary
pi_result piextDeviceSelectBinary(pi_device Device, pi_device_binary *Binaries, pi_uint32 NumBinaries, pi_uint32 *SelectedBinaryInd)
Selects the most appropriate device binary based on runtime information and the IR characteristics.
Definition: pi_hip.cpp:96
piextMemReleaseInterop
pi_result piextMemReleaseInterop(pi_context Context, pi_device Device, pi_interop_mem_handle ExtMem)
API to destroy interop memory.
Definition: pi_hip.cpp:475
piextUSMEnqueueMemcpy
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)
USM Memcpy API.
Definition: pi_hip.cpp:889
piextEventCreateWithNativeHandle
pi_result piextEventCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_event *Event)
Creates PI event object from a native handle.
Definition: pi_hip.cpp:612
_pi_mem_alloc_info
_pi_mem_alloc_info
Definition: pi.h:1869
piextUSMFree
pi_result piextUSMFree(pi_context Context, void *Ptr)
Indicates that the allocated USM memory is no longer needed on the runtime side.
Definition: pi_hip.cpp:871
pi2ur::piextUSMImport
pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context)
Import host system memory into USM.
Definition: pi2ur.hpp:3393
pi2ur::piextUSMEnqueueMemset
pi_result piextUSMEnqueueMemset(pi_queue Queue, void *Ptr, pi_int32 Value, size_t Count, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
USM Memset API.
Definition: pi2ur.hpp:3665
piextPlatformGetNativeHandle
pi_result piextPlatformGetNativeHandle(pi_platform Platform, pi_native_handle *NativeHandle)
Gets the native handle of a PI platform object.
Definition: pi_hip.cpp:45
pi_usm_mem_properties
pi_bitfield pi_usm_mem_properties
Definition: pi.h:716
piextMemImageAllocate
pi_result piextMemImageAllocate(pi_context Context, pi_device Device, pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_image_mem_handle *RetMem)
API to allocate memory for bindless images.
Definition: pi_hip.cpp:376
pi_map_flags
pi_bitfield pi_map_flags
Definition: pi.h:704
_pi_program_build_info
_pi_program_build_info
Definition: pi.h:229
piEventsWait
pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList)
Definition: pi_hip.cpp:583
pi2ur::piEnqueueEventsWaitWithBarrier
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3884
pi2ur::piextEnablePeerAccess
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4528
piEventGetProfilingInfo
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_hip.cpp:575
piGetDeviceAndHostTimer
pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime, uint64_t *HostTime)
Queries device for it's global timestamp in nanoseconds, and updates HostTime with the value of the h...
Definition: pi_hip.cpp:1166
pi_device_partition_property
intptr_t pi_device_partition_property
Definition: pi.h:788
pi2ur::piKernelGetSubGroupInfo
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)
API to query information from the sub-group from a kernel.
Definition: pi2ur.hpp:2471
piextCommandBufferMemBufferCopyRect
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)
API to append a rectangular mem buffer copy command to the command-buffer.
Definition: pi_hip.cpp:1092
pi2ur::piMemRelease
pi_result piMemRelease(pi_mem Mem)
Definition: pi2ur.hpp:3213
piextQueueCreate
pi_result piextQueueCreate(pi_context Context, pi_device Device, pi_queue_properties *Properties, pi_queue *Queue)
Definition: pi_hip.cpp:170
pi2ur::piEnqueueMemUnmap
pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3621
pi_int32
int32_t pi_int32
Definition: pi.h:193
_pi_context
Definition: pi_cuda.hpp:52
piEnqueueMemImageCopy
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)
Definition: pi_hip.cpp:800
pi2ur::piEventSetCallback
pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, void(*PFnNotify)(pi_event Event, pi_int32 EventCommandStatus, void *UserData), void *UserData)
Definition: pi2ur.hpp:4100
PI_QUEUE_FLAGS
constexpr pi_queue_properties PI_QUEUE_FLAGS
Definition: pi.h:730
piextCommandBufferRetain
pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer)
API to increment the reference count of the command-buffer.
Definition: pi_hip.cpp:1051
piEnqueueEventsWait
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_hip.cpp:642
_pi_device
Definition: pi_cuda.hpp:48
piextQueueCreateWithNativeHandle
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)
Creates PI queue object from a native handle.
Definition: pi_hip.cpp:201
_pi_kernel_sub_group_info
_pi_kernel_sub_group_info
Definition: pi.h:507
PI_ASSERT
#define PI_ASSERT(condition, error)
Definition: pi2ur.hpp:150
piextMemUnsampledImageCreate
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)
API to create bindless image handles.
Definition: pi_hip.cpp:385
pi2ur::piContextCreate
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)
Definition: pi2ur.hpp:1457
pi2ur::piextEnqueueDeviceGlobalVariableWrite
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 *OutEvent)
API for writing data from host to a device global variable.
Definition: pi2ur.hpp:2575
pi2ur::piextKernelSetArgSampler
pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_sampler *ArgValue)
Definition: pi2ur.hpp:4242
piContextRelease
pi_result piContextRelease(pi_context Context)
Definition: pi_hip.cpp:160
piextEnablePeerAccess
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_hip.cpp:1171