Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: unify device hierarchy mode 

Related-To: GSD-9560
Signed-off-by: Jaroslaw Warchulski <jaroslaw.warchulski@intel.com>
This commit is contained in:
Jaroslaw Warchulski 2025-01-14 16:36:45 +00:00 committed by Compute-Runtime-Automation
parent 84b8622c16
commit 6a7bee67e9
30 changed files with 216 additions and 382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
level_zero/core/source/device/device_imp.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2024 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -663,9 +663,8 @@ ze_result_t DeviceImp::getP2PProperties(ze_device_handle_t hPeerDevice,
} }
ze_result_t DeviceImp::getRootDevice(ze_device_handle_t *phRootDevice) { ze_result_t DeviceImp::getRootDevice(ze_device_handle_t *phRootDevice) {
DriverHandleImp *driverHandleImp = static_cast<DriverHandleImp *>(driverHandle);
// Given FLAT device Hierarchy mode, then nullptr is returned for the root device since no traversal is allowed. // Given FLAT device Hierarchy mode, then nullptr is returned for the root device since no traversal is allowed.
if (driverHandleImp->deviceHierarchyMode == L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT) { if (this->neoDevice->getExecutionEnvironment()->getDeviceHierarchyMode() == NEO::DeviceHierarchyMode::FLAT) {
*phRootDevice = nullptr; *phRootDevice = nullptr;
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
} }
@ -1006,11 +1005,8 @@ ze_result_t DeviceImp::getProperties(ze_device_properties_t *pDeviceProperties)
pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_INTEGRATED; pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_INTEGRATED;
} }
if (isSubdevice) { if (isSubdevice && this->neoDevice->getExecutionEnvironment()->getDeviceHierarchyMode() != NEO::DeviceHierarchyMode::FLAT) {
DriverHandleImp *driverHandleImp = static_cast<DriverHandleImp *>(driverHandle); pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE;
if (driverHandleImp->deviceHierarchyMode != L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT) {
pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE;
}
} }
if (this->neoDevice->getDeviceInfo().errorCorrectionSupport) { if (this->neoDevice->getDeviceInfo().errorCorrectionSupport) {
@ -1198,9 +1194,8 @@ ze_result_t DeviceImp::getGlobalTimestampsUsingOsInterface(uint64_t *hostTimesta
} }
ze_result_t DeviceImp::getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) { ze_result_t DeviceImp::getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) {
DriverHandleImp *driverHandleImp = static_cast<DriverHandleImp *>(driverHandle);
// Given FLAT device Hierarchy mode, then a count of 0 is returned since no traversal is allowed. // Given FLAT device Hierarchy mode, then a count of 0 is returned since no traversal is allowed.
if (driverHandleImp->deviceHierarchyMode == L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT) { if (this->neoDevice->getExecutionEnvironment()->getDeviceHierarchyMode() == NEO::DeviceHierarchyMode::FLAT) {
*pCount = 0; *pCount = 0;
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
} }

2
level_zero/core/source/driver/driver.cpp
View File

@ -53,8 +53,6 @@ void DriverImp::initialize(ze_result_t *result) {
envReader.getSetting("ZE_ENABLE_PCI_ID_DEVICE_ORDER", false); envReader.getSetting("ZE_ENABLE_PCI_ID_DEVICE_ORDER", false);
envVariables.fp64Emulation = envVariables.fp64Emulation =
envReader.getSetting("NEO_FP64_EMULATION", false); envReader.getSetting("NEO_FP64_EMULATION", false);
envVariables.deviceHierarchyMode =
envReader.getSetting("ZE_FLAT_DEVICE_HIERARCHY", std::string(NEO::deviceHierarchyUnk));
auto executionEnvironment = new NEO::ExecutionEnvironment(); auto executionEnvironment = new NEO::ExecutionEnvironment();
UNRECOVERABLE_IF(nullptr == executionEnvironment); UNRECOVERABLE_IF(nullptr == executionEnvironment);

22
level_zero/core/source/driver/driver_handle_imp.cpp
View File

@ -298,17 +298,7 @@ DriverHandle *DriverHandle::create(std::vector<std::unique_ptr<NEO::Device>> dev
driverHandle->enableProgramDebugging = static_cast<NEO::DebuggingMode>(envVariables.programDebugging); driverHandle->enableProgramDebugging = static_cast<NEO::DebuggingMode>(envVariables.programDebugging);
driverHandle->enableSysman = envVariables.sysman; driverHandle->enableSysman = envVariables.sysman;
driverHandle->enablePciIdDeviceOrder = envVariables.pciIdDeviceOrder; driverHandle->enablePciIdDeviceOrder = envVariables.pciIdDeviceOrder;
char const *preferredDeviceHierarchy = envVariables.deviceHierarchyMode.c_str();
if ((strcmp(preferredDeviceHierarchy, NEO::deviceHierarchyUnk) == 0) || ((strcmp(preferredDeviceHierarchy, NEO::deviceHierarchyComposite) != 0) && (strcmp(preferredDeviceHierarchy, NEO::deviceHierarchyFlat) != 0) && (strcmp(preferredDeviceHierarchy, NEO::deviceHierarchyCombined) != 0))) {
preferredDeviceHierarchy = devices[0]->getGfxCoreHelper().getDefaultDeviceHierarchy();
}
if (strcmp(preferredDeviceHierarchy, NEO::deviceHierarchyComposite) == 0) {
driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE;
} else if (strcmp(preferredDeviceHierarchy, NEO::deviceHierarchyFlat) == 0) {
driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT;
} else if (strcmp(preferredDeviceHierarchy, NEO::deviceHierarchyCombined) == 0) {
driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMBINED;
}
ze_result_t res = driverHandle->initialize(std::move(devices)); ze_result_t res = driverHandle->initialize(std::move(devices));
if (res != ZE_RESULT_SUCCESS) { if (res != ZE_RESULT_SUCCESS) {
delete driverHandle; delete driverHandle;
@ -338,12 +328,9 @@ void DriverHandleImp::initHostUsmAllocPool() {
} }
ze_result_t DriverHandleImp::getDevice(uint32_t *pCount, ze_device_handle_t *phDevices) { ze_result_t DriverHandleImp::getDevice(uint32_t *pCount, ze_device_handle_t *phDevices) {
bool exposeSubDevices = false;
// If the user has requested FLAT or COMBINED device hierarchy model, then report all the sub devices as devices. // If the user has requested FLAT or COMBINED device hierarchy model, then report all the sub devices as devices.
if (this->deviceHierarchyMode != L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE) { bool exposeSubDevices = (this->devices.size() && this->devices[0]->getNEODevice()->getExecutionEnvironment()->getDeviceHierarchyMode() != NEO::DeviceHierarchyMode::COMPOSITE);
exposeSubDevices = true;
}
uint32_t numDevices = 0; uint32_t numDevices = 0;
if (exposeSubDevices) { if (exposeSubDevices) {
@ -871,10 +858,7 @@ ze_result_t DriverHandleImp::fabricVertexGetExp(uint32_t *pCount, ze_fabric_vert
this->initializeVertexes(); this->initializeVertexes();
} }
bool exposeSubDevices = false; bool exposeSubDevices = this->devices[0]->getNEODevice()->getExecutionEnvironment()->getDeviceHierarchyMode() != NEO::DeviceHierarchyMode::COMPOSITE;
if (deviceHierarchyMode == L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT) {
exposeSubDevices = true;
}
if (*pCount == 0) { if (*pCount == 0) {
if (exposeSubDevices) { if (exposeSubDevices) {

6
level_zero/core/source/driver/driver_handle_imp.h
View File

@ -27,11 +27,6 @@ struct FabricEdge;
struct Image; struct Image;
class ExternalSemaphoreController; class ExternalSemaphoreController;
enum L0DeviceHierarchyMode {
L0_DEVICE_HIERARCHY_COMPOSITE,
L0_DEVICE_HIERARCHY_FLAT,
L0_DEVICE_HIERARCHY_COMBINED
};
#pragma pack(1) #pragma pack(1)
struct IpcMemoryData { struct IpcMemoryData {
uint64_t handle = 0; uint64_t handle = 0;
@ -172,7 +167,6 @@ struct DriverHandleImp : public DriverHandle {
bool enableSysman = false; bool enableSysman = false;
bool enablePciIdDeviceOrder = false; bool enablePciIdDeviceOrder = false;
uint8_t powerHint = 0; uint8_t powerHint = 0;
L0DeviceHierarchyMode deviceHierarchyMode = L0_DEVICE_HIERARCHY_COMPOSITE;
// Error messages per thread, variable initialized / destoryed per thread, // Error messages per thread, variable initialized / destoryed per thread,
// not based on the lifetime of the object of a class. // not based on the lifetime of the object of a class.

3
level_zero/core/source/driver/driver_imp.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2024 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -42,7 +42,6 @@ struct L0EnvVariables {
bool sysman; bool sysman;
bool pciIdDeviceOrder; bool pciIdDeviceOrder;
bool fp64Emulation; bool fp64Emulation;
std::string deviceHierarchyMode;
}; };
} // namespace L0 } // namespace L0

6
level_zero/core/test/unit_tests/fixtures/device_fixture.cpp
View File

@ -131,11 +131,7 @@ void MultiDeviceFixtureHierarchy::setUp() {
executionEnvironment->rootDeviceEnvironments[i]->memoryOperationsInterface = std::make_unique<MockMemoryOperations>(); executionEnvironment->rootDeviceEnvironments[i]->memoryOperationsInterface = std::make_unique<MockMemoryOperations>();
} }
if (driverHandle->deviceHierarchyMode == L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT) { executionEnvironment->setDeviceHierarchyMode(deviceHierarchyMode);
executionEnvironment->setExposeSubDevicesAsDevices(true);
} else if (driverHandle->deviceHierarchyMode == L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMBINED) {
executionEnvironment->setCombinedDeviceHierarchy(true);
}
auto devices = NEO::DeviceFactory::createDevices(*executionEnvironment); auto devices = NEO::DeviceFactory::createDevices(*executionEnvironment);
if (devices.size()) { if (devices.size()) {

12
level_zero/core/test/unit_tests/fixtures/device_fixture.h
View File

@ -130,6 +130,7 @@ struct MultiDeviceFixture {
uint32_t numRootDevices = 4u; uint32_t numRootDevices = 4u;
uint32_t numSubDevices = 2u; uint32_t numSubDevices = 2u;
L0::ContextImp *context = nullptr; L0::ContextImp *context = nullptr;
NEO::DeviceHierarchyMode deviceHierarchyMode = NEO::DeviceHierarchyMode::COMPOSITE;
VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle}; VariableBackup<_ze_driver_handle_t *> globalDriverHandleBackup{&globalDriverHandle};
VariableBackup<uint32_t> driverCountBackup{&driverCount}; VariableBackup<uint32_t> driverCountBackup{&driverCount};
@ -139,23 +140,18 @@ struct MultiDeviceFixtureHierarchy : public MultiDeviceFixture {
void setUp(); void setUp();
}; };
struct MultiDeviceFixtureCompositeHierarchy : public MultiDeviceFixtureHierarchy { struct MultiDeviceFixtureCompositeHierarchy : public MultiDeviceFixtureHierarchy {};
void setUp() {
this->driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE;
MultiDeviceFixtureHierarchy::setUp();
}
};
struct MultiDeviceFixtureFlatHierarchy : public MultiDeviceFixtureHierarchy { struct MultiDeviceFixtureFlatHierarchy : public MultiDeviceFixtureHierarchy {
void setUp() { void setUp() {
this->driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT; this->deviceHierarchyMode = NEO::DeviceHierarchyMode::FLAT;
MultiDeviceFixtureHierarchy::setUp(); MultiDeviceFixtureHierarchy::setUp();
} }
}; };
struct MultiDeviceFixtureCombinedHierarchy : public MultiDeviceFixtureHierarchy { struct MultiDeviceFixtureCombinedHierarchy : public MultiDeviceFixtureHierarchy {
void setUp() { void setUp() {
this->driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMBINED; this->deviceHierarchyMode = NEO::DeviceHierarchyMode::COMBINED;
MultiDeviceFixtureHierarchy::setUp(); MultiDeviceFixtureHierarchy::setUp();
} }
}; };

5
level_zero/core/test/unit_tests/sources/device/test_device_pci_bus_info.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2024 Intel Corporation * Copyright (C) 2024-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -62,7 +62,7 @@ TEST_F(PciBusInfoTest, givenSuccessfulReadingOfBusValuesThenCorrectValuesAreRetu
} }
} }
TEST_P(PciBusOrderingTest, givenMultipleDevicesAndZePcieIdOrderingSetThenDevicesAndVerticesAreInCorrectOrder) { TEST_P(PciBusOrderingTest, givenMultipleDevicesWithCompositeHierarchyAndZePcieIdOrderingSetThenDevicesAndVerticesAreInCorrectOrder) {
constexpr uint32_t numRootDevices = 6u; constexpr uint32_t numRootDevices = 6u;
constexpr uint32_t numSubDevices = 2u; constexpr uint32_t numSubDevices = 2u;
const NEO::PhysicalDevicePciBusInfo busInfos[numRootDevices] = {{2, 0, 3, 0}, {2, 0, 1, 9}, {0, 0, 0, 1}, {0, 3, 5, 0}, {1, 3, 5, 0}, {0, 4, 1, 0}}; const NEO::PhysicalDevicePciBusInfo busInfos[numRootDevices] = {{2, 0, 3, 0}, {2, 0, 1, 9}, {0, 0, 0, 1}, {0, 3, 5, 0}, {1, 3, 5, 0}, {0, 4, 1, 0}};
@ -76,6 +76,7 @@ TEST_P(PciBusOrderingTest, givenMultipleDevicesAndZePcieIdOrderingSetThenDevices
debugManager.flags.EnableChipsetUniqueUUID.set(0); debugManager.flags.EnableChipsetUniqueUUID.set(0);
auto executionEnvironment = NEO::MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), 0u); auto executionEnvironment = NEO::MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), 0u);
executionEnvironment->setDeviceHierarchyMode(COMPOSITE);
auto memoryManager = new MockMemoryManagerOsAgnosticContext(*executionEnvironment); auto memoryManager = new MockMemoryManagerOsAgnosticContext(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);
auto neoDevices = NEO::DeviceFactory::createDevices(*executionEnvironment); auto neoDevices = NEO::DeviceFactory::createDevices(*executionEnvironment);

101
level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
View File

@ -558,107 +558,6 @@ TEST_F(DriverImpTest, givenEnabledProgramDebuggingWhenCreatingExecutionEnvironme
L0::globalDriver = nullptr; L0::globalDriver = nullptr;
} }
TEST_F(DriverImpTest, whenCreatingExecutionEnvironmentThenDefaultHierarchyIsEnabled) {
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
auto &gfxCoreHelper = driverHandleImp->memoryManager->peekExecutionEnvironment().rootDeviceEnvironments[0]->getHelper<NEO::GfxCoreHelper>();
if (strcmp(gfxCoreHelper.getDefaultDeviceHierarchy(), "COMPOSITE") == 0) {
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE);
} else {
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT);
}
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenFlatDeviceHierarchyWhenCreatingExecutionEnvironmentThenFlatHierarchyIsEnabled) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "FLAT"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenCompositeDeviceHierarchyWhenCreatingExecutionEnvironmentThenCompositeHierarchyIsEnabled) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "COMPOSITE"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenCombinedDeviceHierarchyWhenCreatingExecutionEnvironmentThenCombinedHierarchyIsEnabled) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "COMBINED"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMBINED);
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenErrantDeviceHierarchyWhenCreatingExecutionEnvironmentThenDefaultHierarchyIsEnabled) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "Flat"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
DriverImp driverImp;
driverImp.initialize(&result);
L0::DriverHandleImp *driverHandleImp = reinterpret_cast<L0::DriverHandleImp *>(L0::globalDriverHandle);
auto &gfxCoreHelper = driverHandleImp->memoryManager->peekExecutionEnvironment().rootDeviceEnvironments[0]->getHelper<NEO::GfxCoreHelper>();
if (strcmp(gfxCoreHelper.getDefaultDeviceHierarchy(), "COMPOSITE") == 0) {
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_COMPOSITE);
} else {
EXPECT_EQ(driverHandleImp->deviceHierarchyMode, L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT);
}
ASSERT_NE(nullptr, L0::globalDriver);
ASSERT_NE(0u, L0::globalDriver->numDevices);
delete L0::globalDriver;
L0::globalDriverHandle = nullptr;
L0::globalDriver = nullptr;
}
TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2WhenCreatingExecutionEnvironmentThenDebuggingEnabledIsTrue) { TEST_F(DriverImpTest, givenEnableProgramDebuggingWithValue2WhenCreatingExecutionEnvironmentThenDebuggingEnabledIsTrue) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);

8
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2024 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -2810,9 +2810,9 @@ TEST_F(TimestampEventCreate, givenEventWhenQueryKernelTimestampThenNotReadyRetur
EXPECT_EQ(0u, resultTimestamp.global.kernelEnd); EXPECT_EQ(0u, resultTimestamp.global.kernelEnd);
} }
TEST_F(EventPoolCreateMultiDevice, givenFlatHierarchyWhenCallZeGetDevicesThenSubDevicesAreReturnedAsSeparateDevices) { using EventPoolCreateMultiDeviceFlatHierarchy = Test<MultiDeviceFixtureFlatHierarchy>;
this->driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT;
TEST_F(EventPoolCreateMultiDeviceFlatHierarchy, givenFlatHierarchyWhenCallZeGetDevicesThenSubDevicesAreReturnedAsSeparateDevices) {
uint32_t deviceCount = 0; uint32_t deviceCount = 0;
ze_result_t result = zeDeviceGet(driverHandle.get(), &deviceCount, nullptr); ze_result_t result = zeDeviceGet(driverHandle.get(), &deviceCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result); EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@ -4311,6 +4311,8 @@ struct EventDynamicPacketUseFixture : public DeviceFixture {
void testSingleDevice() { void testSingleDevice() {
ze_result_t result = ZE_RESULT_SUCCESS; ze_result_t result = ZE_RESULT_SUCCESS;
device->getNEODevice()->getExecutionEnvironment()->setDeviceHierarchyMode(COMPOSITE);
auto &hwInfo = device->getHwInfo(); auto &hwInfo = device->getHwInfo();
auto &l0GfxCoreHelper = device->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>(); auto &l0GfxCoreHelper = device->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
auto &gfxCoreHelper = device->getGfxCoreHelper(); auto &gfxCoreHelper = device->getGfxCoreHelper();

132
level_zero/core/test/unit_tests/sources/fabric/test_fabric.cpp
View File

@ -37,7 +37,7 @@ class MockFabricDeviceInterface {
using FabricVertexFixture = Test<MultiDeviceFixture>; using FabricVertexFixture = Test<MultiDeviceFixture>;
TEST_F(FabricVertexFixture, WhenDevicesAreCreatedThenVerifyFabricVerticesAreCreated) { TEST_F(FabricVertexFixture, whenDevicesAreCreatedThenVerifyFabricVerticesAreCreated) {
uint32_t count = 0; uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, L0::zeFabricVertexGetExp(driverHandle->toHandle(), &count, nullptr)); EXPECT_EQ(ZE_RESULT_SUCCESS, L0::zeFabricVertexGetExp(driverHandle->toHandle(), &count, nullptr));
@ -156,7 +156,7 @@ TEST_F(FabricVertexFixture, givenFabricVerticesAreCreatedWhenzeFabricVertexGetPr
} }
} }
TEST(FabricEngineInstanceTest, GivenSubDeviceWhenFabricVerticesAreCreatedThenSkipCreationForSubDevice) { TEST(FabricEngineInstanceTest, givenSubDeviceWhenFabricVerticesAreCreatedThenSkipCreationForSubDevice) {
auto hwInfo = *NEO::defaultHwInfo.get(); auto hwInfo = *NEO::defaultHwInfo.get();
auto executionEnvironment = NEO::MockDevice::prepareExecutionEnvironment(&hwInfo, 0u); auto executionEnvironment = NEO::MockDevice::prepareExecutionEnvironment(&hwInfo, 0u);
@ -182,7 +182,7 @@ TEST(FabricEngineInstanceTest, GivenSubDeviceWhenFabricVerticesAreCreatedThenSki
EXPECT_EQ(count, 0u); EXPECT_EQ(count, 0u);
} }
TEST_F(FabricVertexFixture, GivenDevicesAreCreatedWhenZeDeviceGetFabricVertexExpIsCalledThenExpectValidVertices) { TEST_F(FabricVertexFixture, givenDevicesAreCreatedWhenZeDeviceGetFabricVertexExpIsCalledThenExpectValidVertices) {
for (auto l0Device : driverHandle->devices) { for (auto l0Device : driverHandle->devices) {
ze_fabric_vertex_handle_t hVertex = nullptr; ze_fabric_vertex_handle_t hVertex = nullptr;
@ -197,7 +197,7 @@ TEST_F(FabricVertexFixture, GivenDevicesAreCreatedWhenZeDeviceGetFabricVertexExp
} }
} }
TEST_F(FabricVertexFixture, GivenDevicesAreCreatedWhenFabricVertexIsNotSetToDeviceThenZeDeviceGetFabricVertexExpReturnsError) { TEST_F(FabricVertexFixture, givenDevicesAreCreatedWhenFabricVertexIsNotSetToDeviceThenZeDeviceGetFabricVertexExpReturnsError) {
auto l0Device = driverHandle->devices[0]; auto l0Device = driverHandle->devices[0];
ze_fabric_vertex_handle_t hVertex = nullptr; ze_fabric_vertex_handle_t hVertex = nullptr;
@ -212,67 +212,20 @@ TEST_F(FabricVertexFixture, GivenDevicesAreCreatedWhenFabricVertexIsNotSetToDevi
EXPECT_EQ(hVertex, nullptr); EXPECT_EQ(hVertex, nullptr);
} }
class FabricVertexFlatDeviceTestFixture : public MultiDeviceFixtureFlatHierarchy, TEST(FabricVertexTestFixture, givenCompositeHierarchyWhenFabricVerticesGetExpIsCalledCorrectVerticesAreReturned) {
public ::testing::Test {
void SetUp() override {
NEO::debugManager.flags.ZE_AFFINITY_MASK.set("0,1.1,2");
MultiDeviceFixtureFlatHierarchy::setUp();
}
void TearDown() override {
MultiDeviceFixtureFlatHierarchy::tearDown();
}
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
}; NEO::debugManager.flags.ZE_AFFINITY_MASK.set("0,1.1,2");
MultiDeviceFixtureCompositeHierarchy multiDeviceFixture{};
multiDeviceFixture.setUp();
TEST_F(FabricVertexFlatDeviceTestFixture, GivenFlatHierarchyWhenFabricVerticesGetExpIsCalledCorrectVerticesAreReturned) {
uint32_t count = 0; uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices; std::vector<ze_fabric_vertex_handle_t> phVertices;
EXPECT_EQ(driverHandle->fabricVertexGetExp(&count, nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(multiDeviceFixture.driverHandle->fabricVertexGetExp(&count, nullptr), ZE_RESULT_SUCCESS);
// only 2 vertexes for mask "0,1.1,2":
// 0 and 2
// 1.1 is ignored in FlatHierarchy
uint32_t expectedVertexes = 2u;
EXPECT_EQ(count, expectedVertexes);
// Requesting for a reduced count
phVertices.resize(count);
EXPECT_EQ(driverHandle->fabricVertexGetExp(&count, phVertices.data()), ZE_RESULT_SUCCESS);
ze_device_handle_t hDevice{};
// Device 0 associated with value 0 in mask
EXPECT_EQ(L0::zeFabricVertexGetDeviceExp(phVertices[0], &hDevice), ZE_RESULT_SUCCESS);
DeviceImp *deviceImp = static_cast<DeviceImp *>(hDevice);
EXPECT_FALSE(deviceImp->isSubdevice);
// Device 1 associated with value 2 in mask
EXPECT_EQ(L0::zeFabricVertexGetDeviceExp(phVertices[1], &hDevice), ZE_RESULT_SUCCESS);
deviceImp = static_cast<DeviceImp *>(hDevice);
EXPECT_FALSE(deviceImp->isSubdevice);
}
class FabricVertexTestFixture : public MultiDeviceFixture,
public ::testing::Test {
void SetUp() override {
NEO::debugManager.flags.ZE_AFFINITY_MASK.set("0,1.1,2");
MultiDeviceFixture::setUp();
}
void TearDown() override {
MultiDeviceFixture::tearDown();
}
DebugManagerStateRestore restorer;
};
TEST_F(FabricVertexTestFixture, GivenCompositeHierarchyWhenFabricVerticesGetExpIsCalledCorrectVerticesAreReturned) {
uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices;
EXPECT_EQ(driverHandle->fabricVertexGetExp(&count, nullptr), ZE_RESULT_SUCCESS);
uint32_t expectedVertexes = 3u; uint32_t expectedVertexes = 3u;
EXPECT_EQ(count, expectedVertexes); EXPECT_EQ(count, expectedVertexes);
phVertices.resize(count); phVertices.resize(count);
EXPECT_EQ(driverHandle->fabricVertexGetExp(&count, phVertices.data()), ZE_RESULT_SUCCESS); EXPECT_EQ(multiDeviceFixture.driverHandle->fabricVertexGetExp(&count, phVertices.data()), ZE_RESULT_SUCCESS);
// Device 0 associated with value 0 in mask // Device 0 associated with value 0 in mask
ze_device_handle_t hDevice{}; ze_device_handle_t hDevice{};
@ -282,7 +235,7 @@ TEST_F(FabricVertexTestFixture, GivenCompositeHierarchyWhenFabricVerticesGetExpI
uint32_t countSubDevices = 0; uint32_t countSubDevices = 0;
EXPECT_EQ(L0::zeFabricVertexGetSubVerticesExp(phVertices[0], &countSubDevices, nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(L0::zeFabricVertexGetSubVerticesExp(phVertices[0], &countSubDevices, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(countSubDevices, numSubDevices); EXPECT_EQ(countSubDevices, multiDeviceFixture.numSubDevices);
std::vector<ze_fabric_vertex_handle_t> phSubvertices(countSubDevices); std::vector<ze_fabric_vertex_handle_t> phSubvertices(countSubDevices);
EXPECT_EQ(L0::zeFabricVertexGetSubVerticesExp(phVertices[0], &countSubDevices, phSubvertices.data()), ZE_RESULT_SUCCESS); EXPECT_EQ(L0::zeFabricVertexGetSubVerticesExp(phVertices[0], &countSubDevices, phSubvertices.data()), ZE_RESULT_SUCCESS);
@ -311,24 +264,65 @@ TEST_F(FabricVertexTestFixture, GivenCompositeHierarchyWhenFabricVerticesGetExpI
phSubvertices.clear(); phSubvertices.clear();
countSubDevices = 0; countSubDevices = 0;
EXPECT_EQ(L0::zeFabricVertexGetSubVerticesExp(phVertices[2], &countSubDevices, nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(L0::zeFabricVertexGetSubVerticesExp(phVertices[2], &countSubDevices, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(countSubDevices, numSubDevices); EXPECT_EQ(countSubDevices, multiDeviceFixture.numSubDevices);
multiDeviceFixture.tearDown();
} }
TEST_F(FabricVertexTestFixture, GivenFlatHierarchyWhenFabricVerticesGetExpIsCalledCorrectVerticesAreReturned) { TEST(FabricVertexTestFixture, givenFlatHierarchyWhenFabricVerticesGetExpIsCalledCorrectVerticesAreReturned) {
DebugManagerStateRestore restorer;
NEO::debugManager.flags.ZE_AFFINITY_MASK.set("0,1.1,2");
MultiDeviceFixtureFlatHierarchy multiDeviceFixture{};
multiDeviceFixture.setUp();
uint32_t count = 0; uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices; std::vector<ze_fabric_vertex_handle_t> phVertices;
this->driverHandle->deviceHierarchyMode = L0::L0DeviceHierarchyMode::L0_DEVICE_HIERARCHY_FLAT; EXPECT_EQ(multiDeviceFixture.driverHandle->fabricVertexGetExp(&count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(driverHandle->fabricVertexGetExp(&count, nullptr), ZE_RESULT_SUCCESS); // only 2 vertexes for mask "0,1.1,2":
uint32_t expectedVertexes = 5u; // 0 and 2
// 1.1 is ignored in FlatHierarchy
uint32_t expectedVertexes = 2u;
EXPECT_EQ(count, expectedVertexes);
// Requesting for a reduced count
phVertices.resize(count);
EXPECT_EQ(multiDeviceFixture.driverHandle->fabricVertexGetExp(&count, phVertices.data()), ZE_RESULT_SUCCESS);
ze_device_handle_t hDevice{};
// Device 0 associated with value 0 in mask
EXPECT_EQ(L0::zeFabricVertexGetDeviceExp(phVertices[0], &hDevice), ZE_RESULT_SUCCESS);
DeviceImp *deviceImp = static_cast<DeviceImp *>(hDevice);
EXPECT_FALSE(deviceImp->isSubdevice);
// Device 1 associated with value 2 in mask
EXPECT_EQ(L0::zeFabricVertexGetDeviceExp(phVertices[1], &hDevice), ZE_RESULT_SUCCESS);
deviceImp = static_cast<DeviceImp *>(hDevice);
EXPECT_FALSE(deviceImp->isSubdevice);
multiDeviceFixture.tearDown();
}
TEST(FabricVertexTestFixture, givenCombinedHierarchyWhenFabricVerticesGetExpIsCalledCorrectVerticesAreReturned2) {
DebugManagerStateRestore restorer;
NEO::debugManager.flags.ZE_AFFINITY_MASK.set("0,1.1,2");
MultiDeviceFixtureCombinedHierarchy multiDeviceFixture{};
multiDeviceFixture.setUp();
uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices;
EXPECT_EQ(multiDeviceFixture.driverHandle->fabricVertexGetExp(&count, nullptr), ZE_RESULT_SUCCESS);
uint32_t expectedVertexes = 2u;
EXPECT_EQ(count, expectedVertexes); EXPECT_EQ(count, expectedVertexes);
phVertices.resize(count); phVertices.resize(count);
EXPECT_EQ(driverHandle->fabricVertexGetExp(&count, phVertices.data()), ZE_RESULT_SUCCESS); EXPECT_EQ(multiDeviceFixture.driverHandle->fabricVertexGetExp(&count, phVertices.data()), ZE_RESULT_SUCCESS);
multiDeviceFixture.tearDown();
} }
using FabricEdgeFixture = Test<MultiDeviceFixture>; using FabricEdgeFixture = Test<MultiDeviceFixture>;
TEST_F(FabricEdgeFixture, GivenFabricVerticesAreCreatedWhenZeFabricEdgeGetExpIsCalledThenReturnSuccess) { TEST_F(FabricEdgeFixture, givenFabricVerticesAreCreatedWhenZeFabricEdgeGetExpIsCalledThenReturnSuccess) {
// initialize // initialize
uint32_t count = 0; uint32_t count = 0;
@ -364,7 +358,7 @@ TEST_F(FabricEdgeFixture, GivenFabricVerticesAreCreatedWhenZeFabricEdgeGetExpIsC
edgeHandles.data())); edgeHandles.data()));
} }
TEST_F(FabricEdgeFixture, GivenFabricVerticesAreCreatedForIndirectEdgesWhenZeFabricEdgeGetExpIsCalledThenReturnSuccess) { TEST_F(FabricEdgeFixture, givenFabricVerticesAreCreatedForIndirectEdgesWhenZeFabricEdgeGetExpIsCalledThenReturnSuccess) {
// initialize // initialize
uint32_t count = 0; uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices; std::vector<ze_fabric_vertex_handle_t> phVertices;
@ -417,7 +411,7 @@ TEST_F(FabricEdgeFixture, GivenFabricVerticesAreCreatedForIndirectEdgesWhenZeFab
driverHandle->fabricIndirectEdges.clear(); driverHandle->fabricIndirectEdges.clear();
} }
TEST_F(FabricEdgeFixture, GivenFabricEdgesAreCreatedWhenZeFabricEdgeGetVerticesExpIsCalledThenReturnCorrectVertices) { TEST_F(FabricEdgeFixture, givenFabricEdgesAreCreatedWhenZeFabricEdgeGetVerticesExpIsCalledThenReturnCorrectVertices) {
// initialize // initialize
uint32_t count = 0; uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices; std::vector<ze_fabric_vertex_handle_t> phVertices;
@ -449,7 +443,7 @@ TEST_F(FabricEdgeFixture, GivenFabricEdgesAreCreatedWhenZeFabricEdgeGetVerticesE
EXPECT_EQ(hVertexB, driverHandle->fabricVertices[1]); EXPECT_EQ(hVertexB, driverHandle->fabricVertices[1]);
} }
TEST_F(FabricEdgeFixture, GivenFabricEdgesAreCreatedWhenZeFabricEdgeGetPropertiesExpIsCalledThenReturnCorrectProperties) { TEST_F(FabricEdgeFixture, givenFabricEdgesAreCreatedWhenZeFabricEdgeGetPropertiesExpIsCalledThenReturnCorrectProperties) {
// initialize // initialize
uint32_t count = 0; uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices; std::vector<ze_fabric_vertex_handle_t> phVertices;
@ -482,7 +476,7 @@ TEST_F(FabricEdgeFixture, GivenFabricEdgesAreCreatedWhenZeFabricEdgeGetPropertie
EXPECT_EQ(getProperties.latency, 20u); EXPECT_EQ(getProperties.latency, 20u);
} }
TEST_F(FabricEdgeFixture, GivenMdfiLinksAreAvailableWhenEdgesAreCreatedThenVerifyThatBiDirectionalEdgesAreNotCreated) { TEST_F(FabricEdgeFixture, givenMdfiLinksAreAvailableWhenEdgesAreCreatedThenVerifyThatBiDirectionalEdgesAreNotCreated) {
// initialize // initialize
uint32_t count = 0; uint32_t count = 0;
std::vector<ze_fabric_vertex_handle_t> phVertices; std::vector<ze_fabric_vertex_handle_t> phVertices;

9
level_zero/tools/test/unit_tests/sources/sysman/mocks/test_sysman_device_info.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2022-2023 Intel Corporation * Copyright (C) 2022-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -14,7 +14,7 @@
namespace L0 { namespace L0 {
namespace ult { namespace ult {
TEST_F(SysmanMultiDeviceInfoFixture, GivenDeviceWithMultipleTilesWhenOnlyTileOneIsEnabledThenGetSysmanDeviceInfoReturnsExpectedValues) { TEST_F(SysmanMultiDeviceInfoFixture, givenDeviceWithMultipleTilesWhenOnlyTileOneIsEnabledThenGetSysmanDeviceInfoReturnsExpectedValues) {
neoDevice->deviceBitfield.reset(); neoDevice->deviceBitfield.reset();
neoDevice->deviceBitfield.set(1); neoDevice->deviceBitfield.set(1);
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
@ -24,7 +24,7 @@ TEST_F(SysmanMultiDeviceInfoFixture, GivenDeviceWithMultipleTilesWhenOnlyTileOne
EXPECT_TRUE(onSubdevice); EXPECT_TRUE(onSubdevice);
} }
TEST_F(SysmanMultiDeviceInfoFixture, GivenDeviceWithMultipleTilesWhenOnlyTileOneIsEnabledAndMultiArchIsDisabledThenGetSysmanDeviceInfoReturnsExpectedValues) { TEST_F(SysmanMultiDeviceInfoFixture, givenDeviceWithMultipleTilesWhenOnlyTileOneIsEnabledAndMultiArchIsDisabledThenGetSysmanDeviceInfoReturnsExpectedValues) {
neoDevice->deviceBitfield.reset(); neoDevice->deviceBitfield.reset();
neoDevice->deviceBitfield.set(1); neoDevice->deviceBitfield.set(1);
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
@ -34,7 +34,8 @@ TEST_F(SysmanMultiDeviceInfoFixture, GivenDeviceWithMultipleTilesWhenOnlyTileOne
EXPECT_FALSE(onSubdevice); EXPECT_FALSE(onSubdevice);
} }
TEST_F(SysmanMultiDeviceInfoFixture, GivenDeviceWithMultipleTilesEnabledThenGetSysmanDeviceInfoReturnsExpectedValues) { TEST_F(SysmanMultiDeviceInfoFixture, givenDeviceWithMultipleTilesEnabledAndCompositeHierarchyThenGetSysmanDeviceInfoReturnsExpectedValues) {
neoDevice->getExecutionEnvironment()->setDeviceHierarchyMode(NEO::DeviceHierarchyMode::COMPOSITE);
uint32_t subDeviceCount = 0; uint32_t subDeviceCount = 0;
std::vector<ze_device_handle_t> deviceHandles; std::vector<ze_device_handle_t> deviceHandles;
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr); Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);

2
opencl/source/api/api.cpp
View File

@ -259,7 +259,7 @@ cl_int CL_API_CALL clGetDeviceIDs(cl_platform_id platform,
cl_uint retNum = 0; cl_uint retNum = 0;
for (auto platformDeviceIndex = 0u; platformDeviceIndex < numDev; platformDeviceIndex++) { for (auto platformDeviceIndex = 0u; platformDeviceIndex < numDev; platformDeviceIndex++) {
bool exposeSubDevices = pPlatform->peekExecutionEnvironment()->isExposingSubDevicesAsDevices(); bool exposeSubDevices = pPlatform->peekExecutionEnvironment()->getDeviceHierarchyMode() != COMPOSITE;
ClDevice *device = pPlatform->getClDevice(platformDeviceIndex); ClDevice *device = pPlatform->getClDevice(platformDeviceIndex);
UNRECOVERABLE_IF(device == nullptr); UNRECOVERABLE_IF(device == nullptr);

2
opencl/source/cl_device/cl_device.cpp
View File

@ -51,7 +51,7 @@ ClDevice::ClDevice(Device &device, ClDevice &rootClDevice, Platform *platform) :
pClSubDevice->decRefApi(); pClSubDevice->decRefApi();
pClSubDevice->internalParentDevice = this; pClSubDevice->internalParentDevice = this;
if (!device.getExecutionEnvironment()->isExposingSubDevicesAsDevices()) { if (device.getExecutionEnvironment()->getDeviceHierarchyMode() == COMPOSITE) {
auto &deviceInfo = pClSubDevice->deviceInfo; auto &deviceInfo = pClSubDevice->deviceInfo;
deviceInfo.parentDevice = this; deviceInfo.parentDevice = this;
deviceInfo.partitionType[0] = CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN; deviceInfo.partitionType[0] = CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN;

62
opencl/test/unit_test/device/sub_device_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2019-2024 Intel Corporation * Copyright (C) 2019-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -104,42 +104,45 @@ TEST(SubDevicesTest, givenDeviceWithSubDevicesWhenSubDeviceApiRefCountsAreChange
EXPECT_EQ(baseDefaultDeviceInternalRefCount, defaultDevice->getRefInternalCount()); EXPECT_EQ(baseDefaultDeviceInternalRefCount, defaultDevice->getRefInternalCount());
} }
TEST(SubDevicesTest, givenDeviceWithSubDevicesAndSubDevicesAsDevicesIsSetWhenSubDeviceApiRefCountsAreChangedThenChangeIsNotPropagatedToRootDevice) { TEST(SubDevicesTest, givenDeviceWithFlatOrCombinedHierarchyWhenSubDeviceApiRefCountsAreChangedThenChangeIsNotPropagatedToRootDevice) {
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
debugManager.flags.CreateMultipleSubDevices.set(2); debugManager.flags.CreateMultipleSubDevices.set(2);
UnitTestSetter::disableHeaplessStateInit(restorer); UnitTestSetter::disableHeaplessStateInit(restorer);
VariableBackup<bool> mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); VariableBackup<bool> mockDeviceFlagBackup(&MockDevice::createSingleDevice, false);
initPlatform(); DeviceHierarchyMode deviceHierarchyModes[] = {FLAT, COMBINED};
platform()->peekExecutionEnvironment()->setExposeSubDevicesAsDevices(1); for (auto deviceHierarchyMode : deviceHierarchyModes) {
auto nonDefaultPlatform = std::make_unique<MockPlatform>(*platform()->peekExecutionEnvironment()); initPlatform();
nonDefaultPlatform->initializeWithNewDevices(); platform()->peekExecutionEnvironment()->setDeviceHierarchyMode(deviceHierarchyMode);
auto device = nonDefaultPlatform->getClDevice(0); auto nonDefaultPlatform = std::make_unique<MockPlatform>(*platform()->peekExecutionEnvironment());
auto defaultDevice = platform()->getClDevice(0); nonDefaultPlatform->initializeWithNewDevices();
auto device = nonDefaultPlatform->getClDevice(0);
auto defaultDevice = platform()->getClDevice(0);
auto subDevice = device->getSubDevice(1); auto subDevice = device->getSubDevice(1);
auto baseDeviceApiRefCount = device->getRefApiCount(); auto baseDeviceApiRefCount = device->getRefApiCount();
auto baseDeviceInternalRefCount = device->getRefInternalCount(); auto baseDeviceInternalRefCount = device->getRefInternalCount();
auto baseSubDeviceApiRefCount = subDevice->getRefApiCount(); auto baseSubDeviceApiRefCount = subDevice->getRefApiCount();
auto baseSubDeviceInternalRefCount = subDevice->getRefInternalCount(); auto baseSubDeviceInternalRefCount = subDevice->getRefInternalCount();
auto baseDefaultDeviceApiRefCount = defaultDevice->getRefApiCount(); auto baseDefaultDeviceApiRefCount = defaultDevice->getRefApiCount();
auto baseDefaultDeviceInternalRefCount = defaultDevice->getRefInternalCount(); auto baseDefaultDeviceInternalRefCount = defaultDevice->getRefInternalCount();
subDevice->retainApi(); subDevice->retainApi();
EXPECT_EQ(baseDeviceApiRefCount, device->getRefApiCount()); EXPECT_EQ(baseDeviceApiRefCount, device->getRefApiCount());
EXPECT_EQ(baseDeviceInternalRefCount, device->getRefInternalCount()); EXPECT_EQ(baseDeviceInternalRefCount, device->getRefInternalCount());
EXPECT_EQ(baseSubDeviceApiRefCount, subDevice->getRefApiCount()); EXPECT_EQ(baseSubDeviceApiRefCount, subDevice->getRefApiCount());
EXPECT_EQ(baseSubDeviceInternalRefCount, subDevice->getRefInternalCount()); EXPECT_EQ(baseSubDeviceInternalRefCount, subDevice->getRefInternalCount());
EXPECT_EQ(baseDefaultDeviceApiRefCount, defaultDevice->getRefApiCount()); EXPECT_EQ(baseDefaultDeviceApiRefCount, defaultDevice->getRefApiCount());
EXPECT_EQ(baseDefaultDeviceInternalRefCount, defaultDevice->getRefInternalCount()); EXPECT_EQ(baseDefaultDeviceInternalRefCount, defaultDevice->getRefInternalCount());
subDevice->releaseApi(); subDevice->releaseApi();
EXPECT_EQ(baseDeviceApiRefCount, device->getRefApiCount()); EXPECT_EQ(baseDeviceApiRefCount, device->getRefApiCount());
EXPECT_EQ(baseDeviceInternalRefCount, device->getRefInternalCount()); EXPECT_EQ(baseDeviceInternalRefCount, device->getRefInternalCount());
EXPECT_EQ(baseSubDeviceApiRefCount, subDevice->getRefApiCount()); EXPECT_EQ(baseSubDeviceApiRefCount, subDevice->getRefApiCount());
EXPECT_EQ(baseSubDeviceInternalRefCount, subDevice->getRefInternalCount()); EXPECT_EQ(baseSubDeviceInternalRefCount, subDevice->getRefInternalCount());
EXPECT_EQ(baseDefaultDeviceApiRefCount, defaultDevice->getRefApiCount()); EXPECT_EQ(baseDefaultDeviceApiRefCount, defaultDevice->getRefApiCount());
EXPECT_EQ(baseDefaultDeviceInternalRefCount, defaultDevice->getRefInternalCount()); EXPECT_EQ(baseDefaultDeviceInternalRefCount, defaultDevice->getRefInternalCount());
}
} }
TEST(SubDevicesTest, givenDeviceWithSubDevicesWhenSubDeviceInternalRefCountsAreChangedThenChangeIsPropagatedToRootDevice) { TEST(SubDevicesTest, givenDeviceWithSubDevicesWhenSubDeviceInternalRefCountsAreChangedThenChangeIsPropagatedToRootDevice) {
@ -176,7 +179,6 @@ TEST(SubDevicesTest, givenClDeviceWithSubDevicesWhenSubDeviceInternalRefCountsAr
debugManager.flags.CreateMultipleSubDevices.set(2); debugManager.flags.CreateMultipleSubDevices.set(2);
VariableBackup<bool> mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); VariableBackup<bool> mockDeviceFlagBackup(&MockDevice::createSingleDevice, false);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get())); auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
device->getExecutionEnvironment()->setExposeSubDevicesAsDevices(false);
device->incRefInternal(); device->incRefInternal();
auto &subDevice = device->subDevices[0]; auto &subDevice = device->subDevices[0];

2
shared/source/device/device.cpp
View File

@ -93,7 +93,7 @@ bool Device::genericSubDevicesAllowed() {
deviceBitfield = maxNBitValue(subDeviceCount); deviceBitfield = maxNBitValue(subDeviceCount);
deviceBitfield &= deviceMask; deviceBitfield &= deviceMask;
numSubDevices = static_cast<uint32_t>(deviceBitfield.count()); numSubDevices = static_cast<uint32_t>(deviceBitfield.count());
if (numSubDevices == 1 && (!executionEnvironment->isCombinedDeviceHierarchy() || subDeviceCount == 1)) { if (numSubDevices == 1 && (executionEnvironment->getDeviceHierarchyMode() != COMBINED || subDeviceCount == 1)) {
numSubDevices = 0; numSubDevices = 0;
} }

26
shared/source/execution_environment/execution_environment.cpp
View File

@ -220,7 +220,7 @@ void ExecutionEnvironment::parseAffinityMask() {
} }
// If the user has requested FLAT or COMBINED device hierarchy models, then report all the sub devices as devices. // If the user has requested FLAT or COMBINED device hierarchy models, then report all the sub devices as devices.
bool exposeSubDevicesAsApiDevices = isExposingSubDevicesAsDevices(); bool exposeSubDevices = this->deviceHierarchyMode != COMPOSITE;
// Reserve at least for a size equal to rootDeviceEnvironments.size() times four, // Reserve at least for a size equal to rootDeviceEnvironments.size() times four,
// which is enough for typical configurations // which is enough for typical configurations
@ -231,7 +231,7 @@ void ExecutionEnvironment::parseAffinityMask() {
mapOfIndices.reserve(reservedSizeForIndices); mapOfIndices.reserve(reservedSizeForIndices);
uint32_t hwSubDevicesCount = 0u; uint32_t hwSubDevicesCount = 0u;
if (exposeSubDevicesAsApiDevices) { if (exposeSubDevices) {
for (uint32_t currentRootDevice = 0u; currentRootDevice < numRootDevices; currentRootDevice++) { for (uint32_t currentRootDevice = 0u; currentRootDevice < numRootDevices; currentRootDevice++) {
auto hwInfo = rootDeviceEnvironments[currentRootDevice]->getHardwareInfo(); auto hwInfo = rootDeviceEnvironments[currentRootDevice]->getHardwareInfo();
@ -258,7 +258,7 @@ void ExecutionEnvironment::parseAffinityMask() {
if (entryIndex >= numDevices) { if (entryIndex >= numDevices) {
continue; continue;
} else if (exposeSubDevicesAsApiDevices) { } else if (exposeSubDevices) {
// tiles as devices // tiles as devices
// so ignore X.Y // so ignore X.Y
if (subEntries.size() > 1) { if (subEntries.size() > 1) {
@ -312,17 +312,17 @@ void ExecutionEnvironment::sortNeoDevices() {
std::sort(rootDeviceEnvironments.begin(), rootDeviceEnvironments.end(), comparePciIdBusNumber); std::sort(rootDeviceEnvironments.begin(), rootDeviceEnvironments.end(), comparePciIdBusNumber);
} }
void ExecutionEnvironment::setDeviceHierarchy(const GfxCoreHelper &gfxCoreHelper) { void ExecutionEnvironment::setDeviceHierarchyMode(const GfxCoreHelper &gfxCoreHelper) {
NEO::EnvironmentVariableReader envReader; NEO::EnvironmentVariableReader envReader;
std::string hierarchyModel = envReader.getSetting("ZE_FLAT_DEVICE_HIERARCHY", std::string(gfxCoreHelper.getDefaultDeviceHierarchy())); std::string deviceHierarchyMode = envReader.getSetting("ZE_FLAT_DEVICE_HIERARCHY", std::string(""));
if (strcmp(hierarchyModel.c_str(), "COMPOSITE") == 0) { if (strcmp(deviceHierarchyMode.c_str(), "COMPOSITE") == 0) {
setExposeSubDevicesAsDevices(false); this->deviceHierarchyMode = COMPOSITE;
} } else if (strcmp(deviceHierarchyMode.c_str(), "FLAT") == 0) {
if (strcmp(hierarchyModel.c_str(), "FLAT") == 0) { this->deviceHierarchyMode = FLAT;
setExposeSubDevicesAsDevices(true); } else if (strcmp(deviceHierarchyMode.c_str(), "COMBINED") == 0) {
} this->deviceHierarchyMode = COMBINED;
if (strcmp(hierarchyModel.c_str(), "COMBINED") == 0) { } else {
setCombinedDeviceHierarchy(true); this->deviceHierarchyMode = gfxCoreHelper.getDefaultDeviceHierarchy();
} }
} }

19
shared/source/execution_environment/execution_environment.h
View File

@ -7,6 +7,7 @@
#pragma once #pragma once
#include "shared/source/debugger/debugger.h" #include "shared/source/debugger/debugger.h"
#include "shared/source/helpers/device_hierarchy_mode.h"
#include "shared/source/utilities/reference_tracked_object.h" #include "shared/source/utilities/reference_tracked_object.h"
#include <mutex> #include <mutex>
@ -38,7 +39,11 @@ class ExecutionEnvironment : public ReferenceTrackedObject<ExecutionEnvironment>
void adjustCcsCount(); void adjustCcsCount();
void adjustCcsCount(const uint32_t rootDeviceIndex) const; void adjustCcsCount(const uint32_t rootDeviceIndex) const;
void sortNeoDevices(); void sortNeoDevices();
void setDeviceHierarchy(const GfxCoreHelper &gfxCoreHelper); void setDeviceHierarchyMode(const GfxCoreHelper &gfxCoreHelper);
void setDeviceHierarchyMode(const DeviceHierarchyMode deviceHierarchyMode) {
this->deviceHierarchyMode = deviceHierarchyMode;
}
DeviceHierarchyMode getDeviceHierarchyMode() const { return deviceHierarchyMode; }
void adjustRootDeviceEnvironments(); void adjustRootDeviceEnvironments();
void prepareForCleanup() const; void prepareForCleanup() const;
void configureCcsMode(); void configureCcsMode();
@ -50,15 +55,6 @@ class ExecutionEnvironment : public ReferenceTrackedObject<ExecutionEnvironment>
void setMetricsEnabled(bool value) { void setMetricsEnabled(bool value) {
this->metricsEnabled = value; this->metricsEnabled = value;
} }
void setExposeSubDevicesAsDevices(bool value) {
this->subDevicesAsDevices = value;
}
void setCombinedDeviceHierarchy(bool value) {
this->subDevicesAsDevices = value;
this->combinedDeviceHierarchy = value;
}
bool isExposingSubDevicesAsDevices() const { return this->subDevicesAsDevices; }
bool isCombinedDeviceHierarchy() const { return this->combinedDeviceHierarchy; }
void getErrorDescription(const char **ppString); void getErrorDescription(const char **ppString);
bool getSubDeviceHierarchy(uint32_t index, std::tuple<uint32_t, uint32_t, uint32_t> *subDeviceMap); bool getSubDeviceHierarchy(uint32_t index, std::tuple<uint32_t, uint32_t, uint32_t> *subDeviceMap);
bool areMetricsEnabled() { return this->metricsEnabled; } bool areMetricsEnabled() { return this->metricsEnabled; }
@ -90,9 +86,8 @@ class ExecutionEnvironment : public ReferenceTrackedObject<ExecutionEnvironment>
void restoreCcsMode(); void restoreCcsMode();
bool metricsEnabled = false; bool metricsEnabled = false;
bool fp64EmulationEnabled = false; bool fp64EmulationEnabled = false;
bool subDevicesAsDevices = false;
bool combinedDeviceHierarchy = false;
DeviceHierarchyMode deviceHierarchyMode = COMPOSITE;
DebuggingMode debuggingEnabledMode = DebuggingMode::disabled; DebuggingMode debuggingEnabledMode = DebuggingMode::disabled;
std::unordered_map<uint32_t, uint32_t> rootDeviceNumCcsMap; std::unordered_map<uint32_t, uint32_t> rootDeviceNumCcsMap;
std::mutex initializeDirectSubmissionControllerMutex; std::mutex initializeDirectSubmissionControllerMutex;

1
shared/source/helpers/CMakeLists.txt
View File

@ -58,6 +58,7 @@ set(NEO_CORE_HELPERS
${CMAKE_CURRENT_SOURCE_DIR}/debug_helpers.h ${CMAKE_CURRENT_SOURCE_DIR}/debug_helpers.h
${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter_helper.h ${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/device_bitfield.h ${CMAKE_CURRENT_SOURCE_DIR}/device_bitfield.h
${CMAKE_CURRENT_SOURCE_DIR}/device_hierarchy_mode.h
${CMAKE_CURRENT_SOURCE_DIR}/driver_model_type.h ${CMAKE_CURRENT_SOURCE_DIR}/driver_model_type.h
${CMAKE_CURRENT_SOURCE_DIR}/dirty_state_helpers.cpp ${CMAKE_CURRENT_SOURCE_DIR}/dirty_state_helpers.cpp
${CMAKE_CURRENT_SOURCE_DIR}/dirty_state_helpers.h ${CMAKE_CURRENT_SOURCE_DIR}/dirty_state_helpers.h

16
shared/source/helpers/device_hierarchy_mode.h Normal file
View File

@ -0,0 +1,16 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
namespace NEO {
enum DeviceHierarchyMode {
COMPOSITE,
FLAT,
COMBINED
};
};

7
shared/source/helpers/gfx_core_helper.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2024 Intel Corporation * Copyright (C) 2018-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -18,11 +18,6 @@ namespace NEO {
GfxCoreHelperCreateFunctionType gfxCoreHelperFactory[IGFX_MAX_CORE] = {}; GfxCoreHelperCreateFunctionType gfxCoreHelperFactory[IGFX_MAX_CORE] = {};
const char *deviceHierarchyComposite = "COMPOSITE";
const char *deviceHierarchyFlat = "FLAT";
const char *deviceHierarchyCombined = "COMBINED";
const char *deviceHierarchyUnk = "UNK";
std::unique_ptr<GfxCoreHelper> GfxCoreHelper::create(const GFXCORE_FAMILY gfxCoreFamily) { std::unique_ptr<GfxCoreHelper> GfxCoreHelper::create(const GFXCORE_FAMILY gfxCoreFamily) {
auto createFunction = gfxCoreHelperFactory[gfxCoreFamily]; auto createFunction = gfxCoreHelperFactory[gfxCoreFamily];

12
shared/source/helpers/gfx_core_helper.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2024 Intel Corporation * Copyright (C) 2018-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -8,6 +8,7 @@
#pragma once #pragma once
#include "shared/source/built_ins/sip_kernel_type.h" #include "shared/source/built_ins/sip_kernel_type.h"
#include "shared/source/helpers/definitions/engine_group_types.h" #include "shared/source/helpers/definitions/engine_group_types.h"
#include "shared/source/helpers/device_hierarchy_mode.h"
#include "shared/source/helpers/engine_node_helper.h" #include "shared/source/helpers/engine_node_helper.h"
#include "shared/source/helpers/options.h" #include "shared/source/helpers/options.h"
#include "shared/source/utilities/stackvec.h" #include "shared/source/utilities/stackvec.h"
@ -49,11 +50,6 @@ class AILConfiguration;
using EngineInstancesContainer = StackVec<EngineTypeUsage, 32>; using EngineInstancesContainer = StackVec<EngineTypeUsage, 32>;
using GfxCoreHelperCreateFunctionType = std::unique_ptr<GfxCoreHelper> (*)(); using GfxCoreHelperCreateFunctionType = std::unique_ptr<GfxCoreHelper> (*)();
extern const char *deviceHierarchyComposite;
extern const char *deviceHierarchyFlat;
extern const char *deviceHierarchyCombined;
extern const char *deviceHierarchyUnk;
class GfxCoreHelper { class GfxCoreHelper {
public: public:
static std::unique_ptr<GfxCoreHelper> create(const GFXCORE_FAMILY gfxCoreFamily); static std::unique_ptr<GfxCoreHelper> create(const GFXCORE_FAMILY gfxCoreFamily);
@ -171,7 +167,7 @@ class GfxCoreHelper {
virtual bool isRelaxedOrderingSupported() const = 0; virtual bool isRelaxedOrderingSupported() const = 0;
virtual uint32_t calculateNumThreadsPerThreadGroup(uint32_t simd, uint32_t totalWorkItems, uint32_t grfCount, bool isHwLocalIdGeneration, const RootDeviceEnvironment &rootDeviceEnvironment) const = 0; virtual uint32_t calculateNumThreadsPerThreadGroup(uint32_t simd, uint32_t totalWorkItems, uint32_t grfCount, bool isHwLocalIdGeneration, const RootDeviceEnvironment &rootDeviceEnvironment) const = 0;
virtual uint32_t overrideMaxWorkGroupSize(uint32_t maxWG) const = 0; virtual uint32_t overrideMaxWorkGroupSize(uint32_t maxWG) const = 0;
virtual char const *getDefaultDeviceHierarchy() const = 0; virtual DeviceHierarchyMode getDefaultDeviceHierarchy() const = 0;
static bool isWorkaroundRequired(uint32_t lowestSteppingWithBug, uint32_t steppingWithFix, const HardwareInfo &hwInfo, const ProductHelper &productHelper); static bool isWorkaroundRequired(uint32_t lowestSteppingWithBug, uint32_t steppingWithFix, const HardwareInfo &hwInfo, const ProductHelper &productHelper);
virtual bool areSecondaryContextsSupported() const = 0; virtual bool areSecondaryContextsSupported() const = 0;
@ -408,7 +404,7 @@ class GfxCoreHelperHw : public GfxCoreHelper {
bool isRelaxedOrderingSupported() const override; bool isRelaxedOrderingSupported() const override;
uint32_t calculateNumThreadsPerThreadGroup(uint32_t simd, uint32_t totalWorkItems, uint32_t grfCount, bool isHwLocalIdGeneration, const RootDeviceEnvironment &rootDeviceEnvironment) const override; uint32_t calculateNumThreadsPerThreadGroup(uint32_t simd, uint32_t totalWorkItems, uint32_t grfCount, bool isHwLocalIdGeneration, const RootDeviceEnvironment &rootDeviceEnvironment) const override;
uint32_t overrideMaxWorkGroupSize(uint32_t maxWG) const override; uint32_t overrideMaxWorkGroupSize(uint32_t maxWG) const override;
char const *getDefaultDeviceHierarchy() const override; DeviceHierarchyMode getDefaultDeviceHierarchy() const override;
bool areSecondaryContextsSupported() const override; bool areSecondaryContextsSupported() const override;
uint32_t getContextGroupContextsCount() const override; uint32_t getContextGroupContextsCount() const override;

6
shared/source/helpers/gfx_core_helper_base.inl
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2019-2024 Intel Corporation * Copyright (C) 2019-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -681,8 +681,8 @@ uint32_t GfxCoreHelperHw<GfxFamily>::calculateNumThreadsPerThreadGroup(uint32_t
} }
template <typename GfxFamily> template <typename GfxFamily>
char const *GfxCoreHelperHw<GfxFamily>::getDefaultDeviceHierarchy() const { DeviceHierarchyMode GfxCoreHelperHw<GfxFamily>::getDefaultDeviceHierarchy() const {
return deviceHierarchyComposite; return COMPOSITE;
} }
template <typename GfxFamily> template <typename GfxFamily>

6
shared/source/os_interface/device_factory.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2024 Intel Corporation * Copyright (C) 2018-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -137,7 +137,7 @@ bool DeviceFactory::prepareDeviceEnvironmentsForProductFamilyOverride(ExecutionE
} }
} }
executionEnvironment.setDeviceHierarchy(executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>()); executionEnvironment.setDeviceHierarchyMode(executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
executionEnvironment.parseAffinityMask(); executionEnvironment.parseAffinityMask();
executionEnvironment.adjustCcsCount(); executionEnvironment.adjustCcsCount();
executionEnvironment.calculateMaxOsContextCount(); executionEnvironment.calculateMaxOsContextCount();
@ -214,7 +214,7 @@ bool DeviceFactory::prepareDeviceEnvironments(ExecutionEnvironment &executionEnv
return false; return false;
} }
executionEnvironment.setDeviceHierarchy(executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>()); executionEnvironment.setDeviceHierarchyMode(executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
executionEnvironment.sortNeoDevices(); executionEnvironment.sortNeoDevices();
executionEnvironment.parseAffinityMask(); executionEnvironment.parseAffinityMask();
executionEnvironment.adjustRootDeviceEnvironments(); executionEnvironment.adjustRootDeviceEnvironments();

4
shared/source/xe_hpc_core/gfx_core_helper_xe_hpc_core.cpp
View File

@ -299,8 +299,8 @@ bool GfxCoreHelperHw<Family>::isRelaxedOrderingSupported() const {
} }
template <> template <>
char const *GfxCoreHelperHw<Family>::getDefaultDeviceHierarchy() const { DeviceHierarchyMode GfxCoreHelperHw<Family>::getDefaultDeviceHierarchy() const {
return deviceHierarchyFlat; return FLAT;
} }
} // namespace NEO } // namespace NEO

6
shared/test/common/mocks/mock_device.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2024 Intel Corporation * Copyright (C) 2018-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -121,7 +121,7 @@ ExecutionEnvironment *MockDevice::prepareExecutionEnvironment(const HardwareInfo
UnitTestSetter::setCcsExposure(*executionEnvironment->rootDeviceEnvironments[i]); UnitTestSetter::setCcsExposure(*executionEnvironment->rootDeviceEnvironments[i]);
executionEnvironment->rootDeviceEnvironments[i]->initGmm(); executionEnvironment->rootDeviceEnvironments[i]->initGmm();
} }
executionEnvironment->setDeviceHierarchy(executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>()); executionEnvironment->setDeviceHierarchyMode(executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
executionEnvironment->calculateMaxOsContextCount(); executionEnvironment->calculateMaxOsContextCount();
return executionEnvironment; return executionEnvironment;
} }
@ -160,7 +160,7 @@ ExecutionEnvironment *MockDevice::prepareExecutionEnvironment(const HardwareInfo
UnitTestSetter::setRcsExposure(*executionEnvironment->rootDeviceEnvironments[0]); UnitTestSetter::setRcsExposure(*executionEnvironment->rootDeviceEnvironments[0]);
UnitTestSetter::setCcsExposure(*executionEnvironment->rootDeviceEnvironments[0]); UnitTestSetter::setCcsExposure(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->setDeviceHierarchy(executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>()); executionEnvironment->setDeviceHierarchyMode(executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
MockAubCenterFixture::setMockAubCenter(*executionEnvironment->rootDeviceEnvironments[0]); MockAubCenterFixture::setMockAubCenter(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();

2
shared/test/unit_test/device/neo_device_tests.cpp
View File

@ -171,7 +171,7 @@ TEST(Device, WhenCreatingDeviceThenCapsInitilizedBeforeEnginesAreCreated) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfoAndInitHelpers(&hwInfo); executionEnvironment->rootDeviceEnvironments[i]->setHwInfoAndInitHelpers(&hwInfo);
executionEnvironment->rootDeviceEnvironments[i]->initGmm(); executionEnvironment->rootDeviceEnvironments[i]->initGmm();
} }
executionEnvironment->setDeviceHierarchy(executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>()); executionEnvironment->setDeviceHierarchyMode(executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
executionEnvironment->calculateMaxOsContextCount(); executionEnvironment->calculateMaxOsContextCount();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();

94
shared/test/unit_test/execution_environment/execution_environment_tests.cpp
View File

@ -361,19 +361,21 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerI
executionEnvironment.initializeMemoryManager(); executionEnvironment.initializeMemoryManager();
EXPECT_NE(nullptr, executionEnvironment.memoryManager); EXPECT_NE(nullptr, executionEnvironment.memoryManager);
} }
static_assert(sizeof(ExecutionEnvironment) == sizeof(std::unique_ptr<HardwareInfo>) +
sizeof(std::vector<RootDeviceEnvironment>) + static_assert(sizeof(ExecutionEnvironment) == sizeof(std::unique_ptr<MemoryManager>) +
sizeof(std::unique_ptr<OsEnvironment>) +
sizeof(std::unique_ptr<DirectSubmissionController>) + sizeof(std::unique_ptr<DirectSubmissionController>) +
sizeof(std::unordered_map<uint32_t, uint32_t>) + sizeof(std::unique_ptr<OsEnvironment>) +
2 * sizeof(bool) + sizeof(std::vector<std::unique_ptr<RootDeviceEnvironment>>) +
sizeof(NEO::DebuggingMode) +
(is64bit ? 18 : 14) +
sizeof(std::mutex) +
sizeof(std::unordered_map<uint32_t, std::tuple<uint32_t, uint32_t, uint32_t>>) + sizeof(std::unordered_map<uint32_t, std::tuple<uint32_t, uint32_t, uint32_t>>) +
sizeof(std::vector<std::tuple<std::string, uint32_t>>) +
sizeof(std::unordered_map<std::thread::id, std::string>) + sizeof(std::unordered_map<std::thread::id, std::string>) +
sizeof(std::mutex), sizeof(std::mutex) +
2 * sizeof(bool) +
sizeof(DeviceHierarchyMode) +
sizeof(DebuggingMode) +
sizeof(std::unordered_map<uint32_t, uint32_t>) +
sizeof(std::mutex) +
sizeof(std::vector<std::tuple<std::string, uint32_t>>) +
(is64bit ? 22 : 14),
"New members detected in ExecutionEnvironment, please ensure that destruction sequence of objects is correct"); "New members detected in ExecutionEnvironment, please ensure that destruction sequence of objects is correct");
TEST(ExecutionEnvironment, givenExecutionEnvironmentWithVariousMembersWhenItIsDestroyedThenDeleteSequenceIsSpecified) { TEST(ExecutionEnvironment, givenExecutionEnvironmentWithVariousMembersWhenItIsDestroyedThenDeleteSequenceIsSpecified) {
@ -547,7 +549,7 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenSettingFP64EmulationEnab
EXPECT_TRUE(executionEnvironment.isFP64EmulationEnabled()); EXPECT_TRUE(executionEnvironment.isFP64EmulationEnabled());
} }
TEST(ExecutionEnvironment, givenCorrectZeAffinityMaskWhenExposeSubDevicesAsApiDevicesIsSetThenMapOfSubDeviceIndicesIsSet) { TEST(ExecutionEnvironment, givenCorrectZeAffinityMaskWithFlatOrCombinedHierarchyThenMapOfSubDeviceIndicesIsSet) {
DebugManagerStateRestore restore; DebugManagerStateRestore restore;
debugManager.flags.CreateMultipleSubDevices.set(4); debugManager.flags.CreateMultipleSubDevices.set(4);
@ -555,16 +557,20 @@ TEST(ExecutionEnvironment, givenCorrectZeAffinityMaskWhenExposeSubDevicesAsApiDe
debugManager.flags.SetCommandStreamReceiver.set(1); debugManager.flags.SetCommandStreamReceiver.set(1);
auto hwInfo = *defaultHwInfo; auto hwInfo = *defaultHwInfo;
MockExecutionEnvironment executionEnvironment(&hwInfo);
executionEnvironment.incRefInternal();
executionEnvironment.setExposeSubDevicesAsDevices(true);
DeviceFactory::createDevices(executionEnvironment); DeviceHierarchyMode deviceHierarchyModes[] = {FLAT, COMBINED};
for (auto deviceHierarchyMode : deviceHierarchyModes) {
MockExecutionEnvironment executionEnvironment(&hwInfo);
executionEnvironment.incRefInternal();
executionEnvironment.setDeviceHierarchyMode(deviceHierarchyMode);
EXPECT_FALSE(executionEnvironment.mapOfSubDeviceIndices.empty()); DeviceFactory::createDevices(executionEnvironment);
EXPECT_FALSE(executionEnvironment.mapOfSubDeviceIndices.empty());
}
} }
TEST(ExecutionEnvironment, givenIncorrectZeAffinityMaskWhenExposeSubDevicesAsApiDevicesIsSetThenMapOfSubDeviceIndicesIsEmpty) { TEST(ExecutionEnvironment, givenIncorrectZeAffinityMaskWithFlatOrCombinedHierarchyThenMapOfSubDeviceIndicesIsEmpty) {
DebugManagerStateRestore restore; DebugManagerStateRestore restore;
debugManager.flags.CreateMultipleSubDevices.set(4); debugManager.flags.CreateMultipleSubDevices.set(4);
@ -572,13 +578,17 @@ TEST(ExecutionEnvironment, givenIncorrectZeAffinityMaskWhenExposeSubDevicesAsApi
debugManager.flags.SetCommandStreamReceiver.set(1); debugManager.flags.SetCommandStreamReceiver.set(1);
auto hwInfo = *defaultHwInfo; auto hwInfo = *defaultHwInfo;
MockExecutionEnvironment executionEnvironment(&hwInfo);
executionEnvironment.incRefInternal();
executionEnvironment.setExposeSubDevicesAsDevices(true);
DeviceFactory::createDevices(executionEnvironment); DeviceHierarchyMode deviceHierarchyModes[] = {FLAT, COMBINED};
for (auto deviceHierarchyMode : deviceHierarchyModes) {
MockExecutionEnvironment executionEnvironment(&hwInfo);
executionEnvironment.incRefInternal();
executionEnvironment.setDeviceHierarchyMode(deviceHierarchyMode);
EXPECT_TRUE(executionEnvironment.mapOfSubDeviceIndices.empty()); DeviceFactory::createDevices(executionEnvironment);
EXPECT_TRUE(executionEnvironment.mapOfSubDeviceIndices.empty());
}
} }
TEST(ExecutionEnvironment, givenBuiltinsSetWhenRootDeviceEnvironmentIsReleasedThenBuiltinsIsReset) { TEST(ExecutionEnvironment, givenBuiltinsSetWhenRootDeviceEnvironmentIsReleasedThenBuiltinsIsReset) {
@ -627,46 +637,6 @@ TEST(ExecutionEnvironmentWithAILTests, whenAILConfigurationFailsOnInitProcessExe
EXPECT_FALSE(rootDeviceEnvironment->initAilConfiguration()); EXPECT_FALSE(rootDeviceEnvironment->initAilConfiguration());
} }
TEST(ExecutionEnvironmentDeviceHierarchy, givenExecutionEnvironmentWithDefaultDeviceHierarchyThenExecutionEnvironmentIsInitializedCorrectly) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
MockExecutionEnvironment executionEnvironment;
executionEnvironment.rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(defaultHwInfo.get());
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
executionEnvironment.setDeviceHierarchy(gfxCoreHelper);
EXPECT_EQ((strcmp(gfxCoreHelper.getDefaultDeviceHierarchy(), "COMPOSITE") != 0),
executionEnvironment.isExposingSubDevicesAsDevices());
}
TEST(ExecutionEnvironmentDeviceHierarchy, givenExecutionEnvironmentWithCompositeDeviceHierarchyThenExposeSubDevicesAsDevicesIsFalse) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "COMPOSITE"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
MockExecutionEnvironment executionEnvironment;
executionEnvironment.rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(defaultHwInfo.get());
executionEnvironment.setDeviceHierarchy(executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
EXPECT_FALSE(executionEnvironment.isExposingSubDevicesAsDevices());
}
TEST(ExecutionEnvironmentDeviceHierarchy, givenExecutionEnvironmentWithFlatDeviceHierarchyThenExposeSubDevicesAsDevicesIsTrue) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "FLAT"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
MockExecutionEnvironment executionEnvironment;
executionEnvironment.rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(defaultHwInfo.get());
executionEnvironment.setDeviceHierarchy(executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
EXPECT_TRUE(executionEnvironment.isExposingSubDevicesAsDevices());
}
TEST(ExecutionEnvironmentDeviceHierarchy, givenExecutionEnvironmentWithCombinedDeviceHierarchyThenExposeSubDevicesAsDevicesIsTrue) {
VariableBackup<uint32_t> mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0);
std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "COMBINED"}};
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
MockExecutionEnvironment executionEnvironment;
executionEnvironment.rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(defaultHwInfo.get());
executionEnvironment.setDeviceHierarchy(executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>());
EXPECT_TRUE(executionEnvironment.isExposingSubDevicesAsDevices());
}
TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenSetErrorDescriptionIsCalledThenGetErrorDescriptionGetsStringCorrectly) { TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenSetErrorDescriptionIsCalledThenGetErrorDescriptionGetsStringCorrectly) {
std::string errorString = "we manually created error"; std::string errorString = "we manually created error";
std::string errorString2 = "here's the next string to pass with arguments: "; std::string errorString2 = "here's the next string to pass with arguments: ";

6
shared/test/unit_test/helpers/gfx_core_helper_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2022-2024 Intel Corporation * Copyright (C) 2022-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -1693,10 +1693,10 @@ HWTEST_F(GfxCoreHelperTest, givenFlagRemoveRestrictionsOnNumberOfThreadsInGpgpuT
} }
} }
HWTEST2_F(GfxCoreHelperTest, whenGetDefaultDeviceHierarchyThenReturnFlatHierarchy, IsNotXeHpcCore) { HWTEST2_F(GfxCoreHelperTest, whenGetDefaultDeviceHierarchyThenReturnCompositeHierarchy, IsNotXeHpcCore) {
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>(); const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto defaultDeviceHierarchy = gfxCoreHelper.getDefaultDeviceHierarchy(); auto defaultDeviceHierarchy = gfxCoreHelper.getDefaultDeviceHierarchy();
EXPECT_STREQ("COMPOSITE", defaultDeviceHierarchy); EXPECT_EQ(COMPOSITE, defaultDeviceHierarchy);
} }
HWTEST_F(GfxCoreHelperTest, givenContextGroupDisabledWhenContextGroupContextsCountAndSecondaryContextsSupportQueriedThenZeroCountAndFalseIsReturned) { HWTEST_F(GfxCoreHelperTest, givenContextGroupDisabledWhenContextGroupContextsCountAndSecondaryContextsSupportQueriedThenZeroCountAndFalseIsReturned) {

4
shared/test/unit_test/xe_hpc_core/gfx_core_helper_xe_hpc_core_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021-2024 Intel Corporation * Copyright (C) 2021-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -113,5 +113,5 @@ XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, whenGetDefaultDeviceHierarchyThenR
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>(); auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto defaultDeviceHierarchy = gfxCoreHelper.getDefaultDeviceHierarchy(); auto defaultDeviceHierarchy = gfxCoreHelper.getDefaultDeviceHierarchy();
EXPECT_STREQ("FLAT", defaultDeviceHierarchy); EXPECT_EQ(FLAT, defaultDeviceHierarchy);
} }