Debian Codegraph @

level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp

raw
1 /*
2 * Copyright (C) 2020-2024 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h"
9 #include "level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power.h"
10
11 namespace L0 {
12 namespace Sysman {
13 namespace ult {
14
15 constexpr uint32_t powerHandleComponentCount = 1u;
16
17 TEST_F(SysmanDevicePowerFixtureI915, GivenComponentCountZeroWhenEnumeratingPowerDomainsWhenhwmonInterfaceExistsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
18 uint32_t count = 0;
19 EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
20 EXPECT_EQ(count, powerHandleComponentCount);
21 }
22
23 TEST_F(SysmanDevicePowerFixtureI915, GivenInvalidComponentCountWhenEnumeratingPowerDomainsWhenhwmonInterfaceExistsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
24 uint32_t count = 0;
25 EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
26 EXPECT_EQ(count, powerHandleComponentCount);
27
28 count = count + 1;
29 EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
30 EXPECT_EQ(count, powerHandleComponentCount);
31 }
32
33 TEST_F(SysmanDevicePowerFixtureI915, GivenComponentCountZeroWhenEnumeratingPowerDomainsWhenhwmonInterfaceExistsThenValidPowerHandlesIsReturned) {
34 uint32_t count = 0;
35 EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
36 EXPECT_EQ(count, powerHandleComponentCount);
37
38 std::vector<zes_pwr_handle_t> handles(count, nullptr);
39 EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
40 for (auto handle : handles) {
41 EXPECT_NE(handle, nullptr);
42 }
43 }
44
45 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerPointerWhenGettingCardPowerDomainWhenhwmonInterfaceExistsAndThenCallSucceeds) {
46 zes_pwr_handle_t phPower = {};
47 EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_SUCCESS);
48 }
49
50 TEST_F(SysmanDevicePowerFixtureI915, GivenInvalidPowerPointerWhenGettingCardPowerDomainAndThenReturnsFailure) {
51 EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), nullptr), ZE_RESULT_ERROR_INVALID_NULL_POINTER);
52 }
53
54 TEST_F(SysmanDevicePowerFixtureI915, GivenUninitializedPowerHandlesAndWhenGettingCardPowerDomainThenReturnsFailure) {
55 for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
56 delete handle;
57 }
58 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
59
60 zes_pwr_handle_t phPower = {};
61 EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
62 }
63
64 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesWhenhwmonInterfaceExistsThenCallSucceeds) {
65 MockSysmanProductHelper *pMockSysmanProductHelper = new MockSysmanProductHelper();
66 pMockSysmanProductHelper->isPowerSetLimitSupportedResult = true;
67 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper(static_cast<SysmanProductHelper *>(pMockSysmanProductHelper));
68 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
69
70 for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
71 delete handle;
72 }
73 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
74 pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
75 auto handles = getPowerHandles(powerHandleComponentCount);
76
77 for (auto handle : handles) {
78 ASSERT_NE(nullptr, handle);
79 zes_power_properties_t properties = {};
80 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
81 EXPECT_FALSE(properties.onSubdevice);
82 EXPECT_EQ(properties.subdeviceId, 0u);
83 EXPECT_EQ(properties.canControl, true);
84 EXPECT_EQ(properties.isEnergyThresholdSupported, false);
85 EXPECT_EQ(properties.defaultLimit, static_cast<int32_t>(mockDefaultPowerLimitVal / milliFactor));
86 EXPECT_EQ(properties.maxLimit, static_cast<int32_t>(mockDefaultPowerLimitVal / milliFactor));
87 EXPECT_EQ(properties.minLimit, -1);
88 }
89 }
90
91 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
92 MockSysmanProductHelper *pMockSysmanProductHelper = new MockSysmanProductHelper();
93 pMockSysmanProductHelper->isPowerSetLimitSupportedResult = true;
94 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper(static_cast<SysmanProductHelper *>(pMockSysmanProductHelper));
95 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
96
97 for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
98 delete handle;
99 }
100 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
101 pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
102 auto handles = getPowerHandles(powerHandleComponentCount);
103
104 for (auto handle : handles) {
105 ASSERT_NE(nullptr, handle);
106 zes_power_properties_t properties = {};
107 zes_power_ext_properties_t extProperties = {};
108 zes_power_limit_ext_desc_t defaultLimit = {};
109
110 extProperties.defaultLimit = &defaultLimit;
111 extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
112 properties.pNext = &extProperties;
113 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
114 EXPECT_FALSE(properties.onSubdevice);
115 EXPECT_EQ(properties.subdeviceId, 0u);
116 EXPECT_EQ(properties.canControl, true);
117 EXPECT_EQ(properties.isEnergyThresholdSupported, false);
118 EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
119 EXPECT_EQ(properties.maxLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
120 EXPECT_EQ(properties.minLimit, -1);
121 EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
122 EXPECT_TRUE(defaultLimit.limitValueLocked);
123 EXPECT_TRUE(defaultLimit.enabledStateLocked);
124 EXPECT_TRUE(defaultLimit.intervalValueLocked);
125 EXPECT_EQ(ZES_POWER_SOURCE_ANY, defaultLimit.source);
126 EXPECT_EQ(ZES_LIMIT_UNIT_POWER, defaultLimit.limitUnit);
127 EXPECT_EQ(defaultLimit.limit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
128 }
129 }
130
131 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWithNoStypeForExtPropertiesWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
132 MockSysmanProductHelper *pMockSysmanProductHelper = new MockSysmanProductHelper();
133 pMockSysmanProductHelper->isPowerSetLimitSupportedResult = true;
134 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper(static_cast<SysmanProductHelper *>(pMockSysmanProductHelper));
135 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
136
137 for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
138 delete handle;
139 }
140 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
141 pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
142 auto handles = getPowerHandles(powerHandleComponentCount);
143
144 for (auto handle : handles) {
145 ASSERT_NE(nullptr, handle);
146 zes_power_properties_t properties = {};
147 zes_power_ext_properties_t extProperties = {};
148 zes_power_limit_ext_desc_t defaultLimit = {};
149
150 extProperties.defaultLimit = &defaultLimit;
151 properties.pNext = &extProperties;
152 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
153 EXPECT_FALSE(properties.onSubdevice);
154 EXPECT_EQ(properties.subdeviceId, 0u);
155 EXPECT_EQ(properties.canControl, true);
156 EXPECT_EQ(properties.isEnergyThresholdSupported, false);
157 EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
158 EXPECT_EQ(properties.maxLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
159 EXPECT_EQ(properties.minLimit, -1);
160 }
161 }
162
163 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndPowerSetLimitSupportedIsUnsupportedWhenCallingzesPowerGetPropertiesThenVerifyCanControlIsSetToFalse) {
164 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
165 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
166
167 for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
168 delete handle;
169 }
170 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
171 pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
172 auto handles = getPowerHandles(powerHandleComponentCount);
173
174 for (auto handle : handles) {
175 ASSERT_NE(nullptr, handle);
176 zes_power_properties_t properties{};
177 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
178 EXPECT_FALSE(properties.canControl);
179 }
180 }
181
182 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsReadFailsThenFailureIsReturned) {
183 std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0, ZES_POWER_DOMAIN_CARD));
184 EXPECT_TRUE(pLinuxPowerImp->isPowerModuleSupported());
185 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
186 zes_power_properties_t properties{};
187 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
188 EXPECT_EQ(properties.defaultLimit, -1);
189 }
190
191 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndHandleCountZeroWhenCallingReInitThenValidCountIsReturnedAndVerifyzesDeviceEnumPowerHandleSucceeds) {
192 VariableBackup<L0::Sysman::SysFsAccessInterface *> sysfsBackup(&pLinuxSysmanImp->pSysfsAccess);
193 pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
194
195 uint32_t count = 0;
196 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPowerDomains(device->toHandle(), &count, NULL));
197 EXPECT_EQ(count, powerHandleComponentCount);
198
199 for (auto handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
200 delete handle;
201 }
202 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
203
204 pLinuxSysmanImp->reInitSysmanDeviceResources();
205
206 count = 0;
207 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPowerDomains(device->toHandle(), &count, NULL));
208 EXPECT_EQ(count, powerHandleComponentCount);
209 }
210
211 HWTEST2_F(SysmanDevicePowerFixtureI915, GivenSetPowerLimitsWhenGettingPowerLimitsWhenHwmonInterfaceExistThenLimitsSetEarlierAreRetrieved, IsXeHpOrXeHpcOrXeHpgCore) {
212 auto handles = getPowerHandles(powerHandleComponentCount);
213 for (auto handle : handles) {
214 ASSERT_NE(nullptr, handle);
215 zes_power_sustained_limit_t sustainedSet = {};
216 zes_power_sustained_limit_t sustainedGet = {};
217 sustainedSet.enabled = 1;
218 sustainedSet.interval = 10;
219 sustainedSet.power = 300000;
220 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
221 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
222 EXPECT_EQ(sustainedGet.power, sustainedSet.power);
223
224 zes_power_burst_limit_t burstGet = {};
225 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, nullptr));
226 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
227 EXPECT_EQ(burstGet.enabled, false);
228 EXPECT_EQ(burstGet.power, -1);
229
230 zes_power_peak_limit_t peakSet = {};
231 zes_power_peak_limit_t peakGet = {};
232 peakSet.powerAC = 300000;
233 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet));
234 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
235 EXPECT_EQ(peakGet.powerAC, peakSet.powerAC);
236 EXPECT_EQ(peakGet.powerDC, -1);
237 }
238 }
239
240 TEST_F(SysmanDevicePowerFixtureI915, GivenDefaultLimitSysfsNodesNotAvailableWhenGettingPowerPropertiesThenApiCallReturnsFailure) {
241 auto handles = getPowerHandles(powerHandleComponentCount);
242 for (auto handle : handles) {
243 ASSERT_NE(nullptr, handle);
244 zes_power_properties_t properties = {};
245 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
246 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetProperties(handle, &properties));
247 }
248 }
249
250 TEST_F(SysmanDevicePowerFixtureI915, GivenDefaultLimitSysfsNodesNotAvailableWhenGettingPowerPropertiesExtThenApiCallReturnsFailure) {
251 auto handles = getPowerHandles(powerHandleComponentCount);
252 for (auto handle : handles) {
253 ASSERT_NE(nullptr, handle);
254 zes_power_properties_t properties = {};
255 zes_power_ext_properties_t extProperties = {};
256 zes_power_limit_ext_desc_t defaultLimit = {};
257
258 extProperties.defaultLimit = &defaultLimit;
259 extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
260 properties.pNext = &extProperties;
261
262 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
263 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
264 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetProperties(handle, &properties));
265 }
266 }
267
268 HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) {
269 auto handles = getPowerHandles(powerHandleComponentCount);
270 for (auto handle : handles) {
271 ASSERT_NE(nullptr, handle);
272
273 uint32_t limitCount = 0;
274 const int32_t testLimit = 300000;
275 const int32_t testInterval = 10;
276
277 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
278 EXPECT_EQ(limitCount, mockLimitCount);
279
280 limitCount++;
281 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
282 EXPECT_EQ(limitCount, mockLimitCount);
283
284 std::vector<zes_power_limit_ext_desc_t> allLimits(limitCount);
285 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
286 for (uint32_t i = 0; i < limitCount; i++) {
287 if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
288 EXPECT_FALSE(allLimits[i].limitValueLocked);
289 EXPECT_TRUE(allLimits[i].enabledStateLocked);
290 EXPECT_FALSE(allLimits[i].intervalValueLocked);
291 EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
292 EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
293 allLimits[i].limit = testLimit;
294 allLimits[i].interval = testInterval;
295 } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
296 EXPECT_FALSE(allLimits[i].limitValueLocked);
297 EXPECT_TRUE(allLimits[i].enabledStateLocked);
298 EXPECT_TRUE(allLimits[i].intervalValueLocked);
299 EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
300 EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit);
301 allLimits[i].limit = testLimit;
302 }
303 }
304 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
305 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
306 for (uint32_t i = 0; i < limitCount; i++) {
307 if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
308 EXPECT_EQ(testInterval, allLimits[i].interval);
309 } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
310 EXPECT_EQ(0, allLimits[i].interval);
311 }
312 EXPECT_EQ(testLimit, allLimits[i].limit);
313 }
314 }
315 }
316
317 HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) {
318 auto handles = getPowerHandles(powerHandleComponentCount);
319 for (auto handle : handles) {
320 ASSERT_NE(nullptr, handle);
321
322 uint32_t limitCount = 0;
323 const int32_t testLimit = 300000;
324 const int32_t testInterval = 10;
325
326 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
327 EXPECT_EQ(limitCount, mockLimitCount);
328
329 limitCount++;
330 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
331 EXPECT_EQ(limitCount, mockLimitCount);
332
333 std::vector<zes_power_limit_ext_desc_t> allLimits(limitCount);
334 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
335 for (uint32_t i = 0; i < limitCount; i++) {
336 if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
337 EXPECT_FALSE(allLimits[i].limitValueLocked);
338 EXPECT_TRUE(allLimits[i].enabledStateLocked);
339 EXPECT_FALSE(allLimits[i].intervalValueLocked);
340 EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
341 EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
342 allLimits[i].limit = testLimit;
343 allLimits[i].interval = testInterval;
344 } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
345 EXPECT_FALSE(allLimits[i].limitValueLocked);
346 EXPECT_TRUE(allLimits[i].enabledStateLocked);
347 EXPECT_TRUE(allLimits[i].intervalValueLocked);
348 EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
349 EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
350 allLimits[i].limit = testLimit;
351 }
352 }
353 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
354 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
355 for (uint32_t i = 0; i < limitCount; i++) {
356 if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
357 EXPECT_EQ(testInterval, allLimits[i].interval);
358 } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
359 EXPECT_EQ(0, allLimits[i].interval);
360 }
361 EXPECT_EQ(testLimit, allLimits[i].limit);
362 }
363 }
364 }
365
366 TEST_F(SysmanDevicePowerFixtureI915, GivenReadingSustainedPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForSustainedPowerLimitEnabledThenProperErrorCodesReturned) {
367 auto handles = getPowerHandles(powerHandleComponentCount);
368
369 pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
370 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
371
372 for (auto handle : handles) {
373 ASSERT_NE(nullptr, handle);
374 zes_power_sustained_limit_t sustainedSet = {};
375 zes_power_sustained_limit_t sustainedGet = {};
376
377 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
378 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
379 }
380 }
381
382 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToSustainedLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
383 auto handles = getPowerHandles(powerHandleComponentCount);
384
385 for (auto handle : handles) {
386 ASSERT_NE(nullptr, handle);
387 uint32_t count = mockLimitCount;
388 std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
389 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
390
391 pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
392 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
393 }
394 }
395
396 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToSustainedLimitIntervalSysNodeFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
397 auto handles = getPowerHandles(powerHandleComponentCount);
398 pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
399 for (auto handle : handles) {
400 ASSERT_NE(nullptr, handle);
401 uint32_t count = mockLimitCount;
402 std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
403 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
404 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
405 }
406 }
407
408 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndReadingToSustainedLimitSysNodesFailsWhenCallingGetPowerLimitsExtThenProperErrorCodesReturned) {
409 auto handles = getPowerHandles(powerHandleComponentCount);
410
411 for (auto handle : handles) {
412 ASSERT_NE(nullptr, handle);
413 uint32_t count = mockLimitCount;
414 std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
415 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
416 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
417 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
418 count = mockLimitCount;
419 pSysfsAccess->mockReadIntResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
420 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
421 }
422 }
423
424 TEST_F(SysmanDevicePowerFixtureI915, GivenReadingToSysNodesFailsWhenCallingGetPowerLimitsExtThenPowerLimitCountIsZero) {
425 for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
426 delete handle;
427 }
428 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
429 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
430 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
431 pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
432
433 auto handles = getPowerHandles(powerHandleComponentCount);
434 for (auto handle : handles) {
435 ASSERT_NE(nullptr, handle);
436 uint32_t count = 0;
437 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
438 EXPECT_EQ(count, 0u);
439 }
440 }
441
442 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
443 auto handles = getPowerHandles(powerHandleComponentCount);
444
445 pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
446
447 for (auto handle : handles) {
448 ASSERT_NE(nullptr, handle);
449 uint32_t count = mockLimitCount;
450 std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
451 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
452
453 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
454 }
455 }
456
457 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndReadingToPeakLimitSysNodesFailsWhenCallingGetPowerLimitsExtThenProperErrorCodesReturned) {
458 auto handles = getPowerHandles(powerHandleComponentCount);
459
460 pSysfsAccess->mockReadPeakResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
461
462 for (auto handle : handles) {
463 ASSERT_NE(nullptr, handle);
464 uint32_t count = mockLimitCount;
465 std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
466 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
467 }
468 }
469
470 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenSettingBurstPowerLimitThenProperErrorCodesReturned) {
471 auto handles = getPowerHandles(powerHandleComponentCount);
472
473 for (auto handle : handles) {
474 ASSERT_NE(nullptr, handle);
475 zes_power_limit_ext_desc_t allLimits{};
476 uint32_t count = 1;
477 allLimits.level = ZES_POWER_LEVEL_BURST;
478
479 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, &allLimits));
480 }
481 }
482
483 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenCallingGetPowerLimitsExtThenProperValuesAreReturned) {
484 auto handles = getPowerHandles(powerHandleComponentCount);
485
486 for (auto handle : handles) {
487 ASSERT_NE(nullptr, handle);
488 zes_power_limit_ext_desc_t allLimits{};
489 uint32_t count = 0;
490
491 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
492 EXPECT_EQ(count, mockLimitCount);
493
494 count = 1;
495 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, &allLimits));
496 EXPECT_EQ(count, 1u);
497 EXPECT_EQ(false, allLimits.limitValueLocked);
498 EXPECT_EQ(true, allLimits.enabledStateLocked);
499 EXPECT_EQ(false, allLimits.intervalValueLocked);
500 EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits.source);
501 EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits.limitUnit);
502 EXPECT_EQ(ZES_POWER_LEVEL_SUSTAINED, allLimits.level);
503 }
504 }
505
506 HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsPVC) {
507 auto handles = getPowerHandles(powerHandleComponentCount);
508
509 pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
510
511 for (auto handle : handles) {
512 ASSERT_NE(nullptr, handle);
513 uint32_t count = mockLimitCount;
514 std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
515 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
516
517 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
518 }
519 }
520
521 HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsDG1) {
522 auto handles = getPowerHandles(powerHandleComponentCount);
523
524 pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
525
526 for (auto handle : handles) {
527 ASSERT_NE(nullptr, handle);
528 uint32_t count = mockLimitCount;
529 std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
530 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
531
532 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
533 }
534 }
535
536 TEST_F(SysmanDevicePowerFixtureI915, GivenReadingPeakPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForPeakPowerLimitEnabledThenProperErrorCodesReturned) {
537 auto handles = getPowerHandles(powerHandleComponentCount);
538
539 pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
540 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
541
542 for (auto handle : handles) {
543 ASSERT_NE(nullptr, handle);
544 zes_power_peak_limit_t peakSet = {};
545 zes_power_peak_limit_t peakGet = {};
546
547 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet));
548 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
549 }
550 }
551
552 TEST_F(SysmanDevicePowerFixtureI915, GivenReadingSustainedPowerNodeReturnErrorWhenGetPowerLimitsForSustainedPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
553 auto handles = getPowerHandles(powerHandleComponentCount);
554
555 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
556 for (auto handle : handles) {
557 ASSERT_NE(nullptr, handle);
558 zes_power_sustained_limit_t sustainedGet = {};
559 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
560 }
561 }
562
563 TEST_F(SysmanDevicePowerFixtureI915, GivenReadingpeakPowerNodeReturnErrorWhenGetPowerLimitsForpeakPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
564 auto handles = getPowerHandles(powerHandleComponentCount);
565 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
566
567 for (auto handle : handles) {
568 ASSERT_NE(nullptr, handle);
569 zes_power_peak_limit_t peakGet = {};
570 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
571 }
572 }
573
574 HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndPermissionsThenFirstDisableSustainedPowerLimitAndThenEnableItAndCheckSuccesIsReturned, IsXeHpOrXeHpcOrXeHpgCore) {
575 auto handles = getPowerHandles(powerHandleComponentCount);
576 ASSERT_NE(nullptr, handles[0]);
577 zes_power_sustained_limit_t sustainedSet = {};
578 zes_power_sustained_limit_t sustainedGet = {};
579 sustainedSet.enabled = 0;
580 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
581 sustainedSet.power = 300000;
582 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
583 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handles[0], &sustainedGet, nullptr, nullptr));
584 EXPECT_EQ(sustainedGet.power, sustainedSet.power);
585 }
586
587 TEST_F(SysmanDevicePowerFixtureI915, GivenwritingSustainedPowerNodeReturnErrorWhenSetPowerLimitsForSustainedPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
588 auto handles = getPowerHandles(powerHandleComponentCount);
589 ASSERT_NE(nullptr, handles[0]);
590
591 pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
592 zes_power_sustained_limit_t sustainedSet = {};
593 sustainedSet.enabled = 1;
594 sustainedSet.interval = 10;
595 sustainedSet.power = 300000;
596 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
597 }
598
599 TEST_F(SysmanDevicePowerFixtureI915, GivenwritingSustainedPowerIntervalNodeReturnErrorWhenSetPowerLimitsForSustainedPowerIntervalWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
600 auto handles = getPowerHandles(powerHandleComponentCount);
601 ASSERT_NE(nullptr, handles[0]);
602
603 pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
604 zes_power_sustained_limit_t sustainedSet = {};
605 sustainedSet.enabled = 1;
606 sustainedSet.interval = 10;
607 sustainedSet.power = 300000;
608 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
609 }
610
611 HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenWritingToSustainedPowerEnableNodeWithoutPermissionsThenValidErrorIsReturned, IsXeHpOrXeHpcOrXeHpgCore) {
612 auto handles = getPowerHandles(powerHandleComponentCount);
613 ASSERT_NE(nullptr, handles[0]);
614
615 pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS);
616 zes_power_sustained_limit_t sustainedSet = {};
617 sustainedSet.enabled = 0;
618 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
619 }
620
621 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) {
622
623 for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
624 delete handle;
625 }
626 pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
627 pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
628 auto handles = getPowerHandles(powerHandleComponentCount);
629
630 for (auto handle : handles) {
631 ASSERT_NE(nullptr, handle);
632 zes_power_properties_t properties = {};
633 EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
634 EXPECT_FALSE(properties.onSubdevice);
635 EXPECT_EQ(properties.subdeviceId, 0u);
636 }
637 }
638
639 TEST_F(SysmanDevicePowerFixtureI915, GivenHwMonDoesNotExistAndTelemDataNotAvailableWhenGettingPowerEnergyCounterThenFailureIsReturned) {
640 auto handles = getPowerHandles(powerHandleComponentCount);
641 for (auto handle : handles) {
642 pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
643 ASSERT_NE(nullptr, handle);
644 zes_power_energy_counter_t energyCounter = {};
645 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zesPowerGetEnergyCounter(handle, &energyCounter));
646 }
647 }
648
649 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
650
651 zes_energy_threshold_t threshold;
652 auto handles = getPowerHandles(powerHandleComponentCount);
653 for (auto handle : handles) {
654 ASSERT_NE(nullptr, handle);
655 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetEnergyThreshold(handle, &threshold));
656 }
657 }
658
659 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenSettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
660
661 double threshold = 0;
662 auto handles = getPowerHandles(powerHandleComponentCount);
663 for (auto handle : handles) {
664 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetEnergyThreshold(handle, threshold));
665 }
666 }
667
668 TEST_F(SysmanDevicePowerFixtureXe, GivenKmdInterfaceWhenGettingSysFsFilenamesForPowerForXeVersionThenProperPathsAreReturned) {
669 auto pSysmanKmdInterface = std::make_unique<SysmanKmdInterfaceXe>(pLinuxSysmanImp->getSysmanProductHelper());
670 EXPECT_STREQ("energy1_input", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEnergyCounterNode, 0, false).c_str());
671 EXPECT_STREQ("power1_rated_max", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameDefaultPowerLimit, 0, false).c_str());
672 EXPECT_STREQ("power1_max", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameSustainedPowerLimit, 0, false).c_str());
673 EXPECT_STREQ("power1_max_interval", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameSustainedPowerLimitInterval, 0, false).c_str());
674 }
675
676 } // namespace ult
677 } // namespace Sysman
678 } // namespace L0