Merge pull request #2391 from igchor/profiling_events_Wait

[L0 v2] fixes around eventsWait and eventsWaitWithBarrier

Author: pbalcer

source/adapters/level_zero/v2/queue_immediate_in_order.cpp

@@ -283,14 +283,46 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueEventsWait(
   return UR_RESULT_SUCCESS;
 }
 
+ur_result_t ur_queue_immediate_in_order_t::enqueueEventsWaitWithBarrierImpl(
+    uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
+    ur_event_handle_t *phEvent) {
+  TRACK_SCOPE_LATENCY(
+      "ur_queue_immediate_in_order_t::enqueueEventsWaitWithBarrier");
+
+  std::scoped_lock<ur_shared_mutex> lock(this->Mutex);
+
+  if (!numEventsInWaitList && !phEvent) {
+    // nop
+    return UR_RESULT_SUCCESS;
+  }
+
+  auto signalEvent =
+      getSignalEvent(phEvent, UR_COMMAND_EVENTS_WAIT_WITH_BARRIER);
+  auto [pWaitEvents, numWaitEvents] =
+      getWaitListView(phEventWaitList, numEventsInWaitList);
+
+  ZE2UR_CALL(zeCommandListAppendBarrier,
+             (handler.commandList.get(), signalEvent->getZeEvent(),
+              numWaitEvents, pWaitEvents));
+
+  return UR_RESULT_SUCCESS;
+}
+
 ur_result_t ur_queue_immediate_in_order_t::enqueueEventsWaitWithBarrier(
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
   // For in-order queue we don't need a real barrier, just wait for
   // requested events in potentially different queues and add a "barrier"
   // event signal because it is already guaranteed that previous commands
-  // in this queue are completed when the signal is started.
-  return enqueueEventsWait(numEventsInWaitList, phEventWaitList, phEvent);
+  // in this queue are completed when the signal is started. However, we do
+  // need to use barrier if profiling is enabled: see
+  // zeCommandListAppendWaitOnEvents
+  if ((flags & UR_QUEUE_FLAG_PROFILING_ENABLE) != 0) {
+    return enqueueEventsWaitWithBarrierImpl(numEventsInWaitList,
+                                            phEventWaitList, phEvent);
+  } else {
+    return enqueueEventsWait(numEventsInWaitList, phEventWaitList, phEvent);
+  }
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueEventsWaitWithBarrierExt(
@@ -757,8 +789,8 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueUSMPrefetch(
       getWaitListView(phEventWaitList, numEventsInWaitList);
 
   if (pWaitEvents) {
-    ZE2UR_CALL(zeCommandListAppendBarrier, (handler.commandList.get(), nullptr,
-                                            numWaitEvents, pWaitEvents));
+    ZE2UR_CALL(zeCommandListAppendWaitOnEvents,
+               (handler.commandList.get(), numWaitEvents, pWaitEvents));
   }
   // TODO: figure out how to translate "flags"
   ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
@@ -789,8 +821,8 @@ ur_queue_immediate_in_order_t::enqueueUSMAdvise(const void *pMem, size_t size,
   auto [pWaitEvents, numWaitEvents] = getWaitListView(nullptr, 0);
 
   if (pWaitEvents) {
-    ZE2UR_CALL(zeCommandListAppendBarrier, (handler.commandList.get(), nullptr,
-                                            numWaitEvents, pWaitEvents));
+    ZE2UR_CALL(zeCommandListAppendWaitOnEvents,
+               (handler.commandList.get(), numWaitEvents, pWaitEvents));
   }
 
   // TODO: figure out how to translate "flags"

source/adapters/level_zero/v2/queue_immediate_in_order.hpp

@@ -77,6 +77,11 @@ struct ur_queue_immediate_in_order_t : _ur_object, public ur_queue_handle_t_ {
       const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent,
       ur_command_t commandType);
 
+  ur_result_t
+  enqueueEventsWaitWithBarrierImpl(uint32_t numEventsInWaitList,
+                                   const ur_event_handle_t *phEventWaitList,
+                                   ur_event_handle_t *phEvent);
+
 public:
   ur_queue_immediate_in_order_t(ur_context_handle_t, ur_device_handle_t,
                                 const ur_queue_properties_t *);

test/conformance/event/urEventGetProfilingInfo.cpp

@@ -121,3 +121,51 @@ TEST_P(urEventGetProfilingInfoNegativeTest, InvalidValue) {
 }
 
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEventGetProfilingInfoNegativeTest);
+
+struct urEventGetProfilingInfoForWaitWithBarrier : uur::urProfilingQueueTest {
+    void SetUp() override {
+        UUR_RETURN_ON_FATAL_FAILURE(urProfilingQueueTest::SetUp());
+        ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_WRITE_ONLY, size,
+                                         nullptr, &buffer));
+
+        input.assign(count, 42);
+        ur_event_handle_t membuf_event = nullptr;
+        ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, false, 0, size,
+                                               input.data(), 0, nullptr,
+                                               &membuf_event));
+
+        ASSERT_SUCCESS(
+            urEnqueueEventsWaitWithBarrier(queue, 1, &membuf_event, &event));
+        ASSERT_SUCCESS(urQueueFinish(queue));
+    }
+
+    void TearDown() override {
+        UUR_RETURN_ON_FATAL_FAILURE(urProfilingQueueTest::TearDown());
+    }
+
+    const size_t count = 1024;
+    const size_t size = sizeof(uint32_t) * count;
+    ur_mem_handle_t buffer = nullptr;
+    ur_event_handle_t event = nullptr;
+    std::vector<uint32_t> input;
+};
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEventGetProfilingInfoForWaitWithBarrier);
+
+TEST_P(urEventGetProfilingInfoForWaitWithBarrier, Success) {
+    std::vector<uint8_t> submit_data(size);
+    ASSERT_SUCCESS(urEventGetProfilingInfo(event,
+                                           UR_PROFILING_INFO_COMMAND_START,
+                                           size, submit_data.data(), nullptr));
+    auto start_timing = reinterpret_cast<size_t *>(submit_data.data());
+    ASSERT_NE(*start_timing, 0);
+
+    std::vector<uint8_t> complete_data(size);
+    ASSERT_SUCCESS(urEventGetProfilingInfo(event, UR_PROFILING_INFO_COMMAND_END,
+                                           size, complete_data.data(),
+                                           nullptr));
+    auto end_timing = reinterpret_cast<size_t *>(complete_data.data());
+    ASSERT_NE(*end_timing, 0);
+
+    ASSERT_GT(*end_timing, *start_timing);
+}