DPC++ Runtime
Runtime libraries for oneAPI DPC++
pi_opencl.cpp
Go to the documentation of this file.
1 //==---------- pi_opencl.cpp - OpenCL 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 //===----------------------------------------------------------------------===//
10 
16 
17 #define CL_USE_DEPRECATED_OPENCL_1_2_APIS
18 
19 #include <cstring>
20 #include <pi_opencl.hpp>
21 #include <sycl/detail/pi.h>
22 
23 extern "C" {
24 
26 
28  pi_uint32 *NumPlatforms) {
29  return pi2ur::piPlatformsGet(NumEntries, Platforms, NumPlatforms);
30 }
31 
33  size_t ParamValueSize, void *ParamValue,
34  size_t *ParamValueSizeRet) {
35  return pi2ur::piPlatformGetInfo(Platform, ParamName, ParamValueSize,
36  ParamValue, ParamValueSizeRet);
37 }
38 
40  pi_native_handle *NativeHandle) {
41  return pi2ur::piextPlatformGetNativeHandle(Platform, NativeHandle);
42 }
43 
45  pi_platform *Platform) {
46  return pi2ur::piextPlatformCreateWithNativeHandle(NativeHandle, Platform);
47 }
48 
50  return pi2ur::piPluginGetLastError(message);
51 }
52 
54  const char *frontend_option,
55  const char **backend_option) {
56  return pi2ur::piPluginGetBackendOption(platform, frontend_option,
57  backend_option);
58 }
59 
61  pi_uint32 NumEntries, pi_device *Devices,
62  pi_uint32 *NumDevices) {
63  return pi2ur::piDevicesGet(Platform, DeviceType, NumEntries, Devices,
64  NumDevices);
65 }
66 
68  return pi2ur::piDeviceRetain(Device);
69 }
70 
72  return pi2ur::piDeviceRelease(Device);
73 }
74 
76  size_t ParamValueSize, void *ParamValue,
77  size_t *ParamValueSizeRet) {
78  return pi2ur::piDeviceGetInfo(Device, ParamName, ParamValueSize, ParamValue,
79  ParamValueSizeRet);
80 }
81 
83  const pi_device_partition_property *Properties,
84  pi_uint32 NumDevices, pi_device *OutDevices,
85  pi_uint32 *OutNumDevices) {
86  return pi2ur::piDevicePartition(Device, Properties, NumDevices, OutDevices,
87  OutNumDevices);
88 }
89 
91  pi_uint32 NumBinaries,
92  pi_uint32 *SelectedBinaryInd) {
93  return pi2ur::piextDeviceSelectBinary(Device, Binaries, NumBinaries,
94  SelectedBinaryInd);
95 }
96 
98  pi_native_handle *NativeHandle) {
99  return pi2ur::piextDeviceGetNativeHandle(Device, NativeHandle);
100 }
101 
103  pi_platform Platform,
104  pi_device *Device) {
105  return pi2ur::piextDeviceCreateWithNativeHandle(NativeHandle, Platform,
106  Device);
107 }
108 
110  pi_uint32 NumDevices, const pi_device *Devices,
111  void (*PFnNotify)(const char *ErrInfo,
112  const void *PrivateInfo, size_t CB,
113  void *UserData),
114  void *UserData, pi_context *RetContext) {
115  return pi2ur::piContextCreate(Properties, NumDevices, Devices, PFnNotify,
116  UserData, RetContext);
117 }
118 
120  size_t ParamValueSize, void *ParamValue,
121  size_t *ParamValueSizeRet) {
122  return pi2ur::piContextGetInfo(Context, ParamName, ParamValueSize, ParamValue,
123  ParamValueSizeRet);
124 }
125 
128  void *UserData) {
129  return pi2ur::piextContextSetExtendedDeleter(Context, Function, UserData);
130 }
131 
133  pi_native_handle *NativeHandle) {
134  return pi2ur::piextContextGetNativeHandle(Context, NativeHandle);
135 }
136 
138  pi_uint32 NumDevices,
139  const pi_device *Devices,
140  bool OwnNativeHandle,
141  pi_context *RetContext) {
143  NativeHandle, NumDevices, Devices, OwnNativeHandle, RetContext);
144 }
145 
147  return pi2ur::piContextRetain(Context);
148 }
149 
151  return pi2ur::piContextRelease(Context);
152 }
153 
155  pi_queue_properties Flags, pi_queue *Queue) {
156  pi_queue_properties Properties[] = {PI_QUEUE_FLAGS, Flags, 0};
157  return piextQueueCreate(Context, Device, Properties, Queue);
158 }
159 
161  pi_queue_properties *Properties, pi_queue *Queue) {
162  return pi2ur::piextQueueCreate(Context, Device, Properties, Queue);
163 }
164 
166  size_t ParamValueSize, void *ParamValue,
167  size_t *ParamValueSizeRet) {
168  return pi2ur::piQueueGetInfo(Queue, ParamName, ParamValueSize, ParamValue,
169  ParamValueSizeRet);
170 }
171 
173 
175  return pi2ur::piQueueRelease(Queue);
176 }
177 
179 
181 
183  pi_native_handle *NativeHandle,
184  int32_t *NativeHandleDesc) {
185  return pi2ur::piextQueueGetNativeHandle(Queue, NativeHandle,
186  NativeHandleDesc);
187 }
188 
190  int32_t NativeHandleDesc,
191  pi_context Context, pi_device Device,
192  bool OwnNativeHandle,
193  pi_queue_properties *Properties,
194  pi_queue *Queue) {
196  NativeHandle, NativeHandleDesc, Context, Device, OwnNativeHandle,
197  Properties, Queue);
198 }
199 
201  void *HostPtr, pi_mem *RetMem,
202  const pi_mem_properties *properties) {
203  return pi2ur::piMemBufferCreate(Context, Flags, Size, HostPtr, RetMem,
204  properties);
205 }
206 
207 pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize,
208  void *ParamValue, size_t *ParamValueSizeRet) {
209  return pi2ur::piMemGetInfo(Mem, ParamName, ParamValueSize, ParamValue,
210  ParamValueSizeRet);
211 }
212 
214 
216 
218  const pi_image_format *ImageFormat,
219  const pi_image_desc *ImageDesc, void *HostPtr,
220  pi_mem *RetImage) {
221  return pi2ur::piMemImageCreate(Context, Flags, ImageFormat, ImageDesc,
222  HostPtr, RetImage);
223 }
224 
226  pi_native_handle *NativeHandle) {
227  return pi2ur::piextMemGetNativeHandle(Mem, Dev, NativeHandle);
228 }
229 
231  pi_context Context,
232  bool ownNativeHandle, pi_mem *Mem) {
233  return pi2ur::piextMemCreateWithNativeHandle(NativeHandle, Context,
234  ownNativeHandle, Mem);
235 }
236 
237 pi_result piProgramCreate(pi_context Context, const void *ILBytes,
238  size_t Length, pi_program *Program) {
239  return pi2ur::piProgramCreate(Context, ILBytes, Length, Program);
240 }
241 
243  pi_context Context, pi_uint32 NumDevices, const pi_device *DeviceList,
244  const size_t *Lengths, const unsigned char **Binaries,
245  size_t NumMetadataEntries, const pi_device_binary_property *Metadata,
246  pi_int32 *BinaryStatus, pi_program *Program) {
247  return pi2ur::piProgramCreateWithBinary(Context, NumDevices, DeviceList,
248  Lengths, Binaries, NumMetadataEntries,
249  Metadata, BinaryStatus, Program);
250 }
251 
253  pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle,
254  const pi_image_format *ImageFormat, const pi_image_desc *ImageDesc,
255  pi_mem *Img) {
257  NativeHandle, Context, OwnNativeHandle, ImageFormat, ImageDesc, Img);
258 }
259 
261  size_t ParamValueSize, void *ParamValue,
262  size_t *ParamValueSizeRet) {
263  return pi2ur::piProgramGetInfo(Program, ParamName, ParamValueSize, ParamValue,
264  ParamValueSizeRet);
265 }
266 
268  const pi_device *DeviceList, const char *Options,
269  pi_uint32 NumInputPrograms,
270  const pi_program *InputPrograms,
271  void (*PFnNotify)(pi_program Program, void *UserData),
272  void *UserData, pi_program *RetProgram) {
273  return pi2ur::piProgramLink(Context, NumDevices, DeviceList, Options,
274  NumInputPrograms, InputPrograms, PFnNotify,
275  UserData, RetProgram);
276 }
277 
279  pi_program Program, pi_uint32 NumDevices, const pi_device *DeviceList,
280  const char *Options, pi_uint32 NumInputHeaders,
281  const pi_program *InputHeaders, const char **HeaderIncludeNames,
282  void (*PFnNotify)(pi_program Program, void *UserData), void *UserData) {
283  return pi2ur::piProgramCompile(Program, NumDevices, DeviceList, Options,
284  NumInputHeaders, InputHeaders,
285  HeaderIncludeNames, PFnNotify, UserData);
286 }
287 
289  const pi_device *DeviceList, const char *Options,
290  void (*PFnNotify)(pi_program Program, void *UserData),
291  void *UserData) {
292  return pi2ur::piProgramBuild(Program, NumDevices, DeviceList, Options,
293  PFnNotify, UserData);
294 }
295 
297  pi_program_build_info ParamName,
298  size_t ParamValueSize, void *ParamValue,
299  size_t *ParamValueSizeRet) {
300  return pi2ur::piProgramGetBuildInfo(Program, Device, ParamName,
301  ParamValueSize, ParamValue,
302  ParamValueSizeRet);
303 }
304 
306  return pi2ur::piProgramRetain(Program);
307 }
308 
310  return pi2ur::piProgramRelease(Program);
311 }
312 
314  pi_native_handle *NativeHandle) {
315  return pi2ur::piextProgramGetNativeHandle(Program, NativeHandle);
316 }
317 
319  pi_context Context,
320  bool OwnNativeHandle,
321  pi_program *Program) {
322  return pi2ur::piextProgramCreateWithNativeHandle(NativeHandle, Context,
323  OwnNativeHandle, Program);
324 }
325 
326 pi_result piKernelCreate(pi_program Program, const char *KernelName,
327  pi_kernel *RetKernel) {
328  return pi2ur::piKernelCreate(Program, KernelName, RetKernel);
329 }
330 
331 pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize,
332  const void *ArgValue) {
333  return pi2ur::piKernelSetArg(Kernel, ArgIndex, ArgSize, ArgValue);
334 }
335 
337  const pi_mem_obj_property *ArgProperties,
338  const pi_mem *ArgValue) {
339  return pi2ur::piextKernelSetArgMemObj(Kernel, ArgIndex, ArgProperties,
340  ArgValue);
341 }
342 
344  const pi_sampler *ArgValue) {
345  return pi2ur::piextKernelSetArgSampler(Kernel, ArgIndex, ArgValue);
346 }
347 
349  size_t ParamValueSize, void *ParamValue,
350  size_t *ParamValueSizeRet) {
351  return pi2ur::piKernelGetInfo(Kernel, ParamName, ParamValueSize, ParamValue,
352  ParamValueSizeRet);
353 }
354 
356  pi_image_format *ImageFormat,
357  pi_image_desc *ImageDesc,
358  pi_image_mem_handle *RetMem) {
359  return pi2ur::piextMemImageAllocate(Context, Device, ImageFormat, ImageDesc,
360  RetMem);
361 }
362 
364  pi_image_mem_handle ImgMem,
365  pi_image_format *ImageFormat,
366  pi_image_desc *ImageDesc,
367  pi_image_handle *RetHandle) {
368  return pi2ur::piextMemUnsampledImageCreate(Context, Device, ImgMem,
369  ImageFormat, ImageDesc, RetHandle);
370 }
371 
373  pi_image_mem_handle ImgMem,
374  pi_image_format *ImageFormat,
375  pi_image_desc *ImageDesc,
376  pi_sampler Sampler,
377  pi_image_handle *RetHandle) {
378  return pi2ur::piextMemSampledImageCreate(Context, Device, ImgMem, ImageFormat,
379  ImageDesc, Sampler, RetHandle);
380 }
381 
383  pi_context Context, const pi_sampler_properties *SamplerProperties,
384  float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy,
385  pi_sampler *RetSampler) {
387  Context, SamplerProperties, MinMipmapLevelClamp, MaxMipmapLevelClamp,
388  MaxAnisotropy, RetSampler);
389 }
390 
392  pi_image_mem_handle MipMem, unsigned int Level,
393  pi_image_mem_handle *RetMem) {
394  return pi2ur::piextMemMipmapGetLevel(Context, Device, MipMem, Level, RetMem);
395 }
396 
398  pi_image_mem_handle MemoryHandle) {
399  return pi2ur::piextMemImageFree(Context, Device, MemoryHandle);
400 }
401 
403  pi_image_mem_handle MemoryHandle) {
404  return pi2ur::piextMemMipmapFree(Context, Device, MemoryHandle);
405 }
406 
407 pi_result
408 piextMemImageCopy(pi_queue Queue, void *DstPtr, void *SrcPtr,
409  const pi_image_format *ImageFormat,
410  const pi_image_desc *ImageDesc,
411  const pi_image_copy_flags Flags, pi_image_offset SrcOffset,
412  pi_image_offset DstOffset, pi_image_region CopyExtent,
413  pi_image_region HostExtent, pi_uint32 NumEventsInWaitList,
414  const pi_event *EventWaitList, pi_event *Event) {
415  return pi2ur::piextMemImageCopy(Queue, DstPtr, SrcPtr, ImageFormat, ImageDesc,
416  Flags, SrcOffset, DstOffset, CopyExtent,
417  HostExtent, NumEventsInWaitList,
418  EventWaitList, Event);
419 }
420 
422  pi_device Device,
423  pi_image_handle Handle) {
424  return pi2ur::piextMemUnsampledImageHandleDestroy(Context, Device, Handle);
425 }
426 
428  pi_device Device,
429  pi_image_handle Handle) {
430  return pi2ur::piextMemSampledImageHandleDestroy(Context, Device, Handle);
431 }
432 
434  pi_image_info ParamName, void *ParamValue,
435  size_t *ParamValueSizeRet) {
436  return pi2ur::piextMemImageGetInfo(MemHandle, ParamName, ParamValue,
437  ParamValueSizeRet);
438 }
439 
440 [[deprecated("This function has been deprecated in favor of "
441  "`piextImportExternalMemory`")]]
443  size_t Size, int FileDescriptor,
444  pi_interop_mem_handle *RetHandle) {
445  return pi2ur::piextMemImportOpaqueFD(Context, Device, Size, FileDescriptor,
446  RetHandle);
447 }
448 
451  pi_interop_mem_handle *RetHandle) {
452  return pi2ur::piextImportExternalMemory(Context, Device, MemDesc, RetHandle);
453 }
454 
456  pi_image_format *ImageFormat,
457  pi_image_desc *ImageDesc,
458  pi_interop_mem_handle MemHandle,
459  pi_image_mem_handle *RetMem) {
460  return pi2ur::piextMemMapExternalArray(Context, Device, ImageFormat,
461  ImageDesc, MemHandle, RetMem);
462 }
463 
465  pi_interop_mem_handle ExtMem) {
466  return pi2ur::piextMemReleaseInterop(Context, Device, ExtMem);
467 }
468 
469 [[deprecated("This function has been deprecated in favor of "
470  "`piextImportExternalSemaphore`")]]
471 pi_result
473  int FileDescriptor,
474  pi_interop_semaphore_handle *RetHandle) {
475  return pi2ur::piextImportExternalSemaphoreOpaqueFD(Context, Device,
476  FileDescriptor, RetHandle);
477 }
478 
479 pi_result
482  pi_interop_semaphore_handle *RetHandle) {
483  return pi2ur::piextImportExternalSemaphore(Context, Device, SemDesc,
484  RetHandle);
485 }
486 
488  pi_interop_semaphore_handle SemHandle) {
489  return pi2ur::piextDestroyExternalSemaphore(Context, Device, SemHandle);
490 }
491 
493  pi_queue Queue, pi_interop_semaphore_handle SemHandle, bool HasWaitValue,
494  pi_uint64 WaitValue, pi_uint32 NumEventsInWaitList,
495  const pi_event *EventWaitList, pi_event *Event) {
496  return pi2ur::piextWaitExternalSemaphore(Queue, SemHandle, HasWaitValue,
497  WaitValue, NumEventsInWaitList,
498  EventWaitList, Event);
499 }
500 
502  pi_queue Queue, pi_interop_semaphore_handle SemHandle, bool HasSignalValue,
503  pi_uint64 SignalValue, pi_uint32 NumEventsInWaitList,
504  const pi_event *EventWaitList, pi_event *Event) {
505  return pi2ur::piextSignalExternalSemaphore(Queue, SemHandle, HasSignalValue,
506  SignalValue, NumEventsInWaitList,
507  EventWaitList, Event);
508 }
509 
511  pi_kernel_group_info ParamName,
512  size_t ParamValueSize, void *ParamValue,
513  size_t *ParamValueSizeRet) {
514  return pi2ur::piKernelGetGroupInfo(Kernel, Device, ParamName, ParamValueSize,
515  ParamValue, ParamValueSizeRet);
516 }
517 
519  pi_kernel_sub_group_info ParamName,
520  size_t InputValueSize, const void *InputValue,
521  size_t ParamValueSize, void *ParamValue,
522  size_t *ParamValueSizeRet) {
524  Kernel, Device, ParamName, InputValueSize, InputValue, ParamValueSize,
525  ParamValue, ParamValueSizeRet);
526 }
527 
529  return pi2ur::piKernelRetain(Kernel);
530 }
531 
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) {
563  NativeHandle, Context, Program, OwnNativeHandle, Kernel);
564 }
565 
567  pi_native_handle *NativeHandle) {
568  return pi2ur::piextKernelGetNativeHandle(Kernel, NativeHandle);
569 }
570 
572  pi_kernel Kernel, size_t LocalWorkSize, size_t DynamicSharedMemorySize,
573  pi_uint32 *GroupCountRet) {
575  Kernel, LocalWorkSize, DynamicSharedMemorySize, GroupCountRet);
576 }
577 
579  return pi2ur::piEventCreate(Context, RetEvent);
580 }
581 
583  size_t ParamValueSize, void *ParamValue,
584  size_t *ParamValueSizeRet) {
585  return pi2ur::piEventGetInfo(Event, ParamName, ParamValueSize, ParamValue,
586  ParamValueSizeRet);
587 }
588 
590  size_t ParamValueSize, void *ParamValue,
591  size_t *ParamValueSizeRet) {
592  return pi2ur::piEventGetProfilingInfo(Event, ParamName, ParamValueSize,
593  ParamValue, ParamValueSizeRet);
594 }
595 
596 pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList) {
597  return pi2ur::piEventsWait(NumEvents, EventList);
598 }
599 
600 pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType,
601  void (*PFnNotify)(pi_event Event,
602  pi_int32 EventCommandStatus,
603  void *UserData),
604  void *UserData) {
605  return pi2ur::piEventSetCallback(Event, CommandExecCallbackType, PFnNotify,
606  UserData);
607 }
608 
609 pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus) {
610  return pi2ur::piEventSetStatus(Event, ExecutionStatus);
611 }
612 
614 
616  return pi2ur::piEventRelease(Event);
617 }
618 
620  pi_native_handle *NativeHandle) {
621  return pi2ur::piextEventGetNativeHandle(Event, NativeHandle);
622 }
623 
625  pi_context Context,
626  bool OwnNativeHandle,
627  pi_event *Event) {
628  return pi2ur::piextEventCreateWithNativeHandle(NativeHandle, Context,
629  OwnNativeHandle, Event);
630 }
631 
633  pi_uint32 NumEventsInWaitList,
634  const pi_event *EventWaitList,
635  pi_event *Event) {
637  Queue, Blocking, NumEventsInWaitList, EventWaitList, Event);
638 }
639 
641  const pi_sampler_properties *SamplerProperties,
642  pi_sampler *RetSampler) {
643  return pi2ur::piSamplerCreate(Context, SamplerProperties, RetSampler);
644 }
645 
647  size_t ParamValueSize, void *ParamValue,
648  size_t *ParamValueSizeRet) {
649  return pi2ur::piSamplerGetInfo(Sampler, ParamName, ParamValueSize, ParamValue,
650  ParamValueSizeRet);
651 }
652 
654  return pi2ur::piSamplerRetain(Sampler);
655 }
656 
658  return pi2ur::piSamplerRelease(Sampler);
659 }
660 
661 pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList,
662  const pi_event *EventWaitList,
663  pi_event *OutEvent) {
664  return pi2ur::piEnqueueEventsWait(Queue, NumEventsInWaitList, EventWaitList,
665  OutEvent);
666 }
667 
669  pi_uint32 NumEventsInWaitList,
670  const pi_event *EventWaitList,
671  pi_event *OutEvent) {
672  return pi2ur::piEnqueueEventsWaitWithBarrier(Queue, NumEventsInWaitList,
673  EventWaitList, OutEvent);
674 }
675 
677  pi_bool BlockingRead, size_t Offset,
678  size_t Size, void *Dst,
679  pi_uint32 NumEventsInWaitList,
680  const pi_event *EventWaitList,
681  pi_event *Event) {
682  return pi2ur::piEnqueueMemBufferRead(Queue, Src, BlockingRead, Offset, Size,
683  Dst, NumEventsInWaitList, EventWaitList,
684  Event);
685 }
686 
688  pi_queue Queue, pi_mem Buffer, pi_bool BlockingRead,
689  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
690  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
691  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
692  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
693  pi_event *Event) {
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  return pi2ur::piEnqueueMemBufferWrite(Queue, Buffer, BlockingWrite, Offset,
707  Size, Ptr, NumEventsInWaitList,
708  EventWaitList, Event);
709 }
710 
712  pi_queue Queue, pi_mem Buffer, pi_bool BlockingWrite,
713  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
714  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
715  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
716  pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList,
717  pi_event *Event) {
719  Queue, Buffer, BlockingWrite, BufferOffset, HostOffset, Region,
720  BufferRowPitch, BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
721  NumEventsInWaitList, EventWaitList, Event);
722 }
723 
725  size_t SrcOffset, size_t DstOffset,
726  size_t Size, pi_uint32 NumEventsInWaitList,
727  const pi_event *EventWaitList,
728  pi_event *Event) {
729  return pi2ur::piEnqueueMemBufferCopy(Queue, SrcMem, DstMem, SrcOffset,
730  DstOffset, Size, NumEventsInWaitList,
731  EventWaitList, Event);
732 }
733 
735  pi_queue Queue, pi_mem SrcMem, pi_mem DstMem, pi_buff_rect_offset SrcOrigin,
736  pi_buff_rect_offset DstOrigin, pi_buff_rect_region Region,
737  size_t SrcRowPitch, size_t SrcSlicePitch, size_t DstRowPitch,
738  size_t DstSlicePitch, pi_uint32 NumEventsInWaitList,
739  const pi_event *EventWaitList, pi_event *Event) {
740 
742  Queue, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
743  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumEventsInWaitList,
744  EventWaitList, Event);
745 }
746 
748  const void *Pattern, size_t PatternSize,
749  size_t Offset, size_t Size,
750  pi_uint32 NumEventsInWaitList,
751  const pi_event *EventWaitList,
752  pi_event *Event) {
753  return pi2ur::piEnqueueMemBufferFill(Queue, Buffer, Pattern, PatternSize,
754  Offset, Size, NumEventsInWaitList,
755  EventWaitList, Event);
756 }
757 
759  pi_map_flags MapFlags, size_t Offset,
760  size_t Size, pi_uint32 NumEventsInWaitList,
761  const pi_event *EventWaitList,
762  pi_event *OutEvent, void **RetMap) {
763  return pi2ur::piEnqueueMemBufferMap(Queue, Mem, BlockingMap, MapFlags, Offset,
764  Size, NumEventsInWaitList, EventWaitList,
765  OutEvent, RetMap);
766 }
767 
768 pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr,
769  pi_uint32 NumEventsInWaitList,
770  const pi_event *EventWaitList, pi_event *OutEvent) {
771  return pi2ur::piEnqueueMemUnmap(Queue, Mem, MappedPtr, NumEventsInWaitList,
772  EventWaitList, OutEvent);
773 }
774 
776  size_t ParamValueSize, void *ParamValue,
777  size_t *ParamValueSizeRet) {
778  return pi2ur::piMemImageGetInfo(Image, ParamName, ParamValueSize, ParamValue,
779  ParamValueSizeRet);
780 }
781 
783  pi_bool BlockingRead, pi_image_offset Origin,
784  pi_image_region Region, size_t RowPitch,
785  size_t SlicePitch, void *Ptr,
786  pi_uint32 NumEventsInWaitList,
787  const pi_event *EventWaitList,
788  pi_event *Event) {
790  Queue, Image, BlockingRead, Origin, Region, RowPitch, SlicePitch, Ptr,
791  NumEventsInWaitList, EventWaitList, Event);
792 }
793 
795  pi_bool BlockingWrite, pi_image_offset Origin,
796  pi_image_region Region, size_t InputRowPitch,
797  size_t InputSlicePitch, const void *Ptr,
798  pi_uint32 NumEventsInWaitList,
799  const pi_event *EventWaitList,
800  pi_event *Event) {
802  Queue, Image, BlockingWrite, Origin, Region, InputRowPitch,
803  InputSlicePitch, Ptr, NumEventsInWaitList, EventWaitList, Event);
804 }
805 
806 pi_result
807 piEnqueueMemImageCopy(pi_queue Queue, pi_mem SrcImage, pi_mem DstImage,
808  pi_image_offset SrcOrigin, pi_image_offset DstOrigin,
809  pi_image_region Region, pi_uint32 NumEventsInWaitList,
810  const pi_event *EventWaitList, pi_event *Event) {
811  return pi2ur::piEnqueueMemImageCopy(Queue, SrcImage, DstImage, SrcOrigin,
812  DstOrigin, Region, NumEventsInWaitList,
813  EventWaitList, Event);
814 }
815 
817  const void *FillColor, const size_t *Origin,
818  const size_t *Region,
819  pi_uint32 NumEventsInWaitList,
820  const pi_event *EventWaitList,
821  pi_event *Event) {
822  return pi2ur::piEnqueueMemImageFill(Queue, Image, FillColor, Origin, Region,
823  NumEventsInWaitList, EventWaitList,
824  Event);
825 }
826 
828  pi_buffer_create_type BufferCreateType,
829  void *BufferCreateInfo, pi_mem *RetMem) {
830  return pi2ur::piMemBufferPartition(Buffer, Flags, BufferCreateType,
831  BufferCreateInfo, RetMem);
832 }
833 
835  const char *FunctionName,
836  pi_uint64 *FunctionPointerRet) {
837  return pi2ur::piextGetDeviceFunctionPointer(Device, Program, FunctionName,
838  FunctionPointerRet);
839 }
840 
842  const char *GlobalVariableName,
843  size_t *GlobalVariableSize,
844  void **GlobalVariablePointerRet) {
846  Device, Program, GlobalVariableName, GlobalVariableSize,
847  GlobalVariablePointerRet);
848 }
849 
850 pi_result piextUSMDeviceAlloc(void **ResultPtr, pi_context Context,
851  pi_device Device,
852  pi_usm_mem_properties *Properties, size_t Size,
854  return pi2ur::piextUSMDeviceAlloc(ResultPtr, Context, Device, Properties,
855  Size, Alignment);
856 }
857 
858 pi_result piextUSMSharedAlloc(void **ResultPtr, pi_context Context,
859  pi_device Device,
860  pi_usm_mem_properties *Properties, size_t Size,
862  return pi2ur::piextUSMSharedAlloc(ResultPtr, Context, Device, Properties,
863  Size, Alignment);
864 }
865 
866 pi_result piextUSMPitchedAlloc(void **ResultPtr, size_t *ResultPitch,
867  pi_context Context, pi_device Device,
868  pi_usm_mem_properties *Properties,
869  size_t WidthInBytes, size_t Height,
870  unsigned int ElementSizeBytes) {
871  return pi2ur::piextUSMPitchedAlloc(ResultPtr, ResultPitch, Context, Device,
872  Properties, WidthInBytes, Height,
873  ElementSizeBytes);
874 }
875 
876 pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context,
877  pi_usm_mem_properties *Properties, size_t Size,
879  return pi2ur::piextUSMHostAlloc(ResultPtr, Context, Properties, Size,
880  Alignment);
881 }
882 
883 pi_result piextUSMFree(pi_context Context, void *Ptr) {
884  return pi2ur::piextUSMFree(Context, Ptr);
885 }
886 
888  size_t ArgSize, const void *ArgValue) {
889  return pi2ur::piextKernelSetArgPointer(Kernel, ArgIndex, ArgSize, ArgValue);
890 }
891 
893  size_t Count, pi_uint32 NumEventsInWaitlist,
894  const pi_event *EventsWaitlist,
895  pi_event *Event) {
897  Queue, Ptr, Value, Count, NumEventsInWaitlist, EventsWaitlist, Event);
898 }
899 
900 pi_result piextUSMEnqueueMemcpy(pi_queue Queue, pi_bool Blocking, void *DstPtr,
901  const void *SrcPtr, size_t Size,
902  pi_uint32 NumEventsInWaitlist,
903  const pi_event *EventsWaitlist,
904  pi_event *Event) {
905  return pi2ur::piextUSMEnqueueMemcpy(Queue, Blocking, DstPtr, SrcPtr, Size,
906  NumEventsInWaitlist, EventsWaitlist,
907  Event);
908 }
909 
910 pi_result piextUSMEnqueuePrefetch(pi_queue Queue, const void *Ptr, size_t Size,
912  pi_uint32 NumEventsInWaitList,
913  const pi_event *EventWaitList,
914  pi_event *OutEvent) {
916  Queue, Ptr, Size, Flags, NumEventsInWaitList, EventWaitList, OutEvent);
917 }
918 
920  size_t Length, pi_mem_advice Advice,
921  pi_event *OutEvent) {
922 
923  return pi2ur::piextUSMEnqueueMemAdvise(Queue, Ptr, Length, Advice, OutEvent);
924 }
925 
926 pi_result piextUSMEnqueueFill2D(pi_queue Queue, void *Ptr, size_t Pitch,
927  size_t PatternSize, const void *Pattern,
928  size_t Width, size_t Height,
929  pi_uint32 NumEventsWaitList,
930  const pi_event *EventsWaitList,
931  pi_event *Event) {
932  return pi2ur::piextUSMEnqueueFill2D(Queue, Ptr, Pitch, PatternSize, Pattern,
933  Width, Height, NumEventsWaitList,
934  EventsWaitList, Event);
935 }
936 
937 pi_result piextUSMEnqueueMemset2D(pi_queue Queue, void *Ptr, size_t Pitch,
938  int Value, size_t Width, size_t Height,
939  pi_uint32 NumEventsWaitList,
940  const pi_event *EventsWaitlist,
941  pi_event *Event) {
942  return pi2ur::piextUSMEnqueueMemset2D(Queue, Ptr, Pitch, Value, Width, Height,
943  NumEventsWaitList, EventsWaitlist,
944  Event);
945 }
946 
948  void *DstPtr, size_t DstPitch,
949  const void *SrcPtr, size_t SrcPitch,
950  size_t Width, size_t Height,
951  pi_uint32 NumEventsInWaitlist,
952  const pi_event *EventWaitlist,
953  pi_event *Event) {
955  Queue, Blocking, DstPtr, DstPitch, SrcPtr, SrcPitch, Width, Height,
956  NumEventsInWaitlist, EventWaitlist, Event);
957 }
958 
960  pi_mem_alloc_info ParamName,
961  size_t ParamValueSize, void *ParamValue,
962  size_t *ParamValueSizeRet) {
963  return pi2ur::piextUSMGetMemAllocInfo(Context, Ptr, ParamName, ParamValueSize,
964  ParamValue, ParamValueSizeRet);
965 }
966 
967 pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context) {
968  return pi2ur::piextUSMImport(HostPtr, Size, Context);
969 }
970 
971 pi_result piextUSMRelease(const void *HostPtr, pi_context Context) {
972  return pi2ur::piextUSMRelease(HostPtr, Context);
973 }
974 
976  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite,
977  size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList,
978  const pi_event *EventsWaitList, pi_event *Event) {
980  Queue, Program, Name, BlockingWrite, Count, Offset, Src,
981  NumEventsInWaitList, EventsWaitList, Event);
982 }
983 
985  pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingRead,
986  size_t Count, size_t Offset, void *Dst, pi_uint32 NumEventsInWaitList,
987  const pi_event *EventsWaitList, pi_event *Event) {
988 
990  Queue, Program, Name, BlockingRead, Count, Offset, Dst,
991  NumEventsInWaitList, EventsWaitList, Event);
992 
993  return PI_SUCCESS;
994 }
995 
997  const char *PipeSymbol, pi_bool Blocking,
998  void *Ptr, size_t Size,
999  pi_uint32 NumEventsInWaitList,
1000  const pi_event *EventsWaitList,
1001  pi_event *Event) {
1002  return pi2ur::piextEnqueueReadHostPipe(Queue, Program, PipeSymbol, Blocking,
1003  Ptr, Size, NumEventsInWaitList,
1004  EventsWaitList, Event);
1005 }
1006 
1008  const char *PipeSymbol, pi_bool Blocking,
1009  void *Ptr, size_t Size,
1010  pi_uint32 NumEventsInWaitList,
1011  const pi_event *EventsWaitList,
1012  pi_event *Event) {
1013  return pi2ur::piextEnqueueWriteHostPipe(Queue, Program, PipeSymbol, Blocking,
1014  Ptr, Size, NumEventsInWaitList,
1015  EventsWaitList, Event);
1016 }
1017 
1019  size_t ParamValueSize, const void *ParamValue) {
1020 
1021  return pi2ur::piKernelSetExecInfo(Kernel, ParamName, ParamValueSize,
1022  ParamValue);
1023 }
1024 
1026  pi_uint32 SpecID, size_t Size,
1027  const void *SpecValue) {
1028  return pi2ur::piextProgramSetSpecializationConstant(Prog, SpecID, Size,
1029  SpecValue);
1030 }
1031 
1033  const pi_ext_command_buffer_desc *Desc,
1034  pi_ext_command_buffer *RetCommandBuffer) {
1035  return pi2ur::piextCommandBufferCreate(Context, Device, Desc,
1036  RetCommandBuffer);
1037 }
1038 
1040  return pi2ur::piextCommandBufferRetain(CommandBuffer);
1041 }
1042 
1044  return pi2ur::piextCommandBufferRelease(CommandBuffer);
1045 }
1046 
1048  return pi2ur::piextCommandBufferFinalize(CommandBuffer);
1049 }
1050 
1052  pi_ext_command_buffer CommandBuffer, pi_kernel Kernel, pi_uint32 WorkDim,
1053  const size_t *GlobalWorkOffset, const size_t *GlobalWorkSize,
1054  const size_t *LocalWorkSize, pi_uint32 NumSyncPointsInWaitList,
1055  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint,
1056  pi_ext_command_buffer_command *Command) {
1058  CommandBuffer, Kernel, WorkDim, GlobalWorkOffset, GlobalWorkSize,
1059  LocalWorkSize, NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint,
1060  Command);
1061 }
1062 
1064  pi_ext_command_buffer CommandBuffer, void *DstPtr, const void *SrcPtr,
1065  size_t Size, pi_uint32 NumSyncPointsInWaitList,
1066  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1067  return pi2ur::piextCommandBufferMemcpyUSM(CommandBuffer, DstPtr, SrcPtr, Size,
1068  NumSyncPointsInWaitList,
1069  SyncPointWaitList, SyncPoint);
1070 }
1071 
1073  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1074  size_t SrcOffset, size_t DstOffset, size_t Size,
1075  pi_uint32 NumSyncPointsInWaitList,
1076  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1078  CommandBuffer, SrcMem, DstMem, SrcOffset, DstOffset, Size,
1079  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1080 }
1081 
1083  pi_ext_command_buffer CommandBuffer, pi_mem SrcMem, pi_mem DstMem,
1084  pi_buff_rect_offset SrcOrigin, pi_buff_rect_offset DstOrigin,
1085  pi_buff_rect_region Region, size_t SrcRowPitch, size_t SrcSlicePitch,
1086  size_t DstRowPitch, size_t DstSlicePitch, pi_uint32 NumSyncPointsInWaitList,
1087  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1089  CommandBuffer, SrcMem, DstMem, SrcOrigin, DstOrigin, Region, SrcRowPitch,
1090  SrcSlicePitch, DstRowPitch, DstSlicePitch, NumSyncPointsInWaitList,
1091  SyncPointWaitList, SyncPoint);
1092 }
1093 
1095  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1096  size_t Size, void *Dst, pi_uint32 NumSyncPointsInWaitList,
1097  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1099  CommandBuffer, Buffer, Offset, Size, Dst, NumSyncPointsInWaitList,
1100  SyncPointWaitList, SyncPoint);
1101 }
1102 
1104  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1105  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1106  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1107  size_t HostRowPitch, size_t HostSlicePitch, void *Ptr,
1108  pi_uint32 NumSyncPointsInWaitList,
1109  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1111  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1112  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1113  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1114 }
1115 
1117  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, size_t Offset,
1118  size_t Size, const void *Ptr, pi_uint32 NumSyncPointsInWaitList,
1119  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1121  CommandBuffer, Buffer, Offset, Size, Ptr, NumSyncPointsInWaitList,
1122  SyncPointWaitList, SyncPoint);
1123 }
1124 
1126  pi_ext_command_buffer CommandBuffer, pi_mem Buffer,
1127  pi_buff_rect_offset BufferOffset, pi_buff_rect_offset HostOffset,
1128  pi_buff_rect_region Region, size_t BufferRowPitch, size_t BufferSlicePitch,
1129  size_t HostRowPitch, size_t HostSlicePitch, const void *Ptr,
1130  pi_uint32 NumSyncPointsInWaitList,
1131  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1133  CommandBuffer, Buffer, BufferOffset, HostOffset, Region, BufferRowPitch,
1134  BufferSlicePitch, HostRowPitch, HostSlicePitch, Ptr,
1135  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1136 }
1137 
1139  pi_ext_command_buffer CommandBuffer, pi_mem Buffer, const void *Pattern,
1140  size_t PatternSize, size_t Offset, size_t Size,
1141  pi_uint32 NumSyncPointsInWaitList,
1142  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1144  CommandBuffer, Buffer, Pattern, PatternSize, Offset, Size,
1145  NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
1146 }
1147 
1149  void *Ptr, const void *Pattern,
1150  size_t PatternSize, size_t Size,
1151  pi_uint32 NumSyncPointsInWaitList,
1152  const pi_ext_sync_point *SyncPointWaitList,
1153  pi_ext_sync_point *SyncPoint) {
1155  CommandBuffer, Ptr, Pattern, PatternSize, Size, NumSyncPointsInWaitList,
1156  SyncPointWaitList, SyncPoint);
1157 }
1158 
1160  pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Size,
1161  pi_usm_migration_flags Flags, pi_uint32 NumSyncPointsInWaitList,
1162  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1163  return pi2ur::piextCommandBufferPrefetchUSM(CommandBuffer, Ptr, Size, Flags,
1164  NumSyncPointsInWaitList,
1165  SyncPointWaitList, SyncPoint);
1166 }
1167 
1169  pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Length,
1170  pi_mem_advice Advice, pi_uint32 NumSyncPointsInWaitList,
1171  const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
1172  return pi2ur::piextCommandBufferAdviseUSM(CommandBuffer, Ptr, Length, Advice,
1173  NumSyncPointsInWaitList,
1174  SyncPointWaitList, SyncPoint);
1175 }
1176 
1178  pi_queue Queue,
1179  pi_uint32 NumEventsInWaitList,
1180  const pi_event *EventWaitList,
1181  pi_event *Event) {
1183  CommandBuffer, Queue, NumEventsInWaitList, EventWaitList, Event);
1184 }
1185 
1189  return pi2ur::piextCommandBufferUpdateKernelLaunch(Command, Desc);
1190 }
1191 
1192 pi_result
1195 }
1196 
1197 pi_result
1200 }
1201 
1202 pi_result piextPluginGetOpaqueData(void *opaque_data_param,
1203  void **opaque_data_return) {
1204  return pi2ur::piextPluginGetOpaqueData(opaque_data_param, opaque_data_return);
1205 }
1206 
1207 pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime,
1208  uint64_t *HostTime) {
1209  return pi2ur::piGetDeviceAndHostTimer(Device, DeviceTime, HostTime);
1210 }
1211 
1213  pi_device peer_device) {
1214  return pi2ur::piextEnablePeerAccess(command_device, peer_device);
1215 }
1216 
1218  pi_device peer_device) {
1219  return pi2ur::piextDisablePeerAccess(command_device, peer_device);
1220 }
1221 
1223  pi_device peer_device, pi_peer_attr attr,
1224  size_t ParamValueSize, void *ParamValue,
1225  size_t *ParamValueSizeRet) {
1226  return pi2ur::piextPeerAccessGetInfo(command_device, peer_device, attr,
1227  ParamValueSize, ParamValue,
1228  ParamValueSizeRet);
1229 }
1230 
1231 pi_result piTearDown(void *PluginParameter) {
1232  return pi2ur::piTearDown(PluginParameter);
1233 }
1234 
1236  // Check that the major version matches in PiVersion and SupportedVersion
1238 
1239  // PI interface supports higher version or the same version.
1240  size_t PluginVersionSize = sizeof(PluginInit->PluginVersion);
1241  if (strlen(SupportedVersion) >= PluginVersionSize)
1242  return PI_ERROR_INVALID_VALUE;
1243  strncpy(PluginInit->PluginVersion, SupportedVersion, PluginVersionSize);
1244 
1245 #define _PI_API(api) \
1246  (PluginInit->PiFunctionTable).api = (decltype(&::api))(&api);
1247 #include <sycl/detail/pi.def>
1248 #undef _PI_API
1249 
1250  return PI_SUCCESS;
1251 }
1252 
1253 #ifdef _WIN32
1254 #define __SYCL_PLUGIN_DLL_NAME "pi_opencl.dll"
1255 #include "../common_win_pi_trace/common_win_pi_trace.hpp"
1256 #undef __SYCL_PLUGIN_DLL_NAME
1257 #endif
1258 
1259 } // end extern 'C'
pi_result piextWaitExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, bool HasWaitValue, pi_uint64 WaitValue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi2ur.hpp:5607
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:3896
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:2160
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:4707
pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1967
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:3520
pi_result piKernelSetExecInfo(pi_kernel Kernel, pi_kernel_exec_info ParamName, size_t ParamValueSize, const void *ParamValue)
Definition: pi2ur.hpp:2332
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:876
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:3421
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:3558
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:2465
pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1824
pi_result piMemRetain(pi_mem Mem)
Definition: pi2ur.hpp:3392
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi2ur.hpp:823
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:4134
pi_result piextEnqueueWriteHostPipe(pi_queue queue, pi_program program, const char *pipe_symbol, pi_bool blocking, void *ptr, size_t size, pi_uint32 num_events_in_waitlist, const pi_event *events_waitlist, pi_event *event)
Definition: pi2ur.hpp:4175
pi_result piextKernelSuggestMaxCooperativeGroupCount(pi_kernel Kernel, size_t LocalWorkSize, size_t DynamicSharedMemorySize, pi_uint32 *GroupCountRet)
Definition: pi2ur.hpp:2657
pi_result piextDestroyExternalSemaphore(pi_context Context, pi_device Device, pi_interop_semaphore_handle SemHandle)
Definition: pi2ur.hpp:5591
pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:3852
pi_result piextDeviceGetNativeHandle(pi_device Device, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:1337
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_image_handle *RetHandle)
Definition: pi2ur.hpp:5054
pi_result piextCommandBufferUpdateKernelLaunch(pi_ext_command_buffer_command command, pi_ext_command_buffer_update_kernel_launch_desc *desc)
Definition: pi2ur.hpp:4871
pi_result piProgramRelease(pi_program Program)
Definition: pi2ur.hpp:2543
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:4787
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:3764
pi_result piPluginGetBackendOption(pi_platform Platform, const char *FrontendOption, const char **PlatformOption)
Definition: pi2ur.hpp:936
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:4579
pi_result piextPluginGetOpaqueData(void *opaque_data_param, void **opaque_data_return)
Definition: pi2ur.hpp:929
pi_result piKernelCreate(pi_program Program, const char *KernelName, pi_kernel *RetKernel)
Definition: pi2ur.hpp:2143
pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context)
Definition: pi2ur.hpp:3600
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:3715
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi2ur.hpp:4344
pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, void(*PFnNotify)(pi_event Event, pi_int32 EventCommandStatus, void *UserData), void *UserData)
Definition: pi2ur.hpp:4331
pi_result piSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, pi_sampler *RetSampler)
Definition: pi2ur.hpp:4391
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4452
pi_result piextMemUnsampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
Definition: pi2ur.hpp:5298
pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_sampler *ArgValue)
Definition: pi2ur.hpp:4490
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:1737
pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:3623
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:4738
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:5463
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:1921
pi_result piextProgramGetNativeHandle(pi_program Program, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:2377
pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2413
pi_result piextEventGetNativeHandle(pi_event Event, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:4239
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventsWaitList, pi_event *OutEvent)
Definition: pi2ur.hpp:4115
pi_result piextMemMipmapFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
Definition: pi2ur.hpp:5223
pi_result piextPlatformGetNativeHandle(pi_platform Platform, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:836
pi_result piSamplerRelease(pi_sampler Sampler)
Definition: pi2ur.hpp:4512
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:2742
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:4033
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:4660
pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, pi_uint32 NumEntries, pi_device *Devices, pi_uint32 *NumDevices)
Definition: pi2ur.hpp:952
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:2683
pi_result piextEventCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_event *Event)
Definition: pi2ur.hpp:4307
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4254
pi_result piKernelRetain(pi_kernel Kernel)
Definition: pi2ur.hpp:2521
pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_mem_obj_property *ArgProperties, const pi_mem *ArgValue)
Definition: pi2ur.hpp:2216
pi_result piextQueueGetNativeHandle(pi_queue Queue, pi_native_handle *NativeHandle, int32_t *NativeHandleDesc)
Definition: pi2ur.hpp:1783
pi_result piextBindlessImageSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, float MinMipmapLevelClamp, float MaxMipmapLevelClamp, float MaxAnisotropy, pi_sampler *RetSampler)
Definition: pi2ur.hpp:5081
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:3266
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:2603
pi_result piQueueFlush(pi_queue Queue)
Definition: pi2ur.hpp:1885
pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, size_t, const void *ArgValue)
Definition: pi2ur.hpp:2555
pi_result piEnqueueTimestampRecordingExp(pi_queue Queue, pi_bool Blocking, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi2ur.hpp:4369
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:2027
pi_result piSamplerRetain(pi_sampler Sampler)
Definition: pi2ur.hpp:4501
pi_result piextDeviceSelectBinary(pi_device Device, pi_device_binary *Binaries, pi_uint32 NumBinaries, pi_uint32 *SelectedBinaryInd)
Definition: pi2ur.hpp:1459
pi_result piextContextSetExtendedDeleter(pi_context Context, pi_context_extended_deleter Function, void *UserData)
Definition: pi2ur.hpp:1538
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:4690
pi_result piextGetDeviceFunctionPointer(pi_device Device, pi_program Program, const char *FunctionName, pi_uint64 *FunctionPointerRet)
Definition: pi2ur.hpp:2179
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:3920
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:5188
pi_result piGetDeviceAndHostTimer(pi_device Device, uint64_t *DeviceTime, uint64_t *HostTime)
Definition: pi2ur.hpp:1451
pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:4210
pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, pi_buffer_create_type BufferCreateType, void *BufferCreateInfo, pi_mem *RetMem)
Definition: pi2ur.hpp:3152
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:3954
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:1518
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:3300
pi_result piextUSMRelease(const void *HostPtr, pi_context Context)
Definition: pi2ur.hpp:3612
pi_result piEventRelease(pi_event Event)
Definition: pi2ur.hpp:4360
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:2566
pi_result piQueueRetain(pi_queue Queue)
Definition: pi2ur.hpp:1874
pi_result piextCommandBufferReleaseCommand(pi_ext_command_buffer_command command)
Definition: pi2ur.hpp:4937
pi_result piDeviceRelease(pi_device Device)
Definition: pi2ur.hpp:990
pi_result piContextRetain(pi_context Context)
Definition: pi2ur.hpp:1641
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:5005
pi_result piextUSMHostAlloc(void **ResultPtr, pi_context Context, pi_usm_mem_properties *Properties, size_t Size, pi_uint32 Alignment)
Definition: pi2ur.hpp:2817
pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer)
Definition: pi2ur.hpp:4550
pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1015
pi_result piextImportExternalMemory(pi_context Context, pi_device Device, pi_external_mem_descriptor *MemDescriptor, pi_interop_mem_handle *RetHandle)
Definition: pi2ur.hpp:5407
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:4808
pi_result piextKernelCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, pi_program Program, bool OwnNativeHandle, pi_kernel *Kernel)
Definition: pi2ur.hpp:2300
pi_result piextMemSampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
Definition: pi2ur.hpp:5314
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:3874
pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform Platform, pi_device *Device)
Definition: pi2ur.hpp:1351
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:3682
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:3819
pi_result piextCommandBufferRetainCommand(pi_ext_command_buffer_command command)
Definition: pi2ur.hpp:4929
pi_result piextEnqueueCommandBuffer(pi_ext_command_buffer CommandBuffer, pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi2ur.hpp:4851
pi_result piextCommandBufferCreate(pi_context Context, pi_device Device, const pi_ext_command_buffer_desc *Desc, pi_ext_command_buffer *RetCommandBuffer)
Definition: pi2ur.hpp:4530
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:3739
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:3539
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:3214
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:3123
pi_result piextQueueCreate(pi_context Context, pi_device Device, pi_queue_properties *Properties, pi_queue *Queue)
Definition: pi2ur.hpp:1660
pi_result piextProgramCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_program *Program)
Definition: pi2ur.hpp:2393
pi_result piextImportExternalSemaphore(pi_context Context, pi_device Device, pi_external_semaphore_descriptor *SemDescriptor, pi_interop_semaphore_handle *RetHandle)
Definition: pi2ur.hpp:5533
pi_result piextUSMFree(pi_context Context, void *Ptr)
Definition: pi2ur.hpp:3385
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:2715
pi_result piEventCreate(pi_context Context, pi_event *RetEvent)
Definition: pi2ur.hpp:4292
pi_result piextKernelGetNativeHandle(pi_kernel Kernel, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:2643
pi_result piextMemImageGetInfo(pi_image_mem_handle MemHandle, pi_image_info ParamName, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:5351
pi_result piQueueFinish(pi_queue Queue)
Definition: pi2ur.hpp:1813
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:4756
pi_result piContextRelease(pi_context Context)
Definition: pi2ur.hpp:1649
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Definition: pi2ur.hpp:853
pi_result piextMemReleaseInterop(pi_context Context, pi_device Device, pi_interop_mem_handle ExtMem)
Definition: pi2ur.hpp:5488
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi2ur.hpp:2271
pi_result piEventRetain(pi_event Event)
Definition: pi2ur.hpp:4351
pi_result piextContextGetNativeHandle(pi_context Context, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:1547
pi_result piMemRelease(pi_mem Mem)
Definition: pi2ur.hpp:3402
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:3979
pi_result piextCommandBufferFinalize(pi_ext_command_buffer CommandBuffer)
Definition: pi2ur.hpp:4570
pi_result piPluginGetLastError(char **Message)
Definition: pi2ur.hpp:998
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:3793
pi_result piKernelRelease(pi_kernel Kernel)
Definition: pi2ur.hpp:2532
pi_result piextMemImageFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
Definition: pi2ur.hpp:5207
pi_result piextMemUnsampledImageCreate(pi_context Context, pi_device Device, pi_image_mem_handle ImgMem, pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_image_handle *RetHandle)
Definition: pi2ur.hpp:5028
pi_result piextContextCreateWithNativeHandle(pi_native_handle NativeHandle, pi_uint32 NumDevices, const pi_device *Devices, bool OwnNativeHandle, pi_context *RetContext)
Definition: pi2ur.hpp:1558
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:4971
pi_result piQueueRelease(pi_queue Queue)
Definition: pi2ur.hpp:1803
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
Definition: pi2ur.hpp:4560
pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:1586
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:4613
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:4773
pi_result piextMemGetNativeHandle(pi_mem Mem, pi_device Dev, pi_native_handle *NativeHandle)
Definition: pi2ur.hpp:3199
pi_result piextGetGlobalVariablePointer(pi_device Device, pi_program Program, const char *GlobalVariableName, size_t *GlobalVariableSize, void **GlobalVariablePointerRet)
Definition: pi2ur.hpp:2198
pi_result piextSignalExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, bool HasSignalValue, pi_uint64 SignalValue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi2ur.hpp:5627
pi_result piTearDown(void *PluginParameter)
Definition: pi2ur.hpp:783
pi_result piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size, int FileDescriptor, pi_interop_mem_handle *RetHandle)
Definition: pi2ur.hpp:5380
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4960
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:4631
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi2ur.hpp:4950
pi_result piDevicePartition(pi_device Device, const pi_device_partition_property *Properties, pi_uint32 NumEntries, pi_device *SubDevices, pi_uint32 *NumSubDevices)
Definition: pi2ur.hpp:1375
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:4057
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:3081
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:2097
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:3999
pi_result piextEnqueueReadHostPipe(pi_queue queue, pi_program program, const char *pipe_symbol, pi_bool blocking, void *ptr, size_t size, pi_uint32 num_events_in_waitlist, const pi_event *events_waitlist, pi_event *event)
Definition: pi2ur.hpp:4157
pi_result piProgramRetain(pi_program Program)
Definition: pi2ur.hpp:2321
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:3458
pi_result piextProgramSetSpecializationConstant(pi_program Program, pi_uint32 SpecID, size_t Size, const void *SpecValue)
Definition: pi2ur.hpp:2126
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:3321
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:4092
pi_result piProgramCreate(pi_context Context, const void *ILBytes, size_t Length, pi_program *Program)
Definition: pi2ur.hpp:1902
pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventsWaitList)
Definition: pi2ur.hpp:4196
pi_result piDeviceRetain(pi_device Device)
Definition: pi2ur.hpp:983
pi_result piextImportExternalSemaphoreOpaqueFD(pi_context Context, pi_device Device, int FileDescriptor, pi_interop_semaphore_handle *RetHandle)
Definition: pi2ur.hpp:5506
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:4599
pi_result piextMemCreateWithNativeHandle(pi_native_handle NativeHandle, pi_context Context, bool OwnNativeHandle, pi_mem *Mem)
Definition: pi2ur.hpp:3245
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi2ur.hpp:2847
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:2059
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:5257
int32_t pi_int32
Definition: pi.h:238
uintptr_t pi_native_handle
Definition: pi.h:243
pi_bitfield pi_map_flags
Definition: pi.h:810
_pi_result
Definition: pi.h:250
pi_uint32 pi_bool
Definition: pi.h:241
pi_bitfield pi_usm_mem_properties
Definition: pi.h:822
_pi_device_info
Definition: pi.h:330
_pi_queue_info
Definition: pi.h:538
_pi_mem_advice
Definition: pi.h:641
_pi_kernel_sub_group_info
Definition: pi.h:580
pi_bitfield pi_mem_properties
Definition: pi.h:816
_pi_kernel_group_info
Definition: pi.h:559
pi_uint64 pi_image_handle
Definition: pi.h:1253
_pi_ext_command_buffer_command * pi_ext_command_buffer_command
Definition: pi.h:2451
_pi_kernel_exec_info
Definition: pi.h:1697
_pi_platform_info
Definition: pi.h:265
_pi_image_info
Definition: pi.h:570
pi_uint32 pi_ext_sync_point
Definition: pi.h:2452
_pi_profiling_info
Definition: pi.h:789
_pi_usm_migration_flags
Definition: pi.h:2075
_pi_device_type
Definition: pi.h:298
uint64_t pi_uint64
Definition: pi.h:240
pi_bitfield pi_queue_properties
Definition: pi.h:835
_pi_image_copy_flags
Definition: pi.h:718
pi_bitfield pi_sampler_properties
Definition: pi.h:766
_pi_buffer_create_type
Definition: pi.h:724
uint32_t pi_uint32
Definition: pi.h:239
_pi_event_info
Definition: pi.h:587
intptr_t pi_context_properties
Definition: pi.h:758
pi_bitfield pi_mem_flags
Definition: pi.h:800
constexpr pi_queue_properties PI_QUEUE_FLAGS
Definition: pi.h:836
void(* pi_context_extended_deleter)(void *user_data)
Definition: pi.h:1437
_pi_sampler_info
Definition: pi.h:729
_pi_kernel_info
Definition: pi.h:550
_pi_mem_alloc_info
Definition: pi.h:2058
_pi_context_info
Definition: pi.h:521
void * pi_image_mem_handle
Definition: pi.h:1254
#define _PI_PLUGIN_VERSION_CHECK(PI_API_VERSION, PI_PLUGIN_VERSION)
Definition: pi.h:216
_pi_program_info
Definition: pi.h:509
intptr_t pi_device_partition_property
Definition: pi.h:895
_pi_mem_info
Definition: pi.h:1279
pi_uint64 pi_interop_semaphore_handle
Definition: pi.h:1256
_pi_peer_attr
Definition: pi.h:1281
pi_uint64 pi_interop_mem_handle
Definition: pi.h:1255
_pi_program_build_info
Definition: pi.h:274
pi_result piextContextSetExtendedDeleter(pi_context Context, pi_context_extended_deleter Function, void *UserData)
Definition: pi_opencl.cpp:126
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_opencl.cpp:189
pi_result piextDisablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_opencl.cpp:1217
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_opencl.cpp:75
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_opencl.cpp:200
pi_result piMemRelease(pi_mem Mem)
Definition: pi_opencl.cpp:215
pi_result piEventSetStatus(pi_event Event, pi_int32 ExecutionStatus)
Definition: pi_opencl.cpp:609
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_opencl.cpp:1177
pi_result piextEnablePeerAccess(pi_device command_device, pi_device peer_device)
Definition: pi_opencl.cpp:1212
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_opencl.cpp:975
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_opencl.cpp:1072
pi_result piProgramGetBuildInfo(pi_program Program, pi_device Device, pi_program_build_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:296
pi_result piKernelGetGroupInfo(pi_kernel Kernel, pi_device Device, pi_kernel_group_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:510
pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform Platform, pi_device *Device)
Creates PI device object from a native handle.
Definition: pi_opencl.cpp:102
pi_result piEventSetCallback(pi_event Event, pi_int32 CommandExecCallbackType, void(*PFnNotify)(pi_event Event, pi_int32 EventCommandStatus, void *UserData), void *UserData)
Definition: pi_opencl.cpp:600
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_opencl.cpp:1047
pi_result piKernelCreate(pi_program Program, const char *KernelName, pi_kernel *RetKernel)
Definition: pi_opencl.cpp:326
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_opencl.cpp:278
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_opencl.cpp:1159
pi_result piextDeviceGetNativeHandle(pi_device Device, pi_native_handle *NativeHandle)
Gets the native handle of a PI device object.
Definition: pi_opencl.cpp:97
pi_result piextPlatformCreateWithNativeHandle(pi_native_handle NativeHandle, pi_platform *Platform)
Creates PI platform object from a native handle.
Definition: pi_opencl.cpp:44
pi_result piQueueRetain(pi_queue Queue)
Definition: pi_opencl.cpp:172
pi_result piQueueRelease(pi_queue Queue)
Definition: pi_opencl.cpp:174
pi_result piextCommandBufferReleaseCommand(pi_ext_command_buffer_command Command)
API to decrement the reference count of a command-buffer command.
Definition: pi_opencl.cpp:1198
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_opencl.cpp:433
pi_result piextPluginGetOpaqueData(void *opaque_data_param, void **opaque_data_return)
API to get Plugin internal data, opaque to SYCL RT.
Definition: pi_opencl.cpp:1202
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_opencl.cpp:1051
pi_result piextEventGetNativeHandle(pi_event Event, pi_native_handle *NativeHandle)
Gets the native handle of a PI event object.
Definition: pi_opencl.cpp:619
pi_result piProgramRelease(pi_program Program)
Definition: pi_opencl.cpp:309
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_opencl.cpp:242
pi_result piextMemImageFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free memory for bindless images.
Definition: pi_opencl.cpp:397
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_opencl.cpp:676
pi_result piKernelSetArg(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Definition: pi_opencl.cpp:331
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_opencl.cpp:90
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_opencl.cpp:230
pi_result piSamplerRelease(pi_sampler Sampler)
Definition: pi_opencl.cpp:657
pi_result piDeviceRelease(pi_device Device)
Definition: pi_opencl.cpp:71
pi_result piextMemUnsampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless unsampled image handles.
Definition: pi_opencl.cpp:421
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_opencl.cpp:782
pi_result piextUSMFree(pi_context Context, void *Ptr)
Indicates that the allocated USM memory is no longer needed on the runtime side.
Definition: pi_opencl.cpp:883
pi_result piQueueFlush(pi_queue Queue)
Definition: pi_opencl.cpp:180
pi_result piMemRetain(pi_mem Mem)
Definition: pi_opencl.cpp:213
pi_result piContextGetInfo(pi_context Context, pi_context_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:119
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_opencl.cpp:734
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_opencl.cpp:1018
pi_result piSamplerGetInfo(pi_sampler Sampler, pi_sampler_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:646
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_opencl.cpp:1025
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_opencl.cpp:900
pi_result piextQueueCreate(pi_context Context, pi_device Device, pi_queue_properties *Properties, pi_queue *Queue)
Definition: pi_opencl.cpp:160
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_opencl.cpp:1116
pi_result piextMemImportOpaqueFD(pi_context Context, pi_device Device, size_t Size, int FileDescriptor, pi_interop_mem_handle *RetHandle)
[DEPRECATED] This function is deprecated in favor of piextImportExternalMemory
Definition: pi_opencl.cpp:442
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_opencl.cpp:747
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_opencl.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_opencl.cpp:1222
pi_result piEventCreate(pi_context Context, pi_event *RetEvent)
Create PI event object in a signalled/completed state.
Definition: pi_opencl.cpp:578
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_opencl.cpp:1063
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_opencl.cpp:1082
pi_result piTearDown(void *PluginParameter)
API to notify that the plugin should clean up its resources.
Definition: pi_opencl.cpp:1231
pi_result piextMemUnsampledImageCreate(pi_context Context, pi_device Device, pi_image_mem_handle ImgMem, pi_image_format *ImageFormat, pi_image_desc *ImageDesc, pi_image_handle *RetHandle)
API to create bindless image handles.
Definition: pi_opencl.cpp:363
pi_result piextKernelGetNativeHandle(pi_kernel Kernel, pi_native_handle *NativeHandle)
Gets the native handle of a PI kernel object.
Definition: pi_opencl.cpp:566
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_opencl.cpp:947
pi_result piSamplerRetain(pi_sampler Sampler)
Definition: pi_opencl.cpp:653
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_opencl.cpp:408
pi_result piEventRelease(pi_event Event)
Definition: pi_opencl.cpp:615
pi_result piKernelRelease(pi_kernel Kernel)
Definition: pi_opencl.cpp:532
pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:589
pi_result piMemGetInfo(pi_mem Mem, pi_mem_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:207
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_image_handle *RetHandle)
API to create sampled bindless image handles.
Definition: pi_opencl.cpp:372
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_opencl.cpp:758
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_opencl.cpp:700
pi_result piKernelGetInfo(pi_kernel Kernel, pi_kernel_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:348
pi_result piextUSMImport(const void *HostPtr, size_t Size, pi_context Context)
Import host system memory into USM.
Definition: pi_opencl.cpp:967
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_opencl.cpp:926
pi_result piPluginInit(pi_plugin *PluginInit)
Definition: pi_opencl.cpp:1235
pi_result piPlatformGetInfo(pi_platform Platform, pi_platform_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:32
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_opencl.cpp:391
pi_result piextMemMipmapFree(pi_context Context, pi_device Device, pi_image_mem_handle MemoryHandle)
API to free mipmap memory for bindless images.
Definition: pi_opencl.cpp:402
pi_result piextSignalExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, bool HasSignalValue, pi_uint64 SignalValue, 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_opencl.cpp:501
pi_result piextCommandBufferRetainCommand(pi_ext_command_buffer_command Command)
API to increment the reference count of a command-buffer command.
Definition: pi_opencl.cpp:1193
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_opencl.cpp:858
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_opencl.cpp:711
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_opencl.cpp:834
pi_result piextUSMEnqueueMemAdvise(pi_queue Queue, const void *Ptr, size_t Length, pi_mem_advice Advice, pi_event *OutEvent)
USM Memadvise API.
Definition: pi_opencl.cpp:919
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_opencl.cpp:876
pi_result piProgramRetain(pi_program Program)
Definition: pi_opencl.cpp:305
pi_result piQueueGetInfo(pi_queue Queue, pi_queue_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:165
pi_result piQueueCreate(pi_context Context, pi_device Device, pi_queue_properties Flags, pi_queue *Queue)
Definition: pi_opencl.cpp:154
pi_result piextGetGlobalVariablePointer(pi_device Device, pi_program Program, const char *GlobalVariableName, size_t *GlobalVariableSize, void **GlobalVariablePointerRet)
Definition: pi_opencl.cpp:841
const char SupportedVersion[]
Definition: pi_opencl.cpp:25
pi_result piContextRelease(pi_context Context)
Definition: pi_opencl.cpp:150
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_opencl.cpp:455
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_opencl.cpp:724
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_opencl.cpp:807
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_opencl.cpp:1186
pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:582
pi_result piProgramGetInfo(pi_program Program, pi_program_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:260
pi_result piextImportExternalSemaphoreOpaqueFD(pi_context Context, pi_device Device, int FileDescriptor, pi_interop_semaphore_handle *RetHandle)
[DEPRECATED] This function is deprecated in favor of piextImportExternalSemaphore
Definition: pi_opencl.cpp:472
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_opencl.cpp:937
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_opencl.cpp:1125
pi_result piextMemReleaseInterop(pi_context Context, pi_device Device, pi_interop_mem_handle ExtMem)
API to destroy interop memory.
Definition: pi_opencl.cpp:464
pi_result piextUSMRelease(const void *HostPtr, pi_context Context)
Release host system memory from USM.
Definition: pi_opencl.cpp:971
pi_result piEventsWait(pi_uint32 NumEvents, const pi_event *EventList)
Definition: pi_opencl.cpp:596
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_opencl.cpp:892
pi_result piextPlatformGetNativeHandle(pi_platform Platform, pi_native_handle *NativeHandle)
Gets the native handle of a PI platform object.
Definition: pi_opencl.cpp:39
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_opencl.cpp:687
pi_result piMemBufferPartition(pi_mem Buffer, pi_mem_flags Flags, pi_buffer_create_type BufferCreateType, void *BufferCreateInfo, pi_mem *RetMem)
Definition: pi_opencl.cpp:827
pi_result piextDestroyExternalSemaphore(pi_context Context, pi_device Device, pi_interop_semaphore_handle SemHandle)
API to destroy the external semaphore handle.
Definition: pi_opencl.cpp:487
pi_result piPluginGetLastError(char **message)
API to get Plugin specific warning and error messages.
Definition: pi_opencl.cpp:49
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_opencl.cpp:1094
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_opencl.cpp:794
pi_result piextContextGetNativeHandle(pi_context Context, pi_native_handle *NativeHandle)
Gets the native handle of a PI context object.
Definition: pi_opencl.cpp:132
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_opencl.cpp:217
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_opencl.cpp:959
pi_result piEnqueueTimestampRecordingExp(pi_queue Queue, pi_bool Blocking, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event)
Definition: pi_opencl.cpp:632
pi_result piEnqueueEventsWaitWithBarrier(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_opencl.cpp:668
pi_result piextMemSampledImageHandleDestroy(pi_context Context, pi_device Device, pi_image_handle Handle)
API to destroy bindless sampled image handles.
Definition: pi_opencl.cpp:427
pi_result piQueueFinish(pi_queue Queue)
Definition: pi_opencl.cpp:178
pi_result piextWaitExternalSemaphore(pi_queue Queue, pi_interop_semaphore_handle SemHandle, bool HasWaitValue, pi_uint64 WaitValue, 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_opencl.cpp:492
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_opencl.cpp:252
pi_result piSamplerCreate(pi_context Context, const pi_sampler_properties *SamplerProperties, pi_sampler *RetSampler)
Definition: pi_opencl.cpp:640
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_opencl.cpp:1207
pi_result piPlatformsGet(pi_uint32 NumEntries, pi_platform *Platforms, pi_uint32 *NumPlatforms)
Definition: pi_opencl.cpp:27
pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType, pi_uint32 NumEntries, pi_device *Devices, pi_uint32 *NumDevices)
Definition: pi_opencl.cpp:60
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_opencl.cpp:816
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_opencl.cpp:1007
pi_result piextKernelSetArgMemObj(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_mem_obj_property *ArgProperties, const pi_mem *ArgValue)
Definition: pi_opencl.cpp:336
pi_result piDevicePartition(pi_device Device, const pi_device_partition_property *Properties, pi_uint32 NumDevices, pi_device *OutDevices, pi_uint32 *OutNumDevices)
Definition: pi_opencl.cpp:82
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_opencl.cpp:984
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_opencl.cpp:109
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_opencl.cpp:850
pi_result piextKernelSetArgSampler(pi_kernel Kernel, pi_uint32 ArgIndex, const pi_sampler *ArgValue)
Definition: pi_opencl.cpp:343
pi_result piextMemGetNativeHandle(pi_mem Mem, pi_device Dev, pi_native_handle *NativeHandle)
Gets the native handle of a PI mem object.
Definition: pi_opencl.cpp:225
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_opencl.cpp:996
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_opencl.cpp:910
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_opencl.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_opencl.cpp:1148
pi_result piextCommandBufferRetain(pi_ext_command_buffer CommandBuffer)
API to increment the reference count of the command-buffer.
Definition: pi_opencl.cpp:1039
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_opencl.cpp:288
pi_result piextImportExternalMemory(pi_context Context, pi_device Device, pi_external_mem_descriptor *MemDesc, pi_interop_mem_handle *RetHandle)
API to import external memory.
Definition: pi_opencl.cpp:449
pi_result piKernelRetain(pi_kernel Kernel)
Definition: pi_opencl.cpp:528
pi_result piEventRetain(pi_event Event)
Definition: pi_opencl.cpp:613
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_opencl.cpp:137
pi_result piextCommandBufferRelease(pi_ext_command_buffer CommandBuffer)
API to decrement the reference count of the command-buffer.
Definition: pi_opencl.cpp:1043
pi_result piPluginGetBackendOption(pi_platform platform, const char *frontend_option, const char **backend_option)
API to get backend specific option.
Definition: pi_opencl.cpp:53
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_opencl.cpp:1138
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_opencl.cpp:267
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_opencl.cpp:318
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_opencl.cpp:1168
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_opencl.cpp:624
pi_result piMemImageGetInfo(pi_mem Image, pi_image_info ParamName, size_t ParamValueSize, void *ParamValue, size_t *ParamValueSizeRet)
Definition: pi_opencl.cpp:775
pi_result piEnqueueEventsWait(pi_queue Queue, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_opencl.cpp:661
pi_result piextImportExternalSemaphore(pi_context Context, pi_device Device, pi_external_semaphore_descriptor *SemDesc, pi_interop_semaphore_handle *RetHandle)
API to import an external semaphore.
Definition: pi_opencl.cpp:480
pi_result piDeviceRetain(pi_device Device)
Definition: pi_opencl.cpp:67
pi_result piextQueueGetNativeHandle(pi_queue Queue, pi_native_handle *NativeHandle, int32_t *NativeHandleDesc)
Gets the native handle of a PI queue object.
Definition: pi_opencl.cpp:182
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_opencl.cpp:866
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_opencl.cpp:1032
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_opencl.cpp:1103
pi_result piContextRetain(pi_context Context)
Definition: pi_opencl.cpp:146
pi_result piextKernelSetArgPointer(pi_kernel Kernel, pi_uint32 ArgIndex, size_t ArgSize, const void *ArgValue)
Sets up pointer arguments for CL kernels.
Definition: pi_opencl.cpp:887
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_opencl.cpp:571
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_opencl.cpp:518
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_opencl.cpp:382
pi_result piEnqueueMemUnmap(pi_queue Queue, pi_mem Mem, void *MappedPtr, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *OutEvent)
Definition: pi_opencl.cpp:768
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_opencl.cpp:355
pi_result piProgramCreate(pi_context Context, const void *ILBytes, size_t Length, pi_program *Program)
Definition: pi_opencl.cpp:237
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_opencl.cpp:557
pi_result piextProgramGetNativeHandle(pi_program Program, pi_native_handle *NativeHandle)
Gets the native handle of a PI program object.
Definition: pi_opencl.cpp:313
Declarations for vOpenCL Plugin.
#define _PI_OPENCL_PLUGIN_VERSION_STRING
Definition: pi_opencl.hpp:31
char PluginVersion[20]
Definition: pi.h:3077
char PiVersion[20]
Definition: pi.h:3075
This struct is a record of the device binary information.
Definition: pi.h:1067