Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: optimize sysman windows power module

Browse Source 
Related-To: NEO-13612

Signed-off-by: shubham kumar <shubham.kumar@intel.com>
This commit is contained in:
shubham kumar
2025-01-08 10:15:16 +00:00
committed by Compute-Runtime-Automation
parent 5218923b6d
commit a8a9b1b92b
7 changed files with 180 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,13 +16,101 @@ namespace L0 {
namespace Sysman {
ze_result_t WddmPowerImp::getProperties(zes_power_properties_t *pProperties) {
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPowerProperties(pProperties, this->powerDomain, pWddmSysmanImp);
if (powerDomain == ZES_POWER_DOMAIN_CARD || powerDomain == ZES_POWER_DOMAIN_PACKAGE) {
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
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(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;
}
pProperties->canControl = false;
pProperties->isEnergyThresholdSupported = false;
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;
} else if (powerDomain == ZES_POWER_DOMAIN_MEMORY || powerDomain == ZES_POWER_DOMAIN_GPU) {
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPowerPropertiesFromPmt(pProperties);
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
}
ze_result_t WddmPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPowerPropertiesExt(pExtPoperties, this->powerDomain, pWddmSysmanImp);
if (powerDomain == ZES_POWER_DOMAIN_CARD || powerDomain == ZES_POWER_DOMAIN_PACKAGE) {
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
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(powerDomain));
request.requestId = KmdSysman::Requests::Power::TdpDefault;
ze_result_t status = pKmdSysManager->requestSingle(request, response);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
pExtPoperties->defaultLimit->limit = -1;
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;
} else if (powerDomain == ZES_POWER_DOMAIN_MEMORY || powerDomain == ZES_POWER_DOMAIN_GPU) {
auto pSysmanProductHelper = pWddmSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPowerPropertiesExtFromPmt(pExtPoperties, powerDomain);
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
}
ze_result_t WddmPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
@ -249,14 +337,6 @@ void WddmPowerImp::initPowerLimits() {
return;
}
auto paramInfo = powerGroupToDomainTypeMap.find(this->powerDomain);
if (paramInfo == powerGroupToDomainTypeMap.end()) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"Power Domain %u is not supported for KMD calls.\n", this->powerDomain);
DEBUG_BREAK_IF(true);
return;
}
powerLimitCount = 0;
std::vector<KmdSysman::RequestProperty> vRequests(3);
std::vector<KmdSysman::ResponseProperty> vResponses = {};
@ -264,7 +344,7 @@ void WddmPowerImp::initPowerLimits() {
request.commandId = KmdSysman::Command::Get;
request.componentId = KmdSysman::Component::PowerComponent;
request.paramInfo = static_cast<uint32_t>(paramInfo->second);
request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
request.requestId = KmdSysman::Requests::Power::PowerLimit1Enabled;
vRequests[0] = request;
@ -302,6 +382,7 @@ void WddmPowerImp::initPowerLimits() {
}
bool WddmPowerImp::isPowerModuleSupported() {
initPowerLimits();
return true;
}
@ -528,13 +609,49 @@ WddmPowerImp::WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t
pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
isPowerHandleEnergyCounterOnly();
initPowerLimits();
}
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");
} else {
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. KMD based power handles will not be created.\n");
break;
}
}
PlatformMonitoringTech *pPmt = pWddmSysmanImp->getSysmanPmt();
if (pPmt != nullptr) {
powerDomains.push_back(ZES_POWER_DOMAIN_MEMORY);
powerDomains.push_back(ZES_POWER_DOMAIN_GPU);
}
return powerDomains;
}
OsPower *OsPower::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) {

7
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -56,9 +56,8 @@ class SysmanProductHelper {
virtual ze_result_t getMemoryBandWidth(zes_mem_bandwidth_t *pBandwidth, WddmSysmanImp *pWddmSysmanImp) = 0;
// Power
virtual std::vector<zes_power_domain_t> getNumberOfPowerDomainsSupported(WddmSysmanImp *pWddmSysmanImp) = 0;
virtual ze_result_t getPowerProperties(zes_power_properties_t *pProperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) = 0;
virtual ze_result_t getPowerPropertiesExt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) = 0;
virtual ze_result_t getPowerPropertiesFromPmt(zes_power_properties_t *pProperties) = 0;
virtual ze_result_t getPowerPropertiesExtFromPmt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain) = 0;
virtual ze_result_t getPowerEnergyCounter(zes_power_energy_counter_t *pEnergy, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) = 0;
// Pmt

7
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -36,9 +36,8 @@ class SysmanProductHelperHw : public SysmanProductHelper {
ze_result_t getMemoryBandWidth(zes_mem_bandwidth_t *pBandwidth, WddmSysmanImp *pWddmSysmanImp) override;
// Power
std::vector<zes_power_domain_t> getNumberOfPowerDomainsSupported(WddmSysmanImp *pWddmSysmanImp) override;
ze_result_t getPowerProperties(zes_power_properties_t *pProperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) override;
ze_result_t getPowerPropertiesExt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) override;
ze_result_t getPowerPropertiesFromPmt(zes_power_properties_t *pProperties) override;
ze_result_t getPowerPropertiesExtFromPmt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain) override;
ze_result_t getPowerEnergyCounter(zes_power_energy_counter_t *pEnergy, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) override;
// Pmt

123
level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -151,126 +151,13 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryBandWidth(zes_mem_bandwi
}
template <PRODUCT_FAMILY gfxProduct>
std::vector<zes_power_domain_t> SysmanProductHelperHw<gfxProduct>::getNumberOfPowerDomainsSupported(WddmSysmanImp *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;
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerPropertiesFromPmt(zes_power_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerProperties(zes_power_properties_t *pProperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) {
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
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(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;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerPropertiesExt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) {
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
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(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 SysmanProductHelperHw<gfxProduct>::getPowerPropertiesExtFromPmt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
template <PRODUCT_FAMILY gfxProduct>

175
level_zero/sysman/source/shared/windows/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -863,163 +863,30 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryBandWidth(zes_mem_bandwi
}
template <>
std::vector<zes_power_domain_t> SysmanProductHelperHw<gfxProduct>::getNumberOfPowerDomainsSupported(WddmSysmanImp *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;
}
PlatformMonitoringTech *pPmt = pWddmSysmanImp->getSysmanPmt();
if (pPmt != nullptr) {
powerDomains.push_back(ZES_POWER_DOMAIN_MEMORY);
powerDomains.push_back(ZES_POWER_DOMAIN_GPU);
}
return powerDomains;
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerPropertiesFromPmt(zes_power_properties_t *pProperties) {
pProperties->onSubdevice = false;
pProperties->subdeviceId = 0;
pProperties->canControl = false;
pProperties->isEnergyThresholdSupported = false;
pProperties->defaultLimit = -1;
pProperties->minLimit = -1;
pProperties->maxLimit = -1;
return ZE_RESULT_SUCCESS;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerProperties(zes_power_properties_t *pProperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) {
if (powerDomain == ZES_POWER_DOMAIN_CARD || powerDomain == ZES_POWER_DOMAIN_PACKAGE) {
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
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(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;
} else if (powerDomain == ZES_POWER_DOMAIN_MEMORY || powerDomain == ZES_POWER_DOMAIN_GPU) {
PlatformMonitoringTech *pPmt = pWddmSysmanImp->getSysmanPmt();
if (pPmt == nullptr) {
return ZE_RESULT_ERROR_UNKNOWN;
}
pProperties->onSubdevice = false;
pProperties->subdeviceId = 0;
pProperties->canControl = false;
pProperties->isEnergyThresholdSupported = false;
pProperties->defaultLimit = -1;
pProperties->minLimit = -1;
pProperties->maxLimit = -1;
return ZE_RESULT_SUCCESS;
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerPropertiesExt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain, WddmSysmanImp *pWddmSysmanImp) {
if (powerDomain == ZES_POWER_DOMAIN_CARD || powerDomain == ZES_POWER_DOMAIN_PACKAGE) {
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
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(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;
} else if (powerDomain == ZES_POWER_DOMAIN_MEMORY || powerDomain == ZES_POWER_DOMAIN_GPU) {
pExtPoperties->domain = powerDomain;
if (pExtPoperties->defaultLimit) {
pExtPoperties->defaultLimit->limit = -1;
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;
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
ze_result_t SysmanProductHelperHw<gfxProduct>::getPowerPropertiesExtFromPmt(zes_power_ext_properties_t *pExtPoperties, zes_power_domain_t powerDomain) {
pExtPoperties->domain = powerDomain;
if (pExtPoperties->defaultLimit) {
pExtPoperties->defaultLimit->limit = -1;
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;
}
template <>

8
level_zero/sysman/test/unit_tests/sources/power/windows/test_zes_sysman_power.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -224,7 +224,7 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerProperties
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndDefaultPowerIsNotAvailableThenCallSucceedsAndDefaultLimitIsInvalid) {
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndDefaultPowerIsNotAvailableThenCallFailsAndDefaultLimitIsInvalid) {
// Setting allow set calls or not
init(true);
@ -241,8 +241,8 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerProperties
pKmdSysManager->mockPowerFailure[KmdSysman::Requests::Power::TdpDefault] = 1;
ze_result_t result = zesPowerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(defaultLimit.limit, -1);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
EXPECT_EQ(defaultLimit.limit, 0);
}
}

15
level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_power_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -254,13 +254,20 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleWhenGettingPowerPro
}
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidEnergyCounterOnlyPowerDomainWhenGettingPowerGetPropertiesAndPmtIsNullThenUnsupportedIsReturned, IsBMG) {
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidEnergyCounterOnlyPowerDomainWhenGettingPowerGetPropertiesThenUnsupportedIsReturned, IsAtMostDg2) {
// Setting allow set calls or not
init(true);
pWddmSysmanImp->pPmt.reset(nullptr);
std::unique_ptr<WddmPowerImp> pWddmPowerImp = std::make_unique<WddmPowerImp>(pOsSysman, false, 0, ZES_POWER_DOMAIN_MEMORY);
zes_power_properties_t powerProperties = {};
ASSERT_EQ(ZE_RESULT_ERROR_UNKNOWN, pWddmPowerImp->getProperties(&powerProperties));
ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pWddmPowerImp->getProperties(&powerProperties));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidEnergyCounterOnlyPowerDomainWhenGettingPowerGetPropertiesExtThenUnsupportedIsReturned, IsAtMostDg2) {
// Setting allow set calls or not
init(true);
std::unique_ptr<WddmPowerImp> pWddmPowerImp = std::make_unique<WddmPowerImp>(pOsSysman, false, 0, ZES_POWER_DOMAIN_MEMORY);
zes_power_ext_properties_t powerProperties = {};
ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pWddmPowerImp->getPropertiesExt(&powerProperties));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenInValidPowerDomainWhenGettingPowerGetPropertiesThenUnsupportedIsReturned, IsBMG) {