fix: expose tiles as devices in OCL with combined hierarchy

Related-To: GSD-8708
Signed-off-by: Jaroslaw Warchulski <jaroslaw.warchulski@intel.com>

opencl/source/api/api.cpp

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

opencl/source/cl_device/cl_device.cpp

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

opencl/test/unit_test/api/cl_get_device_ids_tests.inl

@@ -1,10 +1,11 @@
 /*
- * Copyright (C) 2018-2023 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
+#include "shared/source/device/device.h"
 #include "shared/source/os_interface/device_factory.h"
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
 #include "shared/test/common/helpers/ult_hw_config.h"
@@ -12,7 +13,9 @@
 #include "shared/test/common/mocks/mock_io_functions.h"
 #include "shared/test/common/test_macros/test.h"
 
+#include "opencl/source/cl_device/cl_device.h"
 #include "opencl/test/unit_test/fixtures/platform_fixture.h"
+#include "opencl/test/unit_test/mocks/mock_platform.h"
 
 using namespace NEO;
 
@@ -20,7 +23,7 @@ using clGetDeviceIDsTests = Test<PlatformFixture>;
 
 namespace ULT {
 
-TEST_F(clGetDeviceIDsTests, GivenZeroNumEntriesWhenGettingDeviceIdsThenNumberOfDevicesIsGreaterThanZero) {
+TEST_F(clGetDeviceIDsTests, givenZeroNumEntriesWhenGettingDeviceIdsThenNumberOfDevicesIsGreaterThanZero) {
     cl_uint numDevices = 0;
 
     auto retVal = clGetDeviceIDs(pPlatform, CL_DEVICE_TYPE_GPU, 0, nullptr, &numDevices);
@@ -29,7 +32,7 @@ TEST_F(clGetDeviceIDsTests, GivenZeroNumEntriesWhenGettingDeviceIdsThenNumberOfD
     EXPECT_GT(numDevices, (cl_uint)0);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenNonNullDevicesWhenGettingDeviceIdsThenDeviceIdIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenNonNullDevicesWhenGettingDeviceIdsThenDeviceIdIsReturned) {
     cl_uint numEntries = 1;
     cl_device_id pDevices[1];
 
@@ -37,7 +40,7 @@ TEST_F(clGetDeviceIDsTests, GivenNonNullDevicesWhenGettingDeviceIdsThenDeviceIdI
     EXPECT_EQ(CL_SUCCESS, retVal);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenNullPlatformWhenGettingDeviceIdsThenDeviceIdIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenNullPlatformWhenGettingDeviceIdsThenDeviceIdIsReturned) {
     cl_uint numEntries = 1;
     cl_device_id pDevices[1];
 
@@ -45,7 +48,7 @@ TEST_F(clGetDeviceIDsTests, GivenNullPlatformWhenGettingDeviceIdsThenDeviceIdIsR
     EXPECT_EQ(CL_SUCCESS, retVal);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenInvalidDeviceTypeWhenGettingDeviceIdsThenInvalidDeviceTypeErrorIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenInvalidDeviceTypeWhenGettingDeviceIdsThenInvalidDeviceTypeErrorIsReturned) {
     cl_uint numEntries = 1;
     cl_device_id pDevices[1];
 
@@ -53,14 +56,14 @@ TEST_F(clGetDeviceIDsTests, GivenInvalidDeviceTypeWhenGettingDeviceIdsThenInvali
     EXPECT_EQ(CL_INVALID_DEVICE_TYPE, retVal);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenZeroNumEntriesAndNonNullDevicesWhenGettingDeviceIdsThenInvalidValueErrorIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenZeroNumEntriesAndNonNullDevicesWhenGettingDeviceIdsThenInvalidValueErrorIsReturned) {
     cl_device_id pDevices[1];
 
     auto retVal = clGetDeviceIDs(pPlatform, CL_DEVICE_TYPE_GPU, 0, pDevices, nullptr);
     EXPECT_EQ(CL_INVALID_VALUE, retVal);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenInvalidPlatformWhenGettingDeviceIdsThenInvalidPlatformErrorIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenInvalidPlatformWhenGettingDeviceIdsThenInvalidPlatformErrorIsReturned) {
     cl_uint numEntries = 1;
     cl_device_id pDevices[1];
     uint32_t trash[6] = {0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef};
@@ -70,7 +73,7 @@ TEST_F(clGetDeviceIDsTests, GivenInvalidPlatformWhenGettingDeviceIdsThenInvalidP
     EXPECT_EQ(CL_INVALID_PLATFORM, retVal);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenDeviceTypeAllWhenGettingDeviceIdsThenDeviceIdIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenDeviceTypeAllWhenGettingDeviceIdsThenDeviceIdIsReturned) {
     cl_uint numDevices = 0;
     cl_uint numEntries = 1;
     cl_device_id pDevices[1];
@@ -80,7 +83,7 @@ TEST_F(clGetDeviceIDsTests, GivenDeviceTypeAllWhenGettingDeviceIdsThenDeviceIdIs
     EXPECT_GT(numDevices, (cl_uint)0);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenDeviceTypeDefaultWhenGettingDeviceIdsThenDeviceIdIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenDeviceTypeDefaultWhenGettingDeviceIdsThenDeviceIdIsReturned) {
     cl_uint numDevices = 0;
     cl_uint numEntries = 1;
     cl_device_id pDevices[1];
@@ -90,7 +93,7 @@ TEST_F(clGetDeviceIDsTests, GivenDeviceTypeDefaultWhenGettingDeviceIdsThenDevice
     EXPECT_GT(numDevices, (cl_uint)0);
 }
 
-TEST_F(clGetDeviceIDsTests, GivenDeviceTypeCpuWhenGettingDeviceIdsThenDeviceNotFoundErrorIsReturned) {
+TEST_F(clGetDeviceIDsTests, givenDeviceTypeCpuWhenGettingDeviceIdsThenDeviceNotFoundErrorIsReturned) {
     cl_uint numDevices = 0;
 
     auto retVal = clGetDeviceIDs(pPlatform, CL_DEVICE_TYPE_CPU, 0, nullptr, &numDevices);
@@ -100,7 +103,6 @@ TEST_F(clGetDeviceIDsTests, GivenDeviceTypeCpuWhenGettingDeviceIdsThenDeviceNotF
 }
 
 TEST(clGetDeviceIDsTest, givenMultipleRootDevicesWhenGetDeviceIdsThenAllRootDevicesAreReturned) {
-    platformsImpl->clear();
     constexpr auto numRootDevices = 3u;
     VariableBackup<UltHwConfig> backup(&ultHwConfig);
     ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
@@ -109,31 +111,122 @@ TEST(clGetDeviceIDsTest, givenMultipleRootDevicesWhenGetDeviceIdsThenAllRootDevi
     cl_uint numDevices = 0;
     cl_uint numEntries = numRootDevices;
     cl_device_id devices[numRootDevices];
-    auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+
-    EXPECT_EQ(retVal, CL_SUCCESS);
+    std::string hierarchies[] = {"COMPOSITE", "FLAT", "COMBINED"};
-    EXPECT_EQ(numEntries, numDevices);
+    for (std::string hierarchy : hierarchies) {
-    for (auto i = 0u; i < numRootDevices; i++) {
+        platformsImpl->clear();
-        EXPECT_EQ(devices[i], platform()->getClDevice(i));
+        std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", hierarchy}};
+        VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
+
+        auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+        EXPECT_EQ(retVal, CL_SUCCESS);
+        EXPECT_EQ(numEntries, numDevices);
+        for (auto i = 0u; i < numRootDevices; i++) {
+            EXPECT_EQ(devices[i], platform()->getClDevice(i));
+        }
     }
 }
+
 TEST(clGetDeviceIDsTest, givenMultipleRootDevicesWhenGetDeviceIdsButNumEntriesIsLowerThanNumDevicesThenSubsetOfRootDevicesIsReturned) {
-    platformsImpl->clear();
     constexpr auto numRootDevices = 3u;
     VariableBackup<UltHwConfig> backup(&ultHwConfig);
     ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
     DebugManagerStateRestore restorer;
     debugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
     cl_uint maxNumDevices;
+
+    std::string hierarchies[] = {"COMPOSITE", "FLAT", "COMBINED"};
+    for (std::string hierarchy : hierarchies) {
+        platformsImpl->clear();
+        std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", hierarchy}};
+        VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
+
+        auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, 0, nullptr, &maxNumDevices);
+        EXPECT_EQ(retVal, CL_SUCCESS);
+        EXPECT_EQ(numRootDevices, maxNumDevices);
+
+        cl_uint numDevices = 0;
+        cl_uint numEntries = numRootDevices - 1;
+        cl_device_id devices[numRootDevices];
+
+        const auto dummyDevice = reinterpret_cast<cl_device_id>(0x1357);
+        for (auto i = 0u; i < numRootDevices; i++) {
+            devices[i] = dummyDevice;
+        }
+
+        retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+        EXPECT_EQ(retVal, CL_SUCCESS);
+        EXPECT_LT(numDevices, maxNumDevices);
+        EXPECT_EQ(numEntries, numDevices);
+        for (auto i = 0u; i < numEntries; i++) {
+            EXPECT_EQ(devices[i], platform()->getClDevice(i));
+        }
+        EXPECT_EQ(devices[numEntries], dummyDevice);
+    }
+}
+
+TEST(clGetDeviceIDsTest, givenMultipleRootAndSubDevicesWhenCallClGetDeviceIDsThenSubDevicesAreReturnedAsSeparateClDevices) {
+    constexpr auto numRootDevices = 3u;
+    VariableBackup<UltHwConfig> backup(&ultHwConfig);
+    ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
+    DebugManagerStateRestore restorer;
+    debugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
+    debugManager.flags.CreateMultipleSubDevices.set(numRootDevices);
+    cl_uint maxNumDevices;
+
+    std::string hierarchies[] = {"FLAT", "COMBINED"};
+    for (std::string hierarchy : hierarchies) {
+        platformsImpl->clear();
+        std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", hierarchy}};
+        VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
+
+        auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, 0, nullptr, &maxNumDevices);
+        EXPECT_EQ(retVal, CL_SUCCESS);
+        EXPECT_EQ(numRootDevices * numRootDevices, maxNumDevices);
+
+        cl_uint numDevices = 0;
+        cl_uint numEntries = maxNumDevices - 1;
+        cl_device_id devices[numRootDevices * numRootDevices];
+
+        const auto dummyDevice = reinterpret_cast<cl_device_id>(0x1357);
+        for (auto i = 0u; i < maxNumDevices; i++) {
+            devices[i] = dummyDevice;
+        }
+
+        retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+        EXPECT_EQ(retVal, CL_SUCCESS);
+        EXPECT_LT(numDevices, maxNumDevices);
+        EXPECT_EQ(numEntries, numDevices);
+        for (auto i = 0u; i < numEntries; i++) {
+            EXPECT_EQ(devices[i], platform()->getClDevice(i / numRootDevices)->getSubDevice(i % numRootDevices));
+        }
+        EXPECT_EQ(devices[numEntries], dummyDevice);
+    }
+}
+
+TEST(clGetDeviceIDsTest, givenCompositeHierarchyWithMultipleRootAndSubDevicesWhenCallClGetDeviceIDsThenSubDevicesAreNotReturnedAsSeparateClDevices) {
+    constexpr auto numRootDevices = 3u;
+    VariableBackup<UltHwConfig> backup(&ultHwConfig);
+    ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
+    DebugManagerStateRestore restorer;
+    debugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
+    debugManager.flags.CreateMultipleSubDevices.set(numRootDevices);
+    cl_uint maxNumDevices;
+
+    platformsImpl->clear();
+    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);
+
     auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, 0, nullptr, &maxNumDevices);
     EXPECT_EQ(retVal, CL_SUCCESS);
     EXPECT_EQ(numRootDevices, maxNumDevices);
 
     cl_uint numDevices = 0;
-    cl_uint numEntries = numRootDevices - 1;
+    cl_uint numEntries = maxNumDevices - 1;
     cl_device_id devices[numRootDevices];
 
     const auto dummyDevice = reinterpret_cast<cl_device_id>(0x1357);
-    for (auto i = 0u; i < numRootDevices; i++) {
+    for (auto i = 0u; i < maxNumDevices; i++) {
         devices[i] = dummyDevice;
     }
 
@@ -147,77 +240,7 @@ TEST(clGetDeviceIDsTest, givenMultipleRootDevicesWhenGetDeviceIdsButNumEntriesIs
     EXPECT_EQ(devices[numEntries], dummyDevice);
 }
 
-TEST(clGetDeviceIDsTest, givenFlatHierarchyWhenCallClGetDeviceIDsThenSubDevicesAreReturnedAsSeparateClDevices) {
-    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);
-    platformsImpl->clear();
-    constexpr auto numRootDevices = 3u;
-    VariableBackup<UltHwConfig> backup(&ultHwConfig);
-    ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
-    DebugManagerStateRestore restorer;
-    debugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
-    debugManager.flags.CreateMultipleSubDevices.set(numRootDevices);
-    cl_uint maxNumDevices;
-    auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, 0, nullptr, &maxNumDevices);
-    EXPECT_EQ(retVal, CL_SUCCESS);
-    EXPECT_EQ(numRootDevices * numRootDevices, maxNumDevices);
-
-    cl_uint numDevices = 0;
-    cl_uint numEntries = maxNumDevices - 1;
-    cl_device_id devices[numRootDevices * numRootDevices];
-
-    const auto dummyDevice = reinterpret_cast<cl_device_id>(0x1357);
-    for (auto i = 0u; i < maxNumDevices; i++) {
-        devices[i] = dummyDevice;
-    }
-
-    retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
-    EXPECT_EQ(retVal, CL_SUCCESS);
-    EXPECT_LT(numDevices, maxNumDevices);
-    EXPECT_EQ(numEntries, numDevices);
-    for (auto i = 0u; i < numEntries; i++) {
-        EXPECT_EQ(devices[i], platform()->getClDevice(i / numRootDevices)->getSubDevice(i % numRootDevices));
-    }
-    EXPECT_EQ(devices[numEntries], dummyDevice);
-}
-
-TEST(clGetDeviceIDsTest, givenZeFlatDeviceHierarchyWhenCallClGetDeviceIDsThenSubDevicesAreReturnedAsSeparateClDevices) {
-    platformsImpl->clear();
-    constexpr auto numRootDevices = 3u;
-    VariableBackup<UltHwConfig> backup(&ultHwConfig);
-    ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
-    DebugManagerStateRestore restorer;
-    debugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
-    debugManager.flags.CreateMultipleSubDevices.set(numRootDevices);
-    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);
-    cl_uint maxNumDevices;
-    auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, 0, nullptr, &maxNumDevices);
-    EXPECT_EQ(retVal, CL_SUCCESS);
-    EXPECT_EQ(numRootDevices * numRootDevices, maxNumDevices);
-
-    cl_uint numDevices = 0;
-    cl_uint numEntries = maxNumDevices - 1;
-    cl_device_id devices[numRootDevices * numRootDevices];
-
-    const auto dummyDevice = reinterpret_cast<cl_device_id>(0x1357);
-    for (auto i = 0u; i < maxNumDevices; i++) {
-        devices[i] = dummyDevice;
-    }
-
-    retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
-    EXPECT_EQ(retVal, CL_SUCCESS);
-    EXPECT_LT(numDevices, maxNumDevices);
-    EXPECT_EQ(numEntries, numDevices);
-    for (auto i = 0u; i < numEntries; i++) {
-        EXPECT_EQ(devices[i], platform()->getClDevice(i / numRootDevices)->getSubDevice(i % numRootDevices));
-    }
-    EXPECT_EQ(devices[numEntries], dummyDevice);
-}
-
 TEST(clGetDeviceIDsTest, givenMultipleRootDevicesAndLimitedNumberOfReturnedDevicesWhenGetDeviceIdsThenLimitedNumberOfRootDevicesIsReturned) {
-    platformsImpl->clear();
     constexpr auto numRootDevices = 3u;
     VariableBackup<UltHwConfig> backup(&ultHwConfig);
     ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
@@ -225,37 +248,52 @@ TEST(clGetDeviceIDsTest, givenMultipleRootDevicesAndLimitedNumberOfReturnedDevic
     debugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
     debugManager.flags.LimitAmountOfReturnedDevices.set(numRootDevices - 1);
 
-    cl_uint numDevices = 0;
+    std::string hierarchies[] = {"COMPOSITE", "FLAT", "COMBINED"};
-    cl_uint numEntries = numRootDevices;
+    for (std::string hierarchy : hierarchies) {
-    cl_device_id devices[numRootDevices];
+        platformsImpl->clear();
+        std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", hierarchy}};
+        VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
 
-    const auto dummyDevice = reinterpret_cast<cl_device_id>(0x1357);
+        cl_uint numDevices = 0;
-    for (auto i = 0u; i < numRootDevices; i++) {
+        cl_uint numEntries = numRootDevices;
-        devices[i] = dummyDevice;
+        cl_device_id devices[numRootDevices];
-    }
 
-    auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+        const auto dummyDevice = reinterpret_cast<cl_device_id>(0x1357);
-    EXPECT_EQ(retVal, CL_SUCCESS);
+        for (auto i = 0u; i < numRootDevices; i++) {
-    EXPECT_EQ(numEntries - 1, numDevices);
+            devices[i] = dummyDevice;
-    for (auto i = 0u; i < numDevices; i++) {
+        }
-        EXPECT_EQ(devices[i], platform()->getClDevice(i));
+
+        auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+        EXPECT_EQ(retVal, CL_SUCCESS);
+        EXPECT_EQ(numEntries - 1, numDevices);
+        for (auto i = 0u; i < numDevices; i++) {
+            EXPECT_EQ(devices[i], platform()->getClDevice(i));
+        }
+        EXPECT_EQ(devices[numDevices], dummyDevice);
     }
-    EXPECT_EQ(devices[numDevices], dummyDevice);
 }
+
 TEST(clGetDeviceIDsNegativeTests, whenFailToCreateDeviceThenclGetDeviceIDsReturnsNoDeviceError) {
     VariableBackup<decltype(DeviceFactory::createRootDeviceFunc)> createFuncBackup{&DeviceFactory::createRootDeviceFunc};
     DeviceFactory::createRootDeviceFunc = [](ExecutionEnvironment &executionEnvironment, uint32_t rootDeviceIndex) -> std::unique_ptr<Device> {
         return nullptr;
     };
-    platformsImpl->clear();
 
-    constexpr auto numRootDevices = 3u;
+    std::string hierarchies[] = {"COMPOSITE", "FLAT", "COMBINED"};
-    cl_uint numDevices = 0;
+    for (std::string hierarchy : hierarchies) {
-    cl_uint numEntries = numRootDevices;
+        platformsImpl->clear();
-    cl_device_id devices[numRootDevices];
+        std::unordered_map<std::string, std::string> mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", hierarchy}};
+        VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs);
 
-    auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+        constexpr auto numRootDevices = 3u;
-    EXPECT_EQ(CL_DEVICE_NOT_FOUND, retVal);
+        cl_uint numDevices = 0;
-    EXPECT_EQ(numDevices, 0u);
+        cl_uint numEntries = numRootDevices;
+        cl_device_id devices[numRootDevices];
+
+        auto retVal = clGetDeviceIDs(nullptr, CL_DEVICE_TYPE_ALL, numEntries, devices, &numDevices);
+        EXPECT_EQ(CL_DEVICE_NOT_FOUND, retVal);
+        EXPECT_EQ(numDevices, 0u);
+    }
 }
+
 } // namespace ULT