intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-06 19:32:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Move monitor fence to os context win

Browse Source 
Related-To: NEO-13315

Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk
2025-10-15 09:21:43 +00:00
committed by Compute-Runtime-Automation
parent dd252e7852
commit f1f13f05e2
19 changed files with 199 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
shared/source/direct_submission/windows/wddm_direct_submission.inl
View File

@@ -150,7 +150,7 @@ uint64_t WddmDirectSubmission<GfxFamily, Dispatcher>::updateTagValue(bool requir
if (requireMonitorFence) { if (requireMonitorFence) {
return this->updateTagValueImpl(this->currentRingBuffer); return this->updateTagValueImpl(this->currentRingBuffer);
} }
MonitoredFence &currentFence = osContextWin->getResidencyController().getMonitoredFence(); MonitoredFence &currentFence = osContextWin->getMonitoredFence();
return currentFence.currentFenceValue; return currentFence.currentFenceValue;
} }
@@ -161,7 +161,7 @@ bool WddmDirectSubmission<GfxFamily, Dispatcher>::dispatchMonitorFenceRequired(b
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
uint64_t WddmDirectSubmission<GfxFamily, Dispatcher>::updateTagValueImpl(uint32_t completionBufferIndex) { uint64_t WddmDirectSubmission<GfxFamily, Dispatcher>::updateTagValueImpl(uint32_t completionBufferIndex) {
MonitoredFence &currentFence = osContextWin->getResidencyController().getMonitoredFence(); MonitoredFence &currentFence = osContextWin->getMonitoredFence();
currentFence.lastSubmittedFence = currentFence.currentFenceValue; currentFence.lastSubmittedFence = currentFence.currentFenceValue;
currentFence.currentFenceValue++; currentFence.currentFenceValue++;
@@ -182,7 +182,7 @@ void WddmDirectSubmission<GfxFamily, Dispatcher>::handleCompletionFence(uint64_t
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
void WddmDirectSubmission<GfxFamily, Dispatcher>::getTagAddressValue(TagData &tagData) { void WddmDirectSubmission<GfxFamily, Dispatcher>::getTagAddressValue(TagData &tagData) {
MonitoredFence &currentFence = osContextWin->getResidencyController().getMonitoredFence(); MonitoredFence &currentFence = osContextWin->getMonitoredFence();
auto gmmHelper = wddm->getRootDeviceEnvironment().getGmmHelper(); auto gmmHelper = wddm->getRootDeviceEnvironment().getGmmHelper();
tagData.tagAddress = gmmHelper->canonize(currentFence.gpuAddress); tagData.tagAddress = gmmHelper->canonize(currentFence.gpuAddress);
@@ -226,7 +226,7 @@ void WddmDirectSubmission<GfxFamily, Dispatcher>::updateMonitorFenceValueForResi
if (allocationsForResidency == nullptr) { if (allocationsForResidency == nullptr) {
return; return;
} }
const auto currentFence = osContextWin->getResidencyController().getMonitoredFence().currentFenceValue; const auto currentFence = osContextWin->getMonitoredFence().currentFenceValue;
auto contextId = osContextWin->getContextId(); auto contextId = osContextWin->getContextId();
for (uint32_t i = 0; i < allocationsForResidency->size(); i++) { for (uint32_t i = 0; i < allocationsForResidency->size(); i++) {
WddmAllocation *allocation = static_cast<WddmAllocation *>((*allocationsForResidency)[i]); WddmAllocation *allocation = static_cast<WddmAllocation *>((*allocationsForResidency)[i]);

18
shared/source/os_interface/windows/os_context_win.cpp
View File

@@ -51,7 +51,7 @@ bool OsContextWin::initializeContext(bool allocateInterrupt) {
} }
return true; return true;
}; }
void OsContextWin::reInitializeContext() { void OsContextWin::reInitializeContext() {
NEO::EnvironmentVariableReader envReader; NEO::EnvironmentVariableReader envReader;
@@ -68,7 +68,15 @@ void OsContextWin::reInitializeContext() {
UNRECOVERABLE_IF(!wddmInterface->createMonitoredFence(*this)); UNRECOVERABLE_IF(!wddmInterface->createMonitoredFence(*this));
} }
} }
}; }
void OsContextWin::resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress) {
monitoredFence.lastSubmittedFence = 0;
monitoredFence.currentFenceValue = 1;
monitoredFence.fenceHandle = handle;
monitoredFence.cpuAddress = cpuAddress;
monitoredFence.gpuAddress = gpuAddress;
}
void OsContextWin::getDeviceLuidArray(std::vector<uint8_t> &luidData, size_t arraySize) { void OsContextWin::getDeviceLuidArray(std::vector<uint8_t> &luidData, size_t arraySize) {
auto *wddm = this->getWddm(); auto *wddm = this->getWddm();
@@ -85,7 +93,7 @@ void OsContextWin::getDeviceLuidArray(std::vector<uint8_t> &luidData, size_t arr
luidData.emplace(luidData.end(), luidArray[i - 4]); luidData.emplace(luidData.end(), luidArray[i - 4]);
} }
} }
}; }
uint32_t OsContextWin::getDeviceNodeMask() { uint32_t OsContextWin::getDeviceNodeMask() {
auto *wddm = this->getWddm(); auto *wddm = this->getWddm();
@@ -108,8 +116,8 @@ bool OsContextWin::isDirectSubmissionSupported() const {
OsContextWin::~OsContextWin() { OsContextWin::~OsContextWin() {
if (contextInitialized && (false == this->wddm.skipResourceCleanup())) { if (contextInitialized && (false == this->wddm.skipResourceCleanup())) {
wddm.getWddmInterface()->destroyHwQueue(hardwareQueue.handle); wddm.getWddmInterface()->destroyHwQueue(hardwareQueue.handle);
if (residencyController.getMonitoredFence().fenceHandle != hardwareQueue.progressFenceHandle) { if (getMonitoredFence().fenceHandle != hardwareQueue.progressFenceHandle) {
wddm.getWddmInterface()->destroyMonitorFence(residencyController.getMonitoredFence().fenceHandle); wddm.getWddmInterface()->destroyMonitorFence(getMonitoredFence().fenceHandle);
} }
if (!isPartOfContextGroup() || if (!isPartOfContextGroup() ||

12
shared/source/os_interface/windows/os_context_win.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2024 Intel Corporation * Copyright (C) 2018-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -35,6 +35,11 @@ class OsContextWin : public OsContext {
Wddm *getWddm() const { return &wddm; } Wddm *getWddm() const { return &wddm; }
MOCKABLE_VIRTUAL WddmResidencyController &getResidencyController() { return residencyController; } MOCKABLE_VIRTUAL WddmResidencyController &getResidencyController() { return residencyController; }
static OsContext *create(OSInterface *osInterface, uint32_t rootDeviceIndex, uint32_t contextId, const EngineDescriptor &engineDescriptor); static OsContext *create(OSInterface *osInterface, uint32_t rootDeviceIndex, uint32_t contextId, const EngineDescriptor &engineDescriptor);
MonitoredFence &getMonitoredFence() { return monitoredFence; }
void resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress);
bool wasAllocationUsedSinceLastTrim(uint64_t fenceValue) { return fenceValue > lastTrimFenceValue; }
void updateLastTrimFenceValue() { lastTrimFenceValue = *this->getMonitoredFence().cpuAddress; }
uint64_t getLastTrimFenceValue() const { return this->lastTrimFenceValue; };
void reInitializeContext() override; void reInitializeContext() override;
void getDeviceLuidArray(std::vector<uint8_t> &luidData, size_t arraySize); void getDeviceLuidArray(std::vector<uint8_t> &luidData, size_t arraySize);
uint32_t getDeviceNodeMask(); uint32_t getDeviceNodeMask();
@@ -44,7 +49,12 @@ class OsContextWin : public OsContext {
bool initializeContext(bool allocateInterrupt) override; bool initializeContext(bool allocateInterrupt) override;
WddmResidencyController residencyController; WddmResidencyController residencyController;
HardwareQueue hardwareQueue; HardwareQueue hardwareQueue;
MonitoredFence monitoredFence = {};
uint64_t lastTrimFenceValue = 0u;
Wddm &wddm; Wddm &wddm;
D3DKMT_HANDLE wddmContextHandle = 0; D3DKMT_HANDLE wddmContextHandle = 0;
}; };

21
shared/source/os_interface/windows/trim_callback.cpp
View File

@@ -7,6 +7,7 @@
#include "shared/source/command_stream/command_stream_receiver.h" #include "shared/source/command_stream/command_stream_receiver.h"
#include "shared/source/os_interface/windows/gdi_interface.h" #include "shared/source/os_interface/windows/gdi_interface.h"
#include "shared/source/os_interface/windows/os_context_win.h"
#include "shared/source/os_interface/windows/wddm/wddm.h" #include "shared/source/os_interface/windows/wddm/wddm.h"
#include "shared/source/os_interface/windows/wddm/wddm_residency_logger.h" #include "shared/source/os_interface/windows/wddm/wddm_residency_logger.h"
#include "shared/source/os_interface/windows/wddm_allocation.h" #include "shared/source/os_interface/windows/wddm_allocation.h"
@@ -56,7 +57,8 @@ void APIENTRY WddmResidencyController::trimCallback(_Inout_ D3DKMT_TRIMNOTIFICAT
void WddmResidencyController::trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS &flags, uint64_t bytes) { void WddmResidencyController::trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS &flags, uint64_t bytes) {
std::chrono::high_resolution_clock::time_point callbackStart; std::chrono::high_resolution_clock::time_point callbackStart;
perfLogResidencyTrimCallbackBegin(wddm.getResidencyLogger(), callbackStart); perfLogResidencyTrimCallbackBegin(wddm.getResidencyLogger(), callbackStart);
uint32_t osContextId = this->csr->getOsContext().getContextId(); auto &osContext = static_cast<NEO::OsContextWin &>(this->csr->getOsContext());
uint32_t osContextId = osContext.getContextId();
if (flags.PeriodicTrim) { if (flags.PeriodicTrim) {
uint64_t sizeToTrim = 0; uint64_t sizeToTrim = 0;
@@ -67,9 +69,9 @@ void WddmResidencyController::trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS
for (auto allocationIter = evictionAllocations.begin(); allocationIter != evictionAllocations.end();) { for (auto allocationIter = evictionAllocations.begin(); allocationIter != evictionAllocations.end();) {
wddmAllocation = reinterpret_cast<WddmAllocation *>(*allocationIter); wddmAllocation = reinterpret_cast<WddmAllocation *>(*allocationIter);
DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "lastPeriodicTrimFenceValue = ", lastTrimFenceValue); DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "lastPeriodicTrimFenceValue = ", osContext.getLastTrimFenceValue());
if (wasAllocationUsedSinceLastTrim(wddmAllocation->getResidencyData().getFenceValueForContextId(osContextId))) { if (osContext.wasAllocationUsedSinceLastTrim(wddmAllocation->getResidencyData().getFenceValueForContextId(osContextId))) {
allocationIter++; allocationIter++;
continue; continue;
} }
@@ -87,7 +89,7 @@ void WddmResidencyController::trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS
for (uint32_t allocationId = 0; allocationId < wddmAllocation->fragmentsStorage.fragmentCount; allocationId++) { for (uint32_t allocationId = 0; allocationId < wddmAllocation->fragmentsStorage.fragmentCount; allocationId++) {
AllocationStorageData &fragmentStorageData = wddmAllocation->fragmentsStorage.fragmentStorageData[allocationId]; AllocationStorageData &fragmentStorageData = wddmAllocation->fragmentsStorage.fragmentStorageData[allocationId];
if (!wasAllocationUsedSinceLastTrim(fragmentStorageData.residency->getFenceValueForContextId(osContextId))) { if (!osContext.wasAllocationUsedSinceLastTrim(fragmentStorageData.residency->getFenceValueForContextId(osContextId))) {
auto osHandle = static_cast<OsHandleWin *>(wddmAllocation->fragmentsStorage.fragmentStorageData[allocationId].osHandleStorage); auto osHandle = static_cast<OsHandleWin *>(wddmAllocation->fragmentsStorage.fragmentStorageData[allocationId].osHandleStorage);
DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "Evict fragment: handle =", osHandle->handle, "lastFence =", DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "Evict fragment: handle =", osHandle->handle, "lastFence =",
wddmAllocation->fragmentsStorage.fragmentStorageData[allocationId].residency->getFenceValueForContextId(osContextId)); wddmAllocation->fragmentsStorage.fragmentStorageData[allocationId].residency->getFenceValueForContextId(osContextId));
@@ -112,8 +114,8 @@ void WddmResidencyController::trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS
} }
if (flags.PeriodicTrim || flags.RestartPeriodicTrim) { if (flags.PeriodicTrim || flags.RestartPeriodicTrim) {
this->updateLastTrimFenceValue(); osContext.updateLastTrimFenceValue();
DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "updated lastPeriodicTrimFenceValue =", lastTrimFenceValue); DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "updated lastPeriodicTrimFenceValue =", osContext.getLastTrimFenceValue());
} }
perfLogResidencyTrimCallbackEnd(wddm.getResidencyLogger(), flags.Value, this, callbackStart); perfLogResidencyTrimCallbackEnd(wddm.getResidencyLogger(), flags.Value, this, callbackStart);
@@ -121,7 +123,8 @@ void WddmResidencyController::trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS
bool WddmResidencyController::trimResidencyToBudget(uint64_t bytes) { bool WddmResidencyController::trimResidencyToBudget(uint64_t bytes) {
this->csr->drainPagingFenceQueue(); this->csr->drainPagingFenceQueue();
uint32_t osContextId = this->csr->getOsContext().getContextId(); auto &osContext = static_cast<NEO::OsContextWin &>(this->csr->getOsContext());
uint32_t osContextId = osContext.getContextId();
uint64_t sizeToTrim = 0; uint64_t sizeToTrim = 0;
uint64_t numberOfBytesToTrim = bytes; uint64_t numberOfBytesToTrim = bytes;
WddmAllocation *wddmAllocation = nullptr; WddmAllocation *wddmAllocation = nullptr;
@@ -133,7 +136,7 @@ bool WddmResidencyController::trimResidencyToBudget(uint64_t bytes) {
while (numberOfBytesToTrim > 0 && allocationIter != evictionAllocations.end()) { while (numberOfBytesToTrim > 0 && allocationIter != evictionAllocations.end()) {
wddmAllocation = reinterpret_cast<WddmAllocation *>(*allocationIter); wddmAllocation = reinterpret_cast<WddmAllocation *>(*allocationIter);
uint64_t lastFence = wddmAllocation->getResidencyData().getFenceValueForContextId(osContextId); uint64_t lastFence = wddmAllocation->getResidencyData().getFenceValueForContextId(osContextId);
auto &monitoredFence = this->getMonitoredFence(); auto &monitoredFence = osContext.getMonitoredFence();
if (lastFence > monitoredFence.lastSubmittedFence) { if (lastFence > monitoredFence.lastSubmittedFence) {
allocationIter++; allocationIter++;
@@ -148,7 +151,7 @@ bool WddmResidencyController::trimResidencyToBudget(uint64_t bytes) {
uint64_t sizeEvicted = 0; uint64_t sizeEvicted = 0;
if (lastFence > *monitoredFence.cpuAddress) { if (lastFence > *monitoredFence.cpuAddress) {
this->wddm.waitFromCpu(lastFence, this->getMonitoredFence(), false); this->wddm.waitFromCpu(lastFence, osContext.getMonitoredFence(), false);
} }
if (wddmAllocation->fragmentsStorage.fragmentCount == 0) { if (wddmAllocation->fragmentsStorage.fragmentCount == 0) {

4
shared/source/os_interface/windows/wddm/wddm.cpp
View File

@@ -1197,7 +1197,7 @@ bool Wddm::waitFromCpu(uint64_t lastFenceValue, const MonitoredFence &monitoredF
if (!skipResourceCleanup() && lastFenceValue > *monitoredFence.cpuAddress) { if (!skipResourceCleanup() && lastFenceValue > *monitoredFence.cpuAddress) {
CommandStreamReceiver *csr = nullptr; CommandStreamReceiver *csr = nullptr;
this->forEachContextWithinWddm([&monitoredFence, &csr](const EngineControl &engine) { this->forEachContextWithinWddm([&monitoredFence, &csr](const EngineControl &engine) {
auto &contextMonitoredFence = static_cast<OsContextWin *>(engine.osContext)->getResidencyController().getMonitoredFence(); auto &contextMonitoredFence = static_cast<OsContextWin *>(engine.osContext)->getMonitoredFence();
if (contextMonitoredFence.cpuAddress == monitoredFence.cpuAddress) { if (contextMonitoredFence.cpuAddress == monitoredFence.cpuAddress) {
csr = engine.commandStreamReceiver; csr = engine.commandStreamReceiver;
} }
@@ -1239,7 +1239,7 @@ bool Wddm::waitFromCpu(uint64_t lastFenceValue, const MonitoredFence &monitoredF
bool Wddm::isGpuHangDetected(OsContext &osContext) { bool Wddm::isGpuHangDetected(OsContext &osContext) {
const auto osContextWin = static_cast<OsContextWin *>(&osContext); const auto osContextWin = static_cast<OsContextWin *>(&osContext);
const auto &monitoredFence = osContextWin->getResidencyController().getMonitoredFence(); const auto &monitoredFence = osContextWin->getMonitoredFence();
bool hangDetected = monitoredFence.cpuAddress && *monitoredFence.cpuAddress == gpuHangIndication; bool hangDetected = monitoredFence.cpuAddress && *monitoredFence.cpuAddress == gpuHangIndication;
PRINT_DEBUG_STRING(hangDetected && debugManager.flags.PrintDebugMessages.get(), stderr, "%s", "ERROR: GPU HANG detected!\n"); PRINT_DEBUG_STRING(hangDetected && debugManager.flags.PrintDebugMessages.get(), stderr, "%s", "ERROR: GPU HANG detected!\n");

25
shared/source/os_interface/windows/wddm/wddm_interface.cpp
View File

@@ -47,8 +47,7 @@ bool WddmInterface20::createHwQueue(OsContextWin &osContext) {
void WddmInterface20::destroyHwQueue(D3DKMT_HANDLE hwQueue) {} void WddmInterface20::destroyHwQueue(D3DKMT_HANDLE hwQueue) {}
bool WddmInterface20::createMonitoredFence(OsContextWin &osContext) { bool WddmInterface20::createMonitoredFence(OsContextWin &osContext) {
auto &residencyController = osContext.getResidencyController(); MonitoredFence &monitorFence = osContext.getMonitoredFence();
MonitoredFence &monitorFence = residencyController.getMonitoredFence();
bool ret = WddmInterface::createMonitoredFence(monitorFence); bool ret = WddmInterface::createMonitoredFence(monitorFence);
monitorFence.currentFenceValue = 1; monitorFence.currentFenceValue = 1;
@@ -131,11 +130,10 @@ bool WddmInterface23::createHwQueue(OsContextWin &osContext) {
} }
bool WddmInterface23::createMonitoredFence(OsContextWin &osContext) { bool WddmInterface23::createMonitoredFence(OsContextWin &osContext) {
auto &residencyController = osContext.getResidencyController();
auto hwQueue = osContext.getHwQueue(); auto hwQueue = osContext.getHwQueue();
residencyController.resetMonitoredFenceParams(hwQueue.progressFenceHandle, osContext.resetMonitoredFenceParams(hwQueue.progressFenceHandle,
reinterpret_cast<uint64_t *>(hwQueue.progressFenceCpuVA), reinterpret_cast<uint64_t *>(hwQueue.progressFenceCpuVA),
hwQueue.progressFenceGpuVA); hwQueue.progressFenceGpuVA);
return true; return true;
} }
@@ -187,14 +185,13 @@ bool WddmInterface23::submit(uint64_t commandBuffer, size_t size, void *commandH
bool NEO::WddmInterface23::createFenceForDirectSubmission(MonitoredFence &monitorFence, OsContextWin &osContext) { bool NEO::WddmInterface23::createFenceForDirectSubmission(MonitoredFence &monitorFence, OsContextWin &osContext) {
MonitoredFence monitorFenceForResidency{}; MonitoredFence monitorFenceForResidency{};
auto ret = createSyncObject(monitorFenceForResidency); auto ret = createSyncObject(monitorFenceForResidency);
auto &residencyController = osContext.getResidencyController(); auto lastSubmittedFence = osContext.getMonitoredFence().lastSubmittedFence;
auto lastSubmittedFence = residencyController.getMonitoredFence().lastSubmittedFence; auto currentFenceValue = osContext.getMonitoredFence().currentFenceValue;
auto currentFenceValue = residencyController.getMonitoredFence().currentFenceValue; osContext.resetMonitoredFenceParams(monitorFenceForResidency.fenceHandle,
residencyController.resetMonitoredFenceParams(monitorFenceForResidency.fenceHandle, const_cast<uint64_t *>(monitorFenceForResidency.cpuAddress),
const_cast<uint64_t *>(monitorFenceForResidency.cpuAddress), monitorFenceForResidency.gpuAddress);
monitorFenceForResidency.gpuAddress); osContext.getMonitoredFence().currentFenceValue = currentFenceValue;
residencyController.getMonitoredFence().currentFenceValue = currentFenceValue; osContext.getMonitoredFence().lastSubmittedFence = lastSubmittedFence;
residencyController.getMonitoredFence().lastSubmittedFence = lastSubmittedFence;
auto hwQueue = osContext.getHwQueue(); auto hwQueue = osContext.getHwQueue();
monitorFence.cpuAddress = reinterpret_cast<uint64_t *>(hwQueue.progressFenceCpuVA); monitorFence.cpuAddress = reinterpret_cast<uint64_t *>(hwQueue.progressFenceCpuVA);

6
shared/source/os_interface/windows/wddm_device_command_stream.inl
View File

@@ -134,7 +134,7 @@ SubmissionStatus WddmCommandStreamReceiver<GfxFamily>::flush(BatchBuffer &batchB
WddmSubmitArguments submitArgs = {}; WddmSubmitArguments submitArgs = {};
submitArgs.contextHandle = osContextWin->getWddmContextHandle(); submitArgs.contextHandle = osContextWin->getWddmContextHandle();
submitArgs.hwQueueHandle = osContextWin->getHwQueue().handle; submitArgs.hwQueueHandle = osContextWin->getHwQueue().handle;
submitArgs.monitorFence = &osContextWin->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContextWin->getMonitoredFence();
auto status = wddm->submit(commandStreamAddress, batchBuffer.usedSize - batchBuffer.startOffset, commandBufferHeader, submitArgs); auto status = wddm->submit(commandStreamAddress, batchBuffer.usedSize - batchBuffer.startOffset, commandBufferHeader, submitArgs);
this->flushStamp->setStamp(submitArgs.monitorFence->lastSubmittedFence); this->flushStamp->setStamp(submitArgs.monitorFence->lastSubmittedFence);
@@ -147,7 +147,7 @@ SubmissionStatus WddmCommandStreamReceiver<GfxFamily>::flush(BatchBuffer &batchB
template <typename GfxFamily> template <typename GfxFamily>
SubmissionStatus WddmCommandStreamReceiver<GfxFamily>::processResidency(ResidencyContainer &allocationsForResidency, uint32_t handleId) { SubmissionStatus WddmCommandStreamReceiver<GfxFamily>::processResidency(ResidencyContainer &allocationsForResidency, uint32_t handleId) {
return static_cast<OsContextWin *>(this->osContext)->getResidencyController().makeResidentResidencyAllocations(allocationsForResidency, this->requiresBlockingResidencyHandling, this->osContext->getContextId()) ? SubmissionStatus::success : SubmissionStatus::outOfMemory; return static_cast<OsContextWin *>(this->osContext)->getResidencyController().makeResidentResidencyAllocations(allocationsForResidency, this->requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(this->osContext)) ? SubmissionStatus::success : SubmissionStatus::outOfMemory;
} }
template <typename GfxFamily> template <typename GfxFamily>
@@ -161,7 +161,7 @@ WddmMemoryManager *WddmCommandStreamReceiver<GfxFamily>::getMemoryManager() cons
template <typename GfxFamily> template <typename GfxFamily>
bool WddmCommandStreamReceiver<GfxFamily>::waitForFlushStamp(FlushStamp &flushStampToWait) { bool WddmCommandStreamReceiver<GfxFamily>::waitForFlushStamp(FlushStamp &flushStampToWait) {
return wddm->waitFromCpu(flushStampToWait, static_cast<OsContextWin *>(this->osContext)->getResidencyController().getMonitoredFence(), false); return wddm->waitFromCpu(flushStampToWait, static_cast<OsContextWin *>(this->osContext)->getMonitoredFence(), false);
} }
template <typename GfxFamily> template <typename GfxFamily>

2
shared/source/os_interface/windows/wddm_memory_manager.cpp
View File

@@ -815,7 +815,7 @@ void WddmMemoryManager::handleFenceCompletion(GraphicsAllocation *allocation) {
for (auto &engine : getRegisteredEngines(allocation->getRootDeviceIndex())) { for (auto &engine : getRegisteredEngines(allocation->getRootDeviceIndex())) {
const auto lastFenceValue = wddmAllocation->getResidencyData().getFenceValueForContextId(engine.osContext->getContextId()); const auto lastFenceValue = wddmAllocation->getResidencyData().getFenceValueForContextId(engine.osContext->getContextId());
if (lastFenceValue != 0u) { if (lastFenceValue != 0u) {
const auto &monitoredFence = static_cast<OsContextWin *>(engine.osContext)->getResidencyController().getMonitoredFence(); const auto &monitoredFence = static_cast<OsContextWin *>(engine.osContext)->getMonitoredFence();
const auto wddm = static_cast<OsContextWin *>(engine.osContext)->getWddm(); const auto wddm = static_cast<OsContextWin *>(engine.osContext)->getWddm();
wddm->waitFromCpu(lastFenceValue, monitoredFence, engine.commandStreamReceiver->isAnyDirectSubmissionEnabled()); wddm->waitFromCpu(lastFenceValue, monitoredFence, engine.commandStreamReceiver->isAnyDirectSubmissionEnabled());
} }

25
shared/source/os_interface/windows/wddm_residency_controller.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/command_stream/command_stream_receiver.h" #include "shared/source/command_stream/command_stream_receiver.h"
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/os_interface/windows/os_context_win.h"
#include "shared/source/os_interface/windows/wddm/wddm.h" #include "shared/source/os_interface/windows/wddm/wddm.h"
#include "shared/source/os_interface/windows/wddm_allocation.h" #include "shared/source/os_interface/windows/wddm_allocation.h"
#include "shared/source/os_interface/windows/wddm_residency_allocations_container.h" #include "shared/source/os_interface/windows/wddm_residency_allocations_container.h"
@@ -41,14 +42,6 @@ std::unique_lock<SpinLock> WddmResidencyController::acquireTrimCallbackLock() {
return std::unique_lock<SpinLock>{this->trimCallbackLock}; return std::unique_lock<SpinLock>{this->trimCallbackLock};
} }
void WddmResidencyController::resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress) {
monitoredFence.lastSubmittedFence = 0;
monitoredFence.currentFenceValue = 1;
monitoredFence.fenceHandle = handle;
monitoredFence.cpuAddress = cpuAddress;
monitoredFence.gpuAddress = gpuAddress;
}
/** /**
* @brief Makes resident passed allocations on a device * @brief Makes resident passed allocations on a device
* *
@@ -61,7 +54,8 @@ void WddmResidencyController::resetMonitoredFenceParams(D3DKMT_HANDLE &handle, u
* *
* @return returns true if all allocations either succeeded or are pending to be resident * @return returns true if all allocations either succeeded or are pending to be resident
*/ */
bool WddmResidencyController::makeResidentResidencyAllocations(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, uint32_t osContextId) { bool WddmResidencyController::makeResidentResidencyAllocations(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, OsContextWin &osContext) {
auto osContextId = osContext.getContextId();
const size_t residencyCount = allocationsForResidency.size(); const size_t residencyCount = allocationsForResidency.size();
requiresBlockingResidencyHandling = false; requiresBlockingResidencyHandling = false;
if (debugManager.flags.WaitForPagingFenceInController.get() != -1) { if (debugManager.flags.WaitForPagingFenceInController.get() != -1) {
@@ -70,7 +64,7 @@ bool WddmResidencyController::makeResidentResidencyAllocations(ResidencyContaine
auto lock = this->acquireLock(); auto lock = this->acquireLock();
backupResidencyContainer = allocationsForResidency; backupResidencyContainer = allocationsForResidency;
auto totalSize = fillHandlesContainer(allocationsForResidency, requiresBlockingResidencyHandling, osContextId); auto totalSize = fillHandlesContainer(allocationsForResidency, requiresBlockingResidencyHandling, osContext);
bool result = true; bool result = true;
if (!handlesForResidency.empty()) { if (!handlesForResidency.empty()) {
@@ -81,7 +75,7 @@ bool WddmResidencyController::makeResidentResidencyAllocations(ResidencyContaine
allocationsForResidency = backupResidencyContainer; allocationsForResidency = backupResidencyContainer;
if (!trimmingDone) { if (!trimmingDone) {
auto evictionStatus = wddm.getTemporaryResourcesContainer()->evictAllResources(); auto evictionStatus = wddm.getTemporaryResourcesContainer()->evictAllResources();
totalSize = fillHandlesContainer(allocationsForResidency, requiresBlockingResidencyHandling, osContextId); totalSize = fillHandlesContainer(allocationsForResidency, requiresBlockingResidencyHandling, osContext);
if (evictionStatus == MemoryOperationsStatus::success) { if (evictionStatus == MemoryOperationsStatus::success) {
continue; continue;
} }
@@ -91,10 +85,10 @@ bool WddmResidencyController::makeResidentResidencyAllocations(ResidencyContaine
} while (debugManager.flags.WaitForMemoryRelease.get() && result == false); } while (debugManager.flags.WaitForMemoryRelease.get() && result == false);
break; break;
} }
totalSize = fillHandlesContainer(allocationsForResidency, requiresBlockingResidencyHandling, osContextId); totalSize = fillHandlesContainer(allocationsForResidency, requiresBlockingResidencyHandling, osContext);
} }
} }
const auto currentFence = this->getMonitoredFence().currentFenceValue; const auto currentFence = osContext.getMonitoredFence().currentFenceValue;
if (result == true) { if (result == true) {
for (uint32_t i = 0; i < residencyCount; i++) { for (uint32_t i = 0; i < residencyCount; i++) {
@@ -121,13 +115,14 @@ bool WddmResidencyController::makeResidentResidencyAllocations(ResidencyContaine
* *
* @return returns total size in bytes of allocations which are not yet resident. * @return returns total size in bytes of allocations which are not yet resident.
*/ */
size_t WddmResidencyController::fillHandlesContainer(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, uint32_t osContextId) { size_t WddmResidencyController::fillHandlesContainer(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, OsContextWin &osContext) {
auto osContextId = osContext.getContextId();
size_t totalSize = 0; size_t totalSize = 0;
const size_t residencyCount = allocationsForResidency.size(); const size_t residencyCount = allocationsForResidency.size();
handlesForResidency.clear(); handlesForResidency.clear();
handlesForResidency.reserve(residencyCount); handlesForResidency.reserve(residencyCount);
DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "currentFenceValue =", this->getMonitoredFence().currentFenceValue); DBG_LOG(ResidencyDebugEnable, "Residency:", __FUNCTION__, "currentFenceValue =", osContext.getMonitoredFence().currentFenceValue);
auto checkIfAlreadyResident = [&](GraphicsAllocation *alloc) { auto checkIfAlreadyResident = [&](GraphicsAllocation *alloc) {
WddmAllocation *allocation = static_cast<WddmAllocation *>(alloc); WddmAllocation *allocation = static_cast<WddmAllocation *>(alloc);

15
shared/source/os_interface/windows/wddm_residency_controller.h
View File

@@ -25,6 +25,7 @@ class GraphicsAllocation;
class WddmAllocation; class WddmAllocation;
class Wddm; class Wddm;
class CommandStreamReceiver; class CommandStreamReceiver;
class OsContextWin;
class WddmResidencyController { class WddmResidencyController {
public: public:
@@ -36,12 +37,6 @@ class WddmResidencyController {
[[nodiscard]] MOCKABLE_VIRTUAL std::unique_lock<SpinLock> acquireLock(); [[nodiscard]] MOCKABLE_VIRTUAL std::unique_lock<SpinLock> acquireLock();
[[nodiscard]] std::unique_lock<SpinLock> acquireTrimCallbackLock(); [[nodiscard]] std::unique_lock<SpinLock> acquireTrimCallbackLock();
bool wasAllocationUsedSinceLastTrim(uint64_t fenceValue) { return fenceValue > lastTrimFenceValue; }
void updateLastTrimFenceValue() { lastTrimFenceValue = *this->getMonitoredFence().cpuAddress; }
MonitoredFence &getMonitoredFence() { return monitoredFence; }
void resetMonitoredFenceParams(D3DKMT_HANDLE &handle, uint64_t *cpuAddress, D3DGPU_VIRTUAL_ADDRESS &gpuAddress);
void registerCallback(); void registerCallback();
void trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS &flags, uint64_t bytes); void trimResidency(const D3DDDI_TRIMRESIDENCYSET_FLAGS &flags, uint64_t bytes);
@@ -50,7 +45,7 @@ class WddmResidencyController {
bool isMemoryBudgetExhausted() const { return memoryBudgetExhausted; } bool isMemoryBudgetExhausted() const { return memoryBudgetExhausted; }
void setMemoryBudgetExhausted() { memoryBudgetExhausted = true; } void setMemoryBudgetExhausted() { memoryBudgetExhausted = true; }
bool makeResidentResidencyAllocations(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, uint32_t osContextId); bool makeResidentResidencyAllocations(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, OsContextWin &osContext);
bool isInitialized() const; bool isInitialized() const;
@@ -63,15 +58,11 @@ class WddmResidencyController {
} }
protected: protected:
size_t fillHandlesContainer(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, uint32_t osContextId); size_t fillHandlesContainer(ResidencyContainer &allocationsForResidency, bool &requiresBlockingResidencyHandling, OsContextWin &osContext);
MonitoredFence monitoredFence = {};
SpinLock lock; SpinLock lock;
SpinLock trimCallbackLock; SpinLock trimCallbackLock;
uint64_t lastTrimFenceValue = 0u;
Wddm &wddm; Wddm &wddm;
VOID *trimCallbackHandle = nullptr; VOID *trimCallbackHandle = nullptr;

2
shared/test/common/mocks/mock_os_context_win.h
View File

@@ -12,6 +12,8 @@
namespace NEO { namespace NEO {
class MockOsContextWin : public OsContextWin { class MockOsContextWin : public OsContextWin {
public: public:
using OsContextWin::lastTrimFenceValue;
MockOsContextWin(Wddm &wddm, uint32_t rootDeviceIndex, uint32_t contextId, const EngineDescriptor &engineDescriptor) MockOsContextWin(Wddm &wddm, uint32_t rootDeviceIndex, uint32_t contextId, const EngineDescriptor &engineDescriptor)
: OsContextWin(wddm, rootDeviceIndex, contextId, engineDescriptor), : OsContextWin(wddm, rootDeviceIndex, contextId, engineDescriptor),
mockResidencyController(wddm) {} mockResidencyController(wddm) {}

1
shared/test/common/mocks/mock_wddm_residency_controller.h
View File

@@ -12,7 +12,6 @@ namespace NEO {
class MockWddmResidencyController : public WddmResidencyController { class MockWddmResidencyController : public WddmResidencyController {
public: public:
using WddmResidencyController::csr; using WddmResidencyController::csr;
using WddmResidencyController::lastTrimFenceValue;
using WddmResidencyController::lock; using WddmResidencyController::lock;
using WddmResidencyController::trimCallbackHandle; using WddmResidencyController::trimCallbackHandle;
using WddmResidencyController::trimResidency; using WddmResidencyController::trimResidency;

28
shared/test/unit_test/direct_submission/windows/wddm_direct_submission_tests.cpp
View File

@@ -279,7 +279,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenAllocateOsResourcesResidencyFail
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenGettingTagDataThenExpectContextMonitorFence) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenGettingTagDataThenExpectContextMonitorFence) {
uint64_t address = 0xFF00FF0000ull; uint64_t address = 0xFF00FF0000ull;
uint64_t value = 0x12345678ull; uint64_t value = 0x12345678ull;
MonitoredFence &contextFence = osContext->getResidencyController().getMonitoredFence(); MonitoredFence &contextFence = osContext->getMonitoredFence();
contextFence.gpuAddress = address; contextFence.gpuAddress = address;
contextFence.currentFenceValue = value; contextFence.currentFenceValue = value;
@@ -304,7 +304,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenHandleResidencyThenExpectWddmWai
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenHandlingRingBufferCompletionThenExpectWaitFromCpuWithCorrectFenceValue) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenHandlingRingBufferCompletionThenExpectWaitFromCpuWithCorrectFenceValue) {
uint64_t address = 0xFF00FF0000ull; uint64_t address = 0xFF00FF0000ull;
uint64_t value = 0x12345678ull; uint64_t value = 0x12345678ull;
MonitoredFence &contextFence = osContext->getResidencyController().getMonitoredFence(); MonitoredFence &contextFence = osContext->getMonitoredFence();
contextFence.gpuAddress = address; contextFence.gpuAddress = address;
contextFence.currentFenceValue = value; contextFence.currentFenceValue = value;
@@ -532,7 +532,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSwitchingRingBufferStartedAndWai
HWTEST_F(WddmDirectSubmissionTest, givenWddmDisableMonitorFenceAndStallingCmdsWhenUpdatingTagValueThenUpdateCompletionFence) { HWTEST_F(WddmDirectSubmissionTest, givenWddmDisableMonitorFenceAndStallingCmdsWhenUpdatingTagValueThenUpdateCompletionFence) {
uint64_t address = 0xFF00FF0000ull; uint64_t address = 0xFF00FF0000ull;
uint64_t value = 0x12345678ull; uint64_t value = 0x12345678ull;
MonitoredFence &contextFence = osContext->getResidencyController().getMonitoredFence(); MonitoredFence &contextFence = osContext->getMonitoredFence();
contextFence.gpuAddress = address; contextFence.gpuAddress = address;
contextFence.currentFenceValue = value; contextFence.currentFenceValue = value;
@@ -551,7 +551,7 @@ HWTEST_F(WddmDirectSubmissionWithMockGdiDllTest, givenNoMonitorFenceHangDetected
VariableBackup<bool> backupMonitorFenceCreateSelector(getMonitorFenceCpuAddressSelectorFcn()); VariableBackup<bool> backupMonitorFenceCreateSelector(getMonitorFenceCpuAddressSelectorFcn());
MonitoredFence &contextFence = osContextWin->getResidencyController().getMonitoredFence(); MonitoredFence &contextFence = osContextWin->getMonitoredFence();
VariableBackup<volatile uint64_t> backupWddmMonitorFence(contextFence.cpuAddress); VariableBackup<volatile uint64_t> backupWddmMonitorFence(contextFence.cpuAddress);
*contextFence.cpuAddress = 1; *contextFence.cpuAddress = 1;
contextFence.currentFenceValue = 2u; contextFence.currentFenceValue = 2u;
@@ -574,7 +574,7 @@ HWTEST_F(WddmDirectSubmissionWithMockGdiDllTest, givenWddmMonitorFenceHangDetect
VariableBackup<bool> backupMonitorFenceCreateSelector(getMonitorFenceCpuAddressSelectorFcn()); VariableBackup<bool> backupMonitorFenceCreateSelector(getMonitorFenceCpuAddressSelectorFcn());
MonitoredFence &contextFence = osContextWin->getResidencyController().getMonitoredFence(); MonitoredFence &contextFence = osContextWin->getMonitoredFence();
VariableBackup<volatile uint64_t> backupWddmMonitorFence(contextFence.cpuAddress); VariableBackup<volatile uint64_t> backupWddmMonitorFence(contextFence.cpuAddress);
*contextFence.cpuAddress = std::numeric_limits<uint64_t>::max(); *contextFence.cpuAddress = std::numeric_limits<uint64_t>::max();
@@ -607,7 +607,7 @@ HWTEST_F(WddmDirectSubmissionWithMockGdiDllTest, givenRingMonitorFenceHangDetect
HWTEST_F(WddmDirectSubmissionTest, givenDetectGpuFalseAndRequiredMonitorFenceWhenCallUpdateTagValueThenCurrentFenceValueIsReturned) { HWTEST_F(WddmDirectSubmissionTest, givenDetectGpuFalseAndRequiredMonitorFenceWhenCallUpdateTagValueThenCurrentFenceValueIsReturned) {
uint64_t value = 0x12345678ull; uint64_t value = 0x12345678ull;
MonitoredFence &contextFence = osContext->getResidencyController().getMonitoredFence(); MonitoredFence &contextFence = osContext->getMonitoredFence();
contextFence.currentFenceValue = value; contextFence.currentFenceValue = value;
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device->getDefaultEngine().commandStreamReceiver); MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device->getDefaultEngine().commandStreamReceiver);
@@ -812,7 +812,7 @@ HWTEST_F(WddmDirectSubmissionTest,
hwParse.parseCommands<FamilyType>(wddmDirectSubmission.ringCommandStream, sizeUsedBefore); hwParse.parseCommands<FamilyType>(wddmDirectSubmission.ringCommandStream, sizeUsedBefore);
hwParse.findHardwareCommands<FamilyType>(); hwParse.findHardwareCommands<FamilyType>();
auto &monitorFence = osContext->getResidencyController().getMonitoredFence(); auto &monitorFence = osContext->getMonitoredFence();
bool foundFenceUpdate = false; bool foundFenceUpdate = false;
for (auto it = hwParse.pipeControlList.begin(); it != hwParse.pipeControlList.end(); it++) { for (auto it = hwParse.pipeControlList.begin(); it != hwParse.pipeControlList.end(); it++) {
@@ -875,7 +875,7 @@ HWTEST_F(WddmDirectSubmissionTest,
hwParse.parseCommands<FamilyType>(wddmDirectSubmission.ringCommandStream, sizeUsedBefore); hwParse.parseCommands<FamilyType>(wddmDirectSubmission.ringCommandStream, sizeUsedBefore);
hwParse.findHardwareCommands<FamilyType>(); hwParse.findHardwareCommands<FamilyType>();
auto &monitorFence = osContext->getResidencyController().getMonitoredFence(); auto &monitorFence = osContext->getMonitoredFence();
bool foundFenceUpdate = false; bool foundFenceUpdate = false;
for (auto it = hwParse.pipeControlList.begin(); it != hwParse.pipeControlList.end(); it++) { for (auto it = hwParse.pipeControlList.begin(); it != hwParse.pipeControlList.end(); it++) {
@@ -954,18 +954,6 @@ HWTEST_F(WddmDirectSubmissionTest, givenNullPtrResidencyControllerWhenUpdatingRe
EXPECT_EQ(mockOsContextWin->getResidencyControllerCalledTimes, 0u); EXPECT_EQ(mockOsContextWin->getResidencyControllerCalledTimes, 0u);
} }
HWTEST_F(WddmDirectSubmissionTest, givenEmptyResidencyControllerWhenUpdatingResidencyAfterSwitchRingThenReturnAfterAccessingContextId) {
using Dispatcher = RenderDispatcher<FamilyType>;
auto mockOsContextWin = std::make_unique<MockOsContextWin>(*wddm, 0, 0, EngineDescriptorHelper::getDefaultDescriptor());
MockWddmDirectSubmission<FamilyType, Dispatcher> wddmDirectSubmission(*device->getDefaultEngine().commandStreamReceiver);
wddmDirectSubmission.osContextWin = mockOsContextWin.get();
ResidencyContainer container;
wddmDirectSubmission.updateMonitorFenceValueForResidencyList(&container);
EXPECT_EQ(mockOsContextWin->getResidencyControllerCalledTimes, 1u);
}
HWTEST_F(WddmDirectSubmissionTest, givenResidencyControllerWhenUpdatingResidencyAfterSwitchRingThenAllocationCallUpdateResidency) { HWTEST_F(WddmDirectSubmissionTest, givenResidencyControllerWhenUpdatingResidencyAfterSwitchRingThenAllocationCallUpdateResidency) {
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;

4
shared/test/unit_test/os_interface/windows/device_command_stream_tests.cpp
View File

@@ -233,7 +233,7 @@ HWTEST_TEMPLATED_F(WddmCommandStreamTest, WhenFlushingThenFlushIsSubmitted) {
EXPECT_EQ(1u, wddm->submitResult.called); EXPECT_EQ(1u, wddm->submitResult.called);
EXPECT_TRUE(wddm->submitResult.success); EXPECT_TRUE(wddm->submitResult.success);
EXPECT_EQ(csr->obtainCurrentFlushStamp(), static_cast<OsContextWin &>(csr->getOsContext()).getResidencyController().getMonitoredFence().lastSubmittedFence); EXPECT_EQ(csr->obtainCurrentFlushStamp(), static_cast<OsContextWin &>(csr->getOsContext()).getMonitoredFence().lastSubmittedFence);
memoryManager->freeGraphicsMemory(commandBuffer); memoryManager->freeGraphicsMemory(commandBuffer);
} }
@@ -1103,7 +1103,7 @@ HWTEST_TEMPLATED_F(WddmCommandStreamMockGdiTest, givenLastSubmittedFenceLowerTha
monitorFence.cpuAddress = &value; monitorFence.cpuAddress = &value;
auto gpuVa = castToUint64(&value); auto gpuVa = castToUint64(&value);
static_cast<OsContextWin *>(device->getDefaultEngine().osContext)->getResidencyController().resetMonitoredFenceParams(handle, &value, gpuVa); static_cast<OsContextWin *>(device->getDefaultEngine().osContext)->resetMonitoredFenceParams(handle, &value, gpuVa);
wddm->waitFromCpu(1, monitorFence, false); wddm->waitFromCpu(1, monitorFence, false);
EXPECT_EQ(directSubmission->flushMonitorFenceCalled, 2u); EXPECT_EQ(directSubmission->flushMonitorFenceCalled, 2u);

20
shared/test/unit_test/os_interface/windows/wddm20_tests.cpp
View File

@@ -334,7 +334,7 @@ TEST_F(Wddm20WithMockGdiDllTests, givenWddmAllocationWhenMappingGpuVaThenUseGmmS
} }
TEST_F(Wddm20WithMockGdiDllTests, GivenInvalidCpuAddressWhenCheckingForGpuHangThenFalseIsReturned) { TEST_F(Wddm20WithMockGdiDllTests, GivenInvalidCpuAddressWhenCheckingForGpuHangThenFalseIsReturned) {
osContext->getResidencyController().getMonitoredFence().cpuAddress = nullptr; osContext->getMonitoredFence().cpuAddress = nullptr;
EXPECT_FALSE(wddm->isGpuHangDetected(*osContext)); EXPECT_FALSE(wddm->isGpuHangDetected(*osContext));
} }
@@ -342,7 +342,7 @@ TEST_F(Wddm20WithMockGdiDllTests, GivenCpuValueDifferentThanGpuHangIndicationWhe
constexpr auto cpuValue{777u}; constexpr auto cpuValue{777u};
ASSERT_NE(NEO::Wddm::gpuHangIndication, cpuValue); ASSERT_NE(NEO::Wddm::gpuHangIndication, cpuValue);
*osContext->getResidencyController().getMonitoredFence().cpuAddress = cpuValue; *osContext->getMonitoredFence().cpuAddress = cpuValue;
EXPECT_FALSE(wddm->isGpuHangDetected(*osContext)); EXPECT_FALSE(wddm->isGpuHangDetected(*osContext));
} }
@@ -355,7 +355,7 @@ TEST_F(Wddm20WithMockGdiDllTests, whencreateMonitoredFenceForDirectSubmissionThe
} }
TEST_F(Wddm20WithMockGdiDllTests, GivenGpuHangIndicationWhenCheckingForGpuHangThenTrueIsReturned) { TEST_F(Wddm20WithMockGdiDllTests, GivenGpuHangIndicationWhenCheckingForGpuHangThenTrueIsReturned) {
auto fenceCpuAddress = osContext->getResidencyController().getMonitoredFence().cpuAddress; auto fenceCpuAddress = osContext->getMonitoredFence().cpuAddress;
VariableBackup<volatile uint64_t> backupWddmMonitorFence(fenceCpuAddress); VariableBackup<volatile uint64_t> backupWddmMonitorFence(fenceCpuAddress);
*fenceCpuAddress = NEO::Wddm::gpuHangIndication; *fenceCpuAddress = NEO::Wddm::gpuHangIndication;
@@ -878,7 +878,7 @@ TEST_F(Wddm20WithMockGdiDllTests, whenCreateContextIsCalledThenDisableHwQueues)
} }
TEST_F(Wddm20WithMockGdiDllTests, givenDestructionOsContextWinWhenCallingDestroyMonitorFenceThenDoCallGdiDestroy) { TEST_F(Wddm20WithMockGdiDllTests, givenDestructionOsContextWinWhenCallingDestroyMonitorFenceThenDoCallGdiDestroy) {
auto fenceHandle = osContext->getResidencyController().getMonitoredFence().fenceHandle; auto fenceHandle = osContext->getMonitoredFence().fenceHandle;
osContext.reset(nullptr); osContext.reset(nullptr);
EXPECT_EQ(1u, wddmMockInterface->destroyMonitorFenceCalled); EXPECT_EQ(1u, wddmMockInterface->destroyMonitorFenceCalled);
@@ -978,7 +978,7 @@ TEST_F(Wddm20Tests, givenDestroyAllocationWhenItIsCalledThenAllocationIsPassedTo
allocation.getResidencyData().updateCompletionData(10, osContext->getContextId()); allocation.getResidencyData().updateCompletionData(10, osContext->getContextId());
allocation.handle = ALLOCATION_HANDLE; allocation.handle = ALLOCATION_HANDLE;
*osContext->getResidencyController().getMonitoredFence().cpuAddress = 10; *osContext->getMonitoredFence().cpuAddress = 10;
gdi->getWaitFromCpuArg().FenceValueArray = nullptr; gdi->getWaitFromCpuArg().FenceValueArray = nullptr;
gdi->getWaitFromCpuArg().Flags.Value = 0; gdi->getWaitFromCpuArg().Flags.Value = 0;
@@ -1004,7 +1004,7 @@ TEST_F(Wddm20Tests, WhenLastFenceLessEqualThanMonitoredThenWaitFromCpuIsNotCalle
allocation.getResidencyData().updateCompletionData(10, osContext->getContextId()); allocation.getResidencyData().updateCompletionData(10, osContext->getContextId());
allocation.handle = ALLOCATION_HANDLE; allocation.handle = ALLOCATION_HANDLE;
*osContext->getResidencyController().getMonitoredFence().cpuAddress = 10; *osContext->getMonitoredFence().cpuAddress = 10;
gdi->getWaitFromCpuArg().FenceValueArray = nullptr; gdi->getWaitFromCpuArg().FenceValueArray = nullptr;
gdi->getWaitFromCpuArg().Flags.Value = 0; gdi->getWaitFromCpuArg().Flags.Value = 0;
@@ -1012,7 +1012,7 @@ TEST_F(Wddm20Tests, WhenLastFenceLessEqualThanMonitoredThenWaitFromCpuIsNotCalle
gdi->getWaitFromCpuArg().ObjectCount = 0; gdi->getWaitFromCpuArg().ObjectCount = 0;
gdi->getWaitFromCpuArg().ObjectHandleArray = nullptr; gdi->getWaitFromCpuArg().ObjectHandleArray = nullptr;
auto status = wddm->waitFromCpu(10, osContext->getResidencyController().getMonitoredFence(), true); auto status = wddm->waitFromCpu(10, osContext->getMonitoredFence(), true);
EXPECT_TRUE(status); EXPECT_TRUE(status);
@@ -1027,7 +1027,7 @@ TEST_F(Wddm20Tests, WhenLastFenceGreaterThanMonitoredThenWaitFromCpuIsCalled) {
allocation.getResidencyData().updateCompletionData(10, osContext->getContextId()); allocation.getResidencyData().updateCompletionData(10, osContext->getContextId());
allocation.handle = ALLOCATION_HANDLE; allocation.handle = ALLOCATION_HANDLE;
*osContext->getResidencyController().getMonitoredFence().cpuAddress = 10; *osContext->getMonitoredFence().cpuAddress = 10;
gdi->getWaitFromCpuArg().FenceValueArray = nullptr; gdi->getWaitFromCpuArg().FenceValueArray = nullptr;
gdi->getWaitFromCpuArg().Flags.Value = 0; gdi->getWaitFromCpuArg().Flags.Value = 0;
@@ -1035,7 +1035,7 @@ TEST_F(Wddm20Tests, WhenLastFenceGreaterThanMonitoredThenWaitFromCpuIsCalled) {
gdi->getWaitFromCpuArg().ObjectCount = 0; gdi->getWaitFromCpuArg().ObjectCount = 0;
gdi->getWaitFromCpuArg().ObjectHandleArray = nullptr; gdi->getWaitFromCpuArg().ObjectHandleArray = nullptr;
auto status = wddm->waitFromCpu(20, osContext->getResidencyController().getMonitoredFence(), true); auto status = wddm->waitFromCpu(20, osContext->getMonitoredFence(), true);
EXPECT_TRUE(status); EXPECT_TRUE(status);
@@ -1053,7 +1053,7 @@ TEST_F(Wddm20Tests, WhenCreatingMonitoredFenceThenItIsInitializedWithFenceValueZ
wddm->wddmInterface->createMonitoredFence(*osContext); wddm->wddmInterface->createMonitoredFence(*osContext);
EXPECT_EQ(0u, gdi->getCreateSynchronizationObject2Arg().Info.MonitoredFence.InitialFenceValue); EXPECT_EQ(0u, gdi->getCreateSynchronizationObject2Arg().Info.MonitoredFence.InitialFenceValue);
EXPECT_EQ(1u, osContext->getResidencyController().getMonitoredFence().currentFenceValue); EXPECT_EQ(1u, osContext->getMonitoredFence().currentFenceValue);
} }
NTSTATUS APIENTRY queryResourceInfoMock(D3DKMT_QUERYRESOURCEINFO *pData) { NTSTATUS APIENTRY queryResourceInfoMock(D3DKMT_QUERYRESOURCEINFO *pData) {

40
shared/test/unit_test/os_interface/windows/wddm23_tests.cpp
View File

@@ -110,15 +110,15 @@ TEST_F(Wddm23Tests, whenObjectIsDestructedThenDestroyHwQueue) {
} }
TEST_F(Wddm23Tests, whencreateMonitoredFenceForDirectSubmissionThenObtainHwQueueFenceAndReplaceResidencyControllerWithNewFence) { TEST_F(Wddm23Tests, whencreateMonitoredFenceForDirectSubmissionThenObtainHwQueueFenceAndReplaceResidencyControllerWithNewFence) {
EXPECT_EQ(osContext->getResidencyController().getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle); EXPECT_EQ(osContext->getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle);
osContext->getResidencyController().getMonitoredFence().currentFenceValue = 2u; osContext->getMonitoredFence().currentFenceValue = 2u;
osContext->getResidencyController().getMonitoredFence().lastSubmittedFence = 1u; osContext->getMonitoredFence().lastSubmittedFence = 1u;
MonitoredFence fence{}; MonitoredFence fence{};
wddm->getWddmInterface()->createFenceForDirectSubmission(fence, *osContext); wddm->getWddmInterface()->createFenceForDirectSubmission(fence, *osContext);
EXPECT_EQ(osContext->getHwQueue().progressFenceHandle, fence.fenceHandle); EXPECT_EQ(osContext->getHwQueue().progressFenceHandle, fence.fenceHandle);
EXPECT_NE(osContext->getResidencyController().getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle); EXPECT_NE(osContext->getMonitoredFence().fenceHandle, osContext->getHwQueue().progressFenceHandle);
EXPECT_EQ(osContext->getResidencyController().getMonitoredFence().currentFenceValue, 2u); EXPECT_EQ(osContext->getMonitoredFence().currentFenceValue, 2u);
EXPECT_EQ(osContext->getResidencyController().getMonitoredFence().lastSubmittedFence, 1u); EXPECT_EQ(osContext->getMonitoredFence().lastSubmittedFence, 1u);
EXPECT_EQ(fence.currentFenceValue, 2u); EXPECT_EQ(fence.currentFenceValue, 2u);
EXPECT_EQ(fence.lastSubmittedFence, 1u); EXPECT_EQ(fence.lastSubmittedFence, 1u);
} }
@@ -129,26 +129,26 @@ TEST_F(Wddm23Tests, givenCmdBufferWhenSubmitCalledThenSetAllRequiredFiledsAndUpd
auto hwQueue = osContext->getHwQueue(); auto hwQueue = osContext->getHwQueue();
COMMAND_BUFFER_HEADER cmdBufferHeader = {}; COMMAND_BUFFER_HEADER cmdBufferHeader = {};
EXPECT_EQ(1u, osContext->getResidencyController().getMonitoredFence().currentFenceValue); EXPECT_EQ(1u, osContext->getMonitoredFence().currentFenceValue);
EXPECT_EQ(0u, osContext->getResidencyController().getMonitoredFence().lastSubmittedFence); EXPECT_EQ(0u, osContext->getMonitoredFence().lastSubmittedFence);
WddmSubmitArguments submitArgs = {}; WddmSubmitArguments submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = hwQueue.handle; submitArgs.hwQueueHandle = hwQueue.handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
wddm->submit(cmdBufferAddress, cmdSize, &cmdBufferHeader, submitArgs); wddm->submit(cmdBufferAddress, cmdSize, &cmdBufferHeader, submitArgs);
EXPECT_EQ(cmdBufferAddress, getSubmitCommandToHwQueueDataFcn()->CommandBuffer); EXPECT_EQ(cmdBufferAddress, getSubmitCommandToHwQueueDataFcn()->CommandBuffer);
EXPECT_EQ(static_cast<UINT>(cmdSize), getSubmitCommandToHwQueueDataFcn()->CommandLength); EXPECT_EQ(static_cast<UINT>(cmdSize), getSubmitCommandToHwQueueDataFcn()->CommandLength);
EXPECT_EQ(hwQueue.handle, getSubmitCommandToHwQueueDataFcn()->hHwQueue); EXPECT_EQ(hwQueue.handle, getSubmitCommandToHwQueueDataFcn()->hHwQueue);
EXPECT_EQ(osContext->getResidencyController().getMonitoredFence().lastSubmittedFence, getSubmitCommandToHwQueueDataFcn()->HwQueueProgressFenceId); EXPECT_EQ(osContext->getMonitoredFence().lastSubmittedFence, getSubmitCommandToHwQueueDataFcn()->HwQueueProgressFenceId);
EXPECT_EQ(&cmdBufferHeader, getSubmitCommandToHwQueueDataFcn()->pPrivateDriverData); EXPECT_EQ(&cmdBufferHeader, getSubmitCommandToHwQueueDataFcn()->pPrivateDriverData);
EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize); EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize);
EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceVA); EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceVA);
EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceValue); EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceValue);
EXPECT_EQ(2u, osContext->getResidencyController().getMonitoredFence().currentFenceValue); EXPECT_EQ(2u, osContext->getMonitoredFence().currentFenceValue);
EXPECT_EQ(1u, osContext->getResidencyController().getMonitoredFence().lastSubmittedFence); EXPECT_EQ(1u, osContext->getMonitoredFence().lastSubmittedFence);
} }
TEST_F(Wddm23Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderSizeForPrivateDriverDataSize) { TEST_F(Wddm23Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderSizeForPrivateDriverDataSize) {
@@ -160,7 +160,7 @@ TEST_F(Wddm23Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderS
WddmSubmitArguments submitArgs = {}; WddmSubmitArguments submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = osContext->getHwQueue().handle; submitArgs.hwQueueHandle = osContext->getHwQueue().handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
wddm->submit(123, 456, &cmdBufferHeader, submitArgs); wddm->submit(123, 456, &cmdBufferHeader, submitArgs);
EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize); EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize);
@@ -171,7 +171,7 @@ TEST_F(Wddm23Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderS
submitArgs = {}; submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = osContext->getHwQueue().handle; submitArgs.hwQueueHandle = osContext->getHwQueue().handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
wddm->submit(123, 456, &cmdBufferHeader, submitArgs); wddm->submit(123, 456, &cmdBufferHeader, submitArgs);
EXPECT_EQ(static_cast<UINT>(MemoryConstants::pageSize), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize); EXPECT_EQ(static_cast<UINT>(MemoryConstants::pageSize), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize);
@@ -181,11 +181,11 @@ TEST_F(Wddm23Tests, whenMonitoredFenceIsCreatedThenSetupAllRequiredFields) {
wddm->wddmInterface->createMonitoredFence(*osContext); wddm->wddmInterface->createMonitoredFence(*osContext);
auto hwQueue = osContext->getHwQueue(); auto hwQueue = osContext->getHwQueue();
EXPECT_EQ(hwQueue.progressFenceCpuVA, osContext->getResidencyController().getMonitoredFence().cpuAddress); EXPECT_EQ(hwQueue.progressFenceCpuVA, osContext->getMonitoredFence().cpuAddress);
EXPECT_EQ(1u, osContext->getResidencyController().getMonitoredFence().currentFenceValue); EXPECT_EQ(1u, osContext->getMonitoredFence().currentFenceValue);
EXPECT_EQ(hwQueue.progressFenceHandle, osContext->getResidencyController().getMonitoredFence().fenceHandle); EXPECT_EQ(hwQueue.progressFenceHandle, osContext->getMonitoredFence().fenceHandle);
EXPECT_EQ(hwQueue.progressFenceGpuVA, osContext->getResidencyController().getMonitoredFence().gpuAddress); EXPECT_EQ(hwQueue.progressFenceGpuVA, osContext->getMonitoredFence().gpuAddress);
EXPECT_EQ(0u, osContext->getResidencyController().getMonitoredFence().lastSubmittedFence); EXPECT_EQ(0u, osContext->getMonitoredFence().lastSubmittedFence);
} }
TEST_F(Wddm23Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhenSubmitCalledThenCallWaitOnGpu) { TEST_F(Wddm23Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhenSubmitCalledThenCallWaitOnGpu) {
@@ -196,7 +196,7 @@ TEST_F(Wddm23Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhe
WddmSubmitArguments submitArgs = {}; WddmSubmitArguments submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = osContext->getHwQueue().handle; submitArgs.hwQueueHandle = osContext->getHwQueue().handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
VariableBackup<volatile uint64_t> pagingFenceBackup(wddm->pagingFenceAddress); VariableBackup<volatile uint64_t> pagingFenceBackup(wddm->pagingFenceAddress);
*wddm->pagingFenceAddress = 1; *wddm->pagingFenceAddress = 1;

28
shared/test/unit_test/os_interface/windows/wddm32_tests.cpp
View File

@@ -60,26 +60,26 @@ TEST_F(Wddm32Tests, givenCmdBufferWhenSubmitCalledThenSetAllRequiredFiledsAndUpd
auto hwQueue = osContext->getHwQueue(); auto hwQueue = osContext->getHwQueue();
COMMAND_BUFFER_HEADER cmdBufferHeader = {}; COMMAND_BUFFER_HEADER cmdBufferHeader = {};
EXPECT_EQ(1u, osContext->getResidencyController().getMonitoredFence().currentFenceValue); EXPECT_EQ(1u, osContext->getMonitoredFence().currentFenceValue);
EXPECT_EQ(0u, osContext->getResidencyController().getMonitoredFence().lastSubmittedFence); EXPECT_EQ(0u, osContext->getMonitoredFence().lastSubmittedFence);
WddmSubmitArguments submitArgs = {}; WddmSubmitArguments submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = hwQueue.handle; submitArgs.hwQueueHandle = hwQueue.handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
wddm->submit(cmdBufferAddress, cmdSize, &cmdBufferHeader, submitArgs); wddm->submit(cmdBufferAddress, cmdSize, &cmdBufferHeader, submitArgs);
EXPECT_EQ(cmdBufferAddress, getSubmitCommandToHwQueueDataFcn()->CommandBuffer); EXPECT_EQ(cmdBufferAddress, getSubmitCommandToHwQueueDataFcn()->CommandBuffer);
EXPECT_EQ(static_cast<UINT>(cmdSize), getSubmitCommandToHwQueueDataFcn()->CommandLength); EXPECT_EQ(static_cast<UINT>(cmdSize), getSubmitCommandToHwQueueDataFcn()->CommandLength);
EXPECT_EQ(hwQueue.handle, getSubmitCommandToHwQueueDataFcn()->hHwQueue); EXPECT_EQ(hwQueue.handle, getSubmitCommandToHwQueueDataFcn()->hHwQueue);
EXPECT_EQ(osContext->getResidencyController().getMonitoredFence().lastSubmittedFence, getSubmitCommandToHwQueueDataFcn()->HwQueueProgressFenceId); EXPECT_EQ(osContext->getMonitoredFence().lastSubmittedFence, getSubmitCommandToHwQueueDataFcn()->HwQueueProgressFenceId);
EXPECT_EQ(&cmdBufferHeader, getSubmitCommandToHwQueueDataFcn()->pPrivateDriverData); EXPECT_EQ(&cmdBufferHeader, getSubmitCommandToHwQueueDataFcn()->pPrivateDriverData);
EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize); EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize);
EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceVA); EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceVA);
EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceValue); EXPECT_EQ(0u, cmdBufferHeader.MonitorFenceValue);
EXPECT_EQ(2u, osContext->getResidencyController().getMonitoredFence().currentFenceValue); EXPECT_EQ(2u, osContext->getMonitoredFence().currentFenceValue);
EXPECT_EQ(1u, osContext->getResidencyController().getMonitoredFence().lastSubmittedFence); EXPECT_EQ(1u, osContext->getMonitoredFence().lastSubmittedFence);
} }
TEST_F(Wddm32Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderSizeForPrivateDriverDataSize) { TEST_F(Wddm32Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderSizeForPrivateDriverDataSize) {
@@ -91,7 +91,7 @@ TEST_F(Wddm32Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderS
WddmSubmitArguments submitArgs = {}; WddmSubmitArguments submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = osContext->getHwQueue().handle; submitArgs.hwQueueHandle = osContext->getHwQueue().handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
wddm->submit(123, 456, &cmdBufferHeader, submitArgs); wddm->submit(123, 456, &cmdBufferHeader, submitArgs);
EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize); EXPECT_EQ(static_cast<UINT>(sizeof(COMMAND_BUFFER_HEADER)), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize);
@@ -102,7 +102,7 @@ TEST_F(Wddm32Tests, givenDebugVariableSetWhenSubmitCalledThenUseCmdBufferHeaderS
submitArgs = {}; submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = osContext->getHwQueue().handle; submitArgs.hwQueueHandle = osContext->getHwQueue().handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
wddm->submit(123, 456, &cmdBufferHeader, submitArgs); wddm->submit(123, 456, &cmdBufferHeader, submitArgs);
EXPECT_EQ(static_cast<UINT>(MemoryConstants::pageSize), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize); EXPECT_EQ(static_cast<UINT>(MemoryConstants::pageSize), getSubmitCommandToHwQueueDataFcn()->PrivateDriverDataSize);
@@ -112,11 +112,11 @@ TEST_F(Wddm32Tests, whenMonitoredFenceIsCreatedThenSetupAllRequiredFields) {
wddm->wddmInterface->createMonitoredFence(*osContext); wddm->wddmInterface->createMonitoredFence(*osContext);
auto hwQueue = osContext->getHwQueue(); auto hwQueue = osContext->getHwQueue();
EXPECT_EQ(hwQueue.progressFenceCpuVA, osContext->getResidencyController().getMonitoredFence().cpuAddress); EXPECT_EQ(hwQueue.progressFenceCpuVA, osContext->getMonitoredFence().cpuAddress);
EXPECT_EQ(1u, osContext->getResidencyController().getMonitoredFence().currentFenceValue); EXPECT_EQ(1u, osContext->getMonitoredFence().currentFenceValue);
EXPECT_EQ(hwQueue.progressFenceHandle, osContext->getResidencyController().getMonitoredFence().fenceHandle); EXPECT_EQ(hwQueue.progressFenceHandle, osContext->getMonitoredFence().fenceHandle);
EXPECT_EQ(hwQueue.progressFenceGpuVA, osContext->getResidencyController().getMonitoredFence().gpuAddress); EXPECT_EQ(hwQueue.progressFenceGpuVA, osContext->getMonitoredFence().gpuAddress);
EXPECT_EQ(0u, osContext->getResidencyController().getMonitoredFence().lastSubmittedFence); EXPECT_EQ(0u, osContext->getMonitoredFence().lastSubmittedFence);
} }
TEST_F(Wddm32Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhenSubmitCalledThenCallWaitOnGpu) { TEST_F(Wddm32Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhenSubmitCalledThenCallWaitOnGpu) {
@@ -127,7 +127,7 @@ TEST_F(Wddm32Tests, givenCurrentPendingFenceValueGreaterThanPendingFenceValueWhe
WddmSubmitArguments submitArgs = {}; WddmSubmitArguments submitArgs = {};
submitArgs.contextHandle = osContext->getWddmContextHandle(); submitArgs.contextHandle = osContext->getWddmContextHandle();
submitArgs.hwQueueHandle = osContext->getHwQueue().handle; submitArgs.hwQueueHandle = osContext->getHwQueue().handle;
submitArgs.monitorFence = &osContext->getResidencyController().getMonitoredFence(); submitArgs.monitorFence = &osContext->getMonitoredFence();
VariableBackup<volatile uint64_t> pagingFenceBackup(wddm->pagingFenceAddress); VariableBackup<volatile uint64_t> pagingFenceBackup(wddm->pagingFenceAddress);
*wddm->pagingFenceAddress = 1; *wddm->pagingFenceAddress = 1;

6
shared/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -1309,7 +1309,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSingleEngineRegister
ASSERT_EQ(1u, memoryManager->getRegisteredEngines(0).size()); ASSERT_EQ(1u, memoryManager->getRegisteredEngines(0).size());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, 32, AllocationType::buffer, mockDeviceBitfield})); auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, 32, AllocationType::buffer, mockDeviceBitfield}));
auto fence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(0)[0].osContext)->getResidencyController().getMonitoredFence(); auto fence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(0)[0].osContext)->getMonitoredFence();
allocation->getResidencyData().updateCompletionData(129u, 0u); allocation->getResidencyData().updateCompletionData(129u, 0u);
memoryManager->handleFenceCompletion(allocation); memoryManager->handleFenceCompletion(allocation);
@@ -1338,7 +1338,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValuesOnMultipleEnginesRegi
ASSERT_EQ(1u, memoryManager->getRegisteredEngines(rootDeviceIndex).size()); ASSERT_EQ(1u, memoryManager->getRegisteredEngines(rootDeviceIndex).size());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0u, 32, AllocationType::buffer, mockDeviceBitfield})); auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0u, 32, AllocationType::buffer, mockDeviceBitfield}));
auto lastEngineFence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(0)[0].osContext)->getResidencyController().getMonitoredFence(); auto lastEngineFence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(0)[0].osContext)->getMonitoredFence();
allocation->getResidencyData().updateCompletionData(129u, 0u); allocation->getResidencyData().updateCompletionData(129u, 0u);
allocation->getResidencyData().updateCompletionData(152u, 1u); allocation->getResidencyData().updateCompletionData(152u, 1u);
@@ -1370,7 +1370,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSomeOfMultipleEngine
ASSERT_EQ(2u, memoryManager->getRegisteredEngines(rootDeviceIndex).size()); ASSERT_EQ(2u, memoryManager->getRegisteredEngines(rootDeviceIndex).size());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({1u, 32, AllocationType::buffer, mockDeviceBitfield})); auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({1u, 32, AllocationType::buffer, mockDeviceBitfield}));
auto lastEngineFence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(1)[0].osContext)->getResidencyController().getMonitoredFence(); auto lastEngineFence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(1)[0].osContext)->getMonitoredFence();
allocation->getResidencyData().updateCompletionData(129u, 1u); allocation->getResidencyData().updateCompletionData(129u, 1u);
allocation->getResidencyData().updateCompletionData(0, 2u); allocation->getResidencyData().updateCompletionData(0, 2u);

140
shared/test/unit_test/os_interface/windows/wddm_residency_controller_tests.cpp
View File

@@ -214,20 +214,20 @@ TEST(WddmResidencyController, givenWddmResidencyControllerWhenRegisterCallbackTh
} }
TEST_F(WddmResidencyControllerTest, givenWddmResidencyControllerWhenCallingWasAllocationUsedSinceLastTrimThenReturnCorrectValues) { TEST_F(WddmResidencyControllerTest, givenWddmResidencyControllerWhenCallingWasAllocationUsedSinceLastTrimThenReturnCorrectValues) {
residencyController->lastTrimFenceValue = 100; mockOsContextWin->lastTrimFenceValue = 100;
EXPECT_FALSE(residencyController->wasAllocationUsedSinceLastTrim(99)); EXPECT_FALSE(mockOsContextWin->wasAllocationUsedSinceLastTrim(99));
EXPECT_FALSE(residencyController->wasAllocationUsedSinceLastTrim(99)); EXPECT_FALSE(mockOsContextWin->wasAllocationUsedSinceLastTrim(99));
EXPECT_TRUE(residencyController->wasAllocationUsedSinceLastTrim(101)); EXPECT_TRUE(mockOsContextWin->wasAllocationUsedSinceLastTrim(101));
} }
TEST_F(WddmResidencyControllerTest, givenWddmResidencyControllerThenUpdateLastTrimFenceValueUsesMonitoredFence) { TEST_F(WddmResidencyControllerTest, givenWddmResidencyControllerThenUpdateLastTrimFenceValueUsesMonitoredFence) {
*residencyController->getMonitoredFence().cpuAddress = 1234; *mockOsContextWin->getMonitoredFence().cpuAddress = 1234;
residencyController->updateLastTrimFenceValue(); mockOsContextWin->updateLastTrimFenceValue();
EXPECT_EQ(1234u, residencyController->lastTrimFenceValue); EXPECT_EQ(1234u, mockOsContextWin->lastTrimFenceValue);
*residencyController->getMonitoredFence().cpuAddress = 12345; *mockOsContextWin->getMonitoredFence().cpuAddress = 12345;
residencyController->updateLastTrimFenceValue(); mockOsContextWin->updateLastTrimFenceValue();
EXPECT_EQ(12345u, residencyController->lastTrimFenceValue); EXPECT_EQ(12345u, mockOsContextWin->lastTrimFenceValue);
} }
TEST_F(WddmResidencyControllerWithGdiTest, givenWddmResidencyControllerWhenItIsDestructedThenUnregisterTrimCallback) { TEST_F(WddmResidencyControllerWithGdiTest, givenWddmResidencyControllerWhenItIsDestructedThenUnregisterTrimCallback) {
@@ -279,9 +279,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, givenNotUsedAllocationsFromPreviousPe
allocation2.getResidencyData().resident[osContextId] = true; allocation2.getResidencyData().resident[osContextId] = true;
// Set last periodic fence value // Set last periodic fence value
residencyController->lastTrimFenceValue = 10; mockOsContextWin->lastTrimFenceValue = 10;
// Set current fence value to greater value // Set current fence value to greater value
residencyController->getMonitoredFence().currentFenceValue = 20; mockOsContextWin->getMonitoredFence().currentFenceValue = 20;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
wddm->callBaseEvict = true; wddm->callBaseEvict = true;
@@ -315,9 +315,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, givenOneUsedAllocationFromPreviousPer
allocation2.getResidencyData().resident[osContextId] = true; allocation2.getResidencyData().resident[osContextId] = true;
// Set last periodic fence value // Set last periodic fence value
residencyController->lastTrimFenceValue = 10; mockOsContextWin->lastTrimFenceValue = 10;
// Set current fence value to greater value // Set current fence value to greater value
residencyController->getMonitoredFence().currentFenceValue = 20; mockOsContextWin->getMonitoredFence().currentFenceValue = 20;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
@@ -369,10 +369,10 @@ TEST_F(WddmResidencyControllerWithGdiAndMemoryManagerTest, givenTripleAllocation
allocationTriple->fragmentsStorage.fragmentStorageData[2].residency->resident[osContextId] = true; allocationTriple->fragmentsStorage.fragmentStorageData[2].residency->resident[osContextId] = true;
// Set last periodic fence value // Set last periodic fence value
*residencyController->getMonitoredFence().cpuAddress = 10; *static_cast<OsContextWin *>(osContext)->getMonitoredFence().cpuAddress = 10;
residencyController->updateLastTrimFenceValue(); static_cast<OsContextWin *>(osContext)->updateLastTrimFenceValue();
// Set current fence value to greater value // Set current fence value to greater value
residencyController->getMonitoredFence().currentFenceValue = 20; static_cast<OsContextWin *>(osContext)->getMonitoredFence().currentFenceValue = 20;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
wddm->callBaseEvict = true; wddm->callBaseEvict = true;
@@ -397,13 +397,13 @@ TEST_F(WddmResidencyControllerWithGdiTest, givenPeriodicTrimWhenTrimCallbackCall
trimNotification.NumBytesToTrim = 0; trimNotification.NumBytesToTrim = 0;
// Set last periodic fence value // Set last periodic fence value
residencyController->lastTrimFenceValue = 10; mockOsContextWin->lastTrimFenceValue = 10;
// Set current fence value to greater value // Set current fence value to greater value
*residencyController->getMonitoredFence().cpuAddress = 20; *mockOsContextWin->getMonitoredFence().cpuAddress = 20;
residencyController->trimResidency(trimNotification.Flags, trimNotification.NumBytesToTrim); residencyController->trimResidency(trimNotification.Flags, trimNotification.NumBytesToTrim);
EXPECT_EQ(20u, residencyController->lastTrimFenceValue); EXPECT_EQ(20u, mockOsContextWin->lastTrimFenceValue);
} }
TEST_F(WddmResidencyControllerWithGdiTest, givenRestartPeriodicTrimWhenTrimCallbackCalledThenLastPeriodicTrimFenceIsSetToCurrentFenceValue) { TEST_F(WddmResidencyControllerWithGdiTest, givenRestartPeriodicTrimWhenTrimCallbackCalledThenLastPeriodicTrimFenceIsSetToCurrentFenceValue) {
@@ -412,13 +412,13 @@ TEST_F(WddmResidencyControllerWithGdiTest, givenRestartPeriodicTrimWhenTrimCallb
trimNotification.NumBytesToTrim = 0; trimNotification.NumBytesToTrim = 0;
// Set last periodic fence value // Set last periodic fence value
residencyController->lastTrimFenceValue = 10; mockOsContextWin->lastTrimFenceValue = 10;
// Set current fence value to greater value // Set current fence value to greater value
*residencyController->getMonitoredFence().cpuAddress = 20; *mockOsContextWin->getMonitoredFence().cpuAddress = 20;
residencyController->trimResidency(trimNotification.Flags, trimNotification.NumBytesToTrim); residencyController->trimResidency(trimNotification.Flags, trimNotification.NumBytesToTrim);
EXPECT_EQ(20u, residencyController->lastTrimFenceValue); EXPECT_EQ(20u, mockOsContextWin->lastTrimFenceValue);
} }
HWTEST_F(WddmResidencyControllerWithGdiTest, GivenZeroWhenTrimmingToBudgetThenTrueIsReturnedAndDrainPagingFenceQueueCalled) { HWTEST_F(WddmResidencyControllerWithGdiTest, GivenZeroWhenTrimmingToBudgetThenTrueIsReturnedAndDrainPagingFenceQueueCalled) {
@@ -445,9 +445,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, WhenTrimmingToBudgetThenAllDoneAlloca
allocation3.getResidencyData().updateCompletionData(2, osContextId); allocation3.getResidencyData().updateCompletionData(2, osContextId);
allocation3.getResidencyData().resident[osContextId] = true; allocation3.getResidencyData().resident[osContextId] = true;
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 1; mockOsContextWin->getMonitoredFence().currentFenceValue = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
wddm->callBaseEvict = true; wddm->callBaseEvict = true;
@@ -474,8 +474,8 @@ TEST_F(WddmResidencyControllerWithGdiTest, GivenNumBytesToTrimIsNotZeroWhenTrimm
allocation1.getResidencyData().resident[osContextId] = true; allocation1.getResidencyData().resident[osContextId] = true;
allocation1.getResidencyData().updateCompletionData(0, osContextId); allocation1.getResidencyData().updateCompletionData(0, osContextId);
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
@@ -506,9 +506,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, GivenNumBytesToTrimIsZeroWhenTrimming
allocation3.getResidencyData().updateCompletionData(2, osContextId); allocation3.getResidencyData().updateCompletionData(2, osContextId);
allocation3.getResidencyData().resident[osContextId] = true; allocation3.getResidencyData().resident[osContextId] = true;
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 1; mockOsContextWin->getMonitoredFence().currentFenceValue = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
@@ -541,9 +541,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, WhenTrimmingToBudgetThenEvictedAlloca
allocation3.getResidencyData().updateCompletionData(2, osContextId); allocation3.getResidencyData().updateCompletionData(2, osContextId);
allocation3.getResidencyData().resident[osContextId] = true; allocation3.getResidencyData().resident[osContextId] = true;
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 1; mockOsContextWin->getMonitoredFence().currentFenceValue = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
@@ -566,9 +566,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, givenAlwaysResidentAllocationWhenTrim
allocation.getResidencyData().resident[osContextId] = true; allocation.getResidencyData().resident[osContextId] = true;
allocation.getResidencyData().updateCompletionData(0, osContextId); allocation.getResidencyData().updateCompletionData(0, osContextId);
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 1; mockOsContextWin->getMonitoredFence().currentFenceValue = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
@@ -588,9 +588,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, givenAlwaysResidentAllocationWhenTrim
allocation.getResidencyData().resident[osContextId] = true; allocation.getResidencyData().resident[osContextId] = true;
allocation.getResidencyData().updateCompletionData(0, osContextId); allocation.getResidencyData().updateCompletionData(0, osContextId);
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 1; mockOsContextWin->getMonitoredFence().currentFenceValue = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
@@ -613,9 +613,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, GivenLastFenceIsGreaterThanMonitoredW
allocation1.getResidencyData().resident[osContextId] = true; allocation1.getResidencyData().resident[osContextId] = true;
allocation1.getResidencyData().updateCompletionData(2, osContextId); allocation1.getResidencyData().updateCompletionData(2, osContextId);
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 2; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 2;
residencyController->getMonitoredFence().currentFenceValue = 3; mockOsContextWin->getMonitoredFence().currentFenceValue = 3;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
wddm->waitFromCpuResult.called = 0; wddm->waitFromCpuResult.called = 0;
@@ -668,9 +668,9 @@ TEST_F(WddmResidencyControllerWithGdiAndMemoryManagerTest, WhenTrimmingToBudgetT
residencyController->getEvictionAllocations().push_back(allocationTriple); residencyController->getEvictionAllocations().push_back(allocationTriple);
residencyController->getEvictionAllocations().push_back(&allocation2); residencyController->getEvictionAllocations().push_back(&allocation2);
*residencyController->getMonitoredFence().cpuAddress = 1; *static_cast<OsContextWin *>(osContext)->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; static_cast<OsContextWin *>(osContext)->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 2; static_cast<OsContextWin *>(osContext)->getMonitoredFence().currentFenceValue = 2;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
wddm->callBaseEvict = true; wddm->callBaseEvict = true;
@@ -713,9 +713,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, givenThreeAllocationsAlignedSizeBigge
allocation3.getResidencyData().updateCompletionData(1, osContextId); allocation3.getResidencyData().updateCompletionData(1, osContextId);
allocation3.getResidencyData().resident[osContextId] = true; allocation3.getResidencyData().resident[osContextId] = true;
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 1; mockOsContextWin->getMonitoredFence().currentFenceValue = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
@@ -777,7 +777,7 @@ TEST_F(WddmResidencyControllerWithGdiAndMemoryManagerTest, WhenMakingResidentRes
MockWddmAllocation allocation4(gmmHelper); MockWddmAllocation allocation4(gmmHelper);
ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4}; ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_TRUE(allocation1.getResidencyData().resident[osContextId]); EXPECT_TRUE(allocation1.getResidencyData().resident[osContextId]);
EXPECT_TRUE(allocation2.getResidencyData().resident[osContextId]); EXPECT_TRUE(allocation2.getResidencyData().resident[osContextId]);
@@ -792,9 +792,9 @@ TEST_F(WddmResidencyControllerWithGdiAndMemoryManagerTest, WhenMakingResidentRes
MockWddmAllocation allocation4(gmmHelper); MockWddmAllocation allocation4(gmmHelper);
ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4}; ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4};
residencyController->getMonitoredFence().currentFenceValue = 20; static_cast<OsContextWin *>(osContext)->getMonitoredFence().currentFenceValue = 20;
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_EQ(20u, allocation1.getResidencyData().getFenceValueForContextId(osContext->getContextId())); EXPECT_EQ(20u, allocation1.getResidencyData().getFenceValueForContextId(osContext->getContextId()));
EXPECT_EQ(20u, allocation2.getResidencyData().getFenceValueForContextId(osContext->getContextId())); EXPECT_EQ(20u, allocation2.getResidencyData().getFenceValueForContextId(osContext->getContextId()));
@@ -814,7 +814,7 @@ TEST_F(WddmResidencyControllerWithGdiAndMemoryManagerTest, GivenTripleAllocation
WddmAllocation *allocationTriple = (WddmAllocation *)memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), false, 2 * MemoryConstants::pageSize}, ptr); WddmAllocation *allocationTriple = (WddmAllocation *)memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), false, 2 * MemoryConstants::pageSize}, ptr);
ResidencyContainer residencyPack{&allocation1, allocationTriple, &allocation2}; ResidencyContainer residencyPack{&allocation1, allocationTriple, &allocation2};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
for (uint32_t i = 0; i < allocationTriple->fragmentsStorage.fragmentCount; i++) { for (uint32_t i = 0; i < allocationTriple->fragmentsStorage.fragmentCount; i++) {
EXPECT_TRUE(allocationTriple->fragmentsStorage.fragmentStorageData[i].residency->resident[osContextId]); EXPECT_TRUE(allocationTriple->fragmentsStorage.fragmentStorageData[i].residency->resident[osContextId]);
@@ -831,10 +831,10 @@ TEST_F(WddmResidencyControllerWithGdiAndMemoryManagerTest, GivenTripleAllocation
WddmAllocation *allocationTriple = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), false, 2 * MemoryConstants::pageSize}, reinterpret_cast<void *>(0x1500))); WddmAllocation *allocationTriple = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), false, 2 * MemoryConstants::pageSize}, reinterpret_cast<void *>(0x1500)));
residencyController->getMonitoredFence().currentFenceValue = 20; static_cast<OsContextWin *>(osContext)->getMonitoredFence().currentFenceValue = 20;
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
ResidencyContainer residencyPack{&allocation1, allocationTriple, &allocation2}; ResidencyContainer residencyPack{&allocation1, allocationTriple, &allocation2};
residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
for (uint32_t i = 0; i < allocationTriple->fragmentsStorage.fragmentCount; i++) { for (uint32_t i = 0; i < allocationTriple->fragmentsStorage.fragmentCount; i++) {
EXPECT_EQ(20u, allocationTriple->fragmentsStorage.fragmentStorageData[i].residency->getFenceValueForContextId(0)); EXPECT_EQ(20u, allocationTriple->fragmentsStorage.fragmentStorageData[i].residency->getFenceValueForContextId(0));
@@ -854,7 +854,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsWhenCallin
ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4}; ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_FALSE(result); EXPECT_FALSE(result);
@@ -876,7 +876,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsWhenCallin
ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4}; ResidencyContainer residencyPack{&allocation1, &allocation2, &allocation3, &allocation4};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_FALSE(result); EXPECT_FALSE(result);
EXPECT_EQ(residencyPack.size(), 0u); EXPECT_EQ(residencyPack.size(), 0u);
@@ -895,7 +895,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsWhenCallin
ResidencyContainer residencyPack{&allocation1, allocationTriple, &allocation2}; ResidencyContainer residencyPack{&allocation1, allocationTriple, &allocation2};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_FALSE(result); EXPECT_FALSE(result);
@@ -910,14 +910,14 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsWhenCallin
TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsWhenCallingMakeResidentResidencyAllocationsThenCallItAgainWithCantTrimFurtherSetToTrue) { TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsWhenCallingMakeResidentResidencyAllocationsThenCallItAgainWithCantTrimFurtherSetToTrue) {
MockWddmAllocation allocation1(gmmHelper); MockWddmAllocation allocation1(gmmHelper);
allocation1.getResidencyData().updateCompletionData(0, osContextId); allocation1.getResidencyData().updateCompletionData(0, osContextId);
residencyController->getMonitoredFence().currentFenceValue = 10; static_cast<OsContextWin *>(osContext)->getMonitoredFence().currentFenceValue = 10;
wddm->makeResidentNumberOfBytesToTrim = 4 * 4096; wddm->makeResidentNumberOfBytesToTrim = 4 * 4096;
wddm->makeResidentStatus = false; wddm->makeResidentStatus = false;
ResidencyContainer residencyPack{&allocation1}; ResidencyContainer residencyPack{&allocation1};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_FALSE(result); EXPECT_FALSE(result);
EXPECT_NE(wddm->makeResidentParamsPassed[0].cantTrimFurther, wddm->makeResidentParamsPassed[1].cantTrimFurther); EXPECT_NE(wddm->makeResidentParamsPassed[0].cantTrimFurther, wddm->makeResidentParamsPassed[1].cantTrimFurther);
@@ -932,7 +932,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenAllocationPackPassedWhenCal
allocation2.handle = 2; allocation2.handle = 2;
ResidencyContainer residencyPack{&allocation1, &allocation2}; ResidencyContainer residencyPack{&allocation1, &allocation2};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_TRUE(result); EXPECT_TRUE(result);
EXPECT_EQ(2 * EngineLimits::maxHandleCount, wddm->makeResidentResult.handleCount); EXPECT_EQ(2 * EngineLimits::maxHandleCount, wddm->makeResidentResult.handleCount);
EXPECT_EQ(false, wddm->makeResidentResult.cantTrimFurther); EXPECT_EQ(false, wddm->makeResidentResult.cantTrimFurther);
@@ -948,7 +948,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsAndTrimToB
auto canonizedAddress = gmmHelper->canonize(castToUint64(const_cast<void *>(cpuPtr))); auto canonizedAddress = gmmHelper->canonize(castToUint64(const_cast<void *>(cpuPtr)));
WddmAllocation allocationToTrim(0, 1u /*num gmms*/, AllocationType::unknown, cpuPtr, canonizedAddress, allocationSize, nullptr, MemoryPool::memoryNull, 0u, 1u); WddmAllocation allocationToTrim(0, 1u /*num gmms*/, AllocationType::unknown, cpuPtr, canonizedAddress, allocationSize, nullptr, MemoryPool::memoryNull, 0u, 1u);
allocationToTrim.getResidencyData().updateCompletionData(residencyController->getMonitoredFence().lastSubmittedFence, osContextId); allocationToTrim.getResidencyData().updateCompletionData(static_cast<OsContextWin *>(osContext)->getMonitoredFence().lastSubmittedFence, osContextId);
allocationToTrim.getResidencyData().resident[osContextId] = true; allocationToTrim.getResidencyData().resident[osContextId] = true;
residencyController->getEvictionAllocations().push_back(&allocationToTrim); residencyController->getEvictionAllocations().push_back(&allocationToTrim);
@@ -957,7 +957,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsAndTrimToB
ResidencyContainer residencyPack{&allocation1}; ResidencyContainer residencyPack{&allocation1};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_TRUE(result); EXPECT_TRUE(result);
@@ -974,7 +974,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsAndTrimToB
auto canonizedAddress = gmmHelper->canonize(castToUint64(const_cast<void *>(cpuPtr))); auto canonizedAddress = gmmHelper->canonize(castToUint64(const_cast<void *>(cpuPtr)));
WddmAllocation allocationAlreadyResident(0, 1u /*num gmms*/, AllocationType::unknown, cpuPtr, canonizedAddress, allocationSize, nullptr, MemoryPool::memoryNull, 0u, 1u); WddmAllocation allocationAlreadyResident(0, 1u /*num gmms*/, AllocationType::unknown, cpuPtr, canonizedAddress, allocationSize, nullptr, MemoryPool::memoryNull, 0u, 1u);
allocationAlreadyResident.getResidencyData().updateCompletionData(residencyController->getMonitoredFence().lastSubmittedFence, osContextId); allocationAlreadyResident.getResidencyData().updateCompletionData(static_cast<OsContextWin *>(osContext)->getMonitoredFence().lastSubmittedFence, osContextId);
allocationAlreadyResident.getResidencyData().resident[osContextId] = true; allocationAlreadyResident.getResidencyData().resident[osContextId] = true;
residencyController->getEvictionAllocations().push_back(&allocationAlreadyResident); residencyController->getEvictionAllocations().push_back(&allocationAlreadyResident);
@@ -983,7 +983,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsAndTrimToB
ResidencyContainer residencyPack{&allocation1, &allocationAlreadyResident}; ResidencyContainer residencyPack{&allocation1, &allocationAlreadyResident};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_TRUE(result); EXPECT_TRUE(result);
@@ -1000,7 +1000,7 @@ TEST_F(WddmResidencyControllerWithMockWddmTest, givenMakeResidentFailsWhenCallin
wddm->makeResidentResults = {false, true}; wddm->makeResidentResults = {false, true};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_TRUE(residencyController->isMemoryBudgetExhausted()); EXPECT_TRUE(residencyController->isMemoryBudgetExhausted());
EXPECT_EQ(2u, wddm->makeResidentResult.called); EXPECT_EQ(2u, wddm->makeResidentResult.called);
} }
@@ -1052,7 +1052,7 @@ TEST_F(WddmResidencyControllerWithMockWddmMakeResidentTest, givenMakeResidentFai
MockWddmAllocation allocation1(gmmHelper); MockWddmAllocation allocation1(gmmHelper);
ResidencyContainer residencyPack{&allocation1}; ResidencyContainer residencyPack{&allocation1};
bool requiresBlockingResidencyHandling = true; bool requiresBlockingResidencyHandling = true;
bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, osContext->getContextId()); bool result = residencyController->makeResidentResidencyAllocations(residencyPack, requiresBlockingResidencyHandling, *static_cast<OsContextWin *>(osContext));
EXPECT_TRUE(result); EXPECT_TRUE(result);
EXPECT_EQ(3u, wddm->makeResidentResult.called); EXPECT_EQ(3u, wddm->makeResidentResult.called);
@@ -1125,9 +1125,9 @@ TEST_F(WddmResidencyControllerWithGdiTest, GivenResidencyLoggingEnabledWhenTrimm
allocation3.getResidencyData().updateCompletionData(2, osContextId); allocation3.getResidencyData().updateCompletionData(2, osContextId);
allocation3.getResidencyData().resident[osContextId] = true; allocation3.getResidencyData().resident[osContextId] = true;
*residencyController->getMonitoredFence().cpuAddress = 1; *mockOsContextWin->getMonitoredFence().cpuAddress = 1;
residencyController->getMonitoredFence().lastSubmittedFence = 1; mockOsContextWin->getMonitoredFence().lastSubmittedFence = 1;
residencyController->getMonitoredFence().currentFenceValue = 1; mockOsContextWin->getMonitoredFence().currentFenceValue = 1;
wddm->evictResult.called = 0; wddm->evictResult.called = 0;
wddm->callBaseEvict = true; wddm->callBaseEvict = true;