Use KMD wait function for infinite timeout synchronization

Related-To: NEO-5845

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>

Author: zzdanowicz

level_zero/core/source/cmdqueue/cmdqueue.cpp

@@ -78,7 +78,13 @@ void CommandQueueImp::submitBatchBuffer(size_t offset, NEO::ResidencyContainer &
 }
 
 ze_result_t CommandQueueImp::synchronize(uint64_t timeout) {
-    return synchronizeByPollingForTaskCount(timeout);
+    if (timeout == std::numeric_limits<uint64_t>::max()) {
+        auto &waitPair = buffers.getCurrentFlushStamp();
+        csr->waitForTaskCountWithKmdNotifyFallback(waitPair.first, waitPair.second, false, false);
+        return ZE_RESULT_SUCCESS;
+    } else {
+        return synchronizeByPollingForTaskCount(timeout);
+    }
 }
 
 ze_result_t CommandQueueImp::synchronizeByPollingForTaskCount(uint64_t timeout) {
@@ -87,10 +93,6 @@ ze_result_t CommandQueueImp::synchronizeByPollingForTaskCount(uint64_t timeout)
     auto taskCountToWait = getTaskCount();
     bool enableTimeout = true;
     int64_t timeoutMicroseconds = static_cast<int64_t>(timeout);
-    if (timeout == std::numeric_limits<uint64_t>::max()) {
-        enableTimeout = false;
-        timeoutMicroseconds = NEO::TimeoutControls::maxTimeout;
-    }
 
     csr->waitForCompletionWithTimeout(enableTimeout, timeoutMicroseconds, this->taskCount);
 

level_zero/core/source/cmdqueue/cmdqueue_imp.h

@@ -46,6 +46,9 @@ struct CommandQueueImp : public CommandQueue {
         void setCurrentFlushStamp(uint32_t taskCount, NEO::FlushStamp flushStamp) {
             flushId[bufferUse] = std::make_pair(taskCount, flushStamp);
         }
+        std::pair<uint32_t, NEO::FlushStamp> &getCurrentFlushStamp() {
+            return flushId[bufferUse];
+        }
 
       private:
         NEO::GraphicsAllocation *buffers[BUFFER_ALLOCATION::COUNT];

level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue.cpp

@@ -1402,20 +1402,28 @@ HWTEST_F(CommandQueueSynchronizeTest, givenCallToSynchronizeThenCorrectEnableTim
         ~SynchronizeCsr() override {
             delete tagAddress;
         }
+
         SynchronizeCsr(const NEO::ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
             : NEO::UltCommandStreamReceiver<FamilyType>(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment), 0, deviceBitfield) {
             tagAddress = new uint32_t;
         }
+
         bool waitForCompletionWithTimeout(bool enableTimeout, int64_t timeoutMs, uint32_t taskCountToWait) override {
             waitForComplitionCalledTimes++;
             return true;
         }
 
+        void waitForTaskCountWithKmdNotifyFallback(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool quickKmdSleep, bool forcePowerSavingMode) override {
+            waitForTaskCountWithKmdNotifyFallbackCalled++;
+            NEO::UltCommandStreamReceiver<FamilyType>::waitForTaskCountWithKmdNotifyFallback(taskCountToWait, flushStampToWait, quickKmdSleep, forcePowerSavingMode);
+        }
+
         volatile uint32_t *getTagAddress() const override {
             return tagAddress;
         }
-        uint32_t waitForComplitionCalledTimes = 0;
         uint32_t *tagAddress;
+        uint32_t waitForComplitionCalledTimes = 0;
+        uint32_t waitForTaskCountWithKmdNotifyFallbackCalled = 0;
     };
 
     auto csr = std::unique_ptr<SynchronizeCsr>(new SynchronizeCsr(*device->getNEODevice()->getExecutionEnvironment(),
@@ -1435,14 +1443,17 @@ HWTEST_F(CommandQueueSynchronizeTest, givenCallToSynchronizeThenCorrectEnableTim
 
     queue->synchronize(timeout);
 
-    EXPECT_EQ(csr->waitForComplitionCalledTimes, 1u);
+    EXPECT_EQ(1u, csr->waitForComplitionCalledTimes);
+    EXPECT_EQ(0u, csr->waitForTaskCountWithKmdNotifyFallbackCalled);
+
     timeout = std::numeric_limits<uint64_t>::max();
     enableTimeoutExpected = false;
     timeoutMicrosecondsExpected = NEO::TimeoutControls::maxTimeout;
 
     queue->synchronize(timeout);
 
-    EXPECT_EQ(csr->waitForComplitionCalledTimes, 2u);
+    EXPECT_EQ(2u, csr->waitForComplitionCalledTimes);
+    EXPECT_EQ(1u, csr->waitForTaskCountWithKmdNotifyFallbackCalled);
 
     L0::CommandQueue::fromHandle(commandQueue)->destroy();
 }