fix: last signaled value in Windows external semaphore enqueueWait

Related-To: NEO-17636

Signed-off-by: Eric Mortensen <eric.mortensen@intel.com>
Source: 7b0cef3

Author: enm-intel

shared/source/os_interface/windows/external_semaphore_windows.cpp

@@ -180,7 +180,7 @@ bool ExternalSemaphoreWindows::enqueueWait(uint64_t *fenceValue) {
 
     uint64_t lastSignaledValue = 0;
     if (this->type == ExternalSemaphore::OpaqueWin32) {
-        lastSignaledValue = *this->pLastSignaledValue + 2;
+        lastSignaledValue = *this->pLastSignaledValue;
         wait.FenceValueArray = &lastSignaledValue;
     } else {
         wait.FenceValueArray = fenceValue;

shared/test/unit_test/semaphore/windows/test_semaphore_windows.cpp

@@ -6,8 +6,8 @@
  */
 
 #include "shared/source/execution_environment/root_device_environment.h"
-#include "shared/source/os_interface/external_semaphore.h"
 #include "shared/source/os_interface/os_interface.h"
+#include "shared/source/os_interface/windows/external_semaphore_windows.h"
 #include "shared/test/common/mocks/mock_builtins.h"
 #include "shared/test/common/mocks/mock_device.h"
 #include "shared/test/common/os_interface/windows/wddm_fixture.h"
@@ -19,18 +19,18 @@ namespace NEO {
 
 using WddmExternalSemaphoreTest = WddmFixture;
 
-TEST_F(WddmExternalSemaphoreTest, givenOpaqueFdSemaphoreWhenCreateExternalSemaphoreIsCalledThenNullptrIsReturned) {
-    auto externalSemaphore = ExternalSemaphore::create(osInterface, ExternalSemaphore::Type::OpaqueFd, nullptr, 0u, nullptr);
-    EXPECT_EQ(externalSemaphore, nullptr);
-}
-
 TEST_F(WddmExternalSemaphoreTest, givenNullOsInterfaceWhenCreateExternalSemaphoreIsCalledThenNullptrIsReturned) {
     HANDLE extSemaphoreHandle = 0;
 
     auto externalSemaphore = ExternalSemaphore::create(nullptr, ExternalSemaphore::Type::D3d12Fence, extSemaphoreHandle, 0u, nullptr);
     EXPECT_EQ(externalSemaphore, nullptr);
 }
 
+TEST_F(WddmExternalSemaphoreTest, givenOpaqueFdSemaphoreWhenCreateExternalSemaphoreIsCalledThenNullptrIsReturned) {
+    auto externalSemaphore = ExternalSemaphore::create(osInterface, ExternalSemaphore::Type::OpaqueFd, nullptr, 0u, nullptr);
+    EXPECT_EQ(externalSemaphore, nullptr);
+}
+
 TEST_F(WddmExternalSemaphoreTest, givenValidD3d12FenceSemaphoreWhenCreateExternalSemaphoreIsCalledThenSemaphoreIsSuccessfullyReturned) {
     HANDLE extSemaphoreHandle = 0;
 
@@ -53,24 +53,147 @@ TEST_F(WddmExternalSemaphoreTest, givenValidTimelineSemaphoreWin32WhenCreateExte
     EXPECT_NE(externalSemaphore, nullptr);
 }
 
-class MockFailGdi : public MockGdi {
+class MockWindowsExternalSemaphore : public ExternalSemaphoreWindows {
   public:
-    MockFailGdi() : MockGdi() {
-        openSyncObjectNtHandleFromName = mockD3DKMTOpenSyncObjectNtHandleFromName;
-        openSyncObjectFromNtHandle2 = mockD3DKMTOpenSyncObjectFromNtHandle2;
+    using ExternalSemaphoreWindows::enqueueSignal;
+    using ExternalSemaphoreWindows::enqueueWait;
+
+    MockWindowsExternalSemaphore(OSInterface *osInterface, ExternalSemaphore::Type type, uint64_t *signalVal) {
+        this->osInterface = osInterface;
+        this->type = type;
+        this->state = ExternalSemaphore::SemaphoreState::Initial;
+        this->syncHandle = 1;
+        this->pCpuAddress = nullptr;
+        this->pLastSignaledValue = signalVal;
     }
 
-    static NTSTATUS __stdcall mockD3DKMTOpenSyncObjectNtHandleFromName(IN OUT D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME *) {
-        return STATUS_UNSUCCESSFUL;
+    uint64_t lastSignaledValue() const {
+        return pLastSignaledValue ? *pLastSignaledValue : 0u;
     }
+};
 
-    static NTSTATUS __stdcall mockD3DKMTOpenSyncObjectFromNtHandle2(IN OUT D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 *) {
-        return STATUS_UNSUCCESSFUL;
+class MockSyncGdi : public MockGdi {
+  public:
+    MockSyncGdi() : MockGdi() {
+        openSyncObjectNtHandleFromName = mockOpenSyncObjectNtHandleFromName;
+        openSyncObjectFromNtHandle2 = mockOpenSyncObjectFromNtHandle2;
+        waitForSynchronizationObjectFromCpu = mockWaitForSynchronizationObjectFromCpu;
+        signalSynchronizationObjectFromCpu = mockSignalSynchronizationObjectFromCpu;
+    }
+
+    static NTSTATUS __stdcall mockOpenSyncObjectNtHandleFromName(IN OUT D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME *) {
+        return (failOpenSyncObjectNtHandleName ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS);
+    }
+
+    static NTSTATUS __stdcall mockOpenSyncObjectFromNtHandle2(IN OUT D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 *) {
+        return (failOpenSyncObjectFromNtHandle ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS);
     }
+
+    static NTSTATUS __stdcall mockWaitForSynchronizationObjectFromCpu(IN CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU *) {
+        return (failWaitForSynchObjectFromCpu ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS);
+    }
+
+    static NTSTATUS __stdcall mockSignalSynchronizationObjectFromCpu(IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU *) {
+        return (failSignalSynchObjectFromCpu ? STATUS_UNSUCCESSFUL : STATUS_SUCCESS);
+    }
+
+    static bool failOpenSyncObjectNtHandleName;
+    static bool failOpenSyncObjectFromNtHandle;
+    static bool failWaitForSynchObjectFromCpu;
+    static bool failSignalSynchObjectFromCpu;
 };
 
+bool MockSyncGdi::failOpenSyncObjectNtHandleName = true;
+bool MockSyncGdi::failOpenSyncObjectFromNtHandle = true;
+bool MockSyncGdi::failWaitForSynchObjectFromCpu = false;
+bool MockSyncGdi::failSignalSynchObjectFromCpu = false;
+
+TEST_F(WddmExternalSemaphoreTest, givenGdiWaitForSyncObjFailsWhenEnqueueSignalIsCalledWithOpaqueWin32ThenFalseIsReturnedAndSignalValueIsNotUpdated) {
+    auto mockGdi = new MockSyncGdi();
+    static_cast<OsEnvironmentWin *>(executionEnvironment->osEnvironment.get())->gdi.reset(mockGdi);
+
+    uint64_t signalVal = 0u;
+    auto extSem = new MockWindowsExternalSemaphore{osInterface, ExternalSemaphore::Type::OpaqueWin32, &signalVal};
+    EXPECT_NE(extSem, nullptr);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Initial);
+    EXPECT_EQ(extSem->lastSignaledValue(), 0u);
+    EXPECT_EQ(signalVal, 0u);
+
+    MockSyncGdi::failSignalSynchObjectFromCpu = true;
+    auto result = extSem->enqueueSignal(&signalVal);
+    MockSyncGdi::failSignalSynchObjectFromCpu = false;
+    EXPECT_EQ(result, false);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Initial);
+    EXPECT_EQ(extSem->lastSignaledValue(), signalVal);
+    EXPECT_EQ(signalVal, 0ull);
+
+    delete extSem;
+}
+
+TEST_F(WddmExternalSemaphoreTest, givenGdiWaitForSyncObjFailsWhenEnqueueWaitIsCalledWithOpaqueWin32ThenFalseIsReturned) {
+    auto mockGdi = new MockSyncGdi();
+    static_cast<OsEnvironmentWin *>(executionEnvironment->osEnvironment.get())->gdi.reset(mockGdi);
+
+    uint64_t signalVal = 0u;
+    auto extSem = new MockWindowsExternalSemaphore{osInterface, ExternalSemaphore::Type::OpaqueWin32, &signalVal};
+    EXPECT_NE(extSem, nullptr);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Initial);
+    EXPECT_EQ(extSem->lastSignaledValue(), 0u);
+    EXPECT_EQ(signalVal, 0ull);
+
+    MockSyncGdi::failWaitForSynchObjectFromCpu = true;
+    auto result = extSem->enqueueWait(&signalVal);
+    MockSyncGdi::failWaitForSynchObjectFromCpu = false;
+    EXPECT_EQ(result, false);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Initial);
+    EXPECT_EQ(extSem->lastSignaledValue(), signalVal);
+    EXPECT_EQ(signalVal, 0ull);
+
+    delete extSem;
+}
+
+TEST_F(WddmExternalSemaphoreTest, givenGdiWaitForSyncObjSucceedsWhenEnqueueSignalIsCalledWithOpaqueWin32ThenTrueIsReturnedAndSignalValueIsUpdated) {
+    auto mockGdi = new MockSyncGdi();
+    static_cast<OsEnvironmentWin *>(executionEnvironment->osEnvironment.get())->gdi.reset(mockGdi);
+
+    uint64_t signalVal = 0u;
+    auto extSem = new MockWindowsExternalSemaphore{osInterface, ExternalSemaphore::Type::OpaqueWin32, &signalVal};
+    EXPECT_NE(extSem, nullptr);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Initial);
+    EXPECT_EQ(extSem->lastSignaledValue(), 0u);
+    EXPECT_EQ(signalVal, 0ull);
+
+    auto result = extSem->enqueueSignal(&signalVal);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Signaled);
+    EXPECT_EQ(extSem->lastSignaledValue(), signalVal);
+    EXPECT_EQ(signalVal, 2ull);
+
+    delete extSem;
+}
+
+TEST_F(WddmExternalSemaphoreTest, givenGdiWaitForSyncObjSucceedsWhenEnqueueWaitIsCalledWithOpaqueWin32ThenTrueIsReturned) {
+    auto mockGdi = new MockSyncGdi();
+    static_cast<OsEnvironmentWin *>(executionEnvironment->osEnvironment.get())->gdi.reset(mockGdi);
+
+    uint64_t signalVal = 0u;
+    auto extSem = new MockWindowsExternalSemaphore{osInterface, ExternalSemaphore::Type::OpaqueWin32, &signalVal};
+    EXPECT_NE(extSem, nullptr);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Initial);
+    EXPECT_EQ(extSem->lastSignaledValue(), 0u);
+    EXPECT_EQ(signalVal, 0ull);
+
+    auto result = extSem->enqueueWait(&signalVal);
+    EXPECT_EQ(result, true);
+    EXPECT_EQ(extSem->getState(), ExternalSemaphore::SemaphoreState::Signaled);
+    EXPECT_EQ(extSem->lastSignaledValue(), signalVal);
+    EXPECT_EQ(signalVal, 0ull);
+
+    delete extSem;
+}
+
 TEST_F(WddmExternalSemaphoreTest, givenTimelineSemaphoreWin32FailsToOpenSyncObjectFromNameThenNullptrIsReturned) {
-    auto mockGdi = new MockFailGdi();
+    auto mockGdi = new MockSyncGdi();
     static_cast<OsEnvironmentWin *>(executionEnvironment->osEnvironment.get())->gdi.reset(mockGdi);
     HANDLE extSemaphoreHandle = 0;
     const char *extSemName = "timeline_semaphore_name";
@@ -80,7 +203,7 @@ TEST_F(WddmExternalSemaphoreTest, givenTimelineSemaphoreWin32FailsToOpenSyncObje
 }
 
 TEST_F(WddmExternalSemaphoreTest, givenTimelineSemaphoreWin32FailsToOpenSyncObjectFromNtHandleThenNullptrIsReturned) {
-    auto mockGdi = new MockFailGdi();
+    auto mockGdi = new MockSyncGdi();
     static_cast<OsEnvironmentWin *>(executionEnvironment->osEnvironment.get())->gdi.reset(mockGdi);
     HANDLE extSemaphoreHandle = 0;