mirror of
https://github.com/intel/compute-runtime.git
synced 2026-01-03 14:55:24 +08:00
refactor: Refine Sysman Engine Module
Related-To: NEO-14756 Signed-off-by: Pratik Bari <pratik.bari@intel.com>
This commit is contained in:
Pratik Bari
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
87ed4728f2
commit
b240f92e82
@@ -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
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in New Issue
Block a user