fix: use tpause in Event::hostSynchronize()

HoppeMateusz · Compute-Runtime-Automation · commit 7c256a67ea4d · 2025-11-03T17:04:53.000+01:00
Related-To: NEO-9737

Signed-off-by: Mateusz Hoppe &lt;mateusz.hoppe@intel.com&gt;
diff --git a/level_zero/api/core/ze_event_api_entrypoints.h b/level_zero/api/core/ze_event_api_entrypoints.h
@@ -96,7 +96,7 @@ ze_result_t ZE_APICALL zeEventHostSynchronize(
 
 ze_result_t ZE_APICALL zeEventQueryStatus(
     ze_event_handle_t hEvent) {
-    return L0::Event::fromHandle(hEvent)->queryStatus();
+    return L0::Event::fromHandle(hEvent)->queryStatus(0);
 }
 
 ze_result_t ZE_APICALL zeCommandListAppendEventReset(
diff --git a/level_zero/core/source/device/bcs_split.cpp b/level_zero/core/source/device/bcs_split.cpp
@@ -149,7 +149,7 @@ BcsSplit::CmdListsForSplitContainer BcsSplit::getCmdListsForSplit(NEO::TransferD
 
 size_t BcsSplitEvents::obtainAggregatedEventsForSplit(Context *context) {
     for (size_t i = 0; i < this->marker.size(); i++) {
-        if (this->marker[i]->queryStatus() == ZE_RESULT_SUCCESS) {
+        if (this->marker[i]->queryStatus(0) == ZE_RESULT_SUCCESS) {
             resetAggregatedEventState(i, false);
             return i;
         }
@@ -166,7 +166,7 @@ std::optional<size_t> BcsSplitEvents::obtainForSplit(Context *context, size_t ma
     }
 
     for (size_t i = 0; i < this->marker.size(); i++) {
-        auto ret = this->marker[i]->queryStatus();
+        auto ret = this->marker[i]->queryStatus(0);
         if (ret == ZE_RESULT_SUCCESS) {
             this->resetEventPackage(i);
             return i;
diff --git a/level_zero/core/source/event/event.h b/level_zero/core/source/event/event.h
@@ -112,7 +112,7 @@ struct Event : _ze_event_handle_t {
     virtual ze_result_t destroy();
     virtual ze_result_t hostSignal(bool allowCounterBased) = 0;
     virtual ze_result_t hostSynchronize(uint64_t timeout) = 0;
-    virtual ze_result_t queryStatus() = 0;
+    virtual ze_result_t queryStatus(int64_t timeSinceWait) = 0;
     virtual ze_result_t reset() = 0;
     virtual ze_result_t queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) = 0;
     virtual ze_result_t queryTimestampsExp(Device *device, uint32_t *count, ze_kernel_timestamp_result_t *timestamps) = 0;
diff --git a/level_zero/core/source/event/event_imp.h b/level_zero/core/source/event/event_imp.h
@@ -34,7 +34,7 @@ struct EventImp : public Event {
 
     ze_result_t hostSynchronize(uint64_t timeout) override;
 
-    ze_result_t queryStatus() override;
+    ze_result_t queryStatus(int64_t timeSinceWait) override;
 
     ze_result_t reset() override;
 
@@ -68,8 +68,8 @@ struct EventImp : public Event {
     TaskCountType getTaskCount(const NEO::CommandStreamReceiver &csr) const;
 
     ze_result_t calculateProfilingData();
-    ze_result_t queryStatusEventPackets();
-    ze_result_t queryCounterBasedEventStatus();
+    ze_result_t queryStatusEventPackets(int64_t timeSinceWait);
+    ze_result_t queryCounterBasedEventStatus(int64_t timeSinceWait);
     void handleSuccessfulHostSynchronization();
     MOCKABLE_VIRTUAL ze_result_t hostEventSetValueTimestamps(State eventState);
     void clearTimestampTagData(uint32_t partitionCount, NEO::TagNodeBase *newNode) override;
diff --git a/level_zero/core/source/event/event_impl.inl b/level_zero/core/source/event/event_impl.inl
@@ -291,7 +291,7 @@ void EventImp<TagSizeT>::assignKernelEventCompletionData(void *address) {
 }
 
 template <typename TagSizeT>
-ze_result_t EventImp<TagSizeT>::queryCounterBasedEventStatus() {
+ze_result_t EventImp<TagSizeT>::queryCounterBasedEventStatus(int64_t timeSinceWait) {
     if (!this->inOrderExecInfo.get()) {
         return reportEmptyCbEventAsReady ? ZE_RESULT_SUCCESS : ZE_RESULT_NOT_READY;
     }
@@ -308,7 +308,7 @@ ze_result_t EventImp<TagSizeT>::queryCounterBasedEventStatus() {
         } else {
             const uint64_t *hostAddress = ptrOffset(inOrderExecInfo->getBaseHostAddress(), this->inOrderAllocationOffset);
             for (uint32_t i = 0; i < inOrderExecInfo->getNumHostPartitionsToWait(); i++) {
-                if (!NEO::WaitUtils::waitFunctionWithPredicate<const uint64_t>(hostAddress, waitValue, std::greater_equal<uint64_t>(), 0)) {
+                if (!NEO::WaitUtils::waitFunctionWithPredicate<const uint64_t>(hostAddress, waitValue, std::greater_equal<uint64_t>(), timeSinceWait)) {
                     signaled = false;
                     break;
                 }
@@ -391,10 +391,11 @@ void EventImp<TagSizeT>::handleSuccessfulHostSynchronization() {
 }
 
 template <typename TagSizeT>
-ze_result_t EventImp<TagSizeT>::queryStatusEventPackets() {
+ze_result_t EventImp<TagSizeT>::queryStatusEventPackets(int64_t timeSinceWait) {
     assignKernelEventCompletionData(getHostAddress());
     uint32_t queryVal = Event::STATE_CLEARED;
     uint32_t packets = 0;
+
     for (uint32_t i = 0; i < this->kernelCount; i++) {
         uint32_t packetsToCheck = kernelEventCompletionData[i].getPacketsUsed();
         for (uint32_t packetId = 0; packetId < packetsToCheck; packetId++, packets++) {
@@ -405,7 +406,7 @@ ze_result_t EventImp<TagSizeT>::queryStatusEventPackets() {
                 static_cast<TagSizeT const *>(queryAddress),
                 queryVal,
                 std::not_equal_to<TagSizeT>(),
-                0);
+                timeSinceWait);
             if (!ready) {
                 return ZE_RESULT_NOT_READY;
             }
@@ -422,7 +423,7 @@ ze_result_t EventImp<TagSizeT>::queryStatusEventPackets() {
                     static_cast<TagSizeT const *>(queryAddress),
                     queryVal,
                     std::not_equal_to<TagSizeT>(),
-                    0);
+                    timeSinceWait);
                 if (!ready) {
                     return ZE_RESULT_NOT_READY;
                 }
@@ -512,15 +513,15 @@ bool EventImp<TagSizeT>::handlePreQueryStatusOperationsAndCheckCompletion() {
 }
 
 template <typename TagSizeT>
-ze_result_t EventImp<TagSizeT>::queryStatus() {
+ze_result_t EventImp<TagSizeT>::queryStatus(int64_t timeSinceWait) {
     if (handlePreQueryStatusOperationsAndCheckCompletion()) {
         return ZE_RESULT_SUCCESS;
     }
 
     if (isCounterBased() || this->inOrderExecInfo.get()) {
-        return queryCounterBasedEventStatus();
+        return queryCounterBasedEventStatus(timeSinceWait);
     } else {
-        return queryStatusEventPackets();
+        return queryStatusEventPackets(timeSinceWait);
     }
 }
 
@@ -772,7 +773,7 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
             if (fenceWait) {
                 ret = waitForUserFence(timeout);
             } else {
-                ret = queryStatus();
+                ret = queryStatus(timeDiff);
             }
         }
         if (ret == ZE_RESULT_SUCCESS) {
@@ -835,7 +836,7 @@ ze_result_t EventImp<TagSizeT>::reset() {
     }
 
     if (NEO::debugManager.flags.SynchronizeEventBeforeReset.get() != -1) {
-        if (NEO::debugManager.flags.SynchronizeEventBeforeReset.get() == 2 && queryStatus() != ZE_RESULT_SUCCESS) {
+        if (NEO::debugManager.flags.SynchronizeEventBeforeReset.get() == 2 && queryStatus(0) != ZE_RESULT_SUCCESS) {
             printf("\nzeEventHostReset: Event %p not ready. Calling zeEventHostSynchronize.", this);
         }
 
@@ -884,7 +885,7 @@ ze_result_t EventImp<TagSizeT>::queryKernelTimestamp(ze_kernel_timestamp_result_
     ze_kernel_timestamp_result_t &result = *dstptr;
 
     if (!this->isCounterBased() || this->inOrderTimestampNode.empty()) {
-        if (queryStatus() != ZE_RESULT_SUCCESS) {
+        if (queryStatus(0) != ZE_RESULT_SUCCESS) {
             return ZE_RESULT_NOT_READY;
         }
     }
@@ -1051,7 +1052,7 @@ ze_result_t EventImp<TagSizeT>::queryKernelTimestampsExt(Device *device, uint32_
         return queryTimestampsExp(device, pCount, nullptr);
     }
 
-    if (queryStatus() != ZE_RESULT_SUCCESS) {
+    if (queryStatus(0) != ZE_RESULT_SUCCESS) {
         return ZE_RESULT_NOT_READY;
     }
 
diff --git a/level_zero/core/test/unit_tests/mocks/mock_event.h b/level_zero/core/test/unit_tests/mocks/mock_event.h
@@ -91,7 +91,7 @@ struct Mock<Event> : public Event {
     ADDMETHOD_NOBASE(destroy, ze_result_t, ZE_RESULT_SUCCESS, ());
     ADDMETHOD_NOBASE(hostSignal, ze_result_t, ZE_RESULT_SUCCESS, (bool allowCounterBased));
     ADDMETHOD_NOBASE(hostSynchronize, ze_result_t, ZE_RESULT_SUCCESS, (uint64_t timeout));
-    ADDMETHOD_NOBASE(queryStatus, ze_result_t, ZE_RESULT_SUCCESS, ());
+    ADDMETHOD_NOBASE(queryStatus, ze_result_t, ZE_RESULT_SUCCESS, (int64_t timeDiff));
     ADDMETHOD_NOBASE(reset, ze_result_t, ZE_RESULT_SUCCESS, ());
     ADDMETHOD_NOBASE(queryKernelTimestamp, ze_result_t, ZE_RESULT_SUCCESS, (ze_kernel_timestamp_result_t * dstptr));
     ADDMETHOD_NOBASE(queryTimestampsExp, ze_result_t, ZE_RESULT_SUCCESS, (::L0::Device * device, uint32_t *count, ze_kernel_timestamp_result_t *timestamps));
@@ -174,7 +174,7 @@ class MockEvent : public ::L0::Event {
     ze_result_t hostSynchronize(uint64_t timeout) override {
         return ZE_RESULT_SUCCESS;
     }
-    ze_result_t queryStatus() override {
+    ze_result_t queryStatus(int64_t timeDiff) override {
         return ZE_RESULT_SUCCESS;
     }
     ze_result_t reset() override {
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
@@ -1306,7 +1306,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithSyncModeAndAppendSignal
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 }
 
 TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithSyncModeAndAppendBarrierThenUpdateTaskCountNeededFlagIsDisabled) {
@@ -1346,7 +1346,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithSyncModeAndAppendBarrie
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 
     commandList->appendBarrier(nullptr, 0, nullptr, false);
 }
@@ -2602,7 +2602,7 @@ HWTEST_F(CommandListCreateTests, GivenGpuHangWhenCreatingImmediateCommandListAnd
 
     returnValue = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, eventObject->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, eventObject->queryStatus(0));
 
     MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
     mockCommandStreamReceiver.waitForCompletionWithTimeoutReturnValue = WaitStatus::gpuHang;
@@ -2725,7 +2725,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithSyncModeAndAppendResetE
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 }
 
 TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendSignalEventThenUpdateTaskCountNeededFlagIsEnabled) {
@@ -2766,7 +2766,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendSigna
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 }
 
 TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendBarrierThenUpdateTaskCountNeededFlagIsEnabled) {
@@ -2807,7 +2807,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendBarri
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 
     commandList->appendBarrier(nullptr, 0, nullptr, false);
 }
@@ -2851,7 +2851,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndCopyEngineA
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 
     commandList->appendBarrier(nullptr, 0, nullptr, false);
 }
@@ -2894,7 +2894,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendEvent
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 }
 
 TEST_F(CommandListCreateTests, whenInvokingAppendMemoryCopyFromContextForImmediateCommandListWithSyncModeThenSuccessIsReturned) {
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
@@ -1229,7 +1229,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendSigna
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 }
 
 TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendBarrierThenUpdateTaskCountNeededFlagIsDisabled) {
@@ -1270,7 +1270,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendBarri
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 
     commandList->appendBarrier(event, 0, nullptr, false);
 }
@@ -1313,7 +1313,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendEvent
     auto result = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 }
 
 TEST_F(CommandListCreateWithBcs, givenQueueDescriptionwhenCreatingImmediateCommandListForCopyEnigneThenItHasImmediateCommandQueueCreated) {
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_8.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_8.cpp
@@ -901,11 +901,11 @@ HWTEST_F(AppendMemoryLockedCopyTest, givenImmediateCommandListAndSignalEventAndN
     EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
     auto event = std::unique_ptr<L0::Event>(Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device, returnValue));
 
-    EXPECT_EQ(event->queryStatus(), ZE_RESULT_NOT_READY);
+    EXPECT_EQ(event->queryStatus(0), ZE_RESULT_NOT_READY);
     auto res = cmdList.appendMemoryCopy(devicePtr, nonUsmHostPtr, 1024, event->toHandle(), 0, nullptr, copyParams);
     EXPECT_EQ(res, ZE_RESULT_SUCCESS);
 
-    EXPECT_EQ(event->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(event->queryStatus(0), ZE_RESULT_SUCCESS);
 }
 
 HWTEST_F(AppendMemoryLockedCopyTest, givenImmediateCommandListAndSignalEventAndCpuMemcpyWhenGpuHangThenDontSynchronizeEvent) {
@@ -932,12 +932,12 @@ HWTEST_F(AppendMemoryLockedCopyTest, givenImmediateCommandListAndSignalEventAndC
     EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
     auto event = std::unique_ptr<L0::Event>(Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device, returnValue));
 
-    EXPECT_EQ(event->queryStatus(), ZE_RESULT_NOT_READY);
+    EXPECT_EQ(event->queryStatus(0), ZE_RESULT_NOT_READY);
     cmdList.appendBarrier(nullptr, 0, nullptr, false);
     auto res = cmdList.appendMemoryCopy(devicePtr, nonUsmHostPtr, 1024, event->toHandle(), 0, nullptr, copyParams);
     EXPECT_EQ(res, ZE_RESULT_ERROR_DEVICE_LOST);
 
-    EXPECT_EQ(event->queryStatus(), ZE_RESULT_NOT_READY);
+    EXPECT_EQ(event->queryStatus(0), ZE_RESULT_NOT_READY);
 }
 
 HWTEST_F(AppendMemoryLockedCopyTest, givenImmediateCommandListWhenCpuMemcpyWithoutBarrierThenDontWaitForTagUpdate) {
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp
@@ -462,7 +462,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToC
     EXPECT_EQ(1u, commandList->getPrintfKernelContainer().size());
     EXPECT_EQ(nullptr, commandList->getPrintfKernelContainer()[0].lock().get());
     EXPECT_EQ(nullptr, event->getKernelForPrintf().lock().get());
-    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus(0));
     EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
     EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
 
@@ -610,7 +610,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToI
     EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
     EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
     EXPECT_EQ(nullptr, event->getKernelForPrintf().lock().get());
-    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus(0));
     EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
     EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
 }
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
@@ -893,7 +893,7 @@ HWTEST_F(CommandListAppendWaitOnEvent, givenImmediateCommandListWhenAppendWaitOn
     cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
     cmdList.dcFlushSupport = false;
     event->hostSignal(false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus(0));
     ze_event_handle_t eventHandle = event->toHandle();
 
     EXPECT_FALSE(cmdList.dependenciesPresent);
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_blit.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_blit.cpp
@@ -1418,7 +1418,7 @@ HWTEST2_F(AggregatedBcsSplitTests, whenObtainCalledThenAggregatedEventsCreated,
         EXPECT_FALSE(bcsSplit->events.marker[i]->isSignalScope(ZE_EVENT_SCOPE_FLAG_DEVICE));
 
         // already reserved for this obtainForSplit() call
-        EXPECT_EQ(ZE_RESULT_NOT_READY, bcsSplit->events.marker[i]->queryStatus());
+        EXPECT_EQ(ZE_RESULT_NOT_READY, bcsSplit->events.marker[i]->queryStatus(0));
 
         EXPECT_EQ(8u, bcsSplit->events.subcopy.size());
         EXPECT_EQ(1u, bcsSplit->events.allocsForAggregatedEvents.size());
@@ -1437,9 +1437,9 @@ HWTEST2_F(AggregatedBcsSplitTests, whenObtainCalledThenAggregatedEventsCreated,
         EXPECT_EQ(0u, *bcsSplit->events.subcopy[i]->getInOrderExecInfo()->getBaseHostAddress());
 
         if (i <= 8) {
-            EXPECT_EQ(ZE_RESULT_NOT_READY, bcsSplit->events.marker[i]->queryStatus());
+            EXPECT_EQ(ZE_RESULT_NOT_READY, bcsSplit->events.marker[i]->queryStatus(0));
         } else {
-            EXPECT_EQ(ZE_RESULT_SUCCESS, bcsSplit->events.marker[i]->queryStatus());
+            EXPECT_EQ(ZE_RESULT_SUCCESS, bcsSplit->events.marker[i]->queryStatus(0));
         }
     }
 
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_1.cpp
@@ -244,7 +244,7 @@ HWTEST_F(InOrderCmdListTests, givenNotSignaledInOrderWhenWhenCallingQueryStatusT
     auto eventPool = createEvents<FamilyType>(1, false);
     events[0]->enableCounterBasedMode(true, eventPool->getCounterBasedFlags());
 
-    EXPECT_EQ(ZE_RESULT_SUCCESS, events[0]->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, events[0]->queryStatus(0));
 }
 
 HWTEST_F(InOrderCmdListTests, givenCmdListsWhenDispatchingThenUseInternalTaskCountForWaits) {
@@ -530,9 +530,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, InOrderCmdListTests, givenCounterBasedTimestampEven
     event2->getInOrderExecInfo()->setLastWaitedCounterValue(2);
     event3->getInOrderExecInfo()->setLastWaitedCounterValue(3);
 
-    EXPECT_EQ(ZE_RESULT_SUCCESS, event1->queryStatus());
-    EXPECT_EQ(ZE_RESULT_SUCCESS, event2->queryStatus());
-    EXPECT_EQ(ZE_RESULT_SUCCESS, event3->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event1->queryStatus(0));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event2->queryStatus(0));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event3->queryStatus(0));
 
     ze_kernel_timestamp_result_t kernelTimestamps = {};
 
diff --git a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp
@@ -386,7 +386,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledWithImmediat
 
     returnValue = eventObject->hostSignal(false);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);
 
     returnValue = commandList->appendWriteGlobalTimestamp(reinterpret_cast<uint64_t *>(dstPtr), nullptr, 0, nullptr);
     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
diff --git a/level_zero/core/test/unit_tests/sources/event/test_event.cpp b/level_zero/core/test/unit_tests/sources/event/test_event.cpp

Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ ze_result_t ZE_APICALL zeEventHostSynchronize(`
`96`	`96`
`97`	`97`	`ze_result_t ZE_APICALL zeEventQueryStatus(`
`98`	`98`	`ze_event_handle_t hEvent) {`
`99`		`- return L0::Event::fromHandle(hEvent)->queryStatus();`
	`99`	`+ return L0::Event::fromHandle(hEvent)->queryStatus(0);`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`ze_result_t ZE_APICALL zeCommandListAppendEventReset(`
Original file line number	Diff line number	Diff line change
`@@ -291,7 +291,7 @@ void EventImp<TagSizeT>::assignKernelEventCompletionData(void *address) {`
`291`	`291`	`}`
`292`	`292`
`293`	`293`	`template <typename TagSizeT>`
`294`		`-ze_result_t EventImp<TagSizeT>::queryCounterBasedEventStatus() {`
	`294`	`+ze_result_t EventImp<TagSizeT>::queryCounterBasedEventStatus(int64_t timeSinceWait) {`
`295`	`295`	`if (!this->inOrderExecInfo.get()) {`
`296`	`296`	`return reportEmptyCbEventAsReady ? ZE_RESULT_SUCCESS : ZE_RESULT_NOT_READY;`
`297`	`297`	`}`
`@@ -308,7 +308,7 @@ ze_result_t EventImp<TagSizeT>::queryCounterBasedEventStatus() {`
`308`	`308`	`} else {`
`309`	`309`	`const uint64_t *hostAddress = ptrOffset(inOrderExecInfo->getBaseHostAddress(), this->inOrderAllocationOffset);`
`310`	`310`	`for (uint32_t i = 0; i < inOrderExecInfo->getNumHostPartitionsToWait(); i++) {`
`311`		`- if (!NEO::WaitUtils::waitFunctionWithPredicate<const uint64_t>(hostAddress, waitValue, std::greater_equal<uint64_t>(), 0)) {`
	`311`	`+ if (!NEO::WaitUtils::waitFunctionWithPredicate<const uint64_t>(hostAddress, waitValue, std::greater_equal<uint64_t>(), timeSinceWait)) {`
`312`	`312`	`signaled = false;`
`313`	`313`	`break;`
`314`	`314`	`}`
`@@ -391,10 +391,11 @@ void EventImp<TagSizeT>::handleSuccessfulHostSynchronization() {`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`template <typename TagSizeT>`
`394`		`-ze_result_t EventImp<TagSizeT>::queryStatusEventPackets() {`
	`394`	`+ze_result_t EventImp<TagSizeT>::queryStatusEventPackets(int64_t timeSinceWait) {`
`395`	`395`	`assignKernelEventCompletionData(getHostAddress());`
`396`	`396`	`uint32_t queryVal = Event::STATE_CLEARED;`
`397`	`397`	`uint32_t packets = 0;`
	`398`	`+`
`398`	`399`	`for (uint32_t i = 0; i < this->kernelCount; i++) {`
`399`	`400`	`uint32_t packetsToCheck = kernelEventCompletionData[i].getPacketsUsed();`
`400`	`401`	`for (uint32_t packetId = 0; packetId < packetsToCheck; packetId++, packets++) {`
`@@ -405,7 +406,7 @@ ze_result_t EventImp<TagSizeT>::queryStatusEventPackets() {`
`405`	`406`	`static_cast<TagSizeT const *>(queryAddress),`
`406`	`407`	`queryVal,`
`407`	`408`	`std::not_equal_to<TagSizeT>(),`
`408`		`- 0);`
	`409`	`+ timeSinceWait);`
`409`	`410`	`if (!ready) {`
`410`	`411`	`return ZE_RESULT_NOT_READY;`
`411`	`412`	`}`
`@@ -422,7 +423,7 @@ ze_result_t EventImp<TagSizeT>::queryStatusEventPackets() {`
`422`	`423`	`static_cast<TagSizeT const *>(queryAddress),`
`423`	`424`	`queryVal,`
`424`	`425`	`std::not_equal_to<TagSizeT>(),`
`425`		`- 0);`
	`426`	`+ timeSinceWait);`
`426`	`427`	`if (!ready) {`
`427`	`428`	`return ZE_RESULT_NOT_READY;`
`428`	`429`	`}`
`@@ -512,15 +513,15 @@ bool EventImp<TagSizeT>::handlePreQueryStatusOperationsAndCheckCompletion() {`
`512`	`513`	`}`
`513`	`514`
`514`	`515`	`template <typename TagSizeT>`
`515`		`-ze_result_t EventImp<TagSizeT>::queryStatus() {`
	`516`	`+ze_result_t EventImp<TagSizeT>::queryStatus(int64_t timeSinceWait) {`
`516`	`517`	`if (handlePreQueryStatusOperationsAndCheckCompletion()) {`
`517`	`518`	`return ZE_RESULT_SUCCESS;`
`518`	`519`	`}`
`519`	`520`
`520`	`521`	`if (isCounterBased() \|\| this->inOrderExecInfo.get()) {`
`521`		`- return queryCounterBasedEventStatus();`
	`522`	`+ return queryCounterBasedEventStatus(timeSinceWait);`
`522`	`523`	`} else {`
`523`		`- return queryStatusEventPackets();`
	`524`	`+ return queryStatusEventPackets(timeSinceWait);`
`524`	`525`	`}`
`525`	`526`	`}`
`526`	`527`
`@@ -772,7 +773,7 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {`
`772`	`773`	`if (fenceWait) {`
`773`	`774`	`ret = waitForUserFence(timeout);`
`774`	`775`	`} else {`
`775`		`- ret = queryStatus();`
	`776`	`+ ret = queryStatus(timeDiff);`
`776`	`777`	`}`
`777`	`778`	`}`
`778`	`779`	`if (ret == ZE_RESULT_SUCCESS) {`
`@@ -835,7 +836,7 @@ ze_result_t EventImp<TagSizeT>::reset() {`
`835`	`836`	`}`
`836`	`837`
`837`	`838`	`if (NEO::debugManager.flags.SynchronizeEventBeforeReset.get() != -1) {`
`838`		`- if (NEO::debugManager.flags.SynchronizeEventBeforeReset.get() == 2 && queryStatus() != ZE_RESULT_SUCCESS) {`
	`839`	`+ if (NEO::debugManager.flags.SynchronizeEventBeforeReset.get() == 2 && queryStatus(0) != ZE_RESULT_SUCCESS) {`
`839`	`840`	`printf("\nzeEventHostReset: Event %p not ready. Calling zeEventHostSynchronize.", this);`
`840`	`841`	`}`
`841`	`842`
`@@ -884,7 +885,7 @@ ze_result_t EventImp<TagSizeT>::queryKernelTimestamp(ze_kernel_timestamp_result_`
`884`	`885`	`ze_kernel_timestamp_result_t &result = *dstptr;`
`885`	`886`
`886`	`887`	`if (!this->isCounterBased() \|\| this->inOrderTimestampNode.empty()) {`
`887`		`- if (queryStatus() != ZE_RESULT_SUCCESS) {`
	`888`	`+ if (queryStatus(0) != ZE_RESULT_SUCCESS) {`
`888`	`889`	`return ZE_RESULT_NOT_READY;`
`889`	`890`	`}`
`890`	`891`	`}`
`@@ -1051,7 +1052,7 @@ ze_result_t EventImp<TagSizeT>::queryKernelTimestampsExt(Device *device, uint32_`
`1051`	`1052`	`return queryTimestampsExp(device, pCount, nullptr);`
`1052`	`1053`	`}`
`1053`	`1054`
`1054`		`- if (queryStatus() != ZE_RESULT_SUCCESS) {`
	`1055`	`+ if (queryStatus(0) != ZE_RESULT_SUCCESS) {`
`1055`	`1056`	`return ZE_RESULT_NOT_READY;`
`1056`	`1057`	`}`
`1057`	`1058`
Original file line number	Diff line number	Diff line change
`@@ -1229,7 +1229,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendSigna`
`1229`	`1229`	`auto result = eventObject->hostSignal(false);`
`1230`	`1230`	`ASSERT_EQ(ZE_RESULT_SUCCESS, result);`
`1231`	`1231`
`1232`		`- EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);`
	`1232`	`+ EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);`
`1233`	`1233`	`}`
`1234`	`1234`
`1235`	`1235`	`TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendBarrierThenUpdateTaskCountNeededFlagIsDisabled) {`
`@@ -1270,7 +1270,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendBarri`
`1270`	`1270`	`auto result = eventObject->hostSignal(false);`
`1271`	`1271`	`ASSERT_EQ(ZE_RESULT_SUCCESS, result);`
`1272`	`1272`
`1273`		`- EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);`
	`1273`	`+ EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);`
`1274`	`1274`
`1275`	`1275`	`commandList->appendBarrier(event, 0, nullptr, false);`
`1276`	`1276`	`}`
`@@ -1313,7 +1313,7 @@ TEST_F(CommandListCreateTests, whenCreatingImmCmdListWithASyncModeAndAppendEvent`
`1313`	`1313`	`auto result = eventObject->hostSignal(false);`
`1314`	`1314`	`ASSERT_EQ(ZE_RESULT_SUCCESS, result);`
`1315`	`1315`
`1316`		`- EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);`
	`1316`	`+ EXPECT_EQ(eventObject->queryStatus(0), ZE_RESULT_SUCCESS);`
`1317`	`1317`	`}`
`1318`	`1318`
`1319`	`1319`	`TEST_F(CommandListCreateWithBcs, givenQueueDescriptionwhenCreatingImmediateCommandListForCopyEnigneThenItHasImmediateCommandQueueCreated) {`