feature(sysman): windows add support for card and package power

Related-To: NEO-11820

Signed-off-by: shubham kumar <shubham.kumar@intel.com>

level_zero/sysman/source/api/power/linux/sysman_os_power_imp.cpp

@@ -58,7 +58,7 @@ ze_result_t LinuxPowerImp::getDefaultLimit(int32_t &defaultLimit) {
 }
 
 ze_result_t LinuxPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
-    pExtPoperties->domain = isSubdevice ? ZES_POWER_DOMAIN_PACKAGE : ZES_POWER_DOMAIN_CARD;
+    pExtPoperties->domain = isSubdevice ? ZES_POWER_DOMAIN_PACKAGE : powerDomain;
     if (pExtPoperties->defaultLimit) {
         if (!isSubdevice) {
             uint64_t val = 0;
@@ -320,7 +320,7 @@ bool LinuxPowerImp::isPowerModuleSupported() {
     return true;
 }
 
-LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) {
+LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), powerDomain(powerDomain) {
     LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
     pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
     pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
@@ -328,8 +328,13 @@ LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_
     pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
 }
 
-OsPower *OsPower::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
-    LinuxPowerImp *pLinuxPowerImp = new LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId);
+std::vector<zes_power_domain_t> OsPower::getNumberOfPowerDomainsSupported(OsSysman *pOsSysman) {
+    std::vector<zes_power_domain_t> powerDomains = {ZES_POWER_DOMAIN_CARD};
+    return powerDomains;
+}
+
+OsPower *OsPower::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) {
+    LinuxPowerImp *pLinuxPowerImp = new LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId, powerDomain);
     return static_cast<OsPower *>(pLinuxPowerImp);
 }
 } // namespace Sysman

level_zero/sysman/source/api/power/linux/sysman_os_power_imp.h

@@ -36,7 +36,7 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
     bool isPowerModuleSupported() override;
     bool isIntelGraphicsHwmonDir(const std::string &name);
     ze_result_t getPmtEnergyCounter(zes_power_energy_counter_t *pEnergy);
-    LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
+    LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain);
     LinuxPowerImp() = default;
     ~LinuxPowerImp() override = default;
 
@@ -55,6 +55,7 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
     bool isSubdevice = false;
     uint32_t subdeviceId = 0;
     uint32_t powerLimitCount = 0;
+    zes_power_domain_t powerDomain = ZES_POWER_DOMAIN_CARD;
 
     ze_result_t getErrorCode(ze_result_t result) {
         if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {

level_zero/sysman/source/api/power/sysman_os_power.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Intel Corporation
+ * Copyright (C) 2020-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -9,6 +9,8 @@
 
 #include <level_zero/zes_api.h>
 
+#include <vector>
+
 namespace L0 {
 namespace Sysman {
 
@@ -26,7 +28,9 @@ class OsPower {
     virtual ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) = 0;
 
     virtual bool isPowerModuleSupported() = 0;
-    static OsPower *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
+    static OsPower *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain);
+    static std::vector<zes_power_domain_t> getNumberOfPowerDomainsSupported(OsSysman *pOsSysman);
+
     virtual ~OsPower() = default;
 };
 

level_zero/sysman/source/api/power/sysman_power.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -9,6 +9,7 @@
 
 #include "shared/source/helpers/basic_math.h"
 
+#include "level_zero/sysman/source/api/power/sysman_os_power.h"
 #include "level_zero/sysman/source/api/power/sysman_power_imp.h"
 #include "level_zero/sysman/source/device/os_sysman.h"
 
@@ -26,8 +27,8 @@ PowerHandleContext::~PowerHandleContext() {
     releasePowerHandles();
 }
 
-void PowerHandleContext::createHandle(ze_bool_t isSubDevice, uint32_t subDeviceId) {
-    Power *pPower = new PowerImp(pOsSysman, isSubDevice, subDeviceId);
+void PowerHandleContext::createHandle(ze_bool_t isSubDevice, uint32_t subDeviceId, zes_power_domain_t powerDomain) {
+    Power *pPower = new PowerImp(pOsSysman, isSubDevice, subDeviceId, powerDomain);
     if (pPower->initSuccess == true) {
         handleList.push_back(pPower);
     } else {
@@ -35,11 +36,17 @@ void PowerHandleContext::createHandle(ze_bool_t isSubDevice, uint32_t subDeviceI
     }
 }
 ze_result_t PowerHandleContext::init(uint32_t subDeviceCount) {
-    // Create Handle for card level power
-    createHandle(false, 0);
+
+    auto totalDomains = OsPower::getNumberOfPowerDomainsSupported(pOsSysman);
+
+    for (auto &powerDomain : totalDomains) {
+        createHandle(false, 0, powerDomain);
+    }
 
     for (uint32_t subDeviceId = 0; subDeviceId < subDeviceCount; subDeviceId++) {
-        createHandle(true, subDeviceId);
+        for (auto &powerDomain : totalDomains) {
+            createHandle(true, subDeviceId, powerDomain);
+        }
     }
 
     return ZE_RESULT_SUCCESS;

level_zero/sysman/source/api/power/sysman_power.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -52,7 +52,7 @@ struct PowerHandleContext {
     }
 
   private:
-    void createHandle(ze_bool_t isSubDevice, uint32_t subDeviceId);
+    void createHandle(ze_bool_t isSubDevice, uint32_t subDeviceId, zes_power_domain_t powerDomain);
     std::once_flag initPowerOnce;
     void initPower();
     bool powerInitDone = false;

level_zero/sysman/source/api/power/sysman_power_imp.cpp

@@ -64,9 +64,9 @@ ze_result_t PowerImp::powerSetEnergyThreshold(double threshold) {
     return pOsPower->setEnergyThreshold(threshold);
 }
 
-PowerImp::PowerImp(OsSysman *pOsSysman, ze_bool_t isSubDevice, uint32_t subDeviceId) {
+PowerImp::PowerImp(OsSysman *pOsSysman, ze_bool_t isSubDevice, uint32_t subDeviceId, zes_power_domain_t powerDomain) {
 
-    pOsPower = OsPower::create(pOsSysman, isSubDevice, subDeviceId);
+    pOsPower = OsPower::create(pOsSysman, isSubDevice, subDeviceId, powerDomain);
     UNRECOVERABLE_IF(nullptr == pOsPower);
     this->isCardPower = isSubDevice ? false : true;
     init();

level_zero/sysman/source/api/power/sysman_power_imp.h

@@ -26,7 +26,7 @@ class PowerImp : public Power, NEO::NonCopyableOrMovableClass {
     ze_result_t powerSetLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
 
     PowerImp() = default;
-    PowerImp(OsSysman *pOsSysman, ze_bool_t isSubDevice, uint32_t subDeviceId);
+    PowerImp(OsSysman *pOsSysman, ze_bool_t isSubDevice, uint32_t subDeviceId, zes_power_domain_t powerDomain);
     ~PowerImp() override;
 
     OsPower *pOsPower = nullptr;

level_zero/sysman/source/api/power/windows/sysman_os_power_imp.cpp

@@ -14,6 +14,11 @@
 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) {
     pProperties->onSubdevice = false;
     pProperties->subdeviceId = 0;
@@ -24,6 +29,7 @@ ze_result_t WddmPowerImp::getProperties(zes_power_properties_t *pProperties) {
 
     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);
 
@@ -66,7 +72,32 @@ ze_result_t WddmPowerImp::getProperties(zes_power_properties_t *pProperties) {
 }
 
 ze_result_t WddmPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    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) {
@@ -76,6 +107,7 @@ ze_result_t WddmPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy)
 
     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);
@@ -96,6 +128,7 @@ ze_result_t WddmPowerImp::getLimits(zes_power_sustained_limit_t *pSustained, zes
 
     request.commandId = KmdSysman::Command::Get;
     request.componentId = KmdSysman::Component::PowerComponent;
+    request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
 
     if (pSustained) {
         memset(pSustained, 0, sizeof(zes_power_sustained_limit_t));
@@ -189,6 +222,7 @@ ze_result_t WddmPowerImp::setLimits(const zes_power_sustained_limit_t *pSustaine
 
     request.commandId = KmdSysman::Command::Set;
     request.componentId = KmdSysman::Component::PowerComponent;
+    request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
     request.dataSize = sizeof(uint32_t);
 
     if (pSustained) {
@@ -255,6 +289,7 @@ ze_result_t WddmPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold)
     request.commandId = KmdSysman::Command::Get;
     request.componentId = KmdSysman::Component::PowerComponent;
     request.requestId = KmdSysman::Requests::Power::CurrentEnergyThreshold;
+    request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
 
     ze_result_t status = pKmdSysManager->requestSingle(request, response);
 
@@ -278,6 +313,7 @@ ze_result_t WddmPowerImp::setEnergyThreshold(double threshold) {
 
     request.commandId = KmdSysman::Command::Set;
     request.componentId = KmdSysman::Component::PowerComponent;
+    request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
     request.requestId = KmdSysman::Requests::Power::CurrentEnergyThreshold;
     request.dataSize = sizeof(uint32_t);
 
@@ -295,6 +331,7 @@ bool WddmPowerImp::isPowerModuleSupported() {
 
     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::PowerLimit1Enabled;
     vRequests.push_back(request);
 
@@ -349,6 +386,7 @@ ze_result_t WddmPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
 
     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::PowerLimit1Enabled;
     vRequests.push_back(request);
 
@@ -455,6 +493,7 @@ ze_result_t WddmPowerImp::setLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
 
     request.commandId = KmdSysman::Command::Set;
     request.componentId = KmdSysman::Component::PowerComponent;
+    request.paramInfo = static_cast<uint32_t>(powerGroupToDomainTypeMap.at(this->powerDomain));
     request.dataSize = sizeof(uint32_t);
 
     for (uint32_t i = 0; i < *pCount; i++) {
@@ -493,13 +532,53 @@ ze_result_t WddmPowerImp::setLimitsExt(uint32_t *pCount, zes_power_limit_ext_des
     return status;
 }
 
-WddmPowerImp::WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
+WddmPowerImp::WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) : powerDomain(powerDomain) {
     WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
     pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
 }
 
-OsPower *OsPower::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
-    WddmPowerImp *pWddmPowerImp = new WddmPowerImp(pOsSysman, onSubdevice, subdeviceId);
+std::vector<zes_power_domain_t> OsPower::getNumberOfPowerDomainsSupported(OsSysman *pOsSysman) {
+    WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
+    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) {
+    WddmPowerImp *pWddmPowerImp = new WddmPowerImp(pOsSysman, onSubdevice, subdeviceId, powerDomain);
     return static_cast<OsPower *>(pWddmPowerImp);
 }
 

level_zero/sysman/source/api/power/windows/sysman_os_power_imp.h

@@ -26,13 +26,14 @@ class WddmPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
     ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) override;
 
     bool isPowerModuleSupported() override;
-    WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
+    WddmPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain);
     WddmPowerImp() = default;
     ~WddmPowerImp() override = default;
 
   protected:
     KmdSysManager *pKmdSysManager = nullptr;
     uint32_t powerLimitCount = 0;
+    zes_power_domain_t powerDomain = ZES_POWER_DOMAIN_CARD;
 };
 
 } // namespace Sysman