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

Extend EngineInfo with additional copy engines 

Signed-off-by: Daniel Chabrowski daniel.chabrowski@intel.com
Related-To: NEO-6591
This commit is contained in:
Daniel Chabrowski 2022-02-15 12:56:31 +00:00 committed by Compute-Runtime-Automation
parent 19c7162cf6
commit f7322d3b85
16 changed files with 189 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
opencl/test/unit_test/os_interface/linux/CMakeLists.txt
View File

@ -20,7 +20,6 @@ set(IGDRCL_SRCS_tests_os_interface_linux
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_debug_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_gem_close_worker_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_mapper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_engine_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_manager_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_memory_manager_localmem_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_os_memory_tests.cpp

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

@ -55,7 +55,6 @@ set(NEO_CORE_OS_INTERFACE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}ioctl_helper_prelim_extended.cpp
${CMAKE_CURRENT_SOURCE_DIR}/engine_info.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

61
shared/source/os_interface/linux/engine_info.cpp
View File

@ -21,8 +21,32 @@ 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}};
// 3 types of copy engines:
// - Main - BCS (legacy, aka. BCS0)
// - Host (flavor of link copy engine) - BCS1-2
// - Scale-up (flavor of link copy engine) - BCS3-8
constexpr aub_stream::EngineType baseForMainCopyEngine = aub_stream::EngineType::ENGINE_BCS;
constexpr aub_stream::EngineType baseForHostLinkCopyEngine = aub_stream::EngineType::ENGINE_BCS1;
constexpr aub_stream::EngineType baseForScaleUpLinkCopyEngine = aub_stream::EngineType::ENGINE_BCS3;
} // namespace DrmEngineMappingHelper
namespace {
void assignLinkCopyEngine(std::vector<EngineInfo::EngineToInstanceMap> &tileToEngineToInstanceMap, aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine,
BcsInfoMask &bcsInfoMask, uint32_t &engineCounter) {
engineCounter++;
auto engineIndex = (baseEngineType + engineCounter - 1);
tileToEngineToInstanceMap[tileId][static_cast<aub_stream::EngineType>(engineIndex)] = engine;
// Example: For BCS5 (3rd scale-up engine): BCS3 + 3 - BCS1 = 5
size_t engineMaskIndex = (baseEngineType + engineCounter - aub_stream::EngineType::ENGINE_BCS1);
UNRECOVERABLE_IF(bcsInfoMask.test(engineMaskIndex));
bcsInfoMask.set(engineMaskIndex, true);
}
} // namespace
EngineInfo::EngineInfo(Drm *drm, HardwareInfo *hwInfo, const std::vector<EngineCapabilities> &engineInfos)
: engines(engineInfos), tileToEngineToInstanceMap(1) {
auto computeEngines = 0u;
@ -38,7 +62,7 @@ EngineInfo::EngineInfo(Drm *drm, HardwareInfo *hwInfo, const std::vector<EngineC
tileToEngineToInstanceMap[0][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, *hwInfo)] = engine;
break;
case I915_ENGINE_CLASS_COPY:
assignCopyEngine(EngineInfo::getBaseCopyEngineType(engineInfo.capabilities), 0, engine,
assignCopyEngine(EngineInfo::getBaseCopyEngineType(drm->getIoctlHelper(), engineInfo.capabilities), 0, engine,
bcsInfoMask, numHostLinkCopyEngines, numScaleUpLinkCopyEngines);
break;
default:
@ -143,4 +167,39 @@ void EngineInfo::getListOfEnginesOnATile(uint32_t tile, std::vector<EngineClassI
}
}
void EngineInfo::assignCopyEngine(aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine,
BcsInfoMask &bcsInfoMask, uint32_t &numHostLinkCopyEngines, uint32_t &numScaleUpLinkCopyEngines) {
// Link copy engines:
if (baseEngineType == DrmEngineMappingHelper::baseForHostLinkCopyEngine) {
assignLinkCopyEngine(tileToEngineToInstanceMap, baseEngineType, tileId, engine, bcsInfoMask, numHostLinkCopyEngines);
return;
}
if (baseEngineType == DrmEngineMappingHelper::baseForScaleUpLinkCopyEngine) {
assignLinkCopyEngine(tileToEngineToInstanceMap, baseEngineType, tileId, engine, bcsInfoMask, numScaleUpLinkCopyEngines);
return;
}
// Main copy engine:
UNRECOVERABLE_IF(baseEngineType != DrmEngineMappingHelper::baseForMainCopyEngine);
UNRECOVERABLE_IF(bcsInfoMask.test(0));
tileToEngineToInstanceMap[tileId][aub_stream::ENGINE_BCS] = engine;
bcsInfoMask.set(0, true);
}
// EngineIndex = (Base + EngineCounter - 1)
aub_stream::EngineType EngineInfo::getBaseCopyEngineType(IoctlHelper *ioctlHelper, uint64_t capabilities) {
if (const auto capa = ioctlHelper->getCopyClassSaturatePCIECapability(); capa && isValueSet(capabilities, *capa)) {
return DrmEngineMappingHelper::baseForHostLinkCopyEngine;
}
if (const auto capa = ioctlHelper->getCopyClassSaturateLinkCapability(); capa && isValueSet(capabilities, *capa)) {
return DrmEngineMappingHelper::baseForScaleUpLinkCopyEngine;
}
// no capabilites check for BCS0, to be backward compatible
return DrmEngineMappingHelper::baseForMainCopyEngine;
}
} // namespace NEO

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

@ -36,7 +36,7 @@ struct EngineInfo {
std::vector<EngineCapabilities> engines;
protected:
static aub_stream::EngineType getBaseCopyEngineType(uint64_t capabilities);
static aub_stream::EngineType getBaseCopyEngineType(IoctlHelper *ioctlHelper, 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,

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

@ -1,27 +0,0 @@
/*
* 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

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

@ -98,6 +98,8 @@ class IoctlHelper {
virtual void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) = 0;
virtual std::unique_ptr<uint8_t[]> createVmBindExtSyncFence() = 0;
virtual void fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) = 0;
virtual std::optional<uint64_t> getCopyClassSaturatePCIECapability() = 0;
virtual std::optional<uint64_t> getCopyClassSaturateLinkCapability() = 0;
};
class IoctlHelperUpstream : public IoctlHelper {
@ -135,6 +137,8 @@ class IoctlHelperUpstream : public IoctlHelper {
void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
std::unique_ptr<uint8_t[]> createVmBindExtSyncFence() override;
void fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() override;
};
template <PRODUCT_FAMILY gfxProduct>
@ -187,6 +191,8 @@ class IoctlHelperPrelim20 : public IoctlHelper {
void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
std::unique_ptr<uint8_t[]> createVmBindExtSyncFence() override;
void fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() override;
};
} // namespace NEO

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

@ -417,4 +417,13 @@ void IoctlHelperPrelim20::fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]
prelimVmBindExtSyncFence->addr = fenceAddress;
prelimVmBindExtSyncFence->val = fenceValue;
}
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturatePCIECapability() {
return PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE;
}
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturateLinkCapability() {
return PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK;
}
} // namespace NEO

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

@ -171,6 +171,7 @@ uint32_t IoctlHelperUpstream::createContextWithAccessCounters(Drm *drm, drm_i915
uint32_t IoctlHelperUpstream::createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) {
return EINVAL;
}
std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSetPat() {
return {};
};
@ -179,4 +180,13 @@ std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSyncFence() {
return {};
}
void IoctlHelperUpstream::fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {}
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() {
return std::nullopt;
}
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturateLinkCapability() {
return std::nullopt;
}
} // namespace NEO

31
shared/test/common/libult/linux/drm_mock_helper.h Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/basic_math.h"
#include "gtest/gtest.h"
namespace DrmMockHelper {
inline uint32_t getTileFromEngineOrMemoryInstance(uint16_t instanceValue) {
uint8_t tileMask = (instanceValue >> 8);
return Math::log2(static_cast<uint64_t>(tileMask));
}
inline uint16_t getEngineOrMemoryInstanceValue(uint16_t tile, uint16_t id) {
EXPECT_TRUE(id < 256);
uint16_t tileMask = ((1 << tile) << 8);
return (id | tileMask);
}
inline uint16_t getIdFromEngineOrMemoryInstance(uint16_t instanceValue) {
return (instanceValue & 0b11111111);
}
} // namespace DrmMockHelper

48
shared/test/common/libult/linux/drm_mock_prelim_context.cpp
View File

@ -10,6 +10,7 @@
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/ptr_math.h"
#include "shared/source/os_interface/linux/cache_info_impl.h"
#include "shared/test/common/libult/linux/drm_mock_helper.h"
#include "third_party/uapi/prelim/drm/i915_drm.h"
#include <gtest/gtest.h>
@ -19,19 +20,6 @@
namespace {
uint32_t getTileFromEngineOrMemoryInstance(uint16_t instanceValue) {
uint8_t tileMask = (instanceValue >> 8);
return Math::log2(static_cast<uint64_t>(tileMask));
}
uint16_t getEngineOrMemoryInstanceValue(uint16_t tile, uint16_t id) {
EXPECT_TRUE(id < 256);
uint16_t tileMask = ((1 << tile) << 8);
return (id | tileMask);
}
constexpr BcsInfoMask supportedCopyEnginesMask = 1;
constexpr std::array<uint64_t, 9> copyEnginesCapsMap = {{
PRELIM_I915_COPY_CLASS_CAP_SATURATE_LMEM,
PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE,
@ -102,7 +90,7 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
auto queryItem = reinterpret_cast<drm_i915_query_item *>(arg);
auto &gtSystemInfo = hwInfo->gtSystemInfo;
auto numberOfCCS = gtSystemInfo.CCSInfo.IsValid ? gtSystemInfo.CCSInfo.NumberOfCCSEnabled : 0u;
const auto numberOfCCS = gtSystemInfo.CCSInfo.IsValid && !disableCcsSupport ? gtSystemInfo.CCSInfo.NumberOfCCSEnabled : 0u;
switch (queryItem->query_id) {
case PRELIM_DRM_I915_QUERY_ENGINE_INFO: {
@ -118,19 +106,19 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
queryEngineInfo->num_engines = numberOfEngines;
auto p = queryEngineInfo->engines;
for (uint32_t tile = 0u; tile < numberOfTiles; tile++) {
p++->engine = {I915_ENGINE_CLASS_RENDER, getEngineOrMemoryInstanceValue(tile, 0)};
p++->engine = {I915_ENGINE_CLASS_RENDER, DrmMockHelper::getEngineOrMemoryInstanceValue(tile, 0)};
for (uint32_t i = 0u; i < supportedCopyEnginesMask.size(); i++) {
if (supportedCopyEnginesMask.test(i)) {
auto copyEngineInfo = p++;
copyEngineInfo->engine = {I915_ENGINE_CLASS_COPY, getEngineOrMemoryInstanceValue(tile, i)};
copyEngineInfo->engine = {I915_ENGINE_CLASS_COPY, DrmMockHelper::getEngineOrMemoryInstanceValue(tile, i)};
copyEngineInfo->capabilities = copyEnginesCapsMap[i];
}
}
p++->engine = {I915_ENGINE_CLASS_VIDEO, getEngineOrMemoryInstanceValue(tile, 0)};
p++->engine = {I915_ENGINE_CLASS_VIDEO, getEngineOrMemoryInstanceValue(tile, 0)};
p++->engine = {I915_ENGINE_CLASS_VIDEO_ENHANCE, getEngineOrMemoryInstanceValue(tile, 0)};
p++->engine = {I915_ENGINE_CLASS_VIDEO, DrmMockHelper::getEngineOrMemoryInstanceValue(tile, 0)};
p++->engine = {I915_ENGINE_CLASS_VIDEO, DrmMockHelper::getEngineOrMemoryInstanceValue(tile, 0)};
p++->engine = {I915_ENGINE_CLASS_VIDEO_ENHANCE, DrmMockHelper::getEngineOrMemoryInstanceValue(tile, 0)};
for (auto i = 0u; i < numberOfCCS; i++) {
p++->engine = {PRELIM_I915_ENGINE_CLASS_COMPUTE, getEngineOrMemoryInstanceValue(tile, i)};
p++->engine = {PRELIM_I915_ENGINE_CLASS_COMPUTE, DrmMockHelper::getEngineOrMemoryInstanceValue(tile, i)};
}
}
}
@ -154,13 +142,17 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
queryMemoryRegionInfo->regions[0].probed_size = 2 * MemoryConstants::gigaByte;
for (auto tile = 0u; tile < numberOfLocalMemories; tile++) {
queryMemoryRegionInfo->regions[1 + tile].region.memory_class = PRELIM_I915_MEMORY_CLASS_DEVICE;
queryMemoryRegionInfo->regions[1 + tile].region.memory_instance = getEngineOrMemoryInstanceValue(tile, 0);
queryMemoryRegionInfo->regions[1 + tile].region.memory_instance = DrmMockHelper::getEngineOrMemoryInstanceValue(tile, 0);
queryMemoryRegionInfo->regions[1 + tile].probed_size = 2 * MemoryConstants::gigaByte;
}
}
} break;
case PRELIM_DRM_I915_QUERY_DISTANCE_INFO: {
if (failDistanceInfoQuery) {
return false;
}
auto queryDistanceInfo = reinterpret_cast<prelim_drm_i915_query_distance_info *>(queryItem->data_ptr);
switch (queryDistanceInfo->region.memory_class) {
case PRELIM_I915_MEMORY_CLASS_SYSTEM:
@ -170,8 +162,8 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
case PRELIM_I915_MEMORY_CLASS_DEVICE: {
EXPECT_EQ(sizeof(prelim_drm_i915_query_distance_info), static_cast<size_t>(queryItem->length));
auto engineTile = getTileFromEngineOrMemoryInstance(queryDistanceInfo->engine.engine_instance);
auto memoryTile = getTileFromEngineOrMemoryInstance(queryDistanceInfo->region.memory_instance);
auto engineTile = DrmMockHelper::getTileFromEngineOrMemoryInstance(queryDistanceInfo->engine.engine_instance);
auto memoryTile = DrmMockHelper::getTileFromEngineOrMemoryInstance(queryDistanceInfo->region.memory_instance);
queryDistanceInfo->distance = (memoryTile == engineTile) ? 0 : 100;
break;
@ -246,6 +238,14 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
return true;
}
uint32_t getQueryComputeSlicesIoctl() {
uint32_t DrmPrelimHelper::getQueryComputeSlicesIoctl() {
return PRELIM_DRM_I915_QUERY_COMPUTE_SLICES;
}
uint32_t DrmPrelimHelper::getDistanceInfoQueryId() {
return PRELIM_DRM_I915_QUERY_DISTANCE_INFO;
}
uint32_t DrmPrelimHelper::getComputeEngineClass() {
return PRELIM_I915_ENGINE_CLASS_COMPUTE;
}

9
shared/test/common/libult/linux/drm_mock_prelim_context.h
View File

@ -18,6 +18,8 @@ struct DrmMockPrelimContext {
const RootDeviceEnvironment &rootDeviceEnvironment;
const CacheInfo *cacheInfo;
const bool &failRetTopology;
const BcsInfoMask &supportedCopyEnginesMask;
uint16_t closIndex{0};
uint16_t maxNumWays{32};
uint32_t allocNumWays{0};
@ -29,8 +31,15 @@ struct DrmMockPrelimContext {
int hasPageFaultQueryValue{0};
int hasPageFaultQueryReturn{0};
bool failDistanceInfoQuery{false};
bool disableCcsSupport{false};
int handlePrelimRequest(unsigned long request, void *arg);
bool handlePrelimQueryItem(void *arg);
};
namespace DrmPrelimHelper {
uint32_t getQueryComputeSlicesIoctl();
uint32_t getDistanceInfoQueryId();
uint32_t getComputeEngineClass();
}; // namespace DrmPrelimHelper

20
shared/test/common/libult/linux/drm_query_mock.cpp
View File

@ -7,8 +7,17 @@
#include "shared/test/common/libult/linux/drm_query_mock.h"
#include "shared/source/helpers/ptr_math.h"
#include "gtest/gtest.h"
int DrmQueryMock::handleRemainingRequests(unsigned long request, void *arg) {
if (request == DRM_IOCTL_I915_QUERY && arg) {
if (i915QuerySuccessCount == 0) {
return EINVAL;
}
i915QuerySuccessCount--;
auto query = static_cast<drm_i915_query *>(arg);
if (query->items_ptr == 0) {
return EINVAL;
@ -22,6 +31,17 @@ int DrmQueryMock::handleRemainingRequests(unsigned long request, void *arg) {
}
return 0;
} else if (request == DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM && receivedContextParamRequest.param == I915_CONTEXT_PARAM_ENGINES) {
EXPECT_LE(receivedContextParamRequest.size, sizeof(receivedContextParamEngines));
memcpy(&receivedContextParamEngines, reinterpret_cast<const void *>(receivedContextParamRequest.value), receivedContextParamRequest.size);
auto srcBalancer = reinterpret_cast<const i915_context_engines_load_balance *>(receivedContextParamEngines.extensions);
if (srcBalancer) {
EXPECT_EQ(static_cast<__u32>(I915_CONTEXT_ENGINES_EXT_LOAD_BALANCE), srcBalancer->base.name);
auto balancerSize = ptrDiff(srcBalancer->engines + srcBalancer->num_siblings, srcBalancer);
EXPECT_LE(balancerSize, sizeof(receivedContextEnginesLoadBalance));
memcpy(&receivedContextEnginesLoadBalance, srcBalancer, balancerSize);
}
return storedRetValForSetParamEngines;
}
return context.handlePrelimRequest(request, arg);

17
shared/test/common/libult/linux/drm_query_mock.h
View File

@ -13,16 +13,24 @@
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/libult/linux/drm_mock_prelim_context.h"
#include "gtest/gtest.h"
using namespace NEO;
class DrmQueryMock : public DrmMock {
public:
using Drm::rootDeviceEnvironment;
DrmQueryMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmQueryMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmQueryMock(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
context.hwInfo = rootDeviceEnvironment.getHardwareInfo();
setupIoctlHelper(IGFX_UNKNOWN);
EXPECT_TRUE(queryMemoryInfo());
EXPECT_EQ(2u, ioctlCallsCount);
ioctlCallsCount = 0;
}
void getPrelimVersion(std::string &prelimVersion) override {
@ -34,8 +42,17 @@ class DrmQueryMock : public DrmMock {
.rootDeviceEnvironment = rootDeviceEnvironment,
.cacheInfo = getCacheInfo(),
.failRetTopology = failRetTopology,
.supportedCopyEnginesMask = supportedCopyEnginesMask,
};
static constexpr uint32_t maxEngineCount{9};
I915_DEFINE_CONTEXT_ENGINES_LOAD_BALANCE(receivedContextEnginesLoadBalance, maxEngineCount){};
I915_DEFINE_CONTEXT_PARAM_ENGINES(receivedContextParamEngines, 1 + maxEngineCount){};
BcsInfoMask supportedCopyEnginesMask = 1;
uint32_t i915QuerySuccessCount = std::numeric_limits<uint32_t>::max();
int storedRetValForSetParamEngines{0};
int handleRemainingRequests(unsigned long request, void *arg) override;
virtual bool handleQueryItem(void *queryItem);
};

1
shared/test/unit_test/os_interface/linux/CMakeLists.txt
View File

@ -8,6 +8,7 @@ set(NEO_CORE_OS_INTERFACE_TESTS_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/drm_bind_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_command_stream_l0_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_engine_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_memory_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/drm_mock_impl.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_query_tests.cpp

0
opencl/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp → shared/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp
View File

2
shared/test/unit_test/os_interface/linux/drm_query_topology_prelim_tests.cpp
View File

@ -37,7 +37,7 @@ struct QueryTopologyTests : ::testing::Test {
bool handleQueryItem(void *arg) override {
const auto queryItem = reinterpret_cast<drm_i915_query_item *>(arg);
if (queryItem->query_id != getQueryComputeSlicesIoctl()) {
if (queryItem->query_id != DrmPrelimHelper::getQueryComputeSlicesIoctl()) {
return DrmQueryMock::handleQueryItem(queryItem);
}