From 08fc0c1e1f805f714e4bc6ad46047fd8a311dbce Mon Sep 17 00:00:00 2001 From: Mateusz Hoppe Date: Tue, 28 Oct 2025 18:45:22 +0000 Subject: [PATCH] fix: expose single device mode - return internal engine as default engine when defaultEngineIndex is not yet set - return correct internal engine from Device::getInternalEngine() Resolves: HSD-18043691881 Signed-off-by: Mateusz Hoppe --- shared/source/device/device.cpp | 3 ++ shared/source/device/root_device.cpp | 2 +- .../source/memory_manager/memory_manager.cpp | 9 +++++ .../unit_test/device/neo_device_tests.cpp | 26 +++++++++++++ .../memory_manager/memory_manager_tests.cpp | 37 +++++++++++++++++++ 5 files changed, 76 insertions(+), 1 deletion(-) diff --git a/shared/source/device/device.cpp b/shared/source/device/device.cpp index 8541c28813..471586f437 100644 --- a/shared/source/device/device.cpp +++ b/shared/source/device/device.cpp @@ -904,6 +904,9 @@ EngineControl &Device::getInternalEngine() { auto engineType = getChosenEngineType(getHardwareInfo()); + if (getRootDeviceEnvironment().isExposeSingleDeviceMode()) { + return this->getEngine(engineType, EngineUsage::internal); + } return this->getNearestGenericSubDevice(0)->getEngine(engineType, EngineUsage::internal); } diff --git a/shared/source/device/root_device.cpp b/shared/source/device/root_device.cpp index 0df93e736a..5ce74ce5c8 100644 --- a/shared/source/device/root_device.cpp +++ b/shared/source/device/root_device.cpp @@ -88,7 +88,7 @@ bool RootDevice::createRootDeviceEngine(EngineTypeUsage engineTypeUsage, DeviceB auto engineType = engineTypeUsage.first; auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(hwInfo); - EngineDescriptor engineDescriptor(EngineTypeUsage{engineType, EngineUsage::regular}, deviceBitfield, preemptionMode, deviceBitfield.count() > 1); + EngineDescriptor engineDescriptor(engineTypeUsage, deviceBitfield, preemptionMode, deviceBitfield.count() > 1); auto &gfxCoreHelper = getGfxCoreHelper(); bool isPrimaryEngine = EngineHelpers::isCcs(engineType); diff --git a/shared/source/memory_manager/memory_manager.cpp b/shared/source/memory_manager/memory_manager.cpp index 0750be2d8b..ec57e6e8eb 100644 --- a/shared/source/memory_manager/memory_manager.cpp +++ b/shared/source/memory_manager/memory_manager.cpp @@ -1291,6 +1291,15 @@ OsContext *MemoryManager::getDefaultEngineContext(uint32_t rootDeviceIndex, Devi break; } } + if (!defaultContext && peekExecutionEnvironment().rootDeviceEnvironments[rootDeviceIndex]->isExposeSingleDeviceMode()) { + for (auto &engine : getRegisteredEngines(rootDeviceIndex)) { + auto osContext = engine.osContext; + if (osContext->isInternalEngine() && osContext->getDeviceBitfield() == subdevicesBitfield) { + defaultContext = osContext; + break; + } + } + } if (!defaultContext) { defaultContext = getRegisteredEngines(rootDeviceIndex)[defaultEngineIndex[rootDeviceIndex]].osContext; } diff --git a/shared/test/unit_test/device/neo_device_tests.cpp b/shared/test/unit_test/device/neo_device_tests.cpp index a425a1445c..1e02232186 100644 --- a/shared/test/unit_test/device/neo_device_tests.cpp +++ b/shared/test/unit_test/device/neo_device_tests.cpp @@ -1793,6 +1793,32 @@ HWTEST_F(DeviceTests, givenExposeSingleDeviceAndContextGroupSizeEnabledWhenRootD } } +HWTEST_F(DeviceTests, givenExposeSingleDeviceWhenGettingInternalEngineThenRootDeviceEngineIsReturned) { + if (defaultHwInfo->capabilityTable.defaultEngineType != aub_stream::EngineType::ENGINE_CCS) { + GTEST_SKIP(); + } + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); + + DebugManagerStateRestore dbgRestorer; + debugManager.flags.CreateMultipleSubDevices.set(2); + + HardwareInfo hwInfo = *defaultHwInfo; + hwInfo.featureTable.flags.ftrCCSNode = true; + hwInfo.featureTable.ftrBcsInfo = 0b111; + hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_CCS; + hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 1; + hwInfo.capabilityTable.blitterOperationsSupported = true; + + auto executionEnvironment = MockDevice::prepareExecutionEnvironment(&hwInfo, 0); + executionEnvironment->rootDeviceEnvironments[0]->setExposeSingleDeviceMode(true); + + auto device = std::unique_ptr(MockDevice::createWithExecutionEnvironment(&hwInfo, executionEnvironment, 0)); + + auto internalEngine = device->getInternalEngine(); + EXPECT_EQ(EngineUsage::internal, internalEngine.getEngineUsage()); + EXPECT_EQ(2u, internalEngine.osContext->getDeviceBitfield().count()); +} + HWTEST_F(DeviceTests, givenRootDeviceWithCCSEngineAndContextGroupSizeEnabledWhenDeviceIsCreatedThenSecondaryEnginesAreCreated) { if (defaultHwInfo->capabilityTable.defaultEngineType != aub_stream::EngineType::ENGINE_CCS) { GTEST_SKIP(); diff --git a/shared/test/unit_test/memory_manager/memory_manager_tests.cpp b/shared/test/unit_test/memory_manager/memory_manager_tests.cpp index 5efa320424..5a60854069 100644 --- a/shared/test/unit_test/memory_manager/memory_manager_tests.cpp +++ b/shared/test/unit_test/memory_manager/memory_manager_tests.cpp @@ -251,6 +251,43 @@ TEST(MemoryManagerTest, givenMultipleDevicesMemoryManagerWhenGettingDefaultConte executionEnvironment.memoryManager->getDefaultEngineContext(1, 2)); } +TEST(MemoryManagerTest, givenSingleDeviceModeWhenGettingDefaultContextThenInternalContextReturnedAsAFallback) { + + DebugManagerStateRestore dbgRestorer; + debugManager.flags.CreateMultipleSubDevices.set(2); + + auto executionEnvironment = std::unique_ptr(MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), 0)); + executionEnvironment->rootDeviceEnvironments[0]->setExposeSingleDeviceMode(true); + + auto mockMemoryManager = new MockMemoryManager(false, false, *executionEnvironment); + executionEnvironment->memoryManager.reset(mockMemoryManager); + + { + auto csr = std::make_unique(*executionEnvironment, 0, 1); + auto csr0 = std::make_unique(*executionEnvironment, 0, 1); + auto csr1 = std::make_unique(*executionEnvironment, 0, 1); + + csr->internalAllocationStorage.reset(new MockInternalAllocationStorage(*csr)); + csr0->internalAllocationStorage.reset(new MockInternalAllocationStorage(*csr0)); + csr1->internalAllocationStorage.reset(new MockInternalAllocationStorage(*csr1)); + + auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor({aub_stream::EngineType::ENGINE_RCS, EngineUsage::regular}, DeviceBitfield(0x1))); + auto osContext0 = executionEnvironment->memoryManager->createAndRegisterOsContext(csr0.get(), EngineDescriptorHelper::getDefaultDescriptor({aub_stream::EngineType::ENGINE_RCS, EngineUsage::internal}, DeviceBitfield(0x1))); + auto osContext1 = executionEnvironment->memoryManager->createAndRegisterOsContext(csr1.get(), EngineDescriptorHelper::getDefaultDescriptor({aub_stream::EngineType::ENGINE_RCS, EngineUsage::internal}, DeviceBitfield(0x2))); + + EXPECT_NE(nullptr, osContext0); + EXPECT_NE(nullptr, osContext1); + + EXPECT_EQ(osContext0, executionEnvironment->memoryManager->getDefaultEngineContext(0, 1)); + EXPECT_EQ(osContext1, executionEnvironment->memoryManager->getDefaultEngineContext(0, 2)); + + executionEnvironment->rootDeviceEnvironments[0]->setExposeSingleDeviceMode(false); + + EXPECT_EQ(mockMemoryManager->getRegisteredEngines(0)[mockMemoryManager->defaultEngineIndex[0]].osContext, executionEnvironment->memoryManager->getDefaultEngineContext(0, 1)); + EXPECT_EQ(osContext, executionEnvironment->memoryManager->getDefaultEngineContext(0, 1)); + } +} + TEST(MemoryManagerTest, givenFailureOnRegisterSystemMemoryAllocationWhenAllocatingMemoryThenNullptrIsReturned) { AllocationProperties properties(mockRootDeviceIndex, true, MemoryConstants::cacheLineSize, AllocationType::buffer, false, mockDeviceBitfield); MockMemoryManager memoryManager;