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

refactor: 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-24 09:55:52 +00:00
committed by Compute-Runtime-Automation
parent 87ed4728f2
commit b240f92e82
28 changed files with 616 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
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,62 @@ 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()) {
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 = SysmanKmdInterface::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 = SysmanKmdInterface::checkErrorNumberAndReturnStatus();
return;
}
}
fdList.push_back(fd);
}
initStatus = ZE_RESULT_SUCCESS;
}
}
}
bool LinuxEngineImp::isEngineModuleSupported() {
@@ -115,148 +179,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);

82
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;
@@ -184,7 +193,7 @@ class SysmanKmdInterface {
virtual std::string getBurstPowerLimitFile(SysfsName sysfsName, uint32_t subDeviceId, bool baseDirectoryExists) = 0;
virtual std::string getFreqMediaDomainBasePath() = 0;
const std::string getSysmanDeviceDirName() const;
ze_result_t checkErrorNumberAndReturnStatus();
static ze_result_t checkErrorNumberAndReturnStatus();
virtual ze_result_t readPcieDowngradeAttribute(std::string sysfsName, uint32_t &val) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
protected:
@@ -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) {
uint64_t dataCount = fdList.size();
uint32_t dataOffset = 2;
uint32_t configTypes = 2;
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) {