intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-04 07:14:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move query hwconfig table and engine info to DrmParam enum

Browse Source 
Related-To: NEO-6852, NEO-6999
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-06-01 16:03:01 +00:00
committed by Compute-Runtime-Automation
parent 1cffe921ba
commit c4bb209f91
13 changed files with 93 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shared/test/common/libult/linux/CMakeLists.txt
View File

@@ -9,7 +9,7 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/drm_mock.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_mock.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_mock_engine.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_mock_engine.cpp
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)

11
shared/test/common/libult/linux/drm_mock_engine.cpp
View File

@@ -11,8 +11,7 @@
#include "gtest/gtest.h"
void DrmMockEngine::handleQueryItem(QueryItem *queryItem) {
switch (queryItem->queryId) {
case DRM_I915_QUERY_ENGINE_INFO:
if (queryItem->queryId == static_cast<uint64_t>(ioctlHelper->getDrmParamValue(DrmParam::QueryEngineInfo))) {
if (queryEngineInfoSuccessCount == 0) {
queryItem->length = -EINVAL;
} else {
@@ -26,14 +25,13 @@ void DrmMockEngine::handleQueryItem(QueryItem *queryItem) {
auto queryEnginenInfo = reinterpret_cast<drm_i915_query_engine_info *>(queryItem->dataPtr);
EXPECT_EQ(0u, queryEnginenInfo->num_engines);
queryEnginenInfo->num_engines = numberOfEngines;
queryEnginenInfo->engines[0].engine.engine_class = I915_ENGINE_CLASS_RENDER;
queryEnginenInfo->engines[0].engine.engine_class = static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender));
queryEnginenInfo->engines[0].engine.engine_instance = 1;
queryEnginenInfo->engines[1].engine.engine_class = I915_ENGINE_CLASS_COPY;
queryEnginenInfo->engines[1].engine.engine_class = static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy));
queryEnginenInfo->engines[1].engine.engine_instance = 1;
}
}
break;
case DRM_I915_QUERY_HWCONFIG_TABLE: {
} else if (queryItem->queryId == static_cast<uint64_t>(ioctlHelper->getDrmParamValue(DrmParam::QueryHwconfigTable))) {
if (failQueryDeviceBlob) {
queryItem->length = -EINVAL;
} else {
@@ -46,6 +44,5 @@ void DrmMockEngine::handleQueryItem(QueryItem *queryItem) {
memcpy(deviceBlobData, &dummyDeviceBlobData, deviceBlobSize);
}
}
} break;
}
}

33
shared/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp
View File

@@ -56,12 +56,13 @@ TEST(EngineInfoTest, whenCreateEngineInfoWithRcsThenCorrectHwInfoSet) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> engines(2);
engines[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 0};
engines[0].capabilities = 0;
engines[1].engine = {I915_ENGINE_CLASS_COPY, 0};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 0};
engines[1].capabilities = 0;
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), &hwInfo, engines);
@@ -76,13 +77,14 @@ TEST(EngineInfoTest, whenCreateEngineInfoWithCcsThenCorrectHwInfoSet) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> engines(2);
uint16_t ccsClass = drm->getIoctlHelper()->getDrmParamValue(DrmParam::EngineClassCompute);
uint16_t ccsClass = ioctlHelper->getDrmParamValue(DrmParam::EngineClassCompute);
engines[0].engine = {ccsClass, 0};
engines[0].capabilities = 0;
engines[1].engine = {I915_ENGINE_CLASS_COPY, 0};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 0};
engines[1].capabilities = 0;
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), &hwInfo, engines);
@@ -97,16 +99,17 @@ TEST(EngineInfoTest, whenGetEngineInstanceAndTileThenCorrectValuesReturned) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> engines(4);
engines[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 0};
engines[0].capabilities = 0;
engines[1].engine = {I915_ENGINE_CLASS_COPY, 0};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 0};
engines[1].capabilities = 0;
engines[2].engine = {I915_ENGINE_CLASS_RENDER, 1};
engines[2].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 1};
engines[2].capabilities = 0;
engines[3].engine = {I915_ENGINE_CLASS_COPY, 1};
engines[3].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 1};
engines[3].capabilities = 0;
std::vector<DistanceInfo> distances(4);
@@ -140,23 +143,24 @@ TEST(EngineInfoTest, whenGetEngineInstanceAndTileThenCorrectValuesReturned) {
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}));
EXPECT_EQ(0u, engineInfo->getEngineTileIndex({static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 2}));
}
TEST(EngineInfoTest, whenCreateEngineInfoAndInvalidQueryThenNoEnginesSet) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto hwInfo = *defaultHwInfo.get();
std::vector<EngineCapabilities> engines(4);
engines[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 0};
engines[0].capabilities = 0;
engines[1].engine = {I915_ENGINE_CLASS_COPY, 0};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 0};
engines[1].capabilities = 0;
engines[2].engine = {I915_ENGINE_CLASS_RENDER, 1};
engines[2].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 1};
engines[2].capabilities = 0;
engines[3].engine = {I915_ENGINE_CLASS_COPY, 1};
engines[3].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 1};
engines[3].capabilities = 0;
std::vector<DistanceInfo> distances(4);
@@ -181,6 +185,7 @@ TEST(EngineInfoTest, whenEmptyEngineInfoCreatedThen0TileReturned) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
auto ioctlHelper = drm->getIoctlHelper();
auto hwInfo = *defaultHwInfo.get();
std::vector<DistanceInfo> distances;
@@ -188,5 +193,5 @@ TEST(EngineInfoTest, whenEmptyEngineInfoCreatedThen0TileReturned) {
std::vector<QueryItem> queryItems;
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), &hwInfo, 0, distances, queryItems, engines);
EXPECT_EQ(0u, engineInfo->getEngineTileIndex({I915_ENGINE_CLASS_RENDER, 1}));
EXPECT_EQ(0u, engineInfo->getEngineTileIndex({static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 1}));
}

36
shared/test/unit_test/os_interface/linux/drm_tests.cpp
View File

@@ -1238,3 +1238,39 @@ TEST(IoctlHelperTest, whenGettingDrmParamValueThenProperValueIsReturned) {
EXPECT_THROW(ioctlHelper->getDrmParamValueBase(DrmParam::EngineClassCompute), std::runtime_error);
}
TEST(DistanceInfoTest, givenDistanceInfosWhenAssignRegionsFromDistancesThenCorrectRegionsSet) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
auto ioctlHelper = drm.getIoctlHelper();
std::vector<MemoryRegion> memRegions(4);
memRegions[0] = {{I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0};
memRegions[1] = {{I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0};
memRegions[2] = {{I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0};
memRegions[3] = {{I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0};
auto memoryInfo = std::make_unique<MemoryInfo>(memRegions);
std::vector<EngineClassInstance> engines(3);
engines[0] = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 0};
engines[1] = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 0};
engines[2] = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 2};
auto distances = std::vector<DistanceInfo>();
for (const auto &region : memRegions) {
if (region.region.memoryClass == I915_MEMORY_CLASS_SYSTEM) {
continue;
}
for (const auto &engine : engines) {
DistanceInfo dist{};
dist.engine = engine;
dist.region = {region.region.memoryClass, region.region.memoryInstance};
dist.distance = (region.region.memoryInstance == engine.engineInstance) ? 0 : 100;
distances.push_back(dist);
}
}
memoryInfo->assignRegionsFromDistances(distances);
EXPECT_EQ(1024u, memoryInfo->getMemoryRegionSize(1));
EXPECT_EQ(1024u, memoryInfo->getMemoryRegionSize(2));
EXPECT_EQ(0u, memoryInfo->getMemoryRegionSize(4));
}

9
shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp
View File

@@ -307,15 +307,16 @@ TEST_F(IoctlHelperPrelimFixture, givenVariousDirectSubmissionFlagSettingWhenCrea
}
TEST_F(IoctlHelperPrelimFixture, givenPrelimsWhenQueryDistancesThenCorrectDistanceSet) {
auto ioctlHelper = drm->getIoctlHelper();
std::vector<DistanceInfo> distances(3);
distances[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
distances[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 0};
distances[0].region = {I915_MEMORY_CLASS_DEVICE, 0};
distances[1].engine = {I915_ENGINE_CLASS_RENDER, 1};
distances[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassRender)), 1};
distances[1].region = {I915_MEMORY_CLASS_DEVICE, 1};
distances[2].engine = {I915_ENGINE_CLASS_COPY, 4};
distances[2].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy)), 4};
distances[2].region = {I915_MEMORY_CLASS_DEVICE, 2};
std::vector<QueryItem> queryItems(distances.size());
auto ret = drm->getIoctlHelper()->queryDistances(drm.get(), queryItems, distances);
auto ret = ioctlHelper->queryDistances(drm.get(), queryItems, distances);
EXPECT_EQ(0u, ret);
EXPECT_EQ(0, distances[0].distance);
EXPECT_EQ(0, distances[1].distance);

18
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp
View File

@@ -62,6 +62,12 @@ TEST_F(IoctlPrelimHelperTests, whenGettingIoctlRequestValueThenPropertValueIsRet
EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), std::runtime_error);
}
TEST_F(IoctlPrelimHelperTests, whenGettingDrmParamValueThenPropertValueIsReturned) {
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::EngineClassCompute), static_cast<int>(PRELIM_I915_ENGINE_CLASS_COMPUTE));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryEngineInfo), static_cast<int>(PRELIM_DRM_I915_QUERY_ENGINE_INFO));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryHwconfigTable), static_cast<int>(PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE));
}
TEST_F(IoctlPrelimHelperTests, givenIoctlParamWhenParseToStringThenProperStringIsReturned) {
for (auto &ioctlParamCodeString : ioctlParamCodeStringMap) {
EXPECT_STREQ(IoctlToStringHelper::getIoctlParamString(ioctlParamCodeString.first).c_str(), ioctlParamCodeString.second);
@@ -178,10 +184,6 @@ TEST_F(IoctlPrelimHelperTests, whenGettingVmBindExtFromHandlesThenProperStructsA
EXPECT_EQ(reinterpret_cast<uintptr_t>(&vmBindExt[2]), vmBindExt[1].base.next_extension);
}
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetHwConfigIoctlValThenCorrectValueReturned) {
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE), ioctlHelper.getHwConfigIoctlVal());
}
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetDirectSubmissionFlagThenCorrectValueReturned) {
EXPECT_EQ(PRELIM_I915_CONTEXT_CREATE_FLAGS_LONG_RUNNING, ioctlHelper.getDirectSubmissionFlag());
}
@@ -190,14 +192,10 @@ TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetMemRegionsIoctlValThenCorrectV
EXPECT_EQ(PRELIM_DRM_I915_QUERY_MEMORY_REGIONS, ioctlHelper.getMemRegionsIoctlVal());
}
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetEngineInfoIoctlValThenCorrectValueReturned) {
EXPECT_EQ(PRELIM_DRM_I915_QUERY_ENGINE_INFO, ioctlHelper.getEngineInfoIoctlVal());
}
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenTranslateToEngineCapsThenReturnSameData) {
std::vector<EngineCapabilities> expectedEngines(2);
expectedEngines[0] = {{I915_ENGINE_CLASS_RENDER, 0}, 0};
expectedEngines[1] = {{I915_ENGINE_CLASS_COPY, 1}, 0};
expectedEngines[0] = {{static_cast<uint16_t>(ioctlHelper.getDrmParamValue(DrmParam::EngineClassRender)), 0}, 0};
expectedEngines[1] = {{static_cast<uint16_t>(ioctlHelper.getDrmParamValue(DrmParam::EngineClassCopy)), 1}, 0};
auto engineInfo = getEngineInfo(expectedEngines);

15
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp
View File

@@ -58,6 +58,13 @@ TEST(IoctlHelperUpstreamTest, whenGettingIoctlRequestValueThenPropertValueIsRetu
EXPECT_THROW(ioctlHelper.getIoctlRequestValue(DrmIoctl::DG1GemCreateExt), std::runtime_error);
}
TEST(IoctlHelperUpstreamTest, whenGettingDrmParamValueThenPropertValueIsReturned) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::EngineClassCompute), 4);
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryEngineInfo), static_cast<int>(DRM_I915_QUERY_ENGINE_INFO));
EXPECT_EQ(ioctlHelper.getDrmParamValue(DrmParam::QueryHwconfigTable), static_cast<int>(DRM_I915_QUERY_HWCONFIG_TABLE));
}
TEST(IoctlHelperUpstreamTest, whenCreatingVmControlRegionExtThenNullptrIsReturned) {
IoctlHelperUpstream ioctlHelper{};
std::optional<MemoryClassInstance> regionInstanceClass = MemoryClassInstance{};
@@ -225,14 +232,6 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetMemRegionsIoctlValThenCorrect
EXPECT_EQ(DRM_I915_QUERY_MEMORY_REGIONS, drm->getIoctlHelper()->getMemRegionsIoctlVal());
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetEngineInfoIoctlValThenCorrectValueReturned) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
EXPECT_EQ(DRM_I915_QUERY_ENGINE_INFO, drm->getIoctlHelper()->getEngineInfoIoctlVal());
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryDistancesThenReturnEinval) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);