From 26a24e8fde28895a60ee67c40953ce9479353a68 Mon Sep 17 00:00:00 2001 From: Szymon Morek Date: Tue, 4 Jan 2022 14:48:05 +0000 Subject: [PATCH] Query engine info with distances If prelim kernel is being used, query distances and set correctly number of available engines Signed-off-by: Szymon Morek --- .../sysman/engine/linux/os_engine_imp.cpp | 4 +- .../sources/sysman/engine/linux/mock_engine.h | 5 +- .../sysman/engine/linux/test_zes_engine.cpp | 12 +- .../linux/drm_engine_info_tests.cpp | 167 +++++++++++++++++- .../linux/ioctl_helper_tests_prelim.cpp | 103 ++++++++++- .../linux/ioctl_helper_tests_upstream.cpp | 40 +++++ .../os_interface/linux/prelim_helper_func.cpp | 27 ++- .../source/os_interface/linux/CMakeLists.txt | 5 +- shared/source/os_interface/linux/drm_neo.cpp | 83 ++++++++- .../source/os_interface/linux/drm_query.cpp | 13 +- .../source/os_interface/linux/engine_info.cpp | 145 +++++++++++++++ .../source/os_interface/linux/engine_info.h | 40 ++++- .../linux/engine_info_extended.cpp | 27 +++ .../os_interface/linux/engine_info_impl.h | 32 ---- .../source/os_interface/linux/ioctl_helper.h | 3 + .../linux/ioctl_helper_prelim.cpp | 4 + .../linux/ioctl_helper_upstream.cpp | 4 + shared/test/common/libult/linux/drm_mock.h | 7 +- 18 files changed, 651 insertions(+), 70 deletions(-) create mode 100644 shared/source/os_interface/linux/engine_info.cpp create mode 100644 shared/source/os_interface/linux/engine_info_extended.cpp delete mode 100644 shared/source/os_interface/linux/engine_info_impl.h diff --git a/level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp b/level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp index 17776bfbc8..690605ff69 100644 --- a/level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp +++ b/level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp @@ -7,7 +7,7 @@ #include "level_zero/tools/source/sysman/engine/linux/os_engine_imp.h" -#include "shared/source/os_interface/linux/engine_info_impl.h" +#include "shared/source/os_interface/linux/engine_info.h" #include "sysman/linux/os_sysman_imp.h" @@ -34,7 +34,7 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::setsysmanQueryEngineInfo() == false) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - auto engineInfo = static_cast(pDrm->getEngineInfo()); + auto engineInfo = pDrm->getEngineInfo(); for (auto itr = engineInfo->engines.begin(); itr != engineInfo->engines.end(); ++itr) { auto i915ToEngineMapRange = i915ToEngineMap.equal_range(static_cast<__u16>(itr->engine.engineClass)); for (auto L0EngineEntryInMap = i915ToEngineMapRange.first; L0EngineEntryInMap != i915ToEngineMapRange.second; L0EngineEntryInMap++) { diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h index f8ee8a5703..afacca8bd6 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h +++ b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h @@ -6,7 +6,7 @@ */ #pragma once -#include "shared/source/os_interface/linux/engine_info_impl.h" +#include "shared/source/os_interface/linux/engine_info.h" #include "shared/test/common/libult/linux/drm_mock.h" #include "level_zero/core/test/unit_tests/mock.h" @@ -54,7 +54,8 @@ struct Mock : public EngineNeoDrm { i915engineInfo[5].engine.engineClass = I915_INVALID_ENGINE_CLASS; i915engineInfo[5].engine.engineInstance = 0; - this->engineInfo.reset(new EngineInfoImpl(i915engineInfo)); + NEO::HardwareInfo hwInfo = *rootDeviceEnvironment.getHardwareInfo(); + this->engineInfo.reset(new EngineInfo(this, &hwInfo, i915engineInfo)); return true; } diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp index 3c8dd32d00..5a195ae9ed 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp +++ b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2021 Intel Corporation + * Copyright (C) 2020-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -226,8 +226,11 @@ TEST_F(ZesEngineFixture, GivenValidOsSysmanPointerWhenRetrievingEngineTypeAndIns TEST_F(ZesEngineFixture, givenEngineInfoQuerySupportedWhenQueryingEngineInfoThenEngineInfoIsCreatedWithEngines) { auto drm = std::make_unique((const_cast(neoDevice->getRootDeviceEnvironment()))); ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); drm->sysmanQueryEngineInfo(); - auto engineInfo = static_cast(drm->getEngineInfo()); + auto engineInfo = drm->getEngineInfo(); ASSERT_NE(nullptr, engineInfo); EXPECT_EQ(2u, engineInfo->engines.size()); } @@ -235,8 +238,11 @@ TEST_F(ZesEngineFixture, givenEngineInfoQuerySupportedWhenQueryingEngineInfoThen TEST_F(ZesEngineFixture, GivenEngineInfoWithVideoQuerySupportedWhenQueryingEngineInfoWithVideoThenEngineInfoIsCreatedWithEngines) { auto drm = std::make_unique((const_cast(neoDevice->getRootDeviceEnvironment()))); ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); drm->sysmanQueryEngineInfo(); - auto engineInfo = static_cast(drm->getEngineInfo()); + auto engineInfo = drm->getEngineInfo(); ASSERT_NE(nullptr, engineInfo); EXPECT_EQ(2u, engineInfo->engines.size()); } diff --git a/opencl/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp b/opencl/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp index 6e60ec713c..9ed208fa29 100644 --- a/opencl/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp +++ b/opencl/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp @@ -1,11 +1,11 @@ /* - * Copyright (C) 2019-2021 Intel Corporation + * Copyright (C) 2019-2022 Intel Corporation * * SPDX-License-Identifier: MIT * */ -#include "shared/source/os_interface/linux/engine_info_impl.h" +#include "shared/source/os_interface/linux/engine_info.h" #include "shared/test/common/libult/linux/drm_mock.h" #include "gtest/gtest.h" @@ -21,17 +21,172 @@ TEST(DrmTest, whenQueryingEngineInfoThenSingleIoctlIsCalled) { drm->queryEngineInfo(); EXPECT_EQ(1u, drm->ioctlCallsCount); } + TEST(EngineInfoTest, givenEngineInfoQuerySupportedWhenQueryingEngineInfoThenEngineInfoIsCreatedWithEngines) { auto executionEnvironment = std::make_unique(); executionEnvironment->prepareRootDeviceEnvironments(1); auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{0, 0}, 0, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); + drm->queryEngineInfo(); + EXPECT_EQ(2u, drm->ioctlCallsCount); + auto engineInfo = drm->getEngineInfo(); + + ASSERT_NE(nullptr, engineInfo); + EXPECT_EQ(2u, engineInfo->engines.size()); +} + +TEST(EngineInfoTest, whenQueryingEngineInfoWithoutMemoryInfoThenEngineInfoNotSet) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + ASSERT_NE(nullptr, drm); + drm->queryEngineInfo(); EXPECT_EQ(2u, drm->ioctlCallsCount); + auto engineInfo = drm->getEngineInfo(); - auto engineInfo = static_cast(drm->getEngineInfo()); - - ASSERT_NE(nullptr, engineInfo); - EXPECT_EQ(2u, engineInfo->engines.size()); + ASSERT_EQ(nullptr, engineInfo); +} + +TEST(EngineInfoTest, whenCreateEngineInfoWithRcsThenCorrectHwInfoSet) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto hwInfo = *defaultHwInfo.get(); + std::vector engines(2); + engines[0].engine = {I915_ENGINE_CLASS_RENDER, 0}; + engines[0].capabilities = 0; + engines[1].engine = {I915_ENGINE_CLASS_COPY, 0}; + engines[1].capabilities = 0; + auto engineInfo = std::make_unique(drm.get(), &hwInfo, engines); + + auto ccsInfo = hwInfo.gtSystemInfo.CCSInfo; + EXPECT_FALSE(ccsInfo.IsValid); + EXPECT_EQ(0u, ccsInfo.NumberOfCCSEnabled); + EXPECT_EQ(0u, ccsInfo.Instances.CCSEnableMask); + EXPECT_EQ(1u, hwInfo.featureTable.ftrBcsInfo.to_ulong()); +} + +TEST(EngineInfoTest, whenCreateEngineInfoWithCcsThenCorrectHwInfoSet) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto hwInfo = *defaultHwInfo.get(); + std::vector engines(2); + uint16_t ccsClass = IoctlHelper::get(drm.get())->getComputeEngineClass(); + engines[0].engine = {ccsClass, 0}; + engines[0].capabilities = 0; + engines[1].engine = {I915_ENGINE_CLASS_COPY, 0}; + engines[1].capabilities = 0; + auto engineInfo = std::make_unique(drm.get(), &hwInfo, engines); + + auto ccsInfo = hwInfo.gtSystemInfo.CCSInfo; + EXPECT_TRUE(ccsInfo.IsValid); + EXPECT_EQ(1u, ccsInfo.NumberOfCCSEnabled); + EXPECT_EQ(1u, ccsInfo.Instances.CCSEnableMask); + EXPECT_EQ(1u, hwInfo.featureTable.ftrBcsInfo.to_ulong()); +} + +TEST(EngineInfoTest, whenGetEngineInstanceAndTileThenCorrectValuesReturned) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto hwInfo = *defaultHwInfo.get(); + std::vector engines(4); + engines[0].engine = {I915_ENGINE_CLASS_RENDER, 0}; + engines[0].capabilities = 0; + engines[1].engine = {I915_ENGINE_CLASS_COPY, 0}; + engines[1].capabilities = 0; + engines[2].engine = {I915_ENGINE_CLASS_RENDER, 1}; + engines[2].capabilities = 0; + engines[3].engine = {I915_ENGINE_CLASS_COPY, 1}; + engines[3].capabilities = 0; + + std::vector distances(4); + distances[0].engine = engines[0].engine; + distances[0].region = {I915_MEMORY_CLASS_DEVICE, 0}; + distances[1].engine = engines[1].engine; + distances[1].region = {I915_MEMORY_CLASS_DEVICE, 0}; + distances[2].engine = engines[2].engine; + distances[2].region = {I915_MEMORY_CLASS_DEVICE, 1}; + distances[3].engine = engines[3].engine; + distances[3].region = {I915_MEMORY_CLASS_DEVICE, 1}; + + std::vector queryItems{distances.size()}; + for (auto i = 0u; i < distances.size(); i++) { + queryItems[i].length = sizeof(drm_i915_query_engine_info); + } + auto engineInfo = std::make_unique(drm.get(), &hwInfo, 2, distances, queryItems, engines); + + auto engineType = EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, hwInfo); + auto engine = engineInfo->getEngineInstance(0, engineType); + EXPECT_EQ(engines[0].engine.engineClass, engine->engineClass); + EXPECT_EQ(engines[0].engine.engineInstance, engine->engineInstance); + + engine = engineInfo->getEngineInstance(1, aub_stream::EngineType::ENGINE_BCS); + EXPECT_EQ(engines[3].engine.engineClass, engine->engineClass); + EXPECT_EQ(engines[3].engine.engineInstance, engine->engineInstance); + + EXPECT_EQ(nullptr, engineInfo->getEngineInstance(3, aub_stream::EngineType::ENGINE_RCS)); + EXPECT_EQ(nullptr, engineInfo->getEngineInstance(0, aub_stream::EngineType::ENGINE_VCS)); + + EXPECT_EQ(0u, engineInfo->getEngineTileIndex(engines[0].engine)); + EXPECT_EQ(1u, engineInfo->getEngineTileIndex(engines[2].engine)); + + EXPECT_EQ(0u, engineInfo->getEngineTileIndex({I915_ENGINE_CLASS_RENDER, 2})); +} + +TEST(EngineInfoTest, whenCreateEngineInfoAndInvalidQueryThenNoEnginesSet) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto hwInfo = *defaultHwInfo.get(); + std::vector engines(4); + engines[0].engine = {I915_ENGINE_CLASS_RENDER, 0}; + engines[0].capabilities = 0; + engines[1].engine = {I915_ENGINE_CLASS_COPY, 0}; + engines[1].capabilities = 0; + engines[2].engine = {I915_ENGINE_CLASS_RENDER, 1}; + engines[2].capabilities = 0; + engines[3].engine = {I915_ENGINE_CLASS_COPY, 1}; + engines[3].capabilities = 0; + + std::vector distances(4); + distances[0].engine = engines[0].engine; + distances[0].region = {I915_MEMORY_CLASS_DEVICE, 0}; + distances[1].engine = engines[1].engine; + distances[1].region = {I915_MEMORY_CLASS_DEVICE, 0}; + distances[2].engine = engines[2].engine; + distances[2].region = {I915_MEMORY_CLASS_DEVICE, 1}; + distances[3].engine = engines[3].engine; + distances[3].region = {I915_MEMORY_CLASS_DEVICE, 1}; + + std::vector queryItems{distances.size()}; + for (auto i = 0u; i < distances.size(); i++) { + queryItems[i].length = -1; + } + auto engineInfo = std::make_unique(drm.get(), &hwInfo, 2, distances, queryItems, engines); + EXPECT_EQ(nullptr, engineInfo->getEngineInstance(0, aub_stream::EngineType::ENGINE_RCS)); +} + +TEST(EngineInfoTest, whenEmptyEngineInfoCreatedThen0TileReturned) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto hwInfo = *defaultHwInfo.get(); + std::vector distances; + std::vector engines; + std::vector queryItems; + + auto engineInfo = std::make_unique(drm.get(), &hwInfo, 0, distances, queryItems, engines); + EXPECT_EQ(0u, engineInfo->getEngineTileIndex({I915_ENGINE_CLASS_RENDER, 1})); } diff --git a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp index 9b34c82a33..8f3e88831d 100644 --- a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp +++ b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp @@ -15,7 +15,7 @@ using namespace NEO; -extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal); +extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal); extern std::vector getRegionInfo(const std::vector &inputRegions); extern std::vector getEngineInfo(const std::vector &inputEngines); @@ -28,13 +28,14 @@ class DrmPrelimMock : public DrmMock { } int ioctlRetVal = 0; + int queryDistanceIoctlRetVal = 0; void getPrelimVersion(std::string &prelimVersion) override { prelimVersion = "2.0"; } int handleRemainingRequests(unsigned long request, void *arg) override { - return handlePrelimRequests(request, arg, ioctlRetVal); + return handlePrelimRequests(request, arg, ioctlRetVal, queryDistanceIoctlRetVal); } }; @@ -356,3 +357,101 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenQueryDistancesThenCorrectDistanceSe EXPECT_EQ(0, distances[1].distance); EXPECT_EQ(100, distances[2].distance); } + +TEST(IoctlHelperTestsPrelim, givenPrelimWhenQueryEngineInfoWithDeviceMemoryThenDistancesUsedAndMultileValuesSet) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); + EXPECT_TRUE(drm->queryEngineInfo()); + EXPECT_EQ(3u, drm->ioctlCallsCount); + auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo(); + auto engineInfo = drm->getEngineInfo(); + + auto &multiTileArchInfo = const_cast(hwInfo->gtSystemInfo.MultiTileArchInfo); + EXPECT_TRUE(multiTileArchInfo.IsValid); + EXPECT_EQ(3, multiTileArchInfo.TileCount); + EXPECT_EQ(7, multiTileArchInfo.TileMask); + + EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(1)); + EXPECT_EQ(1024u, drm->memoryInfo->getMemoryRegionSize(2)); + EXPECT_EQ(0u, drm->memoryInfo->getMemoryRegionSize(4)); + + std::vector engines; + engineInfo->getListOfEnginesOnATile(0u, engines); + EXPECT_EQ(3u, engines.size()); + + engines.clear(); + engineInfo->getListOfEnginesOnATile(1u, engines); + EXPECT_EQ(3u, engines.size()); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimWhenQueryEngineInfoThenCorrectCCSFlagsSet) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); + EXPECT_TRUE(drm->queryEngineInfo()); + EXPECT_EQ(3u, drm->ioctlCallsCount); + auto hwInfo = drm->getRootDeviceEnvironment().getHardwareInfo(); + auto ccsInfo = hwInfo->gtSystemInfo.CCSInfo; + EXPECT_TRUE(ccsInfo.IsValid); + EXPECT_EQ(1u, ccsInfo.NumberOfCCSEnabled); + EXPECT_EQ(1u, ccsInfo.Instances.CCSEnableMask); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimWhenSysmanQueryEngineInfoThenAdditionalEnginesUsed) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); + EXPECT_TRUE(drm->sysmanQueryEngineInfo()); + EXPECT_EQ(3u, drm->ioctlCallsCount); + auto engineInfo = drm->getEngineInfo(); + + std::vector engines; + engineInfo->getListOfEnginesOnATile(0u, engines); + EXPECT_EQ(5u, engines.size()); + + engines.clear(); + engineInfo->getListOfEnginesOnATile(1u, engines); + EXPECT_EQ(5u, engines.size()); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimWhenQueryEngineInfoAndFailIoctlThenFalseReturned) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + ASSERT_NE(nullptr, drm); + drm->queryDistanceIoctlRetVal = -1; + + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); + EXPECT_FALSE(drm->queryEngineInfo()); + + EXPECT_EQ(3u, drm->ioctlCallsCount); + auto engineInfo = drm->getEngineInfo(); + + EXPECT_EQ(nullptr, engineInfo); +} diff --git a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp index e82aa55279..44534904d3 100644 --- a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp +++ b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp @@ -145,3 +145,43 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryDistancesThenReturnEinval) [](const drm_i915_query_item &item) { return item.length == -EINVAL; }); EXPECT_TRUE(queryUnsupported); } + +TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryEngineInfoWithoutDeviceMemoryThenDontUseMultitile) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); + EXPECT_TRUE(drm->queryEngineInfo()); + EXPECT_EQ(2u, drm->ioctlCallsCount); + + auto engineInfo = drm->getEngineInfo(); + std::vector engines; + engineInfo->getListOfEnginesOnATile(0, engines); + auto totalEnginesCount = engineInfo->engines.size(); + ASSERT_NE(nullptr, engineInfo); + EXPECT_EQ(totalEnginesCount, engines.size()); +} + +TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryEngineInfoWithDeviceMemoryAndDistancesUnsupportedThenDontUseMultitile) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + ASSERT_NE(nullptr, drm); + std::vector memRegions{ + {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0}, + {{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions)); + EXPECT_TRUE(drm->queryEngineInfo()); + EXPECT_EQ(2u, drm->ioctlCallsCount); + + auto engineInfo = drm->getEngineInfo(); + std::vector engines; + engineInfo->getListOfEnginesOnATile(0, engines); + auto totalEnginesCount = engineInfo->engines.size(); + ASSERT_NE(nullptr, engineInfo); + EXPECT_EQ(totalEnginesCount, engines.size()); +} diff --git a/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp b/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp index 5ee61d9b9f..af78b4a6c9 100644 --- a/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp +++ b/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp @@ -15,7 +15,7 @@ using namespace NEO; -int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal) { +int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal, int queryDistanceIoctlRetVal) { if (request == PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT) { auto createExtParams = static_cast(arg); if (createExtParams->size == 0) { @@ -53,8 +53,33 @@ int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal) { for (auto i = 0u; i < query->num_items; i++) { auto queryItemPtr = reinterpret_cast(query->items_ptr) + i; if (queryItemPtr->query_id == PRELIM_DRM_I915_QUERY_DISTANCE_INFO) { + if (queryDistanceIoctlRetVal != 0) { + return queryDistanceIoctlRetVal; + } auto distance = reinterpret_cast(queryItemPtr->data_ptr); distance->distance = (distance->engine.engine_instance == distance->region.memory_instance) ? 0 : 100; + } else if (queryItemPtr->query_id == PRELIM_DRM_I915_QUERY_ENGINE_INFO) { + auto numberOfTiles = 2u; + uint32_t numberOfEngines = numberOfTiles * 6u; + int engineInfoSize = sizeof(prelim_drm_i915_query_engine_info) + numberOfEngines * sizeof(prelim_drm_i915_engine_info); + if (queryItemPtr->length == 0) { + queryItemPtr->length = engineInfoSize; + } else { + EXPECT_EQ(engineInfoSize, queryItemPtr->length); + auto queryEngineInfo = reinterpret_cast(queryItemPtr->data_ptr); + EXPECT_EQ(0u, queryEngineInfo->num_engines); + queryEngineInfo->num_engines = numberOfEngines; + auto p = queryEngineInfo->engines; + for (uint16_t tile = 0u; tile < numberOfTiles; tile++) { + p++->engine = {I915_ENGINE_CLASS_RENDER, tile}; + p++->engine = {I915_ENGINE_CLASS_COPY, tile}; + p++->engine = {I915_ENGINE_CLASS_VIDEO, tile}; + p++->engine = {I915_ENGINE_CLASS_VIDEO_ENHANCE, tile}; + p++->engine = {PRELIM_I915_ENGINE_CLASS_COMPUTE, tile}; + p++->engine = {UINT16_MAX, tile}; + } + } + break; } } } diff --git a/shared/source/os_interface/linux/CMakeLists.txt b/shared/source/os_interface/linux/CMakeLists.txt index cc47c6bf5c..f46097dc37 100644 --- a/shared/source/os_interface/linux/CMakeLists.txt +++ b/shared/source/os_interface/linux/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (C) 2019-2021 Intel Corporation +# Copyright (C) 2019-2022 Intel Corporation # # SPDX-License-Identifier: MIT # @@ -52,7 +52,8 @@ set(NEO_CORE_OS_INTERFACE_LINUX ${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_prelim.cpp ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}ioctl_helper_getter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/engine_info.h - ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}engine_info_impl.h + ${CMAKE_CURRENT_SOURCE_DIR}/engine_info.cpp + ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}engine_info_extended.cpp ${CMAKE_CURRENT_SOURCE_DIR}/flags${BRANCH_DIR_SUFFIX}drm_query_flags.h ${CMAKE_CURRENT_SOURCE_DIR}/memory_info.h ${CMAKE_CURRENT_SOURCE_DIR}/memory_info.cpp diff --git a/shared/source/os_interface/linux/drm_neo.cpp b/shared/source/os_interface/linux/drm_neo.cpp index 410e65096c..31d14e4712 100644 --- a/shared/source/os_interface/linux/drm_neo.cpp +++ b/shared/source/os_interface/linux/drm_neo.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -950,4 +950,85 @@ bool Drm::queryMemoryInfo() { return false; } +bool Drm::queryEngineInfo(bool isSysmanEnabled) { + auto ioctlHelper = IoctlHelper::get(this); + auto enginesQuery = this->query(ioctlHelper->getEngineInfoIoctlVal(), DrmQueryItemFlags::empty); + if (enginesQuery.empty()) { + return false; + } + auto engines = ioctlHelper->translateToEngineCaps(enginesQuery); + + auto memInfo = memoryInfo.get(); + + if (!memInfo) { + return false; + } + + auto &memoryRegions = memInfo->getDrmRegionInfos(); + + auto tileCount = 0u; + std::vector distanceInfos; + for (const auto ®ion : memoryRegions) { + if (I915_MEMORY_CLASS_DEVICE == region.region.memoryClass) { + tileCount++; + DistanceInfo distanceInfo{}; + distanceInfo.region = region.region; + + for (const auto &engine : engines) { + switch (engine.engine.engineClass) { + case I915_ENGINE_CLASS_RENDER: + case I915_ENGINE_CLASS_COPY: + distanceInfo.engine = engine.engine; + distanceInfos.push_back(distanceInfo); + break; + case I915_ENGINE_CLASS_VIDEO: + case I915_ENGINE_CLASS_VIDEO_ENHANCE: + if (isSysmanEnabled == true) { + distanceInfo.engine = engine.engine; + distanceInfos.push_back(distanceInfo); + } + break; + default: + if (engine.engine.engineClass == ioctlHelper->getComputeEngineClass()) { + distanceInfo.engine = engine.engine; + distanceInfos.push_back(distanceInfo); + } + break; + } + } + } + } + + auto hwInfo = rootDeviceEnvironment.getMutableHardwareInfo(); + + if (tileCount == 0u) { + this->engineInfo.reset(new EngineInfo(this, hwInfo, engines)); + return true; + } + + std::vector queryItems{distanceInfos.size()}; + auto ret = ioctlHelper->queryDistances(this, queryItems, distanceInfos); + if (ret != 0) { + return false; + } + + const bool queryUnsupported = std::all_of(queryItems.begin(), queryItems.end(), + [](const drm_i915_query_item &item) { return item.length == -EINVAL; }); + if (queryUnsupported) { + DEBUG_BREAK_IF(tileCount != 1); + this->engineInfo.reset(new EngineInfo(this, hwInfo, engines)); + return true; + } + + memInfo->assignRegionsFromDistances(distanceInfos); + + auto &multiTileArchInfo = const_cast(hwInfo->gtSystemInfo.MultiTileArchInfo); + multiTileArchInfo.IsValid = true; + multiTileArchInfo.TileCount = tileCount; + multiTileArchInfo.TileMask = static_cast(maxNBitValue(tileCount)); + + this->engineInfo.reset(new EngineInfo(this, hwInfo, tileCount, distanceInfos, queryItems, engines)); + return true; +} + } // namespace NEO diff --git a/shared/source/os_interface/linux/drm_query.cpp b/shared/source/os_interface/linux/drm_query.cpp index fceb37e8a7..dbee0bb2ba 100644 --- a/shared/source/os_interface/linux/drm_query.cpp +++ b/shared/source/os_interface/linux/drm_query.cpp @@ -9,7 +9,7 @@ #include "shared/source/helpers/string.h" #include "shared/source/os_interface/linux/cache_info_impl.h" #include "shared/source/os_interface/linux/drm_engine_mapper.h" -#include "shared/source/os_interface/linux/engine_info_impl.h" +#include "shared/source/os_interface/linux/engine_info.h" #include "shared/source/os_interface/linux/ioctl_helper.h" #include "shared/source/os_interface/linux/memory_info.h" #include "shared/source/os_interface/linux/sys_calls.h" @@ -32,17 +32,6 @@ std::string getIoctlParamStringRemaining(int param) { } } // namespace IoctlToStringHelper -bool Drm::queryEngineInfo(bool isSysmanEnabled) { - auto ioctlHelper = IoctlHelper::get(this); - auto dataQuery = this->query(ioctlHelper->getEngineInfoIoctlVal(), DrmQueryItemFlags::empty); - if (dataQuery.empty()) { - return false; - } - auto engines = ioctlHelper->translateToEngineCaps(dataQuery); - this->engineInfo.reset(new EngineInfoImpl(engines)); - return true; -} - unsigned int Drm::bindDrmContext(uint32_t drmContextId, uint32_t deviceIndex, aub_stream::EngineType engineType, bool engineInstancedDevice) { return DrmEngineMapper::engineNodeMap(engineType); } diff --git a/shared/source/os_interface/linux/engine_info.cpp b/shared/source/os_interface/linux/engine_info.cpp new file mode 100644 index 0000000000..b1287f9213 --- /dev/null +++ b/shared/source/os_interface/linux/engine_info.cpp @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/os_interface/linux/engine_info.h" + +#include "shared/source/helpers/bit_helpers.h" +#include "shared/source/helpers/constants.h" +#include "shared/source/helpers/debug_helpers.h" +#include "shared/source/helpers/engine_node_helper.h" +#include "shared/source/helpers/hw_info.h" + +#include + +namespace NEO { +namespace DrmEngineMappingHelper { +constexpr std::array engineMapping = {{aub_stream::ENGINE_BCS, aub_stream::ENGINE_BCS1, aub_stream::ENGINE_BCS2, + aub_stream::ENGINE_BCS3, aub_stream::ENGINE_BCS4, aub_stream::ENGINE_BCS5, + aub_stream::ENGINE_BCS6, aub_stream::ENGINE_BCS7, aub_stream::ENGINE_BCS8}}; +} // namespace DrmEngineMappingHelper + +EngineInfo::EngineInfo(Drm *drm, HardwareInfo *hwInfo, const std::vector &engineInfos) + : engines(engineInfos), tileToEngineToInstanceMap(1) { + auto computeEngines = 0u; + BcsInfoMask bcsInfoMask = 0; + uint32_t numHostLinkCopyEngines = 0; + uint32_t numScaleUpLinkCopyEngines = 0; + + for (const auto &engineInfo : engineInfos) { + auto &engine = engineInfo.engine; + tileToEngineMap.emplace(0, engine); + switch (engine.engineClass) { + case I915_ENGINE_CLASS_RENDER: + tileToEngineToInstanceMap[0][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, *hwInfo)] = engine; + break; + case I915_ENGINE_CLASS_COPY: + assignCopyEngine(EngineInfo::getBaseCopyEngineType(engineInfo.capabilities), 0, engine, + bcsInfoMask, numHostLinkCopyEngines, numScaleUpLinkCopyEngines); + break; + default: + if (engine.engineClass == IoctlHelper::get(drm)->getComputeEngineClass()) { + tileToEngineToInstanceMap[0][static_cast(aub_stream::ENGINE_CCS + computeEngines)] = engine; + computeEngines++; + } + break; + } + } + setSupportedEngiesInfo(hwInfo, computeEngines, bcsInfoMask); +} + +EngineInfo::EngineInfo(Drm *drm, HardwareInfo *hwInfo, uint32_t tileCount, const std::vector &distanceInfos, const std::vector &queryItems, const std::vector &engineInfos) + : engines(engineInfos), tileToEngineToInstanceMap(tileCount) { + auto tile = 0u; + auto computeEnginesPerTile = 0u; + auto copyEnginesPerTile = 0u; + for (auto i = 0u; i < distanceInfos.size(); i++) { + if (i > 0u && distanceInfos[i].region.memoryInstance != distanceInfos[i - 1u].region.memoryInstance) { + tile++; + computeEnginesPerTile = 0u; + copyEnginesPerTile = 0u; + } + if (queryItems[i].length < 0 || distanceInfos[i].distance != 0) + continue; + + auto engine = distanceInfos[i].engine; + tileToEngineMap.emplace(tile, engine); + switch (engine.engineClass) { + case I915_ENGINE_CLASS_RENDER: + tileToEngineToInstanceMap[tile][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, *hwInfo)] = engine; + break; + case I915_ENGINE_CLASS_COPY: + tileToEngineToInstanceMap[tile][DrmEngineMappingHelper::engineMapping[copyEnginesPerTile]] = engine; + copyEnginesPerTile++; + break; + default: + if (engine.engineClass == IoctlHelper::get(drm)->getComputeEngineClass()) { + tileToEngineToInstanceMap[tile][static_cast(aub_stream::ENGINE_CCS + computeEnginesPerTile)] = engine; + computeEnginesPerTile++; + } + break; + } + } + + BcsInfoMask bcsInfoMask = maxNBitValue(copyEnginesPerTile); + setSupportedEngiesInfo(hwInfo, computeEnginesPerTile, bcsInfoMask); +} + +const EngineClassInstance *EngineInfo::getEngineInstance(uint32_t tile, aub_stream::EngineType engineType) const { + if (tile >= tileToEngineToInstanceMap.size()) { + return nullptr; + } + auto &engineToInstanceMap = tileToEngineToInstanceMap[tile]; + auto iter = engineToInstanceMap.find(engineType); + if (iter == engineToInstanceMap.end()) { + return nullptr; + } + return &iter->second; +} + +void EngineInfo::setSupportedEngiesInfo(HardwareInfo *hwInfo, uint32_t numComputeEngines, const BcsInfoMask &bcsInfoMask) { + auto &ccsInfo = hwInfo->gtSystemInfo.CCSInfo; + + if (numComputeEngines > 0u) { + hwInfo->featureTable.flags.ftrCCSNode = true; + + ccsInfo.IsValid = true; + ccsInfo.NumberOfCCSEnabled = numComputeEngines; + ccsInfo.Instances.CCSEnableMask = static_cast(maxNBitValue(numComputeEngines)); + } else { + hwInfo->capabilityTable.defaultEngineType = EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, *hwInfo); + hwInfo->featureTable.flags.ftrCCSNode = false; + + ccsInfo.IsValid = false; + ccsInfo.NumberOfCCSEnabled = 0; + ccsInfo.Instances.CCSEnableMask = 0; + } + hwInfo->featureTable.ftrBcsInfo = bcsInfoMask; +} + +uint32_t EngineInfo::getEngineTileIndex(const EngineClassInstance &engine) { + uint32_t tile = 0; + if (tileToEngineMap.empty()) { + return tile; //Empty map + } + + for (auto itr = tileToEngineMap.begin(); itr != tileToEngineMap.end(); itr++) { + if ((itr->second.engineClass == engine.engineClass) && (itr->second.engineInstance == engine.engineInstance)) { + tile = itr->first; + break; + } + } + return tile; +} + +void EngineInfo::getListOfEnginesOnATile(uint32_t tile, std::vector &listOfEngines) { + auto range = tileToEngineMap.equal_range(tile); + for (auto itr = range.first; itr != range.second; ++itr) { + listOfEngines.push_back(itr->second); + } +} + +} // namespace NEO diff --git a/shared/source/os_interface/linux/engine_info.h b/shared/source/os_interface/linux/engine_info.h index 16ace68bb2..f4962b18e2 100644 --- a/shared/source/os_interface/linux/engine_info.h +++ b/shared/source/os_interface/linux/engine_info.h @@ -1,19 +1,49 @@ /* - * Copyright (C) 2019-2020 Intel Corporation + * Copyright (C) 2019-2022 Intel Corporation * * SPDX-License-Identifier: MIT * */ #pragma once +#include "shared/source/os_interface/linux/engine_info.h" +#include "shared/source/os_interface/linux/ioctl_helper.h" + +#include "drm/i915_drm.h" +#include "engine_node.h" +#include "sku_info.h" + +#include +#include +#include namespace NEO { +struct HardwareInfo; +class Drm; struct EngineInfo { - EngineInfo() = default; - virtual ~EngineInfo() = 0; + public: + using EngineToInstanceMap = std::map; + + EngineInfo(Drm *drm, HardwareInfo *hwInfo, const std::vector &engineInfos); + EngineInfo(Drm *drm, HardwareInfo *hwInfo, uint32_t tileCount, const std::vector &distanceInfos, const std::vector &queryItems, const std::vector &engineInfos); + + ~EngineInfo() = default; + + const EngineClassInstance *getEngineInstance(uint32_t tile, aub_stream::EngineType engineType) const; + uint32_t getEngineTileIndex(const EngineClassInstance &engine); + void getListOfEnginesOnATile(uint32_t tile, std::vector &listOfEngines); + std::vector engines; + + protected: + static aub_stream::EngineType getBaseCopyEngineType(uint64_t capabilities); + static void setSupportedEngiesInfo(HardwareInfo *hwInfo, uint32_t numComputeEngines, const BcsInfoMask &bcsInfoMask); + + void assignCopyEngine(aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine, + BcsInfoMask &bcsInfoMask, uint32_t &numHostLinkCopyEngines, uint32_t &numScaleUpLinkCopyEngines); + + std::vector tileToEngineToInstanceMap; + std::multimap tileToEngineMap; }; -inline EngineInfo::~EngineInfo() {} - } // namespace NEO diff --git a/shared/source/os_interface/linux/engine_info_extended.cpp b/shared/source/os_interface/linux/engine_info_extended.cpp new file mode 100644 index 0000000000..2781826cee --- /dev/null +++ b/shared/source/os_interface/linux/engine_info_extended.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/helpers/bit_helpers.h" +#include "shared/source/helpers/debug_helpers.h" +#include "shared/source/helpers/engine_node_helper.h" +#include "shared/source/os_interface/linux/engine_info.h" + +namespace NEO { + +aub_stream::EngineType EngineInfo::getBaseCopyEngineType(uint64_t capabilities) { + return aub_stream::EngineType::ENGINE_BCS; +} + +void EngineInfo::assignCopyEngine(aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine, + BcsInfoMask &bcsInfoMask, uint32_t &numHostLinkCopyEngines, uint32_t &numScaleUpLinkCopyEngines) { + // Main copy engine: + UNRECOVERABLE_IF(baseEngineType != aub_stream::ENGINE_BCS); + UNRECOVERABLE_IF(bcsInfoMask.test(0)); + tileToEngineToInstanceMap[tileId][aub_stream::ENGINE_BCS] = engine; + bcsInfoMask.set(0, true); +} +} // namespace NEO diff --git a/shared/source/os_interface/linux/engine_info_impl.h b/shared/source/os_interface/linux/engine_info_impl.h deleted file mode 100644 index 93fde4af22..0000000000 --- a/shared/source/os_interface/linux/engine_info_impl.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Copyright (C) 2020-2022 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once -#include "shared/source/helpers/basic_math.h" -#include "shared/source/helpers/debug_helpers.h" -#include "shared/source/os_interface/linux/drm_neo.h" -#include "shared/source/os_interface/linux/engine_info.h" -#include "shared/source/os_interface/linux/ioctl_helper.h" - -#include "drm/i915_drm.h" - -#include -#include -#include - -namespace NEO { - -struct EngineInfoImpl : public EngineInfo { - ~EngineInfoImpl() override = default; - - EngineInfoImpl(const std::vector &engineInfos) : engines(engineInfos) { - } - - std::vector engines; -}; - -} // namespace NEO diff --git a/shared/source/os_interface/linux/ioctl_helper.h b/shared/source/os_interface/linux/ioctl_helper.h index 6786fcd4de..bac0de6b9a 100644 --- a/shared/source/os_interface/linux/ioctl_helper.h +++ b/shared/source/os_interface/linux/ioctl_helper.h @@ -70,6 +70,7 @@ class IoctlHelper { virtual int32_t getEngineInfoIoctlVal() = 0; virtual std::vector translateToEngineCaps(const std::vector &data) = 0; virtual uint32_t queryDistances(Drm *drm, std::vector &queryItems, std::vector &distanceInfos) = 0; + virtual int32_t getComputeEngineClass() = 0; }; class IoctlHelperUpstream : public IoctlHelper { @@ -90,6 +91,7 @@ class IoctlHelperUpstream : public IoctlHelper { int32_t getEngineInfoIoctlVal() override; std::vector translateToEngineCaps(const std::vector &data) override; uint32_t queryDistances(Drm *drm, std::vector &queryItems, std::vector &distanceInfos) override; + int32_t getComputeEngineClass() override; }; template @@ -121,6 +123,7 @@ class IoctlHelperPrelim20 : public IoctlHelper { int32_t getEngineInfoIoctlVal() override; std::vector translateToEngineCaps(const std::vector &data) override; uint32_t queryDistances(Drm *drm, std::vector &queryItems, std::vector &distanceInfos) override; + int32_t getComputeEngineClass() override; }; } // namespace NEO diff --git a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp index 16240e193b..a90d07b41b 100644 --- a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp +++ b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp @@ -235,4 +235,8 @@ uint32_t IoctlHelperPrelim20::queryDistances(Drm *drm, std::vector #include @@ -215,7 +216,9 @@ class DrmMockEngine : public DrmMock { uint32_t i915QuerySuccessCount = std::numeric_limits::max(); uint32_t queryEngineInfoSuccessCount = std::numeric_limits::max(); - DrmMockEngine(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMock(rootDeviceEnvironment) {} + DrmMockEngine(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMock(rootDeviceEnvironment) { + rootDeviceEnvironment.setHwInfo(defaultHwInfo.get()); + } int handleRemainingRequests(unsigned long request, void *arg) override;