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

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 <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek 2022-01-04 14:48:05 +00:00 committed by Compute-Runtime-Automation
parent 54d377d025
commit 26a24e8fde
18 changed files with 651 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp
View File

@ -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::set<std::pair<zes_engine
if (pDrm->sysmanQueryEngineInfo() == false) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto engineInfo = static_cast<NEO::EngineInfoImpl *>(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++) {

5
level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h
View File

@ -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<EngineNeoDrm> : 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;
}

12
level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp
View File

@ -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<DrmMockEngine>((const_cast<NEO::RootDeviceEnvironment &>(neoDevice->getRootDeviceEnvironment())));
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
drm->sysmanQueryEngineInfo();
auto engineInfo = static_cast<EngineInfoImpl *>(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<DrmMockEngine>((const_cast<NEO::RootDeviceEnvironment &>(neoDevice->getRootDeviceEnvironment())));
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> memRegions{
{{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}};
drm->memoryInfo.reset(new MemoryInfo(memRegions));
drm->sysmanQueryEngineInfo();
auto engineInfo = static_cast<EngineInfoImpl *>(drm->getEngineInfo());
auto engineInfo = drm->getEngineInfo();
ASSERT_NE(nullptr, engineInfo);
EXPECT_EQ(2u, engineInfo->engines.size());
}

167
opencl/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp
View File

@ -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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> 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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->queryEngineInfo();
EXPECT_EQ(2u, drm->ioctlCallsCount);
auto engineInfo = drm->getEngineInfo();
auto engineInfo = static_cast<EngineInfoImpl *>(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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> 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<EngineInfo>(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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> 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<EngineInfo>(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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> 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<DistanceInfo> 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<drm_i915_query_item> 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<EngineInfo>(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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> 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<DistanceInfo> 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<drm_i915_query_item> queryItems{distances.size()};
for (auto i = 0u; i < distances.size(); i++) {
queryItems[i].length = -1;
}
auto engineInfo = std::make_unique<EngineInfo>(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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto hwInfo = *defaultHwInfo.get();
std::vector<DistanceInfo> distances;
std::vector<EngineCapabilities> engines;
std::vector<drm_i915_query_item> queryItems;
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), &hwInfo, 0, distances, queryItems, engines);
EXPECT_EQ(0u, engineInfo->getEngineTileIndex({I915_ENGINE_CLASS_RENDER, 1}));
}

103
opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp
View File

@ -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<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions);
extern std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> 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<GT_MULTI_TILE_ARCH_INFO &>(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<EngineClassInstance> 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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> 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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> 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<EngineClassInstance> 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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
drm->queryDistanceIoctlRetVal = -1;
std::vector<MemoryRegion> 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);
}

40
opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp
View File

@ -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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> 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<EngineClassInstance> 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>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
ASSERT_NE(nullptr, drm);
std::vector<MemoryRegion> 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<EngineClassInstance> engines;
engineInfo->getListOfEnginesOnATile(0, engines);
auto totalEnginesCount = engineInfo->engines.size();
ASSERT_NE(nullptr, engineInfo);
EXPECT_EQ(totalEnginesCount, engines.size());
}

27
opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp
View File

@ -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<prelim_drm_i915_gem_create_ext *>(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<drm_i915_query_item *>(query->items_ptr) + i;
if (queryItemPtr->query_id == PRELIM_DRM_I915_QUERY_DISTANCE_INFO) {
if (queryDistanceIoctlRetVal != 0) {
return queryDistanceIoctlRetVal;
}
auto distance = reinterpret_cast<prelim_drm_i915_query_distance_info *>(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<prelim_drm_i915_query_engine_info *>(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;
}
}
}

5
shared/source/os_interface/linux/CMakeLists.txt
View File

@ -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

83
shared/source/os_interface/linux/drm_neo.cpp
View File

@ -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<DistanceInfo> distanceInfos;
for (const auto &region : 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<drm_i915_query_item> 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<GT_MULTI_TILE_ARCH_INFO &>(hwInfo->gtSystemInfo.MultiTileArchInfo);
multiTileArchInfo.IsValid = true;
multiTileArchInfo.TileCount = tileCount;
multiTileArchInfo.TileMask = static_cast<uint8_t>(maxNBitValue(tileCount));
this->engineInfo.reset(new EngineInfo(this, hwInfo, tileCount, distanceInfos, queryItems, engines));
return true;
}
} // namespace NEO

13
shared/source/os_interface/linux/drm_query.cpp
View File

@ -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);
}

145
shared/source/os_interface/linux/engine_info.cpp Normal file
View File

@ -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 <array>
namespace NEO {
namespace DrmEngineMappingHelper {
constexpr std::array<aub_stream::EngineType, 9> 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<EngineCapabilities> &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::EngineType>(aub_stream::ENGINE_CCS + computeEngines)] = engine;
computeEngines++;
}
break;
}
}
setSupportedEngiesInfo(hwInfo, computeEngines, bcsInfoMask);
}
EngineInfo::EngineInfo(Drm *drm, HardwareInfo *hwInfo, uint32_t tileCount, const std::vector<DistanceInfo> &distanceInfos, const std::vector<drm_i915_query_item> &queryItems, const std::vector<EngineCapabilities> &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::EngineType>(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<uint32_t>(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<EngineClassInstance> &listOfEngines) {
auto range = tileToEngineMap.equal_range(tile);
for (auto itr = range.first; itr != range.second; ++itr) {
listOfEngines.push_back(itr->second);
}
}
} // namespace NEO

40
shared/source/os_interface/linux/engine_info.h
View File

@ -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 <cstdint>
#include <map>
#include <vector>
namespace NEO {
struct HardwareInfo;
class Drm;
struct EngineInfo {
EngineInfo() = default;
virtual ~EngineInfo() = 0;
public:
using EngineToInstanceMap = std::map<aub_stream::EngineType, EngineClassInstance>;
EngineInfo(Drm *drm, HardwareInfo *hwInfo, const std::vector<EngineCapabilities> &engineInfos);
EngineInfo(Drm *drm, HardwareInfo *hwInfo, uint32_t tileCount, const std::vector<DistanceInfo> &distanceInfos, const std::vector<drm_i915_query_item> &queryItems, const std::vector<EngineCapabilities> &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<EngineClassInstance> &listOfEngines);
std::vector<EngineCapabilities> 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<EngineToInstanceMap> tileToEngineToInstanceMap;
std::multimap<uint32_t, EngineClassInstance> tileToEngineMap;
};
inline EngineInfo::~EngineInfo() {}
} // namespace NEO

27
shared/source/os_interface/linux/engine_info_extended.cpp Normal file
View File

@ -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

32
shared/source/os_interface/linux/engine_info_impl.h
View File

@ -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 <cstddef>
#include <cstdint>
#include <vector>
namespace NEO {
struct EngineInfoImpl : public EngineInfo {
~EngineInfoImpl() override = default;
EngineInfoImpl(const std::vector<EngineCapabilities> &engineInfos) : engines(engineInfos) {
}
std::vector<EngineCapabilities> engines;
};
} // namespace NEO

3
shared/source/os_interface/linux/ioctl_helper.h
View File

@ -70,6 +70,7 @@ class IoctlHelper {
virtual int32_t getEngineInfoIoctlVal() = 0;
virtual std::vector<EngineCapabilities> translateToEngineCaps(const std::vector<uint8_t> &data) = 0;
virtual uint32_t queryDistances(Drm *drm, std::vector<drm_i915_query_item> &queryItems, std::vector<DistanceInfo> &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<EngineCapabilities> translateToEngineCaps(const std::vector<uint8_t> &data) override;
uint32_t queryDistances(Drm *drm, std::vector<drm_i915_query_item> &queryItems, std::vector<DistanceInfo> &distanceInfos) override;
int32_t getComputeEngineClass() override;
};
template <PRODUCT_FAMILY gfxProduct>
@ -121,6 +123,7 @@ class IoctlHelperPrelim20 : public IoctlHelper {
int32_t getEngineInfoIoctlVal() override;
std::vector<EngineCapabilities> translateToEngineCaps(const std::vector<uint8_t> &data) override;
uint32_t queryDistances(Drm *drm, std::vector<drm_i915_query_item> &queryItems, std::vector<DistanceInfo> &distanceInfos) override;
int32_t getComputeEngineClass() override;
};
} // namespace NEO

4
shared/source/os_interface/linux/ioctl_helper_prelim.cpp
View File

@ -235,4 +235,8 @@ uint32_t IoctlHelperPrelim20::queryDistances(Drm *drm, std::vector<drm_i915_quer
return ret;
}
int32_t IoctlHelperPrelim20::getComputeEngineClass() {
return PRELIM_I915_ENGINE_CLASS_COMPUTE;
}
} // namespace NEO

4
shared/source/os_interface/linux/ioctl_helper_upstream.cpp
View File

@ -126,4 +126,8 @@ uint32_t IoctlHelperUpstream::queryDistances(Drm *drm, std::vector<drm_i915_quer
return 0;
}
int32_t IoctlHelperUpstream::getComputeEngineClass() {
return 4;
}
} // namespace NEO

7
shared/test/common/libult/linux/drm_mock.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,6 +11,7 @@
#include "shared/source/helpers/hw_helper.h"
#include "shared/source/helpers/string.h"
#include "shared/source/os_interface/linux/drm_neo.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include <cstdio>
#include <fstream>
@ -215,7 +216,9 @@ class DrmMockEngine : public DrmMock {
uint32_t i915QuerySuccessCount = std::numeric_limits<uint32_t>::max();
uint32_t queryEngineInfoSuccessCount = std::numeric_limits<uint32_t>::max();
DrmMockEngine(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMock(rootDeviceEnvironment) {}
DrmMockEngine(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(defaultHwInfo.get());
}
int handleRemainingRequests(unsigned long request, void *arg) override;