[SYCL][PI] Splitting the converter function

Signed-off-by: Steffen Larsen <[email protected]>

Author: Steffen Larsen

sycl/include/CL/sycl/detail/buffer_impl.hpp

@@ -44,8 +44,6 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
   using typename BaseT::MemObjType;
 
 public:
-  static constexpr pi_handle_type PIHandleType = PI_NATIVE_HANDLE_MEM;
-
   buffer_impl(size_t SizeInBytes, size_t RequiredAlign,
               const property_list &Props,
               unique_ptr_class<SYCLMemObjAllocator> Allocator)

sycl/include/CL/sycl/detail/pi.def

@@ -18,26 +18,31 @@
 _PI_API(piPlatformsGet)
 _PI_API(piPlatformGetInfo)
 // Device
-_PI_API(piextDeviceConvert)
 _PI_API(piDevicesGet)
 _PI_API(piDeviceGetInfo)
 _PI_API(piDevicePartition)
 _PI_API(piDeviceRetain)
 _PI_API(piDeviceRelease)
 _PI_API(piextDeviceSelectBinary)
 _PI_API(piextGetDeviceFunctionPointer)
+_PI_API(piextDeviceGetNativeHandle)
+_PI_API(piextDeviceCreateWithNativeHandle)
 // Context
 _PI_API(piContextCreate)
 _PI_API(piContextGetInfo)
 _PI_API(piContextRetain)
 _PI_API(piContextRelease)
 _PI_API(piextContextSetExtendedDeleter)
+_PI_API(piextContextGetNativeHandle)
+_PI_API(piextContextCreateWithNativeHandle)
 // Queue
 _PI_API(piQueueCreate)
 _PI_API(piQueueGetInfo)
 _PI_API(piQueueFinish)
 _PI_API(piQueueRetain)
 _PI_API(piQueueRelease)
+_PI_API(piextQueueGetNativeHandle)
+_PI_API(piextQueueCreateWithNativeHandle)
 // Memory
 _PI_API(piMemBufferCreate)
 _PI_API(piMemImageCreate)
@@ -46,8 +51,9 @@ _PI_API(piMemImageGetInfo)
 _PI_API(piMemRetain)
 _PI_API(piMemRelease)
 _PI_API(piMemBufferPartition)
+_PI_API(piextMemGetNativeHandle)
+_PI_API(piextMemCreateWithNativeHandle)
 // Program
-_PI_API(piextProgramConvert)
 _PI_API(piProgramCreate)
 _PI_API(piclProgramCreateWithSource)
 _PI_API(piclProgramCreateWithBinary)
@@ -59,6 +65,8 @@ _PI_API(piProgramGetBuildInfo)
 _PI_API(piProgramRetain)
 _PI_API(piProgramRelease)
 _PI_API(piextProgramSetSpecializationConstant)
+_PI_API(piextProgramGetNativeHandle)
+_PI_API(piextProgramCreateWithNativeHandle)
 // Kernel
 _PI_API(piKernelCreate)
 _PI_API(piKernelSetArg)
@@ -78,6 +86,8 @@ _PI_API(piEventSetCallback)
 _PI_API(piEventSetStatus)
 _PI_API(piEventRetain)
 _PI_API(piEventRelease)
+_PI_API(piextEventGetNativeHandle)
+_PI_API(piextEventCreateWithNativeHandle)
 // Sampler
 _PI_API(piSamplerCreate)
 _PI_API(piSamplerGetInfo)
@@ -113,7 +123,4 @@ _PI_API(piextUSMGetMemAllocInfo)
 
 _PI_API(piextKernelSetArgMemObj)
 
-// Interop
-_PI_API(piGetNativeHandle)
-
 #undef _PI_API

sycl/include/CL/sycl/detail/pi.h

@@ -61,15 +61,6 @@ using pi_bool = pi_uint32;
 using pi_bitfield = pi_uint64;
 using pi_native_handle = uintptr_t;
 
-enum pi_handle_type {
-  PI_NATIVE_HANDLE_CONTEXT,
-  PI_NATIVE_HANDLE_DEVICE,
-  PI_NATIVE_HANDLE_QUEUE,
-  PI_NATIVE_HANDLE_EVENT,
-  PI_NATIVE_HANDLE_MEM,
-  PI_NATIVE_HANDLE_PLATFORM
-};
-
 //
 // NOTE: prefer to map 1:1 to OpenCL so that no translation is needed
 // for PI <-> OpenCL ways. The PI <-> to other BE translation is almost
@@ -772,19 +763,6 @@ pi_result piPlatformGetInfo(pi_platform platform, pi_platform_info param_name,
                             size_t param_value_size, void *param_value,
                             size_t *param_value_size_ret);
 
-//
-// Device
-//
-///
-/// Create PI device from the given raw device handle (if the "device"
-/// points to null), or, vice versa, extract the raw device handle into
-/// the "handle" (if it was pointing to a null) from the given PI device.
-/// NOTE: The instance of the PI device created is retained.
-///
-pi_result piextDeviceConvert(
-    pi_device *device, ///< [in,out] the pointer to PI device
-    void **handle);    ///< [in,out] the pointer to the raw device handle
-
 pi_result piDevicesGet(pi_platform platform, pi_device_type device_type,
                        pi_uint32 num_entries, pi_device *devices,
                        pi_uint32 *num_devices);
@@ -802,6 +780,23 @@ pi_result piDevicePartition(pi_device device,
                             pi_uint32 num_devices, pi_device *out_devices,
                             pi_uint32 *out_num_devices);
 
+/// Gets the native handle of a PI device object.
+///
+/// \param device is the PI device to get the native handle of.
+/// \param nativeHandle is the native handle of device.
+pi_result piextDeviceGetNativeHandle(pi_device device,
+                                     pi_native_handle *nativeHandle);
+
+/// Creates PI device object from a native handle.
+/// NOTE: If the created PI object shares reference count with the native object
+///       the reference count is increased by one. Otherwise the newly created
+///       PI object has a reference count of 1.
+///
+/// \param nativeHandle is the native handle to create PI device from.
+/// \param device is the PI device created from the native handle.
+pi_result piextDeviceCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                            pi_device *device);
+
 /// Selects the most appropriate device binary based on runtime information
 /// and the IR characteristics.
 ///
@@ -845,6 +840,23 @@ pi_result piextContextSetExtendedDeleter(pi_context context,
                                          pi_context_extended_deleter func,
                                          void *user_data);
 
+/// Gets the native handle of a PI context object.
+///
+/// \param context is the PI context to get the native handle of.
+/// \param nativeHandle is the native handle of context.
+pi_result piextContextGetNativeHandle(pi_context context,
+                                      pi_native_handle *nativeHandle);
+
+/// Creates PI context object from a native handle.
+/// NOTE: If the created PI object shares reference count with the native object
+///       the reference count is increased by one. Otherwise the newly created
+///       PI object has a reference count of 1.
+///
+/// \param nativeHandle is the native handle to create PI context from.
+/// \param context is the PI context created from the native handle.
+pi_result piextContextCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context *context);
+
 //
 // Queue
 //
@@ -861,6 +873,23 @@ pi_result piQueueRelease(pi_queue command_queue);
 
 pi_result piQueueFinish(pi_queue command_queue);
 
+/// Gets the native handle of a PI queue object.
+///
+/// \param queue is the PI queue to get the native handle of.
+/// \param nativeHandle is the native handle of queue.
+pi_result piextQueueGetNativeHandle(pi_queue queue,
+                                    pi_native_handle *nativeHandle);
+
+/// Creates PI queue object from a native handle.
+/// NOTE: If the created PI object shares reference count with the native object
+///       the reference count is increased by one. Otherwise the newly created
+///       PI object has a reference count of 1.
+///
+/// \param nativeHandle is the native handle to create PI queue from.
+/// \param queue is the PI queue created from the native handle.
+pi_result piextQueueCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                           pi_queue *queue);
+
 //
 // Memory
 //
@@ -888,19 +917,26 @@ pi_result piMemRelease(pi_mem mem);
 pi_result piMemBufferPartition(pi_mem buffer, pi_mem_flags flags,
                                pi_buffer_create_type buffer_create_type,
                                void *buffer_create_info, pi_mem *ret_mem);
+
+/// Gets the native handle of a PI mem object.
+///
+/// \param mem is the PI mem to get the native handle of.
+/// \param nativeHandle is the native handle of mem.
+pi_result piextMemGetNativeHandle(pi_mem mem, pi_native_handle *nativeHandle);
+
+/// Creates PI mem object from a native handle.
+/// NOTE: If the created PI object shares reference count with the native object
+///       the reference count is increased by one. Otherwise the newly created
+///       PI object has a reference count of 1.
+///
+/// \param nativeHandle is the native handle to create PI mem from.
+/// \param mem is the PI mem created from the native handle.
+pi_result piextMemCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                         pi_mem *mem);
+
 //
 // Program
 //
-///
-/// Create PI program from the given raw program handle (if the "program"
-/// points to null), or, vice versa, extract the raw program handle into
-/// the "handle" (if it was pointing to a null) from the given PI program.
-/// NOTE: The instance of the PI program created is retained.
-///
-pi_result piextProgramConvert(
-    pi_context context,  ///< [in] the PI context of the program
-    pi_program *program, ///< [in,out] the pointer to PI program
-    void **handle);      ///< [in,out] the pointer to the raw program handle
 
 pi_result piProgramCreate(pi_context context, const void *il, size_t length,
                           pi_program *res_program);
@@ -960,6 +996,23 @@ pi_result piextProgramSetSpecializationConstant(pi_program prog,
                                                 size_t spec_size,
                                                 const void *spec_value);
 
+/// Gets the native handle of a PI program object.
+///
+/// \param program is the PI program to get the native handle of.
+/// \param nativeHandle is the native handle of program.
+pi_result piextProgramGetNativeHandle(pi_program program,
+                                      pi_native_handle *nativeHandle);
+
+/// Creates PI program object from a native handle.
+/// NOTE: If the created PI object shares reference count with the native object
+///       the reference count is increased by one. Otherwise the newly created
+///       PI object has a reference count of 1.
+///
+/// \param nativeHandle is the native handle to create PI program from.
+/// \param program is the PI program created from the native handle.
+pi_result piextProgramCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_program *program);
+
 //
 // Kernel
 //
@@ -1051,6 +1104,23 @@ pi_result piEventRetain(pi_event event);
 
 pi_result piEventRelease(pi_event event);
 
+/// Gets the native handle of a PI event object.
+///
+/// \param event is the PI event to get the native handle of.
+/// \param nativeHandle is the native handle of event.
+pi_result piextEventGetNativeHandle(pi_event event,
+                                    pi_native_handle *nativeHandle);
+
+/// Creates PI event object from a native handle.
+/// NOTE: If the created PI object shares reference count with the native object
+///       the reference count is increased by one. Otherwise the newly created
+///       PI object has a reference count of 1.
+///
+/// \param nativeHandle is the native handle to create PI event from.
+/// \param event is the PI event created from the native handle.
+pi_result piextEventCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                           pi_event *event);
+
 //
 // Sampler
 //
@@ -1356,14 +1426,6 @@ pi_result piextUSMGetMemAllocInfo(pi_context context, const void *ptr,
                                   size_t param_value_size, void *param_value,
                                   size_t *param_value_size_ret);
 
-/// Gets the native handle of a SYCL object.
-///
-/// \param handleType is a representation of the native handle.
-/// \param piObject is the PI object to get the native handle of.
-/// \param nativeHandle is the native handle of piObject.
-pi_result piGetNativeHandle(pi_handle_type handleType, void *piObject,
-                            pi_native_handle *nativeHandle);
-
 struct _pi_plugin {
   // PI version supported by host passed to the plugin. The Plugin
   // checks and writes the appropriate Function Pointers in

sycl/include/CL/sycl/detail/pi.hpp

@@ -311,12 +311,12 @@ template <class To, class From> inline To cast(From value) {
 
 // These conversions should use PI interop API.
 template <> inline pi::PiProgram cast(cl_program interop) {
-  RT::assertion(false, "pi::cast -> use piextProgramConvert");
+  RT::assertion(false, "pi::cast -> use piextProgramFromNative");
   return {};
 }
 
 template <> inline pi::PiDevice cast(cl_device_id interop) {
-  RT::assertion(false, "pi::cast -> use piextDeviceConvert");
+  RT::assertion(false, "pi::cast -> use piextDeviceFromNative");
   return {};
 }
 } // namespace pi