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

fix: store registered engines per root device

Browse Source 
in most cases we need to iterate over engines associated to single root device

Related-To: NEO-7925
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-04-26 10:36:25 +00:00
committed by Compute-Runtime-Automation
parent 9cc5763800
commit 32d8a3bc6d
62 changed files with 777 additions and 805 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
opencl/test/unit_test/device/device_tests.cpp
View File

@@ -216,7 +216,7 @@ HWTEST_F(DeviceTest, givenDeviceWithoutSubDevicesWhenCreatingContextsThenMemoryM
auto rootDeviceIndex = device.getRootDeviceIndex();
MockMemoryManager *memoryManager = static_cast<MockMemoryManager *>(device.getMemoryManager());
OsContext *defaultOsContextMemoryManager = memoryManager->registeredEngines[memoryManager->defaultEngineIndex[rootDeviceIndex]].osContext;
OsContext *defaultOsContextMemoryManager = memoryManager->getRegisteredEngines(rootDeviceIndex)[memoryManager->defaultEngineIndex[rootDeviceIndex]].osContext;
OsContext *defaultOsContextRootDevice = device.getDefaultEngine().osContext;
EXPECT_EQ(defaultOsContextRootDevice, defaultOsContextMemoryManager);
}
@@ -227,7 +227,7 @@ HWTEST_F(DeviceTest, givenDeviceWithSubDevicesWhenCreatingContextsThenMemoryMana
auto rootDeviceIndex = device.getRootDeviceIndex();
MockMemoryManager *memoryManager = static_cast<MockMemoryManager *>(device.getMemoryManager());
OsContext *defaultOsContextMemoryManager = memoryManager->registeredEngines[memoryManager->defaultEngineIndex[rootDeviceIndex]].osContext;
OsContext *defaultOsContextMemoryManager = memoryManager->getRegisteredEngines(rootDeviceIndex)[memoryManager->defaultEngineIndex[rootDeviceIndex]].osContext;
OsContext *defaultOsContextRootDevice = device.getDefaultEngine().osContext;
EXPECT_EQ(defaultOsContextRootDevice, defaultOsContextMemoryManager);
}
@@ -238,7 +238,8 @@ HWTEST_F(DeviceTest, givenMultiDeviceWhenCreatingContextsThenMemoryManagerDefaul
MockMemoryManager *memoryManager = static_cast<MockMemoryManager *>(device.getMemoryManager());
for (auto &pRootDevice : factory.rootDevices) {
OsContext *defaultOsContextMemoryManager = memoryManager->registeredEngines[memoryManager->defaultEngineIndex[pRootDevice->getRootDeviceIndex()]].osContext;
auto rootDeviceIndex = pRootDevice->getRootDeviceIndex();
OsContext *defaultOsContextMemoryManager = memoryManager->getRegisteredEngines(rootDeviceIndex)[memoryManager->defaultEngineIndex[rootDeviceIndex]].osContext;
OsContext *defaultOsContextRootDevice = pRootDevice->getDefaultEngine().osContext;
EXPECT_EQ(defaultOsContextRootDevice, defaultOsContextMemoryManager);
}
@@ -283,7 +284,7 @@ TEST(DeviceCreation, givenDeviceWhenItIsCreatedThenOsContextIsRegistredInMemoryM
} else if (device->getNumSubDevices() > 0) {
numEnginesForDevice += device->getNumSubDevices();
}
EXPECT_EQ(numEnginesForDevice, memoryManager->getRegisteredEnginesCount());
EXPECT_EQ(numEnginesForDevice, memoryManager->getRegisteredEngines(device->getRootDeviceIndex()).size());
}
TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasUniqueId) {
@@ -301,7 +302,6 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasU
MockDevice *devices[] = {device1.get(), device2.get()};
auto &registeredEngines = executionEnvironment->memoryManager->getRegisteredEngines();
auto &gfxCoreHelper = device1->getGfxCoreHelper();
const auto &numGpgpuEngines = static_cast<uint32_t>(gfxCoreHelper.getGpgpuEngineInstances(device1->getRootDeviceEnvironment()).size());
@@ -311,13 +311,14 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasU
numExpectedEngineInstancedEnginesPerDevice = device1->getNumSubDevices();
}
auto expectedTotalRegisteredEngines = (numExpectedGenericEnginesPerDevice + numExpectedEngineInstancedEnginesPerDevice) * numDevices;
EXPECT_EQ(expectedTotalRegisteredEngines, registeredEngines.size());
auto expectedTotalRegisteredEnginesPerRootDevice = numExpectedGenericEnginesPerDevice + numExpectedEngineInstancedEnginesPerDevice;
uint32_t contextId = 0;
for (uint32_t i = 0; i < numDevices; i++) {
uint32_t contextWithinRootDevice = 0;
auto &registeredEngines = executionEnvironment->memoryManager->getRegisteredEngines(i);
EXPECT_EQ(expectedTotalRegisteredEnginesPerRootDevice, registeredEngines.size());
auto device = devices[i];
for (uint32_t j = 0; j < numExpectedEngineInstancedEnginesPerDevice; j++) {
@@ -326,10 +327,11 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasU
EXPECT_EQ(contextId, engine.osContext->getContextId());
EXPECT_EQ(1u, engine.osContext->getDeviceBitfield().to_ulong());
EXPECT_EQ(registeredEngines[contextId].commandStreamReceiver,
EXPECT_EQ(registeredEngines[contextWithinRootDevice].commandStreamReceiver,
engine.commandStreamReceiver);
contextId++;
contextWithinRootDevice++;
}
for (uint32_t j = 0; j < numExpectedGenericEnginesPerDevice; j++) {
@@ -338,14 +340,13 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasU
EXPECT_EQ(contextId, engine.osContext->getContextId());
EXPECT_EQ(1u, engine.osContext->getDeviceBitfield().to_ulong());
EXPECT_EQ(registeredEngines[contextId].commandStreamReceiver,
EXPECT_EQ(registeredEngines[contextWithinRootDevice].commandStreamReceiver,
engine.commandStreamReceiver);
contextId++;
contextWithinRootDevice++;
}
}
EXPECT_EQ(expectedTotalRegisteredEngines, executionEnvironment->memoryManager->getRegisteredEnginesCount());
}
TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSeperateDeviceIndex) {

42
opencl/test/unit_test/memory_manager/memory_manager_tests.cpp
View File

@@ -2122,19 +2122,6 @@ TEST(GraphicsAllocation, givenSharedHandleBasedConstructorWhenGraphicsAllocation
EXPECT_EQ(expectedGpuAddress, graphicsAllocation.getGpuAddress());
}
TEST(ResidencyDataTest, givenOsContextWhenItIsRegisteredToMemoryManagerThenRefCountIncreases) {
MockExecutionEnvironment executionEnvironment(defaultHwInfo.get());
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto memoryManager = new MockMemoryManager(false, false, executionEnvironment);
executionEnvironment.memoryManager.reset(memoryManager);
DeviceBitfield deviceBitfield(1);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u, deviceBitfield));
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment.rootDeviceEnvironments[0])[0],
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo)));
EXPECT_EQ(1u, memoryManager->getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager->registeredEngines[0].osContext->getRefInternalCount());
}
TEST(MemoryManagerRegisteredEnginesTest, givenOsContextWhenItIsUnregisteredFromMemoryManagerThenRefCountDecreases) {
auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
auto memoryManager = device->getMemoryManager();
@@ -2160,9 +2147,10 @@ TEST(ResidencyDataTest, givenDeviceBitfieldWhenCreatingOsContextThenSetValidValu
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment.rootDeviceEnvironments[0])[0],
preemptionMode,
deviceBitfield));
EXPECT_EQ(2u, memoryManager->registeredEngines[0].osContext->getNumSupportedDevices());
EXPECT_EQ(deviceBitfield, memoryManager->registeredEngines[0].osContext->getDeviceBitfield());
EXPECT_EQ(preemptionMode, memoryManager->registeredEngines[0].osContext->getPreemptionMode());
auto &engine = memoryManager->getRegisteredEngines(0u)[0];
EXPECT_EQ(2u, engine.osContext->getNumSupportedDevices());
EXPECT_EQ(deviceBitfield, engine.osContext->getDeviceBitfield());
EXPECT_EQ(preemptionMode, engine.osContext->getPreemptionMode());
}
TEST(ResidencyDataTest, givenTwoOsContextsWhenTheyAreRegisteredFromHigherToLowerThenProperSizeIsReturned) {
@@ -2177,9 +2165,11 @@ TEST(ResidencyDataTest, givenTwoOsContextsWhenTheyAreRegisteredFromHigherToLower
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo)));
memoryManager->createAndRegisterOsContext(csr1.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment.rootDeviceEnvironments[0])[0],
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo)));
EXPECT_EQ(2u, memoryManager->getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager->registeredEngines[0].osContext->getRefInternalCount());
EXPECT_EQ(1, memoryManager->registeredEngines[1].osContext->getRefInternalCount());
EXPECT_EQ(2u, memoryManager->allRegisteredEngines.size());
EXPECT_EQ(1u, memoryManager->allRegisteredEngines[0].size());
EXPECT_EQ(1u, memoryManager->allRegisteredEngines[1].size());
EXPECT_EQ(1, memoryManager->allRegisteredEngines[0][0].osContext->getRefInternalCount());
EXPECT_EQ(1, memoryManager->allRegisteredEngines[1][0].osContext->getRefInternalCount());
}
TEST(ResidencyDataTest, givenGpgpuEnginesWhenAskedForMaxOsContextCountThenValueIsGreaterOrEqual) {
@@ -2587,8 +2577,8 @@ TEST_F(MemoryAllocatorTest, whenCommandStreamerIsRegisteredThenReturnAssociatedE
}
TEST_F(MemoryAllocatorTest, whenCommandStreamerIsNotRegisteredThenReturnNullEngineControl) {
CommandStreamReceiver *dummyCsr = reinterpret_cast<CommandStreamReceiver *>(0x1);
auto engineControl = memoryManager->getRegisteredEngineForCsr(dummyCsr);
MockCommandStreamReceiver csr{*executionEnvironment, 0u, {}};
auto engineControl = memoryManager->getRegisteredEngineForCsr(&csr);
EXPECT_EQ(nullptr, engineControl);
}
@@ -2808,8 +2798,8 @@ HWTEST_F(PageTableManagerTest, givenPageTableManagerWhenMapAuxGpuVaThenForAllEng
auto mockMngr = new MockGmmPageTableMngr();
auto mockMngr2 = new MockGmmPageTableMngr();
memoryManager->getRegisteredEngines()[0].commandStreamReceiver->pageTableManager.reset(mockMngr);
memoryManager->getRegisteredEngines()[1].commandStreamReceiver->pageTableManager.reset(mockMngr2);
memoryManager->getRegisteredEngines(1)[0].commandStreamReceiver->pageTableManager.reset(mockMngr);
memoryManager->getRegisteredEngines(1)[1].commandStreamReceiver->pageTableManager.reset(mockMngr2);
MockGraphicsAllocation allocation(1u, AllocationType::UNKNOWN, nullptr, 0, 0, MemoryPool::MemoryNull, MemoryManager::maxOsContextCount, 0llu);
MockGmm gmm(executionEnvironment->rootDeviceEnvironments[allocation.getRootDeviceIndex()]->getGmmHelper());
@@ -2853,7 +2843,7 @@ HWTEST_F(PageTableManagerTest, givenPageTableManagerWhenUpdateAuxTableGmmErrorTh
auto mockMngr = new MockGmmPageTableMngr();
mockMngr->updateAuxTableResult = GMM_ERROR;
memoryManager->getRegisteredEngines()[0].commandStreamReceiver->pageTableManager.reset(mockMngr);
memoryManager->getRegisteredEngines(1)[0].commandStreamReceiver->pageTableManager.reset(mockMngr);
MockGraphicsAllocation allocation(1u, AllocationType::UNKNOWN, nullptr, 0, 0, MemoryPool::MemoryNull, MemoryManager::maxOsContextCount, 0llu);
MockGmm gmm(executionEnvironment->rootDeviceEnvironments[allocation.getRootDeviceIndex()]->getGmmHelper());
@@ -2885,7 +2875,7 @@ HWTEST_F(PageTableManagerTest, givenNullPageTableManagerWhenMapAuxGpuVaThenNoThr
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(regularEngines[0],
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
memoryManager->getRegisteredEngines()[0].commandStreamReceiver->pageTableManager.reset(nullptr);
memoryManager->getRegisteredEngines(1)[0].commandStreamReceiver->pageTableManager.reset(nullptr);
MockGraphicsAllocation allocation(1u, AllocationType::UNKNOWN, nullptr, 0, 0, MemoryPool::MemoryNull, MemoryManager::maxOsContextCount, 0llu);
MockGmm gmm(executionEnvironment->rootDeviceEnvironments[allocation.getRootDeviceIndex()]->getGmmHelper());
@@ -2912,7 +2902,7 @@ HWTEST_F(PageTableManagerTest, givenNullPageTableManagerWhenMapAuxGpuVaThenRetur
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment->rootDeviceEnvironments[0])[0],
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
for (auto engine : memoryManager->getRegisteredEngines()) {
for (auto engine : memoryManager->getRegisteredEngines(1)) {
engine.commandStreamReceiver->pageTableManager.reset(nullptr);
}

80
opencl/test/unit_test/os_interface/windows/wddm_memory_manager_allocate_in_device_pool_tests.cpp
View File

@@ -19,7 +19,7 @@ using namespace NEO;
using namespace ::testing;
TEST_F(WddmMemoryManagerSimpleTest, givenUseSystemMemorySetToTrueWhenAllocateInDevicePoolIsCalledThenNullptrIsReturned) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.size = MemoryConstants::pageSize;
@@ -34,7 +34,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenUseSystemMemorySetToTrueWhenAllocateInD
TEST_F(WddmMemoryManagerSimpleTest, givenNotSetUseSystemMemoryWhenGraphicsAllocationInDevicePoolIsAllocatedThenLocalMemoryAllocationIsReturned) {
const bool localMemoryEnabled = true;
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
allocData.allFlags = 0;
@@ -55,10 +55,10 @@ TEST_F(WddmMemoryManagerSimpleTest, givenShareableAllocationWhenAllocateInDevice
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.featureTable.flags.ftrLocalMemory = true;
executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(&hwInfo);
executionEnvironment->rootDeviceEnvironments[0]->initGmm();
executionEnvironment.rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(&hwInfo);
executionEnvironment.rootDeviceEnvironments[0]->initGmm();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
allocData.allFlags = 0;
@@ -90,10 +90,10 @@ TEST_F(WddmMemoryManagerSimpleTest, givenShareableAllocationWhenAllocateGraphics
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo.get();
hwInfo.featureTable.flags.ftrLocalMemory = true;
executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(&hwInfo);
executionEnvironment->rootDeviceEnvironments[0]->initGmm();
executionEnvironment.rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(&hwInfo);
executionEnvironment.rootDeviceEnvironments[0]->initGmm();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
AllocationProperties properties{mockRootDeviceIndex, MemoryConstants::pageSize, AllocationType::SVM_GPU, mockDeviceBitfield};
properties.allFlags = 0;
properties.size = MemoryConstants::pageSize;
@@ -118,7 +118,7 @@ struct WddmMemoryManagerDevicePoolAlignmentTests : WddmMemoryManagerSimpleTest {
void testAlignment(uint32_t allocationSize, uint32_t expectedAlignment) {
const bool enable64kbPages = false;
const bool localMemoryEnabled = true;
memoryManager = std::make_unique<MockWddmMemoryManager>(enable64kbPages, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(enable64kbPages, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
@@ -229,7 +229,7 @@ TEST_F(WddmMemoryManagerDevicePoolAlignmentTests, givenAtLeast2MbAllocationWhenA
}
HWTEST_F(WddmMemoryManagerSimpleTest, givenLinearStreamWhenItIsAllocatedThenItIsInLocalMemoryHasCpuPointerAndHasStandardHeap64kbAsGpuAddress) {
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties({mockRootDeviceIndex, 4096u, AllocationType::LINEAR_STREAM, mockDeviceBitfield});
@@ -243,7 +243,7 @@ HWTEST_F(WddmMemoryManagerSimpleTest, givenLinearStreamWhenItIsAllocatedThenItIs
if (is64bit) {
auto gmmHelper = memoryManager->getGmmHelper(graphicsAllocation->getRootDeviceIndex());
if (executionEnvironment->rootDeviceEnvironments[graphicsAllocation->getRootDeviceIndex()]->isFullRangeSvm()) {
if (executionEnvironment.rootDeviceEnvironments[graphicsAllocation->getRootDeviceIndex()]->isFullRangeSvm()) {
EXPECT_GE(gpuAddress, gmmHelper->canonize(partition.Standard64KB.Base));
EXPECT_LE(gpuAddressEnd, gmmHelper->canonize(partition.Standard64KB.Limit));
} else {
@@ -251,7 +251,7 @@ HWTEST_F(WddmMemoryManagerSimpleTest, givenLinearStreamWhenItIsAllocatedThenItIs
EXPECT_LE(gpuAddressEnd, gmmHelper->canonize(partition.Standard.Limit));
}
} else {
if (executionEnvironment->rootDeviceEnvironments[graphicsAllocation->getRootDeviceIndex()]->isFullRangeSvm()) {
if (executionEnvironment.rootDeviceEnvironments[graphicsAllocation->getRootDeviceIndex()]->isFullRangeSvm()) {
EXPECT_GE(gpuAddress, 0ull);
EXPECT_LE(gpuAddress, UINT32_MAX);
@@ -266,8 +266,7 @@ HWTEST_F(WddmMemoryManagerSimpleTest, givenLinearStreamWhenItIsAllocatedThenItIs
}
TEST_F(WddmMemoryManagerSimpleTest, givenNotSetUseSystemMemoryWhenGraphicsAllocationInDevicePoolIsAllocatedThenLocalMemoryAllocationHasCorrectStorageInfoAndFlushL3IsSet) {
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
allocData.allFlags = 0;
@@ -290,8 +289,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNotSetUseSystemMemoryWhenGraphicsAlloca
}
TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryAndUseSytemMemoryWhenGraphicsAllocationInDevicePoolIsAllocatedThenNullptrIsReturned) {
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
@@ -305,8 +303,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryAndUseSytemMemoryWhen
}
TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryAndAllowed32BitAndForce32BitWhenGraphicsAllocationInDevicePoolIsAllocatedThenNullptrIsReturned) {
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
memoryManager->setForce32BitAllocations(true);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
@@ -324,8 +321,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryAndAllowed32BitAndFor
TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryAndAllowed32BitWhen32BitIsNotForcedThenGraphicsAllocationInDevicePoolReturnsLocalMemoryAllocation) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
memoryManager->setForce32BitAllocations(false);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
@@ -346,8 +342,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryAndAllowed32BitWhen32
TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryWhenAllocateFailsThenGraphicsAllocationInDevicePoolReturnsError) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
@@ -367,8 +362,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryWhenAllocateFailsThen
TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryWhenAllocateFailsThenGraphicsAllocationInPhysicalLocalDeviceMemoryReturnsError) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
@@ -387,8 +381,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenEnabledLocalMemoryWhenAllocateFailsThen
}
TEST_F(WddmMemoryManagerSimpleTest, givenAllocatePhysicalLocalDeviceMemoryThenLocalMemoryAllocationHasCorrectStorageInfoAndNoGpuAddress) {
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
allocData.allFlags = 0;
@@ -411,8 +404,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocatePhysicalLocalDeviceMemoryThenLo
}
TEST_F(WddmMemoryManagerSimpleTest, givenAllocatePhysicalLocalDeviceMemoryWithMultiStorageThenLocalMemoryAllocationHasCorrectStorageInfoAndNoGpuAddress) {
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
allocData.allFlags = 0;
@@ -436,8 +428,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocatePhysicalLocalDeviceMemoryWithMu
}
TEST_F(WddmMemoryManagerSimpleTest, givenAllocatePhysicalLocalDeviceMemoryWithMultiBanksThenLocalMemoryAllocationHasCorrectStorageInfoAndNoGpuAddress) {
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
allocData.allFlags = 0;
@@ -462,7 +453,6 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocatePhysicalLocalDeviceMemoryWithMu
TEST_F(WddmMemoryManagerTest, givenLocalMemoryAllocationWhenCpuPointerNotMeetRestrictionsThenDontReserveMemRangeForMap) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
void *cpuPtr = reinterpret_cast<void *>(memoryManager->getAlignedMallocRestrictions()->minAddress - 0x1000);
size_t size = 0x1000;
@@ -483,8 +473,7 @@ TEST_F(WddmMemoryManagerTest, givenLocalMemoryAllocationWhenCpuPointerNotMeetRes
TEST_F(WddmMemoryManagerSimpleTest, whenMemoryIsAllocatedInLocalMemoryThenTheAllocationNeedsMakeResidentBeforeLock) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
@@ -503,8 +492,7 @@ TEST_F(WddmMemoryManagerSimpleTest, whenMemoryIsAllocatedInLocalMemoryThenTheAll
TEST_F(WddmMemoryManagerSimpleTest, givenAllocationWithHighPriorityWhenMemoryIsAllocatedInLocalMemoryThenSetAllocationPriorityIsCalledWithHighPriority) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
AllocationType highPriorityTypes[] = {
AllocationType::KERNEL_ISA,
@@ -536,8 +524,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocationWithHighPriorityWhenMemoryIsA
TEST_F(WddmMemoryManagerSimpleTest, givenAllocationWithoutHighPriorityWhenMemoryIsAllocatedInLocalMemoryThenSetAllocationPriorityIsCalledWithNormalPriority) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
@@ -557,8 +544,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocationWithoutHighPriorityWhenMemory
TEST_F(WddmMemoryManagerSimpleTest, givenSetAllocationPriorityFailureWhenMemoryIsAllocatedInLocalMemoryThenNullptrIsReturned) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
@@ -576,8 +562,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenSetAllocationPriorityFailureWhenMemoryI
TEST_F(WddmMemoryManagerSimpleTest, givenSetAllocationPriorityFailureWhenMemoryIsAllocatedInLocalPhysicalMemoryThenNullptrIsReturned) {
const bool localMemoryEnabled = true;
auto executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, localMemoryEnabled, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
AllocationData allocData;
@@ -598,12 +583,7 @@ class WddmMemoryManagerSimpleTestWithLocalMemory : public MockWddmMemoryManagerF
void SetUp() override {
HardwareInfo localPlatformDevice = *defaultHwInfo;
localPlatformDevice.featureTable.flags.ftrLocalMemory = true;
platformsImpl->clear();
auto executionEnvironment = constructPlatform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(1u);
executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(&localPlatformDevice);
executionEnvironment->rootDeviceEnvironments[0]->initGmm();
executionEnvironment.rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(&localPlatformDevice);
MockWddmMemoryManagerFixture::SetUp();
wddm->init();
@@ -616,7 +596,7 @@ class WddmMemoryManagerSimpleTestWithLocalMemory : public MockWddmMemoryManagerF
};
TEST_F(WddmMemoryManagerSimpleTestWithLocalMemory, givenLocalMemoryAndImageOrSharedResourceWhenAllocateInDevicePoolIsCalledThenLocalMemoryAllocationAndAndStatusSuccessIsReturned) {
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Error;
ImageDescriptor imgDesc = {};
@@ -660,7 +640,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenSvmGpuAllocationWhenHostPtrProvidedThen
EXPECT_EQ(nullptr, allocation->getUnderlyingBuffer());
EXPECT_EQ(nullptr, allocation->getDriverAllocatedCpuPtr());
// limited platforms will not use heap HeapIndex::HEAP_SVM
if (executionEnvironment->rootDeviceEnvironments[0]->isFullRangeSvm()) {
if (executionEnvironment.rootDeviceEnvironments[0]->isFullRangeSvm()) {
EXPECT_EQ(svmPtr, reinterpret_cast<void *>(allocation->getGpuAddress()));
}
EXPECT_EQ(nullptr, allocation->getReservedAddressPtr());
@@ -767,7 +747,7 @@ struct WddmMemoryManagerSimple64BitTest : public WddmMemoryManagerSimpleTest {
wddm->mapGpuVaStatus = true;
VariableBackup<bool> restorer{&wddm->callBaseMapGpuVa, false};
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, *executionEnvironment);
memoryManager = std::make_unique<MockWddmMemoryManager>(false, true, executionEnvironment);
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = static_cast<size_t>(MemoryConstants::gigaByte * 13);

179
opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -64,7 +64,7 @@ void WddmMemoryManagerFixture::setUp() {
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(regularEngines[0],
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
for (auto engine : memoryManager->getRegisteredEngines()) {
for (auto engine : memoryManager->getRegisteredEngines(rootDeviceIndex)) {
if (engine.getEngineUsage() == EngineUsage::Regular) {
engine.commandStreamReceiver->pageTableManager.reset(GmmPageTableMngr::create(nullptr, 0, &dummyTTCallbacks));
}
@@ -189,7 +189,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocateGraphicsMemoryWithPropertiesCal
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemoryIsCalledThenMemoryPoolIsSystem4KBPages) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
if (memoryManager->isLimitedGPU(0)) {
GTEST_SKIP();
}
@@ -197,7 +197,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemory
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
EXPECT_NE(nullptr, allocation);
EXPECT_EQ(MemoryPool::System4KBPages, allocation->getMemoryPool());
EXPECT_EQ(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
EXPECT_EQ(executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
allocation->getDefaultGmm()->resourceParams.Flags.Info.NonLocalOnly);
memoryManager->freeGraphicsMemory(allocation);
}
@@ -214,7 +214,7 @@ class MockCreateWddmAllocationMemoryManager : public MockWddmMemoryManager {
};
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemoryFailedThenNullptrFromAllocateMemoryByKMDIsReturned) {
memoryManager.reset(new MockCreateWddmAllocationMemoryManager(*executionEnvironment));
memoryManager.reset(new MockCreateWddmAllocationMemoryManager(executionEnvironment));
AllocationData allocationData;
allocationData.size = MemoryConstants::pageSize;
auto allocation = memoryManager->allocateMemoryByKMD(allocationData);
@@ -222,7 +222,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemory
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemoryFailedThenNullptrFromAllocatePhysicalDeviceMemoryIsReturned) {
memoryManager.reset(new MockCreateWddmAllocationMemoryManager(*executionEnvironment));
memoryManager.reset(new MockCreateWddmAllocationMemoryManager(executionEnvironment));
AllocationData allocationData;
allocationData.size = MemoryConstants::pageSize;
MemoryManager::AllocationStatus status;
@@ -231,7 +231,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemory
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemoryFailedThenNullptrFromAllocatePhysicalLocalDeviceMemoryIsReturned) {
memoryManager.reset(new MockCreateWddmAllocationMemoryManager(*executionEnvironment));
memoryManager.reset(new MockCreateWddmAllocationMemoryManager(executionEnvironment));
AllocationData allocationData;
allocationData.size = MemoryConstants::pageSize;
MemoryManager::AllocationStatus status;
@@ -240,21 +240,21 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemory
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWith64KBPagesEnabledWhenAllocateGraphicsMemory64kbIsCalledThenMemoryPoolIsSystem64KBPages) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
AllocationData allocationData;
allocationData.size = 4096u;
auto allocation = memoryManager->allocateGraphicsMemory64kb(allocationData);
EXPECT_NE(nullptr, allocation);
EXPECT_EQ(MemoryPool::System64KBPages, allocation->getMemoryPool());
EXPECT_EQ(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
EXPECT_EQ(executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
allocation->getDefaultGmm()->resourceParams.Flags.Info.NonLocalOnly);
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(WddmMemoryManagerSimpleTest, givenAllocationDataWithStorageInfoWhenAllocateGraphicsMemory64kbThenStorageInfoInAllocationIsSetCorrectly) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
AllocationData allocationData;
allocationData.storageInfo = {};
auto allocation = memoryManager->allocateGraphicsMemory64kb(allocationData);
@@ -268,7 +268,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocationDataWithFlagsWhenAllocateGrap
public:
using GraphicsAllocation::allocationInfo;
};
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
AllocationData allocationData;
allocationData.flags.flushL3 = true;
auto allocation = static_cast<MockGraphicsAllocation *>(memoryManager->allocateGraphicsMemory64kb(allocationData));
@@ -278,7 +278,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocationDataWithFlagsWhenAllocateGrap
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemoryWithPtrIsCalledThenMemoryPoolIsSystem4KBPages) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
if (memoryManager->isLimitedGPU(0)) {
GTEST_SKIP();
}
@@ -294,7 +294,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemory
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocate32BitGraphicsMemoryWithPtrIsCalledThenMemoryPoolIsSystem4KBPagesWith32BitGpuAddressing) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
void *ptr = reinterpret_cast<void *>(0x1001);
auto size = MemoryConstants::pageSize;
@@ -302,14 +302,14 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocate32BitGraphicsM
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryPool::System4KBPagesWith32BitGpuAddressing, allocation->getMemoryPool());
EXPECT_EQ(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
EXPECT_EQ(executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
allocation->getDefaultGmm()->resourceParams.Flags.Info.NonLocalOnly);
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWith64KBPagesDisabledWhenAllocateGraphicsMemoryForSVMThen4KBGraphicsAllocationIsReturned) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
if (memoryManager->isLimitedGPU(0)) {
GTEST_SKIP();
}
@@ -318,13 +318,13 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWith64KBPagesDisabledWhenA
auto svmAllocation = memoryManager->allocateGraphicsMemoryWithProperties({csr->getRootDeviceIndex(), size, AllocationType::SVM_ZERO_COPY, mockDeviceBitfield});
EXPECT_NE(nullptr, svmAllocation);
EXPECT_EQ(MemoryPool::System4KBPages, svmAllocation->getMemoryPool());
EXPECT_EQ(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
EXPECT_EQ(executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo()->featureTable.flags.ftrLocalMemory,
svmAllocation->getDefaultGmm()->resourceParams.Flags.Info.NonLocalOnly);
memoryManager->freeGraphicsMemory(svmAllocation);
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWith64KBPagesEnabledWhenAllocateGraphicsMemoryForSVMThenMemoryPoolIsSystem64KBPages) {
memoryManager.reset(new MockWddmMemoryManager(true, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(true, false, executionEnvironment));
if (memoryManager->isLimitedGPU(0)) {
GTEST_SKIP();
}
@@ -337,7 +337,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWith64KBPagesEnabledWhenAl
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenCreateAllocationFromHandleIsCalledThenMemoryPoolIsSystemCpuInaccessible) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
auto osHandle = 1u;
gdi->getQueryResourceInfoArgOut().NumAllocations = 1;
std::unique_ptr<Gmm> gmm(new Gmm(rootDeviceEnvironment->getGmmHelper(), nullptr, 0, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
@@ -357,7 +357,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenCreateAllocationFromHa
}
TEST_F(WddmMemoryManagerSimpleTest, givenSharedHandleWhenCreateGraphicsAllocationFromMultipleSharedHandlesIsCalledThenNullptrIsReturned) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
auto handle = 1u;
gdi->getQueryResourceInfoArgOut().NumAllocations = 1;
std::unique_ptr<Gmm> gmm(new Gmm(rootDeviceEnvironment->getGmmHelper(), nullptr, 0, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
@@ -376,7 +376,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenSharedHandleWhenCreateGraphicsAllocatio
}
TEST_F(WddmMemoryManagerSimpleTest, givenAllocationPropertiesWhenCreateAllocationFromHandleIsCalledThenCorrectAllocationTypeIsSet) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
auto osHandle = 1u;
gdi->getQueryResourceInfoArgOut().NumAllocations = 1;
std::unique_ptr<Gmm> gmm(new Gmm(rootDeviceEnvironment->getGmmHelper(), nullptr, 0, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
@@ -402,7 +402,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocationPropertiesWhenCreateAllocatio
}
TEST_F(WddmMemoryManagerSimpleTest, whenCreateAllocationFromHandleAndMapCallFailsThenFreeGraphicsMemoryIsCalled) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
auto osHandle = 1u;
gdi->getQueryResourceInfoArgOut().NumAllocations = 1;
auto gmm = std::make_unique<Gmm>(rootDeviceEnvironment->getGmmHelper(), nullptr, 0, 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, StorageInfo{}, true);
@@ -425,7 +425,7 @@ TEST_F(WddmMemoryManagerSimpleTest, whenCreateAllocationFromHandleAndMapCallFail
}
TEST_F(WddmMemoryManagerSimpleTest, givenAllocateGraphicsMemoryForNonSvmHostPtrIsCalledWhenNotAlignedPtrIsPassedThenAlignedGraphicsAllocationIsCreated) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
auto size = 13u;
auto hostPtr = reinterpret_cast<const void *>(0x10001);
@@ -441,7 +441,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocateGraphicsMemoryForNonSvmHostPtrI
}
TEST_F(WddmMemoryManagerSimpleTest, givenAllocateGraphicsMemoryForNonSvmHostPtrIsCalledWhenNotAlignedPtrIsPassedAndImportedAllocationIsFalseThenAlignedGraphicsAllocationIsFreed) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
auto size = 13u;
auto hostPtr = reinterpret_cast<const void *>(0x10001);
@@ -470,7 +470,7 @@ TEST_F(WddmMemoryManagerTest, givenAllocateGraphicsMemoryForNonSvmHostPtrIsCalle
}
TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndSmallSizeWhenAskedToCreateGrahicsAllocationThenValidAllocationIsReturned) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
memoryManager->hugeGfxMemoryChunkSize = MemoryConstants::pageSize64k;
AllocationData allocationData;
allocationData.size = 4096u;
@@ -482,7 +482,7 @@ TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndSmallSizeWhenAskedTo
}
TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndHugeSizeWhenAskedToCreateGrahicsAllocationThenValidAllocationIsReturned) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
memoryManager->hugeGfxMemoryChunkSize = MemoryConstants::pageSize64k;
AllocationData allocationData;
allocationData.size = 2ULL * MemoryConstants::pageSize64k;
@@ -494,7 +494,7 @@ TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndHugeSizeWhenAskedToC
}
TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndSmallSizeWhenAskedToCreatePhysicalGraphicsAllocationThenValidAllocationIsReturned) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
memoryManager->hugeGfxMemoryChunkSize = MemoryConstants::pageSize64k;
AllocationData allocationData;
allocationData.size = 4096u;
@@ -506,7 +506,7 @@ TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndSmallSizeWhenAskedTo
}
TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndHugeSizeWhenAskedToCreatePhysicalLocalGraphicsAllocationThenValidAllocationIsReturned) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
memoryManager->hugeGfxMemoryChunkSize = MemoryConstants::pageSize64k;
AllocationData allocationData;
allocationData.size = 2ULL * MemoryConstants::pageSize64k;
@@ -518,7 +518,7 @@ TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndHugeSizeWhenAskedToC
}
TEST_F(WddmMemoryManagerSimpleTest, GivenPhysicalMemoryAndVirtualMemoryThenMapSucceeds) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(false, false, executionEnvironment));
memoryManager->hugeGfxMemoryChunkSize = MemoryConstants::pageSize64k;
AllocationData allocationData;
allocationData.size = 2ULL * MemoryConstants::pageSize64k;
@@ -533,7 +533,7 @@ TEST_F(WddmMemoryManagerSimpleTest, GivenPhysicalMemoryAndVirtualMemoryThenMapSu
}
TEST_F(WddmMemoryManagerSimpleTest, givenZeroFenceValueOnSingleEngineRegisteredWhenHandleFenceCompletionIsCalledThenDoNotWaitOnCpu) {
ASSERT_EQ(1u, memoryManager->getRegisteredEnginesCount());
ASSERT_EQ(1u, memoryManager->getRegisteredEngines(0).size());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, 32, AllocationType::BUFFER, mockDeviceBitfield}));
allocation->getResidencyData().updateCompletionData(0u, 0u);
@@ -545,10 +545,10 @@ TEST_F(WddmMemoryManagerSimpleTest, givenZeroFenceValueOnSingleEngineRegisteredW
}
TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSingleEngineRegisteredWhenHandleFenceCompletionIsCalledThenWaitOnCpuOnce) {
ASSERT_EQ(1u, memoryManager->getRegisteredEnginesCount());
ASSERT_EQ(1u, memoryManager->getRegisteredEngines(0).size());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, 32, AllocationType::BUFFER, mockDeviceBitfield}));
auto fence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines()[0].osContext)->getResidencyController().getMonitoredFence();
auto fence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(0)[0].osContext)->getResidencyController().getMonitoredFence();
allocation->getResidencyData().updateCompletionData(129u, 0u);
memoryManager->handleFenceCompletion(allocation);
@@ -559,71 +559,64 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSingleEngineRegister
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValuesOnMultipleEnginesRegisteredWhenHandleFenceCompletionIsCalledThenWaitOnCpuForEachEngine) {
executionEnvironment->prepareRootDeviceEnvironments(2u);
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfoAndInitHelpers(defaultHwInfo.get());
executionEnvironment->rootDeviceEnvironments[i]->initGmm();
}
TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValuesOnMultipleEnginesRegisteredWhenHandleFenceCompletionIsCalledThenWaitOnCpuForEachEngineFromRootDevice) {
const uint32_t rootDeviceIndex = 1;
DeviceBitfield deviceBitfield(2);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(*executionEnvironment, rootDeviceIndex, deviceBitfield));
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, rootDeviceIndex, deviceBitfield));
auto wddm2 = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[rootDeviceIndex].get()));
wddm2->init();
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
auto wddm2 = static_cast<WddmMock *>(executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->osInterface->getDriverModel()->as<Wddm>());
wddm2->callBaseWaitFromCpu = false;
executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
auto hwInfo = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo();
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->getHelper<GfxCoreHelper>();
auto hwInfo = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo();
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHelper<GfxCoreHelper>();
OsContext *osContext = memoryManager->createAndRegisterOsContext(csr.get(),
EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex])[1],
EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment.rootDeviceEnvironments[rootDeviceIndex])[1],
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), deviceBitfield));
osContext->ensureContextInitialized();
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());
ASSERT_EQ(1u, memoryManager->getRegisteredEngines(rootDeviceIndex).size());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0u, 32, AllocationType::BUFFER, mockDeviceBitfield}));
auto lastEngineFence = &static_cast<OsContextWin *>(osContext)->getResidencyController().getMonitoredFence();
auto lastEngineFence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(0)[0].osContext)->getResidencyController().getMonitoredFence();
allocation->getResidencyData().updateCompletionData(129u, 0u);
allocation->getResidencyData().updateCompletionData(152u, 1u);
memoryManager->handleFenceCompletion(allocation);
EXPECT_EQ(1u, wddm->waitFromCpuResult.called);
EXPECT_EQ(1u, wddm2->waitFromCpuResult.called);
EXPECT_EQ(0u, wddm2->waitFromCpuResult.called);
EXPECT_EQ(129u, wddm->waitFromCpuResult.uint64ParamPassed);
EXPECT_EQ(152u, wddm2->waitFromCpuResult.uint64ParamPassed);
EXPECT_EQ(lastEngineFence, wddm2->waitFromCpuResult.monitoredFence);
EXPECT_EQ(lastEngineFence, wddm->waitFromCpuResult.monitoredFence);
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSomeOfMultipleEnginesRegisteredWhenHandleFenceCompletionIsCalledThenWaitOnCpuForTheseEngines) {
const uint32_t rootDeviceIndex = 1;
executionEnvironment->prepareRootDeviceEnvironments(2u);
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfoAndInitHelpers(defaultHwInfo.get());
executionEnvironment->rootDeviceEnvironments[i]->initGmm();
}
DeviceBitfield deviceBitfield(2);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(*executionEnvironment, rootDeviceIndex, deviceBitfield));
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, rootDeviceIndex, deviceBitfield));
std::unique_ptr<CommandStreamReceiver> csr2(createCommandStream(executionEnvironment, rootDeviceIndex, deviceBitfield));
auto wddm2 = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[rootDeviceIndex].get()));
wddm2->init();
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->getHelper<GfxCoreHelper>();
auto hwInfo = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo();
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex])[1],
auto wddm2 = static_cast<WddmMock *>(executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->osInterface->getDriverModel()->as<Wddm>());
wddm2->callBaseWaitFromCpu = false;
executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHelper<GfxCoreHelper>();
auto hwInfo = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo();
memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment.rootDeviceEnvironments[rootDeviceIndex])[1],
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), deviceBitfield));
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());
memoryManager->createAndRegisterOsContext(csr2.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment.rootDeviceEnvironments[rootDeviceIndex])[1],
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), deviceBitfield));
ASSERT_EQ(2u, memoryManager->getRegisteredEngines(rootDeviceIndex).size());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0u, 32, AllocationType::BUFFER, mockDeviceBitfield}));
auto lastEngineFence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines()[0].osContext)->getResidencyController().getMonitoredFence();
allocation->getResidencyData().updateCompletionData(129u, 0u);
allocation->getResidencyData().updateCompletionData(0, 1u);
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({1u, 32, AllocationType::BUFFER, mockDeviceBitfield}));
auto lastEngineFence = &static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(1)[0].osContext)->getResidencyController().getMonitoredFence();
allocation->getResidencyData().updateCompletionData(129u, 1u);
allocation->getResidencyData().updateCompletionData(0, 2u);
memoryManager->handleFenceCompletion(allocation);
EXPECT_EQ(1u, wddm->waitFromCpuResult.called);
EXPECT_EQ(129u, wddm->waitFromCpuResult.uint64ParamPassed);
EXPECT_EQ(lastEngineFence, wddm->waitFromCpuResult.monitoredFence);
EXPECT_EQ(1u, wddm2->waitFromCpuResult.called);
EXPECT_EQ(129u, wddm2->waitFromCpuResult.uint64ParamPassed);
EXPECT_EQ(lastEngineFence, wddm2->waitFromCpuResult.monitoredFence);
memoryManager->freeGraphicsMemory(allocation);
}
@@ -2027,7 +2020,7 @@ TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWithE
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo), 2));
memoryManager->createAndRegisterOsContext(csr2.get(), EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_RCS, EngineUsage::Regular},
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo), 3));
auto osContext = static_cast<OsContextWin *>(memoryManager->getRegisteredEngines()[1].osContext);
auto osContext = static_cast<OsContextWin *>(memoryManager->getRegisteredEngines(1)[0].osContext);
osContext->getResidencyController().setMemoryBudgetExhausted();
EXPECT_TRUE(memoryManager->isMemoryBudgetExhausted());
}
@@ -2068,7 +2061,7 @@ TEST_F(MockWddmMemoryManagerTest, givenPageTableManagerWhenMapAuxGpuVaCalledThen
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
auto mockMngr = new MockGmmPageTableMngr();
for (auto engine : memoryManager.getRegisteredEngines()) {
for (auto engine : memoryManager.getRegisteredEngines(1u)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2109,7 +2102,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedAllocationWhenMappedGpuVaAndPag
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
auto mockMngr = new MockGmmPageTableMngr();
for (auto engine : executionEnvironment->memoryManager->getRegisteredEngines()) {
for (auto engine : executionEnvironment->memoryManager->getRegisteredEngines(1u)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2143,7 +2136,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedAllocationWhenMappedGpuVaAndPag
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
auto mockMngr = new MockGmmPageTableMngr();
for (auto engine : executionEnvironment->memoryManager->getRegisteredEngines()) {
for (auto engine : executionEnvironment->memoryManager->getRegisteredEngines(1)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2154,7 +2147,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedAllocationWhenMappedGpuVaAndPag
expectedDdiUpdateAuxTable.DoNotWait = true;
expectedDdiUpdateAuxTable.Map = true;
auto expectedCallCount = executionEnvironment->memoryManager->getRegisteredEnginesCount();
auto expectedCallCount = executionEnvironment->memoryManager->getRegisteredEngines(1).size();
auto hwInfoMock = hardwareInfoTable[wddm.getGfxPlatform()->eProductFamily];
ASSERT_NE(nullptr, hwInfoMock);
@@ -2183,7 +2176,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedAllocationAndPageTableSupported
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
auto mockMngr = new MockGmmPageTableMngr();
for (auto engine : memoryManager.getRegisteredEngines()) {
for (auto engine : memoryManager.getRegisteredEngines(1u)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2197,7 +2190,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedAllocationAndPageTableSupported
expectedDdiUpdateAuxTable.DoNotWait = true;
expectedDdiUpdateAuxTable.Map = false;
auto expectedCallCount = memoryManager.getRegisteredEnginesCount();
auto expectedCallCount = memoryManager.getRegisteredEngines(1u).size();
memoryManager.freeGraphicsMemory(wddmAlloc);
@@ -2218,7 +2211,7 @@ TEST_F(MockWddmMemoryManagerTest, givenNonCompressedAllocationWhenReleaseingThen
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
auto mockMngr = new MockGmmPageTableMngr();
for (auto engine : memoryManager.getRegisteredEngines()) {
for (auto engine : memoryManager.getRegisteredEngines(1u)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2246,7 +2239,7 @@ TEST_F(MockWddmMemoryManagerTest, givenNonCompressedAllocationWhenMappedGpuVaThe
PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
auto mockMngr = new MockGmmPageTableMngr();
for (auto engine : executionEnvironment->memoryManager->getRegisteredEngines()) {
for (auto engine : executionEnvironment->memoryManager->getRegisteredEngines(1u)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2282,7 +2275,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedFlagSetWhenInternalIsUnsetThenD
auto mockMngr = new MockGmmPageTableMngr();
auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[1].get();
for (auto engine : memoryManager.getRegisteredEngines()) {
for (auto engine : memoryManager.getRegisteredEngines(1u)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2320,7 +2313,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedFlagSetWhenInternalIsSetThenUpd
auto mockMngr = new MockGmmPageTableMngr();
auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[1].get();
rootDeviceEnvironment->executionEnvironment.initializeMemoryManager();
for (auto engine : memoryManager.getRegisteredEngines()) {
for (auto engine : memoryManager.getRegisteredEngines(1u)) {
engine.commandStreamReceiver->pageTableManager.reset(mockMngr);
}
@@ -2332,7 +2325,7 @@ TEST_F(MockWddmMemoryManagerTest, givenCompressedFlagSetWhenInternalIsSetThenUpd
delete wddmAlloc->getDefaultGmm();
wddmAlloc->setDefaultGmm(myGmm);
auto expectedCallCount = memoryManager.getRegisteredEnginesCount();
auto expectedCallCount = memoryManager.getRegisteredEngines(rootDeviceIndex).size();
auto result = wddm->mapGpuVirtualAddress(myGmm, ALLOCATION_HANDLE, wddm->getGfxPartition().Standard.Base, wddm->getGfxPartition().Standard.Limit, 0u, gpuVa);
EXPECT_TRUE(result);
@@ -2533,7 +2526,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenSvmCpuAllocationWhenSizeAndAlignmentPro
EXPECT_NE(nullptr, allocation->getUnderlyingBuffer());
EXPECT_EQ(allocation->getUnderlyingBuffer(), allocation->getDriverAllocatedCpuPtr());
// limited platforms will not use heap HeapIndex::HEAP_SVM
if (executionEnvironment->rootDeviceEnvironments[allocation->getRootDeviceIndex()]->isFullRangeSvm()) {
if (executionEnvironment.rootDeviceEnvironments[allocation->getRootDeviceIndex()]->isFullRangeSvm()) {
EXPECT_EQ(alignUp(allocation->getReservedAddressPtr(), size), reinterpret_cast<void *>(allocation->getGpuAddress()));
}
EXPECT_EQ((2 * size), allocation->getReservedAddressSize());
@@ -2545,7 +2538,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenWriteCombinedAllocationThenCpuAddressIs
if (is32bit) {
GTEST_SKIP();
}
memoryManager.reset(new MockWddmMemoryManager(true, true, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(true, true, executionEnvironment));
size_t size = 2 * MemoryConstants::megaByte;
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, size, AllocationType::WRITE_COMBINED, mockDeviceBitfield}));
ASSERT_NE(nullptr, allocation);
@@ -2553,7 +2546,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenWriteCombinedAllocationThenCpuAddressIs
EXPECT_NE(nullptr, allocation->getUnderlyingBuffer());
EXPECT_NE(nullptr, reinterpret_cast<void *>(allocation->getGpuAddress()));
if (executionEnvironment->rootDeviceEnvironments[allocation->getRootDeviceIndex()]->isFullRangeSvm()) {
if (executionEnvironment.rootDeviceEnvironments[allocation->getRootDeviceIndex()]->isFullRangeSvm()) {
EXPECT_EQ(allocation->getUnderlyingBuffer(), reinterpret_cast<void *>(allocation->getGpuAddress()));
}
@@ -2566,23 +2559,23 @@ TEST_F(WddmMemoryManagerSimpleTest, givenDebugVariableWhenCreatingWddmMemoryMana
{
DebugManager.flags.EnableMultiStorageResources.set(0);
MockWddmMemoryManager memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManager memoryManager(true, true, executionEnvironment);
EXPECT_FALSE(memoryManager.supportsMultiStorageResources);
}
{
DebugManager.flags.EnableMultiStorageResources.set(1);
MockWddmMemoryManager memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManager memoryManager(true, true, executionEnvironment);
EXPECT_TRUE(memoryManager.supportsMultiStorageResources);
}
}
TEST_F(WddmMemoryManagerSimpleTest, givenBufferHostMemoryAllocationAndLimitedRangeAnd32BitThenAllocationGoesToExternalHeap) {
if (executionEnvironment->rootDeviceEnvironments[0]->isFullRangeSvm() || !is32bit) {
if (executionEnvironment.rootDeviceEnvironments[0]->isFullRangeSvm() || !is32bit) {
GTEST_SKIP();
}
memoryManager.reset(new MockWddmMemoryManager(true, true, *executionEnvironment));
memoryManager.reset(new MockWddmMemoryManager(true, true, executionEnvironment));
size_t size = 2 * MemoryConstants::megaByte;
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, size, AllocationType::BUFFER_HOST_MEMORY, mockDeviceBitfield}));
ASSERT_NE(nullptr, allocation);
@@ -2689,7 +2682,7 @@ TEST_F(WddmMemoryManagerSimpleTest, whenWddmMemoryManagerIsCreatedThenAlignmentS
{MemoryConstants::pageSize64k, true, AlignmentSelector::anyWastage, HeapIndex::TOTAL_HEAPS},
};
MockWddmMemoryManager memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManager memoryManager(true, true, executionEnvironment);
EXPECT_EQ(expectedAlignments, memoryManager.alignmentSelector.peekCandidateAlignments());
}
@@ -2701,7 +2694,7 @@ TEST_F(WddmMemoryManagerSimpleTest, given2MbPagesDisabledWhenWddmMemoryManagerIs
{MemoryConstants::pageSize64k, true, AlignmentSelector::anyWastage, HeapIndex::TOTAL_HEAPS},
};
MockWddmMemoryManager memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManager memoryManager(true, true, executionEnvironment);
EXPECT_EQ(expectedAlignments, memoryManager.alignmentSelector.peekCandidateAlignments());
}
@@ -2715,7 +2708,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenCustomAlignmentWhenWddmMemoryManagerIsC
{MemoryConstants::megaByte, false, AlignmentSelector::anyWastage, HeapIndex::TOTAL_HEAPS},
{MemoryConstants::pageSize64k, true, AlignmentSelector::anyWastage, HeapIndex::TOTAL_HEAPS},
};
MockWddmMemoryManager memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManager memoryManager(true, true, executionEnvironment);
EXPECT_EQ(expectedAlignments, memoryManager.alignmentSelector.peekCandidateAlignments());
}
@@ -2726,13 +2719,13 @@ TEST_F(WddmMemoryManagerSimpleTest, givenCustomAlignmentWhenWddmMemoryManagerIsC
{MemoryConstants::pageSize2Mb, false, 0.1f, HeapIndex::TOTAL_HEAPS},
{MemoryConstants::pageSize64k, true, AlignmentSelector::anyWastage, HeapIndex::TOTAL_HEAPS},
};
MockWddmMemoryManager memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManager memoryManager(true, true, executionEnvironment);
EXPECT_EQ(expectedAlignments, memoryManager.alignmentSelector.peekCandidateAlignments());
}
}
TEST_F(WddmMemoryManagerSimpleTest, givenWddmMemoryManagerWhenGettingGlobalMemoryPercentThenCorrectValueIsReturned) {
MockWddmMemoryManager memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManager memoryManager(true, true, executionEnvironment);
uint32_t rootDeviceIndex = 0u;
EXPECT_EQ(memoryManager.getPercentOfGlobalMemoryAvailable(rootDeviceIndex), 0.8);
}
@@ -2756,7 +2749,7 @@ TEST_F(WddmMemoryManagerSimpleTest, whenAlignmentRequirementExceedsPageSizeThenA
} callCount;
};
MockWddmMemoryManagerAllocateWithAlignment memoryManager(true, true, *executionEnvironment);
MockWddmMemoryManagerAllocateWithAlignment memoryManager(true, true, executionEnvironment);
AllocationData allocData = {};
allocData.size = 1024;

50
opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.h
View File

@@ -21,7 +21,6 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "opencl/test/unit_test/mocks/mock_context.h"
#include "opencl/test/unit_test/mocks/mock_platform.h"
#include "gtest/gtest.h"
@@ -50,22 +49,27 @@ typedef ::Test<WddmMemoryManagerFixture> WddmMemoryManagerTest;
class MockWddmMemoryManagerFixture {
public:
void SetUp() {
executionEnvironment = platform()->peekExecutionEnvironment();
rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[0].get();
auto osEnvironment = new OsEnvironmentWin();
gdi = new MockGdi();
osEnvironment->gdi.reset(gdi);
executionEnvironment->osEnvironment.reset(osEnvironment);
wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *rootDeviceEnvironment));
constexpr uint64_t heap32Base = (is32bit) ? 0x1000 : 0x800000000000;
wddm->setHeap32(heap32Base, 1000 * MemoryConstants::pageSize - 1);
wddm->init();
executionEnvironment.osEnvironment.reset(osEnvironment);
executionEnvironment.prepareRootDeviceEnvironments(2u);
for (auto i = 0u; i < executionEnvironment.rootDeviceEnvironments.size(); i++) {
executionEnvironment.rootDeviceEnvironments[i]->setHwInfoAndInitHelpers(defaultHwInfo.get());
executionEnvironment.rootDeviceEnvironments[i]->initGmm();
auto wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment.rootDeviceEnvironments[i]));
constexpr uint64_t heap32Base = (is32bit) ? 0x1000 : 0x800000000000;
wddm->setHeap32(heap32Base, 1000 * MemoryConstants::pageSize - 1);
wddm->init();
}
rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[0].get();
wddm = static_cast<WddmMock *>(rootDeviceEnvironment->osInterface->getDriverModel()->as<Wddm>());
rootDeviceEnvironment->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
executionEnvironment->initializeMemoryManager();
executionEnvironment.initializeMemoryManager();
memoryManager = std::make_unique<MockWddmMemoryManager>(*executionEnvironment);
csr.reset(createCommandStream(*executionEnvironment, 0u, 1));
memoryManager = std::make_unique<MockWddmMemoryManager>(executionEnvironment);
csr.reset(createCommandStream(executionEnvironment, 0u, 1));
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
auto &gfxCoreHelper = rootDeviceEnvironment->getHelper<GfxCoreHelper>();
osContext = memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*rootDeviceEnvironment)[0],
@@ -81,7 +85,7 @@ class MockWddmMemoryManagerFixture {
}
RootDeviceEnvironment *rootDeviceEnvironment = nullptr;
ExecutionEnvironment *executionEnvironment;
MockExecutionEnvironment executionEnvironment;
std::unique_ptr<MockWddmMemoryManager> memoryManager;
std::unique_ptr<CommandStreamReceiver> csr;
@@ -95,11 +99,7 @@ typedef ::Test<MockWddmMemoryManagerFixture> WddmMemoryManagerResidencyTest;
class ExecutionEnvironmentFixture : public ::testing::Test {
public:
ExecutionEnvironmentFixture() {
executionEnvironment = platform()->peekExecutionEnvironment();
}
ExecutionEnvironment *executionEnvironment;
MockExecutionEnvironment executionEnvironment;
};
class WddmMemoryManagerFixtureWithGmockWddm : public ExecutionEnvironmentFixture {
@@ -109,19 +109,19 @@ class WddmMemoryManagerFixtureWithGmockWddm : public ExecutionEnvironmentFixture
void SetUp() override {
// wddm is deleted by memory manager
wddm = new WddmMock(*executionEnvironment->rootDeviceEnvironments[0].get());
wddm = new WddmMock(*executionEnvironment.rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, wddm);
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
wddm->init();
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
memoryManager = new (std::nothrow) MockWddmMemoryManager(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager);
executionEnvironment.rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
osInterface = executionEnvironment.rootDeviceEnvironments[0]->osInterface.get();
memoryManager = new (std::nothrow) MockWddmMemoryManager(executionEnvironment);
executionEnvironment.memoryManager.reset(memoryManager);
// assert we have memory manager
ASSERT_NE(nullptr, memoryManager);
csr.reset(createCommandStream(*executionEnvironment, 0u, 1));
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
osContext = memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment->rootDeviceEnvironments[0])[0],
csr.reset(createCommandStream(executionEnvironment, 0u, 1));
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
osContext = memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*executionEnvironment.rootDeviceEnvironments[0])[0],
preemptionMode));
osContext->incRefInternal();
}