intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 00:24:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: setup engine capabilities in drm specifc code

Browse Source 
once drm specific code queries engine info, caps are stored in drm-agnostic form

Related-To: NEO-10445
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2024-07-15 10:22:52 +00:00
committed by Compute-Runtime-Automation
parent 2e5bf8d24d
commit 64f2312aa0
14 changed files with 69 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_ip_sampling_linux_pvc_prelim.cpp
View File

@@ -58,13 +58,13 @@ class DrmPrelimMock : public DrmMock {
uint16_t computeEngineClass = getIoctlHelper()->getDrmParamValue(DrmParam::engineClassCompute);
std::vector<EngineCapabilities> engines(4);
engines[0].engine = {computeEngineClass, 0};
engines[0].capabilities = 0;
engines[0].capabilities = {};
engines[1].engine = {computeEngineClass, 1};
engines[1].capabilities = 0;
engines[1].capabilities = {};
engines[2].engine = {computeEngineClass, 2};
engines[2].capabilities = 0;
engines[2].capabilities = {};
engines[3].engine = {computeEngineClass, 3};
engines[3].capabilities = 0;
engines[3].capabilities = {};
std::vector<DistanceInfo> distances(4);
distances[0].engine = engines[0].engine;
@@ -89,7 +89,7 @@ class DrmPrelimMock : public DrmMock {
uint16_t computeEngineClass = getIoctlHelper()->getDrmParamValue(DrmParam::engineClassCompute);
std::vector<EngineCapabilities> engines(1);
engines[0].engine = {computeEngineClass, 0};
engines[0].capabilities = 0;
engines[0].capabilities = {};
std::vector<DistanceInfo> distances(1);
distances[0].engine = engines[0].engine;

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

@@ -124,7 +124,7 @@ EngineInfo::EngineInfo(Drm *drm, uint32_t tileCount, const std::vector<DistanceI
if (queryItems[i].length < 0 || distanceInfos[i].distance != 0) {
continue;
}
EngineCapabilities engineInfo = {distanceInfos[i].engine, 0};
EngineCapabilities engineInfo = {distanceInfos[i].engine, {}};
mapEngine(ioctlHelper, engineInfo, rootDeviceEnvironment, copyEnginesMappingIt, engineCounters, tile);
}
setSupportedEnginesInfo(rootDeviceEnvironment, engineCounters.numComputeEngines);
@@ -217,13 +217,13 @@ const std::vector<EngineCapabilities> &EngineInfo::getEngineInfos() const {
}
// EngineIndex = (Base + EngineCounter - 1)
aub_stream::EngineType EngineInfo::getBaseCopyEngineType(const IoctlHelper *ioctlHelper, uint64_t capabilities, bool isIntegratedDevice) {
aub_stream::EngineType EngineInfo::getBaseCopyEngineType(const IoctlHelper *ioctlHelper, EngineCapabilities::Flags capabilities, bool isIntegratedDevice) {
if (!isIntegratedDevice) {
if (const auto capa = ioctlHelper->getCopyClassSaturatePCIECapability(); capa && isValueSet(capabilities, *capa)) {
if (capabilities.copyClassSaturatePCIE) {
return DrmEngineMappingHelper::baseForHostLinkCopyEngine;
}
if (const auto capa = ioctlHelper->getCopyClassSaturateLinkCapability(); capa && isValueSet(capabilities, *capa)) {
if (capabilities.copyClassSaturateLink) {
return DrmEngineMappingHelper::baseForScaleUpLinkCopyEngine;
}
}

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

@@ -44,7 +44,7 @@ struct EngineInfo {
uint32_t numComputeEngines = 0;
};
static aub_stream::EngineType getBaseCopyEngineType(const IoctlHelper *ioctlHelper, uint64_t capabilities, bool isIntegratedDevice);
static aub_stream::EngineType getBaseCopyEngineType(const IoctlHelper *ioctlHelper, EngineCapabilities::Flags capabilities, bool isIntegratedDevice);
static void setSupportedEnginesInfo(const RootDeviceEnvironment &rootDeviceEnvironment, uint32_t numComputeEngines);
void assignCopyEngine(aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine,

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

@@ -48,7 +48,11 @@ struct MemoryRegion {
struct EngineCapabilities {
EngineClassInstance engine;
uint64_t capabilities;
struct Flags {
bool copyClassSaturatePCIE;
bool copyClassSaturateLink;
};
Flags capabilities;
};
struct DistanceInfo {
@@ -131,8 +135,6 @@ class IoctlHelper {
virtual void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) = 0;
virtual void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) = 0;
virtual void setVmBindUserFence(VmBindParams &vmBind, VmBindExtUserFenceT vmBindUserFence) = 0;
virtual std::optional<uint64_t> getCopyClassSaturatePCIECapability() const = 0;
virtual std::optional<uint64_t> getCopyClassSaturateLinkCapability() const = 0;
virtual uint32_t getVmAdviseAtomicAttribute() = 0;
virtual int vmBind(const VmBindParams &vmBindParams) = 0;
virtual int vmUnbind(const VmBindParams &vmBindParams) = 0;
@@ -246,6 +248,7 @@ class IoctlHelperI915 : public IoctlHelper {
MOCKABLE_VIRTUAL void initializeGetGpuTimeFunction();
bool (*getGpuTime)(::NEO::Drm &, uint64_t *) = nullptr;
bool isPreemptionSupported() override;
virtual EngineCapabilities::Flags getEngineCapabilitiesFlags(uint64_t capabilities) const;
};
class IoctlHelperUpstream : public IoctlHelperI915 {
@@ -285,8 +288,6 @@ class IoctlHelperUpstream : public IoctlHelperI915 {
void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
void setVmBindUserFence(VmBindParams &vmBind, VmBindExtUserFenceT vmBindUserFence) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() const override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() const override;
uint32_t getVmAdviseAtomicAttribute() override;
int vmBind(const VmBindParams &vmBindParams) override;
int vmUnbind(const VmBindParams &vmBindParams) override;
@@ -364,8 +365,6 @@ class IoctlHelperPrelim20 : public IoctlHelperI915 {
void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
void setVmBindUserFence(VmBindParams &vmBind, VmBindExtUserFenceT vmBindUserFence) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() const override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() const override;
uint32_t getVmAdviseAtomicAttribute() override;
int vmBind(const VmBindParams &vmBindParams) override;
int vmUnbind(const VmBindParams &vmBindParams) override;
@@ -407,6 +406,7 @@ class IoctlHelperPrelim20 : public IoctlHelperI915 {
bool validPageFault(uint16_t flags) override;
uint32_t getStatusForResetStats(bool banned) override;
void registerBOBindHandle(Drm *drm, DrmAllocation *drmAllocation) override;
EngineCapabilities::Flags getEngineCapabilitiesFlags(uint64_t capabilities) const override;
protected:
bool queryHwIpVersion(EngineClassInstance &engineInfo, HardwareIpVersion &ipVersion, int &ret);

6
shared/source/os_interface/linux/ioctl_helper_i915.cpp
View File

@@ -164,13 +164,17 @@ int IoctlHelperI915::getDrmParamValueBase(DrmParam drmParam) const {
}
}
EngineCapabilities::Flags IoctlHelperI915::getEngineCapabilitiesFlags(uint64_t capabilities) const {
return {};
}
std::vector<EngineCapabilities> IoctlHelperI915::translateToEngineCaps(const std::vector<uint64_t> &data) {
auto engineInfo = reinterpret_cast<const drm_i915_query_engine_info *>(data.data());
std::vector<EngineCapabilities> engines;
engines.reserve(engineInfo->num_engines);
for (uint32_t i = 0; i < engineInfo->num_engines; i++) {
EngineCapabilities engine{};
engine.capabilities = engineInfo->engines[i].capabilities;
engine.capabilities = getEngineCapabilitiesFlags(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);

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

@@ -9,6 +9,7 @@
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/bit_helpers.h"
#include "shared/source/helpers/common_types.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/helpers/debug_helpers.h"
@@ -727,12 +728,12 @@ void IoctlHelperPrelim20::setVmBindUserFence(VmBindParams &vmBind, VmBindExtUser
return;
}
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturatePCIECapability() const {
return PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE;
}
EngineCapabilities::Flags IoctlHelperPrelim20::getEngineCapabilitiesFlags(uint64_t capabilities) const {
EngineCapabilities::Flags flags{};
flags.copyClassSaturateLink = isValueSet(capabilities, PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK);
flags.copyClassSaturatePCIE = isValueSet(capabilities, PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE);
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturateLinkCapability() const {
return PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK;
return flags;
}
uint32_t IoctlHelperPrelim20::getVmAdviseAtomicAttribute() {

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

@@ -239,14 +239,6 @@ void IoctlHelperUpstream::fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtU
void IoctlHelperUpstream::setVmBindUserFence(VmBindParams &vmBind, VmBindExtUserFenceT vmBindUserFence){};
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() const {
return std::nullopt;
}
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturateLinkCapability() const {
return std::nullopt;
}
uint32_t IoctlHelperUpstream::getVmAdviseAtomicAttribute() {
return 0;
}

10
shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp
View File

@@ -861,16 +861,6 @@ void IoctlHelperXe::setVmBindUserFence(VmBindParams &vmBind, VmBindExtUserFenceT
return;
}
std::optional<uint64_t> IoctlHelperXe::getCopyClassSaturatePCIECapability() const {
xeLog(" -> IoctlHelperXe::%s\n", __FUNCTION__);
return {};
}
std::optional<uint64_t> IoctlHelperXe::getCopyClassSaturateLinkCapability() const {
xeLog(" -> IoctlHelperXe::%s\n", __FUNCTION__);
return {};
}
uint32_t IoctlHelperXe::getVmAdviseAtomicAttribute() {
xeLog(" -> IoctlHelperXe::%s\n", __FUNCTION__);
return 0;

2
shared/source/os_interface/linux/xe/ioctl_helper_xe.h
View File

@@ -74,8 +74,6 @@ class IoctlHelperXe : public IoctlHelper {
void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
void setVmBindUserFence(VmBindParams &vmBind, VmBindExtUserFenceT vmBindUserFence) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() const override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() const override;
uint32_t getVmAdviseAtomicAttribute() override;
int vmBind(const VmBindParams &vmBindParams) override;
int vmUnbind(const VmBindParams &vmBindParams) override;

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

@@ -852,14 +852,18 @@ TEST(DrmTest, givenCapsWhenCallGetBaseCopyEngineTypeAndIsIntegratedGpuThenBcs0Al
auto engineInfo = std::make_unique<MockEngineInfo>(drm.get(), engineInfosPerTile);
bool isIntegratedGpu = true;
auto caps = drm->ioctlHelper->getCopyClassSaturatePCIECapability();
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), *caps, isIntegratedGpu));
EngineCapabilities::Flags capabilities{};
capabilities.copyClassSaturateLink = true;
capabilities.copyClassSaturatePCIE = false;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), capabilities, isIntegratedGpu));
caps = drm->ioctlHelper->getCopyClassSaturateLinkCapability();
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), *caps, isIntegratedGpu));
capabilities.copyClassSaturateLink = false;
capabilities.copyClassSaturatePCIE = true;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), capabilities, isIntegratedGpu));
caps = 0;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), *caps, isIntegratedGpu));
capabilities.copyClassSaturateLink = false;
capabilities.copyClassSaturatePCIE = false;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), capabilities, isIntegratedGpu));
}
TEST(DrmTest, givenCapsWhenCallGetBaseCopyEngineTypeAndIsNotIntegratedGpuThenProperBcsIsReturned) {
@@ -872,14 +876,19 @@ TEST(DrmTest, givenCapsWhenCallGetBaseCopyEngineTypeAndIsNotIntegratedGpuThenPro
auto engineInfo = std::make_unique<MockEngineInfo>(drm.get(), engineInfosPerTile);
bool isIntegratedGpu = false;
auto caps = drm->ioctlHelper->getCopyClassSaturatePCIECapability();
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS1, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), *caps, isIntegratedGpu));
caps = drm->ioctlHelper->getCopyClassSaturateLinkCapability();
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS3, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), *caps, isIntegratedGpu));
EngineCapabilities::Flags capabilities{};
capabilities.copyClassSaturateLink = false;
capabilities.copyClassSaturatePCIE = true;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS1, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), capabilities, isIntegratedGpu));
caps = 0;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), *caps, isIntegratedGpu));
capabilities.copyClassSaturateLink = true;
capabilities.copyClassSaturatePCIE = false;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS3, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), capabilities, isIntegratedGpu));
capabilities.copyClassSaturateLink = false;
capabilities.copyClassSaturatePCIE = false;
EXPECT_EQ(aub_stream::EngineType::ENGINE_BCS, engineInfo->getBaseCopyEngineType(drm->ioctlHelper.get(), capabilities, isIntegratedGpu));
}
struct DistanceQueryDrmTests : ::testing::Test {

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

@@ -63,9 +63,9 @@ TEST(EngineInfoTest, whenCreateEngineInfoWithRcsThenCorrectHwInfoSet) {
auto &hwInfo = *drm->getRootDeviceEnvironment().getHardwareInfo();
std::vector<EngineCapabilities> engines(2);
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 0};
engines[0].capabilities = 0;
engines[0].capabilities = {};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)), 0};
engines[1].capabilities = 0;
engines[1].capabilities = {};
StackVec<std::vector<EngineCapabilities>, 2> engineInfosPerTile{engines};
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), engineInfosPerTile);
@@ -90,7 +90,7 @@ TEST(EngineInfoTest, whenCallingGetEngineTileInfoCorrectValuesAreReturned) {
std::vector<EngineCapabilities> engines(1);
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 0};
engines[0].capabilities = 0;
engines[0].capabilities = {};
StackVec<std::vector<EngineCapabilities>, 2> engineInfosPerTile{engines};
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), engineInfosPerTile);
@@ -109,9 +109,9 @@ TEST(EngineInfoTest, whenCreateEngineInfoWithCcsThenCorrectHwInfoSet) {
std::vector<EngineCapabilities> engines(2);
uint16_t ccsClass = ioctlHelper->getDrmParamValue(DrmParam::engineClassCompute);
engines[0].engine = {ccsClass, 0};
engines[0].capabilities = 0;
engines[0].capabilities = {};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)), 0};
engines[1].capabilities = 0;
engines[1].capabilities = {};
StackVec<std::vector<EngineCapabilities>, 2> engineInfosPerTile{engines};
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), engineInfosPerTile);
@@ -139,13 +139,13 @@ TEST(EngineInfoTest, whenGetEngineInstanceAndTileThenCorrectValuesReturned) {
std::vector<EngineCapabilities> engines(4);
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 0};
engines[0].capabilities = 0;
engines[0].capabilities = {};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)), 0};
engines[1].capabilities = 0;
engines[1].capabilities = {};
engines[2].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 1};
engines[2].capabilities = 0;
engines[2].capabilities = {};
engines[3].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)), 1};
engines[3].capabilities = 0;
engines[3].capabilities = {};
std::vector<DistanceInfo> distances(4);
distances[0].engine = engines[0].engine;
@@ -188,13 +188,13 @@ TEST(EngineInfoTest, whenCreateEngineInfoAndInvalidQueryThenNoEnginesSet) {
std::vector<EngineCapabilities> engines(4);
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 0};
engines[0].capabilities = 0;
engines[0].capabilities = {};
engines[1].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)), 0};
engines[1].capabilities = 0;
engines[1].capabilities = {};
engines[2].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 1};
engines[2].capabilities = 0;
engines[2].capabilities = {};
engines[3].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)), 1};
engines[3].capabilities = 0;
engines[3].capabilities = {};
std::vector<DistanceInfo> distances(4);
distances[0].engine = engines[0].engine;

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

@@ -319,8 +319,8 @@ TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetDirectSubmissionFlagThenCorrec
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenTranslateToEngineCapsThenReturnSameData) {
std::vector<EngineCapabilities> expectedEngines(2);
expectedEngines[0] = {{static_cast<uint16_t>(ioctlHelper.getDrmParamValue(DrmParam::engineClassRender)), 0}, 0};
expectedEngines[1] = {{static_cast<uint16_t>(ioctlHelper.getDrmParamValue(DrmParam::engineClassCopy)), 1}, 0};
expectedEngines[0] = {{static_cast<uint16_t>(ioctlHelper.getDrmParamValue(DrmParam::engineClassRender)), 0}, {true, false}};
expectedEngines[1] = {{static_cast<uint16_t>(ioctlHelper.getDrmParamValue(DrmParam::engineClassCopy)), 1}, {false, true}};
auto engineInfo = getEngineInfo(expectedEngines);
@@ -329,7 +329,8 @@ TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenTranslateToEngineCapsThenReturnSa
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);
EXPECT_EQ(expectedEngines[i].capabilities.copyClassSaturateLink, engines[i].capabilities.copyClassSaturateLink);
EXPECT_EQ(expectedEngines[i].capabilities.copyClassSaturatePCIE, engines[i].capabilities.copyClassSaturatePCIE);
}
}

5
shared/test/unit_test/os_interface/linux/prelim_helper_func.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -123,7 +123,8 @@ std::vector<uint64_t> getEngineInfo(const std::vector<EngineCapabilities> &input
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;
memoryRegions->engines[i].capabilities |= inputEngines[i].capabilities.copyClassSaturateLink ? PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK : 0;
memoryRegions->engines[i].capabilities |= inputEngines[i].capabilities.copyClassSaturatePCIE ? PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE : 0;
}
return data;
}

4
shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp
View File

@@ -295,10 +295,6 @@ TEST(IoctlHelperXeTest, givenIoctlHelperXeWhenCallingAnyMethodThenDummyValueIsRe
VmBindExtUserFenceT vmBindExtUserFence{};
EXPECT_NO_THROW(xeIoctlHelper->fillVmBindExtUserFence(vmBindExtUserFence, 0, 0, 0));
EXPECT_EQ(std::nullopt, xeIoctlHelper->getCopyClassSaturatePCIECapability());
EXPECT_EQ(std::nullopt, xeIoctlHelper->getCopyClassSaturateLinkCapability());
EXPECT_EQ(0u, xeIoctlHelper->getVmAdviseAtomicAttribute());
VmBindParams vmBindParams{};