Debian Codegraph @

level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency.cpp

raw
1 /*
2 * Copyright (C) 2020-2024 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
9 #include "level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysman_frequency.h"
10 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
11 #include "level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h"
12
13 #include <cmath>
14
15 namespace L0 {
16 namespace Sysman {
17 namespace ult {
18
19 constexpr double minFreq = 300.0;
20 constexpr double maxFreq = 1100.0;
21 constexpr double request = 300.0;
22 constexpr double tdp = 1100.0;
23 constexpr double actual = 300.0;
24 constexpr double efficient = 300.0;
25 constexpr double maxVal = 1100.0;
26 constexpr double minVal = 300.0;
27 constexpr uint32_t handleComponentCount = 1u;
28 constexpr uint32_t multiHandleComponentCount = 2u;
29 class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
30
31 protected:
32 L0::Sysman::SysmanDevice *device = nullptr;
33 std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
34 L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
35 uint32_t numClocks = 0;
36 double step = 0;
37
38 void SetUp() override {
39 SysmanDeviceFixture::SetUp();
40 device = pSysmanDevice;
41 pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
42 pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
43 pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
44 auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
45 rootDeviceEnvironment.getMutableHardwareInfo()->capabilityTable.supportsImages = false;
46 pSysfsAccess->setVal(minFreqFile, minFreq);
47 pSysfsAccess->setVal(maxFreqFile, maxFreq);
48 pSysfsAccess->setVal(requestFreqFile, request);
49 pSysfsAccess->setVal(tdpFreqFile, tdp);
50 pSysfsAccess->setVal(actualFreqFile, actual);
51 pSysfsAccess->setVal(efficientFreqFile, efficient);
52 pSysfsAccess->setVal(maxValFreqFile, maxVal);
53 pSysfsAccess->setVal(minValFreqFile, minVal);
54 step = 50;
55 numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
56
57 // delete handles created in initial SysmanDeviceHandleContext::init() call
58 for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
59 delete handle;
60 }
61 pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
62 }
63
64 void TearDown() override {
65 pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
66 SysmanDeviceFixture::TearDown();
67 }
68
69 double clockValue(const double calculatedClock) {
70 // i915 specific. frequency step is a fraction
71 // However, the i915 represents all clock
72 // rates as integer values. So clocks are
73 // rounded to the nearest integer.
74 uint32_t actualClock = static_cast<uint32_t>(calculatedClock + 0.5);
75 return static_cast<double>(actualClock);
76 }
77
78 std::vector<zes_freq_handle_t> getFreqHandles(uint32_t count) {
79 std::vector<zes_freq_handle_t> handles(count, nullptr);
80 EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
81 return handles;
82 }
83 };
84
85 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesThenNonZeroCountIsReturnedAndCallSucceds) {
86 uint32_t count = 0U;
87
88 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
89 EXPECT_EQ(count, handleComponentCount);
90
91 uint32_t testCount = count + 1;
92 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
93 EXPECT_EQ(count, testCount);
94
95 auto handles = getFreqHandles(count);
96 for (auto handle : handles) {
97 EXPECT_NE(handle, nullptr);
98 }
99 }
100
101 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroAndValidPtrWhenEnumeratingFrequencyHandlesThenNonZeroCountAndNoHandlesAreReturnedAndCallSucceds) {
102 uint32_t count = 0U;
103 zes_freq_handle_t handle = static_cast<zes_freq_handle_t>(0UL);
104
105 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, &handle));
106 EXPECT_EQ(count, handleComponentCount);
107 EXPECT_EQ(handle, static_cast<zes_freq_handle_t>(0UL));
108 }
109
110 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaFreqDomainIsPresentThenNonZeroCountIsReturnedAndCallSucceds) {
111 pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef().getMutableHardwareInfo()->capabilityTable.supportsImages = true;
112 uint32_t count = 0U;
113
114 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
115 EXPECT_EQ(count, 2U);
116
117 uint32_t testCount = count + 1;
118 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
119 EXPECT_EQ(count, testCount);
120
121 auto handles = getFreqHandles(count);
122 for (auto handle : handles) {
123 EXPECT_NE(handle, nullptr);
124 }
125 }
126
127 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaDomainIsAbsentThenNonZeroCountIsReturnedAndCallSucceds) {
128 pSysfsAccess->directoryExistsResult = false;
129 pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef().getMutableHardwareInfo()->capabilityTable.supportsImages = true;
130 uint32_t count = 0U;
131
132 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
133 EXPECT_EQ(count, 1U);
134
135 uint32_t testCount = count + 1;
136 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
137 EXPECT_EQ(count, testCount);
138
139 auto handles = getFreqHandles(count);
140 for (auto handle : handles) {
141 EXPECT_NE(handle, nullptr);
142 }
143 }
144
145 TEST_F(SysmanDeviceFrequencyFixture, GivenActualComponentCountTwoWhenTryingToGetOneComponentOnlyThenOneComponentIsReturnedAndCountUpdated) {
146 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
147 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
148 uint32_t subdeviceId = 0;
149 auto pFrequencyHandleContextTest = std::make_unique<L0::Sysman::FrequencyHandleContext>(pOsSysman);
150 pFrequencyHandleContextTest->handleList.push_back(new L0::Sysman::FrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU));
151 pFrequencyHandleContextTest->handleList.push_back(new L0::Sysman::FrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU));
152
153 uint32_t count = 1;
154 std::vector<zes_freq_handle_t> phFrequency(count, nullptr);
155 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyHandleContextTest->frequencyGet(&count, phFrequency.data()));
156 EXPECT_EQ(count, 1u);
157 }
158
159 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
160 MockSysmanProductHelper *pMockSysmanProductHelper = new MockSysmanProductHelper();
161 pMockSysmanProductHelper->isFrequencySetRangeSupportedResult = true;
162 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper(static_cast<SysmanProductHelper *>(pMockSysmanProductHelper));
163 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
164
165 auto handles = getFreqHandles(handleComponentCount);
166 for (auto handle : handles) {
167 EXPECT_NE(handle, nullptr);
168 zes_freq_properties_t properties;
169 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
170 EXPECT_EQ(nullptr, properties.pNext);
171 EXPECT_GE(properties.type, ZES_FREQ_DOMAIN_GPU);
172 EXPECT_LE(properties.type, ZES_FREQ_DOMAIN_MEDIA);
173 EXPECT_FALSE(properties.onSubdevice);
174 EXPECT_DOUBLE_EQ(maxFreq, properties.max);
175 EXPECT_DOUBLE_EQ(minFreq, properties.min);
176 EXPECT_TRUE(properties.canControl);
177 }
178 }
179
180 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndFrequenceSetRangeIsUnsupportedWhenCallingzesFrequencyGetPropertiesThenVerifyCanControlIsSetToFalse) {
181 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
182 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
183
184 auto handles = getFreqHandles(handleComponentCount);
185 for (auto handle : handles) {
186 ASSERT_NE(nullptr, handle);
187 zes_freq_properties_t properties{};
188 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
189 EXPECT_FALSE(properties.canControl);
190 }
191 }
192
193 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds, IsPVC) {
194 auto handles = getFreqHandles(handleComponentCount);
195 for (auto handle : handles) {
196 EXPECT_NE(handle, nullptr);
197 uint32_t count = 0;
198 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
199 EXPECT_EQ(numClocks, count);
200 }
201 }
202
203 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsMoreThanNumClocksThenCallSucceeds, IsPVC) {
204 auto handles = getFreqHandles(handleComponentCount);
205 for (auto handle : handles) {
206 EXPECT_NE(handle, nullptr);
207 uint32_t count = 80;
208 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
209 EXPECT_EQ(numClocks, count);
210 }
211 }
212
213 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsLessThanNumClocksThenCallSucceeds, IsPVC) {
214 auto handles = getFreqHandles(handleComponentCount);
215 for (auto handle : handles) {
216 EXPECT_NE(handle, nullptr);
217 uint32_t count = 20;
218 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
219 }
220 }
221
222 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds, IsPVC) {
223 auto handles = getFreqHandles(handleComponentCount);
224 for (auto handle : handles) {
225 uint32_t count = 0;
226
227 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
228 EXPECT_EQ(numClocks, count);
229
230 double *clocks = new double[count];
231 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, clocks));
232 EXPECT_EQ(numClocks, count);
233 for (uint32_t i = 0; i < count; i++) {
234 EXPECT_DOUBLE_EQ(clockValue(minFreq + (step * i)), clocks[i]);
235 }
236 delete[] clocks;
237 }
238 }
239
240 TEST_F(SysmanDeviceFrequencyFixture, GivenValidateFrequencyGetRangeWhengetMaxAndgetMinFailsThenFrequencyGetRangeCallReturnsNegativeValuesForRange) {
241 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
242 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
243 uint32_t subdeviceId = 0;
244 auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
245 zes_freq_range_t limit = {};
246 pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
247 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetRange(&limit));
248 EXPECT_EQ(-1, limit.max);
249 EXPECT_EQ(-1, limit.min);
250
251 pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_UNKNOWN;
252 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetRange(&limit));
253 EXPECT_EQ(-1, limit.max);
254 EXPECT_EQ(-1, limit.min);
255 }
256
257 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetRangeThenVerifyzesFrequencyGetRangeTestCallSucceeds) {
258 auto handles = getFreqHandles(handleComponentCount);
259 for (auto handle : handles) {
260 zes_freq_range_t limits;
261 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
262 EXPECT_DOUBLE_EQ(minFreq, limits.min);
263 EXPECT_DOUBLE_EQ(maxFreq, limits.max);
264 }
265 }
266
267 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully, IsXeHpOrXeHpcOrXeHpgCore) {
268 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
269 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
270 uint32_t subdeviceId = 0;
271 auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
272 zes_freq_range_t limits = {};
273
274 // Verify that Max must be within range.
275 limits.min = minFreq;
276 limits.max = 600.0;
277 pSysfsAccess->mockWriteMinResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
278 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
279
280 pSysfsAccess->mockWriteMinResult = ZE_RESULT_ERROR_UNKNOWN;
281 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
282 }
283
284 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully, IsXeHpOrXeHpcOrXeHpgCore) {
285 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
286 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
287 uint32_t subdeviceId = 0;
288 auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
289 zes_freq_range_t limits = {};
290
291 // Verify that Max must be within range.
292 limits.min = 900.0;
293 limits.max = maxFreq;
294 pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
295 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
296
297 pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_UNKNOWN;
298 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
299 }
300
301 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
302 auto handles = getFreqHandles(handleComponentCount);
303 for (auto handle : handles) {
304 const double startingMin = 900.0;
305 const double newMax = 600.0;
306 zes_freq_range_t limits;
307
308 pSysfsAccess->setVal(minFreqFile, startingMin);
309 // If the new Max value is less than the old Min
310 // value, the new Min must be set before the new Max
311 limits.min = minFreq;
312 limits.max = newMax;
313 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
314 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
315 EXPECT_DOUBLE_EQ(minFreq, limits.min);
316 EXPECT_DOUBLE_EQ(newMax, limits.max);
317 EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
318 }
319 }
320
321 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenNegativeUnityRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath, IsXeHpOrXeHpcOrXeHpgCore) {
322 auto handles = getFreqHandles(handleComponentCount);
323 for (auto handle : handles) {
324 const double negativeMin = -1;
325 const double negativeMax = -1;
326 zes_freq_range_t limits;
327
328 limits.min = negativeMin;
329 limits.max = negativeMax;
330 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
331 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
332 EXPECT_EQ(1, limits.min);
333 EXPECT_EQ(1000, limits.max);
334 EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
335 }
336 }
337
338 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
339 auto handles = getFreqHandles(handleComponentCount);
340 for (auto handle : handles) {
341 const double startingMax = 600.0;
342 const double newMin = 900.0;
343 zes_freq_range_t limits;
344
345 pSysfsAccess->setVal(maxFreqFile, startingMax);
346 // If the new Min value is greater than the old Max
347 // value, the new Max must be set before the new Min
348 limits.min = newMin;
349 limits.max = maxFreq;
350 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
351 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
352 EXPECT_DOUBLE_EQ(newMin, limits.min);
353 EXPECT_DOUBLE_EQ(maxFreq, limits.max);
354 EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
355 }
356 }
357
358 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTestReturnsError, IsXeHpOrXeHpcOrXeHpgCore) {
359 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
360 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
361 uint32_t subdeviceId = 0;
362 auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
363 zes_freq_range_t limits;
364
365 // Verify that Max must be greater than min range.
366 limits.min = clockValue(maxFreq + step);
367 limits.max = minFreq;
368 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits));
369 }
370
371 TEST_F(SysmanDeviceFrequencyFixture, GivenFrequencySetRangeNotSupportedWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeFails) {
372 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
373 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
374
375 auto handles = getFreqHandles(handleComponentCount);
376 for (auto handle : handles) {
377 const double startingMin = 900.0;
378 const double newMax = 600.0;
379 zes_freq_range_t limits;
380
381 pSysfsAccess->setVal(minFreqFile, startingMin);
382 // If the new Max value is less than the old Min
383 // value, the new Min must be set before the new Max
384 limits.min = minFreq;
385 limits.max = newMax;
386 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
387 }
388 }
389
390 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) {
391 auto handles = getFreqHandles(handleComponentCount);
392 for (auto handle : handles) {
393 const double testRequestValue = 450.0;
394 const double testTdpValue = 1200.0;
395 const double testEfficientValue = 400.0;
396 const double testActualValue = 550.0;
397 const uint32_t invalidReason = 0;
398 zes_freq_state_t state;
399 pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
400 pSysfsAccess->setVal(requestFreqFile, testRequestValue);
401 pSysfsAccess->setVal(tdpFreqFile, testTdpValue);
402 pSysfsAccess->setVal(actualFreqFile, testActualValue);
403 pSysfsAccess->setVal(efficientFreqFile, testEfficientValue);
404 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
405 EXPECT_DOUBLE_EQ(testRequestValue, state.request);
406 EXPECT_DOUBLE_EQ(testTdpValue, state.tdp);
407 EXPECT_DOUBLE_EQ(testEfficientValue, state.efficient);
408 EXPECT_DOUBLE_EQ(testActualValue, state.actual);
409 EXPECT_EQ(0u, state.throttleReasons);
410 EXPECT_EQ(nullptr, state.pNext);
411 EXPECT_LE(state.currentVoltage, 0);
412 }
413 }
414
415 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateWithLegacyPathThenVerifyzesFrequencyGetStateTestCallSucceeds) {
416 pSysfsAccess->isLegacy = true;
417 pSysfsAccess->directoryExistsResult = false;
418 for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
419 delete handle;
420 }
421 pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
422 pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
423
424 auto handles = getFreqHandles(handleComponentCount);
425 for (auto handle : handles) {
426 const double testRequestValue = 400.0;
427 const double testTdpValue = 1100.0;
428 const double testEfficientValue = 300.0;
429 const double testActualValue = 550.0;
430 uint32_t validReason = 1;
431 uint32_t setAllThrottleReasons = (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
432 ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
433 ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
434 ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
435
436 pSysfsAccess->setValLegacy(requestFreqFileLegacy, testRequestValue);
437 pSysfsAccess->setValLegacy(tdpFreqFileLegacy, testTdpValue);
438 pSysfsAccess->setValLegacy(actualFreqFileLegacy, testActualValue);
439 pSysfsAccess->setValLegacy(efficientFreqFileLegacy, testEfficientValue);
440 pSysfsAccess->setValU32Legacy(throttleReasonStatusFileLegacy, validReason);
441 pSysfsAccess->setValU32Legacy(throttleReasonPL1FileLegacy, validReason);
442 pSysfsAccess->setValU32Legacy(throttleReasonPL2FileLegacy, validReason);
443 pSysfsAccess->setValU32Legacy(throttleReasonPL4FileLegacy, validReason);
444 pSysfsAccess->setValU32Legacy(throttleReasonThermalFileLegacy, validReason);
445 zes_freq_state_t state;
446 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
447 EXPECT_DOUBLE_EQ(testRequestValue, state.request);
448 EXPECT_DOUBLE_EQ(testTdpValue, state.tdp);
449 EXPECT_DOUBLE_EQ(testEfficientValue, state.efficient);
450 EXPECT_DOUBLE_EQ(testActualValue, state.actual);
451 EXPECT_EQ(setAllThrottleReasons, state.throttleReasons);
452 EXPECT_EQ(nullptr, state.pNext);
453 EXPECT_LE(state.currentVoltage, 0);
454 }
455 }
456
457 HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
458 pSysfsAccess->isLegacy = true;
459 pSysfsAccess->directoryExistsResult = false;
460 for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
461 delete handle;
462 }
463 pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
464 pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
465 auto handles = getFreqHandles(handleComponentCount);
466 double minFreqLegacy = 400.0;
467 double maxFreqLegacy = 1200.0;
468 pSysfsAccess->setValLegacy(minFreqFileLegacy, minFreqLegacy);
469 pSysfsAccess->setValLegacy(maxFreqFileLegacy, maxFreqLegacy);
470 for (auto handle : handles) {
471 zes_freq_range_t limits;
472 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
473 EXPECT_DOUBLE_EQ(minFreqLegacy, limits.min);
474 EXPECT_DOUBLE_EQ(maxFreqLegacy, limits.max);
475 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
476 EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
477 }
478 }
479
480 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonAveragePower) {
481 auto handles = getFreqHandles(handleComponentCount);
482 for (auto handle : handles) {
483 zes_freq_state_t state;
484 uint32_t validReason = 1;
485 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
486 pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
487 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
488 EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP), state.throttleReasons);
489 EXPECT_EQ(nullptr, state.pNext);
490 }
491 }
492
493 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonBurstPower) {
494 auto handles = getFreqHandles(handleComponentCount);
495 for (auto handle : handles) {
496 zes_freq_state_t state;
497 uint32_t validReason = 1;
498 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
499 pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
500 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
501 EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP), state.throttleReasons);
502 EXPECT_EQ(nullptr, state.pNext);
503 }
504 }
505
506 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsCurrentExcursion) {
507 auto handles = getFreqHandles(handleComponentCount);
508 for (auto handle : handles) {
509 zes_freq_state_t state;
510 uint32_t validReason = 1;
511 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
512 pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
513 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
514 EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT), state.throttleReasons);
515 EXPECT_EQ(nullptr, state.pNext);
516 }
517 }
518
519 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsThermalExcursion) {
520 auto handles = getFreqHandles(handleComponentCount);
521 for (auto handle : handles) {
522 zes_freq_state_t state;
523 uint32_t validReason = 1;
524 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
525 pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
526 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
527 EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT), state.throttleReasons);
528 EXPECT_EQ(nullptr, state.pNext);
529 }
530 }
531
532 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsInvalidThermalExcursion) {
533 auto handles = getFreqHandles(handleComponentCount);
534 for (auto handle : handles) {
535 zes_freq_state_t state;
536 uint32_t validReason = 1;
537 uint32_t invalidReason = 0;
538 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
539 pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
540 pSysfsAccess->setValU32(throttleReasonThermalFile, invalidReason);
541 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
542 EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT), state.throttleReasons);
543 EXPECT_EQ(nullptr, state.pNext);
544 }
545 }
546
547 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforValidReasons) {
548 zes_freq_state_t state;
549 uint32_t validReason = 1;
550 uint32_t setAllThrottleReasons = (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
551 ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
552 ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
553 ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
554
555 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
556 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
557 pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
558 pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
559 pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
560 pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
561
562 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
563 EXPECT_EQ(setAllThrottleReasons, state.throttleReasons);
564 }
565
566 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforInvalidReasons) {
567 pSysfsAccess->mockReadUnsignedIntResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
568 zes_freq_state_t state;
569 uint32_t validReason = 1;
570 uint32_t invalidReason = 0;
571 uint32_t unsetAllThrottleReasons = 0u;
572 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
573 pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
574 pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
575 pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
576 pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
577 pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
578
579 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
580 EXPECT_EQ(unsetAllThrottleReasons, state.throttleReasons);
581 }
582
583 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingTHermalStatusFile) {
584 pSysfsAccess->mockReadThermalResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
585 zes_freq_state_t state;
586 uint32_t validReason = 1;
587 uint32_t invalidReason = 0;
588 uint32_t setAllThrottleReasonsExceptThermal =
589 (ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
590 ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
591 ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
592
593 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
594 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
595 pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
596 pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
597 pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
598
599 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
600 EXPECT_EQ(setAllThrottleReasonsExceptThermal, state.throttleReasons);
601
602 pSysfsAccess->setValU32(throttleReasonThermalFile, invalidReason);
603 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
604 EXPECT_EQ(setAllThrottleReasonsExceptThermal, state.throttleReasons);
605 }
606
607 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL4StatusFile) {
608 pSysfsAccess->mockReadPL4Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
609 zes_freq_state_t state;
610 uint32_t validReason = 1;
611 uint32_t invalidReason = 0;
612 uint32_t setAllThrottleReasonsExceptPL4 =
613 (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
614 ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
615 ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
616
617 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
618 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
619 pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
620 pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
621 pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
622
623 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
624 EXPECT_EQ(setAllThrottleReasonsExceptPL4, state.throttleReasons);
625
626 pSysfsAccess->setValU32(throttleReasonPL4File, invalidReason);
627 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
628 EXPECT_EQ(setAllThrottleReasonsExceptPL4, state.throttleReasons);
629 }
630
631 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL2StatusFile) {
632 pSysfsAccess->mockReadPL2Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
633 zes_freq_state_t state;
634 uint32_t validReason = 1;
635 uint32_t invalidReason = 0;
636 uint32_t setAllThrottleReasonsExceptPL2 =
637 (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
638 ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
639 ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
640
641 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
642 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
643 pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
644 pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
645 pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
646
647 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
648 EXPECT_EQ(setAllThrottleReasonsExceptPL2, state.throttleReasons);
649
650 pSysfsAccess->setValU32(throttleReasonPL2File, invalidReason);
651 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
652 EXPECT_EQ(setAllThrottleReasonsExceptPL2, state.throttleReasons);
653 }
654
655 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL1StatusFile) {
656 pSysfsAccess->mockReadPL1Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
657 zes_freq_state_t state;
658 uint32_t validReason = 1;
659 uint32_t invalidReason = 0;
660 uint32_t setAllThrottleReasonsExceptPL1 =
661 (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
662 ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
663 ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP);
664
665 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
666 pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
667 pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
668 pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
669 pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
670
671 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
672 EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
673
674 pSysfsAccess->setValU32(throttleReasonPL1File, invalidReason);
675 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
676 EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
677 }
678
679 TEST_F(SysmanDeviceFrequencyFixture, GivenValidStatePointerWhenValidatingfrequencyGetStateWhenOneOfTheFrequencyStateThenNegativeValueIsReturned) {
680 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
681 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
682 uint32_t subdeviceId = 0;
683 auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
684 zes_freq_state_t state = {};
685 pSysfsAccess->mockReadRequestResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
686 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
687 EXPECT_EQ(-1, state.request);
688
689 pSysfsAccess->mockReadRequestResult = ZE_RESULT_ERROR_UNKNOWN;
690 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
691 EXPECT_EQ(-1, state.request);
692
693 pSysfsAccess->mockReadRequestResult = ZE_RESULT_SUCCESS;
694 pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
695 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
696 EXPECT_EQ(-1, state.tdp);
697
698 pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_UNKNOWN;
699 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
700 EXPECT_EQ(-1, state.tdp);
701
702 pSysfsAccess->mockReadTdpResult = ZE_RESULT_SUCCESS;
703 pSysfsAccess->mockReadEfficientResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
704 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
705 EXPECT_EQ(-1, state.efficient);
706
707 pSysfsAccess->mockReadEfficientResult = ZE_RESULT_ERROR_UNKNOWN;
708 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
709 EXPECT_EQ(-1, state.efficient);
710
711 pSysfsAccess->mockReadEfficientResult = ZE_RESULT_SUCCESS;
712 pSysfsAccess->mockReadActualResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
713 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
714 EXPECT_EQ(-1, state.actual);
715
716 pSysfsAccess->mockReadActualResult = ZE_RESULT_ERROR_UNKNOWN;
717 EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
718 EXPECT_EQ(-1, state.actual);
719 }
720
721 TEST_F(SysmanDeviceFrequencyFixture, GivenThrottleTimeStructPointerWhenCallingfrequencyGetThrottleTimeThenUnsupportedIsReturned) {
722 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
723 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
724 uint32_t subdeviceId = 0;
725 auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
726 zes_freq_throttle_time_t throttleTime = {};
727 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetThrottleTime(&throttleTime));
728 }
729
730 TEST_F(SysmanDeviceFrequencyFixture, GivengetMinFunctionReturnsErrorWhenValidatinggetMinFailuresThenAPIReturnsErrorAccordingly) {
731 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
732 double min = 0;
733 pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
734 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMin(min));
735
736 pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_UNKNOWN;
737 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMin(min));
738 }
739
740 TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatinggetMinValFailuresThenAPIReturnsErrorAccordingly) {
741 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
742 double val = 0;
743 pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
744 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMinVal(val));
745
746 pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_UNKNOWN;
747 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMinVal(val));
748 }
749
750 TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatinggetMaxValFailuresThenAPIReturnsErrorAccordingly) {
751 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
752 double val = 0;
753 pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
754 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMaxVal(val));
755
756 pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_UNKNOWN;
757 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMaxVal(val));
758 }
759
760 TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
761 zes_freq_properties_t properties = {};
762 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
763 pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
764 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
765 EXPECT_EQ(0, properties.canControl);
766 }
767
768 TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
769 zes_freq_properties_t properties = {};
770 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
771 pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
772 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
773 EXPECT_EQ(0, properties.canControl);
774 }
775
776 TEST_F(SysmanDeviceFrequencyFixture, GivenOnSubdeviceSetWhenValidatingAnyFrequencyAPIThenSuccessIsReturned) {
777 MockSysmanProductHelper *pMockSysmanProductHelper = new MockSysmanProductHelper();
778 pMockSysmanProductHelper->isFrequencySetRangeSupportedResult = true;
779 std::unique_ptr<SysmanProductHelper> pSysmanProductHelper(static_cast<SysmanProductHelper *>(pMockSysmanProductHelper));
780 std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
781
782 zes_freq_properties_t properties = {};
783 PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 1, 0, ZES_FREQ_DOMAIN_GPU);
784 EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
785 EXPECT_EQ(1, properties.canControl);
786 }
787
788 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfsetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
789 auto handles = getFreqHandles(handleComponentCount);
790 for (auto handle : handles) {
791 const double startingMax = 600.0;
792 const double newMin = 900.0;
793 zes_freq_range_t limits;
794
795 pSysfsAccess->setVal(maxFreqFile, startingMax);
796 // If the new Min value is greater than the old Max
797 // value, the new Max must be set before the new Min
798 limits.min = newMin;
799 limits.max = maxFreq;
800 pSysfsAccess->mockReadMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
801 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
802 }
803 }
804
805 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetFrequencyTargetThenVerifyTestCallFail) {
806 auto handles = getFreqHandles(handleComponentCount);
807 for (auto handle : handles) {
808 double freqTarget = 0.0;
809 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetFrequencyTarget(handle, &freqTarget));
810 }
811 }
812
813 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyTestCallFail) {
814 auto handles = getFreqHandles(handleComponentCount);
815 for (auto handle : handles) {
816 double freqTarget = 0.0;
817 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetFrequencyTarget(handle, freqTarget));
818 }
819 }
820
821 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetVoltageTargetThenVerifyTestCallFail) {
822 auto handles = getFreqHandles(handleComponentCount);
823 for (auto handle : handles) {
824 double voltTarget = 0.0, voltOffset = 0.0;
825 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetVoltageTarget(handle, &voltTarget, &voltOffset));
826 }
827 }
828
829 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyTestCallFail) {
830 auto handles = getFreqHandles(handleComponentCount);
831 for (auto handle : handles) {
832 double voltTarget = 0.0, voltOffset = 0.0;
833 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetVoltageTarget(handle, voltTarget, voltOffset));
834 }
835 }
836
837 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetModeThenVerifyTestCallFail) {
838 auto handles = getFreqHandles(handleComponentCount);
839 for (auto handle : handles) {
840 zes_oc_mode_t mode = ZES_OC_MODE_OFF;
841 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetMode(handle, mode));
842 }
843 }
844
845 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetModeThenVerifyTestCallFail) {
846 auto handles = getFreqHandles(handleComponentCount);
847 for (auto handle : handles) {
848 zes_oc_mode_t mode = ZES_OC_MODE_OFF;
849 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetMode(handle, &mode));
850 }
851 }
852
853 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetCapabilitiesThenVerifyTestCallFail) {
854 auto handles = getFreqHandles(handleComponentCount);
855 for (auto handle : handles) {
856 zes_oc_capabilities_t caps = {};
857 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetCapabilities(handle, &caps));
858 }
859 }
860
861 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetIccMaxThenVerifyTestCallFail) {
862 auto handles = getFreqHandles(handleComponentCount);
863 for (auto handle : handles) {
864 double iccMax = 0.0;
865 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetIccMax(handle, &iccMax));
866 }
867 }
868
869 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetIccMaxThenVerifyTestCallFail) {
870 auto handles = getFreqHandles(handleComponentCount);
871 for (auto handle : handles) {
872 double iccMax = 0.0;
873 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetIccMax(handle, iccMax));
874 }
875 }
876
877 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetTjMaxThenVerifyTestCallFail) {
878 auto handles = getFreqHandles(handleComponentCount);
879 for (auto handle : handles) {
880 double tjMax = 0.0;
881 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetTjMax(handle, &tjMax));
882 }
883 }
884
885 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetTjMaxThenVerifyTestCallFail) {
886 auto handles = getFreqHandles(handleComponentCount);
887 for (auto handle : handles) {
888 double tjMax = 0.0;
889 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetTjMax(handle, tjMax));
890 }
891 }
892
893 TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingFrequencyPropertiesThenValidFreqPropertiesRetrieved) {
894 auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
895 ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
896 uint32_t subdeviceId = 0;
897
898 zes_freq_properties_t properties = {};
899 L0::Sysman::LinuxFrequencyImp *pLinuxFrequencyImp = new L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
900 EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxFrequencyImp->osFrequencyGetProperties(properties));
901 EXPECT_EQ(properties.subdeviceId, subdeviceId);
902 EXPECT_EQ(properties.onSubdevice, onSubdevice);
903 delete pLinuxFrequencyImp;
904 }
905
906 class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
907 protected:
908 L0::Sysman::SysmanDevice *device = nullptr;
909 std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
910 L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
911
912 void SetUp() override {
913 SysmanMultiDeviceFixture::SetUp();
914 device = pSysmanDevice;
915 pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
916 pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
917 pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
918 auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
919 rootDeviceEnvironment.getMutableHardwareInfo()->capabilityTable.supportsImages = false;
920 // delete handles created in initial SysmanDeviceHandleContext::init() call
921 for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
922 delete handle;
923 }
924 pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
925 getFreqHandles(0);
926 }
927
928 void TearDown() override {
929 pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
930 SysmanMultiDeviceFixture::TearDown();
931 }
932
933 std::vector<zes_freq_handle_t> getFreqHandles(uint32_t count) {
934 std::vector<zes_freq_handle_t> handles(count, nullptr);
935 EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
936 return handles;
937 }
938 };
939
940 TEST_F(FreqMultiDeviceFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
941 uint32_t count = 0U;
942 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
943 EXPECT_EQ(count, multiHandleComponentCount);
944 auto handles = getFreqHandles(multiHandleComponentCount);
945 for (auto handle : handles) {
946 EXPECT_NE(handle, nullptr);
947 zes_freq_properties_t properties;
948 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
949 EXPECT_EQ(nullptr, properties.pNext);
950 EXPECT_EQ(ZES_FREQ_DOMAIN_GPU, properties.type);
951 EXPECT_TRUE(properties.onSubdevice);
952 }
953 }
954
955 } // namespace ult
956 } // namespace Sysman
957 } // namespace L0