intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-29 09:03:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove DG1 directory from Sysman Power API implementation

Browse Source 
As there is no need to keep Sysman's power API's OS specific code
in DG1 folder. So, lets remove that DG1 directory.

Signed-off-by: Jitendra Sharma <jitendra.sharma@intel.com>
This commit is contained in:
Jitendra Sharma
2021-01-13 11:41:34 +05:30
committed by Compute-Runtime-Automation
parent 670013e88a
commit a931ce24fe
6 changed files with 12 additions and 765 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
level_zero/tools/source/sysman/power/linux/CMakeLists.txt
View File

@@ -1,22 +1,14 @@
#
# Copyright (C) 2020 Intel Corporation
# Copyright (C) 2020-2021 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(SUPPORT_DG1)
set(L0_SRCS_TOOLS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/dg1${BRANCH_DIR_SUFFIX}/os_power_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/dg1${BRANCH_DIR_SUFFIX}/os_power_imp.h
)
else()
set(L0_SRCS_TOOLS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/os_power_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_power_imp.h
)
endif()
set(L0_SRCS_TOOLS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_power_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/os_power_imp.h
)
if(UNIX)
target_sources(${L0_STATIC_LIB_NAME}

178
level_zero/tools/source/sysman/power/linux/dg1/os_power_imp.cpp
View File

@@ -1,178 +0,0 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/sysman/power/linux/dg1/os_power_imp.h"
#include "level_zero/tools/source/sysman/sysman_const.h"
#include "sysman/linux/os_sysman_imp.h"
namespace L0 {
const bool LinuxPowerImp::canControl = true;
const std::string LinuxPowerImp::hwmonDir("device/hwmon");
const std::string LinuxPowerImp::i915("i915");
const std::string LinuxPowerImp::sustainedPowerLimitEnabled("power1_max_enable");
const std::string LinuxPowerImp::sustainedPowerLimit("power1_max");
const std::string LinuxPowerImp::sustainedPowerLimitInterval("power1_max_interval");
const std::string LinuxPowerImp::burstPowerLimitEnabled("power1_cap_enable");
const std::string LinuxPowerImp::burstPowerLimit("power1_cap");
const std::string LinuxPowerImp::energyCounterNode("energy1_input");
void powerGetTimestamp(uint64_t &timestamp) {
std::chrono::time_point<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
}
ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
pProperties->onSubdevice = false;
pProperties->subdeviceId = 0;
pProperties->canControl = canControl;
pProperties->isEnergyThresholdSupported = false;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
auto result = pSysfsAccess->read(i915HwmonDir + "/" + energyCounterNode, pEnergy->energy);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
powerGetTimestamp(pEnergy->timestamp);
return result;
}
ze_result_t LinuxPowerImp::getLimits(zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak) {
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
uint64_t val = 0;
if (pSustained != nullptr) {
result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimitEnabled, val);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
pSustained->enabled = static_cast<ze_bool_t>(val);
if (pSustained->enabled) {
val = 0;
result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
val /= milliFactor; // Convert microWatts to milliwatts
pSustained->power = static_cast<int32_t>(val);
val = 0;
result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimitInterval, val);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
pSustained->interval = static_cast<int32_t>(val);
}
}
if (pBurst != nullptr) {
result = pSysfsAccess->read(i915HwmonDir + "/" + burstPowerLimitEnabled, val);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
pBurst->enabled = static_cast<ze_bool_t>(val);
if (pBurst->enabled) {
result = pSysfsAccess->read(i915HwmonDir + "/" + burstPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
val /= milliFactor; // Convert microWatts to milliwatts
pBurst->power = static_cast<int32_t>(val);
}
}
if (pPeak != nullptr) {
pPeak->powerAC = -1;
pPeak->powerDC = -1;
result = ZE_RESULT_SUCCESS;
}
return result;
}
ze_result_t LinuxPowerImp::setLimits(const zes_power_sustained_limit_t *pSustained, const zes_power_burst_limit_t *pBurst, const zes_power_peak_limit_t *pPeak) {
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
int32_t val = 0;
if (pSustained != nullptr) {
uint64_t isSustainedPowerLimitEnabled = 0;
result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimitEnabled, isSustainedPowerLimitEnabled);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
if (isSustainedPowerLimitEnabled) {
val = static_cast<uint32_t>(pSustained->power) * milliFactor; // Convert milliWatts to microwatts
result = pSysfsAccess->write(i915HwmonDir + "/" + sustainedPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
result = pSysfsAccess->write(i915HwmonDir + "/" + sustainedPowerLimitInterval, pSustained->interval);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
}
}
if (pBurst != nullptr) {
result = pSysfsAccess->write(i915HwmonDir + "/" + burstPowerLimitEnabled, static_cast<int>(pBurst->enabled));
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
if (pBurst->enabled) {
val = static_cast<uint32_t>(pBurst->power) * milliFactor; // Convert milliWatts to microwatts
result = pSysfsAccess->write(i915HwmonDir + "/" + burstPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
return getErrorCode(result);
}
}
}
return result;
}
ze_result_t LinuxPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxPowerImp::setEnergyThreshold(double threshold) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool LinuxPowerImp::isPowerModuleSupported() {
std::vector<std::string> listOfAllHwmonDirs = {};
if (ZE_RESULT_SUCCESS != pSysfsAccess->scanDirEntries(hwmonDir, listOfAllHwmonDirs)) {
return false;
}
for (const auto &tempHwmonDirEntry : listOfAllHwmonDirs) {
const std::string i915NameFile = hwmonDir + "/" + tempHwmonDirEntry + "/" + "name";
std::string name;
if (ZE_RESULT_SUCCESS != pSysfsAccess->read(i915NameFile, name)) {
continue;
}
if (name == i915) {
i915HwmonDir = hwmonDir + "/" + tempHwmonDirEntry;
return true;
}
}
return false;
}
LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
}
OsPower *OsPower::create(OsSysman *pOsSysman) {
LinuxPowerImp *pLinuxPowerImp = new LinuxPowerImp(pOsSysman);
return static_cast<OsPower *>(pLinuxPowerImp);
}
} // namespace L0

54
level_zero/tools/source/sysman/power/linux/dg1/os_power_imp.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/tools/source/sysman/power/os_power.h"
#include <string>
namespace L0 {
class SysfsAccess;
class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getProperties(zes_power_properties_t *pProperties) override;
ze_result_t getEnergyCounter(zes_power_energy_counter_t *pEnergy) override;
ze_result_t getLimits(zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak) override;
ze_result_t setLimits(const zes_power_sustained_limit_t *pSustained, const zes_power_burst_limit_t *pBurst, const zes_power_peak_limit_t *pPeak) override;
ze_result_t getEnergyThreshold(zes_energy_threshold_t *pThreshold) override;
ze_result_t setEnergyThreshold(double threshold) override;
bool isPowerModuleSupported() override;
LinuxPowerImp(OsSysman *pOsSysman);
LinuxPowerImp() = default;
~LinuxPowerImp() override = default;
protected:
SysfsAccess *pSysfsAccess = nullptr;
private:
std::string i915HwmonDir;
static const std::string hwmonDir;
static const std::string i915;
static const std::string sustainedPowerLimitEnabled;
static const std::string sustainedPowerLimit;
static const std::string sustainedPowerLimitInterval;
static const std::string burstPowerLimitEnabled;
static const std::string burstPowerLimit;
static const std::string energyCounterNode;
static const bool canControl;
ze_result_t getErrorCode(ze_result_t result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return result;
}
};
} // namespace L0

20
level_zero/tools/test/unit_tests/sources/sysman/power/linux/CMakeLists.txt
View File

@@ -1,22 +1,14 @@
#
# Copyright (C) 2020 Intel Corporation
# Copyright (C) 2020-2021 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(SUPPORT_DG1)
set(L0_TESTS_TOOLS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/dg1${BRANCH_DIR_SUFFIX}/test_zes_power.cpp
${CMAKE_CURRENT_SOURCE_DIR}/dg1${BRANCH_DIR_SUFFIX}/mock_sysfs_power.h
)
else()
set(L0_TESTS_TOOLS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_power.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_power.h
)
endif()
set(L0_TESTS_TOOLS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_zes_power.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/mock_sysfs_power.h
)
if(UNIX)
target_sources(${TARGET_NAME}

204
level_zero/tools/test/unit_tests/sources/sysman/power/linux/dg1/mock_sysfs_power.h
View File

@@ -1,204 +0,0 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/tools/source/sysman/power/linux/dg1/os_power_imp.h"
#include "sysman/linux/fs_access.h"
#include <string>
namespace L0 {
namespace ult {
const std::string hwmonDir("device/hwmon");
const std::string i915HwmonDir("device/hwmon/hwmon4");
const std::string nonI915HwmonDir("device/hwmon/hwmon1");
const std::vector<std::string> listOfMockedHwmonDirs = {"hwmon1", "hwmon2", "hwmon3", "hwmon4"};
const std::string sustainedPowerLimitEnabled("power1_max_enable");
const std::string sustainedPowerLimit("power1_max");
const std::string sustainedPowerLimitInterval("power1_max_interval");
const std::string burstPowerLimitEnabled("power1_cap_enable");
const std::string burstPowerLimit("power1_cap");
const std::string energyCounterNode("energy1_input");
constexpr uint64_t expectedEnergyCounter = 123456785u;
class PowerSysfsAccess : public SysfsAccess {};
template <>
struct Mock<PowerSysfsAccess> : public PowerSysfsAccess {
ze_result_t getValString(const std::string file, std::string &val) {
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
if (file.compare(i915HwmonDir + "/" + "name") == 0) {
val = "i915";
result = ZE_RESULT_SUCCESS;
} else if (file.compare(nonI915HwmonDir + "/" + "name") == 0) {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
} else {
val = "garbageI915";
result = ZE_RESULT_SUCCESS;
}
return result;
}
uint64_t sustainedPowerLimitEnabledVal = 1u;
uint64_t sustainedPowerLimitVal = 0;
uint64_t sustainedPowerLimitIntervalVal = 0;
uint64_t burstPowerLimitEnabledVal = 0;
uint64_t burstPowerLimitVal = 0;
uint64_t energyCounterNodeVal = expectedEnergyCounter;
ze_result_t getValUnsignedLongReturnErrorForEnergyCounter(const std::string file, uint64_t &val) {
if (file.compare(i915HwmonDir + "/" + energyCounterNode) == 0) {
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValUnsignedLongReturnErrorForBurstPowerLimit(const std::string file, uint64_t &val) {
if (file.compare(i915HwmonDir + "/" + burstPowerLimitEnabled) == 0) {
val = burstPowerLimitEnabledVal;
}
if (file.compare(i915HwmonDir + "/" + burstPowerLimit) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValUnsignedLongReturnErrorForBurstPowerLimitEnabled(const std::string file, uint64_t &val) {
if (file.compare(i915HwmonDir + "/" + burstPowerLimitEnabled) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValUnsignedLongReturnErrorForSustainedPowerLimitEnabled(const std::string file, uint64_t &val) {
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitEnabled) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValUnsignedLongReturnsPowerLimitEnabledAsDisabled(const std::string file, uint64_t &val) {
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitEnabled) == 0) {
val = 0;
return ZE_RESULT_SUCCESS;
} else if (file.compare(i915HwmonDir + "/" + burstPowerLimitEnabled) == 0) {
val = 0;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValUnsignedLongReturnErrorForSustainedPower(const std::string file, uint64_t &val) {
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitEnabled) == 0) {
val = 1;
} else if (file.compare(i915HwmonDir + "/" + sustainedPowerLimit) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValUnsignedLongReturnErrorForSustainedPowerInterval(const std::string file, uint64_t &val) {
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitEnabled) == 0) {
val = 1;
} else if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitInterval) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValUnsignedLongReturnErrorForBurstPowerLimit(const std::string file, const int val) {
if (file.compare(i915HwmonDir + "/" + burstPowerLimit) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValUnsignedLongReturnErrorForBurstPowerLimitEnabled(const std::string file, const int val) {
if (file.compare(i915HwmonDir + "/" + burstPowerLimitEnabled) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValReturnErrorForSustainedPower(const std::string file, const int val) {
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimit) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValReturnErrorForSustainedPowerInterval(const std::string file, const int val) {
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitInterval) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValUnsignedLong(const std::string file, uint64_t &val) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitEnabled) == 0) {
val = sustainedPowerLimitEnabledVal;
} else if (file.compare(i915HwmonDir + "/" + sustainedPowerLimit) == 0) {
val = sustainedPowerLimitVal;
} else if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitInterval) == 0) {
val = sustainedPowerLimitIntervalVal;
} else if (file.compare(i915HwmonDir + "/" + burstPowerLimitEnabled) == 0) {
val = burstPowerLimitEnabledVal;
} else if (file.compare(i915HwmonDir + "/" + burstPowerLimit) == 0) {
val = burstPowerLimitVal;
} else if (file.compare(i915HwmonDir + "/" + energyCounterNode) == 0) {
val = energyCounterNodeVal;
} else {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
}
ze_result_t setVal(const std::string file, const int val) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimit) == 0) {
sustainedPowerLimitVal = static_cast<uint64_t>(val);
} else if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitInterval) == 0) {
sustainedPowerLimitIntervalVal = static_cast<uint64_t>(val);
} else if (file.compare(i915HwmonDir + "/" + burstPowerLimitEnabled) == 0) {
burstPowerLimitEnabledVal = static_cast<uint64_t>(val);
} else if (file.compare(i915HwmonDir + "/" + burstPowerLimit) == 0) {
burstPowerLimitVal = static_cast<uint64_t>(val);
} else {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
}
ze_result_t getscanDirEntries(const std::string file, std::vector<std::string> &listOfEntries) {
if (file.compare(hwmonDir) == 0) {
listOfEntries = listOfMockedHwmonDirs;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getscanDirEntriesStatusReturnError(const std::string file, std::vector<std::string> &listOfEntries) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
Mock<PowerSysfsAccess>() = default;
MOCK_METHOD(ze_result_t, read, (const std::string file, uint64_t &val), (override));
MOCK_METHOD(ze_result_t, read, (const std::string file, std::string &val), (override));
MOCK_METHOD(ze_result_t, write, (const std::string file, const int val), (override));
MOCK_METHOD(ze_result_t, scanDirEntries, (const std::string file, std::vector<std::string> &listOfEntries), (override));
};
class PublicLinuxPowerImp : public L0::LinuxPowerImp {
public:
using LinuxPowerImp::pSysfsAccess;
};
} // namespace ult
} // namespace L0

301
level_zero/tools/test/unit_tests/sources/sysman/power/linux/dg1/test_zes_power.cpp
View File

@@ -1,301 +0,0 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
#include "mock_sysfs_power.h"
using ::testing::DoDefault;
using ::testing::Matcher;
using ::testing::Return;
namespace L0 {
namespace ult {
constexpr uint32_t powerHandleComponentCount = 1u;
class SysmanDevicePowerFixture : public SysmanDeviceFixture {
protected:
std::unique_ptr<Mock<PowerSysfsAccess>> pSysfsAccess;
SysfsAccess *pSysfsAccessOld = nullptr;
std::vector<ze_device_handle_t> deviceHandles;
void SetUp() override {
SysmanDeviceFixture::SetUp();
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<NiceMock<Mock<PowerSysfsAccess>>>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<std::string &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValString));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLong));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::setVal));
ON_CALL(*pSysfsAccess.get(), scanDirEntries(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getscanDirEntries));
pSysmanDeviceImp->pPowerHandleContext->init();
}
void TearDown() override {
SysmanDeviceFixture::TearDown();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
}
std::vector<zes_pwr_handle_t> get_power_handles(uint32_t count) {
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
TEST_F(SysmanDevicePowerFixture, GivenComponentCountZeroWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixture, GivenInvalidComponentCountWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
count = count + 1;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixture, GivenComponentCountZeroWhenEnumeratingPowerDomainsThenValidPowerHandlesIsReturned) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) {
auto handles = get_power_handles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCounterThenValidPowerReadingsRetrieved) {
auto handles = get_power_handles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_energy_counter_t energyCounter = {};
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCounterFailedThenValidErrorCodeReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLongReturnErrorForEnergyCounter));
for (auto handle : handles) {
zes_power_energy_counter_t energyCounter = {};
ASSERT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesPowerGetEnergyCounter(handle, &energyCounter));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
zes_energy_threshold_t threshold;
auto handles = get_power_handles(powerHandleComponentCount);
for (auto handle : handles) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetEnergyThreshold(handle, &threshold));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenSettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
double threshold = 0;
auto handles = get_power_handles(powerHandleComponentCount);
for (auto handle : handles) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetEnergyThreshold(handle, threshold));
}
}
TEST_F(SysmanDevicePowerFixture, GivenSetPowerLimitsWhenGettingPowerLimitsThenLimitsSetEarlierAreRetrieved) {
auto handles = get_power_handles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_sustained_limit_t sustainedSet = {};
zes_power_sustained_limit_t sustainedGet = {};
sustainedSet.interval = 10;
sustainedSet.power = 300000;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
EXPECT_EQ(sustainedGet.power, sustainedSet.power);
EXPECT_EQ(sustainedGet.interval, sustainedSet.interval);
zes_power_burst_limit_t burstSet = {};
zes_power_burst_limit_t burstGet = {};
burstSet.enabled = 1;
burstSet.power = 375000;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, &burstSet, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
EXPECT_EQ(burstSet.enabled, burstGet.enabled);
EXPECT_EQ(burstSet.power, burstGet.power);
burstSet.enabled = 0;
burstGet.enabled = 0;
burstGet.power = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, &burstSet, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
EXPECT_EQ(burstSet.enabled, burstGet.enabled);
EXPECT_EQ(burstGet.power, 0);
zes_power_peak_limit_t peakGet = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
EXPECT_EQ(peakGet.powerAC, -1);
EXPECT_EQ(peakGet.powerDC, -1);
}
}
TEST_F(SysmanDevicePowerFixture, GivenGetPowerLimitsReturnErrorWhenGettingPowerLimitsForBurstPowerLimitThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLongReturnErrorForBurstPowerLimit));
for (auto handle : handles) {
zes_power_burst_limit_t burstSet = {};
zes_power_burst_limit_t burstGet = {};
burstSet.enabled = 1;
burstSet.power = 375000;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, &burstSet, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenSetPowerLimitsReturnErrorWhenSettingPowerLimitsForBurstPowerLimitThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::setValUnsignedLongReturnErrorForBurstPowerLimit));
for (auto handle : handles) {
zes_power_burst_limit_t burstSet = {};
burstSet.enabled = 1;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, nullptr, &burstSet, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenSetPowerLimitsReturnErrorWhenSettingPowerLimitsForBurstPowerLimitEnabledThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::setValUnsignedLongReturnErrorForBurstPowerLimitEnabled));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLongReturnErrorForBurstPowerLimitEnabled));
for (auto handle : handles) {
zes_power_burst_limit_t burstSet = {};
zes_power_burst_limit_t burstGet = {};
burstSet.enabled = 1;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, nullptr, &burstSet, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingSustainedPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsForSustainedPowerLimitEnabledThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLongReturnErrorForSustainedPowerLimitEnabled));
for (auto handle : handles) {
zes_power_sustained_limit_t sustainedSet = {};
zes_power_sustained_limit_t sustainedGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingSustainedPowerNodeReturnErrorWhenGetPowerLimitsForSustainedPowerThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLongReturnErrorForSustainedPower));
for (auto handle : handles) {
zes_power_sustained_limit_t sustainedGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingSustainedPowerIntervalNodeReturnErrorWhenGetPowerLimitsForSustainedPowerThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLongReturnErrorForSustainedPowerInterval));
for (auto handle : handles) {
zes_power_sustained_limit_t sustainedGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenwritingSustainedPowerNodeReturnErrorWhenSetPowerLimitsForSustainedPowerThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::setValReturnErrorForSustainedPower));
zes_power_sustained_limit_t sustainedSet = {};
sustainedSet.interval = 10;
sustainedSet.power = 300000;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
}
TEST_F(SysmanDevicePowerFixture, GivenwritingSustainedPowerIntervalNodeReturnErrorWhenSetPowerLimitsForSustainedPowerIntervalThenProperErrorCodesReturned) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::setValReturnErrorForSustainedPowerInterval));
zes_power_sustained_limit_t sustainedSet = {};
sustainedSet.interval = 10;
sustainedSet.power = 300000;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
}
TEST_F(SysmanDevicePowerFixture, GivenGetPowerLimitsWhenPowerLimitsAreDisabledThenAllPowerValuesAreIgnored) {
auto handles = get_power_handles(powerHandleComponentCount);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<uint64_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PowerSysfsAccess>::getValUnsignedLongReturnsPowerLimitEnabledAsDisabled));
zes_power_sustained_limit_t sustainedGet = {};
zes_power_burst_limit_t burstGet = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handles[0], &sustainedGet, nullptr, nullptr));
EXPECT_EQ(sustainedGet.interval, 0);
EXPECT_EQ(sustainedGet.power, 0);
EXPECT_EQ(sustainedGet.enabled, 0);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handles[0], nullptr, &burstGet, nullptr));
EXPECT_EQ(burstGet.enabled, 0);
EXPECT_EQ(burstGet.power, 0);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedGet, nullptr, nullptr));
zes_power_burst_limit_t burstSet = {};
burstSet.enabled = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], nullptr, &burstSet, nullptr));
}
} // namespace ult
} // namespace L0