intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(sysman): Refine Sysman Engine Module

Browse Source 
Related-To: NEO-14756

Signed-off-by: Pratik Bari <pratik.bari@intel.com>
This commit is contained in:
Pratik Bari
2025-07-25 09:30:44 +00:00
committed by Compute-Runtime-Automation
parent dfc97c016e
commit 3f241b9fc5
28 changed files with 618 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.cpp
View File

@@ -22,9 +22,9 @@ namespace L0 {
namespace Sysman {
void LinuxEngineImp::cleanup() {
for (auto &fdPair : fdList) {
DEBUG_BREAK_IF(fdPair.first < 0);
NEO::SysCalls::close(static_cast<int>(fdPair.first));
for (auto &fd : fdList) {
DEBUG_BREAK_IF(fd < 0);
NEO::SysCalls::close(static_cast<int>(fd));
}
fdList.clear();
}
@@ -49,7 +49,7 @@ zes_engine_group_t LinuxEngineImp::getGroupFromEngineType(zes_engine_group_t typ
return ZES_ENGINE_GROUP_ALL;
}
ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine_group_t, EngineInstanceSubDeviceId>> &engineGroupInstance, OsSysman *pOsSysman) {
ze_result_t OsEngine::getNumEngineTypeAndInstances(MapOfEngineInfo &mapEngineInfo, OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
NEO::Drm *pDrm = pLinuxSysmanImp->getDrm();
auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
@@ -68,6 +68,7 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():sysmanQueryEngineInfo is returning false and error message:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto engineInfo = pDrm->getEngineInfo();
auto engineTileMap = engineInfo->getEngineTileInfo();
for (auto itr = engineTileMap.begin(); itr != engineTileMap.end(); ++itr) {
@@ -75,10 +76,37 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine
auto engineGroupRange = engineClassToEngineGroup.equal_range(static_cast<uint16_t>(itr->second.engineClass));
for (auto l0EngineEntryInMap = engineGroupRange.first; l0EngineEntryInMap != engineGroupRange.second; l0EngineEntryInMap++) {
auto l0EngineType = l0EngineEntryInMap->second;
engineGroupInstance.insert({l0EngineType, {static_cast<uint32_t>(itr->second.engineInstance), tileId}});
// Addition of Single Engine Info in the map
auto itrEngineGroupInfo = mapEngineInfo.find(l0EngineType);
auto engineInstanceTileId = std::pair(static_cast<uint32_t>(itr->second.engineInstance), tileId);
if (itrEngineGroupInfo != mapEngineInfo.end()) {
itrEngineGroupInfo->second.insert({engineInstanceTileId});
} else {
SetOfEngineInstanceAndTileId engineInstancesAndTileIds = {engineInstanceTileId};
mapEngineInfo[l0EngineType] = engineInstancesAndTileIds;
}
// Addition of Group Engine Info in the map
if (pSysmanKmdInterface->isGroupEngineInterfaceAvailable() || pSysmanProductHelper->isAggregationOfSingleEnginesSupported()) {
engineGroupInstance.insert({LinuxEngineImp::getGroupFromEngineType(l0EngineType), {0u, tileId}});
engineGroupInstance.insert({ZES_ENGINE_GROUP_ALL, {0u, tileId}});
auto engineGroup = LinuxEngineImp::getGroupFromEngineType(l0EngineType);
auto itrEngineGroupInfo = mapEngineInfo.find(engineGroup);
if (itrEngineGroupInfo != mapEngineInfo.end()) {
itrEngineGroupInfo->second.insert({0u, tileId});
} else {
SetOfEngineInstanceAndTileId engineInstancesAndTileIds = {{0u, tileId}};
mapEngineInfo[engineGroup] = engineInstancesAndTileIds;
}
itrEngineGroupInfo = mapEngineInfo.find(ZES_ENGINE_GROUP_ALL);
if (itrEngineGroupInfo != mapEngineInfo.end()) {
itrEngineGroupInfo->second.insert({0u, tileId});
} else {
SetOfEngineInstanceAndTileId engineInstancesAndTileIds = {{0u, tileId}};
mapEngineInfo[ZES_ENGINE_GROUP_ALL] = engineInstancesAndTileIds;
}
}
}
}
@@ -86,26 +114,66 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine
}
ze_result_t LinuxEngineImp::getActivity(zes_engine_stats_t *pStats) {
auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
if (!fdList.empty()) {
return pSysmanKmdInterface->readBusynessFromGroupFd(pPmuInterface, fdList[0], pStats);
} else if (pSysmanProductHelper->isAggregationOfSingleEnginesSupported()) {
return pSysmanProductHelper->getGroupEngineBusynessFromSingleEngines(pLinuxSysmanImp, pStats, engineGroup);
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return pSysmanKmdInterface->readBusynessFromGroupFd(pPmuInterface, fdList, pStats);
}
ze_result_t LinuxEngineImp::getProperties(zes_engine_properties_t &properties) {
properties.type = engineGroup;
properties.type = engineGroupInfo.engineGroup;
properties.onSubdevice = onSubDevice;
properties.subdeviceId = tileId;
properties.subdeviceId = engineGroupInfo.tileId;
return ZE_RESULT_SUCCESS;
}
void LinuxEngineImp::init() {
initStatus = pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(engineGroup, engineInstance, gtId, pPmuInterface, fdList, pmuConfigPair);
void LinuxEngineImp::init(MapOfEngineInfo &mapEngineInfo) {
std::vector<uint64_t> pmuConfigs;
const std::string sysmanDeviceDir = std::string(sysDevicesDir) + pSysmanKmdInterface->getSysmanDeviceDirName();
if (isGroupEngineHandle(engineGroupInfo.engineGroup)) {
initStatus = pSysmanKmdInterface->getPmuConfigsForGroupEngines(mapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface, pDrm, pmuConfigs);
} else {
initStatus = pSysmanKmdInterface->getPmuConfigsForSingleEngines(sysmanDeviceDir, engineGroupInfo, pPmuInterface, pDrm, pmuConfigs);
}
if (initStatus != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to fetch Pmu Configs \n", __FUNCTION__);
return;
} else {
if (pmuConfigs.empty()) {
initStatus = ZE_RESULT_ERROR_UNKNOWN;
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmu Configs Not Available \n", __FUNCTION__);
return;
} else {
for (auto &config : pmuConfigs) {
int64_t fd = -1;
if (fdList.empty()) {
if (pmuConfigs.size() == 1) {
fd = pPmuInterface->pmuInterfaceOpen(config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED);
} else {
fd = pPmuInterface->pmuInterfaceOpen(config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
}
if (fd < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Could not open Ticks Handle \n", __FUNCTION__);
initStatus = pSysmanKmdInterface->checkErrorNumberAndReturnStatus();
return;
}
} else {
fd = pPmuInterface->pmuInterfaceOpen(config, static_cast<int>(fdList[0]), PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
if (fd < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Could not open Ticks Handle \n", __FUNCTION__);
for (auto &fd : fdList) {
NEO::SysCalls::close(static_cast<int>(fd));
}
fdList.clear();
initStatus = pSysmanKmdInterface->checkErrorNumberAndReturnStatus();
return;
}
}
fdList.push_back(fd);
}
initStatus = ZE_RESULT_SUCCESS;
}
}
}
bool LinuxEngineImp::isEngineModuleSupported() {
@@ -115,148 +183,26 @@ bool LinuxEngineImp::isEngineModuleSupported() {
return true;
}
void LinuxEngineImp::getConfigPair(std::pair<uint64_t, uint64_t> &configPair) {
configPair = pmuConfigPair;
return;
}
LinuxEngineImp::LinuxEngineImp(OsSysman *pOsSysman, MapOfEngineInfo &mapEngineInfo, zes_engine_group_t type, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice) : onSubDevice(onSubDevice) {
LinuxEngineImp::LinuxEngineImp(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice) : engineGroup(type), engineInstance(engineInstance), tileId(tileId), onSubDevice(onSubDevice) {
pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
engineGroupInfo.engineGroup = type;
engineGroupInfo.engineInstance = engineInstance;
engineGroupInfo.tileId = tileId;
pDrm = pLinuxSysmanImp->getDrm();
pDevice = pLinuxSysmanImp->getSysmanDeviceImp();
pPmuInterface = pLinuxSysmanImp->getPmuInterface();
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
if (!isGroupEngineHandle(type)) {
auto engineClass = engineGroupToEngineClass.find(type);
gtId = pDrm->getIoctlHelper()->getGtIdFromTileId(tileId, engineClass->second);
}
init();
init(mapEngineInfo);
if (initStatus != ZE_RESULT_SUCCESS) {
cleanup();
}
}
std::unique_ptr<OsEngine> OsEngine::create(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice) {
std::unique_ptr<LinuxEngineImp> pLinuxEngineImp = std::make_unique<LinuxEngineImp>(pOsSysman, type, engineInstance, tileId, onSubDevice);
std::unique_ptr<OsEngine> OsEngine::create(OsSysman *pOsSysman, MapOfEngineInfo &mapEngineInfo, zes_engine_group_t type, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice) {
std::unique_ptr<LinuxEngineImp> pLinuxEngineImp = std::make_unique<LinuxEngineImp>(pOsSysman, mapEngineInfo, type, engineInstance, tileId, onSubDevice);
return pLinuxEngineImp;
}
static int32_t getFdList(PmuInterface *const &pPmuInterface, std::vector<uint64_t> &engineConfigs, std::vector<int64_t> &fdList) {
for (auto &engineConfig : engineConfigs) {
int64_t fd = -1;
if (fdList.empty()) {
fd = pPmuInterface->pmuInterfaceOpen(engineConfig, -1, PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
if (fd < 0) {
return -1;
}
} else {
fd = pPmuInterface->pmuInterfaceOpen(engineConfig, static_cast<int>(fdList[0]), PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
if (fd < 0) {
return -1;
}
}
fdList.push_back(fd);
}
return 0;
}
static void closeFds(std::vector<int64_t> &fdList) {
if (!fdList.empty()) {
for (auto &fd : fdList) {
DEBUG_BREAK_IF(fd < 0);
NEO::SysCalls::close(static_cast<int>(fd));
}
fdList.clear();
}
}
void OsEngine::initGroupEngineHandleGroupFd(OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
if (!pSysmanProductHelper->isAggregationOfSingleEnginesSupported()) {
return;
}
auto pPmuInterface = pLinuxSysmanImp->getPmuInterface();
auto pSysmanDeviceImp = pLinuxSysmanImp->getSysmanDeviceImp();
std::vector<uint64_t> mediaEngineConfigs{};
std::vector<uint64_t> computeEngineConfigs{};
std::vector<uint64_t> copyEngineConfigs{};
std::vector<uint64_t> renderEngineConfigs{};
std::vector<uint64_t> allEnginesConfigs{};
for (auto &engine : pSysmanDeviceImp->pEngineHandleContext->handleList) {
zes_engine_properties_t engineProperties = {};
engine->engineGetProperties(&engineProperties);
if (engineProperties.type == ZES_ENGINE_GROUP_MEDIA_DECODE_SINGLE || engineProperties.type == ZES_ENGINE_GROUP_MEDIA_ENCODE_SINGLE || engineProperties.type == ZES_ENGINE_GROUP_MEDIA_ENHANCEMENT_SINGLE) {
mediaEngineConfigs.push_back(engine->configPair.first);
mediaEngineConfigs.push_back(engine->configPair.second);
} else if (engineProperties.type == ZES_ENGINE_GROUP_COMPUTE_SINGLE) {
computeEngineConfigs.push_back(engine->configPair.first);
computeEngineConfigs.push_back(engine->configPair.second);
} else if (engineProperties.type == ZES_ENGINE_GROUP_COPY_SINGLE) {
copyEngineConfigs.push_back(engine->configPair.first);
copyEngineConfigs.push_back(engine->configPair.second);
} else if (engineProperties.type == ZES_ENGINE_GROUP_RENDER_SINGLE) {
renderEngineConfigs.push_back(engine->configPair.first);
renderEngineConfigs.push_back(engine->configPair.second);
}
}
uint64_t allEngineGroupsSize = mediaEngineConfigs.size() + computeEngineConfigs.size() + copyEngineConfigs.size() + renderEngineConfigs.size();
allEnginesConfigs.reserve(allEngineGroupsSize);
allEnginesConfigs.insert(allEnginesConfigs.end(), mediaEngineConfigs.begin(), mediaEngineConfigs.end());
allEnginesConfigs.insert(allEnginesConfigs.end(), computeEngineConfigs.begin(), computeEngineConfigs.end());
allEnginesConfigs.insert(allEnginesConfigs.end(), copyEngineConfigs.begin(), copyEngineConfigs.end());
allEnginesConfigs.insert(allEnginesConfigs.end(), renderEngineConfigs.begin(), renderEngineConfigs.end());
std::vector<std::unique_ptr<L0::Sysman::Engine>>::iterator it = pSysmanDeviceImp->pEngineHandleContext->handleList.begin();
while (it != pSysmanDeviceImp->pEngineHandleContext->handleList.end()) {
int32_t ret = 0;
zes_engine_properties_t engineProperties = {};
(*it)->engineGetProperties(&engineProperties);
if (engineProperties.type == ZES_ENGINE_GROUP_MEDIA_ALL) {
ret = getFdList(pPmuInterface, mediaEngineConfigs, (*it)->fdList);
} else if (engineProperties.type == ZES_ENGINE_GROUP_COMPUTE_ALL) {
ret = getFdList(pPmuInterface, computeEngineConfigs, (*it)->fdList);
} else if (engineProperties.type == ZES_ENGINE_GROUP_COPY_ALL) {
ret = getFdList(pPmuInterface, copyEngineConfigs, (*it)->fdList);
} else if (engineProperties.type == ZES_ENGINE_GROUP_RENDER_ALL) {
ret = getFdList(pPmuInterface, renderEngineConfigs, (*it)->fdList);
} else if (engineProperties.type == ZES_ENGINE_GROUP_ALL) {
ret = getFdList(pPmuInterface, allEnginesConfigs, (*it)->fdList);
}
if (ret < 0) {
closeFds((*it)->fdList);
it = pSysmanDeviceImp->pEngineHandleContext->handleList.erase(it);
} else {
++it;
}
}
return;
}
void OsEngine::closeFdsForGroupEngineHandles(OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
auto pSysmanDeviceImp = pLinuxSysmanImp->getSysmanDeviceImp();
for (auto &engine : pSysmanDeviceImp->pEngineHandleContext->handleList) {
closeFds(engine->fdList);
}
}
} // namespace Sysman
} // namespace L0

20
level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h
View File

@@ -21,6 +21,13 @@ class SysmanKmdInterface;
class PmuInterface;
class LinuxSysmanImp;
struct Device;
struct EngineGroupInfo {
zes_engine_group_t engineGroup;
uint32_t engineInstance;
uint32_t tileId;
};
class LinuxEngineImp : public OsEngine, NEO::NonCopyableAndNonMovableClass {
public:
ze_result_t getActivity(zes_engine_stats_t *pStats) override;
@@ -30,28 +37,23 @@ class LinuxEngineImp : public OsEngine, NEO::NonCopyableAndNonMovableClass {
ze_result_t getProperties(zes_engine_properties_t &properties) override;
bool isEngineModuleSupported() override;
static zes_engine_group_t getGroupFromEngineType(zes_engine_group_t type);
void getConfigPair(std::pair<uint64_t, uint64_t> &configPair) override;
LinuxEngineImp() = default;
LinuxEngineImp(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice);
LinuxEngineImp(OsSysman *pOsSysman, MapOfEngineInfo &mapEngineInfo, zes_engine_group_t type, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice);
~LinuxEngineImp() override;
void cleanup();
protected:
SysmanKmdInterface *pSysmanKmdInterface = nullptr;
LinuxSysmanImp *pLinuxSysmanImp = nullptr;
zes_engine_group_t engineGroup = ZES_ENGINE_GROUP_ALL;
uint32_t engineInstance = 0;
EngineGroupInfo engineGroupInfo = {};
PmuInterface *pPmuInterface = nullptr;
NEO::Drm *pDrm = nullptr;
SysmanDeviceImp *pDevice = nullptr;
uint32_t gtId = 0;
uint32_t tileId = 0;
ze_bool_t onSubDevice = false;
private:
void init();
std::vector<std::pair<int64_t, int64_t>> fdList{};
std::pair<uint64_t, uint64_t> pmuConfigPair{};
void init(MapOfEngineInfo &mapEngineInfo);
std::vector<int64_t> fdList{};
ze_result_t initStatus = ZE_RESULT_SUCCESS;
};

20
level_zero/sysman/source/api/engine/sysman_engine.cpp
View File

@@ -24,31 +24,33 @@ EngineHandleContext::~EngineHandleContext() {
releaseEngines();
}
void EngineHandleContext::createHandle(zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice) {
std::unique_ptr<Engine> pEngine = std::make_unique<EngineImp>(pOsSysman, engineType, engineInstance, tileId, onSubdevice);
void EngineHandleContext::createHandle(MapOfEngineInfo &mapEngineInfo, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice) {
std::unique_ptr<Engine> pEngine = std::make_unique<EngineImp>(pOsSysman, mapEngineInfo, engineType, engineInstance, tileId, onSubdevice);
if (pEngine->initSuccess == true) {
handleList.push_back(std::move(pEngine));
}
}
void EngineHandleContext::init(uint32_t subDeviceCount) {
std::set<std::pair<zes_engine_group_t, EngineInstanceSubDeviceId>> engineGroupInstance = {}; // set contains pair of engine group and struct containing engine instance and gtId
deviceEngineInitStatus = OsEngine::getNumEngineTypeAndInstances(engineGroupInstance, pOsSysman);
MapOfEngineInfo mapEngineInfo = {};
deviceEngineInitStatus = OsEngine::getNumEngineTypeAndInstances(mapEngineInfo, pOsSysman);
if (deviceEngineInitStatus != ZE_RESULT_SUCCESS) {
return;
}
for (auto itr = engineGroupInstance.begin(); itr != engineGroupInstance.end(); ++itr) {
for (auto &engineInfo : mapEngineInfo) {
const auto isSubDevice = subDeviceCount > 0;
createHandle(itr->first, itr->second.first, itr->second.second, isSubDevice);
auto engineGroup = engineInfo.first;
auto setEngineInstanceAndTileId = engineInfo.second;
for (auto &engineInstanceAndTileId : setEngineInstanceAndTileId) {
createHandle(mapEngineInfo, engineGroup, engineInstanceAndTileId.first, engineInstanceAndTileId.second, isSubDevice);
}
}
OsEngine::initGroupEngineHandleGroupFd(pOsSysman);
}
void EngineHandleContext::releaseEngines() {
OsEngine::closeFdsForGroupEngineHandles(pOsSysman);
handleList.clear();
}

11
level_zero/sysman/source/api/engine/sysman_engine.h
View File

@@ -12,11 +12,16 @@
#include <map>
#include <mutex>
#include <set>
#include <vector>
namespace L0 {
namespace Sysman {
using EngineInstanceSubDeviceId = std::pair<uint32_t, uint32_t>;
typedef std::pair<uint32_t, uint32_t> EngineInstanceAndTileId;
typedef std::set<EngineInstanceAndTileId> SetOfEngineInstanceAndTileId;
typedef std::map<zes_engine_group_t, SetOfEngineInstanceAndTileId> MapOfEngineInfo;
struct OsSysman;
class Engine : _zes_engine_handle_t {
@@ -31,8 +36,6 @@ class Engine : _zes_engine_handle_t {
}
inline zes_engine_handle_t toHandle() { return this; }
bool initSuccess = false;
std::pair<uint64_t, uint64_t> configPair{};
std::vector<int64_t> fdList{};
};
struct EngineHandleContext {
@@ -50,7 +53,7 @@ struct EngineHandleContext {
}
private:
void createHandle(zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice);
void createHandle(MapOfEngineInfo &mapEngineInfo, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice);
std::once_flag initEngineOnce;
bool engineInitDone = false;
ze_result_t deviceEngineInitStatus = ZE_RESULT_SUCCESS;

5
level_zero/sysman/source/api/engine/sysman_engine_imp.cpp
View File

@@ -26,13 +26,12 @@ ze_result_t EngineImp::engineGetProperties(zes_engine_properties_t *pProperties)
void EngineImp::init() {
if (pOsEngine->isEngineModuleSupported()) {
pOsEngine->getProperties(engineProperties);
pOsEngine->getConfigPair(this->configPair);
this->initSuccess = true;
}
}
EngineImp::EngineImp(OsSysman *pOsSysman, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice) {
pOsEngine = OsEngine::create(pOsSysman, engineType, engineInstance, tileId, onSubdevice);
EngineImp::EngineImp(OsSysman *pOsSysman, MapOfEngineInfo &mapEngineInfo, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice) {
pOsEngine = OsEngine::create(pOsSysman, mapEngineInfo, engineType, engineInstance, tileId, onSubdevice);
init();
}

2
level_zero/sysman/source/api/engine/sysman_engine_imp.h
View File

@@ -22,7 +22,7 @@ class EngineImp : public Engine, NEO::NonCopyableAndNonMovableClass {
ze_result_t engineGetActivityExt(uint32_t *pCount, zes_engine_stats_t *pStats) override;
EngineImp() = default;
EngineImp(OsSysman *pOsSysman, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice);
EngineImp(OsSysman *pOsSysman, MapOfEngineInfo &mapEngineInfo, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice);
~EngineImp() override;
std::unique_ptr<OsEngine> pOsEngine;

7
level_zero/sysman/source/api/engine/sysman_os_engine.h
View File

@@ -22,12 +22,9 @@ class OsEngine {
virtual ze_result_t getActivity(zes_engine_stats_t *pStats) = 0;
virtual ze_result_t getActivityExt(uint32_t *pCount, zes_engine_stats_t *pStats) = 0;
virtual ze_result_t getProperties(zes_engine_properties_t &properties) = 0;
virtual void getConfigPair(std::pair<uint64_t, uint64_t> &configPair) = 0;
virtual bool isEngineModuleSupported() = 0;
static std::unique_ptr<OsEngine> create(OsSysman *pOsSysman, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice);
static ze_result_t getNumEngineTypeAndInstances(std::set<std::pair<zes_engine_group_t, EngineInstanceSubDeviceId>> &engineGroupInstance, OsSysman *pOsSysman);
static void initGroupEngineHandleGroupFd(OsSysman *pOsSysman);
static void closeFdsForGroupEngineHandles(OsSysman *pOsSysman);
static std::unique_ptr<OsEngine> create(OsSysman *pOsSysman, MapOfEngineInfo &mapEngineInfo, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubdevice);
static ze_result_t getNumEngineTypeAndInstances(MapOfEngineInfo &mapEngineInfo, OsSysman *pOsSysman);
virtual ~OsEngine() = default;
};

19
level_zero/sysman/source/api/engine/windows/sysman_os_engine_imp.cpp
View File

@@ -94,17 +94,16 @@ WddmEngineImp::WddmEngineImp(OsSysman *pOsSysman, zes_engine_group_t engineType,
pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
}
std::unique_ptr<OsEngine> OsEngine::create(OsSysman *pOsSysman, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice) {
std::unique_ptr<OsEngine> OsEngine::create(OsSysman *pOsSysman, MapOfEngineInfo &mapEngineInfo, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t tileId, ze_bool_t onSubDevice) {
std::unique_ptr<WddmEngineImp> pWddmEngineImp = std::make_unique<WddmEngineImp>(pOsSysman, engineType, engineInstance, tileId);
return pWddmEngineImp;
}
ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine_group_t, EngineInstanceSubDeviceId>> &engineGroupInstance, OsSysman *pOsSysman) {
ze_result_t OsEngine::getNumEngineTypeAndInstances(MapOfEngineInfo &mapEngineInfo, OsSysman *pOsSysman) {
WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
engineGroupInstance.clear();
// create multiple requests for all the possible engine groups
std::vector<KmdSysman::RequestProperty> vRequests{};
std::vector<KmdSysman::ResponseProperty> vResponses{};
@@ -131,26 +130,20 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine
uint32_t index = 0;
for (auto &engineGroup : engineGroupToDomainTypeMap) {
SetOfEngineInstanceAndTileId engineInstancesAndTileIds = {};
if (vResponses[index].dataSize > 0) {
uint32_t instanceCount = 0;
memcpy_s(&instanceCount, sizeof(uint32_t), vResponses[index].dataBuffer, sizeof(uint32_t));
for (uint32_t instance = 0; instance < instanceCount; instance++) {
engineGroupInstance.insert({engineGroup.first, {instance, 0}});
engineInstancesAndTileIds.insert({instance, 0});
}
}
mapEngineInfo[engineGroup.first] = engineInstancesAndTileIds;
index++;
}
return status;
}
void OsEngine::initGroupEngineHandleGroupFd(OsSysman *pOsSysman) {
return;
}
void OsEngine::closeFdsForGroupEngineHandles(OsSysman *pOsSysman) {
return;
}
} // namespace Sysman
} // namespace L0

1
level_zero/sysman/source/api/engine/windows/sysman_os_engine_imp.h
View File

@@ -20,7 +20,6 @@ class WddmEngineImp : public OsEngine, NEO::NonCopyableAndNonMovableClass {
ze_result_t getActivityExt(uint32_t *pCount, zes_engine_stats_t *pStats) override;
ze_result_t getProperties(zes_engine_properties_t &properties) override;
bool isEngineModuleSupported() override;
void getConfigPair(std::pair<uint64_t, uint64_t> &configPair) override { return; }
WddmEngineImp() = default;
WddmEngineImp(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t tileId);

80
level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h
View File

@@ -7,6 +7,7 @@
#pragma once
#include "level_zero/sysman/source/api/engine/sysman_engine.h"
#include <level_zero/zes_api.h>
#include "neo_igfxfmid.h"
@@ -14,6 +15,7 @@
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
@@ -31,6 +33,8 @@ class PmuInterface;
class LinuxSysmanImp;
class SysmanProductHelper;
struct EngineGroupInfo;
constexpr std::string_view deviceDir("device");
constexpr std::string_view sysDevicesDir("/sys/devices/");
constexpr std::string_view mediaDirSuffix("1");
@@ -128,13 +132,18 @@ class SysmanKmdInterface {
zes_freq_domain_t frequencyDomainNumber) = 0;
virtual std::string getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) = 0;
virtual std::string getEnergyCounterNodeFile(zes_power_domain_t powerDomain) = 0;
virtual ze_result_t getEngineActivityFdListAndConfigPair(zes_engine_group_t engineGroup,
uint32_t engineInstance,
uint32_t gtId,
PmuInterface *const &pPmuInterface,
std::vector<std::pair<int64_t, int64_t>> &fdList,
std::pair<uint64_t, uint64_t> &configPair) = 0;
virtual ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::pair<int64_t, int64_t> &fdPair, zes_engine_stats_t *pStats) = 0;
virtual ze_result_t getPmuConfigsForSingleEngines(const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) = 0;
virtual ze_result_t getPmuConfigsForGroupEngines(const MapOfEngineInfo &mapEngineInfo,
const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) = 0;
virtual ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::vector<int64_t> &fdList, zes_engine_stats_t *pStats) = 0;
virtual std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const = 0;
virtual bool isStandbyModeControlAvailable() const = 0;
virtual bool clientInfoAvailableInFdInfo() const = 0;
@@ -221,13 +230,18 @@ class SysmanKmdInterfaceI915Upstream : public SysmanKmdInterface, SysmanKmdInter
zes_freq_domain_t frequencyDomainNumber) override;
std::string getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) override;
std::string getEnergyCounterNodeFile(zes_power_domain_t powerDomain) override;
ze_result_t getEngineActivityFdListAndConfigPair(zes_engine_group_t engineGroup,
uint32_t engineInstance,
uint32_t gtId,
PmuInterface *const &pPmuInterface,
std::vector<std::pair<int64_t, int64_t>> &fdList,
std::pair<uint64_t, uint64_t> &configPair) override;
ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::pair<int64_t, int64_t> &fdPair, zes_engine_stats_t *pStats) override;
ze_result_t getPmuConfigsForSingleEngines(const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) override;
ze_result_t getPmuConfigsForGroupEngines(const MapOfEngineInfo &mapEngineInfo,
const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) override;
ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::vector<int64_t> &fdList, zes_engine_stats_t *pStats) override;
std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const override;
bool isStandbyModeControlAvailable() const override { return true; }
bool clientInfoAvailableInFdInfo() const override { return false; }
@@ -286,13 +300,18 @@ class SysmanKmdInterfaceI915Prelim : public SysmanKmdInterface, SysmanKmdInterfa
zes_freq_domain_t frequencyDomainNumber) override;
std::string getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) override;
std::string getEnergyCounterNodeFile(zes_power_domain_t powerDomain) override;
ze_result_t getEngineActivityFdListAndConfigPair(zes_engine_group_t engineGroup,
uint32_t engineInstance,
uint32_t gtId,
PmuInterface *const &pPmuInterface,
std::vector<std::pair<int64_t, int64_t>> &fdList,
std::pair<uint64_t, uint64_t> &configPair) override;
ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::pair<int64_t, int64_t> &fdPair, zes_engine_stats_t *pStats) override;
ze_result_t getPmuConfigsForSingleEngines(const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) override;
ze_result_t getPmuConfigsForGroupEngines(const MapOfEngineInfo &mapEngineInfo,
const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) override;
ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::vector<int64_t> &fdList, zes_engine_stats_t *pStats) override;
std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const override;
bool isStandbyModeControlAvailable() const override { return true; }
bool clientInfoAvailableInFdInfo() const override { return false; }
@@ -352,13 +371,18 @@ class SysmanKmdInterfaceXe : public SysmanKmdInterface {
std::string getSysfsFilePathForPhysicalMemorySize(uint32_t subDeviceId) override;
std::string getEngineBasePath(uint32_t subDeviceId) const override;
std::string getEnergyCounterNodeFile(zes_power_domain_t powerDomain) override;
ze_result_t getEngineActivityFdListAndConfigPair(zes_engine_group_t engineGroup,
uint32_t engineInstance,
uint32_t gtId,
PmuInterface *const &pPmuInterface,
std::vector<std::pair<int64_t, int64_t>> &fdList,
std::pair<uint64_t, uint64_t> &configPair) override;
ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::pair<int64_t, int64_t> &fdPair, zes_engine_stats_t *pStats) override;
ze_result_t getPmuConfigsForSingleEngines(const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) override;
ze_result_t getPmuConfigsForGroupEngines(const MapOfEngineInfo &mapEngineInfo,
const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) override;
ze_result_t readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::vector<int64_t> &fdList, zes_engine_stats_t *pStats) override;
std::string getHwmonName(uint32_t subDeviceId, bool isSubdevice) const override;
bool isStandbyModeControlAvailable() const override { return false; }
bool clientInfoAvailableInFdInfo() const override { return true; }

78
level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_i915_prelim.cpp
View File

@@ -8,6 +8,7 @@
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/os_interface/linux/i915_prelim.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
@@ -117,63 +118,64 @@ std::string SysmanKmdInterfaceI915Prelim::getBurstPowerLimitFile(SysfsName sysfs
return "";
}
ze_result_t SysmanKmdInterfaceI915Prelim::getEngineActivityFdListAndConfigPair(zes_engine_group_t engineGroup,
uint32_t engineInstance,
uint32_t gtId,
PmuInterface *const &pPmuInterface,
std::vector<std::pair<int64_t, int64_t>> &fdList,
std::pair<uint64_t, uint64_t> &configPair) {
uint64_t config = UINT64_MAX;
switch (engineGroup) {
ze_result_t SysmanKmdInterfaceI915Prelim::getPmuConfigsForGroupEngines(const MapOfEngineInfo &mapEngineInfo,
const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) {
uint64_t busyTicksConfig = UINT64_MAX;
uint64_t totalTicksConfig = UINT64_MAX;
switch (engineInfo.engineGroup) {
case ZES_ENGINE_GROUP_ALL:
config = __PRELIM_I915_PMU_ANY_ENGINE_GROUP_BUSY_TICKS(gtId);
busyTicksConfig = __PRELIM_I915_PMU_ANY_ENGINE_GROUP_BUSY_TICKS(engineInfo.tileId);
break;
case ZES_ENGINE_GROUP_COMPUTE_ALL:
case ZES_ENGINE_GROUP_RENDER_ALL:
config = __PRELIM_I915_PMU_RENDER_GROUP_BUSY_TICKS(gtId);
busyTicksConfig = __PRELIM_I915_PMU_RENDER_GROUP_BUSY_TICKS(engineInfo.tileId);
break;
case ZES_ENGINE_GROUP_COPY_ALL:
config = __PRELIM_I915_PMU_COPY_GROUP_BUSY_TICKS(gtId);
busyTicksConfig = __PRELIM_I915_PMU_COPY_GROUP_BUSY_TICKS(engineInfo.tileId);
break;
case ZES_ENGINE_GROUP_MEDIA_ALL:
config = __PRELIM_I915_PMU_MEDIA_GROUP_BUSY_TICKS(gtId);
busyTicksConfig = __PRELIM_I915_PMU_MEDIA_GROUP_BUSY_TICKS(engineInfo.tileId);
break;
default:
auto i915EngineClass = engineGroupToEngineClass.find(engineGroup);
config = PRELIM_I915_PMU_ENGINE_BUSY_TICKS(i915EngineClass->second, engineInstance);
break;
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Engine Group Not Supported and returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
int64_t fd[2];
totalTicksConfig = __PRELIM_I915_PMU_TOTAL_ACTIVE_TICKS(engineInfo.tileId);
if (isGroupEngineHandle(engineGroup)) {
configPair = std::make_pair(config, __PRELIM_I915_PMU_TOTAL_ACTIVE_TICKS(gtId));
} else {
auto i915EngineClass = engineGroupToEngineClass.find(engineGroup);
configPair = std::make_pair(config, PRELIM_I915_PMU_ENGINE_TOTAL_TICKS(i915EngineClass->second, engineInstance));
}
pmuConfigs.push_back(busyTicksConfig);
pmuConfigs.push_back(totalTicksConfig);
fd[0] = pPmuInterface->pmuInterfaceOpen(configPair.first, -1, PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
if (fd[0] < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Could not open Busy Ticks Handle \n", __FUNCTION__);
return checkErrorNumberAndReturnStatus();
}
fd[1] = pPmuInterface->pmuInterfaceOpen(configPair.second, static_cast<int>(fd[0]), PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
if (fd[1] < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Could not open Total Active Ticks Handle \n", __FUNCTION__);
NEO::SysCalls::close(static_cast<int>(fd[0]));
return checkErrorNumberAndReturnStatus();
}
fdList.push_back(std::make_pair(fd[0], fd[1]));
return ZE_RESULT_SUCCESS;
}
ze_result_t SysmanKmdInterfaceI915Prelim::readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::pair<int64_t, int64_t> &fdPair, zes_engine_stats_t *pStats) {
ze_result_t SysmanKmdInterfaceI915Prelim::getPmuConfigsForSingleEngines(const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) {
uint64_t busyTicksConfig = UINT64_MAX;
uint64_t totalTicksConfig = UINT64_MAX;
auto i915EngineClass = engineGroupToEngineClass.find(engineInfo.engineGroup);
busyTicksConfig = PRELIM_I915_PMU_ENGINE_BUSY_TICKS(i915EngineClass->second, engineInfo.engineInstance);
totalTicksConfig = PRELIM_I915_PMU_ENGINE_TOTAL_TICKS(i915EngineClass->second, engineInfo.engineInstance);
pmuConfigs.push_back(busyTicksConfig);
pmuConfigs.push_back(totalTicksConfig);
return ZE_RESULT_SUCCESS;
}
ze_result_t SysmanKmdInterfaceI915Prelim::readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::vector<int64_t> &fdList, zes_engine_stats_t *pStats) {
uint64_t data[4] = {};
auto ret = pPmuInterface->pmuRead(static_cast<int>(fdPair.first), data, sizeof(data));
auto ret = pPmuInterface->pmuRead(static_cast<int>(fdList[0]), data, sizeof(data));
if (ret < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():pmuRead is returning value:%d and error:0x%x \n", __FUNCTION__, ret, ZE_RESULT_ERROR_UNKNOWN);
return ZE_RESULT_ERROR_UNKNOWN;

38
level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_i915_upstream.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/os_interface/linux/engine_info.h"
#include "shared/source/os_interface/linux/i915.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
@@ -110,29 +111,30 @@ std::string SysmanKmdInterfaceI915Upstream::getBurstPowerLimitFile(SysfsName sys
return "";
}
ze_result_t SysmanKmdInterfaceI915Upstream::getEngineActivityFdListAndConfigPair(zes_engine_group_t engineGroup,
uint32_t engineInstance,
uint32_t gtId,
PmuInterface *const &pPmuInterface,
std::vector<std::pair<int64_t, int64_t>> &fdList,
std::pair<uint64_t, uint64_t> &configPair) {
uint64_t config = UINT64_MAX;
auto engineClass = engineGroupToEngineClass.find(engineGroup);
config = I915_PMU_ENGINE_BUSY(engineClass->second, engineInstance);
configPair = std::make_pair(config, UINT64_MAX);
auto fd = pPmuInterface->pmuInterfaceOpen(configPair.first, -1, PERF_FORMAT_TOTAL_TIME_ENABLED);
if (fd < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Could not open Busy Ticks Handle \n", __FUNCTION__);
return checkErrorNumberAndReturnStatus();
}
fdList.push_back(std::make_pair(fd, -1));
ze_result_t SysmanKmdInterfaceI915Upstream::getPmuConfigsForGroupEngines(const MapOfEngineInfo &mapEngineInfo,
const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanKmdInterfaceI915Upstream::getPmuConfigsForSingleEngines(const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) {
auto engineClass = engineGroupToEngineClass.find(engineInfo.engineGroup);
uint64_t config = I915_PMU_ENGINE_BUSY(engineClass->second, engineInfo.engineInstance);
pmuConfigs.push_back(config);
return ZE_RESULT_SUCCESS;
}
ze_result_t SysmanKmdInterfaceI915Upstream::readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::pair<int64_t, int64_t> &fdPair, zes_engine_stats_t *pStats) {
ze_result_t SysmanKmdInterfaceI915Upstream::readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::vector<int64_t> &fdList, zes_engine_stats_t *pStats) {
uint64_t data[2] = {};
auto ret = pPmuInterface->pmuRead(static_cast<int>(fdPair.first), data, sizeof(data));
auto ret = pPmuInterface->pmuRead(static_cast<int>(fdList[0]), data, sizeof(data));
if (ret < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():pmuRead is returning value:%d and error:0x%x \n", __FUNCTION__, ret, ZE_RESULT_ERROR_UNKNOWN);
return ZE_RESULT_ERROR_UNKNOWN;

173
level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface_xe.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/os_interface/linux/engine_info.h"
#include "shared/source/os_interface/linux/xe/xedrm.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
@@ -167,69 +168,143 @@ std::string SysmanKmdInterfaceXe::getBurstPowerLimitFile(SysfsName sysfsName, ui
return getSysfsFilePath(sysfsName, subDeviceId, false);
}
ze_result_t SysmanKmdInterfaceXe::getEngineActivityFdListAndConfigPair(zes_engine_group_t engineGroup,
uint32_t engineInstance,
uint32_t gtId,
PmuInterface *const &pPmuInterface,
std::vector<std::pair<int64_t, int64_t>> &fdList,
std::pair<uint64_t, uint64_t> &configPair) {
static ze_result_t getConfigs(PmuInterface *const &pPmuInterface,
const std::string &sysmanDeviceDir,
const SetOfEngineInstanceAndTileId &setEngineInstanceAndTileId,
zes_engine_group_t engineGroup,
const NEO::Drm *pDrm,
std::vector<uint64_t> &configs) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (isGroupEngineHandle(engineGroup)) {
return result;
}
auto engineClass = engineGroupToEngineClass.find(engineGroup);
if (engineClass == engineGroupToEngineClass.end()) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Engine Group not supported and returning error:0x%x\n", __FUNCTION__, result);
return result;
for (auto &engineInstanceAndTileId : setEngineInstanceAndTileId) {
auto gtId = pDrm->getIoctlHelper()->getGtIdFromTileId(engineInstanceAndTileId.second, engineClass->second);
uint64_t activeTicksConfig = UINT64_MAX;
uint64_t totalTicksConfig = UINT64_MAX;
auto ret = pPmuInterface->getPmuConfigs(sysmanDeviceDir, engineClass->second, engineInstanceAndTileId.first, gtId, activeTicksConfig, totalTicksConfig);
if (ret < 0) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to get configs and returning error:0x%x\n", __FUNCTION__, result);
return result;
}
configs.push_back(activeTicksConfig);
configs.push_back(totalTicksConfig);
}
const std::string sysmanDeviceDir = std::string(sysDevicesDir) + getSysmanDeviceDirName();
uint64_t activeTicksConfig = UINT64_MAX;
uint64_t totalTicksConfig = UINT64_MAX;
auto ret = pPmuInterface->getPmuConfigs(sysmanDeviceDir, engineClass->second, engineInstance, gtId, activeTicksConfig, totalTicksConfig);
if (ret < 0) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to get configs and returning error:0x%x\n", __FUNCTION__, result);
return result;
}
configPair = std::make_pair(activeTicksConfig, totalTicksConfig);
int64_t fd[2];
fd[0] = pPmuInterface->pmuInterfaceOpen(configPair.first, -1, PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
if (fd[0] < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Could not open Busy Ticks Handle \n", __FUNCTION__);
return checkErrorNumberAndReturnStatus();
}
fd[1] = pPmuInterface->pmuInterfaceOpen(configPair.second, static_cast<int>(fd[0]), PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP);
if (fd[1] < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Could not open Total Active Ticks Handle \n", __FUNCTION__);
NEO::SysCalls::close(static_cast<int>(fd[0]));
return checkErrorNumberAndReturnStatus();
}
fdList.push_back(std::make_pair(fd[0], fd[1]));
return result;
}
ze_result_t SysmanKmdInterfaceXe::readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::pair<int64_t, int64_t> &fdPair, zes_engine_stats_t *pStats) {
uint64_t data[4] = {};
ze_result_t SysmanKmdInterfaceXe::getPmuConfigsForGroupEngines(const MapOfEngineInfo &mapEngineInfo,
const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) {
auto ret = pPmuInterface->pmuRead(static_cast<int>(fdPair.first), data, sizeof(data));
const std::vector<zes_engine_group_t> singleMediaEngines = {
ZES_ENGINE_GROUP_MEDIA_DECODE_SINGLE,
ZES_ENGINE_GROUP_MEDIA_ENCODE_SINGLE,
ZES_ENGINE_GROUP_MEDIA_ENHANCEMENT_SINGLE};
ze_result_t result = ZE_RESULT_SUCCESS;
auto getConfigForEngine{
[&](zes_engine_group_t engineGroup) {
auto itrEngineInfo = mapEngineInfo.find(engineGroup);
if (itrEngineInfo != mapEngineInfo.end()) {
result = getConfigs(pPmuInterface, sysmanDeviceDir, itrEngineInfo->second, engineGroup, pDrm, pmuConfigs);
}
return result;
}};
switch (engineInfo.engineGroup) {
case ZES_ENGINE_GROUP_MEDIA_ALL:
for (auto &mediaEngineGroup : singleMediaEngines) {
result = getConfigForEngine(mediaEngineGroup);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
}
break;
case ZES_ENGINE_GROUP_COMPUTE_ALL:
result = getConfigForEngine(ZES_ENGINE_GROUP_COMPUTE_SINGLE);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
break;
case ZES_ENGINE_GROUP_COPY_ALL:
result = getConfigForEngine(ZES_ENGINE_GROUP_COPY_SINGLE);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
break;
case ZES_ENGINE_GROUP_RENDER_ALL:
result = getConfigForEngine(ZES_ENGINE_GROUP_RENDER_SINGLE);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
break;
default:
for (auto &itrMapEngineInfo : mapEngineInfo) {
if (!isGroupEngineHandle(itrMapEngineInfo.first)) {
result = getConfigForEngine(itrMapEngineInfo.first);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
}
}
}
return result;
}
ze_result_t SysmanKmdInterfaceXe::getPmuConfigsForSingleEngines(const std::string &sysmanDeviceDir,
const EngineGroupInfo &engineInfo,
PmuInterface *const &pPmuInterface,
const NEO::Drm *pDrm,
std::vector<uint64_t> &pmuConfigs) {
ze_result_t result = ZE_RESULT_SUCCESS;
SetOfEngineInstanceAndTileId setEngineInstanceAndTileId = {{engineInfo.engineInstance, engineInfo.tileId}};
result = getConfigs(pPmuInterface, sysmanDeviceDir, setEngineInstanceAndTileId, engineInfo.engineGroup, pDrm, pmuConfigs);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
return result;
}
ze_result_t SysmanKmdInterfaceXe::readBusynessFromGroupFd(PmuInterface *const &pPmuInterface, std::vector<int64_t> &fdList, zes_engine_stats_t *pStats) {
constexpr uint32_t dataOffset = 2;
constexpr uint32_t configTypes = 2;
uint64_t dataCount = fdList.size();
std::vector<uint64_t> readData(dataCount + dataOffset, 0);
auto ret = pPmuInterface->pmuRead(static_cast<int>(fdList[0]), readData.data(), sizeof(uint64_t) * (dataCount + dataOffset));
if (ret < 0) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():pmuRead is returning value:%d and error:0x%x \n", __FUNCTION__, ret, ZE_RESULT_ERROR_UNKNOWN);
return ZE_RESULT_ERROR_UNKNOWN;
}
pStats->activeTime = data[2];
pStats->timestamp = data[3] ? data[3] : SysmanDevice::getSysmanTimestamp();
uint64_t activeTime = 0u;
uint64_t timeStamp = 0u;
for (uint32_t i = 0u; i < dataCount; i++) {
i % configTypes ? timeStamp += (readData[dataOffset + i] ? readData[dataOffset + i] : SysmanDevice::getSysmanTimestamp()) : activeTime += readData[dataOffset + i];
}
uint64_t engineCount = fdList.size() / configTypes;
pStats->activeTime = activeTime / engineCount;
pStats->timestamp = timeStamp / engineCount;
return ZE_RESULT_SUCCESS;
}

1
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h
View File

@@ -106,7 +106,6 @@ class SysmanProductHelper {
// Engine
virtual bool isAggregationOfSingleEnginesSupported() = 0;
virtual ze_result_t getGroupEngineBusynessFromSingleEngines(LinuxSysmanImp *pLinuxSysmanImp, zes_engine_stats_t *pStats, zes_engine_group_t &engineGroup) = 0;
// Vf Management
virtual bool isVfMemoryUtilizationSupported() = 0;

1
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h
View File

@@ -80,7 +80,6 @@ class SysmanProductHelperHw : public SysmanProductHelper {
// Engine
bool isAggregationOfSingleEnginesSupported() override;
ze_result_t getGroupEngineBusynessFromSingleEngines(LinuxSysmanImp *pLinuxSysmanImp, zes_engine_stats_t *pStats, zes_engine_group_t &engineGroup) override;
// Vf Management
bool isVfMemoryUtilizationSupported() override;

5
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl
View File

@@ -401,11 +401,6 @@ bool SysmanProductHelperHw<gfxProduct>::isAggregationOfSingleEnginesSupported()
return false;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGroupEngineBusynessFromSingleEngines(LinuxSysmanImp *pLinuxSysmanImp, zes_engine_stats_t *pStats, zes_engine_group_t &engineGroup) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
template <PRODUCT_FAMILY gfxProduct>
bool SysmanProductHelperHw<gfxProduct>::isVfMemoryUtilizationSupported() {
return false;

42
level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp
View File

@@ -1615,48 +1615,6 @@ bool SysmanProductHelperHw<gfxProduct>::isAggregationOfSingleEnginesSupported()
return true;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGroupEngineBusynessFromSingleEngines(LinuxSysmanImp *pLinuxSysmanImp, zes_engine_stats_t *pStats, zes_engine_group_t &engineGroup) {
auto pSysmanDeviceImp = pLinuxSysmanImp->getSysmanDeviceImp();
auto pPmuInterface = pLinuxSysmanImp->getPmuInterface();
std::vector<int64_t> fdList{};
for (auto &engine : pSysmanDeviceImp->pEngineHandleContext->handleList) {
zes_engine_properties_t engineProperties = {};
engine->engineGetProperties(&engineProperties);
if (engineGroup == engineProperties.type) {
fdList = engine->fdList;
break;
}
}
if (fdList.empty()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
uint64_t dataCount = fdList.size();
std::vector<uint64_t> readData(dataCount + 2, 0);
auto ret = pPmuInterface->pmuRead(static_cast<int>(fdList[0]), readData.data(), sizeof(uint64_t) * (dataCount + 2));
if (ret < 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
uint64_t activeTime = 0u;
uint64_t timeStamp = 0u;
for (uint32_t i = 0u; i < dataCount; i++) {
i % 2 ? timeStamp += (readData[2 + i] ? readData[2 + i] : SysmanDevice::getSysmanTimestamp()) : activeTime += readData[2 + i];
}
uint64_t engineCount = fdList.size() / 2;
pStats->activeTime = activeTime / engineCount;
pStats->timestamp = timeStamp / engineCount;
return ZE_RESULT_SUCCESS;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerEnergyCounter(zes_power_energy_counter_t *pEnergy, LinuxSysmanImp *pLinuxSysmanImp, zes_power_domain_t powerDomain, uint32_t subdeviceId) {

1
level_zero/sysman/test/unit_tests/sources/engine/linux/CMakeLists.txt
View File

@@ -6,6 +6,7 @@
set(L0_TESTS_SYSMAN_ENGINE_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine_xe.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_engine_xe.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_engine.h

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

@@ -67,7 +67,7 @@ struct MockEngineNeoDrm : public Drm {
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915engineInfo};
this->engineInfo.reset(new EngineInfo(this, engineInfosPerTile));
this->engineInfo = std::make_unique<NEO::EngineInfo>(this, engineInfosPerTile);
return true;
}
};

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

@@ -85,7 +85,7 @@ struct MockEngineNeoDrmPrelim : public Drm {
StackVec<std::vector<NEO::EngineCapabilities>, 2> engineInfosPerTile{i915QueryEngineInfo};
this->engineInfo.reset(new EngineInfo(this, engineInfosPerTile));
this->engineInfo = std::make_unique<NEO::EngineInfo>(this, engineInfosPerTile);
return true;
}
@@ -114,7 +114,7 @@ struct MockEngineNeoDrmPrelim : public Drm {
i915QueryEngineInfo[1].engine.engineClass = drm_i915_gem_engine_class::I915_ENGINE_CLASS_VIDEO;
i915QueryEngineInfo[1].engine.engineInstance = 0;
this->engineInfo.reset(new EngineInfo(this, numberOfTiles, distanceInfos, queryItems, i915QueryEngineInfo));
this->engineInfo = std::make_unique<NEO::EngineInfo>(this, numberOfTiles, distanceInfos, queryItems, i915QueryEngineInfo);
return true;
}
};

4
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine.cpp
View File

@@ -134,13 +134,13 @@ TEST_F(ZesEngineFixtureI915, GivenValidEngineHandleWhenCallingZesEngineGetActivi
}
TEST_F(ZesEngineFixtureI915, GivenValidOsSysmanPointerWhenRetrievingEngineTypeAndInstancesAndIfEngineInfoQueryFailsThenErrorIsReturned) {
std::set<std::pair<zes_engine_group_t, L0::Sysman::EngineInstanceSubDeviceId>> engineGroupInstance;
MapOfEngineInfo mapEngineInfo = {};
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
auto *pDrm = osInterface->getDriverModel()->as<MockEngineNeoDrm>();
pDrm->mockSysmanQueryEngineInfoReturnFalse = false;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, L0::Sysman::OsEngine::getNumEngineTypeAndInstances(engineGroupInstance, pOsSysman));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, L0::Sysman::OsEngine::getNumEngineTypeAndInstances(mapEngineInfo, pOsSysman));
}
TEST_F(ZesEngineFixtureI915, givenEngineInfoQuerySupportedWhenQueryingEngineInfoThenEngineInfoIsCreatedWithEngines) {

6
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_prelim.cpp
View File

@@ -258,11 +258,9 @@ TEST_F(ZesEngineFixturePrelim, GivenValidEngineHandleWhenCallingZesEngineGetActi
}
TEST_F(ZesEngineFixturePrelim, GivenValidOsSysmanPointerWhenRetrievingEngineTypeAndInstancesAndIfEngineInfoQueryFailsThenErrorIsReturned) {
std::set<std::pair<zes_engine_group_t, std::pair<uint32_t, uint32_t>>> engineGroupInstance;
MapOfEngineInfo mapEngineInfo = {};
pDrm->mockReadSysmanQueryEngineInfo = true;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, L0::Sysman::OsEngine::getNumEngineTypeAndInstances(engineGroupInstance, pOsSysman));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, L0::Sysman::OsEngine::getNumEngineTypeAndInstances(mapEngineInfo, pOsSysman));
}
TEST_F(ZesEngineFixturePrelim, GivenHandleQueryItemCalledWithInvalidEngineTypeThenzesDeviceEnumEngineGroupsSucceeds) {

85
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_xe.cpp Normal file
View File

@@ -0,0 +1,85 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/linux/xe/ioctl_helper_xe.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_xe.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/mock_sysman_kmd_interface_xe.h"
#include "level_zero/sysman/test/unit_tests/sources/shared/linux/mock_pmu_interface.h"
namespace L0 {
namespace Sysman {
namespace ult {
static MapOfEngineInfo mockMapEngineInfo = {
{ZES_ENGINE_GROUP_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_COMPUTE_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_COPY_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_RENDER_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_RENDER_SINGLE, {{1, 0}}},
{ZES_ENGINE_GROUP_COPY_SINGLE, {{0, 0}}},
{ZES_ENGINE_GROUP_COMPUTE_SINGLE, {{1, 0}}}};
class ZesEngineFixtureXe : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockPmuInterfaceImp> pPmuInterface;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
MockSysmanKmdInterfaceXe *pSysmanKmdInterface = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
std::string str = "../../devices/pci0000:37/0000:37:01.0/0000:38:00.0/0000:39:01.0/0000:3a:00.0/drm/renderD128";
std::memcpy(buf, str.c_str(), str.size());
return static_cast<int>(str.size());
});
device = pSysmanDevice;
MockNeoDrm *pDrm = new MockNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
pDrm->ioctlHelper = std::make_unique<NEO::IoctlHelperXe>(*pDrm);
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
osInterface->setDriverModel(std::unique_ptr<MockNeoDrm>(pDrm));
pSysmanKmdInterface = new MockSysmanKmdInterfaceXe(pLinuxSysmanImp->getSysmanProductHelper());
pLinuxSysmanImp->pSysmanKmdInterface.reset(pSysmanKmdInterface);
pLinuxSysmanImp->pSysmanKmdInterface->initFsAccessInterface(*pDrm);
pPmuInterface = std::make_unique<MockPmuInterfaceImp>(pLinuxSysmanImp);
pPmuInterface->pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
pOriginalPmuInterface = pLinuxSysmanImp->pPmuInterface;
pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
bool isIntegratedDevice = true;
pLinuxSysmanImp->pSysmanKmdInterface->setSysmanDeviceDirName(isIntegratedDevice);
}
void TearDown() override {
pLinuxSysmanImp->pPmuInterface = pOriginalPmuInterface;
SysmanDeviceFixture::TearDown();
}
};
TEST_F(ZesEngineFixtureXe, GivenEngineImpInstanceForSingleComputeEngineAndGetPmuConfigsForSingleEnginesFailsWhenCallingIsEngineModuleSupportedThenFalseValueIsReturned) {
pPmuInterface->mockEventConfigReturnValue.push_back(-1);
auto pLinuxEngineImp = std::make_unique<L0::Sysman::LinuxEngineImp>(pOsSysman, mockMapEngineInfo, ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, 0);
EXPECT_FALSE(pLinuxEngineImp->isEngineModuleSupported());
}
TEST_F(ZesEngineFixtureXe, GivenEngineImpInstanceForMediaGroupEngineAndSingleMediaEngineNotAvailableWhenCallingIsEngineModuleSupportedThenFalseValueIsReturned) {
auto pLinuxEngineImp = std::make_unique<L0::Sysman::LinuxEngineImp>(pOsSysman, mockMapEngineInfo, ZES_ENGINE_GROUP_MEDIA_ALL, 0, 0, 0);
EXPECT_FALSE(pLinuxEngineImp->isEngineModuleSupported());
}
} // namespace ult
} // namespace Sysman
} // namespace L0

31
level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_prelim.cpp
View File

@@ -12,6 +12,7 @@
#include "shared/test/common/helpers/variable_backup.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
@@ -303,28 +304,22 @@ TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceWhenGetEnergyCounte
EXPECT_EQ(expectedFilePath, pSysmanKmdInterface->getEnergyCounterNodeFile(ZES_POWER_DOMAIN_CARD));
}
TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceAndPmuFailsDueToTooManyFilesOpenWhenGetEngineActivityFdListIsCalledThenErrorIsReturned) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceAndSingleEngineGroupWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
pPmuInterface->mockErrorNumber = EMFILE;
pPmuInterface->mockPerfEventOpenReadFail = true;
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
EngineGroupInfo engineInfo = {ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0};
MapOfEngineInfo mapEngineInfo = {};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mapEngineInfo, sysmanDeviceDir, engineInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceInstanceAndPmuOpenFailsDueToFileTableOverFlowWhenGetEngineActivityFdListIsCalledThenErrorIsReturned) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
TEST_F(SysmanFixtureDeviceI915Prelim, GivenSysmanKmdInterfaceAndPmuReadFailsWhenCallingReadBusynessFromGroupFdThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
pPmuInterface->mockErrorNumber = ENFILE;
pPmuInterface->mockPerfEventOpenReadFail = true;
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
std::vector<int64_t> fdList = {1, 2};
zes_engine_stats_t pStats = {};
pPmuInterface->mockPmuReadFailureReturnValue = -1;
EXPECT_EQ(pSysmanKmdInterface->readBusynessFromGroupFd(pPmuInterface.get(), fdList, &pStats), ZE_RESULT_ERROR_UNKNOWN);
}
} // namespace ult

63
level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_i915_upstream.cpp
View File

@@ -10,6 +10,7 @@
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/shared/linux/mock_pmu_interface.h"
@@ -220,57 +221,35 @@ TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceWhenCalli
EXPECT_EQ(validPowerDomainList, outputPowerDomainList);
}
TEST_F(SysmanFixtureDeviceI915Upstream, GivenGroupEngineTypeAndSysmanKmdInterfaceInstanceWhenGetEngineActivityFdListIsCalledThenErrorIsReturned) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COPY_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_RENDER_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_MEDIA_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
EngineGroupInfo engineInfo = {ZES_ENGINE_GROUP_ALL, 0, 0};
MapOfEngineInfo mapEngineInfo = {};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mapEngineInfo, sysmanDeviceDir, engineInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceI915Upstream, GivenSingleEngineTypeAndSysmanKmdInterfaceInstanceWhenGetEngineActivityFdListIsCalledThenValidFdAndSuccessIsReturned) {
TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceWhenCallingGetPmuConfigsForSingleEnginesThenSuccessIsReturned) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
pPmuInterface->mockPmuFd = 10;
uint64_t mockPmuConfig = 16384;
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_SUCCESS);
EXPECT_EQ(fdList[0].first, pPmuInterface->mockPmuFd);
EXPECT_EQ(fdList[0].second, -1);
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
EngineGroupInfo engineInfo = {ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForSingleEngines(sysmanDeviceDir, engineInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_SUCCESS);
EXPECT_EQ(pmuConfigs[0], mockPmuConfig);
}
TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceAndPmuFailsDueToTooManyFilesOpenWhenGetEngineActivityFdListIsCalledThenErrorIsReturned) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceAndPmuReadFailsWhenCallingReadBusynessFromGroupFdThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
pPmuInterface->mockErrorNumber = EMFILE;
pPmuInterface->mockPerfEventOpenReadFail = true;
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
}
TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceAndPmuOpenFailsDueToFileTableOverFlowWhenGetEngineActivityFdListIsCalledThenErrorIsReturned) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
pPmuInterface->mockErrorNumber = ENFILE;
pPmuInterface->mockPerfEventOpenReadFail = true;
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_ALL, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
std::vector<int64_t> fdList = {1, 2};
zes_engine_stats_t pStats = {};
pPmuInterface->mockPmuReadFailureReturnValue = -1;
EXPECT_EQ(pSysmanKmdInterface->readBusynessFromGroupFd(pPmuInterface.get(), fdList, &pStats), ZE_RESULT_ERROR_UNKNOWN);
}
TEST_F(SysmanFixtureDeviceI915Upstream, GivenSysmanKmdInterfaceInstanceAndIsIntegratedDeviceWhenGetEventsIsCalledThenValidEventTypeIsReturned) {

170
level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/test_sysman_kmd_interface_xe.cpp
View File

@@ -10,6 +10,7 @@
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/mock_sysman_kmd_interface_xe.h"
#include "level_zero/sysman/test/unit_tests/sources/shared/linux/mock_pmu_interface.h"
@@ -24,6 +25,19 @@ namespace ult {
using namespace NEO;
static const MapOfEngineInfo mockMapEngineInfo = {
{ZES_ENGINE_GROUP_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_COMPUTE_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_COPY_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_RENDER_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_MEDIA_DECODE_SINGLE, {{1, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ENCODE_SINGLE, {{1, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ENHANCEMENT_SINGLE, {{0, 0}}},
{ZES_ENGINE_GROUP_RENDER_SINGLE, {{1, 0}}},
{ZES_ENGINE_GROUP_COPY_SINGLE, {{0, 0}}},
{ZES_ENGINE_GROUP_COMPUTE_SINGLE, {{1, 0}}}};
static const uint32_t mockReadVal = 23;
static int mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) {
@@ -239,80 +253,136 @@ TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceWhenGetEnergyCounterNodeFil
EXPECT_EQ(expectedFilePath, pSysmanKmdInterface->getEnergyCounterNodeFile(ZES_POWER_DOMAIN_UNKNOWN));
}
TEST_F(SysmanFixtureDeviceXe, Given3DSingleEngineTypeAndSysmanKmdInterfaceWhenCallingGetEngineActivityFdListThenErrorIsReturned) {
TEST_F(SysmanFixtureDeviceXe, GivenInvalidConfigFromEventFileForEngineActiveTicksWhenCallingGetPmuConfigsForSingleEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_3D_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndGettingConfigFromEventFileFailsForEngineActiveTicksWhenCallingGetEngineActivityFdListThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockEventConfigReturnValue.push_back(-1);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForSingleEngines(sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndGettingConfigFromEventFileFailsForEngineTotalTicksWhenCallingGetEngineActivityFdListThenErrorIsReturned) {
TEST_F(SysmanFixtureDeviceXe, GivenInvalidConfigFromEventFileForEngineActiveTicksWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockEventConfigReturnValue.push_back(-1);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_MEDIA_ALL, 0, 0};
const MapOfEngineInfo mapEngineInfo = {
{ZES_ENGINE_GROUP_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ENCODE_SINGLE, {{0, 0}}}};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
TEST_F(SysmanFixtureDeviceXe, GivenInvalidConfigFromEventFileForEngineTotalTicksWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockEventConfigReturnValue.push_back(0);
pPmuInterface->mockEventConfigReturnValue.push_back(-1);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_MEDIA_ALL, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mockMapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndGettingConfigAfterFormatFailsForEngineActiveTicksWhenCallingGetEngineActivityFdListThenErrorIsReturned) {
TEST_F(SysmanFixtureDeviceXe, GivenInvalidConfigAfterFormatForEngineActiveTicksWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockFormatConfigReturnValue.push_back(-1);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_MEDIA_ALL, 0, 0};
const MapOfEngineInfo mapEngineInfo = {
{ZES_ENGINE_GROUP_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ALL, {{0, 0}}},
{ZES_ENGINE_GROUP_MEDIA_ENHANCEMENT_SINGLE, {{0, 0}}}};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndGettingConfigAfterFormatFailsForEngineTotalTicksWhenCallingGetEngineActivityFdListThenErrorIsReturned) {
TEST_F(SysmanFixtureDeviceXe, GivenMediaGroupEngineAndNoMediaSingleEnginesAvailableWhenCallingGetPmuConfigsForGroupEnginesThenNoPmuConfigsAreReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_MEDIA_ALL, 0, 0};
const MapOfEngineInfo mapEngineInfo = {{ZES_ENGINE_GROUP_MEDIA_ALL, {{0, 0}}}};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_SUCCESS);
EXPECT_TRUE(pmuConfigs.empty());
}
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
TEST_F(SysmanFixtureDeviceXe, GivenComputeGroupEngineAndInvalidConfigAfterFormatForEngineActiveTicksWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockFormatConfigReturnValue.push_back(-1);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_COMPUTE_ALL, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mockMapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenCopyGroupEngineAndInvalidConfigAfterFormatForEngineActiveTicksWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockFormatConfigReturnValue.push_back(-1);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_COPY_ALL, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mockMapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenRenderGroupEngineAndInvalidConfigAfterFormatForEngineActiveTicksWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockFormatConfigReturnValue.push_back(-1);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_RENDER_ALL, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mockMapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenGroupAllEngineAndInvalidConfigAfterFormatForEngineActiveTicksWhenCallingGetPmuConfigsForGroupEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockFormatConfigReturnValue.push_back(-1);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_ALL, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mockMapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenInvalidConfigAfterFormatForEngineTotalTicksWhenCallingGetPmuConfigsForSingleEnginesThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
pPmuInterface->mockFormatConfigReturnValue.push_back(0);
pPmuInterface->mockFormatConfigReturnValue.push_back(-1);
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForSingleEngines(sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndPmuInterfaceOpenFailsForBusyTicksHandleWhenCallingGetEngineActivityFdListThenErrorIsReturned) {
TEST_F(SysmanFixtureDeviceXe, GivenMediaGroupEngineWhenCallingGetPmuConfigsForGroupEnginesThenSuccessIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
pPmuInterface->mockPerfEventOpenReadFail = true;
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
auto pDrm = pLinuxSysmanImp->getDrm();
std::vector<uint64_t> mockPmuConfigs = {1, 2, 1, 2, 1, 2};
std::vector<uint64_t> pmuConfigs = {};
const std::string sysmanDeviceDir = "/sys/devices/0000:aa:bb:cc";
EngineGroupInfo engineGroupInfo = {ZES_ENGINE_GROUP_MEDIA_ALL, 0, 0};
EXPECT_EQ(pSysmanKmdInterface->getPmuConfigsForGroupEngines(mockMapEngineInfo, sysmanDeviceDir, engineGroupInfo, pPmuInterface.get(), pDrm, pmuConfigs), ZE_RESULT_SUCCESS);
for (uint32_t i = 0; i < pmuConfigs.size(); i++) {
EXPECT_EQ(pmuConfigs[i], mockPmuConfigs[i]);
}
}
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndPmuInterfaceOpenFailsForTotalTicksHandleWhenCallingGetEngineActivityFdListThenErrorIsReturned) {
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::ostringstream oStream;
oStream << 23;
std::string value = oStream.str();
memcpy(buf, value.data(), count);
return count;
});
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndPmuReadFailsWhenCallingReadBusynessFromGroupFdThenErrorIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
std::vector<std::pair<int64_t, int64_t>> fdList = {};
std::pair<uint64_t, uint64_t> configPair = {};
pPmuInterface->mockPerfEventOpenReadFail = true;
pPmuInterface->mockPerfEventOpenFailAtCount = 3;
pPmuInterface->mockPmuFd = 10;
EXPECT_EQ(pSysmanKmdInterface->getEngineActivityFdListAndConfigPair(ZES_ENGINE_GROUP_COMPUTE_SINGLE, 0, 0, pPmuInterface.get(), fdList, configPair), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
std::vector<int64_t> fdList = {1, 2};
zes_engine_stats_t pStats = {};
pPmuInterface->mockPmuReadFailureReturnValue = -1;
EXPECT_EQ(pSysmanKmdInterface->readBusynessFromGroupFd(pPmuInterface.get(), fdList, &pStats), ZE_RESULT_ERROR_UNKNOWN);
}
TEST_F(SysmanFixtureDeviceXe, GivenSysmanKmdInterfaceAndGetPmuConfigsFailsWhenCallingGetBusyAndTotalTicksConfigsForVfThenErrorIsReturned) {

15
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_engine_tests.cpp
View File

@@ -136,26 +136,11 @@ HWTEST2_F(SysmanProductHelperEngineTestsFixture, GivenHandleQueryItemCalledAndPm
EXPECT_EQ(count, mockHandleCount);
}
HWTEST2_F(SysmanProductHelperEngineTestsFixture, GivenValidEngineHandleWith3DSingleGroupEngineWhenCallingEngineGetActivityThenErrorIsReturned, IsPVC) {
zes_engine_group_t engineType = ZES_ENGINE_GROUP_3D_SINGLE;
zes_engine_stats_t stats = {};
auto pLinuxEngineImp = std::make_unique<L0::Sysman::LinuxEngineImp>(pOsSysman, engineType, 0, 0, 0);
EXPECT_EQ(pLinuxEngineImp->getActivity(&stats), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
HWTEST2_F(SysmanProductHelperEngineTestsFixture, GivenSysmanProductHelperHandleWhenCheckingIsAggregationOfSingleEnginesSupportedThenFailureIsReturned, IsPVC) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_FALSE(pSysmanProductHelper->isAggregationOfSingleEnginesSupported());
}
HWTEST2_F(SysmanProductHelperEngineTestsFixture, GivenSysmanProductHelperHandleWhenCallingGetGroupEngineBusynessFromSingleEnginesThenErrorIsReturned, IsPVC) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_engine_group_t engineType = ZES_ENGINE_GROUP_3D_SINGLE;
zes_engine_stats_t stats = {};
EXPECT_EQ(pSysmanProductHelper->getGroupEngineBusynessFromSingleEngines(pLinuxSysmanImp, &stats, engineType), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
} // namespace ult
} // namespace Sysman
} // namespace L0

62
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_engine_tests_xe.cpp
View File

@@ -106,23 +106,6 @@ HWTEST2_F(SysmanProductHelperEngineXeTestFixture, GivenComponentCountZeroWhenCal
EXPECT_EQ(count, mockEngineHandleCount);
}
HWTEST2_F(SysmanProductHelperEngineXeTestFixture, GivenValidEngineHandleWhenFetchingConfigPairThenProperValuesAreReturned, IsBMG) {
auto handles = getEngineHandles(mockEngineHandleCount);
EXPECT_EQ(mockEngineHandleCount, handles.size());
for (auto handle : handles) {
zes_engine_properties_t properties = {};
EXPECT_EQ(zesEngineGetProperties(handle, &properties), ZE_RESULT_SUCCESS);
if (!isGroupEngineHandle(properties.type)) {
L0::Sysman::Engine *pEngine = L0::Sysman::Engine::fromHandle(handle);
EXPECT_EQ(pEngine->configPair.first, pPmuInterface->mockActiveTicksConfig);
EXPECT_EQ(pEngine->configPair.second, pPmuInterface->mockTotalTicksConfig);
}
}
}
HWTEST2_F(SysmanProductHelperEngineXeTestFixture, GivenValidEngineHandleWhenCallingZesEngineGetActivityThenCallSuccedsAndValidValuesAreReturned, IsBMG) {
zes_engine_stats_t stats = {};
@@ -167,56 +150,11 @@ HWTEST2_F(SysmanProductHelperEngineXeTestFixture, GivenValidEngineHandleAndPmuRe
}
}
HWTEST2_F(SysmanProductHelperEngineXeTestFixture, GivenEngineHandleWithGroupAllEngineTypeAndPmuInterfaceOpenFailsWhenCallingZesEngineGetActivityThenErrorIsReturned, IsBMG) {
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
uint32_t mockReadVal = 23;
std::ostringstream oStream;
oStream << mockReadVal;
std::string value = oStream.str();
memcpy(buf, value.data(), count);
return count;
});
pPmuInterface->mockPerfEventOpenReadFail = true;
pPmuInterface->mockPerfEventOpenFailAtCount = 12;
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL));
std::vector<zes_engine_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
for (auto handle : handles) {
zes_engine_properties_t properties = {};
EXPECT_EQ(zesEngineGetProperties(handle, &properties), ZE_RESULT_SUCCESS);
if (isGroupEngineHandle(properties.type)) {
zes_engine_stats_t stats = {};
EXPECT_EQ(zesEngineGetActivity(handle, &stats), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
}
HWTEST2_F(SysmanProductHelperEngineXeTestFixture, GivenSysmanProductHelperHandleWhenCheckingIsAggregationOfSingleEnginesSupportedThenSuccessIsReturned, IsBMG) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_TRUE(pSysmanProductHelper->isAggregationOfSingleEnginesSupported());
}
HWTEST2_F(SysmanProductHelperEngineXeTestFixture, GivenSysmanProductHelperHandleAndFdListNotAvailableWhenCallingGetGroupEngineBusynessFromSingleEnginesThenErrorIsReturned, IsBMG) {
zes_engine_group_t engineType = ZES_ENGINE_GROUP_COMPUTE_ALL;
std::unique_ptr<L0::Sysman::Engine> pEngine = std::make_unique<L0::Sysman::EngineImp>(pOsSysman, engineType, 0, 0, 0);
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->pEngineHandleContext->handleList.push_back(std::move(pEngine));
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_engine_stats_t stats = {};
EXPECT_EQ(pSysmanProductHelper->getGroupEngineBusynessFromSingleEngines(pLinuxSysmanImp, &stats, engineType), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
} // namespace ult
} // namespace Sysman
} // namespace L0