mirror of
https://github.com/intel/compute-runtime.git
synced 2026-01-06 02:18:05 +08:00
Update Temperature APIs to get correct temperature
This change updates Temperature APIs to get correct current temperature based on updated PMT interface. Signed-off-by: Jitendra Sharma <jitendra.sharma@intel.com>
This commit is contained in:
Jitendra Sharma
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
a6d898a026
commit
3597093758
@@ -194,6 +194,21 @@ void testSysmanPower(ze_device_handle_t &device) {
|
||||
}
|
||||
}
|
||||
|
||||
std::string getTemperatureSensorType(zes_temp_sensors_t type) {
|
||||
static const std::map<zes_temp_sensors_t, std::string> mgetSensorType{
|
||||
{ZES_TEMP_SENSORS_GLOBAL, "ZES_TEMP_SENSORS_GLOBAL"},
|
||||
{ZES_TEMP_SENSORS_GPU, "ZES_TEMP_SENSORS_GPU"},
|
||||
{ZES_TEMP_SENSORS_MEMORY, "ZES_TEMP_SENSORS_MEMORY"},
|
||||
{ZES_TEMP_SENSORS_GLOBAL_MIN, "ZES_TEMP_SENSORS_GLOBAL_MIN"},
|
||||
{ZES_TEMP_SENSORS_GPU_MIN, "ZES_TEMP_SENSORS_GPU_MIN"},
|
||||
{ZES_TEMP_SENSORS_MEMORY_MIN, "ZES_TEMP_SENSORS_MEMORY_MIN"}};
|
||||
auto i = mgetSensorType.find(type);
|
||||
if (i == mgetSensorType.end())
|
||||
return "NOT SUPPORTED MODE Engine avalialbe";
|
||||
else
|
||||
return mgetSensorType.at(type);
|
||||
}
|
||||
|
||||
void testSysmanTemperature(ze_device_handle_t &device) {
|
||||
std::cout << std::endl
|
||||
<< " ---- Temperature tests ---- " << std::endl;
|
||||
@@ -207,10 +222,14 @@ void testSysmanTemperature(ze_device_handle_t &device) {
|
||||
VALIDATECALL(zesDeviceEnumTemperatureSensors(device, &count, handles.data()));
|
||||
|
||||
for (const auto &handle : handles) {
|
||||
zes_temp_properties_t properties = {};
|
||||
VALIDATECALL(zesTemperatureGetProperties(handle, &properties));
|
||||
|
||||
double temperature;
|
||||
VALIDATECALL(zesTemperatureGetState(handle, &temperature));
|
||||
if (verbose) {
|
||||
std::cout << "temperature current state is: " << temperature << std::endl;
|
||||
std::cout << "For subDevice " << properties.subdeviceId << " temperature current state for "
|
||||
<< getTemperatureSensorType(properties.type) << " is: " << temperature << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
* Copyright (C) 2020-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -31,10 +31,10 @@ class SysmanMockDrm : public Drm {
|
||||
|
||||
class PublicLinuxSysmanImp : public L0::LinuxSysmanImp {
|
||||
public:
|
||||
using LinuxSysmanImp::mapOfSubDeviceIdToPmtObject;
|
||||
using LinuxSysmanImp::pDrm;
|
||||
using LinuxSysmanImp::pFsAccess;
|
||||
using LinuxSysmanImp::pFwUtilInterface;
|
||||
using LinuxSysmanImp::pPmt;
|
||||
using LinuxSysmanImp::pPmuInterface;
|
||||
using LinuxSysmanImp::pProcfsAccess;
|
||||
using LinuxSysmanImp::pSysfsAccess;
|
||||
|
||||
@@ -88,16 +88,6 @@ TEST_F(SysmanDeviceFixture, GivenInvalidPidWhenCallingProcfsAccessIsAliveThenErr
|
||||
EXPECT_FALSE(ProcfsAccess.isAlive(reinterpret_cast<::pid_t>(-1)));
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceFixture, GivenPmtHandleWhenCallinggetPlatformMonitoringTechAccessThenCreatedPmtHandleWillBeRetrieved) {
|
||||
if (pLinuxSysmanImp->pPmt != nullptr) {
|
||||
//delete previously allocated pPmt
|
||||
delete pLinuxSysmanImp->pPmt;
|
||||
pLinuxSysmanImp->pPmt = nullptr;
|
||||
}
|
||||
pLinuxSysmanImp->pPmt = new PlatformMonitoringTech();
|
||||
EXPECT_EQ(&pLinuxSysmanImp->getPlatformMonitoringTechAccess(), pLinuxSysmanImp->pPmt);
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleThenSameHandleIsRetrievedFromOsSpecificCode) {
|
||||
EXPECT_EQ(pLinuxSysmanImp->getDeviceHandle(), device);
|
||||
}
|
||||
@@ -112,6 +102,18 @@ TEST_F(SysmanDeviceFixture, GivenPmuInterfaceHandleWhenCallinggetPmuInterfaceThe
|
||||
EXPECT_EQ(pLinuxSysmanImp->getPmuInterface(), pLinuxSysmanImp->pPmuInterface);
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceFixture, GivenValidPciPathWhileGettingRootPciPortThenReturnedPathIs2LevelUpThenTheCurrentPath) {
|
||||
const std::string mockBdf = "0000:00:02.0";
|
||||
const std::string mockRealPath = "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/" + mockBdf;
|
||||
const std::string mockRealPath2LevelsUp = "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0";
|
||||
|
||||
std::string pciRootPort1 = pLinuxSysmanImp->getPciRootPortDirectoryPath(mockRealPath);
|
||||
EXPECT_EQ(pciRootPort1, mockRealPath2LevelsUp);
|
||||
|
||||
std::string pciRootPort2 = pLinuxSysmanImp->getPciRootPortDirectoryPath("device");
|
||||
EXPECT_EQ(pciRootPort2, "device");
|
||||
}
|
||||
|
||||
TEST_F(SysmanMultiDeviceFixture, GivenValidDeviceHandleHavingSubdevicesWhenValidatingSysmanHandlesForSubdevicesThenSysmanHandleForSubdeviceWillBeSameAsSysmanHandleForDevice) {
|
||||
uint32_t count = 0;
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getSubDevices(&count, nullptr));
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
* Copyright (C) 2020-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -136,7 +136,6 @@ struct Mock<PciSysfsAccess> : public PciSysfsAccess {
|
||||
|
||||
class PublicLinuxPciImp : public L0::LinuxPciImp {
|
||||
public:
|
||||
using LinuxPciImp::changeDirNLevelsUp;
|
||||
using LinuxPciImp::pfsAccess;
|
||||
using LinuxPciImp::pSysfsAccess;
|
||||
};
|
||||
|
||||
@@ -207,12 +207,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVe
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(ZesPciFixture, GivenValidPathWhileCallingchangeDirNLevelsUpThenReturnedPathIsNLevelUpThenTheCurrentPath) {
|
||||
PublicLinuxPciImp *pOsPci = static_cast<PublicLinuxPciImp *>(pPciImp->pOsPci);
|
||||
std::string testMockRealPath2LevelsUp = pOsPci->changeDirNLevelsUp(mockRealPath, 2);
|
||||
EXPECT_EQ(testMockRealPath2LevelsUp, mockRealPath2LevelsUp);
|
||||
}
|
||||
|
||||
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetStateThenVerifyzetSysmanPciGetStateCallReturnNotSupported) {
|
||||
zes_pci_state_t state;
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDevicePciGetState(device, &state));
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
* Copyright (C) 2020-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -11,7 +11,7 @@
|
||||
#include "level_zero/core/test/unit_tests/mock.h"
|
||||
#include "level_zero/tools/source/sysman/power/linux/os_power_imp.h"
|
||||
|
||||
#include "sysman/linux/pmt.h"
|
||||
#include "sysman/linux/pmt/pmt.h"
|
||||
#include "sysman/power/power_imp.h"
|
||||
#include "sysman/sysman_imp.h"
|
||||
|
||||
@@ -21,29 +21,90 @@ constexpr uint64_t setEnergyCounter = 83456;
|
||||
constexpr uint64_t offset = 0x400;
|
||||
constexpr uint64_t mappedLength = 2048;
|
||||
const std::string deviceName("device");
|
||||
FsAccess *pFsAccess = nullptr;
|
||||
class PowerPmt : public PlatformMonitoringTech {};
|
||||
const std::string baseTelemSysFS("/sys/class/pmt_telemetry");
|
||||
|
||||
class PowerPmt : public PlatformMonitoringTech {
|
||||
public:
|
||||
PowerPmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
|
||||
using PlatformMonitoringTech::keyOffsetMap;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Mock<PowerPmt> : public PlatformMonitoringTech {
|
||||
Mock() = default;
|
||||
struct Mock<PowerPmt> : public PowerPmt {
|
||||
~Mock() override {
|
||||
delete mappedMemory;
|
||||
mappedMemory = nullptr;
|
||||
if (mappedMemory != nullptr) {
|
||||
delete mappedMemory;
|
||||
mappedMemory = nullptr;
|
||||
}
|
||||
rootDeviceTelemNodeIndex = 0;
|
||||
}
|
||||
|
||||
void init(const std::string &deviceName, FsAccess *pFsAccess) override {
|
||||
Mock<PowerPmt>(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PowerPmt(pFsAccess, onSubdevice, subdeviceId) {}
|
||||
|
||||
void mockedInit(FsAccess *pFsAccess) {
|
||||
mappedMemory = new char[mappedLength];
|
||||
std::string rootPciPathOfGpuDevice = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
|
||||
if (ZE_RESULT_SUCCESS != PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, rootPciPathOfGpuDevice)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// fill memmory with 8 bytes of data using setEnergyCoutner at offset = 0x400
|
||||
for (uint64_t i = 0; i < sizeof(uint64_t); i++) {
|
||||
mappedMemory[offset + i] = static_cast<char>((setEnergyCounter >> 8 * i) & 0xff);
|
||||
}
|
||||
pmtSupported = true;
|
||||
}
|
||||
};
|
||||
|
||||
class PowerFsAccess : public FsAccess {};
|
||||
|
||||
template <>
|
||||
struct Mock<PowerFsAccess> : public PowerFsAccess {
|
||||
ze_result_t listDirectorySuccess(const std::string directory, std::vector<std::string> &listOfTelemNodes) {
|
||||
if (directory.compare(baseTelemSysFS) == 0) {
|
||||
listOfTelemNodes.push_back("telem1");
|
||||
listOfTelemNodes.push_back("telem2");
|
||||
listOfTelemNodes.push_back("telem3");
|
||||
listOfTelemNodes.push_back("telem4");
|
||||
listOfTelemNodes.push_back("telem5");
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
|
||||
ze_result_t listDirectoryFailure(const std::string directory, std::vector<std::string> &events) {
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
|
||||
ze_result_t getRealPathSuccess(const std::string path, std::string &buf) {
|
||||
if (path.compare("/sys/class/pmt_telemetry/telem1") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem1";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem2") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem2";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem3") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem3";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem4") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem4";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem5") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem5";
|
||||
} else {
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t getRealPathFailure(const std::string path, std::string &buf) {
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
|
||||
MOCK_METHOD(ze_result_t, listDirectory, (const std::string path, std::vector<std::string> &list), (override));
|
||||
MOCK_METHOD(ze_result_t, getRealPath, (const std::string path, std::string &buf), (override));
|
||||
Mock<PowerFsAccess>() = default;
|
||||
};
|
||||
|
||||
class PublicLinuxPowerImp : public L0::LinuxPowerImp {
|
||||
public:
|
||||
PublicLinuxPowerImp(OsSysman *pOsSysman) : LinuxPowerImp(pOsSysman) {}
|
||||
using LinuxPowerImp::pPmt;
|
||||
};
|
||||
} // namespace ult
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
* Copyright (C) 2020-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -18,21 +18,54 @@ namespace ult {
|
||||
|
||||
constexpr uint64_t convertJouleToMicroJoule = 1000000u;
|
||||
constexpr uint32_t powerHandleComponentCount = 1u;
|
||||
const std::map<std::string, uint64_t> deviceKeyOffsetMapPower = {
|
||||
{"PACKAGE_ENERGY", 0x400},
|
||||
{"COMPUTE_TEMPERATURES", 0x68},
|
||||
{"SOC_TEMPERATURES", 0x60},
|
||||
{"CORE_TEMPERATURES", 0x6c}};
|
||||
|
||||
class SysmanDevicePowerFixture : public SysmanDeviceFixture {
|
||||
protected:
|
||||
std::unique_ptr<PublicLinuxPowerImp> pPublicLinuxPowerImp;
|
||||
std::unique_ptr<Mock<PowerPmt>> pPmt;
|
||||
PlatformMonitoringTech *pPmtOld = nullptr;
|
||||
std::unique_ptr<Mock<PowerFsAccess>> pFsAccess;
|
||||
FsAccess *pFsAccessOriginal = nullptr;
|
||||
OsPower *pOsPowerOriginal = nullptr;
|
||||
std::vector<ze_device_handle_t> deviceHandles;
|
||||
void SetUp() override {
|
||||
SysmanDeviceFixture::SetUp();
|
||||
pPmtOld = pLinuxSysmanImp->pPmt;
|
||||
pPmt = std::make_unique<NiceMock<Mock<PowerPmt>>>();
|
||||
pPmt->init(deviceName, pFsAccess);
|
||||
pLinuxSysmanImp->pPmt = pPmt.get();
|
||||
pFsAccess = std::make_unique<NiceMock<Mock<PowerFsAccess>>>();
|
||||
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
|
||||
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
|
||||
ON_CALL(*pFsAccess.get(), listDirectory(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<PowerFsAccess>::listDirectorySuccess));
|
||||
ON_CALL(*pFsAccess.get(), getRealPath(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<PowerFsAccess>::getRealPathSuccess));
|
||||
|
||||
uint32_t subDeviceCount = 0;
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
|
||||
if (subDeviceCount == 0) {
|
||||
deviceHandles.resize(1, device->toHandle());
|
||||
} else {
|
||||
deviceHandles.resize(subDeviceCount, nullptr);
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
|
||||
}
|
||||
|
||||
for (auto &deviceHandle : deviceHandles) {
|
||||
ze_device_properties_t deviceProperties = {};
|
||||
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
|
||||
auto pPmt = new NiceMock<Mock<PowerPmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
|
||||
deviceProperties.subdeviceId);
|
||||
pPmt->mockedInit(pFsAccess.get());
|
||||
pPmt->keyOffsetMap = deviceKeyOffsetMapPower;
|
||||
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
|
||||
}
|
||||
|
||||
pSysmanDeviceImp->pPowerHandleContext->init();
|
||||
}
|
||||
void TearDown() override {
|
||||
SysmanDeviceFixture::TearDown();
|
||||
pLinuxSysmanImp->pPmt = pPmtOld;
|
||||
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
|
||||
}
|
||||
|
||||
std::vector<zes_pwr_handle_t> get_power_handles(uint32_t count) {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (C) 2020 Intel Corporation
|
||||
# Copyright (C) 2020-2021 Intel Corporation
|
||||
#
|
||||
# SPDX-License-Identifier: MIT
|
||||
#
|
||||
@@ -8,7 +8,7 @@ if(UNIX)
|
||||
target_sources(${TARGET_NAME}
|
||||
PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_temperature.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_zes_temperature.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_temperature.h
|
||||
)
|
||||
endif()
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
* Copyright (C) 2020-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -8,49 +8,119 @@
|
||||
#pragma once
|
||||
#include "level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h"
|
||||
|
||||
#include "sysman/linux/pmt.h"
|
||||
#include "sysman/linux/pmt/pmt.h"
|
||||
#include "sysman/temperature/temperature_imp.h"
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
constexpr uint8_t computeIndex = 9;
|
||||
constexpr uint8_t globalIndex = 3;
|
||||
constexpr uint8_t tempArr[16] = {0x12, 0x23, 0x43, 0xde, 0xa3, 0xce, 0x23, 0x11, 0x45, 0x32, 0x67, 0x47, 0xac, 0x21, 0x03, 0x90};
|
||||
constexpr uint64_t offsetCompute = 0x60;
|
||||
|
||||
constexpr uint8_t tempArrForSubDevices[28] = {0x12, 0, 0, 0, 0, 0, 0, 0, 0x45, 0, 0, 0, 0x6f, 0, 0, 0, 0x34, 0, 0, 0, 0x16, 0, 0, 0, 0x1d, 0, 0, 0};
|
||||
constexpr uint64_t offsetForSubDevices = 28;
|
||||
constexpr uint8_t memory0MaxTempIndex = 0;
|
||||
constexpr uint8_t memory1MaxTempIndex = 8;
|
||||
constexpr uint8_t subDeviceMinTempIndex = 12;
|
||||
constexpr uint8_t subDeviceMaxTempIndex = 16;
|
||||
constexpr uint8_t gtMinTempIndex = 20;
|
||||
constexpr uint8_t gtMaxTempIndex = 24;
|
||||
|
||||
constexpr uint8_t tempArrForNoSubDevices[19] = {0x12, 0x23, 0x43, 0xde, 0xa3, 0xce, 0x23, 0x11, 0x45, 0x32, 0x67, 0x47, 0xac, 0x21, 0x03, 0x90, 0, 0, 0};
|
||||
constexpr uint64_t offsetForNoSubDevices = 0x60;
|
||||
constexpr uint8_t computeIndexForNoSubDevices = 9;
|
||||
constexpr uint8_t globalIndexForNoSubDevices = 3;
|
||||
|
||||
constexpr uint64_t mappedLength = 256;
|
||||
const std::string baseTelemSysFS("/sys/class/pmt_telemetry");
|
||||
class TemperaturePmt : public PlatformMonitoringTech {
|
||||
public:
|
||||
TemperaturePmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
|
||||
using PlatformMonitoringTech::keyOffsetMap;
|
||||
using PlatformMonitoringTech::mappedMemory;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct Mock<TemperaturePmt> : public TemperaturePmt {
|
||||
Mock() = default;
|
||||
Mock<TemperaturePmt>(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : TemperaturePmt(pFsAccess, onSubdevice, subdeviceId) {}
|
||||
~Mock() override {
|
||||
if (mappedMemory != nullptr) {
|
||||
delete mappedMemory;
|
||||
mappedMemory = nullptr;
|
||||
}
|
||||
rootDeviceTelemNodeIndex = 0;
|
||||
}
|
||||
|
||||
void setVal(bool val) {
|
||||
isPmtSupported = val;
|
||||
}
|
||||
|
||||
void init(const std::string &deviceName, FsAccess *pFsAccess) override {
|
||||
void mockedInit(FsAccess *pFsAccess) {
|
||||
mappedMemory = new char[mappedLength];
|
||||
for (uint64_t i = 0; i < sizeof(tempArr) / sizeof(uint8_t); i++) {
|
||||
mappedMemory[offsetCompute + i] = tempArr[i];
|
||||
std::string rootPciPathOfGpuDevice = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
|
||||
if (ZE_RESULT_SUCCESS != PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, rootPciPathOfGpuDevice)) {
|
||||
return;
|
||||
}
|
||||
// Fill mappedMemory to validate cases when there are subdevices
|
||||
for (uint64_t i = 0; i < sizeof(tempArrForSubDevices) / sizeof(uint8_t); i++) {
|
||||
mappedMemory[offsetForSubDevices + i] = tempArrForSubDevices[i];
|
||||
}
|
||||
// Fill mappedMemory to validate cases when there are no subdevices
|
||||
for (uint64_t i = 0; i < sizeof(tempArrForNoSubDevices) / sizeof(uint8_t); i++) {
|
||||
mappedMemory[offsetForNoSubDevices + i] = tempArrForNoSubDevices[i];
|
||||
}
|
||||
pmtSupported = isPmtSupported;
|
||||
}
|
||||
|
||||
private:
|
||||
bool isPmtSupported = false;
|
||||
void mockedInitWithoutMappedMemory(FsAccess *pFsAccess) {
|
||||
std::string rootPciPathOfGpuDevice = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
|
||||
if (ZE_RESULT_SUCCESS != PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, rootPciPathOfGpuDevice)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class TemperatureFsAccess : public FsAccess {};
|
||||
|
||||
template <>
|
||||
struct Mock<TemperatureFsAccess> : public TemperatureFsAccess {
|
||||
ze_result_t listDirectorySuccess(const std::string directory, std::vector<std::string> &listOfTelemNodes) {
|
||||
if (directory.compare(baseTelemSysFS) == 0) {
|
||||
listOfTelemNodes.push_back("telem1");
|
||||
listOfTelemNodes.push_back("telem2");
|
||||
listOfTelemNodes.push_back("telem3");
|
||||
listOfTelemNodes.push_back("telem4");
|
||||
listOfTelemNodes.push_back("telem5");
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
|
||||
ze_result_t listDirectoryFailure(const std::string directory, std::vector<std::string> &events) {
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
ze_result_t getRealPathSuccess(const std::string path, std::string &buf) {
|
||||
if (path.compare("/sys/class/pmt_telemetry/telem1") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem1";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem2") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem2";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem3") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem3";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem4") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem4";
|
||||
} else if (path.compare("/sys/class/pmt_telemetry/telem5") == 0) {
|
||||
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry/telem5";
|
||||
} else {
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t getRealPathFailure(const std::string path, std::string &buf) {
|
||||
return ZE_RESULT_ERROR_NOT_AVAILABLE;
|
||||
}
|
||||
|
||||
MOCK_METHOD(ze_result_t, listDirectory, (const std::string path, std::vector<std::string> &list), (override));
|
||||
MOCK_METHOD(ze_result_t, getRealPath, (const std::string path, std::string &buf), (override));
|
||||
Mock<TemperatureFsAccess>() = default;
|
||||
};
|
||||
|
||||
class PublicLinuxTemperatureImp : public L0::LinuxTemperatureImp {
|
||||
public:
|
||||
PublicLinuxTemperatureImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : LinuxTemperatureImp(pOsSysman, onSubdevice, subdeviceId) {}
|
||||
using LinuxTemperatureImp::pPmt;
|
||||
using LinuxTemperatureImp::type;
|
||||
};
|
||||
|
||||
@@ -1,144 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
|
||||
#include "level_zero/tools/source/sysman/sysman_imp.h"
|
||||
#include "level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
#include "mock_sysfs_temperature.h"
|
||||
#include "sysman/linux/os_sysman_imp.h"
|
||||
#include "sysman/temperature/temperature_imp.h"
|
||||
|
||||
using ::testing::_;
|
||||
using ::testing::NiceMock;
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
constexpr uint32_t handleCount = 2u; // We are creating two temp handles
|
||||
const std::string deviceName("testDevice");
|
||||
class SysmanTemperatureFixture : public DeviceFixture, public ::testing::Test {
|
||||
protected:
|
||||
std::unique_ptr<SysmanImp> sysmanImp;
|
||||
zet_sysman_handle_t hSysman;
|
||||
Mock<TemperaturePmt> *pPmt = nullptr;
|
||||
|
||||
TemperatureImp *pTemperatureImp[handleCount] = {};
|
||||
zet_sysman_temp_handle_t hSysmanTempHandle[handleCount];
|
||||
PublicLinuxTemperatureImp linuxTemperatureImp[handleCount];
|
||||
|
||||
void SetUp() override {
|
||||
DeviceFixture::SetUp();
|
||||
sysmanImp = std::make_unique<SysmanImp>(device->toHandle());
|
||||
pPmt = new NiceMock<Mock<TemperaturePmt>>;
|
||||
FsAccess *pFsAccess = nullptr;
|
||||
pPmt->setVal(true);
|
||||
pPmt->init(deviceName, pFsAccess);
|
||||
|
||||
for (uint32_t i = 0; i < handleCount; i++) {
|
||||
linuxTemperatureImp[i].pPmt = pPmt;
|
||||
linuxTemperatureImp[i].setSensorType(static_cast<zes_temp_sensors_t>(i));
|
||||
OsTemperature *pOsTemperature = static_cast<OsTemperature *>(&linuxTemperatureImp[i]);
|
||||
pTemperatureImp[i] = new TemperatureImp();
|
||||
pTemperatureImp[i]->pOsTemperature = pOsTemperature;
|
||||
pTemperatureImp[i]->init();
|
||||
sysmanImp->pTempHandleContext->handleList.push_back(pTemperatureImp[i]);
|
||||
hSysmanTempHandle[i] = pTemperatureImp[i]->toZetHandle();
|
||||
}
|
||||
hSysman = sysmanImp->toHandle();
|
||||
}
|
||||
void TearDown() override {
|
||||
// pOsTemperatureGlobal is static_cast of LinuxTemperatureImp class , hence in cleanup assign to nullptr
|
||||
pTemperatureImp[0]->pOsTemperature = nullptr;
|
||||
pTemperatureImp[1]->pOsTemperature = nullptr;
|
||||
|
||||
if (pPmt != nullptr) {
|
||||
delete pPmt;
|
||||
pPmt = nullptr;
|
||||
}
|
||||
DeviceFixture::TearDown();
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(SysmanTemperatureFixture, GivenComponentCountZeroWhenCallingZetSysmanTemperatureGetThenZeroCountIsReturnedAndVerifySysmanTemperatureGetCallSucceeds) {
|
||||
uint32_t count = 0;
|
||||
ze_result_t result = zetSysmanTemperatureGet(hSysman, &count, NULL);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
EXPECT_EQ(count, handleCount);
|
||||
uint32_t testcount = count + 1;
|
||||
result = zetSysmanTemperatureGet(hSysman, &testcount, NULL);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
EXPECT_EQ(testcount, count);
|
||||
}
|
||||
|
||||
TEST_F(SysmanTemperatureFixture, GivenValidTempHandleWhenGettingGPUTemperatureThenValidTemperatureReadingsRetrieved) {
|
||||
double temperature;
|
||||
ASSERT_EQ(ZE_RESULT_SUCCESS, zetSysmanTemperatureGetState(hSysmanTempHandle[1], &temperature));
|
||||
EXPECT_EQ(temperature, static_cast<double>(tempArr[computeIndex]));
|
||||
}
|
||||
|
||||
TEST_F(SysmanTemperatureFixture, GivenValidTempHandleWhenGettingGlobalTemperatureThenValidTemperatureReadingsRetrieved) {
|
||||
double temperature;
|
||||
ASSERT_EQ(ZE_RESULT_SUCCESS, zetSysmanTemperatureGetState(hSysmanTempHandle[0], &temperature));
|
||||
EXPECT_EQ(temperature, static_cast<double>(tempArr[globalIndex]));
|
||||
}
|
||||
|
||||
TEST_F(SysmanTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) {
|
||||
double pTemperature = 0;
|
||||
linuxTemperatureImp[0].setSensorType(ZET_TEMP_SENSORS_MEMORY);
|
||||
OsTemperature *pOsTemperatureTest1 = static_cast<OsTemperature *>(&linuxTemperatureImp[0]);
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pOsTemperatureTest1->getSensorTemperature(&pTemperature));
|
||||
|
||||
linuxTemperatureImp[1].setSensorType(ZET_TEMP_SENSORS_MEMORY);
|
||||
OsTemperature *pOsTemperatureTest2 = static_cast<OsTemperature *>(&linuxTemperatureImp[1]);
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pOsTemperatureTest2->getSensorTemperature(&pTemperature));
|
||||
}
|
||||
|
||||
TEST_F(SysmanTemperatureFixture, GivenPmtSupportNotAvailableWhenCheckingForTempModuleSupportThenTempModuleSupportShouldReturnFalse) {
|
||||
//delete previously allocated memory, allocated by init() call in SetUp()
|
||||
if (pPmt->mappedMemory != nullptr) {
|
||||
delete pPmt->mappedMemory;
|
||||
pPmt->mappedMemory = nullptr;
|
||||
}
|
||||
pPmt->setVal(false);
|
||||
FsAccess *pFsAccess = nullptr;
|
||||
pPmt->init(deviceName, pFsAccess);
|
||||
EXPECT_FALSE(pTemperatureImp[0]->pOsTemperature->isTempModuleSupported());
|
||||
EXPECT_FALSE(pTemperatureImp[1]->pOsTemperature->isTempModuleSupported());
|
||||
}
|
||||
|
||||
TEST_F(SysmanTemperatureFixture, GivenPmtSupportAvailableWhenCheckingForTempModuleSupportThenTempModuleSupportShouldReturnTrue) {
|
||||
//delete previously allocated memory, allocated by init() call in SetUp()
|
||||
if (pPmt->mappedMemory != nullptr) {
|
||||
delete pPmt->mappedMemory;
|
||||
pPmt->mappedMemory = nullptr;
|
||||
}
|
||||
pPmt->setVal(true);
|
||||
FsAccess *pFsAccess = nullptr;
|
||||
pPmt->init(deviceName, pFsAccess);
|
||||
EXPECT_TRUE(pTemperatureImp[0]->pOsTemperature->isTempModuleSupported());
|
||||
EXPECT_TRUE(pTemperatureImp[1]->pOsTemperature->isTempModuleSupported());
|
||||
}
|
||||
|
||||
class ZetPublicLinuxSysmanImpTemperature : public L0::LinuxSysmanImp {
|
||||
public:
|
||||
using LinuxSysmanImp::pPmt;
|
||||
ZetPublicLinuxSysmanImpTemperature(SysmanImp *pParentSysmanImp) : LinuxSysmanImp(pParentSysmanImp) {}
|
||||
};
|
||||
|
||||
TEST_F(SysmanTemperatureFixture, GivenOsSysmanPointerWhenCreatingOsTemperaturePointerThenValidOsTemperatureIsCreated) {
|
||||
auto pLinuxSysmanImpTest = std::make_unique<ZetPublicLinuxSysmanImpTemperature>(sysmanImp.get());
|
||||
pLinuxSysmanImpTest->pPmt = new PlatformMonitoringTech();
|
||||
auto pOsSysmanTest = static_cast<OsSysman *>(pLinuxSysmanImpTest.get());
|
||||
auto pOsTemperatureTest = OsTemperature::create(pOsSysmanTest, ZES_TEMP_SENSORS_GLOBAL);
|
||||
EXPECT_NE(pOsTemperatureTest, nullptr);
|
||||
delete pOsTemperatureTest;
|
||||
}
|
||||
|
||||
} // namespace ult
|
||||
} // namespace L0
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
* Copyright (C) 2020-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -10,25 +10,58 @@
|
||||
|
||||
namespace L0 {
|
||||
namespace ult {
|
||||
constexpr uint32_t handleComponentCount = 3u;
|
||||
const std::string deviceName("testDevice");
|
||||
FsAccess *pFsAccessTemp = nullptr;
|
||||
class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
|
||||
std::string rootPciPathOfGpuDevice = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
|
||||
constexpr uint32_t handleComponentCountForSubDevices = 10u;
|
||||
constexpr uint32_t handleComponentCountForNoSubDevices = 2u;
|
||||
constexpr uint32_t invalidMaxTemperature = 125;
|
||||
constexpr uint32_t invalidMinTemperature = 10;
|
||||
|
||||
const std::map<std::string, uint64_t> deviceKeyOffsetMapTemperature = {
|
||||
{"PACKAGE_ENERGY", 0x420},
|
||||
{"COMPUTE_TEMPERATURES", 0x68},
|
||||
{"SOC_TEMPERATURES", 0x60},
|
||||
{"CORE_TEMPERATURES", 0x6c}};
|
||||
|
||||
class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
|
||||
protected:
|
||||
std::unique_ptr<Mock<TemperaturePmt>> pPmt;
|
||||
PlatformMonitoringTech *pPmtOld = nullptr;
|
||||
std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
|
||||
std::unique_ptr<Mock<TemperatureFsAccess>> pFsAccess;
|
||||
FsAccess *pFsAccessOriginal = nullptr;
|
||||
std::vector<ze_device_handle_t> deviceHandles;
|
||||
void SetUp() override {
|
||||
SysmanDeviceFixture::SetUp();
|
||||
pPmtOld = pLinuxSysmanImp->pPmt;
|
||||
pPmt = std::make_unique<NiceMock<Mock<TemperaturePmt>>>();
|
||||
pPmt->setVal(true);
|
||||
pPmt->init(deviceName, pFsAccessTemp);
|
||||
pLinuxSysmanImp->pPmt = pPmt.get();
|
||||
pSysmanDeviceImp->pTempHandleContext->init();
|
||||
SysmanMultiDeviceFixture::SetUp();
|
||||
pFsAccess = std::make_unique<NiceMock<Mock<TemperatureFsAccess>>>();
|
||||
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
|
||||
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
|
||||
ON_CALL(*pFsAccess.get(), listDirectory(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<TemperatureFsAccess>::listDirectorySuccess));
|
||||
ON_CALL(*pFsAccess.get(), getRealPath(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<TemperatureFsAccess>::getRealPathSuccess));
|
||||
|
||||
uint32_t subDeviceCount = 0;
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
|
||||
if (subDeviceCount == 0) {
|
||||
deviceHandles.resize(1, device->toHandle());
|
||||
} else {
|
||||
deviceHandles.resize(subDeviceCount, nullptr);
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
|
||||
}
|
||||
|
||||
for (auto &deviceHandle : deviceHandles) {
|
||||
ze_device_properties_t deviceProperties = {};
|
||||
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
|
||||
auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
|
||||
deviceProperties.subdeviceId);
|
||||
pPmt->mockedInit(pFsAccess.get());
|
||||
pPmt->keyOffsetMap = deviceKeyOffsetMapTemperature;
|
||||
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
|
||||
}
|
||||
|
||||
pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
|
||||
}
|
||||
void TearDown() override {
|
||||
SysmanDeviceFixture::TearDown();
|
||||
pLinuxSysmanImp->pPmt = pPmtOld;
|
||||
SysmanMultiDeviceFixture::TearDown();
|
||||
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
|
||||
}
|
||||
|
||||
std::vector<zes_temp_handle_t> get_temp_handles(uint32_t count) {
|
||||
@@ -38,101 +71,214 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenComponentCountZeroWhenCallingZetSysmanTemperatureGetThenZeroCountIsReturnedAndVerifySysmanTemperatureGetCallSucceeds) {
|
||||
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenComponentCountZeroWhenCallingZetSysmanTemperatureGetThenZeroCountIsReturnedAndVerifySysmanTemperatureGetCallSucceeds) {
|
||||
uint32_t count = 0;
|
||||
ze_result_t result = zesDeviceEnumTemperatureSensors(device->toHandle(), &count, NULL);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
EXPECT_EQ(count, handleComponentCount);
|
||||
EXPECT_EQ(count, handleComponentCountForSubDevices);
|
||||
|
||||
uint32_t testcount = count + 1;
|
||||
result = zesDeviceEnumTemperatureSensors(device->toHandle(), &testcount, NULL);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
EXPECT_EQ(testcount, handleComponentCount);
|
||||
EXPECT_EQ(testcount, handleComponentCountForSubDevices);
|
||||
|
||||
count = 0;
|
||||
std::vector<zes_temp_handle_t> handles(count, nullptr);
|
||||
EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
|
||||
EXPECT_EQ(count, handleComponentCount);
|
||||
EXPECT_EQ(count, handleComponentCountForSubDevices);
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUTemperatureThenValidTemperatureReadingsRetrieved) {
|
||||
auto handles = get_temp_handles(handleComponentCount);
|
||||
double temperature;
|
||||
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handles[1], &temperature));
|
||||
EXPECT_EQ(temperature, static_cast<double>(tempArr[computeIndex]));
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGlobalTemperatureThenValidTemperatureReadingsRetrieved) {
|
||||
auto handles = get_temp_handles(handleComponentCount);
|
||||
double temperature;
|
||||
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handles[0], &temperature));
|
||||
EXPECT_EQ(temperature, static_cast<double>(tempArr[globalIndex]));
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) {
|
||||
auto pTemperatureImpMemory = std::make_unique<TemperatureImp>(pOsSysman, ZES_TEMP_SENSORS_GLOBAL_MIN);
|
||||
auto pLinuxTemperatureImpMemory = static_cast<LinuxTemperatureImp *>(pTemperatureImpMemory->pOsTemperature);
|
||||
double pTemperature = 0;
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxTemperatureImpMemory->getSensorTemperature(&pTemperature));
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenPmtSupportNotAvailableWhenCheckingForTempModuleSupportThenTempModuleSupportShouldReturnFalse) {
|
||||
//delete previously allocated memory, allocated by init() call in SetUp()
|
||||
if (pPmt->mappedMemory != nullptr) {
|
||||
delete pPmt->mappedMemory;
|
||||
pPmt->mappedMemory = nullptr;
|
||||
}
|
||||
pPmt->setVal(false);
|
||||
//FsAccess *pFsAccessTemp = nullptr;
|
||||
pPmt->init(deviceName, pFsAccessTemp);
|
||||
auto handles = get_temp_handles(handleComponentCount);
|
||||
for (auto handle : handles) {
|
||||
auto pTemperatureImpTest = static_cast<TemperatureImp *>(L0::Temperature::fromHandle(handle));
|
||||
EXPECT_FALSE(pTemperatureImpTest->pOsTemperature->isTempModuleSupported());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenPmtSupportAvailableWhenCheckingForTempModuleSupportThenTempModuleSupportShouldReturnTrue) {
|
||||
//delete previously allocated memory, allocated by init() call in SetUp()
|
||||
if (pPmt->mappedMemory != nullptr) {
|
||||
delete pPmt->mappedMemory;
|
||||
pPmt->mappedMemory = nullptr;
|
||||
}
|
||||
pPmt->setVal(true);
|
||||
//FsAccess *pFsAccessTemp = nullptr;
|
||||
pPmt->init(deviceName, pFsAccessTemp);
|
||||
auto handles = get_temp_handles(handleComponentCount);
|
||||
for (auto handle : handles) {
|
||||
auto pTemperatureImpTest = static_cast<TemperatureImp *>(L0::Temperature::fromHandle(handle));
|
||||
EXPECT_TRUE(pTemperatureImpTest->pOsTemperature->isTempModuleSupported());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperaturePropertiesThenUnsupportedIsReturned) {
|
||||
auto handles = get_temp_handles(handleComponentCount);
|
||||
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureThenValidTemperatureReadingsRetrieved) {
|
||||
auto handles = get_temp_handles(handleComponentCountForSubDevices);
|
||||
for (auto handle : handles) {
|
||||
zes_temp_properties_t properties = {};
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
|
||||
EXPECT_FALSE(properties.onSubdevice);
|
||||
EXPECT_EQ(properties.subdeviceId, 0u);
|
||||
double temperature;
|
||||
ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetState(handle, &temperature));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureConfigThenUnsupportedIsReturned) {
|
||||
auto handles = get_temp_handles(handleComponentCount);
|
||||
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureConfigThenUnsupportedIsReturned) {
|
||||
auto handles = get_temp_handles(handleComponentCountForSubDevices);
|
||||
for (auto handle : handles) {
|
||||
zes_temp_config_t config = {};
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetConfig(handle, &config));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenSettingTemperatureConfigThenUnsupportedIsReturned) {
|
||||
auto handles = get_temp_handles(handleComponentCount);
|
||||
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenSettingTemperatureConfigThenUnsupportedIsReturned) {
|
||||
auto handles = get_temp_handles(handleComponentCountForSubDevices);
|
||||
for (auto handle : handles) {
|
||||
zes_temp_config_t config = {};
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureSetConfig(handle, &config));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenCreatePmtObjectsWhenRootTileIndexEnumeratesSuccessfulThenValidatePmtObjectsReceivedAndBranches) {
|
||||
std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
|
||||
PlatformMonitoringTech::create(deviceHandles, pFsAccess.get(), rootPciPathOfGpuDevice, mapOfSubDeviceIdToPmtObject);
|
||||
uint32_t deviceHandlesIndex = 0;
|
||||
for (auto &subDeviceIdToPmtEntry : mapOfSubDeviceIdToPmtObject) {
|
||||
ze_device_properties_t deviceProperties = {};
|
||||
Device::fromHandle(deviceHandles[deviceHandlesIndex++])->getProperties(&deviceProperties);
|
||||
EXPECT_NE(subDeviceIdToPmtEntry.second, nullptr);
|
||||
EXPECT_EQ(subDeviceIdToPmtEntry.first, deviceProperties.subdeviceId);
|
||||
delete subDeviceIdToPmtEntry.second; // delete memory to avoid mem leak here, as we finished our test validation just above.
|
||||
}
|
||||
}
|
||||
|
||||
class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
|
||||
protected:
|
||||
std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
|
||||
std::unique_ptr<Mock<TemperatureFsAccess>> pFsAccess;
|
||||
FsAccess *pFsAccessOriginal = nullptr;
|
||||
std::vector<ze_device_handle_t> deviceHandles;
|
||||
void SetUp() override {
|
||||
SysmanDeviceFixture::SetUp();
|
||||
pFsAccess = std::make_unique<NiceMock<Mock<TemperatureFsAccess>>>();
|
||||
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
|
||||
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
|
||||
ON_CALL(*pFsAccess.get(), listDirectory(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<TemperatureFsAccess>::listDirectorySuccess));
|
||||
ON_CALL(*pFsAccess.get(), getRealPath(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<TemperatureFsAccess>::getRealPathSuccess));
|
||||
|
||||
uint32_t subDeviceCount = 0;
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
|
||||
if (subDeviceCount == 0) {
|
||||
deviceHandles.resize(1, device->toHandle());
|
||||
} else {
|
||||
deviceHandles.resize(subDeviceCount, nullptr);
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
|
||||
}
|
||||
|
||||
for (auto &deviceHandle : deviceHandles) {
|
||||
ze_device_properties_t deviceProperties = {};
|
||||
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
|
||||
auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
|
||||
deviceProperties.subdeviceId);
|
||||
pPmt->mockedInit(pFsAccess.get());
|
||||
pPmt->keyOffsetMap = deviceKeyOffsetMapTemperature;
|
||||
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
|
||||
}
|
||||
|
||||
pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
|
||||
}
|
||||
void TearDown() override {
|
||||
SysmanDeviceFixture::TearDown();
|
||||
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
|
||||
}
|
||||
|
||||
std::vector<zes_temp_handle_t> get_temp_handles(uint32_t count) {
|
||||
std::vector<zes_temp_handle_t> handles(count, nullptr);
|
||||
EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
|
||||
return handles;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUAndGlobalTemperatureThenValidTemperatureReadingsRetrieved) {
|
||||
auto handles = get_temp_handles(handleComponentCountForNoSubDevices);
|
||||
for (auto &handle : handles) {
|
||||
zes_temp_properties_t properties = {};
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
|
||||
double temperature;
|
||||
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
|
||||
if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
|
||||
uint8_t maxTemp = 0;
|
||||
for (uint64_t i = 0; i < sizeof(tempArrForNoSubDevices) / sizeof(uint8_t); i++) {
|
||||
if ((tempArrForNoSubDevices[i] > invalidMaxTemperature) ||
|
||||
(tempArrForNoSubDevices[i] < invalidMinTemperature) || (maxTemp > tempArrForNoSubDevices[i])) {
|
||||
continue;
|
||||
}
|
||||
maxTemp = tempArrForNoSubDevices[i];
|
||||
}
|
||||
EXPECT_EQ(temperature, static_cast<double>(maxTemp));
|
||||
}
|
||||
if (properties.type == ZES_TEMP_SENSORS_GPU) {
|
||||
EXPECT_EQ(temperature, static_cast<double>(tempArrForNoSubDevices[computeIndexForNoSubDevices]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsWhenGettingTemperatureThenFailureReturned) {
|
||||
// delete previously allocated pPmt objects
|
||||
for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
|
||||
delete subDeviceIdToPmtEntry.second;
|
||||
}
|
||||
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
|
||||
// delete previously created temp handles
|
||||
for (auto &handle : pSysmanDeviceImp->pTempHandleContext->handleList) {
|
||||
delete handle;
|
||||
handle = nullptr;
|
||||
pSysmanDeviceImp->pTempHandleContext->handleList.pop_back();
|
||||
}
|
||||
for (auto &deviceHandle : deviceHandles) {
|
||||
ze_device_properties_t deviceProperties = {};
|
||||
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
|
||||
auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
|
||||
deviceProperties.subdeviceId);
|
||||
pPmt->mockedInitWithoutMappedMemory(pFsAccess.get());
|
||||
pPmt->keyOffsetMap = deviceKeyOffsetMapTemperature;
|
||||
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
|
||||
}
|
||||
|
||||
pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
|
||||
auto handles = get_temp_handles(handleComponentCountForNoSubDevices);
|
||||
for (auto &handle : handles) {
|
||||
double temperature;
|
||||
ASSERT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, zesTemperatureGetState(handle, &temperature));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) {
|
||||
ze_device_properties_t deviceProperties = {};
|
||||
Device::fromHandle(device->toHandle())->getProperties(&deviceProperties);
|
||||
auto pPublicLinuxTemperatureImp = std::make_unique<LinuxTemperatureImp>(pOsSysman, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
|
||||
deviceProperties.subdeviceId);
|
||||
pPublicLinuxTemperatureImp->setSensorType(ZES_TEMP_SENSORS_MEMORY_MIN);
|
||||
double temperature;
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPublicLinuxTemperatureImp->getSensorTemperature(&temperature));
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidateEnumerateRootTelemIndexWhengetRealPathFailsThenFailureReturned) {
|
||||
ON_CALL(*pFsAccess.get(), getRealPath(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<TemperatureFsAccess>::getRealPathFailure));
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE,
|
||||
PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess.get(), rootPciPathOfGpuDevice));
|
||||
|
||||
ON_CALL(*pFsAccess.get(), listDirectory(_, _))
|
||||
.WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<TemperatureFsAccess>::listDirectoryFailure));
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE,
|
||||
PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess.get(), rootPciPathOfGpuDevice));
|
||||
|
||||
std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
|
||||
PlatformMonitoringTech::create(deviceHandles, pFsAccess.get(), rootPciPathOfGpuDevice, mapOfSubDeviceIdToPmtObject);
|
||||
EXPECT_TRUE(mapOfSubDeviceIdToPmtObject.empty());
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidatePmtReadValueWhenkeyOffsetMapIsNotThereThenFailureReturned) {
|
||||
auto pPmt = std::make_unique<NiceMock<Mock<TemperaturePmt>>>(pFsAccess.get(), 0, 0);
|
||||
pPmt->mockedInit(pFsAccess.get());
|
||||
pPmt->keyOffsetMap = deviceKeyOffsetMapTemperature;
|
||||
uint8_t val = 0;
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("SOMETHING", val));
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenCreatePmtObjectsWhenRootTileIndexEnumeratesSuccessfulThenValidatePmtObjectsReceivedAndBranches) {
|
||||
std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject1;
|
||||
PlatformMonitoringTech::create(deviceHandles, pFsAccess.get(), rootPciPathOfGpuDevice, mapOfSubDeviceIdToPmtObject1);
|
||||
for (auto &subDeviceIdToPmtEntry : mapOfSubDeviceIdToPmtObject1) {
|
||||
EXPECT_NE(subDeviceIdToPmtEntry.second, nullptr);
|
||||
EXPECT_EQ(subDeviceIdToPmtEntry.first, 0u); // We know that subdeviceID is zero as core device didnt have any subdevices
|
||||
delete subDeviceIdToPmtEntry.second; // delete memory to avoid mem leak here, as we finished our test validation just above.
|
||||
}
|
||||
|
||||
std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject2;
|
||||
std::vector<ze_device_handle_t> testHandleVector;
|
||||
// If empty device handle vector is provided then empty map is retrieved
|
||||
PlatformMonitoringTech::create(testHandleVector, pFsAccess.get(), rootPciPathOfGpuDevice, mapOfSubDeviceIdToPmtObject2);
|
||||
EXPECT_TRUE(mapOfSubDeviceIdToPmtObject2.empty());
|
||||
}
|
||||
|
||||
} // namespace ult
|
||||
} // namespace L0
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
* Copyright (C) 2020-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -18,6 +18,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
|
||||
protected:
|
||||
Mock<TemperatureKmdSysManager> *pKmdSysManager = nullptr;
|
||||
KmdSysManager *pOriginalKmdSysManager = nullptr;
|
||||
std::vector<ze_device_handle_t> deviceHandles;
|
||||
void SetUp() override {
|
||||
SysmanDeviceFixture::SetUp();
|
||||
|
||||
@@ -34,7 +35,16 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
|
||||
}
|
||||
|
||||
pSysmanDeviceImp->pTempHandleContext->handleList.clear();
|
||||
pSysmanDeviceImp->pTempHandleContext->init();
|
||||
uint32_t subDeviceCount = 0;
|
||||
// We received a device handle. Check for subdevices in this device
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
|
||||
if (subDeviceCount == 0) {
|
||||
deviceHandles.resize(1, device->toHandle());
|
||||
} else {
|
||||
deviceHandles.resize(subDeviceCount, nullptr);
|
||||
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
|
||||
}
|
||||
pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
|
||||
}
|
||||
void TearDown() override {
|
||||
SysmanDeviceFixture::TearDown();
|
||||
@@ -121,8 +131,8 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGlobalTemp
|
||||
}
|
||||
|
||||
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) {
|
||||
auto pTemperatureImpMemory = std::make_unique<TemperatureImp>(pOsSysman, ZES_TEMP_SENSORS_GLOBAL_MIN);
|
||||
auto pWddmTemperatureImp = static_cast<WddmTemperatureImp *>(pTemperatureImpMemory->pOsTemperature);
|
||||
auto pTemperatureImpMemory = std::make_unique<TemperatureImp>(deviceHandles[0], pOsSysman, ZES_TEMP_SENSORS_GLOBAL_MIN);
|
||||
auto pWddmTemperatureImp = static_cast<WddmTemperatureImp *>(pTemperatureImpMemory->pOsTemperature.get());
|
||||
double pTemperature = 0;
|
||||
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pWddmTemperatureImp->getSensorTemperature(&pTemperature));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user