feature: Add ULLS support for WDDM 2.3

LukaszJobczyk · Compute-Runtime-Automation · commit 64175d8bb651 · 2024-01-29T15:45:43.000+01:00
Resolves: NEO-4843

Signed-off-by: Lukasz Jobczyk &lt;lukasz.jobczyk@intel.com&gt;
diff --git a/shared/source/direct_submission/windows/wddm_direct_submission.inl b/shared/source/direct_submission/windows/wddm_direct_submission.inl
@@ -86,10 +86,7 @@ void WddmDirectSubmission<GfxFamily, Dispatcher>::ensureRingCompletion() {
 
 template <typename GfxFamily, typename Dispatcher>
 bool WddmDirectSubmission<GfxFamily, Dispatcher>::allocateOsResources() {
-    // for now only WDDM2.0
-    UNRECOVERABLE_IF(wddm->getWddmVersion() != WddmVersion::wddm20);
-
-    bool ret = wddm->getWddmInterface()->createMonitoredFence(ringFence);
+    bool ret = wddm->getWddmInterface()->createMonitoredFenceForDirectSubmission(ringFence, *this->osContextWin);
     ringFence.currentFenceValue = 1;
     perfLogResidencyVariadicLog(wddm->getResidencyLogger(), "ULLS resource allocation finished with: %d\n", ret);
     return ret;
diff --git a/shared/source/os_interface/windows/os_context_win.cpp b/shared/source/os_interface/windows/os_context_win.cpp
@@ -108,7 +108,9 @@ bool OsContextWin::isDirectSubmissionSupported() const {
 OsContextWin::~OsContextWin() {
     if (contextInitialized && (false == this->wddm.skipResourceCleanup())) {
         wddm.getWddmInterface()->destroyHwQueue(hardwareQueue.handle);
-        wddm.getWddmInterface()->destroyMonitorFence(residencyController.getMonitoredFence());
+        if (residencyController.getMonitoredFence().fenceHandle != hardwareQueue.progressFenceHandle) {
+            wddm.getWddmInterface()->destroyMonitorFence(residencyController.getMonitoredFence().fenceHandle);
+        }
         wddm.destroyContext(wddmContextHandle);
     }
 }
diff --git a/shared/source/os_interface/windows/wddm/wddm_interface.cpp b/shared/source/os_interface/windows/wddm/wddm_interface.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2023 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -161,3 +161,21 @@ bool WddmInterface23::submit(uint64_t commandBuffer, size_t size, void *commandH
     UNRECOVERABLE_IF(status != STATUS_SUCCESS);
     return status == STATUS_SUCCESS;
 }
+
+bool NEO::WddmInterface23::createMonitoredFenceForDirectSubmission(MonitoredFence &monitorFence, OsContextWin &osContext) {
+    MonitoredFence monitorFenceForResidency{};
+    auto ret = WddmInterface::createMonitoredFence(monitorFenceForResidency);
+    auto &residencyController = osContext.getResidencyController();
+    residencyController.resetMonitoredFenceParams(monitorFenceForResidency.fenceHandle,
+                                                  const_cast<uint64_t *>(monitorFenceForResidency.cpuAddress),
+                                                  monitorFenceForResidency.gpuAddress);
+
+    auto hwQueue = osContext.getHwQueue();
+    monitorFence.cpuAddress = reinterpret_cast<uint64_t *>(hwQueue.progressFenceCpuVA);
+    monitorFence.currentFenceValue = 1u;
+    monitorFence.lastSubmittedFence = 0u;
+    monitorFence.gpuAddress = hwQueue.progressFenceGpuVA;
+    monitorFence.fenceHandle = hwQueue.progressFenceHandle;
+
+    return ret;
+}
diff --git a/shared/source/os_interface/windows/wddm/wddm_interface.h b/shared/source/os_interface/windows/wddm/wddm_interface.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2022 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -27,10 +27,11 @@ class WddmInterface {
     virtual void destroyHwQueue(D3DKMT_HANDLE hwQueue) = 0;
     virtual bool createMonitoredFence(OsContextWin &osContext) = 0;
     MOCKABLE_VIRTUAL bool createMonitoredFence(MonitoredFence &monitorFence);
-    void destroyMonitorFence(D3DKMT_HANDLE fenceHandle);
+    MOCKABLE_VIRTUAL void destroyMonitorFence(D3DKMT_HANDLE fenceHandle);
     virtual void destroyMonitorFence(MonitoredFence &monitorFence) = 0;
     virtual bool hwQueuesSupported() = 0;
     virtual bool submit(uint64_t commandBuffer, size_t size, void *commandHeader, WddmSubmitArguments &submitArguments) = 0;
+    virtual bool createMonitoredFenceForDirectSubmission(MonitoredFence &monitorFence, OsContextWin &osContext) = 0;
     Wddm &wddm;
 };
 
@@ -43,6 +44,9 @@ class WddmInterface20 : public WddmInterface {
     void destroyMonitorFence(MonitoredFence &monitorFence) override;
     bool hwQueuesSupported() override;
     bool submit(uint64_t commandBuffer, size_t size, void *commandHeader, WddmSubmitArguments &submitArguments) override;
+    bool createMonitoredFenceForDirectSubmission(MonitoredFence &monitorFence, OsContextWin &osContext) override {
+        return WddmInterface::createMonitoredFence(monitorFence);
+    };
 };
 
 class WddmInterface23 : public WddmInterface {
@@ -54,5 +58,6 @@ class WddmInterface23 : public WddmInterface {
     void destroyMonitorFence(MonitoredFence &monitorFence) override;
     bool hwQueuesSupported() override;
     bool submit(uint64_t commandBuffer, size_t size, void *commandHeader, WddmSubmitArguments &submitArguments) override;
+    bool createMonitoredFenceForDirectSubmission(MonitoredFence &monitorFence, OsContextWin &osContext) override;
 };
 } // namespace NEO
diff --git a/shared/test/common/mocks/mock_wddm_interface.h b/shared/test/common/mocks/mock_wddm_interface.h
@@ -20,5 +20,6 @@ class WddmMockInterface : public WddmInterface {
     ADDMETHOD_NOBASE_VOIDRETURN(destroyMonitorFence, (MonitoredFence & monitorFence));
     ADDMETHOD_NOBASE(hwQueuesSupported, bool, false, ());
     ADDMETHOD_NOBASE(submit, bool, true, (uint64_t commandBuffer, size_t size, void *commandHeader, WddmSubmitArguments &submitArguments));
+    ADDMETHOD_NOBASE(createMonitoredFenceForDirectSubmission, bool, true, (MonitoredFence & monitorFence, OsContextWin &osContext));
 };
 } // namespace NEO
diff --git a/shared/test/common/mocks/mock_wddm_interface20.h b/shared/test/common/mocks/mock_wddm_interface20.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 Intel Corporation
+ * Copyright (C) 2019-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,6 +20,11 @@ class WddmMockInterface20 : public WddmInterface20 {
         WddmInterface20::destroyMonitorFence(monitorFence);
     }
 
+    void destroyMonitorFence(D3DKMT_HANDLE fenceHandle) override {
+        destroyMonitorFenceCalled++;
+        WddmInterface::destroyMonitorFence(fenceHandle);
+    }
+
     bool createMonitoredFence(MonitoredFence &monitorFence) override {
         createMonitoredFenceCalled++;
         if (createMonitoredFenceCalledFail) {
@@ -28,6 +33,10 @@ class WddmMockInterface20 : public WddmInterface20 {
         return WddmInterface::createMonitoredFence(monitorFence);
     }
 
+    bool createMonitoredFenceForDirectSubmission(MonitoredFence &monitorFence, OsContextWin &osContext) override {
+        return createMonitoredFence(monitorFence);
+    };
+
     uint32_t destroyMonitorFenceCalled = 0;
     uint32_t createMonitoredFenceCalled = 0;
     bool createMonitoredFenceCalledFail = false;
diff --git a/shared/test/unit_test/os_interface/windows/wddm20_tests.cpp b/shared/test/unit_test/os_interface/windows/wddm20_tests.cpp
@@ -346,6 +346,14 @@ TEST_F(Wddm20WithMockGdiDllTests, GivenCpuValueDifferentThanGpuHangIndicationWhe
     EXPECT_FALSE(wddm->isGpuHangDetected(*osContext));
 }
 
+TEST_F(Wddm20WithMockGdiDllTests, whencreateMonitoredFenceForDirectSubmissionThenCreateFence) {
+    MonitoredFence fence{};
+    wddm->getWddmInterface()->createMonitoredFenceForDirectSubmission(fence, *osContext);
+    EXPECT_EQ(wddmMockInterface->createMonitoredFenceCalled, 1u);
+    EXPECT_NE(osContext->getHwQueue().progressFenceHandle, fence.fenceHandle);
+    wddm->getWddmInterface()->destroyMonitorFence(fence);
+}
+
 TEST_F(Wddm20WithMockGdiDllTests, GivenGpuHangIndicationWhenCheckingForGpuHangThenTrueIsReturned) {
     auto fenceCpuAddress = osContext->getResidencyController().getMonitoredFence().cpuAddress;
     VariableBackup<volatile uint64_t> backupWddmMonitorFence(fenceCpuAddress);
diff --git a/shared/test/unit_test/os_interface/windows/wddm23_tests.cpp b/shared/test/unit_test/os_interface/windows/wddm23_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2023 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -109,6 +109,14 @@ TEST_F(Wddm23Tests, whenObjectIsDestructedThenDestroyHwQueue) {
     EXPECT_EQ(hwQueue, getDestroyHwQueueDataFcn()->hHwQueue);
 }
 
+TEST_F(Wddm23Tests, whencreateMonitoredFenceForDirectSubmissionThenObtainHwQueueFenceAndReplaceResidencyControllerWithNewFence) {
+    EXPECT_EQ(osContext->getResidencyController().getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle);
+    MonitoredFence fence{};
+    wddm->getWddmInterface()->createMonitoredFenceForDirectSubmission(fence, *osContext);
+    EXPECT_EQ(osContext->getHwQueue().progressFenceHandle, fence.fenceHandle);
+    EXPECT_NE(osContext->getResidencyController().getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle);
+}
+
 TEST_F(Wddm23Tests, givenCmdBufferWhenSubmitCalledThenSetAllRequiredFiledsAndUpdateMonitoredFence) {
     uint64_t cmdBufferAddress = 123;
     size_t cmdSize = 456;
@@ -196,9 +204,9 @@ TEST_F(Wddm23Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhe
     EXPECT_EQ(1u, wddm->waitOnGPUResult.called);
 }
 
-TEST_F(Wddm23Tests, givenDestructionOsContextWinWhenCallingDestroyMonitorFenceThenDoNotCallGdiDestroy) {
+TEST_F(Wddm23Tests, givenDestructionOsContextWinWhenCallingDestroyMonitorFenceThenDoNotCallDestroy) {
     osContext.reset(nullptr);
-    EXPECT_EQ(1u, wddmMockInterface->destroyMonitorFenceCalled);
+    EXPECT_EQ(0u, wddmMockInterface->destroyMonitorFenceCalled);
     EXPECT_EQ(0u, getDestroySynchronizationObjectDataFcn()->hSyncObject);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,9 @@ bool OsContextWin::isDirectSubmissionSupported() const {`
`108`	`108`	`OsContextWin::~OsContextWin() {`
`109`	`109`	`if (contextInitialized && (false == this->wddm.skipResourceCleanup())) {`
`110`	`110`	`wddm.getWddmInterface()->destroyHwQueue(hardwareQueue.handle);`
`111`		`- wddm.getWddmInterface()->destroyMonitorFence(residencyController.getMonitoredFence());`
	`111`	`+ if (residencyController.getMonitoredFence().fenceHandle != hardwareQueue.progressFenceHandle) {`
	`112`	`+ wddm.getWddmInterface()->destroyMonitorFence(residencyController.getMonitoredFence().fenceHandle);`
	`113`	`+ }`
`112`	`114`	`wddm.destroyContext(wddmContextHandle);`
`113`	`115`	`}`
`114`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2018-2023 Intel Corporation`
	`2`	`+ * Copyright (C) 2018-2024 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -109,6 +109,14 @@ TEST_F(Wddm23Tests, whenObjectIsDestructedThenDestroyHwQueue) {`
`109`	`109`	`EXPECT_EQ(hwQueue, getDestroyHwQueueDataFcn()->hHwQueue);`
`110`	`110`	`}`
`111`	`111`
	`112`	`+TEST_F(Wddm23Tests, whencreateMonitoredFenceForDirectSubmissionThenObtainHwQueueFenceAndReplaceResidencyControllerWithNewFence) {`
	`113`	`+ EXPECT_EQ(osContext->getResidencyController().getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle);`
	`114`	`+ MonitoredFence fence{};`
	`115`	`+ wddm->getWddmInterface()->createMonitoredFenceForDirectSubmission(fence, *osContext);`
	`116`	`+ EXPECT_EQ(osContext->getHwQueue().progressFenceHandle, fence.fenceHandle);`
	`117`	`+ EXPECT_NE(osContext->getResidencyController().getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle);`
	`118`	`+}`
	`119`	`+`
`112`	`120`	`TEST_F(Wddm23Tests, givenCmdBufferWhenSubmitCalledThenSetAllRequiredFiledsAndUpdateMonitoredFence) {`
`113`	`121`	`uint64_t cmdBufferAddress = 123;`
`114`	`122`	`size_t cmdSize = 456;`
`@@ -196,9 +204,9 @@ TEST_F(Wddm23Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhe`
`196`	`204`	`EXPECT_EQ(1u, wddm->waitOnGPUResult.called);`
`197`	`205`	`}`
`198`	`206`
`199`		`-TEST_F(Wddm23Tests, givenDestructionOsContextWinWhenCallingDestroyMonitorFenceThenDoNotCallGdiDestroy) {`
	`207`	`+TEST_F(Wddm23Tests, givenDestructionOsContextWinWhenCallingDestroyMonitorFenceThenDoNotCallDestroy) {`
`200`	`208`	`osContext.reset(nullptr);`
`201`		`- EXPECT_EQ(1u, wddmMockInterface->destroyMonitorFenceCalled);`
	`209`	`+ EXPECT_EQ(0u, wddmMockInterface->destroyMonitorFenceCalled);`
`202`	`210`	`EXPECT_EQ(0u, getDestroySynchronizationObjectDataFcn()->hSyncObject);`
`203`	`211`	`}`
`204`	`212`