DPC++ Runtime
Runtime libraries for oneAPI DPC++
pi_level_zero.cpp
Go to the documentation of this file.
1 //===-------- pi_level_zero.cpp - Level Zero 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_level_zero.hpp"
15 #include "ur_bindings.hpp"
16 
17 // Defined in tracing.cpp
18 void enableZeTracing();
19 void disableZeTracing();
20 
21 extern "C" {
22 
23 // Forward declarations
25 
27  pi_uint32 *NumPlatforms) {
28  return pi2ur::piPlatformsGet(NumEntries, Platforms, NumPlatforms);
29 }
30 
32  size_t ParamValueSize, void *ParamValue,
33  size_t *ParamValueSizeRet) {
34  // To distinguish this L0 platform from Unified Runtime one.
35  if (ParamName == PI_PLATFORM_INFO_NAME) {
36  ReturnHelper ReturnValue(ParamValueSize, ParamValue, ParamValueSizeRet);
37  return ReturnValue("Intel(R) Level-Zero");
38  }
39  return pi2ur::piPlatformGetInfo(Platform, ParamName, ParamValueSize,
40  ParamValue, ParamValueSizeRet);
41 }
42 
44  pi_native_handle *NativeHandle) {
45 
46  return pi2ur::piextPlatformGetNativeHandle(Platform, NativeHandle);
47 }
48 
50  pi_platform *Platform) {
51 
52  return pi2ur::piextPlatformCreateWithNativeHandle(NativeHandle, Platform);
53 }
54 
56  return pi2ur::piPluginGetLastError(message);
57 }
58 
59 // Returns plugin specific backend option.
60 // Return '-ze-opt-disable' for frontend_option = -O0.
61 // Return '-ze-opt-level=1' for frontend_option = -O1 or -O2.
62 // Return '-ze-opt-level=2' for frontend_option = -O3.
63 // Return '-igc_opts 'PartitionUnit=1,SubroutineThreshold=50000'' for
64 // frontend_option = -ftarget-compile-fast.
66  const char *frontend_option,
67  const char **backend_option) {
68  return pi2ur::piPluginGetBackendOption(platform, frontend_option,
69  backend_option);
70 }
71 
73  pi_uint32 NumEntries, pi_device *Devices,
74  pi_uint32 *NumDevices) {
75  return pi2ur::piDevicesGet(Platform, DeviceType, NumEntries, Devices,
76  NumDevices);
77 }
78 
80  return pi2ur::piDeviceRetain(Device);
81 }
82 
84  return pi2ur::piDeviceRelease(Device);
85 }
86 
88  size_t ParamValueSize, void *ParamValue,
89  size_t *ParamValueSizeRet) {
90  return pi2ur::piDeviceGetInfo(Device, ParamName, ParamValueSize, ParamValue,
91  ParamValueSizeRet);
92 }
93 
95  const pi_device_partition_property *Properties,
96  pi_uint32 NumDevices, pi_device *OutDevices,
97  pi_uint32 *OutNumDevices) {
98  return pi2ur::piDevicePartition(Device, Properties, NumDevices, OutDevices,
99  OutNumDevices);
100 }
101 
102 pi_result
103 piextDeviceSelectBinary(pi_device Device, // TODO: does this need to be context?
104  pi_device_binary *Binaries, pi_uint32 NumBinaries,
105  pi_uint32 *SelectedBinaryInd) {
106  return pi2ur::piextDeviceSelectBinary(Device, Binaries, NumBinaries,
107  SelectedBinaryInd);
108 }
109 
111  pi_native_handle *NativeHandle) {
112 
113  return pi2ur::piextDeviceGetNativeHandle(Device, NativeHandle);
114 }
115 
117  pi_platform Platform,
118  pi_device *Device) {
119 
120  return pi2ur::piextDeviceCreateWithNativeHandle(NativeHandle, Platform,
121  Device);
122 }
123 
125  pi_uint32 NumDevices, const pi_device *Devices,
126  void (*PFnNotify)(const char *ErrInfo,
127  const void *PrivateInfo, size_t CB,
128  void *UserData),
129  void *UserData, pi_context *RetContext) {
130  return pi2ur::piContextCreate(Properties, NumDevices, Devices, PFnNotify,
131  UserData, RetContext);
132 }
133 
135  size_t ParamValueSize, void *ParamValue,
136  size_t *ParamValueSizeRet) {
137 
138  return pi2ur::piContextGetInfo(Context, ParamName, ParamValueSize, ParamValue,
139  ParamValueSizeRet);
140 }
141 
142 // FIXME: Dummy implementation to prevent link fail
145  void *UserData) {
146  return pi2ur::piextContextSetExtendedDeleter(Context, Function, UserData);
147 }
148 
150  pi_native_handle *NativeHandle) {
151  return pi2ur::piextContextGetNativeHandle(Context, NativeHandle);
152 }
153 
155  pi_uint32 NumDevices,
156  const pi_device *Devices,
157  bool OwnNativeHandle,
158  pi_context *RetContext) {
160  NativeHandle, NumDevices, Devices, OwnNativeHandle, RetContext);
161 }
162 
164 
165  return pi2ur::piContextRetain(Context);
166 }
167 
169  return pi2ur::piContextRelease(Context);
170 }
171 
173  pi_queue_properties Flags, pi_queue *Queue) {
174  pi_queue_properties Properties[] = {PI_QUEUE_FLAGS, Flags, 0};
175  return piextQueueCreate(Context, Device, Properties, Queue);
176 }
177 
179  pi_queue_properties *Properties, pi_queue *Queue) {
180  return pi2ur::piextQueueCreate(Context, Device, Properties, Queue);
181 }
182 
184  size_t ParamValueSize, void *ParamValue,
185  size_t *ParamValueSizeRet) {
186 
187  return pi2ur::piQueueGetInfo(Queue, ParamName, ParamValueSize, ParamValue,
188  ParamValueSizeRet);
189 }
190 
192 
194  return pi2ur::piQueueRelease(Queue);
195 }
196 
198 
200 
202  pi_native_handle *NativeHandle,
203  int32_t *NativeHandleDesc) {
204 
205  return pi2ur::piextQueueGetNativeHandle(Queue, NativeHandle,
206  NativeHandleDesc);
207 }
208 
210  int32_t NativeHandleDesc,
211  pi_context Context, pi_device Device,
212  bool OwnNativeHandle,
213  pi_queue_properties *Properties,
214  pi_queue *Queue) {
215 
217  NativeHandle, NativeHandleDesc, Context, Device, OwnNativeHandle,
218  Properties, Queue);
219 }
220 
222  void *HostPtr, pi_mem *RetMem,
223  const pi_mem_properties *properties) {
224  return pi2ur::piMemBufferCreate(Context, Flags, Size, HostPtr, RetMem,
225  properties);
226 }
227 
228 pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize,
229  void *ParamValue, size_t *ParamValueSizeRet) {
230  return pi2ur::piMemGetInfo(Mem, ParamName, ParamValueSize, ParamValue,
231  ParamValueSizeRet);
232 }
233 
235 
237 
239  const pi_image_format *ImageFormat,
240  const pi_image_desc *ImageDesc, void *HostPtr,
241  pi_mem *RetImage) {
242 
243  return pi2ur::piMemImageCreate(Context, Flags, ImageFormat, ImageDesc,
244  HostPtr, RetImage);
245 }
246 
248  return pi2ur::piextMemGetNativeHandle(Mem, NativeHandle);
249 }
250 
252  pi_context Context,
253  bool ownNativeHandle, pi_mem *Mem) {
254  return pi2ur::piextMemCreateWithNativeHandle(NativeHandle, Context,
255  ownNativeHandle, Mem);
256 }
257 
258 pi_result piProgramCreate(pi_context Context, const void *ILBytes,
259  size_t Length, pi_program *Program) {
260  return pi2ur::piProgramCreate(Context, ILBytes, Length, Program);
261 }
262 
264  pi_context Context, pi_uint32 NumDevices, const pi_device *DeviceList,
265  const size_t *Lengths, const unsigned char **Binaries,
266  size_t NumMetadataEntries, const pi_device_binary_property *Metadata,
267  pi_int32 *BinaryStatus, pi_program *Program) {
268 
269  return pi2ur::piProgramCreateWithBinary(Context, NumDevices, DeviceList,
270  Lengths, Binaries, NumMetadataEntries,
271  Metadata, BinaryStatus, Program);
272 }
273 
275  pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle,
276  const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc,
277  pi_mem *Img) {
279  NativeHandle, Context, OwnNativeHandle, ImageFormat, ImageDesc, Img);
280 }
281 
283  size_t ParamValueSize, void *ParamValue,
284  size_t *ParamValueSizeRet) {
285 
286  return pi2ur::piProgramGetInfo(Program, ParamName, ParamValueSize, ParamValue,
287  ParamValueSizeRet);
288 }
289 
291  const pi_device *DeviceList, const char *Options,
292  pi_uint32 NumInputPrograms,
293  const pi_program *InputPrograms,
294  void (*PFnNotify)(pi_program Program, void *UserData),
295  void *UserData, pi_program *RetProgram) {
296  return pi2ur::piProgramLink(Context, NumDevices, DeviceList, Options,
297  NumInputPrograms, InputPrograms, PFnNotify,
298  UserData, RetProgram);
299 }
300 
302  pi_program Program, pi_uint32 NumDevices, const pi_device *DeviceList,
303  const char *Options, pi_uint32 NumInputHeaders,
304  const pi_program *InputHeaders, const char **HeaderIncludeNames,
305  void (*PFnNotify)(pi_program Program, void *UserData), void *UserData) {
306 
307  return pi2ur::piProgramCompile(Program, NumDevices, DeviceList, Options,
308  NumInputHeaders, InputHeaders,
309  HeaderIncludeNames, PFnNotify, UserData);
310 }
311 
313  const pi_device *DeviceList, const char *Options,
314  void (*PFnNotify)(pi_program Program, void *UserData),
315  void *UserData) {
316  return pi2ur::piProgramBuild(Program, NumDevices, DeviceList, Options,
317  PFnNotify, UserData);
318 }
319 
321  pi_program_build_info ParamName,
322  size_t ParamValueSize, void *ParamValue,
323  size_t *ParamValueSizeRet) {
324 
325  return pi2ur::piProgramGetBuildInfo(Program, Device, ParamName,
326  ParamValueSize, ParamValue,
327  ParamValueSizeRet);
328 }
329 
331  return pi2ur::piProgramRetain(Program);
332 }
333 
335  return pi2ur::piProgramRelease(Program);
336 }
337 
339  pi_native_handle *NativeHandle) {
340  return pi2ur::piextProgramGetNativeHandle(Program, NativeHandle);
341 }
342 
344  pi_context Context,
345  bool OwnNativeHandle,
346  pi_program *Program) {
347  return pi2ur::piextProgramCreateWithNativeHandle(NativeHandle, Context,
348  OwnNativeHandle, Program);
349 }
350 
351 pi_result piKernelCreate(pi_program Program, const char *KernelName,
352  pi_kernel *RetKernel) {
353 
354  return pi2ur::piKernelCreate(Program, KernelName, RetKernel);
355 }
356 
357 pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize,
358  const void *ArgValue) {
359 
360  return pi2ur::piKernelSetArg(Kernel, ArgIndex, ArgSize, ArgValue);
361 }
362 
363 // Special version of piKernelSetArg to accept pi_mem.
365  const pi_mem_obj_property *ArgProperties,
366  const pi_mem *ArgValue) {
367  return pi2ur::piextKernelSetArgMemObj(Kernel, ArgIndex, ArgProperties,
368  ArgValue);
369 }
370 
371 // Special version of piKernelSetArg to accept pi_sampler.
373  const pi_sampler *ArgValue) {
374 
375  return pi2ur::piextKernelSetArgSampler(Kernel, ArgIndex, ArgValue);
376 }
377 
379  size_t ParamValueSize, void *ParamValue,
380  size_t *ParamValueSizeRet) {
381 
382  return pi2ur::piKernelGetInfo(Kernel, ParamName, ParamValueSize, ParamValue,
383  ParamValueSizeRet);
384 }
385 
387  pi_device Device,
388  pi_image_format *ImageFormat,
389  pi_image_desc *ImageDesc,
390  pi_image_mem_handle *RetMem) {
391  return pi2ur::piextMemImageAllocate(Context, Device, ImageFormat, ImageDesc,
392  RetMem);
393 }
394 
396  pi_context Context, pi_device Device, pi_image_mem_handle ImgMem,
397  pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_mem *RetMem,
398  pi_image_handle *RetHandle) {
400  Context, Device, ImgMem, ImageFormat, ImageDesc, RetMem, RetHandle);
401 }
402 
404  pi_context Context, pi_device Device, pi_image_mem_handle ImgMem,
405  pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_sampler Sampler,
406  pi_mem *RetMem, pi_image_handle *RetHandle) {
407  return pi2ur::piextMemSampledImageCreate(Context, Device, ImgMem, ImageFormat,
408  ImageDesc, Sampler, RetMem,
409  RetHandle);
410 }
411 
413  pi_context Context, const pi_sampler_properties *SamplerProperties,
414  float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy,
415  pi_sampler *RetSampler) {
417  Context, SamplerProperties, MinMipmapLevelClamp, MaxMipmapLevelClamp,
418  MaxAnisotropy, RetSampler);
419 }
420 
422  pi_device Device,
423  pi_image_mem_handle MipMem,
424  unsigned int Level,
425  pi_image_mem_handle *RetMem) {
426  return pi2ur::piextMemMipmapGetLevel(Context, Device, MipMem, Level, RetMem);
427 }
428 
429 __SYCL_EXPORT pi_result piextMemImageFree(pi_context Context, pi_device Device,
430  pi_image_mem_handle MemoryHandle) {
431  return pi2ur::piextMemImageFree(Context, Device, MemoryHandle);
432 }
433 
434 __SYCL_EXPORT pi_result piextMemMipmapFree(pi_context Context, pi_device Device,
435  pi_image_mem_handle MemoryHandle) {
436  return pi2ur::piextMemMipmapFree(Context, Device, MemoryHandle);
437 }
438 
440  pi_queue Queue, void *DstPtr, void *SrcPtr,
441  const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc,
442  const pi_image_copy_flags Flags, pi_image_offset SrcOffset,
443  pi_image_offset DstOffset, pi_image_region CopyExtent,
444  pi_image_region HostExtent, pi_uint32 NumEventsInWaitList,
445  const pi_event *EventWaitList, pi_event *Event) {
446  return pi2ur::piextMemImageCopy(Queue, DstPtr, SrcPtr, ImageFormat, ImageDesc,
447  Flags, SrcOffset, DstOffset, CopyExtent,
448  HostExtent, NumEventsInWaitList,
449  EventWaitList, Event);
450 }
451 
453  pi_context Context, pi_device Device, pi_image_handle Handle) {
454  return pi2ur::piextMemUnsampledImageHandleDestroy(Context, Device, Handle);
455 }
456 
458  pi_context Context, pi_device Device, pi_image_handle Handle) {
459  return pi2ur::piextMemSampledImageHandleDestroy(Context, Device, Handle);
460 }
461 
463  pi_image_info ParamName,
464  void *ParamValue,
465  size_t *ParamValueSizeRet) {
466  return pi2ur::piextMemImageGetInfo(MemHandle, ParamName, ParamValue,
467  ParamValueSizeRet);
468 }
469 
470 __SYCL_EXPORT pi_result
471 piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size,
472  int FileDescriptor, pi_interop_mem_handle *RetHandle) {
473  return pi2ur::piextMemImportOpaqueFD(Context, Device, Size, FileDescriptor,
474  RetHandle);
475 }
476 
478  pi_context Context, pi_device Device, pi_image_format *ImageFormat,
479  pi_image_desc *ImageDesc, pi_interop_mem_handle MemHandle,
480  pi_image_mem_handle *RetMem) {
481  return pi2ur::piextMemMapExternalArray(Context, Device, ImageFormat,
482  ImageDesc, MemHandle, RetMem);
483 }
484 
486  pi_device Device,
487  pi_interop_mem_handle ExtMem) {
488  return pi2ur::piextMemReleaseInterop(Context, Device, ExtMem);
489 }
490 
492  pi_context Context, pi_device Device, int FileDescriptor,
493  pi_interop_semaphore_handle *RetHandle) {
494  return pi2ur::piextImportExternalSemaphoreOpaqueFD(Context, Device,
495  FileDescriptor, RetHandle);
496 }
497 
498 __SYCL_EXPORT pi_result
500  pi_interop_semaphore_handle SemHandle) {
501  return pi2ur::piextDestroyExternalSemaphore(Context, Device, SemHandle);
502 }
503 
505  pi_queue Queue, pi_interop_semaphore_handle SemHandle,
506  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
507  pi_event *Event) {
509  Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event);
510 }
511 
513  pi_queue Queue, pi_interop_semaphore_handle SemHandle,
514  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
515  pi_event *Event) {
517  Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event);
518 }
519 
521  pi_kernel_group_info ParamName,
522  size_t ParamValueSize, void *ParamValue,
523  size_t *ParamValueSizeRet) {
524 
525  return pi2ur::piKernelGetGroupInfo(Kernel, Device, ParamName, ParamValueSize,
526  ParamValue, ParamValueSizeRet);
527 }
528 
530  pi_kernel_sub_group_info ParamName,
531  size_t InputValueSize, const void *InputValue,
532  size_t ParamValueSize, void *ParamValue,
533  size_t *ParamValueSizeRet) {
534 
536  Kernel, Device, ParamName, InputValueSize, InputValue, ParamValueSize,
537  ParamValue, ParamValueSizeRet);
538 }
539 
541 
542  return pi2ur::piKernelRetain(Kernel);
543 }
544 
546 
547  return pi2ur::piKernelRelease(Kernel);
548 }
549 
550 pi_result
552  const size_t *GlobalWorkOffset,
553  const size_t *GlobalWorkSize, const size_t *LocalWorkSize,
554  pi_uint32 NumEventsInWaitList,
555  const pi_event *EventWaitList, pi_event *OutEvent) {
557  Queue, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, LocalWorkSize,
558  NumEventsInWaitList, EventWaitList, OutEvent);
559 }
560 
562  pi_context Context,
563  pi_program Program,
564  bool OwnNativeHandle,
565  pi_kernel *Kernel) {
566 
568  NativeHandle, Context, Program, OwnNativeHandle, Kernel);
569 }
570 
572  pi_native_handle *NativeHandle) {
573  return pi2ur::piextKernelGetNativeHandle(Kernel, NativeHandle);
574 }
575 
576 //
577 // Events
578 //
579 
580 // External PI API entry
582  return pi2ur::piEventCreate(Context, RetEvent);
583 }
584 
586  size_t ParamValueSize, void *ParamValue,
587  size_t *ParamValueSizeRet) {
588  return pi2ur::piEventGetInfo(Event, ParamName, ParamValueSize, ParamValue,
589  ParamValueSizeRet);
590 }
591 
593  size_t ParamValueSize, void *ParamValue,
594  size_t *ParamValueSizeRet) {
595 
596  return pi2ur::piEventGetProfilingInfo(Event, ParamName, ParamValueSize,
597  ParamValue, ParamValueSizeRet);
598 }
599 
600 pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList) {
601  return pi2ur::piEventsWait(NumEvents, EventList);
602 }
603 
604 pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType,
605  void (*PFnNotify)(pi_event Event,
606  pi_int32 EventCommandStatus,
607  void *UserData),
608  void *UserData) {
609  return pi2ur::piEventSetCallback(Event, CommandExecCallbackType, PFnNotify,
610  UserData);
611 }
612 
613 pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus) {
614  return pi2ur::piEventSetStatus(Event, ExecutionStatus);
615 }
616 
618 
620  return pi2ur::piEventRelease(Event);
621 }
622 
624  pi_native_handle *NativeHandle) {
625 
626  return pi2ur::piextEventGetNativeHandle(Event, NativeHandle);
627 }
628 
630  pi_context Context,
631  bool OwnNativeHandle,
632  pi_event *Event) {
633  return pi2ur::piextEventCreateWithNativeHandle(NativeHandle, Context,
634  OwnNativeHandle, Event);
635 }
636 
637 //
638 // Sampler
639 //
641  const pi_sampler_properties *SamplerProperties,
642  pi_sampler *RetSampler) {
643  return pi2ur::piSamplerCreate(Context, SamplerProperties, RetSampler);
644 }
645 
647  size_t ParamValueSize, void *ParamValue,
648  size_t *ParamValueSizeRet) {
649 
650  return pi2ur::piSamplerGetInfo(Sampler, ParamName, ParamValueSize, ParamValue,
651  ParamValueSizeRet);
652 }
653 
655  return pi2ur::piSamplerRetain(Sampler);
656 }
657 
659  return pi2ur::piSamplerRelease(Sampler);
660 }
661 
662 //
663 // Queue Commands
664 //
665 pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList,
666  const pi_event *EventWaitList,
667  pi_event *OutEvent) {
668 
669  return pi2ur::piEnqueueEventsWait(Queue, NumEventsInWaitList, EventWaitList,
670  OutEvent);
671 }
672 
674  pi_uint32 NumEventsInWaitList,
675  const pi_event *EventWaitList,
676  pi_event *OutEvent) {
677 
678  return pi2ur::piEnqueueEventsWaitWithBarrier(Queue, NumEventsInWaitList,
679  EventWaitList, OutEvent);
680 }
681 
683  pi_bool BlockingRead, size_t Offset,
684  size_t Size, void *Dst,
685  pi_uint32 NumEventsInWaitList,
686  const pi_event *EventWaitList,
687  pi_event *Event) {
688 
689  return pi2ur::piEnqueueMemBufferRead(Queue, Src, BlockingRead, Offset, Size,
690  Dst, NumEventsInWaitList, EventWaitList,
691  Event);
692 }
693 
695  pi_queue Queue, pi_mem Buffer, pi_bool BlockingRead,
696  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
697  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
698  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
699  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
700  pi_event *Event) {
701 
703  Queue, Buffer, BlockingRead, BufferOffset, HostOffset, Region,
704  BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
705  NumEventsInWaitList, EventWaitList, Event);
706 }
707 
709  pi_bool BlockingWrite, size_t Offset,
710  size_t Size, const void *Ptr,
711  pi_uint32 NumEventsInWaitList,
712  const pi_event *EventWaitList,
713  pi_event *Event) {
714 
715  return pi2ur::piEnqueueMemBufferWrite(Queue, Buffer, BlockingWrite, Offset,
716  Size, Ptr, NumEventsInWaitList,
717  EventWaitList, Event);
718 }
719 
721  pi_queue Queue, pi_mem Buffer, pi_bool BlockingWrite,
722  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
723  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
724  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
725  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
726  pi_event *Event) {
727 
729  Queue, Buffer, BlockingWrite, BufferOffset, HostOffset, Region,
730  BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
731  NumEventsInWaitList, EventWaitList, Event);
732 }
733 
735  size_t SrcOffset, size_t DstOffset,
736  size_t Size, pi_uint32 NumEventsInWaitList,
737  const pi_event *EventWaitList,
738  pi_event *Event) {
739 
740  return pi2ur::piEnqueueMemBufferCopy(Queue, SrcMem, DstMem, SrcOffset,
741  DstOffset, Size, NumEventsInWaitList,
742  EventWaitList, Event);
743 }
744 
746  pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, pi_buff_rect_offset SrcOrigin,
747  pi_buff_rect_offset DstOrigin, pi_buff_rect_region Region,
748  size_t SrcRowPitch, size_t SrcSlicePitch, size_t DstRowPitch,
749  size_t DstSlicePitch, pi_uint32 NumEventsInWaitList,
750  const pi_event *EventWaitList, pi_event *Event) {
751 
753  Queue, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
754  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumEventsInWaitList,
755  EventWaitList, Event);
756 }
757 
759  const void *Pattern, size_t PatternSize,
760  size_t Offset, size_t Size,
761  pi_uint32 NumEventsInWaitList,
762  const pi_event *EventWaitList,
763  pi_event *Event) {
764 
765  return pi2ur::piEnqueueMemBufferFill(Queue, Buffer, Pattern, PatternSize,
766  Offset, Size, NumEventsInWaitList,
767  EventWaitList, Event);
768 }
769 
771  pi_map_flags MapFlags, size_t Offset,
772  size_t Size, pi_uint32 NumEventsInWaitList,
773  const pi_event *EventWaitList,
774  pi_event *OutEvent, void **RetMap) {
775 
776  return pi2ur::piEnqueueMemBufferMap(Queue, Mem, BlockingMap, MapFlags, Offset,
777  Size, NumEventsInWaitList, EventWaitList,
778  OutEvent, RetMap);
779 }
780 
781 pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr,
782  pi_uint32 NumEventsInWaitList,
783  const pi_event *EventWaitList, pi_event *OutEvent) {
784 
785  return pi2ur::piEnqueueMemUnmap(Queue, Mem, MappedPtr, NumEventsInWaitList,
786  EventWaitList, OutEvent);
787 }
788 
790  size_t ParamValueSize, void *ParamValue,
791  size_t *ParamValueSizeRet) {
792 
793  return pi2ur::piMemImageGetInfo(Image, ParamName, ParamValueSize, ParamValue,
794  ParamValueSizeRet);
795 }
796 
798  pi_bool BlockingRead, pi_image_offset Origin,
799  pi_image_region Region, size_t RowPitch,
800  size_t SlicePitch, void *Ptr,
801  pi_uint32 NumEventsInWaitList,
802  const pi_event *EventWaitList,
803  pi_event *Event) {
805  Queue, Image, BlockingRead, Origin, Region, RowPitch, SlicePitch, Ptr,
806  NumEventsInWaitList, EventWaitList, Event);
807 }
808 
810  pi_bool BlockingWrite, pi_image_offset Origin,
811  pi_image_region Region, size_t InputRowPitch,
812  size_t InputSlicePitch, const void *Ptr,
813  pi_uint32 NumEventsInWaitList,
814  const pi_event *EventWaitList,
815  pi_event *Event) {
816 
818  Queue, Image, BlockingWrite, Origin, Region, InputRowPitch,
819  InputSlicePitch, Ptr, NumEventsInWaitList, EventWaitList, Event);
820 }
821 
822 pi_result
823 piEnqueueMemImageCopy(pi_queue Queue, pi_mem SrcImage, pi_mem DstImage,
824  pi_image_offset SrcOrigin, pi_image_offset DstOrigin,
825  pi_image_region Region, pi_uint32 NumEventsInWaitList,
826  const pi_event *EventWaitList, pi_event *Event) {
827  return pi2ur::piEnqueueMemImageCopy(Queue, SrcImage, DstImage, SrcOrigin,
828  DstOrigin, Region, NumEventsInWaitList,
829  EventWaitList, Event);
830 }
831 
833  const void *FillColor, const size_t *Origin,
834  const size_t *Region,
835  pi_uint32 NumEventsInWaitList,
836  const pi_event *EventWaitList,
837  pi_event *Event) {
838 
839  return pi2ur::piEnqueueMemImageFill(Queue, Image, FillColor, Origin, Region,
840  NumEventsInWaitList, EventWaitList,
841  Event);
842 }
843 
845  pi_buffer_create_type BufferCreateType,
846  void *BufferCreateInfo, pi_mem *RetMem) {
847 
848  return pi2ur::piMemBufferPartition(Buffer, Flags, BufferCreateType,
849  BufferCreateInfo, RetMem);
850 }
851 
852 // TODO: Check if the function_pointer_ret type can be converted to void**.
854  const char *FunctionName,
855  pi_uint64 *FunctionPointerRet) {
856 
857  return pi2ur::piextGetDeviceFunctionPointer(Device, Program, FunctionName,
858  FunctionPointerRet);
859 }
860 
861 pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context,
862  pi_device Device,
863  pi_usm_mem_properties *Properties, size_t Size,
865 
866  return pi2ur::piextUSMDeviceAlloc(ResultPtr, Context, Device, Properties,
867  Size, Alignment);
868 }
869 
870 pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context,
871  pi_device Device,
872  pi_usm_mem_properties *Properties, size_t Size,
874 
875  return pi2ur::piextUSMSharedAlloc(ResultPtr, Context, Device, Properties,
876  Size, Alignment);
877 }
878 
880  void **ResultPtr, size_t *ResultPitch, pi_context Context, pi_device Device,
881  pi_usm_mem_properties *Properties, size_t WidthInBytes, size_t Height,
882  unsigned int ElementSizeBytes) {
883 
884  return pi2ur::piextUSMPitchedAlloc(ResultPtr, ResultPitch, Context, Device,
885  Properties, WidthInBytes, Height,
886  ElementSizeBytes);
887 }
888 
889 pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context,
890  pi_usm_mem_properties *Properties, size_t Size,
892  return pi2ur::piextUSMHostAlloc(ResultPtr, Context, Properties, Size,
893  Alignment);
894 }
895 
896 pi_result piextUSMFree(pi_context Context, void *Ptr) {
897 
898  return pi2ur::piextUSMFree(Context, Ptr);
899 }
900 
902  size_t ArgSize, const void *ArgValue) {
903  return pi2ur::piextKernelSetArgPointer(Kernel, ArgIndex, ArgSize, ArgValue);
904 }
905 
918  size_t Count, pi_uint32 NumEventsInWaitlist,
919  const pi_event *EventsWaitlist,
920  pi_event *Event) {
922  Queue, Ptr, Value, Count, NumEventsInWaitlist, EventsWaitlist, Event);
923 }
924 
925 pi_result piextUSMEnqueueMemcpy(pi_queue Queue, pi_bool Blocking, void *DstPtr,
926  const void *SrcPtr, size_t Size,
927  pi_uint32 NumEventsInWaitlist,
928  const pi_event *EventsWaitlist,
929  pi_event *Event) {
930 
931  return pi2ur::piextUSMEnqueueMemcpy(Queue, Blocking, DstPtr, SrcPtr, Size,
932  NumEventsInWaitlist, EventsWaitlist,
933  Event);
934 }
935 
945 pi_result piextUSMEnqueuePrefetch(pi_queue Queue, const void *Ptr, size_t Size,
947  pi_uint32 NumEventsInWaitList,
948  const pi_event *EventWaitList,
949  pi_event *OutEvent) {
950 
952  Queue, Ptr, Size, Flags, NumEventsInWaitList, EventWaitList, OutEvent);
953 }
954 
964  size_t Length, pi_mem_advice Advice,
965  pi_event *OutEvent) {
966 
967  return pi2ur::piextUSMEnqueueMemAdvise(Queue, Ptr, Length, Advice, OutEvent);
968 }
969 
982 __SYCL_EXPORT pi_result piextUSMEnqueueFill2D(pi_queue Queue, void *Ptr,
983  size_t Pitch, size_t PatternSize,
984  const void *Pattern, size_t Width,
985  size_t Height,
986  pi_uint32 NumEventsWaitList,
987  const pi_event *EventsWaitList,
988  pi_event *Event) {
989 
990  return pi2ur::piextUSMEnqueueFill2D(Queue, Ptr, Pitch, PatternSize, Pattern,
991  Width, Height, NumEventsWaitList,
992  EventsWaitList, Event);
993 }
994 
1007 __SYCL_EXPORT pi_result piextUSMEnqueueMemset2D(pi_queue Queue, void *Ptr,
1008  size_t Pitch, int Value,
1009  size_t Width, size_t Height,
1010  pi_uint32 NumEventsWaitList,
1011  const pi_event *EventsWaitlist,
1012  pi_event *Event) {
1013 
1014  return pi2ur::piextUSMEnqueueMemset2D(Queue, Ptr, Pitch, Value, Width, Height,
1015  NumEventsWaitList, EventsWaitlist,
1016  Event);
1017 }
1018 
1034  pi_queue Queue, pi_bool Blocking, void *DstPtr, size_t DstPitch,
1035  const void *SrcPtr, size_t SrcPitch, size_t Width, size_t Height,
1036  pi_uint32 NumEventsInWaitlist, const pi_event *EventWaitlist,
1037  pi_event *Event) {
1038 
1040  Queue, Blocking, DstPtr, DstPitch, SrcPtr, SrcPitch, Width, Height,
1041  NumEventsInWaitlist, EventWaitlist, Event);
1042 }
1043 
1061  pi_mem_alloc_info ParamName,
1062  size_t ParamValueSize, void *ParamValue,
1063  size_t *ParamValueSizeRet) {
1064  return pi2ur::piextUSMGetMemAllocInfo(Context, Ptr, ParamName, ParamValueSize,
1065  ParamValue, ParamValueSizeRet);
1066 }
1067 
1068 pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context) {
1069  return pi2ur::piextUSMImport(HostPtr, Size, Context);
1070 }
1071 
1072 pi_result piextUSMRelease(const void *HostPtr, pi_context Context) {
1073  return pi2ur::piextUSMRelease(HostPtr, Context);
1074 }
1075 
1090  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite,
1091  size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList,
1092  const pi_event *EventsWaitList, pi_event *Event) {
1094  Queue, Program, Name, BlockingWrite, Count, Offset, Src,
1095  NumEventsInWaitList, EventsWaitList, Event);
1096 }
1097 
1112  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingRead,
1113  size_t Count, size_t Offset, void *Dst, pi_uint32 NumEventsInWaitList,
1114  const pi_event *EventsWaitList, pi_event *Event) {
1115 
1117  Queue, Program, Name, BlockingRead, Count, Offset, Dst,
1118  NumEventsInWaitList, EventsWaitList, Event);
1119 
1120  return PI_SUCCESS;
1121 }
1134  const char *PipeSymbol, pi_bool Blocking,
1135  void *Ptr, size_t Size,
1136  pi_uint32 NumEventsInWaitList,
1137  const pi_event *EventsWaitList,
1138  pi_event *Event) {
1139  (void)Queue;
1140  (void)Program;
1141  (void)PipeSymbol;
1142  (void)Blocking;
1143  (void)Ptr;
1144  (void)Size;
1145  (void)NumEventsInWaitList;
1146  (void)EventsWaitList;
1147  (void)Event;
1148 
1149  PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE);
1150 
1151  die("piextEnqueueReadHostPipe: not implemented");
1152  return {};
1153 }
1154 
1167  const char *PipeSymbol, pi_bool Blocking,
1168  void *Ptr, size_t Size,
1169  pi_uint32 NumEventsInWaitList,
1170  const pi_event *EventsWaitList,
1171  pi_event *Event) {
1172  (void)Queue;
1173  (void)Program;
1174  (void)PipeSymbol;
1175  (void)Blocking;
1176  (void)Ptr;
1177  (void)Size;
1178  (void)NumEventsInWaitList;
1179  (void)EventsWaitList;
1180  (void)Event;
1181 
1182  PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE);
1183 
1184  die("piextEnqueueWriteHostPipe: not implemented");
1185  return {};
1186 }
1187 
1189  size_t ParamValueSize, const void *ParamValue) {
1190 
1191  return pi2ur::piKernelSetExecInfo(Kernel, ParamName, ParamValueSize,
1192  ParamValue);
1193 }
1194 
1196  pi_uint32 SpecID, size_t Size,
1197  const void *SpecValue) {
1198  return pi2ur::piextProgramSetSpecializationConstant(Prog, SpecID, Size,
1199  SpecValue);
1200 }
1201 
1202 // Command buffer extension
1204  const pi_ext_command_buffer_desc *Desc,
1205  pi_ext_command_buffer *RetCommandBuffer) {
1206  return pi2ur::piextCommandBufferCreate(Context, Device, Desc,
1207  RetCommandBuffer);
1208 }
1209 
1211  return pi2ur::piextCommandBufferRetain(CommandBuffer);
1212 }
1213 
1215  return pi2ur::piextCommandBufferRelease(CommandBuffer);
1216 }
1217 
1219  return pi2ur::piextCommandBufferFinalize(CommandBuffer);
1220 }
1221 
1223  pi_ext_command_buffer CommandBuffer, pi_kernel Kernel, pi_uint32 WorkDim,
1224  const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize,
1225  const size_t *LocalWorkSize, pi_uint32 NumSyncPointsInWaitList,
1226  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1228  CommandBuffer, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize,
1229  LocalWorkSize, NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1230 }
1231 
1233  pi_ext_command_buffer CommandBuffer, void *DstPtr, const void *SrcPtr,
1234  size_t Size, pi_uint32 NumSyncPointsInWaitList,
1235  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1236  return pi2ur::piextCommandBufferMemcpyUSM(CommandBuffer, DstPtr, SrcPtr, Size,
1237  NumSyncPointsInWaitList,
1238  SyncPointWaitList, SyncPoint);
1239 }
1240 
1242  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1243  size_t SrcOffset, size_t DstOffset, size_t Size,
1244  pi_uint32 NumSyncPointsInWaitList,
1245  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1247  CommandBuffer, SrcMem, DstMem, SrcOffset, DstOffset, Size,
1248  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1249 }
1250 
1252  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1253  pi_buff_rect_offset SrcOrigin, pi_buff_rect_offset DstOrigin,
1254  pi_buff_rect_region Region, size_t SrcRowPitch, size_t SrcSlicePitch,
1255  size_t DstRowPitch, size_t DstSlicePitch, pi_uint32 NumSyncPointsInWaitList,
1256  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1258  CommandBuffer, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
1259  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumSyncPointsInWaitList,
1260  SyncPointWaitList, SyncPoint);
1261 }
1262 
1264  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1265  size_t Size, void *Dst, pi_uint32 NumSyncPointsInWaitList,
1266  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1268  CommandBuffer, Buffer, Offset, Size, Dst, NumSyncPointsInWaitList,
1269  SyncPointWaitList, SyncPoint);
1270 }
1271 
1273  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1274  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1275  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1276  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
1277  pi_uint32 NumSyncPointsInWaitList,
1278  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1280  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1281  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1282  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1283 }
1284 
1286  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1287  size_t Size, const void *Ptr, pi_uint32 NumSyncPointsInWaitList,
1288  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1290  CommandBuffer, Buffer, Offset, Size, Ptr, NumSyncPointsInWaitList,
1291  SyncPointWaitList, SyncPoint);
1292 }
1293 
1295  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1296  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1297  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1298  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
1299  pi_uint32 NumSyncPointsInWaitList,
1300  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1302  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1303  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1304  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1305 }
1306 
1308  pi_queue Queue,
1309  pi_uint32 NumEventsInWaitList,
1310  const pi_event *EventWaitList,
1311  pi_event *Event) {
1313  CommandBuffer, Queue, NumEventsInWaitList, EventWaitList, Event);
1314 }
1315 
1317 
1318 pi_result piPluginInit(pi_plugin *PluginInit) { // missing
1319  PI_ASSERT(PluginInit, PI_ERROR_INVALID_VALUE);
1320 
1321  // Check that the major version matches in PiVersion and SupportedVersion
1323 
1324  // TODO: handle versioning/targets properly.
1325  size_t PluginVersionSize = sizeof(PluginInit->PluginVersion);
1326 
1327  PI_ASSERT(strlen(_PI_LEVEL_ZERO_PLUGIN_VERSION_STRING) < PluginVersionSize,
1328  PI_ERROR_INVALID_VALUE);
1329 
1330  strncpy(PluginInit->PluginVersion, SupportedVersion, PluginVersionSize);
1331 
1332 #define _PI_API(api) \
1333  (PluginInit->PiFunctionTable).api = (decltype(&::api))(&api);
1334 #include <sycl/detail/pi.def>
1335 
1336  enableZeTracing();
1337  return PI_SUCCESS;
1338 }
1339 
1340 pi_result piextPluginGetOpaqueData(void *opaque_data_param,
1341  void **opaque_data_return) {
1342  return pi2ur::piextPluginGetOpaqueData(opaque_data_param, opaque_data_return);
1343 }
1344 
1345 // SYCL RT calls this api to notify the end of plugin lifetime.
1346 // Windows: dynamically loaded plugins might have been unloaded already
1347 // when this is called. Sycl RT holds onto the PI plugin so it can be
1348 // called safely. But this is not transitive. If the PI plugin in turn
1349 // dynamically loaded a different DLL, that may have been unloaded.
1350 // It can include all the jobs to tear down resources before
1351 // the plugin is unloaded from memory.
1352 pi_result piTearDown(void *PluginParameter) {
1353  return pi2ur::piTearDown(PluginParameter);
1354 }
1355 
1356 pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime,
1357  uint64_t *HostTime) {
1358  return pi2ur::piGetDeviceAndHostTimer(Device, DeviceTime, HostTime);
1359 }
1360 
1362  pi_device peer_device) {
1363 
1364  return pi2ur::piextEnablePeerAccess(command_device, peer_device);
1365 }
1366 
1368  pi_device peer_device) {
1369 
1370  return pi2ur::piextDisablePeerAccess(command_device, peer_device);
1371 }
1372 
1374  pi_device peer_device, pi_peer_attr attr,
1375  size_t ParamValueSize, void *ParamValue,
1376  size_t *ParamValueSizeRet) {
1377 
1378  return pi2ur::piextPeerAccessGetInfo(command_device, peer_device, attr,
1379  ParamValueSize, ParamValue,
1380  ParamValueSizeRet);
1381 }
1382 
1383 #ifdef _WIN32
1384 #define __SYCL_PLUGIN_DLL_NAME "pi_level_zero.dll"
1385 #include "../common_win_pi_trace/common_win_pi_trace.hpp"
1386 #undef __SYCL_PLUGIN_DLL_NAME
1387 #endif
1388 } // 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
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_level_zero.cpp:421
piEventsWait
pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList)
Definition: pi_level_zero.cpp:600
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_level_zero.cpp:491
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_level_zero.cpp:434
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_level_zero.cpp:1241
piEventRelease
pi_result piEventRelease(pi_event Event)
Definition: pi_level_zero.cpp:619
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
piPluginGetLastError
pi_result piPluginGetLastError(char **message)
API to get Plugin specific warning and error messages.
Definition: pi_level_zero.cpp:55
piSamplerGetInfo
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:646
_pi_mem
Definition: pi_cuda.hpp:56
pi2ur::piKernelSetArg
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi2ur.hpp:2189
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_level_zero.cpp:1222
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_level_zero.cpp:1373
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
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_level_zero.cpp:682
pi2ur::piEventGetProfilingInfo
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4023
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_level_zero.cpp:301
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
piTearDown
pi_result piTearDown(void *PluginParameter)
API to notify that the plugin should clean up its resources.
Definition: pi_level_zero.cpp:1352
SupportedVersion
const char SupportedVersion[]
Definition: pi_level_zero.cpp:1316
piMemGetInfo
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:228
piPlatformsGet
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi_level_zero.cpp:26
_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
pi2ur::piPlatformGetInfo
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:854
piextEventGetNativeHandle
pi_result piextEventGetNativeHandle(pi_event Event, pi_native_handle *NativeHandle)
Gets the native handle of a PI event object.
Definition: pi_level_zero.cpp:623
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
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_level_zero.cpp:1218
piextDestroyExternalSemaphore
pi_result piextDestroyExternalSemaphore(pi_context Context, pi_device Device, pi_interop_semaphore_handle SemHandle)
API to destroy the external semaphore handle.
Definition: pi_level_zero.cpp:499
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_level_zero.cpp:520
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
_PI_LEVEL_ZERO_PLUGIN_VERSION_STRING
#define _PI_LEVEL_ZERO_PLUGIN_VERSION_STRING
Definition: pi_level_zero.hpp:25
piEventRetain
pi_result piEventRetain(pi_event Event)
Definition: pi_level_zero.cpp:617
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
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_level_zero.cpp:1203
piMemRelease
pi_result piMemRelease(pi_mem Mem)
Definition: pi_level_zero.cpp:236
piextUSMImport
pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context)
Import host system memory into USM.
Definition: pi_level_zero.cpp:1068
pi2ur::piextPlatformCreateWithNativeHandle
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Creates PI platform object from a native handle.
Definition: pi2ur.hpp:837
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
piextKernelSetArgSampler
pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_sampler *ArgValue)
Definition: pi_level_zero.cpp:372
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
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)
API for writing data from host to a device global variable.
Definition: pi_level_zero.cpp:1089
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
_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
_pi_image_copy_flags
_pi_image_copy_flags
Definition: pi.h:619
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_level_zero.cpp:917
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_level_zero.cpp:209
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
piMemBufferPartition
pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, pi_buffer_create_type BufferCreateType, void *BufferCreateInfo, pi_mem *RetMem)
Definition: pi_level_zero.cpp:844
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_level_zero.cpp:512
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
_pi_plugin::PluginVersion
char PluginVersion[20]
Definition: pi.h:2704
_pi_result
_pi_result
Definition: pi.h:205
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_level_zero.cpp:823
piQueueCreate
pi_result piQueueCreate(pi_context Context, pi_device Device, pi_queue_properties Flags, pi_queue *Queue)
Definition: pi_level_zero.cpp:172
pi_context_properties
intptr_t pi_context_properties
Definition: pi.h:654
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_level_zero.cpp:395
pi2ur::piEventSetStatus
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi2ur.hpp:4113
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_level_zero.cpp:1272
piextCommandBufferRelease
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
API to decrement the reference count of the command-buffer.
Definition: pi_level_zero.cpp:1214
pi2ur::piPlatformsGet
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi2ur.hpp:800
_pi_device_type
_pi_device_type
Definition: pi.h:253
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_level_zero.cpp:1356
piContextRetain
pi_result piContextRetain(pi_context Context)
Definition: pi_level_zero.cpp:163
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_level_zero.cpp:889
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_level_zero.cpp:1232
piDevicePartition
pi_result piDevicePartition(pi_device Device, const pi_device_partition_property *Properties, pi_uint32 NumDevices, pi_device *OutDevices, pi_uint32 *OutNumDevices)
Definition: pi_level_zero.cpp:94
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
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)
API for Read from host pipe.
Definition: pi_level_zero.cpp:1133
ReturnHelper
Definition: pi2ur.hpp:160
piContextRelease
pi_result piContextRelease(pi_context Context)
Definition: pi_level_zero.cpp:168
enableZeTracing
void enableZeTracing()
Definition: tracing.cpp:41
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_level_zero.cpp:201
pi2ur::piextDisablePeerAccess
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4538
piextContextSetExtendedDeleter
pi_result piextContextSetExtendedDeleter(pi_context Context, pi_context_extended_deleter Function, void *UserData)
Definition: pi_level_zero.cpp:143
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
_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
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_level_zero.cpp:734
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
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
piextPluginGetOpaqueData
pi_result piextPluginGetOpaqueData(void *opaque_data_param, void **opaque_data_return)
API to get Plugin internal data, opaque to SYCL RT.
Definition: pi_level_zero.cpp:1340
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_level_zero.cpp:471
piMemImageGetInfo
pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:789
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_level_zero.cpp:290
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_level_zero.cpp:403
PI_PLATFORM_INFO_NAME
@ PI_PLATFORM_INFO_NAME
Definition: pi.h:222
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
piEventSetCallback
pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, void(*PFnNotify)(pi_event Event, pi_int32 EventCommandStatus, void *UserData), void *UserData)
Definition: pi_level_zero.cpp:604
_pi_device_info
_pi_device_info
Definition: pi.h:285
_pi_image_info
_pi_image_info
Definition: pi.h:497
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
piSamplerRetain
pi_result piSamplerRetain(pi_sampler Sampler)
Definition: pi_level_zero.cpp:654
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
piextMemImageFree
pi_result piextMemImageFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free memory for bindless images.
Definition: pi_level_zero.cpp:429
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
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
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_level_zero.cpp:274
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_level_zero.cpp:504
_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
_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
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)
API for write to pipe of a given name.
Definition: pi_level_zero.cpp:1166
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
_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
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
piEnqueueEventsWaitWithBarrier
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_level_zero.cpp:673
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
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_level_zero.cpp:770
pi2ur::piextCommandBufferRelease
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
API to decrement the reference count of the command-buffer.
Definition: pi2ur.hpp:4309
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_level_zero.cpp:343
piQueueRelease
pi_result piQueueRelease(pi_queue Queue)
Definition: pi_level_zero.cpp:193
pi2ur::piSamplerGetInfo
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4204
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_level_zero.cpp:945
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
piEventSetStatus
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi_level_zero.cpp:613
_pi_queue
Definition: pi_cuda.hpp:60
piKernelRetain
pi_result piKernelRetain(pi_kernel Kernel)
Definition: pi_level_zero.cpp:540
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_level_zero.cpp:320
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_level_zero.cpp:809
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
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_level_zero.cpp:1263
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_level_zero.cpp:529
piKernelRelease
pi_result piKernelRelease(pi_kernel Kernel)
Definition: pi_level_zero.cpp:545
pi_buff_rect_region_struct
Definition: pi.h:1025
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_level_zero.cpp:1007
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
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_level_zero.cpp:251
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_level_zero.cpp:853
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
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_level_zero.cpp:1285
pi2ur::piEnqueueEventsWait
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3903
_pi_kernel_exec_info
_pi_kernel_exec_info
Definition: pi.h:1530
pi2ur::piDeviceRelease
pi_result piDeviceRelease(pi_device Device)
Definition: pi2ur.hpp:969
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
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_level_zero.cpp:720
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
piQueueRetain
pi_result piQueueRetain(pi_queue Queue)
Definition: pi_level_zero.cpp:191
ur_bindings.hpp
piSamplerCreate
pi_result piSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, pi_sampler *RetSampler)
Definition: pi_level_zero.cpp:640
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_level_zero.cpp:745
piextMemUnsampledImageHandleDestroy
pi_result piextMemUnsampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless unsampled image handles.
Definition: pi_level_zero.cpp:452
pi_mem_flags
pi_bitfield pi_mem_flags
Definition: pi.h:694
piPluginGetBackendOption
pi_result piPluginGetBackendOption(pi_platform platform, const char *frontend_option, const char **backend_option)
API to get backend specific option.
Definition: pi_level_zero.cpp:65
piProgramGetInfo
pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:282
piextProgramGetNativeHandle
pi_result piextProgramGetNativeHandle(pi_program Program, pi_native_handle *NativeHandle)
Gets the native handle of a PI program object.
Definition: pi_level_zero.cpp:338
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
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_level_zero.cpp:238
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
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_level_zero.cpp:561
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
piQueueGetInfo
pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:183
piKernelSetArg
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi_level_zero.cpp:357
piextEnablePeerAccess
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_level_zero.cpp:1361
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
piextContextGetNativeHandle
pi_result piextContextGetNativeHandle(pi_context Context, pi_native_handle *NativeHandle)
Gets the native handle of a PI context object.
Definition: pi_level_zero.cpp:149
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_level_zero.cpp:386
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
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
piEventCreate
decltype(piEventCreate) piEventCreate
Definition: pi_level_zero.cpp:24
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
piKernelCreate
pi_result piKernelCreate(pi_program Program, const char *KernelName, pi_kernel *RetKernel)
Definition: pi_level_zero.cpp:351
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
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
piEnqueueMemUnmap
pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_level_zero.cpp:781
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
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_level_zero.cpp:1251
sycl::_V1::ext::oneapi::experimental::detail::Alignment
@ Alignment
Definition: property.hpp:193
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
_pi_event_info
_pi_event_info
Definition: pi.h:514
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_level_zero.cpp:832
_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
_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
piEventGetInfo
pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:585
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_level_zero.cpp:879
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
piextDeviceGetNativeHandle
pi_result piextDeviceGetNativeHandle(pi_device Device, pi_native_handle *NativeHandle)
Gets the native handle of a PI device object.
Definition: pi_level_zero.cpp:110
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_level_zero.cpp:1195
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_level_zero.cpp:870
piContextGetInfo
pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:134
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
piEventGetProfilingInfo
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:592
_pi_image_format
Definition: pi.h:1096
_pi_kernel_info
_pi_kernel_info
Definition: pi.h:477
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_level_zero.cpp:797
piSamplerRelease
pi_result piSamplerRelease(pi_sampler Sampler)
Definition: pi_level_zero.cpp:658
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_level_zero.cpp:708
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
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
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_level_zero.cpp:462
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
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
piextKernelSetArgMemObj
pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_mem_obj_property *ArgProperties, const pi_mem *ArgValue)
Definition: pi_level_zero.cpp:364
_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
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_level_zero.cpp:896
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
pi2ur::piMemGetInfo
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2689
piextCommandBufferRetain
pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer)
API to increment the reference count of the command-buffer.
Definition: pi_level_zero.cpp:1210
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_level_zero.cpp:477
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
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_level_zero.cpp:1033
piextMemSampledImageHandleDestroy
pi_result piextMemSampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless sampled image handles.
Definition: pi_level_zero.cpp:457
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
pi_queue_properties
pi_bitfield pi_queue_properties
Definition: pi.h:729
_pi_platform_info
_pi_platform_info
Definition: pi.h:220
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_level_zero.cpp:861
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
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_level_zero.cpp:103
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
pi_level_zero.hpp
_pi_event
Definition: pi_cuda.hpp:64
pi2ur::piContextRelease
pi_result piContextRelease(pi_context Context)
Definition: pi2ur.hpp:1583
piextMemReleaseInterop
pi_result piextMemReleaseInterop(pi_context Context, pi_device Device, pi_interop_mem_handle ExtMem)
API to destroy interop memory.
Definition: pi_level_zero.cpp:485
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
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_level_zero.cpp:982
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
piProgramCreate
pi_result piProgramCreate(pi_context Context, const void *ILBytes, size_t Length, pi_program *Program)
Definition: pi_level_zero.cpp:258
_pi_mem_info
_pi_mem_info
Definition: pi.h:1117
pi_image_offset_struct
Definition: pi.h:1034
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_level_zero.cpp:629
pi2ur::piContextRetain
pi_result piContextRetain(pi_context Context)
Definition: pi2ur.hpp:1575
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
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: pi_level_zero.cpp:963
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_level_zero.cpp:1307
pi_image_region_struct
Definition: pi.h:1043
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_level_zero.cpp:758
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
piQueueFinish
pi_result piQueueFinish(pi_queue Queue)
Definition: pi_level_zero.cpp:197
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_level_zero.cpp:925
piProgramRelease
pi_result piProgramRelease(pi_program Program)
Definition: pi_level_zero.cpp:334
_pi_mem_obj_property
Definition: pi.h:1828
_pi_usm_migration_flags
_pi_usm_migration_flags
Definition: pi.h:1886
piProgramRetain
pi_result piProgramRetain(pi_program Program)
Definition: pi_level_zero.cpp:330
piextQueueCreate
pi_result piextQueueCreate(pi_context Context, pi_device Device, pi_queue_properties *Properties, pi_queue *Queue)
Definition: pi_level_zero.cpp:178
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_level_zero.cpp:1188
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
piPluginInit
pi_result piPluginInit(pi_plugin *PluginInit)
Definition: pi_level_zero.cpp:1318
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
piextPlatformGetNativeHandle
pi_result piextPlatformGetNativeHandle(pi_platform Platform, pi_native_handle *NativeHandle)
Gets the native handle of a PI platform object.
Definition: pi_level_zero.cpp:43
piQueueFlush
pi_result piQueueFlush(pi_queue Queue)
Definition: pi_level_zero.cpp:199
_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
piEnqueueEventsWait
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_level_zero.cpp:665
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_level_zero.cpp:154
piMemRetain
pi_result piMemRetain(pi_mem Mem)
Definition: pi_level_zero.cpp:234
piDeviceRetain
pi_result piDeviceRetain(pi_device Device)
Definition: pi_level_zero.cpp:79
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
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_level_zero.cpp:694
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
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
_pi_kernel_group_info
_pi_kernel_group_info
Definition: pi.h:486
piextUSMRelease
pi_result piextUSMRelease(const void *HostPtr, pi_context Context)
Release host system memory from USM.
Definition: pi_level_zero.cpp:1072
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
piDevicesGet
pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, pi_uint32 NumEntries, pi_device *Devices, pi_uint32 *NumDevices)
Definition: pi_level_zero.cpp:72
_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
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.
Definition: pi_level_zero.cpp:1060
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
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_level_zero.cpp:124
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_level_zero.cpp:312
_pi_mem_alloc_info
_pi_mem_alloc_info
Definition: pi.h:1869
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
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_level_zero.cpp:551
piextDeviceCreateWithNativeHandle
pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform Platform, pi_device *Device)
Creates PI device object from a native handle.
Definition: pi_level_zero.cpp:116
disableZeTracing
void disableZeTracing()
Definition: tracing.cpp:146
pi_usm_mem_properties
pi_bitfield pi_usm_mem_properties
Definition: pi.h:716
pi_map_flags
pi_bitfield pi_map_flags
Definition: pi.h:704
piKernelGetInfo
pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:378
_pi_program_build_info
_pi_program_build_info
Definition: pi.h:229
pi2ur::piEnqueueEventsWaitWithBarrier
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3884
piDeviceRelease
pi_result piDeviceRelease(pi_device Device)
Definition: pi_level_zero.cpp:83
pi2ur::piextEnablePeerAccess
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4528
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_level_zero.cpp:412
piextPlatformCreateWithNativeHandle
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Creates PI platform object from a native handle.
Definition: pi_level_zero.cpp:49
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
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_level_zero.cpp:1111
piPlatformGetInfo
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_level_zero.cpp:31
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_level_zero.cpp:901
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_level_zero.cpp:221
piextMemGetNativeHandle
pi_result piextMemGetNativeHandle(pi_mem Mem, pi_native_handle *NativeHandle)
Gets the native handle of a PI mem object.
Definition: pi_level_zero.cpp:247
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_level_zero.cpp:263
pi2ur::piMemRelease
pi_result piMemRelease(pi_mem Mem)
Definition: pi2ur.hpp:3213
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
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_level_zero.cpp:439
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
_pi_device
Definition: pi_cuda.hpp:48
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_level_zero.cpp:87
_pi_kernel_sub_group_info
_pi_kernel_sub_group_info
Definition: pi.h:507
piextDisablePeerAccess
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_level_zero.cpp:1367
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_level_zero.cpp:1294
PI_ASSERT
#define PI_ASSERT(condition, error)
Definition: pi2ur.hpp:150
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
piextKernelGetNativeHandle
pi_result piextKernelGetNativeHandle(pi_kernel Kernel, pi_native_handle *NativeHandle)
Gets the native handle of a PI kernel object.
Definition: pi_level_zero.cpp:571
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