[SYCL][HIP] Implemented supported make_* interop functions. (intel#10526)

This PR adds missing functions in the hip backend to allow for
interoperability in programs that create sycl objects from native hip
objects. The new function implementations are:

- `make_device`
- `make_queue`
- `make_event`

Note that it would really make sense for
intel#10491 to be merged first because this
PR makes the same code change in pi2ur, for a fix that is attributed to
intel#10491.

---------

Signed-off-by: Jack Kirk <jack.kirk@codeplay.com>

Author: JackAKirk

event.cpp

@@ -15,10 +15,10 @@ ur_event_handle_t_::ur_event_handle_t_(ur_command_t Type,
                                        ur_context_handle_t Context,
                                        ur_queue_handle_t Queue,
                                        hipStream_t Stream, uint32_t StreamToken)
-    : CommandType{Type}, RefCount{1}, HasBeenWaitedOn{false}, IsRecorded{false},
-      IsStarted{false}, StreamToken{StreamToken}, EvEnd{nullptr},
-      EvStart{nullptr}, EvQueued{nullptr}, Queue{Queue}, Stream{Stream},
-      Context{Context} {
+    : CommandType{Type}, RefCount{1}, HasOwnership{true},
+      HasBeenWaitedOn{false}, IsRecorded{false}, IsStarted{false},
+      StreamToken{StreamToken}, EvEnd{nullptr}, EvStart{nullptr},
+      EvQueued{nullptr}, Queue{Queue}, Stream{Stream}, Context{Context} {
 
   bool ProfilingEnabled = Queue->URFlags & UR_QUEUE_FLAG_PROFILING_ENABLE;
 
@@ -36,6 +36,15 @@ ur_event_handle_t_::ur_event_handle_t_(ur_command_t Type,
   urContextRetain(Context);
 }
 
+ur_event_handle_t_::ur_event_handle_t_(ur_context_handle_t Context,
+                                       hipEvent_t EventNative)
+    : CommandType{UR_COMMAND_EVENTS_WAIT}, RefCount{1}, HasOwnership{false},
+      HasBeenWaitedOn{false}, IsRecorded{false}, IsStarted{false},
+      StreamToken{std::numeric_limits<uint32_t>::max()}, EvEnd{EventNative},
+      EvStart{nullptr}, EvQueued{nullptr}, Queue{nullptr}, Context{Context} {
+  urContextRetain(Context);
+}
+
 ur_event_handle_t_::~ur_event_handle_t_() {
   if (Queue != nullptr) {
     urQueueRelease(Queue);
@@ -160,6 +169,9 @@ ur_result_t ur_event_handle_t_::wait() {
 }
 
 ur_result_t ur_event_handle_t_::release() {
+  if (!backendHasOwnership())
+    return UR_RESULT_SUCCESS;
+
   assert(Queue != nullptr);
   UR_CHECK_ERROR(hipEventDestroy(EvEnd));
 
@@ -302,15 +314,18 @@ UR_APIEXPORT ur_result_t UR_APICALL urEventGetNativeHandle(
 }
 
 /// Created a UR event object from a HIP event handle.
-/// TODO: Implement this.
-/// NOTE: The created UR object takes ownership of the native handle.
+/// NOTE: The created UR object doesn't take ownership of the native handle.
 ///
 /// \param[in] hNativeEvent The native handle to create UR event object from.
 /// \param[out] phEvent Set to the UR event object created from native handle.
-///
-/// \return UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 UR_APIEXPORT ur_result_t UR_APICALL urEventCreateWithNativeHandle(
-    ur_native_handle_t, ur_context_handle_t,
-    const ur_event_native_properties_t *, ur_event_handle_t *) {
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    ur_native_handle_t hNativeEvent, ur_context_handle_t hContext,
+    const ur_event_native_properties_t *pProperties,
+    ur_event_handle_t *phEvent) {
+  std::ignore = pProperties;
+
+  *phEvent = ur_event_handle_t_::makeWithNative(
+      hContext, reinterpret_cast<hipEvent_t>(hNativeEvent));
+
+  return UR_RESULT_SUCCESS;
 }

event.hpp

@@ -60,6 +60,8 @@ struct ur_event_handle_t_ {
 
   uint32_t getEventId() const noexcept { return EventId; }
 
+  bool backendHasOwnership() const noexcept { return HasOwnership; }
+
   // Returns the counter time when the associated command(s) were enqueued
   uint64_t getQueuedTime() const;
 
@@ -77,6 +79,11 @@ struct ur_event_handle_t_ {
                                   StreamToken);
   }
 
+  static ur_event_handle_t makeWithNative(ur_context_handle_t context,
+                                          hipEvent_t eventNative) {
+    return new ur_event_handle_t_(context, eventNative);
+  }
+
   ur_result_t release();
 
   ~ur_event_handle_t_();
@@ -88,10 +95,16 @@ struct ur_event_handle_t_ {
                      ur_queue_handle_t Queue, hipStream_t Stream,
                      uint32_t StreamToken);
 
+  // This constructor is private to force programmers to use the
+  // makeWithNative for event interop
+  ur_event_handle_t_(ur_context_handle_t Context, hipEvent_t EventNative);
+
   ur_command_t CommandType; // The type of command associated with event.
 
   std::atomic_uint32_t RefCount; // Event reference count.
 
+  bool HasOwnership; // Signifies if event owns the native type.
+
   bool HasBeenWaitedOn; // Signifies whether the event has been waited
                         // on through a call to wait(), which implies
                         // that it has completed.

queue.cpp

@@ -193,6 +193,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueRelease(ur_queue_handle_t hQueue) {
   try {
     std::unique_ptr<ur_queue_handle_t_> QueueImpl(hQueue);
 
+    if (!hQueue->backendHasOwnership())
+      return UR_RESULT_SUCCESS;
+
     ScopedContext Active(hQueue->getContext()->getDevice());
 
     hQueue->forEachStream([](hipStream_t S) {
@@ -252,19 +255,44 @@ urQueueGetNativeHandle(ur_queue_handle_t hQueue, ur_queue_native_desc_t *,
 }
 
 /// Created a UR queue object from a HIP queue handle.
-/// TODO: Implement this.
-/// NOTE: The created UR object takes ownership of the native handle.
+/// NOTE: The created UR object doesn't takes ownership of the native handle.
 ///
 /// \param[in] hNativeQueue The native handle to create UR queue object from.
 /// \param[in] hContext is the UR context of the queue.
 /// \param[out] phQueue Set to the UR queue object created from native handle.
-/// \param pProperties->isNativeHandleOwned tells if SYCL RT should assume the
-/// ownership of
-///        the native handle, if it can.
-///
-/// \return UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
-    ur_native_handle_t, ur_context_handle_t, ur_device_handle_t,
-    const ur_queue_native_properties_t *, ur_queue_handle_t *) {
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    ur_native_handle_t hNativeQueue, ur_context_handle_t hContext,
+    ur_device_handle_t hDevice, const ur_queue_native_properties_t *pProperties,
+    ur_queue_handle_t *phQueue) {
+  (void)hDevice;
+
+  unsigned int HIPFlags;
+  hipStream_t HIPStream = reinterpret_cast<hipStream_t>(hNativeQueue);
+
+  auto Return = UR_CHECK_ERROR(hipStreamGetFlags(HIPStream, &HIPFlags));
+
+  ur_queue_flags_t Flags = 0;
+  if (HIPFlags == hipStreamDefault)
+    Flags = UR_QUEUE_FLAG_USE_DEFAULT_STREAM;
+  else if (HIPFlags == hipStreamNonBlocking)
+    Flags = UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
+  else
+    detail::ur::die("Unknown hip stream");
+
+  std::vector<hipStream_t> ComputeHIPStreams(1, HIPStream);
+  std::vector<hipStream_t> TransferHIPStreams(0);
+
+  // Create queue and set num_compute_streams to 1, as computeHIPStreams has
+  // valid stream
+  *phQueue =
+      new ur_queue_handle_t_{std::move(ComputeHIPStreams),
+                             std::move(TransferHIPStreams),
+                             hContext,
+                             hContext->getDevice(),
+                             HIPFlags,
+                             Flags,
+                             /*backend_owns*/ pProperties->isNativeHandleOwned};
+  (*phQueue)->NumComputeStreams = 1;
+
+  return Return;
 }

queue.hpp

@@ -49,11 +49,13 @@ struct ur_queue_handle_t_ {
   std::mutex ComputeStreamMutex;
   std::mutex TransferStreamMutex;
   std::mutex BarrierMutex;
+  bool HasOwnership;
 
   ur_queue_handle_t_(std::vector<native_type> &&ComputeStreams,
                      std::vector<native_type> &&TransferStreams,
                      ur_context_handle_t Context, ur_device_handle_t Device,
-                     unsigned int Flags, ur_queue_flags_t URFlags)
+                     unsigned int Flags, ur_queue_flags_t URFlags,
+                     bool BackendOwns = true)
       : ComputeStreams{std::move(ComputeStreams)},
         TransferStreams{std::move(TransferStreams)},
         DelayCompute(this->ComputeStreams.size(), false),
@@ -62,7 +64,7 @@ struct ur_queue_handle_t_ {
         Device{Device}, RefCount{1}, EventCount{0}, ComputeStreamIdx{0},
         TransferStreamIdx{0}, NumComputeStreams{0}, NumTransferStreams{0},
         LastSyncComputeStreams{0}, LastSyncTransferStreams{0}, Flags(Flags),
-        URFlags(URFlags) {
+        URFlags(URFlags), HasOwnership{BackendOwns} {
     urContextRetain(Context);
     urDeviceRetain(Device);
   }
@@ -235,4 +237,6 @@ struct ur_queue_handle_t_ {
   uint32_t getReferenceCount() const noexcept { return RefCount; }
 
   uint32_t getNextEventId() noexcept { return ++EventCount; }
+
+  bool backendHasOwnership() const noexcept { return HasOwnership; }
 };