Debian Codegraph @

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

raw
1 /*
2 * Copyright (C) 2020-2023 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "level_zero/sysman/source/api/frequency/windows/sysman_os_frequency_imp.h"
9 #include "level_zero/sysman/source/sysman_const.h"
10 #include "level_zero/sysman/test/unit_tests/sources/frequency/windows/mock_frequency.h"
11 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h"
12
13 namespace L0 {
14 namespace Sysman {
15 namespace ult {
16
17 constexpr uint32_t frequencyHandleComponentCount = 3u;
18 constexpr double minFreq = 400.0;
19 constexpr double maxFreq = 1200.0;
20 constexpr double step = 50.0 / 3;
21 constexpr uint32_t numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
22
23 class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
24 protected:
25 std::unique_ptr<MockFrequencyKmdSysManager> pKmdSysManager;
26 L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr;
27 void SetUp() override {
28 SysmanDeviceFixture::SetUp();
29 pKmdSysManager.reset(new MockFrequencyKmdSysManager);
30
31 pKmdSysManager->allowSetCalls = true;
32
33 pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
34 pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
35
36 for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
37 delete handle;
38 }
39 pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
40 }
41
42 void TearDown() override {
43 pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
44 SysmanDeviceFixture::TearDown();
45 }
46
47 double clockValue(const double calculatedClock) {
48 // i915 specific. frequency step is a fraction
49 // However, the Kmd represents all clock
50 // rates as integer values. So clocks are
51 // rounded to the nearest integer.
52 uint32_t actualClock = static_cast<uint32_t>(calculatedClock + 0.5);
53 return static_cast<double>(actualClock);
54 }
55
56 std::vector<zes_freq_handle_t> getFrequencyHandles(uint32_t count) {
57 std::vector<zes_freq_handle_t> handles(count, nullptr);
58 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
59 return handles;
60 }
61 };
62
63 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsIfNoHandlesArePresentThenZeroCountIsReturned) {
64 uint32_t count = 0;
65 pKmdSysManager->mockSupportedDomains = 0;
66 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
67 EXPECT_EQ(count, 0u);
68 }
69
70 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
71 uint32_t count = 0;
72 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
73 EXPECT_EQ(count, frequencyHandleComponentCount);
74 }
75
76 TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidComponentCountWhenEnumeratingFrequencyDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
77 uint32_t count = 0;
78 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
79 EXPECT_EQ(count, frequencyHandleComponentCount);
80 count = count + 1;
81 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
82 EXPECT_EQ(count, frequencyHandleComponentCount);
83 }
84
85 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsAndRequestSingleFailsThenZeroHandlesAreCreated) {
86 pKmdSysManager->mockRequestSingle = true;
87 pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNKNOWN;
88 uint32_t count = 0;
89 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
90 EXPECT_EQ(count, 0u);
91 }
92
93 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsThenValidPowerHandlesIsReturned) {
94 uint32_t count = 0;
95 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
96 EXPECT_EQ(count, frequencyHandleComponentCount);
97
98 std::vector<zes_freq_handle_t> handles(count, nullptr);
99 EXPECT_EQ(zesDeviceEnumFrequencyDomains(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
100 for (auto handle : handles) {
101 EXPECT_NE(handle, nullptr);
102 }
103 }
104
105 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
106 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
107 uint32_t domainIndex = 0;
108 for (auto handle : handles) {
109 EXPECT_NE(handle, nullptr);
110 zes_freq_properties_t properties;
111 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
112 EXPECT_EQ(pKmdSysManager->mockDomainType[domainIndex], properties.type);
113 EXPECT_FALSE(properties.onSubdevice);
114 EXPECT_EQ(pKmdSysManager->mockGPUCanControl[domainIndex], properties.canControl);
115 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
116 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRp0[domainIndex], properties.max);
117 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRpn[domainIndex], properties.min);
118 } else if (domainIndex == ZES_FREQ_DOMAIN_MEMORY) {
119 EXPECT_DOUBLE_EQ(-1, properties.max);
120 EXPECT_DOUBLE_EQ(-1, properties.min);
121 } else if (domainIndex == ZES_FREQ_DOMAIN_MEDIA) {
122 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRp0[domainIndex], properties.max);
123 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRpn[domainIndex], properties.min);
124 }
125 domainIndex++;
126 }
127 }
128
129 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesAllowSetCallsToFalseFrequencyGetPropertiesThenSuccessIsReturned) {
130 pKmdSysManager->allowSetCalls = false;
131 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
132 uint32_t domainIndex = 0;
133 for (auto handle : handles) {
134 EXPECT_NE(handle, nullptr);
135 zes_freq_properties_t properties;
136 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
137 EXPECT_EQ(pKmdSysManager->mockDomainType[domainIndex], properties.type);
138 EXPECT_FALSE(properties.onSubdevice);
139 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
140 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRp0[domainIndex], properties.max);
141 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRpn[domainIndex], properties.min);
142 } else if (domainIndex == ZES_FREQ_DOMAIN_MEMORY) {
143 EXPECT_DOUBLE_EQ(-1.0, properties.max);
144 EXPECT_DOUBLE_EQ(-1.0, properties.min);
145 } else if (domainIndex == ZES_FREQ_DOMAIN_MEDIA) {
146 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRp0[domainIndex], properties.max);
147 EXPECT_DOUBLE_EQ(pKmdSysManager->mockRpn[domainIndex], properties.min);
148 }
149 EXPECT_EQ(pKmdSysManager->mockGPUCannotControl[domainIndex], properties.canControl);
150 domainIndex++;
151 }
152 }
153
154 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyPropertiesAndRequestMultipleFailsThenInvalidPropertiesAreReturned) {
155 pKmdSysManager->mockRequestMultiple = true;
156 pKmdSysManager->requestMultipleSizeDiff = false;
157 pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
158 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
159 for (auto handle : handles) {
160 zes_freq_properties_t properties;
161 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
162 EXPECT_EQ(-1.0, properties.min);
163 EXPECT_EQ(-1.0, properties.max);
164 }
165 }
166
167 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyPropertiesAndRequestMultipleReturnsInvalidSizeThenInvalidpropertiesAreReturned) {
168 pKmdSysManager->mockRequestMultiple = true;
169 pKmdSysManager->requestMultipleSizeDiff = true;
170 pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_SUCCESS;
171 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
172 for (auto handle : handles) {
173 zes_freq_properties_t properties;
174 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
175 EXPECT_EQ(-1.0, properties.min);
176 EXPECT_EQ(-1.0, properties.max);
177 }
178 }
179
180 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
181 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
182 uint32_t domainIndex = 0;
183
184 for (auto handle : handles) {
185 EXPECT_NE(handle, nullptr);
186 uint32_t count = 0;
187 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
188 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
189 EXPECT_EQ(numClocks, count);
190 } else if (domainIndex == ZES_FREQ_DOMAIN_MEMORY) {
191 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
192 EXPECT_EQ(1u, count);
193 } else if (domainIndex == ZES_FREQ_DOMAIN_MEDIA) {
194 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
195 EXPECT_EQ(numClocks, count);
196 }
197
198 domainIndex++;
199 }
200 }
201
202 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
203 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
204 uint32_t domainIndex = 0;
205
206 for (auto handle : handles) {
207 uint32_t count = 0;
208 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
209 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
210 EXPECT_EQ(numClocks, count);
211
212 double *clocks = new double[count];
213 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, clocks));
214 EXPECT_EQ(numClocks, count);
215 for (uint32_t i = 0; i < count; i++) {
216 EXPECT_DOUBLE_EQ(clockValue(pKmdSysManager->mockRpn[domainIndex] + (step * i)), clocks[i]);
217 }
218 delete[] clocks;
219 }
220
221 domainIndex++;
222 }
223 }
224
225 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetRangeThenVerifyzesFrequencyGetRangeTestCallSucceeds) {
226 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
227 uint32_t domainIndex = 0;
228
229 for (auto handle : handles) {
230 zes_freq_range_t limits;
231 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
232 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
233 EXPECT_DOUBLE_EQ(pKmdSysManager->mockMinFrequencyRange, limits.min);
234 EXPECT_DOUBLE_EQ(pKmdSysManager->mockMaxFrequencyRange, limits.max);
235 } else if (domainIndex == ZES_FREQ_DOMAIN_MEMORY) {
236 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zesFrequencyGetRange(handle, &limits));
237 } else if (domainIndex == ZES_FREQ_DOMAIN_MEDIA) {
238 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
239 EXPECT_DOUBLE_EQ(pKmdSysManager->mockMinFrequencyRange, limits.min);
240 EXPECT_DOUBLE_EQ(pKmdSysManager->mockMaxFrequencyRange, limits.max);
241 }
242
243 domainIndex++;
244 }
245 }
246
247 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
248 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
249 uint32_t domainIndex = 0;
250
251 for (auto handle : handles) {
252 const double startingMin = 900.0;
253 const double newMax = 600.0;
254 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
255 zes_freq_range_t limits;
256
257 pKmdSysManager->mockMinFrequencyRange = static_cast<uint32_t>(startingMin);
258
259 // If the new Max value is less than the old Min
260 // value, the new Min must be set before the new Max
261 limits.min = minFreq;
262 limits.max = newMax;
263 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
264 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
265 EXPECT_DOUBLE_EQ(minFreq, limits.min);
266 EXPECT_DOUBLE_EQ(newMax, limits.max);
267 }
268
269 domainIndex++;
270 }
271 }
272
273 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
274 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
275 uint32_t domainIndex = 0;
276
277 for (auto handle : handles) {
278 const double startingMax = 600.0;
279 const double newMin = 900.0;
280
281 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
282 zes_freq_range_t limits;
283
284 pKmdSysManager->mockMaxFrequencyRange = static_cast<uint32_t>(startingMax);
285
286 // If the new Min value is greater than the old Max
287 // value, the new Max must be set before the new Min
288 limits.min = newMin;
289 limits.max = maxFreq;
290 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
291 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
292 EXPECT_DOUBLE_EQ(newMin, limits.min);
293 EXPECT_DOUBLE_EQ(maxFreq, limits.max);
294 } else if (domainIndex == ZES_FREQ_DOMAIN_MEDIA) {
295 zes_freq_range_t limits;
296
297 pKmdSysManager->mockMinFrequencyRange = static_cast<uint32_t>(startingMax);
298
299 // If the new Max value is less than the old Min
300 // value, the new Min must be set before the new Max
301 limits.min = minFreq;
302 limits.max = maxFreq;
303 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
304 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
305 EXPECT_DOUBLE_EQ(minFreq, limits.min);
306 EXPECT_DOUBLE_EQ(maxFreq, limits.max);
307 }
308 domainIndex++;
309 }
310 }
311
312 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyCallSucceeds) {
313 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
314 uint32_t domainIndex = 0;
315
316 for (auto handle : handles) {
317 zes_freq_state_t state = {};
318 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
319
320 if (domainIndex == ZES_FREQ_DOMAIN_GPU) {
321 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockResolvedFrequency[domainIndex]), state.actual);
322 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockCurrentVoltage) / milliVoltsFactor, state.currentVoltage);
323 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockEfficientFrequency), state.efficient);
324 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockRequestedFrequency), state.request);
325 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockTdpFrequency), state.tdp);
326 EXPECT_EQ(pKmdSysManager->mockThrottleReasons, state.throttleReasons);
327 } else if (domainIndex == ZES_FREQ_DOMAIN_MEMORY) {
328 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockResolvedFrequency[domainIndex]), state.actual);
329 EXPECT_DOUBLE_EQ(-1.0, state.currentVoltage);
330 EXPECT_DOUBLE_EQ(-1.0, state.efficient);
331 EXPECT_DOUBLE_EQ(-1.0, state.request);
332 EXPECT_DOUBLE_EQ(-1.0, state.tdp);
333 EXPECT_EQ(pKmdSysManager->mockThrottleReasons, state.throttleReasons);
334 } else if (domainIndex == ZES_FREQ_DOMAIN_MEDIA) {
335 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockResolvedFrequency[domainIndex]), state.actual);
336 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockCurrentVoltage) / milliVoltsFactor, state.currentVoltage);
337 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockEfficientFrequency), state.efficient);
338 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockRequestedFrequency), state.request);
339 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockTdpFrequency), state.tdp);
340 EXPECT_EQ(pKmdSysManager->mockThrottleReasons, state.throttleReasons);
341 }
342
343 domainIndex++;
344 }
345 }
346
347 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyStateAndRequestMultipleFailsThenFailureIsReturned) {
348 pKmdSysManager->mockRequestMultiple = true;
349 pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
350 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
351 for (auto handle : handles) {
352 zes_freq_state_t state = {};
353 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zesFrequencyGetState(handle, &state));
354 }
355 }
356
357 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhileGettingFrequencyStateAndRequestMultipleReturnsInvalidSizeThenFailureIsReturned) {
358 pKmdSysManager->mockRequestMultiple = true;
359 pKmdSysManager->requestMultipleSizeDiff = true;
360 pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
361 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
362 for (auto handle : handles) {
363 zes_freq_state_t state = {};
364 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zesFrequencyGetState(handle, &state));
365 }
366 }
367
368 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetThrottleTimeThenVerifyCallFails) {
369 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
370 for (auto handle : handles) {
371 zes_freq_throttle_time_t throttletime = {};
372 EXPECT_NE(ZE_RESULT_SUCCESS, zesFrequencyGetThrottleTime(handle, &throttletime));
373 }
374 }
375
376 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetCapabilitiesThenVerifyCallSucceeds) {
377 pKmdSysManager->allowSetCalls = false;
378 uint32_t domainIndex = 0;
379 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
380 for (auto handle : handles) {
381 zes_oc_capabilities_t ocCaps = {};
382 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetCapabilities(handle, &ocCaps));
383 EXPECT_EQ(pKmdSysManager->mockIsExtendedModeSupported[domainIndex], ocCaps.isExtendedModeSupported);
384 EXPECT_EQ(pKmdSysManager->mockIsFixedModeSupported[domainIndex], ocCaps.isFixedModeSupported);
385 EXPECT_EQ(pKmdSysManager->mockHighVoltageSupported[domainIndex], ocCaps.isHighVoltModeCapable);
386 EXPECT_EQ(pKmdSysManager->mockHighVoltageEnabled[domainIndex], ocCaps.isHighVoltModeEnabled);
387 EXPECT_EQ(pKmdSysManager->mockIsIccMaxSupported, ocCaps.isIccMaxSupported);
388 EXPECT_EQ(pKmdSysManager->mockIsOcSupported[domainIndex], ocCaps.isOcSupported);
389 EXPECT_EQ(pKmdSysManager->mockIsTjMaxSupported, ocCaps.isTjMaxSupported);
390 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockMaxFactoryDefaultFrequency[domainIndex]), ocCaps.maxFactoryDefaultFrequency);
391 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockMaxFactoryDefaultVoltage[domainIndex]), ocCaps.maxFactoryDefaultVoltage);
392 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockMaxOcFrequency[domainIndex]), ocCaps.maxOcFrequency);
393 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockMaxOcVoltage[domainIndex]), ocCaps.maxOcVoltage);
394 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockVoltageOffset[domainIndex]), ocCaps.maxOcVoltageOffset);
395 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockVoltageOffset[domainIndex]), ocCaps.minOcVoltageOffset);
396 domainIndex++;
397 }
398 }
399
400 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetFrequencyTargetThenVerifyCallSucceeds) {
401 uint32_t domainIndex = 0;
402 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
403 for (auto handle : handles) {
404 double freqTarget = 0.0;
405 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetFrequencyTarget(handle, &freqTarget));
406 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockFrequencyTarget[domainIndex]), freqTarget);
407 domainIndex++;
408 }
409 }
410
411 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetFrequencyTargetAndRequestSingleFailsThenFailureIsReturned) {
412 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
413 for (auto handle : handles) {
414 pKmdSysManager->mockRequestSingle = true;
415 pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNKNOWN;
416 double freqTarget = 0.0;
417 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zesFrequencyOcGetFrequencyTarget(handle, &freqTarget));
418 }
419 }
420
421 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetVoltageTargetThenVerifyCallSucceeds) {
422 uint32_t domainIndex = 0;
423 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
424 for (auto handle : handles) {
425 double voltageTarget = 0.0, voltageOffset = 0.0;
426 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetVoltageTarget(handle, &voltageTarget, &voltageOffset));
427 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockVoltageTarget[domainIndex]), voltageTarget);
428 EXPECT_DOUBLE_EQ(static_cast<double>(pKmdSysManager->mockVoltageOffset[domainIndex]), voltageOffset);
429 domainIndex++;
430 }
431 }
432
433 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetVoltageTargetAndRequestMultipleFailsThenFailureIsReturned) {
434 pKmdSysManager->mockRequestMultiple = true;
435 pKmdSysManager->requestMultipleSizeDiff = false;
436 pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_INVALID_SIZE;
437 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
438 for (auto handle : handles) {
439 double voltageTarget = 0.0, voltageOffset = 0.0;
440 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zesFrequencyOcGetVoltageTarget(handle, &voltageTarget, &voltageOffset));
441 }
442 }
443
444 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetModeThenVerifyCallSucceeds) {
445 pKmdSysManager->allowSetCalls = false;
446 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
447 for (auto handle : handles) {
448 zes_oc_mode_t mode = ZES_OC_MODE_OFF;
449 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &mode));
450 EXPECT_DOUBLE_EQ(ZES_OC_MODE_INTERPOLATIVE, mode);
451 }
452 }
453
454 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallFails) {
455 pKmdSysManager->allowSetCalls = false;
456 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
457 for (auto handle : handles) {
458 double freqTarget = 1400.0;
459 EXPECT_NE(ZE_RESULT_SUCCESS, zesFrequencyOcSetFrequencyTarget(handle, freqTarget));
460 }
461 }
462
463 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallFails) {
464 pKmdSysManager->allowSetCalls = false;
465 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
466 for (auto handle : handles) {
467 double voltageTarget = 1040.0, voltageOffset = 20.0;
468 EXPECT_NE(ZE_RESULT_SUCCESS, zesFrequencyOcSetVoltageTarget(handle, voltageTarget, voltageOffset));
469 }
470 }
471
472 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetModeThenVerifyCallFails) {
473 pKmdSysManager->allowSetCalls = false;
474 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
475 for (auto handle : handles) {
476 zes_oc_mode_t mode = ZES_OC_MODE_OVERRIDE;
477 EXPECT_NE(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
478 }
479 }
480
481 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallSucceed) {
482 pKmdSysManager->allowSetCalls = true;
483 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
484 for (auto handle : handles) {
485 double freqTarget = 1400.0;
486 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetFrequencyTarget(handle, freqTarget));
487 double newFreqTarget = 0.0;
488 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetFrequencyTarget(handle, &newFreqTarget));
489 EXPECT_DOUBLE_EQ(newFreqTarget, freqTarget);
490 }
491 }
492
493 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallSucceed) {
494 pKmdSysManager->allowSetCalls = true;
495 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
496 for (auto handle : handles) {
497 double voltageTarget = 1040.0, voltageOffset = 20.0;
498 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetVoltageTarget(handle, voltageTarget, voltageOffset));
499 double newVoltageTarget = 1040.0, newVoltageOffset = 20.0;
500 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetVoltageTarget(handle, &newVoltageTarget, &newVoltageOffset));
501 EXPECT_DOUBLE_EQ(voltageTarget, newVoltageTarget);
502 EXPECT_DOUBLE_EQ(voltageOffset, newVoltageOffset);
503 }
504 }
505
506 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetIccMaxTargetThenVerifyCallSucceed) {
507 pKmdSysManager->allowSetCalls = true;
508 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
509 for (auto handle : handles) {
510 double setIccMax = 1050.0;
511 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetIccMax(handle, setIccMax));
512 double newSetIccMax = 0.0;
513 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetIccMax(handle, &newSetIccMax));
514 EXPECT_DOUBLE_EQ(setIccMax, newSetIccMax);
515 }
516 }
517
518 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetTjMaxTargetThenVerifyCallSucceed) {
519 pKmdSysManager->allowSetCalls = true;
520 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
521 for (auto handle : handles) {
522 double setTjMax = 1050.0;
523 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetTjMax(handle, setTjMax));
524 double newSetTjMax = 0.0;
525 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetTjMax(handle, &newSetTjMax));
526 EXPECT_DOUBLE_EQ(newSetTjMax, setTjMax);
527 }
528 }
529
530 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetModeThenVerifyCallSucceed) {
531 pKmdSysManager->allowSetCalls = true;
532 auto handles = getFrequencyHandles(frequencyHandleComponentCount);
533 for (auto handle : handles) {
534
535 zes_oc_mode_t mode = ZES_OC_MODE_INTERPOLATIVE;
536 zes_oc_mode_t newmode;
537 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
538 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
539 EXPECT_EQ(newmode, ZES_OC_MODE_INTERPOLATIVE);
540
541 mode = ZES_OC_MODE_OFF;
542 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
543 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
544 EXPECT_EQ(newmode, ZES_OC_MODE_INTERPOLATIVE);
545
546 mode = ZES_OC_MODE_FIXED;
547 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION, zesFrequencyOcSetMode(handle, mode));
548 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
549 EXPECT_EQ(newmode, ZES_OC_MODE_INTERPOLATIVE);
550
551 mode = ZES_OC_MODE_OFF;
552 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
553 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
554 EXPECT_EQ(newmode, ZES_OC_MODE_INTERPOLATIVE);
555
556 mode = ZES_OC_MODE_OVERRIDE;
557 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
558 EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
559 EXPECT_EQ(newmode, ZES_OC_MODE_OVERRIDE);
560 }
561 }
562
563 } // namespace ult
564 } // namespace Sysman
565 } // namespace L0