Implement partial support for UR_QUEUE_INFO_EMPTY (#18601)

By storing last event in the queue.

This only works for in-order queues and when last enqueued operation had
signalEvent set. Otherwise UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION is
returned.

---------

Co-authored-by: aarongreig <aaron.greig@codeplay.com>

Author: igchor

source/adapters/opencl/event.hpp

@@ -69,16 +69,20 @@ inline cl_event *ifUrEvent(ur_event_handle_t *ReturnedEvent, cl_event &Event) {
 inline ur_result_t createUREvent(cl_event Event, ur_context_handle_t Context,
                                  ur_queue_handle_t Queue,
                                  ur_event_handle_t *ReturnedEvent) {
+  assert(Queue);
   if (ReturnedEvent) {
     try {
       auto UREvent =
           std::make_unique<ur_event_handle_t_>(Event, Context, Queue);
       *ReturnedEvent = UREvent.release();
+      UR_RETURN_ON_FAILURE(Queue->storeLastEvent(*ReturnedEvent));
     } catch (std::bad_alloc &) {
       return UR_RESULT_ERROR_OUT_OF_RESOURCES;
     } catch (...) {
       return UR_RESULT_ERROR_UNKNOWN;
     }
+  } else {
+    UR_RETURN_ON_FAILURE(Queue->storeLastEvent(nullptr));
   }
   return UR_RESULT_SUCCESS;
 }

source/adapters/opencl/queue.cpp

@@ -94,8 +94,8 @@ ur_result_t ur_queue_handle_t_::makeWithNative(native_type NativeQueue,
       UR_RETURN_ON_FAILURE(urDeviceCreateWithNativeHandle(
           hNativeHandle, nullptr, nullptr, &Device));
     }
-    auto URQueue =
-        std::make_unique<ur_queue_handle_t_>(NativeQueue, Context, Device);
+    auto URQueue = std::make_unique<ur_queue_handle_t_>(NativeQueue, Context,
+                                                        Device, false);
     Queue = URQueue.release();
   } catch (std::bad_alloc &) {
     return UR_RESULT_ERROR_OUT_OF_RESOURCES;
@@ -125,14 +125,16 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreate(
 
   cl_int RetErr = CL_INVALID_OPERATION;
 
+  bool InOrder = !(CLProperties & SupportByOpenCL &
+                   CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE);
   if (Version < oclv::V2_0) {
     cl_command_queue Queue =
         clCreateCommandQueue(hContext->CLContext, hDevice->CLDevice,
                              CLProperties & SupportByOpenCL, &RetErr);
     CL_RETURN_ON_FAILURE(RetErr);
     try {
-      auto URQueue =
-          std::make_unique<ur_queue_handle_t_>(Queue, hContext, hDevice);
+      auto URQueue = std::make_unique<ur_queue_handle_t_>(Queue, hContext,
+                                                          hDevice, InOrder);
       *phQueue = URQueue.release();
     } catch (std::bad_alloc &) {
       return UR_RESULT_ERROR_OUT_OF_RESOURCES;
@@ -151,7 +153,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreate(
   CL_RETURN_ON_FAILURE(RetErr);
   try {
     auto URQueue =
-        std::make_unique<ur_queue_handle_t_>(Queue, hContext, hDevice);
+        std::make_unique<ur_queue_handle_t_>(Queue, hContext, hDevice, InOrder);
     *phQueue = URQueue.release();
   } catch (std::bad_alloc &) {
     return UR_RESULT_ERROR_OUT_OF_RESOURCES;
@@ -166,12 +168,23 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueGetInfo(ur_queue_handle_t hQueue,
                                                    size_t propSize,
                                                    void *pPropValue,
                                                    size_t *pPropSizeRet) {
-  if (propName == UR_QUEUE_INFO_EMPTY) {
-    // OpenCL doesn't provide API to check the status of the queue.
-    return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
-  }
   cl_command_queue_info CLCommandQueueInfo = mapURQueueInfoToCL(propName);
   UrReturnHelper ReturnValue(propSize, pPropValue, pPropSizeRet);
+  if (propName == UR_QUEUE_INFO_EMPTY) {
+    if (!hQueue->LastEvent) {
+      // OpenCL doesn't provide API to check the status of the queue.
+      return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+    } else {
+      ur_event_status_t Status;
+      UR_RETURN_ON_FAILURE(urEventGetInfo(
+          hQueue->LastEvent, UR_EVENT_INFO_COMMAND_EXECUTION_STATUS,
+          sizeof(ur_event_status_t), (void *)&Status, nullptr));
+      if (Status == UR_EVENT_STATUS_COMPLETE) {
+        return ReturnValue(true);
+      }
+      return ReturnValue(false);
+    }
+  }
   switch (propName) {
   case UR_QUEUE_INFO_CONTEXT: {
     return ReturnValue(hQueue->Context);

source/adapters/opencl/queue.hpp

@@ -24,10 +24,14 @@ struct ur_queue_handle_t_ : ur::opencl::handle_base {
   std::optional<ur_queue_handle_t> DeviceDefault = std::nullopt;
   std::atomic<uint32_t> RefCount = 0;
   bool IsNativeHandleOwned = true;
+  // Used to implement UR_QUEUE_INFO_EMPTY query
+  bool IsInOrder;
+  ur_event_handle_t LastEvent = nullptr;
 
   ur_queue_handle_t_(native_type Queue, ur_context_handle_t Ctx,
-                     ur_device_handle_t Dev)
-      : handle_base(), CLQueue(Queue), Context(Ctx), Device(Dev) {
+                     ur_device_handle_t Dev, bool InOrder)
+      : handle_base(), CLQueue(Queue), Context(Ctx), Device(Dev),
+        IsInOrder(InOrder) {
     RefCount = 1;
     urDeviceRetain(Device);
     urContextRetain(Context);
@@ -54,4 +58,20 @@ struct ur_queue_handle_t_ : ur::opencl::handle_base {
   uint32_t decrementReferenceCount() noexcept { return --RefCount; }
 
   uint32_t getReferenceCount() const noexcept { return RefCount; }
+
+  // Stores last event for in-order queues. Has no effect if queue is Out Of
+  // Order. The last event is used to implement UR_QUEUE_INFO_EMPTY query.
+  ur_result_t storeLastEvent(ur_event_handle_t Event) {
+    if (!IsInOrder) {
+      return UR_RESULT_SUCCESS;
+    }
+    if (LastEvent) {
+      UR_RETURN_ON_FAILURE(urEventRelease(LastEvent));
+    }
+    LastEvent = Event;
+    if (LastEvent) {
+      UR_RETURN_ON_FAILURE(urEventRetain(LastEvent));
+    }
+    return UR_RESULT_SUCCESS;
+  }
 };