Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use queryEngineInfo with prelim ioctls

Browse Source 
If prelim kernel is being used, query engines
with prelim ioctls.

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2022-01-03 14:16:00 +00:00
committed by Compute-Runtime-Automation
parent a18c706408
commit 6258575e5e
10 changed files with 218 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -36,10 +36,10 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine
} }
auto engineInfo = static_cast<NEO::EngineInfoImpl *>(pDrm->getEngineInfo()); auto engineInfo = static_cast<NEO::EngineInfoImpl *>(pDrm->getEngineInfo());
for (auto itr = engineInfo->engines.begin(); itr != engineInfo->engines.end(); ++itr) { for (auto itr = engineInfo->engines.begin(); itr != engineInfo->engines.end(); ++itr) {
auto i915ToEngineMapRange = i915ToEngineMap.equal_range(static_cast<__u16>(itr->engine.engine_class)); auto i915ToEngineMapRange = i915ToEngineMap.equal_range(static_cast<__u16>(itr->engine.engineClass));
for (auto L0EngineEntryInMap = i915ToEngineMapRange.first; L0EngineEntryInMap != i915ToEngineMapRange.second; L0EngineEntryInMap++) { for (auto L0EngineEntryInMap = i915ToEngineMapRange.first; L0EngineEntryInMap != i915ToEngineMapRange.second; L0EngineEntryInMap++) {
auto L0EngineType = L0EngineEntryInMap->second; auto L0EngineType = L0EngineEntryInMap->second;
engineGroupInstance.insert({L0EngineType, {static_cast<uint32_t>(itr->engine.engine_instance), 0}}); engineGroupInstance.insert({L0EngineType, {static_cast<uint32_t>(itr->engine.engineInstance), 0}});
} }
} }
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -40,21 +40,21 @@ struct Mock<EngineNeoDrm> : public EngineNeoDrm {
Mock<EngineNeoDrm>(RootDeviceEnvironment &rootDeviceEnvironment) : EngineNeoDrm(rootDeviceEnvironment) {} Mock<EngineNeoDrm>(RootDeviceEnvironment &rootDeviceEnvironment) : EngineNeoDrm(rootDeviceEnvironment) {}
bool queryEngineInfoMockPositiveTest() { bool queryEngineInfoMockPositiveTest() {
drm_i915_engine_info i915engineInfo[6] = {}; std::vector<NEO::EngineCapabilities> i915engineInfo(6);
i915engineInfo[0].engine.engine_class = I915_ENGINE_CLASS_RENDER; i915engineInfo[0].engine.engineClass = I915_ENGINE_CLASS_RENDER;
i915engineInfo[0].engine.engine_instance = 0; i915engineInfo[0].engine.engineInstance = 0;
i915engineInfo[1].engine.engine_class = I915_ENGINE_CLASS_RENDER; i915engineInfo[1].engine.engineClass = I915_ENGINE_CLASS_RENDER;
i915engineInfo[1].engine.engine_instance = 1; i915engineInfo[1].engine.engineInstance = 1;
i915engineInfo[2].engine.engine_class = I915_ENGINE_CLASS_VIDEO; i915engineInfo[2].engine.engineClass = I915_ENGINE_CLASS_VIDEO;
i915engineInfo[2].engine.engine_instance = 1; i915engineInfo[2].engine.engineInstance = 1;
i915engineInfo[3].engine.engine_class = I915_ENGINE_CLASS_COPY; i915engineInfo[3].engine.engineClass = I915_ENGINE_CLASS_COPY;
i915engineInfo[3].engine.engine_instance = 0; i915engineInfo[3].engine.engineInstance = 0;
i915engineInfo[4].engine.engine_class = I915_ENGINE_CLASS_VIDEO_ENHANCE; i915engineInfo[4].engine.engineClass = I915_ENGINE_CLASS_VIDEO_ENHANCE;
i915engineInfo[4].engine.engine_instance = 0; i915engineInfo[4].engine.engineInstance = 0;
i915engineInfo[5].engine.engine_class = I915_INVALID_ENGINE_CLASS; i915engineInfo[5].engine.engineClass = I915_INVALID_ENGINE_CLASS;
i915engineInfo[5].engine.engine_instance = 0; i915engineInfo[5].engine.engineInstance = 0;
this->engineInfo.reset(new EngineInfoImpl(i915engineInfo, 6)); this->engineInfo.reset(new EngineInfoImpl(i915engineInfo));
return true; return true;
} }

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -17,6 +17,7 @@ using namespace NEO;
extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal); extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal);
extern std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions); extern std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions);
extern std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines);
class DrmPrelimMock : public DrmMock { class DrmPrelimMock : public DrmMock {
public: public:
@ -307,3 +308,51 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenGetMemRegionsIoctlValThenCorrectVal
int32_t ioctlVal = (1 << 16) | 4; int32_t ioctlVal = (1 << 16) | 4;
EXPECT_EQ(ioctlVal, IoctlHelper::get(drm.get())->getMemRegionsIoctlVal()); EXPECT_EQ(ioctlVal, IoctlHelper::get(drm.get())->getMemRegionsIoctlVal());
} }
TEST(IoctlHelperTestsPrelim, givenPrelimsWhenGetEngineInfoIoctlValThenCorrectValueReturned) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
int32_t ioctlVal = (1 << 16) | 13;
EXPECT_EQ(ioctlVal, IoctlHelper::get(drm.get())->getEngineInfoIoctlVal());
}
TEST(IoctlHelperTestsPrelim, givenPrelimsWhenTranslateToEngineCapsThenReturnSameData) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
std::vector<EngineCapabilities> expectedEngines(2);
expectedEngines[0] = {{I915_ENGINE_CLASS_RENDER, 0}, 0};
expectedEngines[1] = {{I915_ENGINE_CLASS_COPY, 1}, 0};
auto engineInfo = getEngineInfo(expectedEngines);
auto ioctlHelper = IoctlHelper::get(drm.get());
auto engines = ioctlHelper->translateToEngineCaps(engineInfo);
EXPECT_EQ(2u, engines.size());
for (uint32_t i = 0; i < engines.size(); i++) {
EXPECT_EQ(expectedEngines[i].engine.engineClass, engines[i].engine.engineClass);
EXPECT_EQ(expectedEngines[i].engine.engineInstance, engines[i].engine.engineInstance);
EXPECT_EQ(expectedEngines[i].capabilities, engines[i].capabilities);
}
}
TEST(IoctlHelperTestsPrelim, givenPrelimsWhenQueryDistancesThenCorrectDistanceSet) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmPrelimMock>(*executionEnvironment->rootDeviceEnvironments[0]);
std::vector<DistanceInfo> distances(3);
distances[0].engine = {I915_ENGINE_CLASS_RENDER, 0};
distances[0].region = {I915_MEMORY_CLASS_DEVICE, 0};
distances[1].engine = {I915_ENGINE_CLASS_RENDER, 1};
distances[1].region = {I915_MEMORY_CLASS_DEVICE, 1};
distances[2].engine = {I915_ENGINE_CLASS_COPY, 4};
distances[2].region = {I915_MEMORY_CLASS_DEVICE, 2};
std::vector<drm_i915_query_item> queryItems(distances.size());
auto ret = IoctlHelper::get(drm.get())->queryDistances(drm.get(), queryItems, distances);
EXPECT_EQ(0u, ret);
EXPECT_EQ(0, distances[0].distance);
EXPECT_EQ(0, distances[1].distance);
EXPECT_EQ(100, distances[2].distance);
}

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -124,3 +124,24 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetMemRegionsIoctlValThenCorrect
EXPECT_EQ(DRM_I915_QUERY_MEMORY_REGIONS, IoctlHelper::get(drm.get())->getMemRegionsIoctlVal()); EXPECT_EQ(DRM_I915_QUERY_MEMORY_REGIONS, IoctlHelper::get(drm.get())->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, IoctlHelper::get(drm.get())->getEngineInfoIoctlVal());
}
TEST(IoctlHelperTestsUpstream, givenUpstreamWhenQueryDistancesThenReturnEinval) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmTipMock>(*executionEnvironment->rootDeviceEnvironments[0]);
std::vector<DistanceInfo> distanceInfos;
std::vector<drm_i915_query_item> queries(4);
auto ret = IoctlHelper::get(drm.get())->queryDistances(drm.get(), queries, distanceInfos);
EXPECT_EQ(0u, ret);
const bool queryUnsupported = std::all_of(queries.begin(), queries.end(),
[](const drm_i915_query_item &item) { return item.length == -EINVAL; });
EXPECT_TRUE(queryUnsupported);
}

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -45,6 +45,18 @@ int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal) {
} else if (request == PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE) { } else if (request == PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE) {
auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg); auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
closReserveArg->clos_index = 1u; closReserveArg->clos_index = 1u;
} else if (request == DRM_IOCTL_I915_QUERY) {
auto query = static_cast<drm_i915_query *>(arg);
if (query->items_ptr == 0) {
return EINVAL;
}
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) {
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;
}
}
} }
return ioctlRetVal; return ioctlRetVal;
} }
@ -64,3 +76,18 @@ std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions
} }
return data; return data;
} }
std::vector<uint8_t> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines) {
auto inputSize = static_cast<uint32_t>(inputEngines.size());
int length = sizeof(prelim_drm_i915_query_engine_info) + inputSize * sizeof(prelim_drm_i915_engine_info);
auto data = std::vector<uint8_t>(length);
auto memoryRegions = reinterpret_cast<prelim_drm_i915_query_engine_info *>(data.data());
memoryRegions->num_engines = inputSize;
for (uint32_t i = 0; i < inputSize; i++) {
memoryRegions->engines[i].engine.engine_class = inputEngines[i].engine.engineClass;
memoryRegions->engines[i].engine.engine_instance = inputEngines[i].engine.engineInstance;
memoryRegions->engines[i].capabilities = inputEngines[i].capabilities;
}
return data;
}

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -33,12 +33,13 @@ std::string getIoctlParamStringRemaining(int param) {
} // namespace IoctlToStringHelper } // namespace IoctlToStringHelper
bool Drm::queryEngineInfo(bool isSysmanEnabled) { bool Drm::queryEngineInfo(bool isSysmanEnabled) {
auto dataQuery = this->query(DRM_I915_QUERY_ENGINE_INFO, DrmQueryItemFlags::empty); auto ioctlHelper = IoctlHelper::get(this);
auto dataQuery = this->query(ioctlHelper->getEngineInfoIoctlVal(), DrmQueryItemFlags::empty);
if (dataQuery.empty()) { if (dataQuery.empty()) {
return false; return false;
} }
auto data = reinterpret_cast<drm_i915_query_engine_info *>(dataQuery.data()); auto engines = ioctlHelper->translateToEngineCaps(dataQuery);
this->engineInfo.reset(new EngineInfoImpl(data->engines, data->num_engines)); this->engineInfo.reset(new EngineInfoImpl(engines));
return true; return true;
} }

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -10,6 +10,7 @@
#include "shared/source/helpers/debug_helpers.h" #include "shared/source/helpers/debug_helpers.h"
#include "shared/source/os_interface/linux/drm_neo.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/engine_info.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "drm/i915_drm.h" #include "drm/i915_drm.h"
@ -22,10 +23,10 @@ namespace NEO {
struct EngineInfoImpl : public EngineInfo { struct EngineInfoImpl : public EngineInfo {
~EngineInfoImpl() override = default; ~EngineInfoImpl() override = default;
EngineInfoImpl(const drm_i915_engine_info *engineInfo, size_t count) : engines(engineInfo, engineInfo + count) { EngineInfoImpl(const std::vector<EngineCapabilities> &engineInfos) : engines(engineInfos) {
} }
std::vector<drm_i915_engine_info> engines; std::vector<EngineCapabilities> engines;
}; };
} // namespace NEO } // namespace NEO

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -13,6 +13,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
struct drm_i915_query_item;
namespace NEO { namespace NEO {
class Drm; class Drm;
class IoctlHelper; class IoctlHelper;
@ -36,6 +37,11 @@ struct MemoryRegion {
uint64_t unallocatedSize; uint64_t unallocatedSize;
}; };
struct EngineCapabilities {
EngineClassInstance engine;
uint64_t capabilities;
};
struct DistanceInfo { struct DistanceInfo {
MemoryClassInstance region; MemoryClassInstance region;
EngineClassInstance engine; EngineClassInstance engine;
@ -61,6 +67,9 @@ class IoctlHelper {
virtual bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) = 0; virtual bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) = 0;
virtual uint32_t getDirectSubmissionFlag() = 0; virtual uint32_t getDirectSubmissionFlag() = 0;
virtual int32_t getMemRegionsIoctlVal() = 0; virtual int32_t getMemRegionsIoctlVal() = 0;
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;
}; };
class IoctlHelperUpstream : public IoctlHelper { class IoctlHelperUpstream : public IoctlHelper {
@ -78,6 +87,9 @@ class IoctlHelperUpstream : public IoctlHelper {
bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override; bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override;
uint32_t getDirectSubmissionFlag() override; uint32_t getDirectSubmissionFlag() override;
int32_t getMemRegionsIoctlVal() override; int32_t getMemRegionsIoctlVal() override;
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;
}; };
template <PRODUCT_FAMILY gfxProduct> template <PRODUCT_FAMILY gfxProduct>
@ -106,6 +118,9 @@ class IoctlHelperPrelim20 : public IoctlHelper {
bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override; bool setVmBoAdvise(Drm *drm, int32_t handle, uint32_t attribute, void *region) override;
uint32_t getDirectSubmissionFlag() override; uint32_t getDirectSubmissionFlag() override;
int32_t getMemRegionsIoctlVal() override; int32_t getMemRegionsIoctlVal() override;
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;
}; };
} // namespace NEO } // namespace NEO

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -12,6 +12,7 @@
#include "third_party/uapi/prelim/drm/i915_drm.h" #include "third_party/uapi/prelim/drm/i915_drm.h"
#include <algorithm>
#include <cerrno> #include <cerrno>
#include <cstring> #include <cstring>
#include <sys/ioctl.h> #include <sys/ioctl.h>
@ -185,4 +186,52 @@ int32_t IoctlHelperPrelim20::getMemRegionsIoctlVal() {
return PRELIM_DRM_I915_QUERY_MEMORY_REGIONS; return PRELIM_DRM_I915_QUERY_MEMORY_REGIONS;
} }
int32_t IoctlHelperPrelim20::getEngineInfoIoctlVal() {
return PRELIM_DRM_I915_QUERY_ENGINE_INFO;
}
std::vector<EngineCapabilities> IoctlHelperPrelim20::translateToEngineCaps(const std::vector<uint8_t> &data) {
auto engineInfo = reinterpret_cast<const prelim_drm_i915_query_engine_info *>(data.data());
std::vector<EngineCapabilities> engines;
for (uint32_t i = 0; i < engineInfo->num_engines; i++) {
EngineCapabilities engine{};
engine.capabilities = engineInfo->engines[i].capabilities;
engine.engine.engineClass = engineInfo->engines[i].engine.engine_class;
engine.engine.engineInstance = engineInfo->engines[i].engine.engine_instance;
engines.push_back(engine);
}
return engines;
}
prelim_drm_i915_query_distance_info translateToi915(const DistanceInfo &distanceInfo) {
prelim_drm_i915_query_distance_info dist{};
dist.engine.engine_class = distanceInfo.engine.engineClass;
dist.engine.engine_instance = distanceInfo.engine.engineInstance;
dist.region.memory_class = distanceInfo.region.memoryClass;
dist.region.memory_instance = distanceInfo.region.memoryInstance;
return dist;
}
uint32_t IoctlHelperPrelim20::queryDistances(Drm *drm, std::vector<drm_i915_query_item> &queryItems, std::vector<DistanceInfo> &distanceInfos) {
std::vector<prelim_drm_i915_query_distance_info> i915Distances(distanceInfos.size());
std::transform(distanceInfos.begin(), distanceInfos.end(), i915Distances.begin(), translateToi915);
for (auto i = 0u; i < i915Distances.size(); i++) {
queryItems[i].query_id = PRELIM_DRM_I915_QUERY_DISTANCE_INFO;
queryItems[i].length = sizeof(prelim_drm_i915_query_distance_info);
queryItems[i].flags = 0u;
queryItems[i].data_ptr = reinterpret_cast<__u64>(&i915Distances[i]);
}
drm_i915_query query{};
query.items_ptr = reinterpret_cast<__u64>(queryItems.data());
query.num_items = static_cast<uint32_t>(queryItems.size());
auto ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_QUERY, &query);
for (auto i = 0u; i < i915Distances.size(); i++) {
distanceInfos[i].distance = i915Distances[i].distance;
}
return ret;
}
} // namespace NEO } // namespace NEO

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -101,4 +101,28 @@ int32_t IoctlHelperUpstream::getMemRegionsIoctlVal() {
return DRM_I915_QUERY_MEMORY_REGIONS; return DRM_I915_QUERY_MEMORY_REGIONS;
} }
int32_t IoctlHelperUpstream::getEngineInfoIoctlVal() {
return DRM_I915_QUERY_ENGINE_INFO;
}
std::vector<EngineCapabilities> IoctlHelperUpstream::translateToEngineCaps(const std::vector<uint8_t> &data) {
auto engineInfo = reinterpret_cast<const drm_i915_query_engine_info *>(data.data());
std::vector<EngineCapabilities> engines;
for (uint32_t i = 0; i < engineInfo->num_engines; i++) {
EngineCapabilities engine{};
engine.capabilities = engineInfo->engines[i].capabilities;
engine.engine.engineClass = engineInfo->engines[i].engine.engine_class;
engine.engine.engineInstance = engineInfo->engines[i].engine.engine_instance;
engines.push_back(engine);
}
return engines;
}
uint32_t IoctlHelperUpstream::queryDistances(Drm *drm, std::vector<drm_i915_query_item> &queryItems, std::vector<DistanceInfo> &distanceInfos) {
for (auto &query : queryItems) {
query.length = -EINVAL;
}
return 0;
}
} // namespace NEO } // namespace NEO