intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 14:02:58 +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

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

@@ -966,7 +966,7 @@ int Drm::waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWi
}
bool Drm::querySystemInfo() {
auto request = ioctlHelper->getHwConfigIoctlVal();
auto request = ioctlHelper->getDrmParamValue(DrmParam::QueryHwconfigTable);
auto deviceBlobQuery = this->query(request, 0);
if (deviceBlobQuery.empty()) {
PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stdout, "%s", "INFO: System Info query failed!\n");
@@ -991,7 +991,8 @@ bool Drm::queryMemoryInfo() {
}
bool Drm::queryEngineInfo(bool isSysmanEnabled) {
auto enginesQuery = this->query(ioctlHelper->getEngineInfoIoctlVal(), 0);
auto request = ioctlHelper->getDrmParamValue(DrmParam::QueryEngineInfo);
auto enginesQuery = this->query(request, 0);
if (enginesQuery.empty()) {
return false;
}

2
shared/source/os_interface/linux/drm_wrappers.h
View File

@@ -244,6 +244,8 @@ enum class DrmParam {
EngineClassVideoEnhance,
EngineClassInvalid,
EngineClassInvalidNone,
QueryEngineInfo,
QueryHwconfigTable,
};
unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest, IoctlHelper *ioctlHelper);

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

@@ -78,14 +78,12 @@ class IoctlHelper {
virtual CacheRegion closFree(Drm *drm, CacheRegion closIndex) = 0;
virtual int waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) = 0;
virtual uint32_t getHwConfigIoctlVal() = 0;
virtual uint32_t getAtomicAdvise(bool isNonAtomic) = 0;
virtual uint32_t getPreferredLocationAdvise() = 0;
virtual bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) = 0;
virtual bool setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) = 0;
virtual uint32_t getDirectSubmissionFlag() = 0;
virtual int32_t getMemRegionsIoctlVal() = 0;
virtual int32_t getEngineInfoIoctlVal() = 0;
virtual uint32_t getComputeSlicesIoctlVal() = 0;
virtual std::unique_ptr<uint8_t[]> prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) = 0;
virtual uint64_t getFlagsForVmBind(bool bindCapture, bool bindImmediate, bool bindMakeResident) = 0;
@@ -139,14 +137,12 @@ class IoctlHelperUpstream : public IoctlHelper {
CacheRegion closFree(Drm *drm, CacheRegion closIndex) override;
int waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) override;
uint32_t getHwConfigIoctlVal() override;
uint32_t getAtomicAdvise(bool isNonAtomic) override;
uint32_t getPreferredLocationAdvise() override;
bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override;
bool setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) override;
uint32_t getDirectSubmissionFlag() override;
int32_t getMemRegionsIoctlVal() override;
int32_t getEngineInfoIoctlVal() override;
uint32_t getComputeSlicesIoctlVal() override;
std::unique_ptr<uint8_t[]> prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) override;
uint64_t getFlagsForVmBind(bool bindCapture, bool bindImmediate, bool bindMakeResident) override;
@@ -205,14 +201,12 @@ class IoctlHelperPrelim20 : public IoctlHelper {
CacheRegion closFree(Drm *drm, CacheRegion closIndex) override;
int waitUserFence(Drm *drm, uint32_t ctxId, uint64_t address,
uint64_t value, uint32_t dataWidth, int64_t timeout, uint16_t flags) override;
uint32_t getHwConfigIoctlVal() override;
uint32_t getAtomicAdvise(bool isNonAtomic) override;
uint32_t getPreferredLocationAdvise() override;
bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override;
bool setVmPrefetch(Drm *drm, uint64_t start, uint64_t length, uint32_t region) override;
uint32_t getDirectSubmissionFlag() override;
int32_t getMemRegionsIoctlVal() override;
int32_t getEngineInfoIoctlVal() override;
uint32_t getComputeSlicesIoctlVal() override;
std::unique_ptr<uint8_t[]> prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) override;
uint64_t getFlagsForVmBind(bool bindCapture, bool bindImmediate, bool bindMakeResident) override;

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

@@ -175,10 +175,6 @@ int IoctlHelperPrelim20::waitUserFence(Drm *drm, uint32_t ctxId, uint64_t addres
return IoctlHelper::ioctl(drm, DrmIoctl::GemWaitUserFence, &wait);
}
uint32_t IoctlHelperPrelim20::getHwConfigIoctlVal() {
return PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE;
}
uint32_t IoctlHelperPrelim20::getAtomicAdvise(bool isNonAtomic) {
return isNonAtomic ? PRELIM_I915_VM_ADVISE_ATOMIC_NONE : PRELIM_I915_VM_ADVISE_ATOMIC_SYSTEM;
}
@@ -231,10 +227,6 @@ int32_t IoctlHelperPrelim20::getMemRegionsIoctlVal() {
return PRELIM_DRM_I915_QUERY_MEMORY_REGIONS;
}
int32_t IoctlHelperPrelim20::getEngineInfoIoctlVal() {
return PRELIM_DRM_I915_QUERY_ENGINE_INFO;
}
uint32_t IoctlHelperPrelim20::getComputeSlicesIoctlVal() {
return PRELIM_DRM_I915_QUERY_COMPUTE_SLICES;
}
@@ -636,6 +628,10 @@ int IoctlHelperPrelim20::getDrmParamValue(DrmParam drmParam) const {
switch (drmParam) {
case DrmParam::EngineClassCompute:
return PRELIM_I915_ENGINE_CLASS_COMPUTE;
case DrmParam::QueryEngineInfo:
return PRELIM_DRM_I915_QUERY_ENGINE_INFO;
case DrmParam::QueryHwconfigTable:
return PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE;
default:
return getDrmParamValueBase(drmParam);
}

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

@@ -87,10 +87,6 @@ int IoctlHelperUpstream::waitUserFence(Drm *drm, uint32_t ctxId, uint64_t addres
return 0;
}
uint32_t IoctlHelperUpstream::getHwConfigIoctlVal() {
return DRM_I915_QUERY_HWCONFIG_TABLE;
}
uint32_t IoctlHelperUpstream::getAtomicAdvise(bool isNonAtomic) {
return 0;
}
@@ -115,10 +111,6 @@ int32_t IoctlHelperUpstream::getMemRegionsIoctlVal() {
return DRM_I915_QUERY_MEMORY_REGIONS;
}
int32_t IoctlHelperUpstream::getEngineInfoIoctlVal() {
return DRM_I915_QUERY_ENGINE_INFO;
}
uint32_t IoctlHelperUpstream::getComputeSlicesIoctlVal() {
return 0;
}
@@ -296,6 +288,10 @@ int IoctlHelperUpstream::getDrmParamValue(DrmParam drmParam) const {
switch (drmParam) {
case DrmParam::EngineClassCompute:
return 4;
case DrmParam::QueryEngineInfo:
return DRM_I915_QUERY_ENGINE_INFO;
case DrmParam::QueryHwconfigTable:
return DRM_I915_QUERY_HWCONFIG_TABLE;
default:
return getDrmParamValueBase(drmParam);
}

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