1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/api/frequency/sysman_frequency_imp.h"
#include "shared/source/helpers/debug_helpers.h"
#include <algorithm>
#include <cmath>
namespace L0 {
namespace Sysman {
ze_result_t FrequencyImp::frequencyGetProperties(zes_freq_properties_t *pProperties) {
*pProperties = zesFrequencyProperties;
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyImp::frequencyGetAvailableClocks(uint32_t *pCount, double *phFrequency) {
uint32_t numToCopy = std::min(*pCount, numClocks);
if (0 == *pCount || *pCount > numClocks) {
*pCount = numClocks;
}
if (nullptr != phFrequency) {
for (uint32_t i = 0; i < numToCopy; i++) {
phFrequency[i] = pClocks[i];
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyImp::frequencyGetRange(zes_freq_range_t *pLimits) {
return pOsFrequency->osFrequencyGetRange(pLimits);
}
ze_result_t FrequencyImp::frequencySetRange(const zes_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
// No need to check if the frequency is inside the clocks array:
// 1. GuC will cap this, GuC has an internal range. Hw too rounds to the next step, no need to do that check.
// 2. For Overclocking, Oc frequency will be higher than the zesFrequencyProperties.max frequency, so it would be outside
// the clocks array too. Pcode at the end will decide the granted frequency, no need for the check.
if (newMin > newMax) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
return pOsFrequency->osFrequencySetRange(pLimits);
}
ze_result_t FrequencyImp::frequencyGetState(zes_freq_state_t *pState) {
return pOsFrequency->osFrequencyGetState(pState);
}
ze_result_t FrequencyImp::frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return pOsFrequency->osFrequencyGetThrottleTime(pThrottleTime);
}
ze_result_t FrequencyImp::frequencyOcGetCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
return pOsFrequency->getOcCapabilities(pOcCapabilities);
}
ze_result_t FrequencyImp::frequencyOcGetFrequencyTarget(double *pCurrentOcFrequency) {
return pOsFrequency->getOcFrequencyTarget(pCurrentOcFrequency);
}
ze_result_t FrequencyImp::frequencyOcSetFrequencyTarget(double currentOcFrequency) {
return pOsFrequency->setOcFrequencyTarget(currentOcFrequency);
}
ze_result_t FrequencyImp::frequencyOcGetVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
return pOsFrequency->getOcVoltageTarget(pCurrentVoltageTarget, pCurrentVoltageOffset);
}
ze_result_t FrequencyImp::frequencyOcSetVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
return pOsFrequency->setOcVoltageTarget(currentVoltageTarget, currentVoltageOffset);
}
ze_result_t FrequencyImp::frequencyOcGetMode(zes_oc_mode_t *pCurrentOcMode) {
return pOsFrequency->getOcMode(pCurrentOcMode);
}
ze_result_t FrequencyImp::frequencyOcSetMode(zes_oc_mode_t currentOcMode) {
return pOsFrequency->setOcMode(currentOcMode);
}
ze_result_t FrequencyImp::frequencyOcGetIccMax(double *pOcIccMax) {
return pOsFrequency->getOcIccMax(pOcIccMax);
}
ze_result_t FrequencyImp::frequencyOcSetIccMax(double ocIccMax) {
return pOsFrequency->setOcIccMax(ocIccMax);
}
ze_result_t FrequencyImp::frequencyOcGeTjMax(double *pOcTjMax) {
return pOsFrequency->getOcTjMax(pOcTjMax);
}
ze_result_t FrequencyImp::frequencyOcSetTjMax(double ocTjMax) {
return pOsFrequency->setOcTjMax(ocTjMax);
}
void FrequencyImp::init() {
pOsFrequency->osFrequencyGetProperties(zesFrequencyProperties);
double step = pOsFrequency->osFrequencyGetStepSize();
double freqRange = zesFrequencyProperties.max - zesFrequencyProperties.min;
numClocks = static_cast<uint32_t>(round(freqRange / step)) + 1;
pClocks = new double[numClocks];
for (unsigned int i = 0; i < numClocks; i++) {
pClocks[i] = round(zesFrequencyProperties.min + (step * i));
}
}
FrequencyImp::FrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
pOsFrequency = OsFrequency::create(pOsSysman, onSubdevice, subdeviceId, frequencyDomainNumber);
UNRECOVERABLE_IF(nullptr == pOsFrequency);
init();
}
FrequencyImp::~FrequencyImp() {
delete pOsFrequency;
delete[] pClocks;
}
} // namespace Sysman
} // namespace L0
|
