diff --git a/runtime/os_interface/windows/wddm/wddm.cpp b/runtime/os_interface/windows/wddm/wddm.cpp index 64f7344968..fa334610ac 100644 --- a/runtime/os_interface/windows/wddm/wddm.cpp +++ b/runtime/os_interface/windows/wddm/wddm.cpp @@ -636,41 +636,41 @@ bool Wddm::openNTHandle(HANDLE handle, WddmAllocation *alloc) { return true; } -void *Wddm::lockResource(WddmAllocation &wddmAllocation) { +void *Wddm::lockResource(const D3DKMT_HANDLE &handle, bool applyMakeResidentPriorToLock) { - if (wddmAllocation.needsMakeResidentBeforeLock) { - applyBlockingMakeResident(wddmAllocation); + if (applyMakeResidentPriorToLock) { + applyBlockingMakeResident(handle); } NTSTATUS status = STATUS_UNSUCCESSFUL; D3DKMT_LOCK2 lock2 = {}; - lock2.hAllocation = wddmAllocation.handle; + lock2.hAllocation = handle; lock2.hDevice = this->device; status = gdi->lock2(&lock2); DEBUG_BREAK_IF(status != STATUS_SUCCESS); - kmDafListener->notifyLock(featureTable->ftrKmdDaf, adapter, device, wddmAllocation.handle, 0, gdi->escape); + kmDafLock(handle); return lock2.pData; } -void Wddm::unlockResource(WddmAllocation &wddmAllocation) { +void Wddm::unlockResource(const D3DKMT_HANDLE &handle) { NTSTATUS status = STATUS_UNSUCCESSFUL; D3DKMT_UNLOCK2 unlock2 = {}; - unlock2.hAllocation = wddmAllocation.handle; + unlock2.hAllocation = handle; unlock2.hDevice = this->device; status = gdi->unlock2(&unlock2); DEBUG_BREAK_IF(status != STATUS_SUCCESS); - kmDafListener->notifyUnlock(featureTable->ftrKmdDaf, adapter, device, &wddmAllocation.handle, 1, gdi->escape); + kmDafListener->notifyUnlock(featureTable->ftrKmdDaf, adapter, device, &handle, 1, gdi->escape); } -void Wddm::kmDafLock(WddmAllocation *wddmAllocation) { - kmDafListener->notifyLock(featureTable->ftrKmdDaf, adapter, device, wddmAllocation->handle, 0, gdi->escape); +void Wddm::kmDafLock(D3DKMT_HANDLE handle) { + kmDafListener->notifyLock(featureTable->ftrKmdDaf, adapter, device, handle, 0, gdi->escape); } bool Wddm::createContext(OsContextWin &osContext) { @@ -970,27 +970,27 @@ EvictionStatus Wddm::evictAllTemporaryResources() { return error ? EvictionStatus::FAILED : EvictionStatus::SUCCESS; } -EvictionStatus Wddm::evictTemporaryResource(WddmAllocation &allocation) { +EvictionStatus Wddm::evictTemporaryResource(const D3DKMT_HANDLE &handle) { auto lock = acquireLock(temporaryResourcesLock); - auto position = std::find(temporaryResources.begin(), temporaryResources.end(), allocation.handle); + auto position = std::find(temporaryResources.begin(), temporaryResources.end(), handle); if (position == temporaryResources.end()) { return EvictionStatus::NOT_APPLIED; } *position = temporaryResources.back(); temporaryResources.pop_back(); uint64_t sizeToTrim = 0; - if (!evict(&allocation.handle, 1, sizeToTrim)) { + if (!evict(&handle, 1, sizeToTrim)) { return EvictionStatus::FAILED; } return EvictionStatus::SUCCESS; } -void Wddm::applyBlockingMakeResident(WddmAllocation &allocation) { +void Wddm::applyBlockingMakeResident(const D3DKMT_HANDLE &handle) { bool madeResident = false; - while (!(madeResident = makeResident(&allocation.handle, 1, false, nullptr))) { + while (!(madeResident = makeResident(&handle, 1, false, nullptr))) { if (evictAllTemporaryResources() == EvictionStatus::SUCCESS) { continue; } - if (!makeResident(&allocation.handle, 1, false, nullptr)) { + if (!makeResident(&handle, 1, false, nullptr)) { DEBUG_BREAK_IF(true); return; }; @@ -998,7 +998,7 @@ void Wddm::applyBlockingMakeResident(WddmAllocation &allocation) { } DEBUG_BREAK_IF(!madeResident); auto lock = acquireLock(temporaryResourcesLock); - temporaryResources.push_back(allocation.handle); + temporaryResources.push_back(handle); lock.unlock(); while (currentPagingFenceValue > *getPagingFenceAddress()) ; diff --git a/runtime/os_interface/windows/wddm/wddm.h b/runtime/os_interface/windows/wddm/wddm.h index 4ccb7d2636..2d555adf1b 100644 --- a/runtime/os_interface/windows/wddm/wddm.h +++ b/runtime/os_interface/windows/wddm/wddm.h @@ -69,9 +69,9 @@ class Wddm { MOCKABLE_VIRTUAL bool destroyAllocations(const D3DKMT_HANDLE *handles, uint32_t allocationCount, D3DKMT_HANDLE resourceHandle); MOCKABLE_VIRTUAL bool openSharedHandle(D3DKMT_HANDLE handle, WddmAllocation *alloc); bool openNTHandle(HANDLE handle, WddmAllocation *alloc); - MOCKABLE_VIRTUAL void *lockResource(WddmAllocation &wddmAllocation); - MOCKABLE_VIRTUAL void unlockResource(WddmAllocation &wddmAllocation); - MOCKABLE_VIRTUAL void kmDafLock(WddmAllocation *wddmAllocation); + MOCKABLE_VIRTUAL void *lockResource(const D3DKMT_HANDLE &handle, bool applyMakeResidentPriorToLock); + MOCKABLE_VIRTUAL void unlockResource(const D3DKMT_HANDLE &handle); + MOCKABLE_VIRTUAL void kmDafLock(D3DKMT_HANDLE handle); MOCKABLE_VIRTUAL bool isKmDafEnabled() const { return featureTable->ftrKmdDaf; } MOCKABLE_VIRTUAL bool destroyContext(D3DKMT_HANDLE context); @@ -147,8 +147,8 @@ class Wddm { return pagingFenceAddress; } MOCKABLE_VIRTUAL EvictionStatus evictAllTemporaryResources(); - MOCKABLE_VIRTUAL EvictionStatus evictTemporaryResource(WddmAllocation &allocation); - MOCKABLE_VIRTUAL void applyBlockingMakeResident(WddmAllocation &allocation); + MOCKABLE_VIRTUAL EvictionStatus evictTemporaryResource(const D3DKMT_HANDLE &handle); + MOCKABLE_VIRTUAL void applyBlockingMakeResident(const D3DKMT_HANDLE &handle); MOCKABLE_VIRTUAL std::unique_lock acquireLock(SpinLock &lock); protected: diff --git a/runtime/os_interface/windows/wddm_device_command_stream.inl b/runtime/os_interface/windows/wddm_device_command_stream.inl index 6f677805f2..1e0ab69222 100644 --- a/runtime/os_interface/windows/wddm_device_command_stream.inl +++ b/runtime/os_interface/windows/wddm_device_command_stream.inl @@ -197,7 +197,7 @@ void WddmCommandStreamReceiver::kmDafLockAllocations(ResidencyContain if ((GraphicsAllocation::AllocationType::LINEAR_STREAM == graphicsAllocation->getAllocationType()) || (GraphicsAllocation::AllocationType::FILL_PATTERN == graphicsAllocation->getAllocationType()) || (GraphicsAllocation::AllocationType::COMMAND_BUFFER == graphicsAllocation->getAllocationType())) { - wddm->kmDafLock(static_cast(graphicsAllocation)); + wddm->kmDafLock(static_cast(graphicsAllocation)->handle); } } } diff --git a/runtime/os_interface/windows/wddm_memory_manager.cpp b/runtime/os_interface/windows/wddm_memory_manager.cpp index 091a4fb348..bc5b2d064f 100644 --- a/runtime/os_interface/windows/wddm_memory_manager.cpp +++ b/runtime/os_interface/windows/wddm_memory_manager.cpp @@ -276,13 +276,14 @@ void WddmMemoryManager::removeAllocationFromHostPtrManager(GraphicsAllocation *g } void *WddmMemoryManager::lockResourceImpl(GraphicsAllocation &graphicsAllocation) { - return wddm->lockResource(static_cast(graphicsAllocation)); + auto &wddmAllocation = static_cast(graphicsAllocation); + return wddm->lockResource(wddmAllocation.handle, wddmAllocation.needsMakeResidentBeforeLock); } void WddmMemoryManager::unlockResourceImpl(GraphicsAllocation &graphicsAllocation) { auto &wddmAllocation = static_cast(graphicsAllocation); - wddm->unlockResource(wddmAllocation); + wddm->unlockResource(wddmAllocation.handle); if (wddmAllocation.needsMakeResidentBeforeLock) { - auto evictionStatus = wddm->evictTemporaryResource(wddmAllocation); + auto evictionStatus = wddm->evictTemporaryResource(wddmAllocation.handle); DEBUG_BREAK_IF(evictionStatus == EvictionStatus::FAILED); } } diff --git a/unit_tests/mocks/mock_wddm.cpp b/unit_tests/mocks/mock_wddm.cpp index e46c8ec802..f62b213114 100644 --- a/unit_tests/mocks/mock_wddm.cpp +++ b/unit_tests/mocks/mock_wddm.cpp @@ -146,24 +146,25 @@ bool WddmMock::waitOnGPU(D3DKMT_HANDLE context) { return waitOnGPUResult.success = Wddm::waitOnGPU(context); } -void *WddmMock::lockResource(WddmAllocation &allocation) { +void *WddmMock::lockResource(const D3DKMT_HANDLE &handle, bool applyMakeResidentPriorToLock) { lockResult.called++; - auto ptr = Wddm::lockResource(allocation); + auto ptr = Wddm::lockResource(handle, applyMakeResidentPriorToLock); lockResult.success = ptr != nullptr; + lockResult.uint64ParamPassed = applyMakeResidentPriorToLock; return ptr; } -void WddmMock::unlockResource(WddmAllocation &allocation) { +void WddmMock::unlockResource(const D3DKMT_HANDLE &handle) { unlockResult.called++; unlockResult.success = true; - Wddm::unlockResource(allocation); + Wddm::unlockResource(handle); } -void WddmMock::kmDafLock(WddmAllocation *allocation) { +void WddmMock::kmDafLock(D3DKMT_HANDLE handle) { kmDafLockResult.called++; kmDafLockResult.success = true; - kmDafLockResult.lockedAllocations.push_back(allocation); - Wddm::kmDafLock(allocation); + kmDafLockResult.lockedAllocations.push_back(handle); + Wddm::kmDafLock(handle); } bool WddmMock::isKmDafEnabled() const { @@ -242,15 +243,15 @@ EvictionStatus WddmMock::evictAllTemporaryResources() { return evictAllTemporaryResourcesResult.status; } -EvictionStatus WddmMock::evictTemporaryResource(WddmAllocation &allocation) { +EvictionStatus WddmMock::evictTemporaryResource(const D3DKMT_HANDLE &handle) { evictTemporaryResourceResult.called++; - evictTemporaryResourceResult.status = Wddm::evictTemporaryResource(allocation); + evictTemporaryResourceResult.status = Wddm::evictTemporaryResource(handle); return evictTemporaryResourceResult.status; } -void WddmMock::applyBlockingMakeResident(WddmAllocation &allocation) { +void WddmMock::applyBlockingMakeResident(const D3DKMT_HANDLE &handle) { applyBlockingMakeResidentResult.called++; - return Wddm::applyBlockingMakeResident(allocation); + return Wddm::applyBlockingMakeResident(handle); } std::unique_lock WddmMock::acquireLock(SpinLock &lock) { diff --git a/unit_tests/mocks/mock_wddm.h b/unit_tests/mocks/mock_wddm.h index 55aab2ce09..56d309d38f 100644 --- a/unit_tests/mocks/mock_wddm.h +++ b/unit_tests/mocks/mock_wddm.h @@ -36,7 +36,7 @@ struct EvictCallResult : public CallResult { EvictionStatus status = EvictionStatus::UNKNOWN; }; struct KmDafLockCall : public CallResult { - std::vector lockedAllocations; + std::vector lockedAllocations; }; } // namespace WddmMockHelpers @@ -76,9 +76,9 @@ class WddmMock : public Wddm { bool queryAdapterInfo() override; bool submit(uint64_t commandBuffer, size_t size, void *commandHeader, OsContextWin &osContext) override; bool waitOnGPU(D3DKMT_HANDLE context) override; - void *lockResource(WddmAllocation &allocation) override; - void unlockResource(WddmAllocation &allocation) override; - void kmDafLock(WddmAllocation *allocation) override; + void *lockResource(const D3DKMT_HANDLE &handle, bool applyMakeResidentPriorToLock) override; + void unlockResource(const D3DKMT_HANDLE &handle) override; + void kmDafLock(D3DKMT_HANDLE handle) override; bool isKmDafEnabled() const override; void setKmDafEnabled(bool state); void setHwContextId(unsigned long hwContextId); @@ -91,8 +91,8 @@ class WddmMock : public Wddm { void releaseReservedAddress(void *reservedAddress) override; VOID *registerTrimCallback(PFND3DKMT_TRIMNOTIFICATIONCALLBACK callback, WddmResidencyController &residencyController) override; EvictionStatus evictAllTemporaryResources() override; - EvictionStatus evictTemporaryResource(WddmAllocation &allocation) override; - void applyBlockingMakeResident(WddmAllocation &allocation) override; + EvictionStatus evictTemporaryResource(const D3DKMT_HANDLE &handle) override; + void applyBlockingMakeResident(const D3DKMT_HANDLE &handle) override; std::unique_lock acquireLock(SpinLock &lock) override; bool reserveValidAddressRange(size_t size, void *&reservedMem); GmmMemory *getGmmMemory() const; diff --git a/unit_tests/os_interface/windows/device_command_stream_tests.cpp b/unit_tests/os_interface/windows/device_command_stream_tests.cpp index 30bea71813..f51fe8412d 100644 --- a/unit_tests/os_interface/windows/device_command_stream_tests.cpp +++ b/unit_tests/os_interface/windows/device_command_stream_tests.cpp @@ -404,7 +404,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithResi LinearStream cs(commandBuffer); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; - auto linearStreamAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); + auto linearStreamAllocation = static_cast(memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize})); ASSERT_NE(nullptr, linearStreamAllocation); linearStreamAllocation->setAllocationType(GraphicsAllocation::AllocationType::LINEAR_STREAM); @@ -417,7 +417,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithResi EXPECT_EQ(1u, wddm->kmDafLockResult.called); EXPECT_EQ(1u, wddm->kmDafLockResult.lockedAllocations.size()); - EXPECT_EQ(linearStreamAllocation, wddm->kmDafLockResult.lockedAllocations[0]); + EXPECT_EQ(linearStreamAllocation->handle, wddm->kmDafLockResult.lockedAllocations[0]); memoryManager->freeGraphicsMemory(commandBuffer); memoryManager->freeGraphicsMemory(linearStreamAllocation); @@ -429,7 +429,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithAllo LinearStream cs(commandBuffer); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; - auto linearStreamAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); + auto linearStreamAllocation = static_cast(memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize})); ASSERT_NE(nullptr, linearStreamAllocation); linearStreamAllocation->setAllocationType(GraphicsAllocation::AllocationType::LINEAR_STREAM); ResidencyContainer allocationsForResidency = {linearStreamAllocation}; @@ -439,7 +439,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithAllo EXPECT_EQ(1u, wddm->kmDafLockResult.called); EXPECT_EQ(1u, wddm->kmDafLockResult.lockedAllocations.size()); - EXPECT_EQ(linearStreamAllocation, wddm->kmDafLockResult.lockedAllocations[0]); + EXPECT_EQ(linearStreamAllocation->handle, wddm->kmDafLockResult.lockedAllocations[0]); memoryManager->freeGraphicsMemory(commandBuffer); memoryManager->freeGraphicsMemory(linearStreamAllocation); @@ -451,7 +451,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithAllo LinearStream cs(commandBuffer); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; - auto fillPatternAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); + auto fillPatternAllocation = static_cast(memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize})); ASSERT_NE(nullptr, fillPatternAllocation); fillPatternAllocation->setAllocationType(GraphicsAllocation::AllocationType::FILL_PATTERN); ResidencyContainer allocationsForResidency = {fillPatternAllocation}; @@ -461,7 +461,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithAllo EXPECT_EQ(1u, wddm->kmDafLockResult.called); EXPECT_EQ(1u, wddm->kmDafLockResult.lockedAllocations.size()); - EXPECT_EQ(fillPatternAllocation, wddm->kmDafLockResult.lockedAllocations[0]); + EXPECT_EQ(fillPatternAllocation->handle, wddm->kmDafLockResult.lockedAllocations[0]); memoryManager->freeGraphicsMemory(commandBuffer); memoryManager->freeGraphicsMemory(fillPatternAllocation); @@ -473,7 +473,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithAllo LinearStream cs(commandBuffer); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; - auto commandBufferAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); + auto commandBufferAllocation = static_cast(memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize})); ASSERT_NE(nullptr, commandBufferAllocation); commandBufferAllocation->setAllocationType(GraphicsAllocation::AllocationType::COMMAND_BUFFER); ResidencyContainer allocationsForResidency = {commandBufferAllocation}; @@ -483,7 +483,7 @@ TEST_F(WddmCommandStreamTest, givenWddmWithKmDafEnabledWhenFlushIsCalledWithAllo EXPECT_EQ(1u, wddm->kmDafLockResult.called); EXPECT_EQ(1u, wddm->kmDafLockResult.lockedAllocations.size()); - EXPECT_EQ(commandBufferAllocation, wddm->kmDafLockResult.lockedAllocations[0]); + EXPECT_EQ(commandBufferAllocation->handle, wddm->kmDafLockResult.lockedAllocations[0]); memoryManager->freeGraphicsMemory(commandBuffer); memoryManager->freeGraphicsMemory(commandBufferAllocation); diff --git a/unit_tests/os_interface/windows/wddm20_tests.cpp b/unit_tests/os_interface/windows/wddm20_tests.cpp index 2752a527dd..8b32b07779 100644 --- a/unit_tests/os_interface/windows/wddm20_tests.cpp +++ b/unit_tests/os_interface/windows/wddm20_tests.cpp @@ -21,6 +21,7 @@ #include "runtime/os_interface/windows/wddm_memory_manager.h" #include "unit_tests/helpers/debug_manager_state_restore.h" #include "unit_tests/mocks/mock_gmm_resource_info.h" +#include "unit_tests/os_interface/windows/mock_wddm_allocation.h" #include "unit_tests/os_interface/windows/wddm_fixture.h" #include "gtest/gtest.h" @@ -835,60 +836,55 @@ TEST_F(Wddm20Tests, givenNullTrimCallbackHandleWhenUnregisteringTrimCallbackThen EXPECT_EQ(trimCallbackHandleBefore, gdi->getUnregisterTrimNotificationArg().Handle); } -TEST_F(Wddm20Tests, givenAllocationThatDoesntNeedMakeResidentBeforeLockWhenLockThenDontStoreItOrCallMakeResident) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - EXPECT_FALSE(allocation.needsMakeResidentBeforeLock); +using WddmLockWithMakeResidentTests = Wddm20Tests; + +TEST_F(WddmLockWithMakeResidentTests, givenAllocationThatDoesntNeedMakeResidentBeforeLockWhenLockThenDontStoreItOrCallMakeResident) { EXPECT_TRUE(wddm->temporaryResources.empty()); EXPECT_EQ(0u, wddm->makeResidentResult.called); - wddm->lockResource(allocation); + wddm->lockResource(ALLOCATION_HANDLE, false); EXPECT_TRUE(wddm->temporaryResources.empty()); EXPECT_EQ(0u, wddm->makeResidentResult.called); - wddm->unlockResource(allocation); + wddm->unlockResource(ALLOCATION_HANDLE); } -TEST_F(Wddm20Tests, givenAllocationThatNeedsMakeResidentBeforeLockWhenLockThenCallBlockingMakeResident) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - allocation.needsMakeResidentBeforeLock = true; - wddm->lockResource(allocation); +TEST_F(WddmLockWithMakeResidentTests, givenAllocationThatNeedsMakeResidentBeforeLockWhenLockThenCallBlockingMakeResident) { + wddm->lockResource(ALLOCATION_HANDLE, true); EXPECT_EQ(1u, wddm->applyBlockingMakeResidentResult.called); } -TEST_F(Wddm20Tests, givenAllocationWhenApplyBlockingMakeResidentThenAcquireUniqueLock) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - wddm->applyBlockingMakeResident(allocation); +TEST_F(WddmLockWithMakeResidentTests, givenAllocationWhenApplyBlockingMakeResidentThenAcquireUniqueLock) { + wddm->applyBlockingMakeResident(ALLOCATION_HANDLE); EXPECT_EQ(1u, wddm->acquireLockResult.called); EXPECT_EQ(reinterpret_cast(&wddm->temporaryResourcesLock), wddm->acquireLockResult.uint64ParamPassed); } -TEST_F(Wddm20Tests, givenAllocationWhenApplyBlockingMakeResidentThenCallMakeResidentAndStoreAllocation) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - wddm->applyBlockingMakeResident(allocation); +TEST_F(WddmLockWithMakeResidentTests, givenAllocationWhenApplyBlockingMakeResidentThenCallMakeResidentAndStoreAllocation) { + wddm->applyBlockingMakeResident(ALLOCATION_HANDLE); EXPECT_EQ(1u, wddm->makeResidentResult.called); - EXPECT_EQ(allocation.handle, wddm->temporaryResources.back()); + EXPECT_EQ(ALLOCATION_HANDLE, wddm->temporaryResources.back()); } -TEST_F(Wddm20Tests, givenAllocationWhenApplyBlockingMakeResidentThenWaitForCurrentPagingFenceValue) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; +TEST_F(WddmLockWithMakeResidentTests, givenAllocationWhenApplyBlockingMakeResidentThenWaitForCurrentPagingFenceValue) { wddm->mockPagingFence = 0u; wddm->currentPagingFenceValue = 3u; - wddm->applyBlockingMakeResident(allocation); + wddm->applyBlockingMakeResident(ALLOCATION_HANDLE); EXPECT_EQ(1u, wddm->makeResidentResult.called); EXPECT_EQ(3u, wddm->mockPagingFence); EXPECT_EQ(3u, wddm->getPagingFenceAddressResult.called); } -TEST_F(Wddm20Tests, givenAllocationWhenApplyBlockingMakeResidentAndMakeResidentCallFailsThenEvictTemporaryResourcesAndRetry) { +TEST_F(WddmLockWithMakeResidentTests, givenAllocationWhenApplyBlockingMakeResidentAndMakeResidentCallFailsThenEvictTemporaryResourcesAndRetry) { WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; GmockWddm gmockWddm; EXPECT_CALL(gmockWddm, makeResident(&allocation.handle, ::testing::_, ::testing::_, ::testing::_)).Times(2).WillRepeatedly(::testing::Return(false)); - gmockWddm.applyBlockingMakeResident(allocation); + gmockWddm.applyBlockingMakeResident(allocation.handle); EXPECT_EQ(1u, gmockWddm.evictAllTemporaryResourcesResult.called); } -TEST_F(Wddm20Tests, whenApplyBlockingMakeResidentAndTemporaryResourcesAreEvictedSuccessfullyThenCallMakeResidentOneMoreTime) { +TEST_F(WddmLockWithMakeResidentTests, whenApplyBlockingMakeResidentAndTemporaryResourcesAreEvictedSuccessfullyThenCallMakeResidentOneMoreTime) { WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; GmockWddm gmockWddm; gmockWddm.temporaryResources.push_back(allocation.handle); EXPECT_CALL(gmockWddm, evict(::testing::_, ::testing::_, ::testing::_)).Times(1).WillRepeatedly(::testing::Return(true)); EXPECT_CALL(gmockWddm, makeResident(&allocation.handle, ::testing::_, ::testing::_, ::testing::_)).Times(3).WillRepeatedly(::testing::Return(false)); - gmockWddm.applyBlockingMakeResident(allocation); + gmockWddm.applyBlockingMakeResident(allocation.handle); EXPECT_EQ(2u, gmockWddm.evictAllTemporaryResourcesResult.called); } -TEST_F(Wddm20Tests, whenApplyBlockingMakeResidentAndMakeResidentStillFailsThenDontStoreTemporaryResource) { +TEST_F(WddmLockWithMakeResidentTests, whenApplyBlockingMakeResidentAndMakeResidentStillFailsThenDontStoreTemporaryResource) { WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; allocation.handle = 0x2; GmockWddm gmockWddm; @@ -896,10 +892,10 @@ TEST_F(Wddm20Tests, whenApplyBlockingMakeResidentAndMakeResidentStillFailsThenDo EXPECT_CALL(gmockWddm, evict(::testing::_, ::testing::_, ::testing::_)).Times(1).WillRepeatedly(::testing::Return(true)); EXPECT_CALL(gmockWddm, makeResident(&allocation.handle, ::testing::_, ::testing::_, ::testing::_)).Times(3).WillRepeatedly(::testing::Return(false)); EXPECT_EQ(1u, gmockWddm.temporaryResources.size()); - gmockWddm.applyBlockingMakeResident(allocation); + gmockWddm.applyBlockingMakeResident(allocation.handle); EXPECT_EQ(0u, gmockWddm.temporaryResources.size()); } -TEST_F(Wddm20Tests, whenApplyBlockingMakeResidentAndMakeResidentPassesAfterEvictThenStoreTemporaryResource) { +TEST_F(WddmLockWithMakeResidentTests, whenApplyBlockingMakeResidentAndMakeResidentPassesAfterEvictThenStoreTemporaryResource) { WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; allocation.handle = 0x2; GmockWddm gmockWddm; @@ -907,30 +903,30 @@ TEST_F(Wddm20Tests, whenApplyBlockingMakeResidentAndMakeResidentPassesAfterEvict EXPECT_CALL(gmockWddm, evict(::testing::_, ::testing::_, ::testing::_)).Times(1).WillRepeatedly(::testing::Return(true)); EXPECT_CALL(gmockWddm, makeResident(&allocation.handle, ::testing::_, ::testing::_, ::testing::_)).Times(2).WillOnce(::testing::Return(false)).WillOnce(::testing::Return(true)); EXPECT_EQ(1u, gmockWddm.temporaryResources.size()); - gmockWddm.applyBlockingMakeResident(allocation); + gmockWddm.applyBlockingMakeResident(allocation.handle); EXPECT_EQ(1u, gmockWddm.temporaryResources.size()); EXPECT_EQ(0x2, gmockWddm.temporaryResources.back()); } -TEST_F(Wddm20Tests, whenApplyBlockingMakeResidentAndMakeResidentPassesThenStoreTemporaryResource) { +TEST_F(WddmLockWithMakeResidentTests, whenApplyBlockingMakeResidentAndMakeResidentPassesThenStoreTemporaryResource) { WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; allocation.handle = 0x2; GmockWddm gmockWddm; gmockWddm.temporaryResources.push_back(0x1); EXPECT_CALL(gmockWddm, makeResident(&allocation.handle, ::testing::_, ::testing::_, ::testing::_)).Times(1).WillOnce(::testing::Return(true)); - gmockWddm.applyBlockingMakeResident(allocation); + gmockWddm.applyBlockingMakeResident(allocation.handle); EXPECT_EQ(2u, gmockWddm.temporaryResources.size()); EXPECT_EQ(0x2, gmockWddm.temporaryResources.back()); } -TEST_F(Wddm20Tests, givenNoTemporaryResourcesWhenEvictingAllTemporaryResourcesThenEvictionIsNotApplied) { +TEST_F(WddmLockWithMakeResidentTests, givenNoTemporaryResourcesWhenEvictingAllTemporaryResourcesThenEvictionIsNotApplied) { wddm->evictAllTemporaryResources(); EXPECT_EQ(EvictionStatus::NOT_APPLIED, wddm->evictAllTemporaryResourcesResult.status); } -TEST_F(Wddm20Tests, whenEvictingAllTemporaryResourcesThenAcquireTemporaryResourcesLock) { +TEST_F(WddmLockWithMakeResidentTests, whenEvictingAllTemporaryResourcesThenAcquireTemporaryResourcesLock) { wddm->evictAllTemporaryResources(); EXPECT_EQ(1u, wddm->acquireLockResult.called); EXPECT_EQ(reinterpret_cast(&wddm->temporaryResourcesLock), wddm->acquireLockResult.uint64ParamPassed); } -TEST_F(Wddm20Tests, whenEvictingAllTemporaryResourcesAndAllEvictionsSucceedThenReturnSuccess) { +TEST_F(WddmLockWithMakeResidentTests, whenEvictingAllTemporaryResourcesAndAllEvictionsSucceedThenReturnSuccess) { WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; GmockWddm gmockWddm; gmockWddm.temporaryResources.push_back(allocation.handle); @@ -939,7 +935,7 @@ TEST_F(Wddm20Tests, whenEvictingAllTemporaryResourcesAndAllEvictionsSucceedThenR EXPECT_EQ(1u, gmockWddm.evictAllTemporaryResourcesResult.called); EXPECT_EQ(EvictionStatus::SUCCESS, gmockWddm.evictAllTemporaryResourcesResult.status); } -TEST_F(Wddm20Tests, givenThreeAllocationsWhenEvictingAllTemporaryResourcesThenCallEvictForEachAllocationAndCleanList) { +TEST_F(WddmLockWithMakeResidentTests, givenThreeAllocationsWhenEvictingAllTemporaryResourcesThenCallEvictForEachAllocationAndCleanList) { GmockWddm gmockWddm; constexpr uint32_t numAllocations = 3u; for (auto i = 0u; i < numAllocations; i++) { @@ -949,7 +945,7 @@ TEST_F(Wddm20Tests, givenThreeAllocationsWhenEvictingAllTemporaryResourcesThenCa gmockWddm.evictAllTemporaryResources(); EXPECT_TRUE(gmockWddm.temporaryResources.empty()); } -TEST_F(Wddm20Tests, givenThreeAllocationsWhenEvictingAllTemporaryResourcesAndOneOfThemFailsThenReturnFail) { +TEST_F(WddmLockWithMakeResidentTests, givenThreeAllocationsWhenEvictingAllTemporaryResourcesAndOneOfThemFailsThenReturnFail) { GmockWddm gmockWddm; constexpr uint32_t numAllocations = 3u; for (auto i = 0u; i < numAllocations; i++) { @@ -959,58 +955,66 @@ TEST_F(Wddm20Tests, givenThreeAllocationsWhenEvictingAllTemporaryResourcesAndOne gmockWddm.evictAllTemporaryResources(); EXPECT_EQ(EvictionStatus::FAILED, gmockWddm.evictAllTemporaryResourcesResult.status); } -TEST_F(Wddm20Tests, givenNoTemporaryResourcesWhenEvictingTemporaryResourceThenEvictionIsNotApplied) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - wddm->evictTemporaryResource(allocation); +TEST_F(WddmLockWithMakeResidentTests, givenNoTemporaryResourcesWhenEvictingTemporaryResourceThenEvictionIsNotApplied) { + wddm->evictTemporaryResource(ALLOCATION_HANDLE); EXPECT_EQ(EvictionStatus::NOT_APPLIED, wddm->evictTemporaryResourceResult.status); } -TEST_F(Wddm20Tests, whenEvictingTemporaryResourceThenAcquireTemporaryResourcesLock) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - wddm->evictTemporaryResource(allocation); +TEST_F(WddmLockWithMakeResidentTests, whenEvictingTemporaryResourceThenAcquireTemporaryResourcesLock) { + wddm->evictTemporaryResource(ALLOCATION_HANDLE); EXPECT_EQ(1u, wddm->acquireLockResult.called); EXPECT_EQ(reinterpret_cast(&wddm->temporaryResourcesLock), wddm->acquireLockResult.uint64ParamPassed); } -TEST_F(Wddm20Tests, whenEvictingNonExistingTemporaryResourceThenEvictIsNotAppliedAndTemporaryResourcesAreRestored) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - allocation.handle = 0x1; - wddm->temporaryResources.push_back(0x2); +TEST_F(WddmLockWithMakeResidentTests, whenEvictingNonExistingTemporaryResourceThenEvictIsNotAppliedAndTemporaryResourcesAreRestored) { + wddm->temporaryResources.push_back(ALLOCATION_HANDLE); EXPECT_FALSE(wddm->temporaryResources.empty()); - wddm->evictTemporaryResource(allocation); + wddm->evictTemporaryResource(ALLOCATION_HANDLE + 1); EXPECT_FALSE(wddm->temporaryResources.empty()); EXPECT_EQ(EvictionStatus::NOT_APPLIED, wddm->evictTemporaryResourceResult.status); } -TEST_F(Wddm20Tests, whenEvictingTemporaryResourceAndEvictFailsThenReturnFail) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; +TEST_F(WddmLockWithMakeResidentTests, whenEvictingTemporaryResourceAndEvictFailsThenReturnFail) { GmockWddm gmockWddm; - gmockWddm.temporaryResources.push_back(allocation.handle); + gmockWddm.temporaryResources.push_back(ALLOCATION_HANDLE); EXPECT_CALL(gmockWddm, evict(::testing::_, ::testing::_, ::testing::_)).Times(1).WillOnce(::testing::Return(false)); - gmockWddm.evictTemporaryResource(allocation); + gmockWddm.evictTemporaryResource(ALLOCATION_HANDLE); EXPECT_TRUE(gmockWddm.temporaryResources.empty()); EXPECT_EQ(EvictionStatus::FAILED, gmockWddm.evictTemporaryResourceResult.status); } -TEST_F(Wddm20Tests, whenEvictingTemporaryResourceAndEvictSucceedThenReturnSuccess) { - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; +TEST_F(WddmLockWithMakeResidentTests, whenEvictingTemporaryResourceAndEvictSucceedThenReturnSuccess) { GmockWddm gmockWddm; - gmockWddm.temporaryResources.push_back(allocation.handle); + gmockWddm.temporaryResources.push_back(ALLOCATION_HANDLE); EXPECT_CALL(gmockWddm, evict(::testing::_, ::testing::_, ::testing::_)).Times(1).WillOnce(::testing::Return(true)); - gmockWddm.evictTemporaryResource(allocation); + gmockWddm.evictTemporaryResource(ALLOCATION_HANDLE); EXPECT_TRUE(gmockWddm.temporaryResources.empty()); EXPECT_EQ(EvictionStatus::SUCCESS, gmockWddm.evictTemporaryResourceResult.status); } -TEST_F(Wddm20Tests, whenEvictingTemporaryResourceThenOtherResourcesRemainOnTheList) { +TEST_F(WddmLockWithMakeResidentTests, whenEvictingTemporaryResourceThenOtherResourcesRemainOnTheList) { wddm->temporaryResources.push_back(0x1); wddm->temporaryResources.push_back(0x2); wddm->temporaryResources.push_back(0x3); - WddmAllocation allocation{GraphicsAllocation::AllocationType::UNDECIDED, nullptr, 0, nullptr, MemoryPool::MemoryNull, false}; - allocation.handle = 0x2; - wddm->evictTemporaryResource(allocation); + wddm->evictTemporaryResource(0x2); EXPECT_EQ(2u, wddm->temporaryResources.size()); EXPECT_EQ(0x1, wddm->temporaryResources.front()); EXPECT_EQ(0x3, wddm->temporaryResources.back()); } +TEST_F(WddmLockWithMakeResidentTests, whenAlllocationNeedsBlockingMakeResidentBeforeLockThenLockWithBlockingMakeResident) { + WddmMemoryManager memoryManager(false, false, wddm, executionEnvironment); + MockWddmAllocation allocation; + allocation.needsMakeResidentBeforeLock = false; + memoryManager.lockResource(&allocation); + EXPECT_EQ(1u, wddm->lockResult.called); + EXPECT_EQ(0u, wddm->lockResult.uint64ParamPassed); + memoryManager.unlockResource(&allocation); + + allocation.needsMakeResidentBeforeLock = true; + memoryManager.lockResource(&allocation); + EXPECT_EQ(2u, wddm->lockResult.called); + EXPECT_EQ(1u, wddm->lockResult.uint64ParamPassed); + memoryManager.unlockResource(&allocation); +} + TEST(WddmInternalHeapTest, whenConfigurationIs64BitThenInternalHeapIndexIsHeapInternalDeviceMemory) { if (is64bit) { EXPECT_EQ(HeapIndex::HEAP_INTERNAL_DEVICE_MEMORY, internalHeapIndex); diff --git a/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp b/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp index dcad0e2a1d..5a78c78df2 100644 --- a/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp +++ b/unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp @@ -52,29 +52,23 @@ class WddmKmDafListenerTest : public GmmEnvironmentFixture, public ::testing::Te }; TEST_F(WddmKmDafListenerTest, givenWddmWhenLockResourceIsCalledThenKmDafListenerNotifyLockIsFedWithCorrectParams) { - MockWddmAllocation allocation; - allocation.handle = ALLOCATION_HANDLE; - - wddmWithKmDafMock->lockResource(allocation); + wddmWithKmDafMock->lockResource(ALLOCATION_HANDLE, false); EXPECT_EQ(wddmWithKmDafMock->featureTable->ftrKmdDaf, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.ftrKmdDaf); EXPECT_EQ(wddmWithKmDafMock->getAdapter(), wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hAdapter); EXPECT_EQ(wddmWithKmDafMock->getDevice(), wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hDevice); - EXPECT_EQ(allocation.handle, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hAllocation); + EXPECT_EQ(ALLOCATION_HANDLE, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hAllocation); EXPECT_EQ(0, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.pLockFlags); EXPECT_EQ(wddmWithKmDafMock->getGdi()->escape, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.pfnEscape); } TEST_F(WddmKmDafListenerTest, givenWddmWhenUnlockResourceIsCalledThenKmDafListenerNotifyUnlockIsFedWithCorrectParams) { - MockWddmAllocation allocation; - allocation.handle = ALLOCATION_HANDLE; - - wddmWithKmDafMock->unlockResource(allocation); + wddmWithKmDafMock->unlockResource(ALLOCATION_HANDLE); EXPECT_EQ(wddmWithKmDafMock->featureTable->ftrKmdDaf, wddmWithKmDafMock->getKmDafListenerMock().notifyUnlockParametrization.ftrKmdDaf); EXPECT_EQ(wddmWithKmDafMock->getAdapter(), wddmWithKmDafMock->getKmDafListenerMock().notifyUnlockParametrization.hAdapter); EXPECT_EQ(wddmWithKmDafMock->getDevice(), wddmWithKmDafMock->getKmDafListenerMock().notifyUnlockParametrization.hDevice); - EXPECT_EQ(allocation.handle, *wddmWithKmDafMock->getKmDafListenerMock().notifyUnlockParametrization.phAllocation); + EXPECT_EQ(ALLOCATION_HANDLE, *wddmWithKmDafMock->getKmDafListenerMock().notifyUnlockParametrization.phAllocation); EXPECT_EQ(1u, wddmWithKmDafMock->getKmDafListenerMock().notifyUnlockParametrization.allocations); EXPECT_EQ(wddmWithKmDafMock->getGdi()->escape, wddmWithKmDafMock->getKmDafListenerMock().notifyUnlockParametrization.pfnEscape); } @@ -190,15 +184,12 @@ TEST_F(WddmKmDafListenerTest, givenWddmWhenCreateAllocationsAndMapGpuVaIsCalledT } TEST_F(WddmKmDafListenerTest, givenWddmWhenKmDafLockIsCalledThenKmDafListenerNotifyLockIsFedWithCorrectParams) { - MockWddmAllocation allocation; - allocation.handle = ALLOCATION_HANDLE; - - wddmWithKmDafMock->kmDafLock(&allocation); + wddmWithKmDafMock->kmDafLock(ALLOCATION_HANDLE); EXPECT_EQ(wddmWithKmDafMock->featureTable->ftrKmdDaf, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.ftrKmdDaf); EXPECT_EQ(wddmWithKmDafMock->getAdapter(), wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hAdapter); EXPECT_EQ(wddmWithKmDafMock->getDevice(), wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hDevice); - EXPECT_EQ(allocation.handle, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hAllocation); + EXPECT_EQ(ALLOCATION_HANDLE, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.hAllocation); EXPECT_EQ(0, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.pLockFlags); EXPECT_EQ(wddmWithKmDafMock->getGdi()->escape, wddmWithKmDafMock->getKmDafListenerMock().notifyLockParametrization.pfnEscape); }