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

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
*
@ -17,6 +17,7 @@ using namespace NEO;
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> getEngineInfo(const std::vector<EngineCapabilities> &inputEngines);
class DrmPrelimMock : public DrmMock {
public:
@ -307,3 +308,51 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenGetMemRegionsIoctlValThenCorrectVal
int32_t ioctlVal = (1 << 16) | 4;
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
*
@ -124,3 +124,24 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetMemRegionsIoctlValThenCorrect
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
*
@ -45,6 +45,18 @@ int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal) {
} else if (request == PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE) {
auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
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;
}
@ -64,3 +76,18 @@ std::vector<uint8_t> getRegionInfo(const std::vector<MemoryRegion> &inputRegions
}
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;
}