DPC++ Runtime
Runtime libraries for oneAPI DPC++
pi_cuda.cpp
Go to the documentation of this file.
1 //==---------- pi_cuda.cpp - CUDA 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_cuda.hpp>
16 #include <sycl/detail/defines.hpp>
17 #include <sycl/detail/pi.hpp>
18 
19 // Forward declarations
20 struct cuda_tracing_context_t_;
21 
22 void enableCUDATracing(cuda_tracing_context_t_ *ctx);
23 void disableCUDATracing(cuda_tracing_context_t_ *ctx);
24 cuda_tracing_context_t_ *createCUDATracingContext();
25 void freeCUDATracingContext(cuda_tracing_context_t_ *Ctx);
26 
27 //-- PI API implementation
28 extern "C" {
29 
31  pi_uint32 *NumPlatforms) {
32  return pi2ur::piPlatformsGet(NumEntries, Platforms, NumPlatforms);
33 }
34 
36  size_t ParamValueSize, void *ParamValue,
37  size_t *ParamValueSizeRet) {
38  return pi2ur::piPlatformGetInfo(Platform, ParamName, ParamValueSize,
39  ParamValue, ParamValueSizeRet);
40 }
41 
43  pi_native_handle *NativeHandle) {
44  return pi2ur::piextPlatformGetNativeHandle(Platform, NativeHandle);
45 }
46 
48  pi_platform *Platform) {
49  return pi2ur::piextPlatformCreateWithNativeHandle(NativeHandle, Platform);
50 }
51 
53  return pi2ur::piPluginGetLastError(message);
54 }
55 
57  const char *frontend_option,
58  const char **backend_option) {
59  return pi2ur::piPluginGetBackendOption(platform, frontend_option,
60  backend_option);
61 }
62 
64  pi_uint32 NumEntries, pi_device *Devices,
65  pi_uint32 *NumDevices) {
66  return pi2ur::piDevicesGet(Platform, DeviceType, NumEntries, Devices,
67  NumDevices);
68 }
69 
71  return pi2ur::piDeviceRetain(Device);
72 }
73 
75  return pi2ur::piDeviceRelease(Device);
76 }
77 
79  size_t ParamValueSize, void *ParamValue,
80  size_t *ParamValueSizeRet) {
81  return pi2ur::piDeviceGetInfo(Device, ParamName, ParamValueSize, ParamValue,
82  ParamValueSizeRet);
83 }
84 
86  const pi_device_partition_property *Properties,
87  pi_uint32 NumDevices, pi_device *OutDevices,
88  pi_uint32 *OutNumDevices) {
89  return pi2ur::piDevicePartition(Device, Properties, NumDevices, OutDevices,
90  OutNumDevices);
91 }
92 
94  pi_uint32 NumBinaries,
95  pi_uint32 *SelectedBinaryInd) {
96  return pi2ur::piextDeviceSelectBinary(Device, Binaries, NumBinaries,
97  SelectedBinaryInd);
98 }
99 
101  pi_native_handle *NativeHandle) {
102 
103  return pi2ur::piextDeviceGetNativeHandle(Device, NativeHandle);
104 }
105 
107  pi_platform Platform,
108  pi_device *Device) {
109 
110  return pi2ur::piextDeviceCreateWithNativeHandle(NativeHandle, Platform,
111  Device);
112 }
113 
115  pi_uint32 NumDevices, const pi_device *Devices,
116  void (*PFnNotify)(const char *ErrInfo,
117  const void *PrivateInfo, size_t CB,
118  void *UserData),
119  void *UserData, pi_context *RetContext) {
120  return pi2ur::piContextCreate(Properties, NumDevices, Devices, PFnNotify,
121  UserData, RetContext);
122 }
123 
125  size_t ParamValueSize, void *ParamValue,
126  size_t *ParamValueSizeRet) {
127 
128  return pi2ur::piContextGetInfo(Context, ParamName, ParamValueSize, ParamValue,
129  ParamValueSizeRet);
130 }
131 
134  void *UserData) {
135  return pi2ur::piextContextSetExtendedDeleter(Context, Function, UserData);
136 }
137 
139  pi_native_handle *NativeHandle) {
140  return pi2ur::piextContextGetNativeHandle(Context, NativeHandle);
141 }
142 
144  pi_uint32 NumDevices,
145  const pi_device *Devices,
146  bool OwnNativeHandle,
147  pi_context *RetContext) {
149  NativeHandle, NumDevices, Devices, OwnNativeHandle, RetContext);
150 }
151 
153 
154  return pi2ur::piContextRetain(Context);
155 }
156 
158  return pi2ur::piContextRelease(Context);
159 }
160 
162  pi_queue_properties Flags, pi_queue *Queue) {
163  pi_queue_properties Properties[] = {PI_QUEUE_FLAGS, Flags, 0};
164  return piextQueueCreate(Context, Device, Properties, Queue);
165 }
166 
168  pi_queue_properties *Properties, pi_queue *Queue) {
169  return pi2ur::piextQueueCreate(Context, Device, Properties, Queue);
170 }
171 
173  size_t ParamValueSize, void *ParamValue,
174  size_t *ParamValueSizeRet) {
175 
176  return pi2ur::piQueueGetInfo(Queue, ParamName, ParamValueSize, ParamValue,
177  ParamValueSizeRet);
178 }
179 
181 
183  return pi2ur::piQueueRelease(Queue);
184 }
185 
187 
189 
191  pi_native_handle *NativeHandle,
192  int32_t *NativeHandleDesc) {
193 
194  return pi2ur::piextQueueGetNativeHandle(Queue, NativeHandle,
195  NativeHandleDesc);
196 }
197 
199  int32_t NativeHandleDesc,
200  pi_context Context, pi_device Device,
201  bool OwnNativeHandle,
202  pi_queue_properties *Properties,
203  pi_queue *Queue) {
204 
206  NativeHandle, NativeHandleDesc, Context, Device, OwnNativeHandle,
207  Properties, Queue);
208 }
209 
211  void *HostPtr, pi_mem *RetMem,
212  const pi_mem_properties *properties) {
213  return pi2ur::piMemBufferCreate(Context, Flags, Size, HostPtr, RetMem,
214  properties);
215 }
216 
217 pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize,
218  void *ParamValue, size_t *ParamValueSizeRet) {
219  return pi2ur::piMemGetInfo(Mem, ParamName, ParamValueSize, ParamValue,
220  ParamValueSizeRet);
221 }
222 
224 
226 
228  const pi_image_format *ImageFormat,
229  const pi_image_desc *ImageDesc, void *HostPtr,
230  pi_mem *RetImage) {
231 
232  return pi2ur::piMemImageCreate(Context, Flags, ImageFormat, ImageDesc,
233  HostPtr, RetImage);
234 }
235 
237  pi_native_handle *NativeHandle) {
238  return pi2ur::piextMemGetNativeHandle(Mem, Dev, NativeHandle);
239 }
240 
242  pi_context Context,
243  bool ownNativeHandle, pi_mem *Mem) {
244  return pi2ur::piextMemCreateWithNativeHandle(NativeHandle, Context,
245  ownNativeHandle, Mem);
246 }
247 
248 pi_result piProgramCreate(pi_context Context, const void *ILBytes,
249  size_t Length, pi_program *Program) {
250  return pi2ur::piProgramCreate(Context, ILBytes, Length, Program);
251 }
252 
254  pi_context Context, pi_uint32 NumDevices, const pi_device *DeviceList,
255  const size_t *Lengths, const unsigned char **Binaries,
256  size_t NumMetadataEntries, const pi_device_binary_property *Metadata,
257  pi_int32 *BinaryStatus, pi_program *Program) {
258 
259  return pi2ur::piProgramCreateWithBinary(Context, NumDevices, DeviceList,
260  Lengths, Binaries, NumMetadataEntries,
261  Metadata, BinaryStatus, Program);
262 }
263 
265  pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle,
266  const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc,
267  pi_mem *Img) {
269  NativeHandle, Context, OwnNativeHandle, ImageFormat, ImageDesc, Img);
270 }
271 
273  size_t ParamValueSize, void *ParamValue,
274  size_t *ParamValueSizeRet) {
275 
276  return pi2ur::piProgramGetInfo(Program, ParamName, ParamValueSize, ParamValue,
277  ParamValueSizeRet);
278 }
279 
281  const pi_device *DeviceList, const char *Options,
282  pi_uint32 NumInputPrograms,
283  const pi_program *InputPrograms,
284  void (*PFnNotify)(pi_program Program, void *UserData),
285  void *UserData, pi_program *RetProgram) {
286  return pi2ur::piProgramLink(Context, NumDevices, DeviceList, Options,
287  NumInputPrograms, InputPrograms, PFnNotify,
288  UserData, RetProgram);
289 }
290 
292  pi_program Program, pi_uint32 NumDevices, const pi_device *DeviceList,
293  const char *Options, pi_uint32 NumInputHeaders,
294  const pi_program *InputHeaders, const char **HeaderIncludeNames,
295  void (*PFnNotify)(pi_program Program, void *UserData), void *UserData) {
296 
297  return pi2ur::piProgramCompile(Program, NumDevices, DeviceList, Options,
298  NumInputHeaders, InputHeaders,
299  HeaderIncludeNames, PFnNotify, UserData);
300 }
301 
303  const pi_device *DeviceList, const char *Options,
304  void (*PFnNotify)(pi_program Program, void *UserData),
305  void *UserData) {
306  return pi2ur::piProgramBuild(Program, NumDevices, DeviceList, Options,
307  PFnNotify, UserData);
308 }
309 
311  pi_program_build_info ParamName,
312  size_t ParamValueSize, void *ParamValue,
313  size_t *ParamValueSizeRet) {
314 
315  return pi2ur::piProgramGetBuildInfo(Program, Device, ParamName,
316  ParamValueSize, ParamValue,
317  ParamValueSizeRet);
318 }
319 
321  return pi2ur::piProgramRetain(Program);
322 }
323 
325  return pi2ur::piProgramRelease(Program);
326 }
327 
329  pi_native_handle *NativeHandle) {
330  return pi2ur::piextProgramGetNativeHandle(Program, NativeHandle);
331 }
332 
334  pi_context Context,
335  bool OwnNativeHandle,
336  pi_program *Program) {
337  return pi2ur::piextProgramCreateWithNativeHandle(NativeHandle, Context,
338  OwnNativeHandle, Program);
339 }
340 
341 pi_result piKernelCreate(pi_program Program, const char *KernelName,
342  pi_kernel *RetKernel) {
343 
344  return pi2ur::piKernelCreate(Program, KernelName, RetKernel);
345 }
346 
347 pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize,
348  const void *ArgValue) {
349 
350  return pi2ur::piKernelSetArg(Kernel, ArgIndex, ArgSize, ArgValue);
351 }
352 
354  const pi_mem_obj_property *ArgProperties,
355  const pi_mem *ArgValue) {
356  return pi2ur::piextKernelSetArgMemObj(Kernel, ArgIndex, ArgProperties,
357  ArgValue);
358 }
359 
361  const pi_sampler *ArgValue) {
362 
363  return pi2ur::piextKernelSetArgSampler(Kernel, ArgIndex, ArgValue);
364 }
365 
367  size_t ParamValueSize, void *ParamValue,
368  size_t *ParamValueSizeRet) {
369 
370  return pi2ur::piKernelGetInfo(Kernel, ParamName, ParamValueSize, ParamValue,
371  ParamValueSizeRet);
372 }
373 
375  pi_device Device,
376  pi_image_format *ImageFormat,
377  pi_image_desc *ImageDesc,
378  pi_image_mem_handle *RetMem) {
379  return pi2ur::piextMemImageAllocate(Context, Device, ImageFormat, ImageDesc,
380  RetMem);
381 }
382 
384  pi_context Context, pi_device Device, pi_image_mem_handle ImgMem,
385  pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_mem *RetMem,
386  pi_image_handle *RetHandle) {
388  Context, Device, ImgMem, ImageFormat, ImageDesc, RetMem, RetHandle);
389 }
390 
392  pi_context Context, pi_device Device, pi_image_mem_handle ImgMem,
393  pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_sampler Sampler,
394  pi_mem *RetMem, pi_image_handle *RetHandle) {
395  return pi2ur::piextMemSampledImageCreate(Context, Device, ImgMem, ImageFormat,
396  ImageDesc, Sampler, RetMem,
397  RetHandle);
398 }
399 
401  pi_context Context, const pi_sampler_properties *SamplerProperties,
402  float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy,
403  pi_sampler *RetSampler) {
405  Context, SamplerProperties, MinMipmapLevelClamp, MaxMipmapLevelClamp,
406  MaxAnisotropy, RetSampler);
407 }
408 
410  pi_device Device,
411  pi_image_mem_handle MipMem,
412  unsigned int Level,
413  pi_image_mem_handle *RetMem) {
414  return pi2ur::piextMemMipmapGetLevel(Context, Device, MipMem, Level, RetMem);
415 }
416 
417 __SYCL_EXPORT pi_result piextMemImageFree(pi_context Context, pi_device Device,
418  pi_image_mem_handle MemoryHandle) {
419  return pi2ur::piextMemImageFree(Context, Device, MemoryHandle);
420 }
421 
422 __SYCL_EXPORT pi_result piextMemMipmapFree(pi_context Context, pi_device Device,
423  pi_image_mem_handle MemoryHandle) {
424  return pi2ur::piextMemMipmapFree(Context, Device, MemoryHandle);
425 }
426 
428  pi_queue Queue, void *DstPtr, void *SrcPtr,
429  const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc,
430  const pi_image_copy_flags Flags, pi_image_offset SrcOffset,
431  pi_image_offset DstOffset, pi_image_region CopyExtent,
432  pi_image_region HostExtent, pi_uint32 NumEventsInWaitList,
433  const pi_event *EventWaitList, pi_event *Event) {
434  return pi2ur::piextMemImageCopy(Queue, DstPtr, SrcPtr, ImageFormat, ImageDesc,
435  Flags, SrcOffset, DstOffset, CopyExtent,
436  HostExtent, NumEventsInWaitList,
437  EventWaitList, Event);
438 }
439 
441  pi_context Context, pi_device Device, pi_image_handle Handle) {
442  return pi2ur::piextMemUnsampledImageHandleDestroy(Context, Device, Handle);
443 }
444 
446  pi_context Context, pi_device Device, pi_image_handle Handle) {
447  return pi2ur::piextMemSampledImageHandleDestroy(Context, Device, Handle);
448 }
449 
451  pi_image_info ParamName,
452  void *ParamValue,
453  size_t *ParamValueSizeRet) {
454  return pi2ur::piextMemImageGetInfo(MemHandle, ParamName, ParamValue,
455  ParamValueSizeRet);
456 }
457 
458 __SYCL_EXPORT pi_result
459 piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size,
460  int FileDescriptor, pi_interop_mem_handle *RetHandle) {
461  return pi2ur::piextMemImportOpaqueFD(Context, Device, Size, FileDescriptor,
462  RetHandle);
463 }
464 
466  pi_context Context, pi_device Device, pi_image_format *ImageFormat,
467  pi_image_desc *ImageDesc, pi_interop_mem_handle MemHandle,
468  pi_image_mem_handle *RetMem) {
469  return pi2ur::piextMemMapExternalArray(Context, Device, ImageFormat,
470  ImageDesc, MemHandle, RetMem);
471 }
472 
474  pi_device Device,
475  pi_interop_mem_handle ExtMem) {
476  return pi2ur::piextMemReleaseInterop(Context, Device, ExtMem);
477 }
478 
480  pi_context Context, pi_device Device, int FileDescriptor,
481  pi_interop_semaphore_handle *RetHandle) {
482  return pi2ur::piextImportExternalSemaphoreOpaqueFD(Context, Device,
483  FileDescriptor, RetHandle);
484 }
485 
486 __SYCL_EXPORT pi_result
488  pi_interop_semaphore_handle SemHandle) {
489  return pi2ur::piextDestroyExternalSemaphore(Context, Device, SemHandle);
490 }
491 
493  pi_queue Queue, pi_interop_semaphore_handle SemHandle,
494  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
495  pi_event *Event) {
497  Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event);
498 }
499 
501  pi_queue Queue, pi_interop_semaphore_handle SemHandle,
502  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
503  pi_event *Event) {
505  Queue, SemHandle, NumEventsInWaitList, EventWaitList, Event);
506 }
507 
509  pi_kernel_group_info ParamName,
510  size_t ParamValueSize, void *ParamValue,
511  size_t *ParamValueSizeRet) {
512  return pi2ur::piKernelGetGroupInfo(Kernel, Device, ParamName, ParamValueSize,
513  ParamValue, ParamValueSizeRet);
514 }
515 
517  pi_kernel_sub_group_info ParamName,
518  size_t InputValueSize, const void *InputValue,
519  size_t ParamValueSize, void *ParamValue,
520  size_t *ParamValueSizeRet) {
522  Kernel, Device, ParamName, InputValueSize, InputValue, ParamValueSize,
523  ParamValue, ParamValueSizeRet);
524 }
525 
527 
528  return pi2ur::piKernelRetain(Kernel);
529 }
530 
532 
533  return pi2ur::piKernelRelease(Kernel);
534 }
535 
536 pi_result
538  const size_t *GlobalWorkOffset,
539  const size_t *GlobalWorkSize, const size_t *LocalWorkSize,
540  pi_uint32 NumEventsInWaitList,
541  const pi_event *EventWaitList, pi_event *OutEvent) {
543  Queue, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, LocalWorkSize,
544  NumEventsInWaitList, EventWaitList, OutEvent);
545 }
546 
548  pi_queue Queue, pi_kernel Kernel, pi_uint32 WorkDim,
549  const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize,
550  const size_t *LocalWorkSize, pi_uint32 NumEventsInWaitList,
551  const pi_event *EventWaitList, pi_event *OutEvent) {
553  Queue, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize, LocalWorkSize,
554  NumEventsInWaitList, EventWaitList, OutEvent);
555 }
556 
558  pi_context Context,
559  pi_program Program,
560  bool OwnNativeHandle,
561  pi_kernel *Kernel) {
562 
564  NativeHandle, Context, Program, OwnNativeHandle, Kernel);
565 }
566 
568  pi_native_handle *NativeHandle) {
569  return pi2ur::piextKernelGetNativeHandle(Kernel, NativeHandle);
570 }
571 
573  pi_kernel Kernel, size_t LocalWorkSize, size_t DynamicSharedMemorySize,
574  pi_uint32 *GroupCountRet) {
576  Kernel, LocalWorkSize, DynamicSharedMemorySize, GroupCountRet);
577 }
578 
580  return pi2ur::piEventCreate(Context, RetEvent);
581 }
582 
584  size_t ParamValueSize, void *ParamValue,
585  size_t *ParamValueSizeRet) {
586  return pi2ur::piEventGetInfo(Event, ParamName, ParamValueSize, ParamValue,
587  ParamValueSizeRet);
588 }
589 
591  size_t ParamValueSize, void *ParamValue,
592  size_t *ParamValueSizeRet) {
593 
594  return pi2ur::piEventGetProfilingInfo(Event, ParamName, ParamValueSize,
595  ParamValue, ParamValueSizeRet);
596 }
597 
598 pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList) {
599  return pi2ur::piEventsWait(NumEvents, EventList);
600 }
601 
602 pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType,
603  void (*PFnNotify)(pi_event Event,
604  pi_int32 EventCommandStatus,
605  void *UserData),
606  void *UserData) {
607  return pi2ur::piEventSetCallback(Event, CommandExecCallbackType, PFnNotify,
608  UserData);
609 }
610 
611 pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus) {
612  return pi2ur::piEventSetStatus(Event, ExecutionStatus);
613 }
614 
616 
618  return pi2ur::piEventRelease(Event);
619 }
620 
622  pi_native_handle *NativeHandle) {
623 
624  return pi2ur::piextEventGetNativeHandle(Event, NativeHandle);
625 }
626 
628  pi_context Context,
629  bool OwnNativeHandle,
630  pi_event *Event) {
631  return pi2ur::piextEventCreateWithNativeHandle(NativeHandle, Context,
632  OwnNativeHandle, Event);
633 }
634 
636  const pi_sampler_properties *SamplerProperties,
637  pi_sampler *RetSampler) {
638  return pi2ur::piSamplerCreate(Context, SamplerProperties, RetSampler);
639 }
640 
642  size_t ParamValueSize, void *ParamValue,
643  size_t *ParamValueSizeRet) {
644 
645  return pi2ur::piSamplerGetInfo(Sampler, ParamName, ParamValueSize, ParamValue,
646  ParamValueSizeRet);
647 }
648 
650  return pi2ur::piSamplerRetain(Sampler);
651 }
652 
654  return pi2ur::piSamplerRelease(Sampler);
655 }
656 
657 pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList,
658  const pi_event *EventWaitList,
659  pi_event *OutEvent) {
660 
661  return pi2ur::piEnqueueEventsWait(Queue, NumEventsInWaitList, EventWaitList,
662  OutEvent);
663 }
664 
666  pi_uint32 NumEventsInWaitList,
667  const pi_event *EventWaitList,
668  pi_event *OutEvent) {
669 
670  return pi2ur::piEnqueueEventsWaitWithBarrier(Queue, NumEventsInWaitList,
671  EventWaitList, OutEvent);
672 }
673 
675  pi_bool BlockingRead, size_t Offset,
676  size_t Size, void *Dst,
677  pi_uint32 NumEventsInWaitList,
678  const pi_event *EventWaitList,
679  pi_event *Event) {
680 
681  return pi2ur::piEnqueueMemBufferRead(Queue, Src, BlockingRead, Offset, Size,
682  Dst, NumEventsInWaitList, EventWaitList,
683  Event);
684 }
685 
687  pi_queue Queue, pi_mem Buffer, pi_bool BlockingRead,
688  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
689  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
690  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
691  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
692  pi_event *Event) {
693 
695  Queue, Buffer, BlockingRead, BufferOffset, HostOffset, Region,
696  BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
697  NumEventsInWaitList, EventWaitList, Event);
698 }
699 
701  pi_bool BlockingWrite, size_t Offset,
702  size_t Size, const void *Ptr,
703  pi_uint32 NumEventsInWaitList,
704  const pi_event *EventWaitList,
705  pi_event *Event) {
706 
707  return pi2ur::piEnqueueMemBufferWrite(Queue, Buffer, BlockingWrite, Offset,
708  Size, Ptr, NumEventsInWaitList,
709  EventWaitList, Event);
710 }
711 
713  pi_queue Queue, pi_mem Buffer, pi_bool BlockingWrite,
714  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
715  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
716  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
717  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
718  pi_event *Event) {
719 
721  Queue, Buffer, BlockingWrite, BufferOffset, HostOffset, Region,
722  BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
723  NumEventsInWaitList, EventWaitList, Event);
724 }
725 
727  size_t SrcOffset, size_t DstOffset,
728  size_t Size, pi_uint32 NumEventsInWaitList,
729  const pi_event *EventWaitList,
730  pi_event *Event) {
731 
732  return pi2ur::piEnqueueMemBufferCopy(Queue, SrcMem, DstMem, SrcOffset,
733  DstOffset, Size, NumEventsInWaitList,
734  EventWaitList, Event);
735 }
736 
738  pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, pi_buff_rect_offset SrcOrigin,
739  pi_buff_rect_offset DstOrigin, pi_buff_rect_region Region,
740  size_t SrcRowPitch, size_t SrcSlicePitch, size_t DstRowPitch,
741  size_t DstSlicePitch, pi_uint32 NumEventsInWaitList,
742  const pi_event *EventWaitList, pi_event *Event) {
743 
745  Queue, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
746  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumEventsInWaitList,
747  EventWaitList, Event);
748 }
749 
751  const void *Pattern, size_t PatternSize,
752  size_t Offset, size_t Size,
753  pi_uint32 NumEventsInWaitList,
754  const pi_event *EventWaitList,
755  pi_event *Event) {
756 
757  return pi2ur::piEnqueueMemBufferFill(Queue, Buffer, Pattern, PatternSize,
758  Offset, Size, NumEventsInWaitList,
759  EventWaitList, Event);
760 }
761 
763  pi_map_flags MapFlags, size_t Offset,
764  size_t Size, pi_uint32 NumEventsInWaitList,
765  const pi_event *EventWaitList,
766  pi_event *OutEvent, void **RetMap) {
767 
768  return pi2ur::piEnqueueMemBufferMap(Queue, Mem, BlockingMap, MapFlags, Offset,
769  Size, NumEventsInWaitList, EventWaitList,
770  OutEvent, RetMap);
771 }
772 
773 pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr,
774  pi_uint32 NumEventsInWaitList,
775  const pi_event *EventWaitList, pi_event *OutEvent) {
776 
777  return pi2ur::piEnqueueMemUnmap(Queue, Mem, MappedPtr, NumEventsInWaitList,
778  EventWaitList, OutEvent);
779 }
780 
782  size_t ParamValueSize, void *ParamValue,
783  size_t *ParamValueSizeRet) {
784 
785  return pi2ur::piMemImageGetInfo(Image, ParamName, ParamValueSize, ParamValue,
786  ParamValueSizeRet);
787 }
788 
790  pi_bool BlockingRead, pi_image_offset Origin,
791  pi_image_region Region, size_t RowPitch,
792  size_t SlicePitch, void *Ptr,
793  pi_uint32 NumEventsInWaitList,
794  const pi_event *EventWaitList,
795  pi_event *Event) {
797  Queue, Image, BlockingRead, Origin, Region, RowPitch, SlicePitch, Ptr,
798  NumEventsInWaitList, EventWaitList, Event);
799 }
800 
802  pi_bool BlockingWrite, pi_image_offset Origin,
803  pi_image_region Region, size_t InputRowPitch,
804  size_t InputSlicePitch, const void *Ptr,
805  pi_uint32 NumEventsInWaitList,
806  const pi_event *EventWaitList,
807  pi_event *Event) {
808 
810  Queue, Image, BlockingWrite, Origin, Region, InputRowPitch,
811  InputSlicePitch, Ptr, NumEventsInWaitList, EventWaitList, Event);
812 }
813 
814 pi_result
815 piEnqueueMemImageCopy(pi_queue Queue, pi_mem SrcImage, pi_mem DstImage,
816  pi_image_offset SrcOrigin, pi_image_offset DstOrigin,
817  pi_image_region Region, pi_uint32 NumEventsInWaitList,
818  const pi_event *EventWaitList, pi_event *Event) {
819  return pi2ur::piEnqueueMemImageCopy(Queue, SrcImage, DstImage, SrcOrigin,
820  DstOrigin, Region, NumEventsInWaitList,
821  EventWaitList, Event);
822 }
823 
825  const void *FillColor, const size_t *Origin,
826  const size_t *Region,
827  pi_uint32 NumEventsInWaitList,
828  const pi_event *EventWaitList,
829  pi_event *Event) {
830 
831  return pi2ur::piEnqueueMemImageFill(Queue, Image, FillColor, Origin, Region,
832  NumEventsInWaitList, EventWaitList,
833  Event);
834 }
835 
837  pi_buffer_create_type BufferCreateType,
838  void *BufferCreateInfo, pi_mem *RetMem) {
839 
840  return pi2ur::piMemBufferPartition(Buffer, Flags, BufferCreateType,
841  BufferCreateInfo, RetMem);
842 }
843 
845  const char *FunctionName,
846  pi_uint64 *FunctionPointerRet) {
847  return pi2ur::piextGetDeviceFunctionPointer(Device, Program, FunctionName,
848  FunctionPointerRet);
849 }
850 
852  const char *GlobalVariableName,
853  size_t *GlobalVariableSize,
854  void **GlobalVariablePointerRet) {
856  Device, Program, GlobalVariableName, GlobalVariableSize,
857  GlobalVariablePointerRet);
858 }
859 
860 pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context,
861  pi_device Device,
862  pi_usm_mem_properties *Properties, size_t Size,
864 
865  return pi2ur::piextUSMDeviceAlloc(ResultPtr, Context, Device, Properties,
866  Size, Alignment);
867 }
868 
869 pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context,
870  pi_device Device,
871  pi_usm_mem_properties *Properties, size_t Size,
873 
874  return pi2ur::piextUSMSharedAlloc(ResultPtr, Context, Device, Properties,
875  Size, Alignment);
876 }
877 
879  void **ResultPtr, size_t *ResultPitch, pi_context Context, pi_device Device,
880  pi_usm_mem_properties *Properties, size_t WidthInBytes, size_t Height,
881  unsigned int ElementSizeBytes) {
882 
883  return pi2ur::piextUSMPitchedAlloc(ResultPtr, ResultPitch, Context, Device,
884  Properties, WidthInBytes, Height,
885  ElementSizeBytes);
886 }
887 
888 pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context,
889  pi_usm_mem_properties *Properties, size_t Size,
891  return pi2ur::piextUSMHostAlloc(ResultPtr, Context, Properties, Size,
892  Alignment);
893 }
894 
895 pi_result piextUSMFree(pi_context Context, void *Ptr) {
896 
897  return pi2ur::piextUSMFree(Context, Ptr);
898 }
899 
901  size_t ArgSize, const void *ArgValue) {
902  return pi2ur::piextKernelSetArgPointer(Kernel, ArgIndex, ArgSize, ArgValue);
903 }
904 
906  size_t Count, pi_uint32 NumEventsInWaitlist,
907  const pi_event *EventsWaitlist,
908  pi_event *Event) {
910  Queue, Ptr, Value, Count, NumEventsInWaitlist, EventsWaitlist, Event);
911 }
912 
913 pi_result piextUSMEnqueueMemcpy(pi_queue Queue, pi_bool Blocking, void *DstPtr,
914  const void *SrcPtr, size_t Size,
915  pi_uint32 NumEventsInWaitlist,
916  const pi_event *EventsWaitlist,
917  pi_event *Event) {
918 
919  return pi2ur::piextUSMEnqueueMemcpy(Queue, Blocking, DstPtr, SrcPtr, Size,
920  NumEventsInWaitlist, EventsWaitlist,
921  Event);
922 }
923 
924 pi_result piextUSMEnqueuePrefetch(pi_queue Queue, const void *Ptr, size_t Size,
926  pi_uint32 NumEventsInWaitList,
927  const pi_event *EventWaitList,
928  pi_event *OutEvent) {
929 
931  Queue, Ptr, Size, Flags, NumEventsInWaitList, EventWaitList, OutEvent);
932 }
933 
935  size_t Length, pi_mem_advice Advice,
936  pi_event *OutEvent) {
937 
938  return pi2ur::piextUSMEnqueueMemAdvise(Queue, Ptr, Length, Advice, OutEvent);
939 }
940 
941 __SYCL_EXPORT pi_result piextUSMEnqueueFill2D(pi_queue Queue, void *Ptr,
942  size_t Pitch, size_t PatternSize,
943  const void *Pattern, size_t Width,
944  size_t Height,
945  pi_uint32 NumEventsWaitList,
946  const pi_event *EventsWaitList,
947  pi_event *Event) {
948 
949  return pi2ur::piextUSMEnqueueFill2D(Queue, Ptr, Pitch, PatternSize, Pattern,
950  Width, Height, NumEventsWaitList,
951  EventsWaitList, Event);
952 }
953 
954 __SYCL_EXPORT pi_result piextUSMEnqueueMemset2D(pi_queue Queue, void *Ptr,
955  size_t Pitch, int Value,
956  size_t Width, size_t Height,
957  pi_uint32 NumEventsWaitList,
958  const pi_event *EventsWaitlist,
959  pi_event *Event) {
960 
961  return pi2ur::piextUSMEnqueueMemset2D(Queue, Ptr, Pitch, Value, Width, Height,
962  NumEventsWaitList, EventsWaitlist,
963  Event);
964 }
965 
967  pi_queue Queue, pi_bool Blocking, void *DstPtr, size_t DstPitch,
968  const void *SrcPtr, size_t SrcPitch, size_t Width, size_t Height,
969  pi_uint32 NumEventsInWaitlist, const pi_event *EventWaitlist,
970  pi_event *Event) {
971 
973  Queue, Blocking, DstPtr, DstPitch, SrcPtr, SrcPitch, Width, Height,
974  NumEventsInWaitlist, EventWaitlist, Event);
975 }
976 
978  pi_mem_alloc_info ParamName,
979  size_t ParamValueSize, void *ParamValue,
980  size_t *ParamValueSizeRet) {
981  return pi2ur::piextUSMGetMemAllocInfo(Context, Ptr, ParamName, ParamValueSize,
982  ParamValue, ParamValueSizeRet);
983 }
984 
985 pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context) {
986  return pi2ur::piextUSMImport(HostPtr, Size, Context);
987 }
988 
989 pi_result piextUSMRelease(const void *HostPtr, pi_context Context) {
990  return pi2ur::piextUSMRelease(HostPtr, Context);
991 }
992 
994  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite,
995  size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList,
996  const pi_event *EventsWaitList, pi_event *Event) {
998  Queue, Program, Name, BlockingWrite, Count, Offset, Src,
999  NumEventsInWaitList, EventsWaitList, Event);
1000 }
1001 
1003  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingRead,
1004  size_t Count, size_t Offset, void *Dst, pi_uint32 NumEventsInWaitList,
1005  const pi_event *EventsWaitList, pi_event *Event) {
1007  Queue, Program, Name, BlockingRead, Count, Offset, Dst,
1008  NumEventsInWaitList, EventsWaitList, Event);
1009 
1010  return PI_SUCCESS;
1011 }
1012 
1014  const char *PipeSymbol, pi_bool Blocking,
1015  void *Ptr, size_t Size,
1016  pi_uint32 NumEventsInWaitList,
1017  const pi_event *EventsWaitList,
1018  pi_event *Event) {
1019  (void)Queue;
1020  (void)Program;
1021  (void)PipeSymbol;
1022  (void)Blocking;
1023  (void)Ptr;
1024  (void)Size;
1025  (void)NumEventsInWaitList;
1026  (void)EventsWaitList;
1027  (void)Event;
1028  PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE);
1029  die("piextEnqueueReadHostPipe: not implemented");
1030  return {};
1031 }
1032 
1034  const char *PipeSymbol, pi_bool Blocking,
1035  void *Ptr, size_t Size,
1036  pi_uint32 NumEventsInWaitList,
1037  const pi_event *EventsWaitList,
1038  pi_event *Event) {
1039  (void)Queue;
1040  (void)Program;
1041  (void)PipeSymbol;
1042  (void)Blocking;
1043  (void)Ptr;
1044  (void)Size;
1045  (void)NumEventsInWaitList;
1046  (void)EventsWaitList;
1047  (void)Event;
1048  PI_ASSERT(Queue, PI_ERROR_INVALID_QUEUE);
1049  die("piextEnqueueWriteHostPipe: not implemented");
1050  return {};
1051 }
1052 
1054  size_t ParamValueSize, const void *ParamValue) {
1055 
1056  return pi2ur::piKernelSetExecInfo(Kernel, ParamName, ParamValueSize,
1057  ParamValue);
1058 }
1059 
1061  pi_uint32 SpecID, size_t Size,
1062  const void *SpecValue) {
1063  return pi2ur::piextProgramSetSpecializationConstant(Prog, SpecID, Size,
1064  SpecValue);
1065 }
1066 
1067 // Command buffer extension
1069  const pi_ext_command_buffer_desc *Desc,
1070  pi_ext_command_buffer *RetCommandBuffer) {
1071  return pi2ur::piextCommandBufferCreate(Context, Device, Desc,
1072  RetCommandBuffer);
1073 }
1074 
1076  return pi2ur::piextCommandBufferRetain(CommandBuffer);
1077 }
1078 
1080  return pi2ur::piextCommandBufferRelease(CommandBuffer);
1081 }
1082 
1084  return pi2ur::piextCommandBufferFinalize(CommandBuffer);
1085 }
1086 
1088  pi_ext_command_buffer CommandBuffer, pi_kernel Kernel, pi_uint32 WorkDim,
1089  const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize,
1090  const size_t *LocalWorkSize, pi_uint32 NumSyncPointsInWaitList,
1091  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint,
1092  pi_ext_command_buffer_command *Command) {
1094  CommandBuffer, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize,
1095  LocalWorkSize, NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint,
1096  Command);
1097 }
1098 
1100  pi_ext_command_buffer CommandBuffer, void *DstPtr, const void *SrcPtr,
1101  size_t Size, pi_uint32 NumSyncPointsInWaitList,
1102  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1103  return pi2ur::piextCommandBufferMemcpyUSM(CommandBuffer, DstPtr, SrcPtr, Size,
1104  NumSyncPointsInWaitList,
1105  SyncPointWaitList, SyncPoint);
1106 }
1107 
1109  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1110  size_t SrcOffset, size_t DstOffset, size_t Size,
1111  pi_uint32 NumSyncPointsInWaitList,
1112  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1114  CommandBuffer, SrcMem, DstMem, SrcOffset, DstOffset, Size,
1115  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1116 }
1117 
1119  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1120  pi_buff_rect_offset SrcOrigin, pi_buff_rect_offset DstOrigin,
1121  pi_buff_rect_region Region, size_t SrcRowPitch, size_t SrcSlicePitch,
1122  size_t DstRowPitch, size_t DstSlicePitch, pi_uint32 NumSyncPointsInWaitList,
1123  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1125  CommandBuffer, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
1126  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumSyncPointsInWaitList,
1127  SyncPointWaitList, SyncPoint);
1128 }
1129 
1131  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1132  size_t Size, void *Dst, pi_uint32 NumSyncPointsInWaitList,
1133  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1135  CommandBuffer, Buffer, Offset, Size, Dst, NumSyncPointsInWaitList,
1136  SyncPointWaitList, SyncPoint);
1137 }
1138 
1140  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1141  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1142  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1143  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
1144  pi_uint32 NumSyncPointsInWaitList,
1145  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1147  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1148  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1149  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1150 }
1151 
1153  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1154  size_t Size, const void *Ptr, pi_uint32 NumSyncPointsInWaitList,
1155  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1157  CommandBuffer, Buffer, Offset, Size, Ptr, NumSyncPointsInWaitList,
1158  SyncPointWaitList, SyncPoint);
1159 }
1160 
1162  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1163  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1164  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1165  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
1166  pi_uint32 NumSyncPointsInWaitList,
1167  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1169  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1170  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1171  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1172 }
1173 
1175  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, const void *Pattern,
1176  size_t PatternSize, size_t Offset, size_t Size,
1177  pi_uint32 NumSyncPointsInWaitList,
1178  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1180  CommandBuffer, Buffer, Pattern, PatternSize, Offset, Size,
1181  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1182 }
1183 
1185  void *Ptr, const void *Pattern,
1186  size_t PatternSize, size_t Size,
1187  pi_uint32 NumSyncPointsInWaitList,
1188  const pi_ext_sync_point *SyncPointWaitList,
1189  pi_ext_sync_point *SyncPoint) {
1191  CommandBuffer, Ptr, Pattern, PatternSize, Size, NumSyncPointsInWaitList,
1192  SyncPointWaitList, SyncPoint);
1193 }
1194 
1196  pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Size,
1197  pi_usm_migration_flags Flags, pi_uint32 NumSyncPointsInWaitList,
1198  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1199  return pi2ur::piextCommandBufferPrefetchUSM(CommandBuffer, Ptr, Size, Flags,
1200  NumSyncPointsInWaitList,
1201  SyncPointWaitList, SyncPoint);
1202 }
1203 
1205  pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Length,
1206  pi_mem_advice Advice, pi_uint32 NumSyncPointsInWaitList,
1207  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1208  return pi2ur::piextCommandBufferAdviseUSM(CommandBuffer, Ptr, Length, Advice,
1209  NumSyncPointsInWaitList,
1210  SyncPointWaitList, SyncPoint);
1211 }
1212 
1214  pi_queue Queue,
1215  pi_uint32 NumEventsInWaitList,
1216  const pi_event *EventWaitList,
1217  pi_event *Event) {
1219  CommandBuffer, Queue, NumEventsInWaitList, EventWaitList, Event);
1220 }
1221 
1225  return pi2ur::piextCommandBufferUpdateKernelLaunch(Command, Desc);
1226 }
1227 
1228 pi_result
1231 }
1232 
1233 pi_result
1236 }
1237 
1238 pi_result piextPluginGetOpaqueData(void *opaque_data_param,
1239  void **opaque_data_return) {
1240  return pi2ur::piextPluginGetOpaqueData(opaque_data_param, opaque_data_return);
1241 }
1242 
1243 pi_result piTearDown(void *PluginParameter) {
1244  return pi2ur::piTearDown(PluginParameter);
1245 }
1246 
1247 pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime,
1248  uint64_t *HostTime) {
1249  return pi2ur::piGetDeviceAndHostTimer(Device, DeviceTime, HostTime);
1250 }
1251 
1253  pi_device peer_device) {
1254 
1255  return pi2ur::piextEnablePeerAccess(command_device, peer_device);
1256 }
1257 
1259  pi_device peer_device) {
1260 
1261  return pi2ur::piextDisablePeerAccess(command_device, peer_device);
1262 }
1263 
1265  pi_device peer_device, pi_peer_attr attr,
1266  size_t ParamValueSize, void *ParamValue,
1267  size_t *ParamValueSizeRet) {
1268  return pi2ur::piextPeerAccessGetInfo(command_device, peer_device, attr,
1269  ParamValueSize, ParamValue,
1270  ParamValueSizeRet);
1271 }
1272 
1274 
1276  // Check that the major version matches in PiVersion and SupportedVersion
1278 
1279  // PI interface supports higher version or the same version.
1280  size_t PluginVersionSize = sizeof(PluginInit->PluginVersion);
1281  if (strlen(SupportedVersion) >= PluginVersionSize)
1282  return PI_ERROR_INVALID_VALUE;
1283  strncpy(PluginInit->PluginVersion, SupportedVersion, PluginVersionSize);
1284 
1285  // Set whole function table to zero to make it easier to detect if
1286  // functions are not set up below.
1287  std::memset(&(PluginInit->PiFunctionTable), 0,
1288  sizeof(PluginInit->PiFunctionTable));
1289 
1290  cuda_tracing_context_t_ *Ctx = createCUDATracingContext();
1291  enableCUDATracing(Ctx);
1292 
1293 // Forward calls to CUDA RT.
1294 #define _PI_API(api) \
1295  (PluginInit->PiFunctionTable).api = (decltype(&::api))(&api);
1296 #include <sycl/detail/pi.def>
1297 #undef _PI_API
1298 
1299  return PI_SUCCESS;
1300 }
1301 
1302 #ifdef _WIN32
1303 #define __SYCL_PLUGIN_DLL_NAME "pi_cuda.dll"
1304 #include "../common_win_pi_trace/common_win_pi_trace.hpp"
1305 #undef __SYCL_PLUGIN_DLL_NAME
1306 #endif
1307 
1308 } // extern "C"
pi_result piextUSMEnqueueMemset(pi_queue Queue, void *Ptr, pi_int32 Value, size_t Count, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3864
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:2133
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)
Definition: pi2ur.hpp:4656
pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1940
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:3488
pi_result piKernelSetExecInfo(pi_kernel Kernel, pi_kernel_exec_info ParamName, size_t ParamValueSize, const void *ParamValue)
Definition: pi2ur.hpp:2302
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:875
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:3389
pi_result piextUSMGetMemAllocInfo(pi_context Context, const void *Ptr, pi_mem_alloc_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:3526
pi_result piextSignalExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi2ur.hpp:5445
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:2435
pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1797
pi_result piMemRetain(pi_mem Mem)
Definition: pi2ur.hpp:3360
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi2ur.hpp:822
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:4102
pi_result piextKernelSuggestMaxCooperativeGroupCount(pi_kernel Kernel, size_t LocalWorkSize, size_t DynamicSharedMemorySize, pi_uint32 *GroupCountRet)
Definition: pi2ur.hpp:2624
pi_result piextDestroyExternalSemaphore(pi_context Context, pi_device Device, pi_interop_semaphore_handle SemHandle)
Definition: pi2ur.hpp:5408
pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3820
pi_result piextDeviceGetNativeHandle(pi_device Device, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:1310
pi_result piextCommandBufferUpdateKernelLaunch(pi_ext_command_buffer_command command, pi_ext_command_buffer_update_kernel_launch_desc *desc)
Definition: pi2ur.hpp:4820
pi_result piProgramRelease(pi_program Program)
Definition: pi2ur.hpp:2513
pi_result piextCommandBufferPrefetchUSM(pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Size, pi_usm_migration_flags Flags, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
Definition: pi2ur.hpp:4736
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:3732
pi_result piPluginGetBackendOption(pi_platform Platform, const char *FrontendOption, const char **PlatformOption)
Definition: pi2ur.hpp:935
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, pi_ext_command_buffer_command *Command)
Definition: pi2ur.hpp:4528
pi_result piextPluginGetOpaqueData(void *opaque_data_param, void **opaque_data_return)
Definition: pi2ur.hpp:928
pi_result piKernelCreate(pi_program Program, const char *KernelName, pi_kernel *RetKernel)
Definition: pi2ur.hpp:2116
pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context)
Definition: pi2ur.hpp:3568
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:3683
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi2ur.hpp:4312
pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, void(*PFnNotify)(pi_event Event, pi_int32 EventCommandStatus, void *UserData), void *UserData)
Definition: pi2ur.hpp:4299
pi_result piSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, pi_sampler *RetSampler)
Definition: pi2ur.hpp:4342
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4403
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)
Definition: pi2ur.hpp:5008
pi_result piextMemUnsampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
Definition: pi2ur.hpp:5236
pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_sampler *ArgValue)
Definition: pi2ur.hpp:4441
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)
Definition: pi2ur.hpp:1710
pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:3591
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)
Definition: pi2ur.hpp:4687
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)
Definition: pi2ur.hpp:5341
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)
Definition: pi2ur.hpp:1894
pi_result piextProgramGetNativeHandle(pi_program Program, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:2347
pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2383
pi_result piextEventGetNativeHandle(pi_event Event, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:4207
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:4083
pi_result piextMemMipmapFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
Definition: pi2ur.hpp:5161
pi_result piextPlatformGetNativeHandle(pi_platform Platform, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:835
pi_result piSamplerRelease(pi_sampler Sampler)
Definition: pi2ur.hpp:4463
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:2709
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:4001
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)
Definition: pi2ur.hpp:4609
pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, pi_uint32 NumEntries, pi_device *Devices, pi_uint32 *NumDevices)
Definition: pi2ur.hpp:951
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:2650
pi_result piextEventCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_event *Event)
Definition: pi2ur.hpp:4275
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4222
pi_result piKernelRetain(pi_kernel Kernel)
Definition: pi2ur.hpp:2491
pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_mem_obj_property *ArgProperties, const pi_mem *ArgValue)
Definition: pi2ur.hpp:2189
pi_result piextQueueGetNativeHandle(pi_queue Queue, pi_native_handle *NativeHandle, int32_t *NativeHandleDesc)
Definition: pi2ur.hpp:1756
pi_result piextBindlessImageSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy, pi_sampler *RetSampler)
Definition: pi2ur.hpp:5037
pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context, pi_device Device, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Definition: pi2ur.hpp:3234
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:2570
pi_result piQueueFlush(pi_queue Queue)
Definition: pi2ur.hpp:1858
pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, size_t, const void *ArgValue)
Definition: pi2ur.hpp:2525
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:2000
pi_result piSamplerRetain(pi_sampler Sampler)
Definition: pi2ur.hpp:4452
pi_result piextDeviceSelectBinary(pi_device Device, pi_device_binary *Binaries, pi_uint32 NumBinaries, pi_uint32 *SelectedBinaryInd)
Definition: pi2ur.hpp:1432
pi_result piextContextSetExtendedDeleter(pi_context Context, pi_context_extended_deleter Function, void *UserData)
Definition: pi2ur.hpp:1511
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)
Definition: pi2ur.hpp:4639
pi_result piextGetDeviceFunctionPointer(pi_device Device, pi_program Program, const char *FunctionName, pi_uint64 *FunctionPointerRet)
Definition: pi2ur.hpp:2152
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:3888
pi_result piextMemMipmapGetLevel(pi_context Context, pi_device Device, pi_image_mem_handle MipMem, unsigned int Level, pi_image_mem_handle *RetMem)
Definition: pi2ur.hpp:5126
pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime, uint64_t *HostTime)
Definition: pi2ur.hpp:1424
pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4178
pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, pi_buffer_create_type BufferCreateType, void *BufferCreateInfo, pi_mem *RetMem)
Definition: pi2ur.hpp:3120
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:3922
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:1491
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)
Definition: pi2ur.hpp:3268
pi_result piextUSMRelease(const void *HostPtr, pi_context Context)
Definition: pi2ur.hpp:3580
pi_result piEventRelease(pi_event Event)
Definition: pi2ur.hpp:4328
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)
Definition: pi2ur.hpp:2533
pi_result piQueueRetain(pi_queue Queue)
Definition: pi2ur.hpp:1847
pi_result piextCommandBufferReleaseCommand(pi_ext_command_buffer_command command)
Definition: pi2ur.hpp:4890
pi_result piDeviceRelease(pi_device Device)
Definition: pi2ur.hpp:989
pi_result piContextRetain(pi_context Context)
Definition: pi2ur.hpp:1614
pi_result piextMemImageAllocate(pi_context Context, pi_device Device, pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_image_mem_handle *RetMem)
Definition: pi2ur.hpp:4958
pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Definition: pi2ur.hpp:2784
pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer)
Definition: pi2ur.hpp:4499
pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1014
pi_result piextCommandBufferAdviseUSM(pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Length, pi_mem_advice Advice, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
Definition: pi2ur.hpp:4757
pi_result piextKernelCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, pi_program Program, bool OwnNativeHandle, pi_kernel *Kernel)
Definition: pi2ur.hpp:2270
pi_result piextMemSampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
Definition: pi2ur.hpp:5252
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:3842
pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform Platform, pi_device *Device)
Definition: pi2ur.hpp:1324
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:3650
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:3787
pi_result piextCommandBufferRetainCommand(pi_ext_command_buffer_command command)
Definition: pi2ur.hpp:4882
pi_result piextEnqueueCommandBuffer(pi_ext_command_buffer CommandBuffer, pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi2ur.hpp:4800
pi_result piextCommandBufferCreate(pi_context Context, pi_device Device, const pi_ext_command_buffer_desc *Desc, pi_ext_command_buffer *RetCommandBuffer)
Definition: pi2ur.hpp:4481
pi_result piextEnqueueCooperativeKernelLaunch(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:3707
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)
Definition: pi2ur.hpp:3507
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:3182
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)
Definition: pi2ur.hpp:3091
pi_result piextQueueCreate(pi_context Context, pi_device Device, pi_queue_properties *Properties, pi_queue *Queue)
Definition: pi2ur.hpp:1633
pi_result piextProgramCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_program *Program)
Definition: pi2ur.hpp:2363
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)
Definition: pi2ur.hpp:4981
pi_result piextUSMFree(pi_context Context, void *Ptr)
Definition: pi2ur.hpp:3353
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:2682
pi_result piEventCreate(pi_context Context, pi_event *RetEvent)
Definition: pi2ur.hpp:4260
pi_result piextKernelGetNativeHandle(pi_kernel Kernel, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:2610
pi_result piextMemImageGetInfo(pi_image_mem_handle MemHandle, pi_image_info ParamName, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:5289
pi_result piQueueFinish(pi_queue Queue)
Definition: pi2ur.hpp:1786
pi_result piextCommandBufferMemBufferFill(pi_ext_command_buffer CommandBuffer, pi_mem Buffer, const void *Pattern, size_t PatternSize, size_t Offset, size_t Size, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
Definition: pi2ur.hpp:4705
pi_result piContextRelease(pi_context Context)
Definition: pi2ur.hpp:1622
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Definition: pi2ur.hpp:852
pi_result piextMemReleaseInterop(pi_context Context, pi_device Device, pi_interop_mem_handle ExtMem)
Definition: pi2ur.hpp:5366
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi2ur.hpp:2244
pi_result piEventRetain(pi_event Event)
Definition: pi2ur.hpp:4319
pi_result piextContextGetNativeHandle(pi_context Context, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:1520
pi_result piMemRelease(pi_mem Mem)
Definition: pi2ur.hpp:3370
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)
Definition: pi2ur.hpp:3947
pi_result piextCommandBufferFinalize(pi_ext_command_buffer CommandBuffer)
Definition: pi2ur.hpp:4519
pi_result piPluginGetLastError(char **Message)
Definition: pi2ur.hpp:997
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:3761
pi_result piKernelRelease(pi_kernel Kernel)
Definition: pi2ur.hpp:2502
pi_result piextMemImageFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
Definition: pi2ur.hpp:5145
pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle, pi_uint32 NumDevices, const pi_device *Devices, bool OwnNativeHandle, pi_context *RetContext)
Definition: pi2ur.hpp:1531
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:4924
pi_result piQueueRelease(pi_queue Queue)
Definition: pi2ur.hpp:1776
pi_result piextWaitExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi2ur.hpp:5425
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
Definition: pi2ur.hpp:4509
pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1559
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)
Definition: pi2ur.hpp:4562
pi_result piextCommandBufferFillUSM(pi_ext_command_buffer CommandBuffer, void *Ptr, const void *Pattern, size_t PatternSize, size_t Size, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
Definition: pi2ur.hpp:4722
pi_result piextMemGetNativeHandle(pi_mem Mem, pi_device Dev, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:3167
pi_result piextGetGlobalVariablePointer(pi_device Device, pi_program Program, const char *GlobalVariableName, size_t *GlobalVariableSize, void **GlobalVariablePointerRet)
Definition: pi2ur.hpp:2171
pi_result piTearDown(void *PluginParameter)
Definition: pi2ur.hpp:782
pi_result piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size, int FileDescriptor, pi_interop_mem_handle *RetHandle)
Definition: pi2ur.hpp:5316
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4913
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)
Definition: pi2ur.hpp:4580
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4903
pi_result piDevicePartition(pi_device Device, const pi_device_partition_property *Properties, pi_uint32 NumEntries, pi_device *SubDevices, pi_uint32 *NumSubDevices)
Definition: pi2ur.hpp:1348
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:4025
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:3049
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:2070
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:3967
pi_result piProgramRetain(pi_program Program)
Definition: pi2ur.hpp:2291
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:3426
pi_result piextProgramSetSpecializationConstant(pi_program Program, pi_uint32 SpecID, size_t Size, const void *SpecValue)
Definition: pi2ur.hpp:2099
pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context, pi_device Device, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Definition: pi2ur.hpp:3289
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:4060
pi_result piProgramCreate(pi_context Context, const void *ILBytes, size_t Length, pi_program *Program)
Definition: pi2ur.hpp:1875
pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventsWaitList)
Definition: pi2ur.hpp:4164
pi_result piDeviceRetain(pi_device Device)
Definition: pi2ur.hpp:982
pi_result piextImportExternalSemaphoreOpaqueFD(pi_context Context, pi_device Device, int FileDescriptor, pi_interop_semaphore_handle *RetHandle)
Definition: pi2ur.hpp:5382
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)
Definition: pi2ur.hpp:4548
pi_result piextMemCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_mem *Mem)
Definition: pi2ur.hpp:3213
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2814
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:2032
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)
Definition: pi2ur.hpp:5195
void die(const char *Message)
Definition: pi.cpp:586
#define PI_ASSERT(condition, error)
Definition: pi2ur.hpp:155
int32_t pi_int32
Definition: pi.h:204
uintptr_t pi_native_handle
Definition: pi.h:209
pi_bitfield pi_map_flags
Definition: pi.h:748
_pi_result
Definition: pi.h:216
pi_uint32 pi_bool
Definition: pi.h:207
pi_bitfield pi_usm_mem_properties
Definition: pi.h:760
_pi_device_info
Definition: pi.h:296
_pi_queue_info
Definition: pi.h:484
_pi_mem_advice
Definition: pi.h:586
_pi_kernel_sub_group_info
Definition: pi.h:526
pi_bitfield pi_mem_properties
Definition: pi.h:754
_pi_kernel_group_info
Definition: pi.h:505
pi_uint64 pi_image_handle
Definition: pi.h:1137
_pi_ext_command_buffer_command * pi_ext_command_buffer_command
Definition: pi.h:2331
_pi_kernel_exec_info
Definition: pi.h:1581
_pi_platform_info
Definition: pi.h:231
_pi_image_info
Definition: pi.h:516
pi_uint32 pi_ext_sync_point
Definition: pi.h:2332
_pi_profiling_info
Definition: pi.h:727
_pi_usm_migration_flags
Definition: pi.h:1955
_pi_device_type
Definition: pi.h:264
uint64_t pi_uint64
Definition: pi.h:206
pi_bitfield pi_queue_properties
Definition: pi.h:773
_pi_image_copy_flags
Definition: pi.h:663
pi_bitfield pi_sampler_properties
Definition: pi.h:706
_pi_buffer_create_type
Definition: pi.h:669
uint32_t pi_uint32
Definition: pi.h:205
_pi_event_info
Definition: pi.h:533
intptr_t pi_context_properties
Definition: pi.h:698
pi_bitfield pi_mem_flags
Definition: pi.h:738
constexpr pi_queue_properties PI_QUEUE_FLAGS
Definition: pi.h:774
void(* pi_context_extended_deleter)(void *user_data)
Definition: pi.h:1321
_pi_sampler_info
Definition: pi.h:674
_pi_kernel_info
Definition: pi.h:496
_pi_mem_alloc_info
Definition: pi.h:1938
_pi_context_info
Definition: pi.h:467
void * pi_image_mem_handle
Definition: pi.h:1138
#define _PI_PLUGIN_VERSION_CHECK(PI_API_VERSION, PI_PLUGIN_VERSION)
Definition: pi.h:182
_pi_program_info
Definition: pi.h:455
intptr_t pi_device_partition_property
Definition: pi.h:832
_pi_mem_info
Definition: pi.h:1163
pi_uint64 pi_interop_semaphore_handle
Definition: pi.h:1140
_pi_peer_attr
Definition: pi.h:1165
pi_uint64 pi_interop_mem_handle
Definition: pi.h:1139
_pi_program_build_info
Definition: pi.h:240
C++ wrapper of extern "C" PI interfaces.
pi_result piextContextSetExtendedDeleter(pi_context Context, pi_context_extended_deleter Function, void *UserData)
Definition: pi_cuda.cpp:132
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_cuda.cpp:198
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_cuda.cpp:1258
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_cuda.cpp:78
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_cuda.cpp:210
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_cuda.cpp:492
pi_result piMemRelease(pi_mem Mem)
Definition: pi_cuda.cpp:225
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi_cuda.cpp:611
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_cuda.cpp:1213
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_cuda.cpp:1252
pi_result piextEnqueueDeviceGlobalVariableWrite(pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite, size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *Event)
Device global variable.
Definition: pi_cuda.cpp:993
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_cuda.cpp:1108
pi_result piProgramGetBuildInfo(pi_program Program, pi_device Device, pi_program_build_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:310
pi_result piKernelGetGroupInfo(pi_kernel Kernel, pi_device Device, pi_kernel_group_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:508
pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform Platform, pi_device *Device)
Creates PI device object from a native handle.
Definition: pi_cuda.cpp:106
pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, void(*PFnNotify)(pi_event Event, pi_int32 EventCommandStatus, void *UserData), void *UserData)
Definition: pi_cuda.cpp:602
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_cuda.cpp:1083
pi_result piKernelCreate(pi_program Program, const char *KernelName, pi_kernel *RetKernel)
Definition: pi_cuda.cpp:341
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_cuda.cpp:291
pi_result piextCommandBufferPrefetchUSM(pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Size, pi_usm_migration_flags Flags, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
API to append a USM Prefetch command to the command-buffer.
Definition: pi_cuda.cpp:1195
pi_result piextDeviceGetNativeHandle(pi_device Device, pi_native_handle *NativeHandle)
Gets the native handle of a PI device object.
Definition: pi_cuda.cpp:100
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Creates PI platform object from a native handle.
Definition: pi_cuda.cpp:47
pi_result piQueueRetain(pi_queue Queue)
Definition: pi_cuda.cpp:180
pi_result piQueueRelease(pi_queue Queue)
Definition: pi_cuda.cpp:182
pi_result piextCommandBufferReleaseCommand(pi_ext_command_buffer_command Command)
API to decrement the reference count of a command-buffer command.
Definition: pi_cuda.cpp:1234
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_cuda.cpp:450
pi_result piextPluginGetOpaqueData(void *opaque_data_param, void **opaque_data_return)
API to get Plugin internal data, opaque to SYCL RT.
Definition: pi_cuda.cpp:1238
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, pi_ext_command_buffer_command *Command)
API to append a kernel execution command to the command-buffer.
Definition: pi_cuda.cpp:1087
pi_result piextEventGetNativeHandle(pi_event Event, pi_native_handle *NativeHandle)
Gets the native handle of a PI event object.
Definition: pi_cuda.cpp:621
pi_result piProgramRelease(pi_program Program)
Definition: pi_cuda.cpp:324
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_cuda.cpp:253
pi_result piextMemImageFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free memory for bindless images.
Definition: pi_cuda.cpp:417
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_cuda.cpp:674
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi_cuda.cpp:347
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_cuda.cpp:93
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_cuda.cpp:241
pi_result piSamplerRelease(pi_sampler Sampler)
Definition: pi_cuda.cpp:653
pi_result piDeviceRelease(pi_device Device)
Definition: pi_cuda.cpp:74
pi_result piextMemUnsampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless unsampled image handles.
Definition: pi_cuda.cpp:440
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_cuda.cpp:789
pi_result piextUSMFree(pi_context Context, void *Ptr)
Indicates that the allocated USM memory is no longer needed on the runtime side.
Definition: pi_cuda.cpp:895
pi_result piQueueFlush(pi_queue Queue)
Definition: pi_cuda.cpp:188
pi_result piMemRetain(pi_mem Mem)
Definition: pi_cuda.cpp:223
pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:124
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_cuda.cpp:737
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_cuda.cpp:1053
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:641
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_cuda.cpp:1060
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_cuda.cpp:913
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_cuda.cpp:383
pi_result piextQueueCreate(pi_context Context, pi_device Device, pi_queue_properties *Properties, pi_queue *Queue)
Definition: pi_cuda.cpp:167
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_cuda.cpp:1152
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_cuda.cpp:459
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_cuda.cpp:750
pi_result piextEnqueueCooperativeKernelLaunch(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_cuda.cpp:547
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_cuda.cpp:1264
pi_result piEventCreate(pi_context Context, pi_event *RetEvent)
Create PI event object in a signalled/completed state.
Definition: pi_cuda.cpp:579
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_cuda.cpp:1099
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_cuda.cpp:1118
pi_result piTearDown(void *PluginParameter)
API to notify that the plugin should clean up its resources.
Definition: pi_cuda.cpp:1243
pi_result piextKernelGetNativeHandle(pi_kernel Kernel, pi_native_handle *NativeHandle)
Gets the native handle of a PI kernel object.
Definition: pi_cuda.cpp:567
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_cuda.cpp:966
pi_result piSamplerRetain(pi_sampler Sampler)
Definition: pi_cuda.cpp:649
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_cuda.cpp:427
pi_result piEventRelease(pi_event Event)
Definition: pi_cuda.cpp:617
pi_result piKernelRelease(pi_kernel Kernel)
Definition: pi_cuda.cpp:531
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:590
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:217
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_cuda.cpp:762
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_cuda.cpp:700
pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:366
pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context)
Import host system memory into USM.
Definition: pi_cuda.cpp:985
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_cuda.cpp:941
pi_result piPluginInit(pi_plugin *PluginInit)
Definition: pi_cuda.cpp:1275
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:35
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_cuda.cpp:409
pi_result piextMemMipmapFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free mipmap memory for bindless images.
Definition: pi_cuda.cpp:422
pi_result piextCommandBufferRetainCommand(pi_ext_command_buffer_command Command)
API to increment the reference count of a command-buffer command.
Definition: pi_cuda.cpp:1229
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_cuda.cpp:869
void freeCUDATracingContext(cuda_tracing_context_t_ *Ctx)
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_cuda.cpp:712
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_cuda.cpp:844
pi_result piextUSMEnqueueMemAdvise(pi_queue Queue, const void *Ptr, size_t Length, pi_mem_advice Advice, pi_event *OutEvent)
USM Memadvise API.
Definition: pi_cuda.cpp:934
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_cuda.cpp:888
pi_result piProgramRetain(pi_program Program)
Definition: pi_cuda.cpp:320
pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:172
pi_result piQueueCreate(pi_context Context, pi_device Device, pi_queue_properties Flags, pi_queue *Queue)
Definition: pi_cuda.cpp:161
pi_result piextGetGlobalVariablePointer(pi_device Device, pi_program Program, const char *GlobalVariableName, size_t *GlobalVariableSize, void **GlobalVariablePointerRet)
Definition: pi_cuda.cpp:851
const char SupportedVersion[]
Definition: pi_cuda.cpp:1273
pi_result piContextRelease(pi_context Context)
Definition: pi_cuda.cpp:157
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_cuda.cpp:465
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_cuda.cpp:726
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_cuda.cpp:815
pi_result piextCommandBufferUpdateKernelLaunch(pi_ext_command_buffer_command Command, pi_ext_command_buffer_update_kernel_launch_desc *Desc)
API to update a kernel launch command inside of a command-buffer.
Definition: pi_cuda.cpp:1222
pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:583
pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:272
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_cuda.cpp:479
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_cuda.cpp:954
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_cuda.cpp:1161
pi_result piextMemReleaseInterop(pi_context Context, pi_device Device, pi_interop_mem_handle ExtMem)
API to destroy interop memory.
Definition: pi_cuda.cpp:473
pi_result piextUSMRelease(const void *HostPtr, pi_context Context)
Release host system memory from USM.
Definition: pi_cuda.cpp:989
pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList)
Definition: pi_cuda.cpp:598
void enableCUDATracing(cuda_tracing_context_t_ *ctx)
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_cuda.cpp:905
pi_result piextPlatformGetNativeHandle(pi_platform Platform, pi_native_handle *NativeHandle)
Gets the native handle of a PI platform object.
Definition: pi_cuda.cpp:42
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_cuda.cpp:686
pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, pi_buffer_create_type BufferCreateType, void *BufferCreateInfo, pi_mem *RetMem)
Definition: pi_cuda.cpp:836
pi_result piextDestroyExternalSemaphore(pi_context Context, pi_device Device, pi_interop_semaphore_handle SemHandle)
API to destroy the external semaphore handle.
Definition: pi_cuda.cpp:487
pi_result piPluginGetLastError(char **message)
API to get Plugin specific warning and error messages.
Definition: pi_cuda.cpp:52
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_cuda.cpp:1130
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_cuda.cpp:801
pi_result piextContextGetNativeHandle(pi_context Context, pi_native_handle *NativeHandle)
Gets the native handle of a PI context object.
Definition: pi_cuda.cpp:138
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_cuda.cpp:227
pi_result piextUSMGetMemAllocInfo(pi_context Context, const void *Ptr, pi_mem_alloc_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
API to query information about USM allocated pointers Valid Queries: PI_MEM_ALLOC_TYPE returns host/d...
Definition: pi_cuda.cpp:977
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_cuda.cpp:665
pi_result piextMemSampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless sampled image handles.
Definition: pi_cuda.cpp:445
pi_result piQueueFinish(pi_queue Queue)
Definition: pi_cuda.cpp:186
void disableCUDATracing(cuda_tracing_context_t_ *ctx)
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_cuda.cpp:264
pi_result piSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, pi_sampler *RetSampler)
Definition: pi_cuda.cpp:635
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_cuda.cpp:1247
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi_cuda.cpp:30
pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, pi_uint32 NumEntries, pi_device *Devices, pi_uint32 *NumDevices)
Definition: pi_cuda.cpp:63
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_cuda.cpp:824
pi_result piextEnqueueWriteHostPipe(pi_queue Queue, pi_program Program, const char *PipeSymbol, pi_bool Blocking, void *Ptr, size_t Size, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *Event)
Write to pipe of a given name.
Definition: pi_cuda.cpp:1033
pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_mem_obj_property *ArgProperties, const pi_mem *ArgValue)
Definition: pi_cuda.cpp:353
pi_result piDevicePartition(pi_device Device, const pi_device_partition_property *Properties, pi_uint32 NumDevices, pi_device *OutDevices, pi_uint32 *OutNumDevices)
Definition: pi_cuda.cpp:85
cuda_tracing_context_t_ * createCUDATracingContext()
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_cuda.cpp:1002
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_cuda.cpp:114
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_cuda.cpp:860
pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_sampler *ArgValue)
Definition: pi_cuda.cpp:360
pi_result piextMemGetNativeHandle(pi_mem Mem, pi_device Dev, pi_native_handle *NativeHandle)
Gets the native handle of a PI mem object.
Definition: pi_cuda.cpp:236
pi_result piextEnqueueReadHostPipe(pi_queue Queue, pi_program Program, const char *PipeSymbol, pi_bool Blocking, void *Ptr, size_t Size, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *Event)
Plugin.
Definition: pi_cuda.cpp:1013
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_cuda.cpp:924
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_cuda.cpp:537
pi_result piextCommandBufferFillUSM(pi_ext_command_buffer CommandBuffer, void *Ptr, const void *Pattern, size_t PatternSize, size_t Size, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
API to append a USM fill command to the command-buffer.
Definition: pi_cuda.cpp:1184
pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer)
API to increment the reference count of the command-buffer.
Definition: pi_cuda.cpp:1075
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_cuda.cpp:302
pi_result piKernelRetain(pi_kernel Kernel)
Definition: pi_cuda.cpp:526
pi_result piEventRetain(pi_event Event)
Definition: pi_cuda.cpp:615
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_cuda.cpp:143
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
API to decrement the reference count of the command-buffer.
Definition: pi_cuda.cpp:1079
pi_result piPluginGetBackendOption(pi_platform platform, const char *frontend_option, const char **backend_option)
API to get backend specific option.
Definition: pi_cuda.cpp:56
pi_result piextCommandBufferMemBufferFill(pi_ext_command_buffer CommandBuffer, pi_mem Buffer, const void *Pattern, size_t PatternSize, size_t Offset, size_t Size, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
API to append a mem buffer fill command to the command-buffer.
Definition: pi_cuda.cpp:1174
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_cuda.cpp:280
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_cuda.cpp:391
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_cuda.cpp:333
pi_result piextCommandBufferAdviseUSM(pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Length, pi_mem_advice Advice, pi_uint32 NumSyncPointsInWaitList, const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint)
API to append a USM Advise command to the command-buffer.
Definition: pi_cuda.cpp:1204
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_cuda.cpp:627
pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_cuda.cpp:781
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_cuda.cpp:657
pi_result piDeviceRetain(pi_device Device)
Definition: pi_cuda.cpp:70
pi_result piextQueueGetNativeHandle(pi_queue Queue, pi_native_handle *NativeHandle, int32_t *NativeHandleDesc)
Gets the native handle of a PI queue object.
Definition: pi_cuda.cpp:190
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_cuda.cpp:878
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_cuda.cpp:1068
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_cuda.cpp:1139
pi_result piContextRetain(pi_context Context)
Definition: pi_cuda.cpp:152
pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Sets up pointer arguments for CL kernels.
Definition: pi_cuda.cpp:900
pi_result piextKernelSuggestMaxCooperativeGroupCount(pi_kernel Kernel, size_t LocalWorkSize, size_t DynamicSharedMemorySize, pi_uint32 *GroupCountRet)
Gets the max work group count for a cooperative kernel.
Definition: pi_cuda.cpp:572
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_cuda.cpp:516
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_cuda.cpp:400
pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_cuda.cpp:773
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_cuda.cpp:374
pi_result piProgramCreate(pi_context Context, const void *ILBytes, size_t Length, pi_program *Program)
Definition: pi_cuda.cpp:248
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_cuda.cpp:557
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_cuda.cpp:500
pi_result piextProgramGetNativeHandle(pi_program Program, pi_native_handle *NativeHandle)
Gets the native handle of a PI program object.
Definition: pi_cuda.cpp:328
Declarations for CUDA Plugin.
#define _PI_CUDA_PLUGIN_VERSION_STRING
Definition: pi_cuda.hpp:25
char PluginVersion[20]
Definition: pi.h:2905
struct _pi_plugin::FunctionPointers PiFunctionTable
char PiVersion[20]
Definition: pi.h:2903
This struct is a record of the device binary information.
Definition: pi.h:1005