intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-29 09:03:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Register valid command stream receiver

Browse Source 
Resolves: NEO-4150

Change-Id: I09c3f1dbffbaeabe92c528341006318d8abff6b9
Signed-off-by: Jobczyk, Lukasz <lukasz.jobczyk@intel.com>
This commit is contained in:
Jobczyk, Lukasz
2020-02-17 13:26:02 +01:00
committed by sys_ocldev
parent bbb8332e2e
commit afd85845bb
5 changed files with 102 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
core/memory_manager/memory_manager.cpp
View File

@@ -201,8 +201,7 @@ bool MemoryManager::isMemoryBudgetExhausted() const {
OsContext *MemoryManager::createAndRegisterOsContext(CommandStreamReceiver *commandStreamReceiver, aub_stream::EngineType engineType,
DeviceBitfield deviceBitfield, PreemptionMode preemptionMode, bool lowPriority) {
auto contextId = ++latestContextId;
auto rootDeviceIndex = commandStreamReceiver ? commandStreamReceiver->getRootDeviceIndex() : 0u;
auto osContext = OsContext::create(peekExecutionEnvironment().rootDeviceEnvironments[rootDeviceIndex]->osInterface.get(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority);
auto osContext = OsContext::create(peekExecutionEnvironment().rootDeviceEnvironments[commandStreamReceiver->getRootDeviceIndex()]->osInterface.get(), contextId, deviceBitfield, engineType, preemptionMode, lowPriority);
UNRECOVERABLE_IF(!osContext->isInitialized());
osContext->incRefInternal();

47
unit_tests/memory_manager/memory_manager_tests.cpp
View File

@@ -1653,11 +1653,13 @@ TEST(GraphicsAllocation, givenSharedHandleBasedConstructorWhenGraphicsAllocation
TEST(ResidencyDataTest, givenOsContextWhenItIsRegisteredToMemoryManagerThenRefCountIncreases) {
MockExecutionEnvironment executionEnvironment(*platformDevices);
MockMemoryManager memoryManager(false, false, executionEnvironment);
memoryManager.createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_EQ(1u, memoryManager.getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager.registeredEngines[0].osContext->getRefInternalCount());
auto memoryManager = new MockMemoryManager(false, false, executionEnvironment);
executionEnvironment.memoryManager.reset(memoryManager);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_EQ(1u, memoryManager->getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager->registeredEngines[0].osContext->getRefInternalCount());
}
TEST(MemoryManagerRegisteredEnginesTest, givenOsContextWhenItIsUnregisteredFromMemoryManagerThenRefCountDecreases) {
@@ -1676,26 +1678,31 @@ TEST(MemoryManagerRegisteredEnginesTest, givenOsContextWhenItIsUnregisteredFromM
TEST(ResidencyDataTest, givenDeviceBitfieldWhenCreatingOsContextThenSetValidValue) {
MockExecutionEnvironment executionEnvironment(*platformDevices);
MockMemoryManager memoryManager(false, false, executionEnvironment);
auto memoryManager = new MockMemoryManager(false, false, executionEnvironment);
executionEnvironment.memoryManager.reset(memoryManager);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
DeviceBitfield deviceBitfield = 0b11;
PreemptionMode preemptionMode = PreemptionMode::MidThread;
memoryManager.createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
deviceBitfield, preemptionMode, false);
EXPECT_EQ(2u, memoryManager.registeredEngines[0].osContext->getNumSupportedDevices());
EXPECT_EQ(deviceBitfield, memoryManager.registeredEngines[0].osContext->getDeviceBitfield());
EXPECT_EQ(preemptionMode, memoryManager.registeredEngines[0].osContext->getPreemptionMode());
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
deviceBitfield, preemptionMode, false);
EXPECT_EQ(2u, memoryManager->registeredEngines[0].osContext->getNumSupportedDevices());
EXPECT_EQ(deviceBitfield, memoryManager->registeredEngines[0].osContext->getDeviceBitfield());
EXPECT_EQ(preemptionMode, memoryManager->registeredEngines[0].osContext->getPreemptionMode());
}
TEST(ResidencyDataTest, givenTwoOsContextsWhenTheyAreRegisteredFromHigherToLowerThenProperSizeIsReturned) {
MockExecutionEnvironment executionEnvironment(*platformDevices);
MockMemoryManager memoryManager(false, false, executionEnvironment);
memoryManager.createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager.createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_EQ(2u, memoryManager.getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager.registeredEngines[0].osContext->getRefInternalCount());
EXPECT_EQ(1, memoryManager.registeredEngines[1].osContext->getRefInternalCount());
MockExecutionEnvironment executionEnvironment(*platformDevices, true, 2u);
auto memoryManager = new MockMemoryManager(false, false, executionEnvironment);
executionEnvironment.memoryManager.reset(memoryManager);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
std::unique_ptr<CommandStreamReceiver> csr1(createCommandStream(executionEnvironment, 1u));
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(csr1.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_EQ(2u, memoryManager->getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager->registeredEngines[0].osContext->getRefInternalCount());
EXPECT_EQ(1, memoryManager->registeredEngines[1].osContext->getRefInternalCount());
}
TEST(ResidencyDataTest, givenGpgpuEnginesWhenAskedForMaxOsContextCountThenValueIsGreaterOrEqual) {

66
unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -341,7 +341,16 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSingleEngineRegister
}
TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValuesOnMultipleEnginesRegisteredWhenHandleFenceCompletionIsCalledThenWaitOnCpuForEachEngine) {
memoryManager->createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
executionEnvironment->prepareRootDeviceEnvironments(2u);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(*executionEnvironment, 1u));
auto wddm2 = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
wddm2->init();
executionEnvironment->rootDeviceEnvironments[1]->osInterface.reset(new OSInterface());
executionEnvironment->rootDeviceEnvironments[1]->osInterface->get()->setWddm(wddm2);
executionEnvironment->rootDeviceEnvironments[1]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
2, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());
@@ -351,15 +360,26 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValuesOnMultipleEnginesRegi
allocation->getResidencyData().updateCompletionData(152u, 1u);
memoryManager->handleFenceCompletion(allocation);
EXPECT_EQ(2u, wddm->waitFromCpuResult.called);
EXPECT_EQ(152u, wddm->waitFromCpuResult.uint64ParamPassed);
EXPECT_EQ(lastEngineFence, wddm->waitFromCpuResult.monitoredFence);
EXPECT_EQ(1u, wddm->waitFromCpuResult.called);
EXPECT_EQ(1u, wddm2->waitFromCpuResult.called);
EXPECT_EQ(129u, wddm->waitFromCpuResult.uint64ParamPassed);
EXPECT_EQ(152u, wddm2->waitFromCpuResult.uint64ParamPassed);
EXPECT_EQ(lastEngineFence, wddm2->waitFromCpuResult.monitoredFence);
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSomeOfMultipleEnginesRegisteredWhenHandleFenceCompletionIsCalledThenWaitOnCpuForTheseEngines) {
memoryManager->createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
executionEnvironment->prepareRootDeviceEnvironments(2u);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(*executionEnvironment, 1u));
auto wddm2 = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[0].get()));
wddm2->init();
executionEnvironment->rootDeviceEnvironments[1]->osInterface.reset(new OSInterface());
executionEnvironment->rootDeviceEnvironments[1]->osInterface->get()->setWddm(wddm2);
executionEnvironment->rootDeviceEnvironments[1]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
2, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());
@@ -1408,16 +1428,40 @@ TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerAnd32bitBuildThenSvmPartitio
}
TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWhenCallingIsMemoryBudgetExhaustedThenReturnFalse) {
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
executionEnvironment->prepareRootDeviceEnvironments(3u);
executionEnvironment->initializeMemoryManager();
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
auto wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[i].get()));
wddm->init();
executionEnvironment->rootDeviceEnvironments[i]->osInterface.reset(new OSInterface());
executionEnvironment->rootDeviceEnvironments[i]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[i]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
}
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(*executionEnvironment, 0u));
std::unique_ptr<CommandStreamReceiver> csr1(createCommandStream(*executionEnvironment, 1u));
std::unique_ptr<CommandStreamReceiver> csr2(createCommandStream(*executionEnvironment, 2u));
memoryManager->createAndRegisterOsContext(csr.get(), aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(csr1.get(), aub_stream::ENGINE_RCS, 2, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(csr2.get(), aub_stream::ENGINE_RCS, 3, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_FALSE(memoryManager->isMemoryBudgetExhausted());
}
TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWithRegisteredOsContextWithExhaustedMemoryBudgetWhenCallingIsMemoryBudgetExhaustedThenReturnTrue) {
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(nullptr, aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
executionEnvironment->prepareRootDeviceEnvironments(3u);
executionEnvironment->initializeMemoryManager();
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
auto wddm = static_cast<WddmMock *>(Wddm::createWddm(nullptr, *executionEnvironment->rootDeviceEnvironments[i].get()));
wddm->init();
executionEnvironment->rootDeviceEnvironments[i]->osInterface.reset(new OSInterface());
executionEnvironment->rootDeviceEnvironments[i]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[i]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
}
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(*executionEnvironment, 0u));
std::unique_ptr<CommandStreamReceiver> csr1(createCommandStream(*executionEnvironment, 1u));
std::unique_ptr<CommandStreamReceiver> csr2(createCommandStream(*executionEnvironment, 2u));
memoryManager->createAndRegisterOsContext(csr.get(), aub_stream::ENGINE_RCS, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(csr1.get(), aub_stream::ENGINE_RCS, 2, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(csr2.get(), aub_stream::ENGINE_RCS, 3, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto osContext = static_cast<OsContextWin *>(memoryManager->getRegisteredEngines()[1].osContext);
osContext->getResidencyController().setMemoryBudgetExhausted();
EXPECT_TRUE(memoryManager->isMemoryBudgetExhausted());

11
unit_tests/os_interface/windows/wddm_memory_manager_tests.h
View File

@@ -57,9 +57,11 @@ class MockWddmMemoryManagerFixture {
executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new OSInterface());
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
executionEnvironment->initializeMemoryManager();
memoryManager = std::make_unique<MockWddmMemoryManager>(*executionEnvironment);
osContext = memoryManager->createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
osContext->incRefInternal();
@@ -72,6 +74,7 @@ class MockWddmMemoryManagerFixture {
ExecutionEnvironment *executionEnvironment;
std::unique_ptr<MockWddmMemoryManager> memoryManager;
std::unique_ptr<CommandStreamReceiver> csr;
WddmMock *wddm = nullptr;
MockWddmResidentAllocationsContainer *mockTemporaryResources;
OsContext *osContext = nullptr;
@@ -105,9 +108,11 @@ class WddmMemoryManagerFixtureWithGmockWddm : public ExecutionEnvironmentFixture
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);
osContext = memoryManager->createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], 1, preemptionMode, false);
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], 1, preemptionMode, false);
osContext->incRefInternal();
@@ -116,10 +121,10 @@ class WddmMemoryManagerFixtureWithGmockWddm : public ExecutionEnvironmentFixture
void TearDown() override {
osContext->decRefInternal();
delete memoryManager;
}
NiceMock<GmockWddm> *wddm = nullptr;
std::unique_ptr<CommandStreamReceiver> csr;
OSInterface *osInterface;
OsContext *osContext;
};

13
unit_tests/os_interface/windows/wddm_residency_controller_tests.cpp
View File

@@ -18,8 +18,10 @@
#include "core/os_interface/windows/wddm_memory_operations_handler.h"
#include "core/os_interface/windows/wddm_residency_controller.h"
#include "core/unit_tests/os_interface/windows/mock_gdi_interface.h"
#include "runtime/command_stream/command_stream_receiver.h"
#include "runtime/platform/platform.h"
#include "test.h"
#include "unit_tests/libult/create_command_stream.h"
#include "unit_tests/mocks/mock_allocation_properties.h"
#include "unit_tests/mocks/mock_execution_environment.h"
#include "unit_tests/mocks/mock_wddm.h"
@@ -119,9 +121,12 @@ struct WddmResidencyControllerWithMockWddmTest : public WddmResidencyControllerT
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
executionEnvironment->initializeMemoryManager();
memoryManager = std::make_unique<MockWddmMemoryManager>(*executionEnvironment);
osContext = memoryManager->createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], 1, preemptionMode, false);
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], 1, preemptionMode, false);
osContext->incRefInternal();
residencyController = &static_cast<OsContextWin *>(osContext)->getResidencyController();
@@ -133,6 +138,7 @@ struct WddmResidencyControllerWithMockWddmTest : public WddmResidencyControllerT
ExecutionEnvironment *executionEnvironment;
std::unique_ptr<MockWddmMemoryManager> memoryManager;
std::unique_ptr<CommandStreamReceiver> csr;
::testing::NiceMock<GmockWddm> *wddm = nullptr;
OsContext *osContext;
WddmResidencyController *residencyController;
@@ -151,9 +157,11 @@ struct WddmResidencyControllerWithGdiAndMemoryManagerTest : ::testing::Test {
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm);
executionEnvironment->initializeMemoryManager();
memoryManager = std::make_unique<MockWddmMemoryManager>(*executionEnvironment);
osContext = memoryManager->createAndRegisterOsContext(nullptr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
osContext->incRefInternal();
@@ -167,6 +175,7 @@ struct WddmResidencyControllerWithGdiAndMemoryManagerTest : ::testing::Test {
ExecutionEnvironment *executionEnvironment;
std::unique_ptr<MockWddmMemoryManager> memoryManager;
std::unique_ptr<CommandStreamReceiver> csr;
WddmMock *wddm = nullptr;
OsContext *osContext = nullptr;