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: unify EngineInfo ctors

Browse Source 
remove redundant constructor
create helper struct for numbers of engines
adjust test scopes

Related-To: NEO-10445
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2024-07-11 12:52:18 +00:00
committed by Compute-Runtime-Automation
parent e188de2489
commit 3f65f75cc3
15 changed files with 114 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -65,7 +65,9 @@ struct MockEngineNeoDrm : public Drm {
i915engineInfo[5].engine.engineClass = UINT16_MAX;
i915engineInfo[5].engine.engineInstance = 0;
this->engineInfo.reset(new EngineInfo(this, i915engineInfo));
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915engineInfo};
this->engineInfo.reset(new EngineInfo(this, engineInfosPerTile));
return true;
}
};

4
level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_prelim.h
View File

@@ -84,7 +84,9 @@ struct MockEngineNeoDrmPrelim : public Drm {
i915QueryEngineInfo[6].engine.engineClass = invalidEngineClass;
i915QueryEngineInfo[6].engine.engineInstance = 0;
this->engineInfo.reset(new EngineInfo(this, i915QueryEngineInfo));
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915QueryEngineInfo};
this->engineInfo.reset(new EngineInfo(this, engineInfosPerTile));
return true;
}

3
level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_xe.h
View File

@@ -47,7 +47,8 @@ class MockNeoDrm : public NEO::Drm {
mockEngineInfo[5].engine.engineClass = UINT16_MAX;
mockEngineInfo[5].engine.engineInstance = 0;
this->engineInfo.reset(new NEO::EngineInfo(this, mockEngineInfo));
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{mockEngineInfo};
this->engineInfo.reset(new NEO::EngineInfo(this, engineInfosPerTile));
return true;
}
};

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

@@ -55,7 +55,9 @@ struct MockEngineNeoDrm : public Drm {
i915engineInfo[5].engine.engineClass = invalidEngineClass;
i915engineInfo[5].engine.engineInstance = 0;
this->engineInfo.reset(new EngineInfo(this, i915engineInfo));
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915engineInfo};
this->engineInfo.reset(new EngineInfo(this, engineInfosPerTile));
return true;
}
};

4
level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine_prelim.h
View File

@@ -64,7 +64,9 @@ struct MockEngineNeoDrmPrelim : public Drm {
i915QueryEngineInfo[6].engine.engineClass = invalidEngineClass;
i915QueryEngineInfo[6].engine.engineInstance = 0;
this->engineInfo.reset(new EngineInfo(this, i915QueryEngineInfo));
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915QueryEngineInfo};
this->engineInfo.reset(new EngineInfo(this, engineInfosPerTile));
return true;
}

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

@@ -63,86 +63,71 @@ uint32_t getBcsEngineMaskIndex(const aub_stream::EngineType *mappingCopyEngineIt
}
} // namespace
void EngineInfo::mapEngine(const NEO::IoctlHelper *ioctlHelper, const EngineClassInstance &engine, BcsInfoMask &bcsInfoMask, const NEO::RootDeviceEnvironment &rootDeviceEnvironment,
const aub_stream::EngineType *&mappingCopyEngineIt, uint32_t &computeEnginesCounter, uint32_t tileId) {
void EngineInfo::mapEngine(const NEO::IoctlHelper *ioctlHelper, const EngineCapabilities &engineInfo, const NEO::RootDeviceEnvironment &rootDeviceEnvironment,
const aub_stream::EngineType *&mappingCopyEngineIt, EngineCounters &engineCounters, uint32_t tileId) {
aub_stream::EngineType engineType = aub_stream::EngineType::NUM_ENGINES;
auto &engine = engineInfo.engine;
tileToEngineMap.emplace(tileId, engine);
if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)) {
tileToEngineToInstanceMap[tileId][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, rootDeviceEnvironment)] = engine;
engineType = EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, rootDeviceEnvironment);
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)) {
tileToEngineToInstanceMap[tileId][*(mappingCopyEngineIt)] = engine;
bcsInfoMask.set(getBcsEngineMaskIndex(mappingCopyEngineIt++), true);
auto isIntergrated = rootDeviceEnvironment.getHardwareInfo()->capabilityTable.isIntegratedDevice;
auto &bcsInfoMask = rootDeviceEnvironment.getMutableHardwareInfo()->featureTable.ftrBcsInfo;
assignCopyEngine(EngineInfo::getBaseCopyEngineType(ioctlHelper, engineInfo.capabilities, isIntergrated), tileId, engine,
bcsInfoMask, engineCounters, mappingCopyEngineIt);
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCompute)) {
tileToEngineToInstanceMap[tileId][static_cast<aub_stream::EngineType>(aub_stream::ENGINE_CCS + computeEnginesCounter)] = engine;
computeEnginesCounter++;
engineType = static_cast<aub_stream::EngineType>(aub_stream::ENGINE_CCS + engineCounters.numComputeEngines);
engineCounters.numComputeEngines++;
}
}
EngineInfo::EngineInfo(Drm *drm, const std::vector<EngineCapabilities> &engineInfos) : engines(engineInfos), tileToEngineToInstanceMap(1) {
auto computeEngines = 0u;
BcsInfoMask bcsInfoMask = 0;
uint32_t numHostLinkCopyEngines = 0;
uint32_t numScaleUpLinkCopyEngines = 0;
auto ioctlHelper = drm->getIoctlHelper();
auto &rootDeviceEnvironment = drm->getRootDeviceEnvironment();
for (const auto &engineInfo : engineInfos) {
auto &engine = engineInfo.engine;
tileToEngineMap.emplace(0, engine);
if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)) {
tileToEngineToInstanceMap[0][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, rootDeviceEnvironment)] = engine;
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)) {
const auto &hwInfo = rootDeviceEnvironment.getHardwareInfo();
assignCopyEngine(EngineInfo::getBaseCopyEngineType(ioctlHelper, engineInfo.capabilities, hwInfo->capabilityTable.isIntegratedDevice), 0, engine,
bcsInfoMask, numHostLinkCopyEngines, numScaleUpLinkCopyEngines);
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCompute)) {
tileToEngineToInstanceMap[0][static_cast<aub_stream::EngineType>(aub_stream::ENGINE_CCS + computeEngines)] = engine;
computeEngines++;
}
if (engineType != aub_stream::EngineType::NUM_ENGINES) {
tileToEngineToInstanceMap[tileId][engineType] = engine;
}
setSupportedEnginesInfo(rootDeviceEnvironment, computeEngines, bcsInfoMask);
}
EngineInfo::EngineInfo(Drm *drm, const StackVec<std::vector<EngineCapabilities>, 2> &engineInfosPerTile) : tileToEngineToInstanceMap(engineInfosPerTile.size()) {
auto ioctlHelper = drm->getIoctlHelper();
auto &rootDeviceEnvironment = drm->getRootDeviceEnvironment();
auto computeEnginesPerTile = 0u;
BcsInfoMask bcsInfoMask = {};
EngineCounters engineCounters{};
rootDeviceEnvironment.getMutableHardwareInfo()->featureTable.ftrBcsInfo = 0;
for (auto tile = 0u; tile < engineInfosPerTile.size(); tile++) {
computeEnginesPerTile = 0u;
engineCounters.numComputeEngines = 0u;
auto copyEnginesMappingIt = getCopyEnginesMappingIterator(rootDeviceEnvironment);
for (const auto &engineCapabilities : engineInfosPerTile[tile]) {
mapEngine(ioctlHelper, engineCapabilities.engine, bcsInfoMask, rootDeviceEnvironment, copyEnginesMappingIt, computeEnginesPerTile, tile);
engines.push_back(engineCapabilities);
mapEngine(ioctlHelper, engineCapabilities, rootDeviceEnvironment, copyEnginesMappingIt, engineCounters, tile);
}
}
setSupportedEnginesInfo(rootDeviceEnvironment, computeEnginesPerTile, bcsInfoMask);
setSupportedEnginesInfo(rootDeviceEnvironment, engineCounters.numComputeEngines);
}
EngineInfo::EngineInfo(Drm *drm, uint32_t tileCount, const std::vector<DistanceInfo> &distanceInfos, const std::vector<QueryItem> &queryItems, const std::vector<EngineCapabilities> &engineInfos)
: engines(engineInfos), tileToEngineToInstanceMap(tileCount) {
auto tile = 0u;
auto computeEnginesPerTile = 0u;
EngineCounters engineCounters{};
auto ioctlHelper = drm->getIoctlHelper();
auto &rootDeviceEnvironment = drm->getRootDeviceEnvironment();
BcsInfoMask bcsInfoMask = {};
rootDeviceEnvironment.getMutableHardwareInfo()->featureTable.ftrBcsInfo = 0;
auto copyEnginesMappingIt = getCopyEnginesMappingIterator(rootDeviceEnvironment);
for (auto i = 0u; i < distanceInfos.size(); i++) {
if (i > 0u && distanceInfos[i].region.memoryInstance != distanceInfos[i - 1u].region.memoryInstance) {
tile++;
computeEnginesPerTile = 0u;
engineCounters.numComputeEngines = 0u;
copyEnginesMappingIt = getCopyEnginesMappingIterator(rootDeviceEnvironment);
}
if (queryItems[i].length < 0 || distanceInfos[i].distance != 0) {
continue;
}
auto engine = distanceInfos[i].engine;
mapEngine(ioctlHelper, engine, bcsInfoMask, rootDeviceEnvironment, copyEnginesMappingIt, computeEnginesPerTile, tile);
EngineCapabilities engineInfo = {distanceInfos[i].engine, 0};
mapEngine(ioctlHelper, engineInfo, rootDeviceEnvironment, copyEnginesMappingIt, engineCounters, tile);
}
setSupportedEnginesInfo(rootDeviceEnvironment, computeEnginesPerTile, bcsInfoMask);
setSupportedEnginesInfo(rootDeviceEnvironment, engineCounters.numComputeEngines);
}
const EngineClassInstance *EngineInfo::getEngineInstance(uint32_t tile, aub_stream::EngineType engineType) const {
@@ -157,7 +142,7 @@ const EngineClassInstance *EngineInfo::getEngineInstance(uint32_t tile, aub_stre
return &iter->second;
}
void EngineInfo::setSupportedEnginesInfo(const RootDeviceEnvironment &rootDeviceEnvironment, uint32_t numComputeEngines, const BcsInfoMask &bcsInfoMask) {
void EngineInfo::setSupportedEnginesInfo(const RootDeviceEnvironment &rootDeviceEnvironment, uint32_t numComputeEngines) {
auto hwInfo = rootDeviceEnvironment.getMutableHardwareInfo();
auto &ccsInfo = hwInfo->gtSystemInfo.CCSInfo;
@@ -175,7 +160,6 @@ void EngineInfo::setSupportedEnginesInfo(const RootDeviceEnvironment &rootDevice
ccsInfo.NumberOfCCSEnabled = 0;
ccsInfo.Instances.CCSEnableMask = 0;
}
hwInfo->featureTable.ftrBcsInfo = bcsInfoMask;
}
uint32_t EngineInfo::getEngineTileIndex(const EngineClassInstance &engine) {
@@ -205,23 +189,23 @@ const std::multimap<uint32_t, EngineClassInstance> &EngineInfo::getEngineTileInf
}
void EngineInfo::assignCopyEngine(aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine,
BcsInfoMask &bcsInfoMask, uint32_t &numHostLinkCopyEngines, uint32_t &numScaleUpLinkCopyEngines) {
BcsInfoMask &bcsInfoMask, EngineCounters &engineCounters, const aub_stream::EngineType *&mappingCopyEngineIt) {
// Link copy engines:
if (baseEngineType == DrmEngineMappingHelper::baseForHostLinkCopyEngine) {
assignLinkCopyEngine(tileToEngineToInstanceMap, baseEngineType, tileId, engine, bcsInfoMask, numHostLinkCopyEngines);
assignLinkCopyEngine(tileToEngineToInstanceMap, baseEngineType, tileId, engine, bcsInfoMask, engineCounters.numHostLinkCopyEngines);
return;
}
if (baseEngineType == DrmEngineMappingHelper::baseForScaleUpLinkCopyEngine) {
assignLinkCopyEngine(tileToEngineToInstanceMap, baseEngineType, tileId, engine, bcsInfoMask, numScaleUpLinkCopyEngines);
assignLinkCopyEngine(tileToEngineToInstanceMap, baseEngineType, tileId, engine, bcsInfoMask, engineCounters.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);
auto engineType = *(mappingCopyEngineIt++);
tileToEngineToInstanceMap[tileId][engineType] = engine;
bcsInfoMask.set(getBcsEngineMaskIndex(&engineType), true);
}
bool EngineInfo::hasEngines() {
@@ -233,7 +217,7 @@ const std::vector<EngineCapabilities> &EngineInfo::getEngineInfos() const {
}
// EngineIndex = (Base + EngineCounter - 1)
aub_stream::EngineType EngineInfo::getBaseCopyEngineType(IoctlHelper *ioctlHelper, uint64_t capabilities, bool isIntegratedDevice) {
aub_stream::EngineType EngineInfo::getBaseCopyEngineType(const IoctlHelper *ioctlHelper, uint64_t capabilities, bool isIntegratedDevice) {
if (!isIntegratedDevice) {
if (const auto capa = ioctlHelper->getCopyClassSaturatePCIECapability(); capa && isValueSet(capabilities, *capa)) {
return DrmEngineMappingHelper::baseForHostLinkCopyEngine;

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

@@ -26,7 +26,6 @@ struct EngineInfo {
using EngineToInstanceMap = std::map<aub_stream::EngineType, EngineClassInstance>;
EngineInfo(Drm *drm, const StackVec<std::vector<EngineCapabilities>, 2> &engineInfosPerTile);
EngineInfo(Drm *drm, const std::vector<EngineCapabilities> &engineInfos);
EngineInfo(Drm *drm, uint32_t tileCount, const std::vector<DistanceInfo> &distanceInfos, const std::vector<QueryItem> &queryItems, const std::vector<EngineCapabilities> &engineInfos);
~EngineInfo() = default;
@@ -39,13 +38,19 @@ struct EngineInfo {
const std::vector<EngineCapabilities> &getEngineInfos() const;
protected:
static aub_stream::EngineType getBaseCopyEngineType(IoctlHelper *ioctlHelper, uint64_t capabilities, bool isIntegratedDevice);
static void setSupportedEnginesInfo(const RootDeviceEnvironment &rootDeviceEnvironment, uint32_t numComputeEngines, const BcsInfoMask &bcsInfoMask);
struct EngineCounters {
uint32_t numHostLinkCopyEngines = 0;
uint32_t numScaleUpLinkCopyEngines = 0;
uint32_t numComputeEngines = 0;
};
static aub_stream::EngineType getBaseCopyEngineType(const IoctlHelper *ioctlHelper, uint64_t capabilities, bool isIntegratedDevice);
static void setSupportedEnginesInfo(const RootDeviceEnvironment &rootDeviceEnvironment, uint32_t numComputeEngines);
void assignCopyEngine(aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine,
BcsInfoMask &bcsInfoMask, uint32_t &numHostLinkCopyEngines, uint32_t &numScaleUpLinkCopyEngines);
void mapEngine(const NEO::IoctlHelper *ioctlHelper, const EngineClassInstance &engine, BcsInfoMask &bcsInfoMask, const NEO::RootDeviceEnvironment &rootDeviceEnvironment,
const aub_stream::EngineType *&mappingCopyEngineIt, uint32_t &computeEnginesCounter, uint32_t tileId = 0u);
BcsInfoMask &bcsInfoMask, EngineCounters &engineCounters, const aub_stream::EngineType *&mappingCopyEngineIt);
void mapEngine(const NEO::IoctlHelper *ioctlHelper, const EngineCapabilities &engineInfo, const NEO::RootDeviceEnvironment &rootDeviceEnvironment,
const aub_stream::EngineType *&mappingCopyEngineIt, EngineCounters &engineCounters, uint32_t tileId);
std::vector<EngineCapabilities> engines;
std::vector<EngineToInstanceMap> tileToEngineToInstanceMap;

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

@@ -131,8 +131,8 @@ 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() = 0;
virtual std::optional<uint64_t> getCopyClassSaturateLinkCapability() = 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;
@@ -284,8 +284,8 @@ 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() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() 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;
@@ -362,8 +362,8 @@ 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() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() 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;

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

@@ -197,12 +197,13 @@ std::unique_ptr<EngineInfo> IoctlHelperI915::createEngineInfo(bool isSysmanEnabl
return {};
}
auto engines = translateToEngineCaps(enginesQuery);
StackVec<std::vector<EngineCapabilities>, 2> engineInfosPerTile{engines};
auto hwInfo = drm.getRootDeviceEnvironment().getMutableHardwareInfo();
auto memInfo = drm.getMemoryInfo();
if (!memInfo) {
return std::make_unique<EngineInfo>(&drm, engines);
return std::make_unique<EngineInfo>(&drm, engineInfosPerTile);
}
auto &memoryRegions = memInfo->getDrmRegionInfos();
@@ -234,7 +235,7 @@ std::unique_ptr<EngineInfo> IoctlHelperI915::createEngineInfo(bool isSysmanEnabl
}
if (tileCount == 0u) {
return std::make_unique<EngineInfo>(&drm, engines);
return std::make_unique<EngineInfo>(&drm, engineInfosPerTile);
}
std::vector<QueryItem> queryItems{distanceInfos.size()};
@@ -247,7 +248,7 @@ std::unique_ptr<EngineInfo> IoctlHelperI915::createEngineInfo(bool isSysmanEnabl
[](const QueryItem &item) { return item.length == -EINVAL; });
if (queryUnsupported) {
DEBUG_BREAK_IF(tileCount != 1);
return std::make_unique<EngineInfo>(&drm, engines);
return std::make_unique<EngineInfo>(&drm, engineInfosPerTile);
}
memInfo->assignRegionsFromDistances(distanceInfos);

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

@@ -723,11 +723,11 @@ void IoctlHelperPrelim20::setVmBindUserFence(VmBindParams &vmBind, VmBindExtUser
return;
}
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturatePCIECapability() {
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturatePCIECapability() const {
return PRELIM_I915_COPY_CLASS_CAP_SATURATE_PCIE;
}
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturateLinkCapability() {
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturateLinkCapability() const {
return PRELIM_I915_COPY_CLASS_CAP_SATURATE_LINK;
}

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

@@ -235,11 +235,11 @@ void IoctlHelperUpstream::fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtU
void IoctlHelperUpstream::setVmBindUserFence(VmBindParams &vmBind, VmBindExtUserFenceT vmBindUserFence){};
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() {
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() const {
return std::nullopt;
}
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturateLinkCapability() {
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturateLinkCapability() const {
return std::nullopt;
}

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

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

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

@@ -74,8 +74,8 @@ 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() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() 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;

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

@@ -98,8 +98,9 @@ class MockIoctlHelperEngineInfoDetection : public IoctlHelperPrelim20 {
std::unique_ptr<EngineInfo> createEngineInfo(bool isSysmanEnabled) override {
std::vector<NEO::EngineCapabilities> engineInfo(0);
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{engineInfo};
return std::make_unique<EngineInfo>(&drm, engineInfo);
return std::make_unique<EngineInfo>(&drm, engineInfosPerTile);
}
};
@@ -245,7 +246,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenBcsEngineWhenBindingDrmCo
EXPECT_EQ(ftrBcsInfoVal, hwInfo->featureTable.ftrBcsInfo.to_ulong());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWhenBindingSingleTileDrmContextThenContextParamEngineIsSet) {
HWTEST2_F(DrmTestXeHPAndLater, givenLinkBcsEngineWhenBindingSingleTileDrmContextThenContextParamEngineIsSet, IsXeHpcCore) {
HardwareInfo localHwInfo = *defaultHwInfo;
localHwInfo.gtSystemInfo.MultiTileArchInfo.IsValid = false;
localHwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = 0;
@@ -324,7 +325,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWithoutMainC
}
}
HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, giveNotAllLinkBcsEnginesWhenBindingSingleTileDrmContextThenContextParamEngineIsSet) {
HWTEST2_F(DrmTestXeHPAndLater, givenNotAllLinkBcsEnginesWhenBindingSingleTileDrmContextThenContextParamEngineIsSet, IsXeHpcCore) {
DebugManagerStateRestore restore;
debugManager.flags.UseDrmVirtualEnginesForBcs.set(1);
HardwareInfo localHwInfo = *defaultHwInfo;
@@ -415,7 +416,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWhenBindingM
}
}
HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContextThenEnableLoadBalancing, IsAtLeastXeHpcCore) {
HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContextThenEnableLoadBalancing, IsXeHpcCore) {
DebugManagerStateRestore restore;
debugManager.flags.UseDrmVirtualEnginesForBcs.set(1);
HardwareInfo localHwInfo = *defaultHwInfo;
@@ -444,7 +445,7 @@ HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContext
}
}
HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContextThenEnableLoadBalancingLimitedToMaxCount, IsAtLeastXeHpcCore) {
HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContextThenEnableLoadBalancingLimitedToMaxCount, IsXeHpcCore) {
DebugManagerStateRestore restore;
debugManager.flags.UseDrmVirtualEnginesForBcs.set(1);
debugManager.flags.LimitEngineCountForVirtualBcs.set(3);
@@ -474,7 +475,7 @@ HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContext
}
}
HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesDisabledWhenCreatingContextThenDisableLoadBalancing, IsAtLeastXeHpcCore) {
HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesDisabledWhenCreatingContextThenDisableLoadBalancing, IsXeHpcCore) {
DebugManagerStateRestore restore;
debugManager.flags.UseDrmVirtualEnginesForBcs.set(0);
@@ -838,8 +839,8 @@ TEST(DrmTest, givenNewMemoryInfoQuerySupportedWhenQueryingEngineInfoThenEngineIn
EXPECT_NE(nullptr, drm->engineInfo);
}
struct MockEngineInfo : EngineInfo {
using EngineInfo::EngineInfo;
using EngineInfo::getBaseCopyEngineType;
MockEngineInfo(Drm *drm, const std::vector<EngineCapabilities> &engineInfos) : EngineInfo(drm, engineInfos){};
};
TEST(DrmTest, givenCapsWhenCallGetBaseCopyEngineTypeAndIsIntegratedGpuThenBcs0AlwaysIsReturned) {
@@ -847,8 +848,9 @@ TEST(DrmTest, givenCapsWhenCallGetBaseCopyEngineTypeAndIsIntegratedGpuThenBcs0Al
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
drm->ioctlHelper = std::make_unique<IoctlHelperPrelim20>(*drm);
std::vector<NEO::EngineCapabilities> i915engineInfo(1);
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915engineInfo};
auto engineInfo = std::make_unique<MockEngineInfo>(drm.get(), i915engineInfo);
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));
@@ -866,7 +868,9 @@ TEST(DrmTest, givenCapsWhenCallGetBaseCopyEngineTypeAndIsNotIntegratedGpuThenPro
drm->ioctlHelper = std::make_unique<IoctlHelperPrelim20>(*drm);
std::vector<NEO::EngineCapabilities> i915engineInfo(1);
auto engineInfo = std::make_unique<MockEngineInfo>(drm.get(), i915engineInfo);
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915engineInfo};
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));

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

@@ -66,13 +66,21 @@ TEST(EngineInfoTest, whenCreateEngineInfoWithRcsThenCorrectHwInfoSet) {
engines[0].capabilities = 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(), engines);
StackVec<std::vector<EngineCapabilities>, 2> engineInfosPerTile{engines};
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), engineInfosPerTile);
auto ccsInfo = hwInfo.gtSystemInfo.CCSInfo;
EXPECT_FALSE(ccsInfo.IsValid);
EXPECT_EQ(0u, ccsInfo.NumberOfCCSEnabled);
EXPECT_EQ(0u, ccsInfo.Instances.CCSEnableMask);
EXPECT_EQ(1u, hwInfo.featureTable.ftrBcsInfo.to_ulong());
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
auto defaultCopyEngine = productHelper.getDefaultCopyEngine();
if (defaultCopyEngine == aub_stream::EngineType::ENGINE_BCS) {
EXPECT_EQ(1u, hwInfo.featureTable.ftrBcsInfo.to_ulong());
} else {
EXPECT_TRUE(hwInfo.featureTable.ftrBcsInfo.test(static_cast<uint32_t>(defaultCopyEngine) - static_cast<uint32_t>(aub_stream::EngineType::ENGINE_BCS1) + 1));
}
}
TEST(EngineInfoTest, whenCallingGetEngineTileInfoCorrectValuesAreReturned) {
@@ -83,7 +91,8 @@ TEST(EngineInfoTest, whenCallingGetEngineTileInfoCorrectValuesAreReturned) {
std::vector<EngineCapabilities> engines(1);
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 0};
engines[0].capabilities = 0;
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), engines);
StackVec<std::vector<EngineCapabilities>, 2> engineInfosPerTile{engines};
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), engineInfosPerTile);
auto engineTileMap = engineInfo->getEngineTileInfo();
auto it = engineTileMap.begin();
@@ -103,13 +112,21 @@ TEST(EngineInfoTest, whenCreateEngineInfoWithCcsThenCorrectHwInfoSet) {
engines[0].capabilities = 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(), engines);
StackVec<std::vector<EngineCapabilities>, 2> engineInfosPerTile{engines};
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), engineInfosPerTile);
auto ccsInfo = hwInfo.gtSystemInfo.CCSInfo;
EXPECT_TRUE(ccsInfo.IsValid);
EXPECT_EQ(1u, ccsInfo.NumberOfCCSEnabled);
EXPECT_EQ(1u, ccsInfo.Instances.CCSEnableMask);
EXPECT_EQ(1u, hwInfo.featureTable.ftrBcsInfo.to_ulong());
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
auto defaultCopyEngine = productHelper.getDefaultCopyEngine();
if (defaultCopyEngine == aub_stream::EngineType::ENGINE_BCS) {
EXPECT_EQ(1u, hwInfo.featureTable.ftrBcsInfo.to_ulong());
} else {
EXPECT_TRUE(hwInfo.featureTable.ftrBcsInfo.test(static_cast<uint32_t>(defaultCopyEngine) - static_cast<uint32_t>(aub_stream::EngineType::ENGINE_BCS1) + 1));
}
}
TEST(EngineInfoTest, whenGetEngineInstanceAndTileThenCorrectValuesReturned) {