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

Revert "feature: Add Memory and GPU domain support for getEnergyCounter()"

Browse Source 
This reverts commit 0be4ebe6c2.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2024-11-07 03:04:40 +01:00
committed by Compute-Runtime-Automation
parent b9fb514ad2
commit 2345979800
11 changed files with 142 additions and 843 deletions
Download Patch File Download Diff File Expand all files Collapse all files

178
level_zero/sysman/source/api/power/windows/sysman_os_power_imp.cpp
View File

@@ -7,7 +7,6 @@
#include "level_zero/sysman/source/api/power/windows/sysman_os_power_imp.h"
#include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/source/shared/windows/sysman_kmd_sys_manager.h"
#include "level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h"
#include "level_zero/sysman/source/sysman_const.h"
@@ -15,25 +14,114 @@
namespace L0 {
namespace Sysman {
static const std::map<zes_power_domain_t, KmdSysman::PowerDomainsType> powerGroupToDomainTypeMap = {
{ZES_POWER_DOMAIN_CARD, KmdSysman::PowerDomainsType::powerDomainCard},
{ZES_POWER_DOMAIN_PACKAGE, KmdSysman::PowerDomainsType::powerDomainPackage},
};
ze_result_t WddmPowerImp::getProperties(zes_power_properties_t *pProperties) {
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPowerProperties(pProperties, this->powerDomain, pWddmSysmanImp);
pProperties->onSubdevice = false;
pProperties->subdeviceId = 0;
std::vector<KmdSysman::RequestProperty> vRequests = {};
std::vector<KmdSysman::ResponseProperty> vResponses = {};
KmdSysman::RequestProperty request = {};
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PowerComponent;
request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
request.requestId = KmdSysman::Requests::Power::EnergyThresholdSupported;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Power::TdpDefault;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Power::MinPowerLimitDefault;
vRequests.push_back(request);
request.requestId = KmdSysman::Requests::Power::MaxPowerLimitDefault;
vRequests.push_back(request);
ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
return status;
}
if (vResponses[0].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->canControl, sizeof(ze_bool_t), vResponses[0].dataBuffer, sizeof(ze_bool_t));
memcpy_s(&pProperties->isEnergyThresholdSupported, sizeof(ze_bool_t), vResponses[0].dataBuffer, sizeof(ze_bool_t));
}
pProperties->defaultLimit = -1;
if (vResponses[1].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->defaultLimit, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
}
pProperties->minLimit = -1;
if (vResponses[2].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->minLimit, sizeof(uint32_t), vResponses[2].dataBuffer, sizeof(uint32_t));
}
pProperties->maxLimit = -1;
if (vResponses[3].returnCode == KmdSysman::Success) {
memcpy_s(&pProperties->maxLimit, sizeof(uint32_t), vResponses[3].dataBuffer, sizeof(uint32_t));
}
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPowerPropertiesExt(pExtPoperties, this->powerDomain, pWddmSysmanImp);
pExtPoperties->domain = powerDomain;
if (pExtPoperties->defaultLimit) {
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PowerComponent;
request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
request.requestId = KmdSysman::Requests::Power::TdpDefault;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
pExtPoperties->defaultLimit->limit = -1;
if (status == ZE_RESULT_SUCCESS) {
memcpy_s(&pExtPoperties->defaultLimit->limit, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
}
pExtPoperties->defaultLimit->limitUnit = ZES_LIMIT_UNIT_POWER;
pExtPoperties->defaultLimit->enabledStateLocked = true;
pExtPoperties->defaultLimit->intervalValueLocked = true;
pExtPoperties->defaultLimit->limitValueLocked = true;
pExtPoperties->defaultLimit->source = ZES_POWER_SOURCE_ANY;
pExtPoperties->defaultLimit->level = ZES_POWER_LEVEL_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t WddmPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPowerEnergyCounter(pEnergy, this->powerDomain, pWddmSysmanImp);
uint64_t energyCounter64Bit = 0;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PowerComponent;
request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
request.requestId = KmdSysman::Requests::Power::CurrentEnergyCounter64Bit;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status == ZE_RESULT_SUCCESS) {
memcpy_s(&energyCounter64Bit, sizeof(uint64_t), response.dataBuffer, sizeof(uint64_t));
pEnergy->energy = energyCounter64Bit;
pEnergy->timestamp = SysmanDevice::getSysmanTimestamp();
}
return status;
}
ze_result_t WddmPowerImp::getLimits(zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak) {
if (supportsEnergyCounterOnly) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t status = ZE_RESULT_SUCCESS;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
@@ -128,9 +216,6 @@ ze_result_t WddmPowerImp::getLimits(zes_power_sustained_limit_t *pSustained, zes
}
ze_result_t WddmPowerImp::setLimits(const zes_power_sustained_limit_t *pSustained, const zes_power_burst_limit_t *pBurst, const zes_power_peak_limit_t *pPeak) {
if (supportsEnergyCounterOnly) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t status = ZE_RESULT_SUCCESS;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
@@ -196,9 +281,6 @@ ze_result_t WddmPowerImp::setLimits(const zes_power_sustained_limit_t *pSustaine
}
ze_result_t WddmPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold) {
if (supportsEnergyCounterOnly) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
@@ -226,9 +308,6 @@ ze_result_t WddmPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold)
}
ze_result_t WddmPowerImp::setEnergyThreshold(double threshold) {
if (supportsEnergyCounterOnly) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
@@ -245,9 +324,6 @@ ze_result_t WddmPowerImp::setEnergyThreshold(double threshold) {
}
bool WddmPowerImp::isPowerModuleSupported() {
if (supportsEnergyCounterOnly) {
return true;
}
powerLimitCount = 0;
std::vector<KmdSysman::RequestProperty> vRequests(3);
std::vector<KmdSysman::ResponseProperty> vResponses = {};
@@ -299,9 +375,6 @@ bool WddmPowerImp::isPowerModuleSupported() {
}
ze_result_t WddmPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) {
if (supportsEnergyCounterOnly) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t result = ZE_RESULT_SUCCESS;
uint8_t count = 0;
@@ -449,9 +522,6 @@ ze_result_t WddmPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
}
ze_result_t WddmPowerImp::setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) {
if (supportsEnergyCounterOnly) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t status = ZE_RESULT_SUCCESS;
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
@@ -506,27 +576,49 @@ ze_result_t WddmPowerImp::setLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
return status;
}
void WddmPowerImp::isPowerHandleEnergyCounterOnly() {
switch (this->powerDomain) {
case ZES_POWER_DOMAIN_MEMORY:
case ZES_POWER_DOMAIN_GPU:
supportsEnergyCounterOnly = true;
break;
default:
break;
}
}
WddmPowerImp::WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) : powerDomain(powerDomain) {
pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
isPowerHandleEnergyCounterOnly();
}
std::vector<zes_power_domain_t> OsPower::getNumberOfPowerDomainsSupported(OsSysman *pOsSysman) {
WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getNumberOfPowerDomainsSupported(pWddmSysmanImp);
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
KmdSysman::RequestProperty request;
KmdSysman::ResponseProperty response;
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PowerComponent;
request.requestId = KmdSysman::Requests::Power::NumPowerDomains;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
std::vector<zes_power_domain_t> powerDomains;
if (status != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"No power domains are supported, power handles will not be created.\n");
return powerDomains;
}
uint32_t supportedPowerDomains = 0;
memcpy_s(&supportedPowerDomains, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
switch (supportedPowerDomains) {
case 1:
powerDomains.push_back(ZES_POWER_DOMAIN_PACKAGE);
break;
case 2:
powerDomains.push_back(ZES_POWER_DOMAIN_PACKAGE);
powerDomains.push_back(ZES_POWER_DOMAIN_CARD);
break;
default:
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"Unexpected value returned by KMD, power handles will not be created.\n");
break;
}
return powerDomains;
}
OsPower *OsPower::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) {

4
level_zero/sysman/source/api/power/windows/sysman_os_power_imp.h
View File

@@ -13,7 +13,6 @@
namespace L0 {
namespace Sysman {
class KmdSysManager;
class WddmSysmanImp;
class WddmPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getProperties(zes_power_properties_t *pProperties) override;
@@ -27,17 +26,14 @@ class WddmPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) override;
bool isPowerModuleSupported() override;
void isPowerHandleEnergyCounterOnly();
WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain);
WddmPowerImp() = default;
~WddmPowerImp() override = default;
protected:
KmdSysManager *pKmdSysManager = nullptr;
WddmSysmanImp *pWddmSysmanImp = nullptr;
uint32_t powerLimitCount = 0;
zes_power_domain_t powerDomain = ZES_POWER_DOMAIN_CARD;
bool supportsEnergyCounterOnly = false;
};
} // namespace Sysman