Commit | Line | Data |
---|---|---|
a032d2de | 1 | Intel P-State driver |
a3ea0153 RR |
2 | -------------------- |
3 | ||
a032d2de SP |
4 | This driver provides an interface to control the P-State selection for the |
5 | SandyBridge+ Intel processors. | |
6 | ||
7 | The following document explains P-States: | |
8 | http://events.linuxfoundation.org/sites/events/files/slides/LinuxConEurope_2015.pdf | |
9 | As stated in the document, P-State doesn’t exactly mean a frequency. However, for | |
10 | the sake of the relationship with cpufreq, P-State and frequency are used | |
11 | interchangeably. | |
12 | ||
13 | Understanding the cpufreq core governors and policies are important before | |
14 | discussing more details about the Intel P-State driver. Based on what callbacks | |
15 | a cpufreq driver provides to the cpufreq core, it can support two types of | |
16 | drivers: | |
17 | - with target_index() callback: In this mode, the drivers using cpufreq core | |
18 | simply provide the minimum and maximum frequency limits and an additional | |
19 | interface target_index() to set the current frequency. The cpufreq subsystem | |
20 | has a number of scaling governors ("performance", "powersave", "ondemand", | |
21 | etc.). Depending on which governor is in use, cpufreq core will call for | |
22 | transitions to a specific frequency using target_index() callback. | |
23 | - setpolicy() callback: In this mode, drivers do not provide target_index() | |
24 | callback, so cpufreq core can't request a transition to a specific frequency. | |
25 | The driver provides minimum and maximum frequency limits and callbacks to set a | |
26 | policy. The policy in cpufreq sysfs is referred to as the "scaling governor". | |
27 | The cpufreq core can request the driver to operate in any of the two policies: | |
5bc8ac0f | 28 | "performance" and "powersave". The driver decides which frequency to use based |
a032d2de SP |
29 | on the above policy selection considering minimum and maximum frequency limits. |
30 | ||
31 | The Intel P-State driver falls under the latter category, which implements the | |
32 | setpolicy() callback. This driver decides what P-State to use based on the | |
33 | requested policy from the cpufreq core. If the processor is capable of | |
34 | selecting its next P-State internally, then the driver will offload this | |
35 | responsibility to the processor (aka HWP: Hardware P-States). If not, the | |
36 | driver implements algorithms to select the next P-State. | |
37 | ||
38 | Since these policies are implemented in the driver, they are not same as the | |
39 | cpufreq scaling governors implementation, even if they have the same name in | |
40 | the cpufreq sysfs (scaling_governors). For example the "performance" policy is | |
41 | similar to cpufreq’s "performance" governor, but "powersave" is completely | |
42 | different than the cpufreq "powersave" governor. The strategy here is similar | |
43 | to cpufreq "ondemand", where the requested P-State is related to the system load. | |
44 | ||
45 | Sysfs Interface | |
46 | ||
47 | In addition to the frequency-controlling interfaces provided by the cpufreq | |
48 | core, the driver provides its own sysfs files to control the P-State selection. | |
49 | These files have been added to /sys/devices/system/cpu/intel_pstate/. | |
50 | Any changes made to these files are applicable to all CPUs (even in a | |
9e472f95 | 51 | multi-package system, Refer to later section on placing "Per-CPU limits"). |
a032d2de SP |
52 | |
53 | max_perf_pct: Limits the maximum P-State that will be requested by | |
54 | the driver. It states it as a percentage of the available performance. The | |
55 | available (P-State) performance may be reduced by the no_turbo | |
41629a82 | 56 | setting described below. |
a3ea0153 | 57 | |
a032d2de SP |
58 | min_perf_pct: Limits the minimum P-State that will be requested by |
59 | the driver. It states it as a percentage of the max (non-turbo) | |
41629a82 | 60 | performance level. |
a3ea0153 | 61 | |
a032d2de | 62 | no_turbo: Limits the driver to selecting P-State below the turbo |
a3ea0153 RR |
63 | frequency range. |
64 | ||
a032d2de SP |
65 | turbo_pct: Displays the percentage of the total performance that |
66 | is supported by hardware that is in the turbo range. This number | |
d01b1f48 KCA |
67 | is independent of whether turbo has been disabled or not. |
68 | ||
a032d2de SP |
69 | num_pstates: Displays the number of P-States that are supported |
70 | by hardware. This number is independent of whether turbo has | |
0522424e KCA |
71 | been disabled or not. |
72 | ||
a032d2de SP |
73 | For example, if a system has these parameters: |
74 | Max 1 core turbo ratio: 0x21 (Max 1 core ratio is the maximum P-State) | |
75 | Max non turbo ratio: 0x17 | |
76 | Minimum ratio : 0x08 (Here the ratio is called max efficiency ratio) | |
77 | ||
78 | Sysfs will show : | |
79 | max_perf_pct:100, which corresponds to 1 core ratio | |
80 | min_perf_pct:24, max_efficiency_ratio / max 1 Core ratio | |
81 | no_turbo:0, turbo is not disabled | |
82 | num_pstates:26 = (max 1 Core ratio - Max Efficiency Ratio + 1) | |
83 | turbo_pct:39 = (max 1 core ratio - max non turbo ratio) / num_pstates | |
84 | ||
85 | Refer to "Intel® 64 and IA-32 Architectures Software Developer’s Manual | |
86 | Volume 3: System Programming Guide" to understand ratios. | |
87 | ||
88 | cpufreq sysfs for Intel P-State | |
89 | ||
90 | Since this driver registers with cpufreq, cpufreq sysfs is also presented. | |
91 | There are some important differences, which need to be considered. | |
92 | ||
93 | scaling_cur_freq: This displays the real frequency which was used during | |
94 | the last sample period instead of what is requested. Some other cpufreq driver, | |
95 | like acpi-cpufreq, displays what is requested (Some changes are on the | |
96 | way to fix this for acpi-cpufreq driver). The same is true for frequencies | |
97 | displayed at /proc/cpuinfo. | |
98 | ||
99 | scaling_governor: This displays current active policy. Since each CPU has a | |
100 | cpufreq sysfs, it is possible to set a scaling governor to each CPU. But this | |
101 | is not possible with Intel P-States, as there is one common policy for all | |
102 | CPUs. Here, the last requested policy will be applicable to all CPUs. It is | |
103 | suggested that one use the cpupower utility to change policy to all CPUs at the | |
104 | same time. | |
105 | ||
106 | scaling_setspeed: This attribute can never be used with Intel P-State. | |
107 | ||
108 | scaling_max_freq/scaling_min_freq: This interface can be used similarly to | |
109 | the max_perf_pct/min_perf_pct of Intel P-State sysfs. However since frequencies | |
110 | are converted to nearest possible P-State, this is prone to rounding errors. | |
111 | This method is not preferred to limit performance. | |
112 | ||
113 | affected_cpus: Not used | |
114 | related_cpus: Not used | |
115 | ||
a3ea0153 | 116 | For contemporary Intel processors, the frequency is controlled by the |
a032d2de | 117 | processor itself and the P-State exposed to software is related to |
a3ea0153 | 118 | performance levels. The idea that frequency can be set to a single |
a032d2de SP |
119 | frequency is fictional for Intel Core processors. Even if the scaling |
120 | driver selects a single P-State, the actual frequency the processor | |
a3ea0153 RR |
121 | will run at is selected by the processor itself. |
122 | ||
9e472f95 SP |
123 | Per-CPU limits |
124 | ||
125 | The kernel command line option "intel_pstate=per_cpu_perf_limits" forces | |
126 | the intel_pstate driver to use per-CPU performance limits. When it is set, | |
127 | the sysfs control interface described above is subject to limitations. | |
128 | - The following controls are not available for both read and write | |
129 | /sys/devices/system/cpu/intel_pstate/max_perf_pct | |
130 | /sys/devices/system/cpu/intel_pstate/min_perf_pct | |
131 | - The following controls can be used to set performance limits, as far as the | |
132 | architecture of the processor permits: | |
133 | /sys/devices/system/cpu/cpu*/cpufreq/scaling_max_freq | |
134 | /sys/devices/system/cpu/cpu*/cpufreq/scaling_min_freq | |
135 | /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor | |
136 | - User can still observe turbo percent and number of P-States from | |
137 | /sys/devices/system/cpu/intel_pstate/turbo_pct | |
138 | /sys/devices/system/cpu/intel_pstate/num_pstates | |
139 | - User can read write system wide turbo status | |
140 | /sys/devices/system/cpu/no_turbo | |
141 | ||
a032d2de SP |
142 | Tuning Intel P-State driver |
143 | ||
b8b97a42 SP |
144 | When the performance can be tuned using PID (Proportional Integral |
145 | Derivative) controller, debugfs files are provided for adjusting performance. | |
146 | They are presented under: | |
147 | /sys/kernel/debug/pstate_snb/ | |
a3ea0153 | 148 | |
b8b97a42 | 149 | The PID tunable parameters are: |
a3ea0153 RR |
150 | deadband |
151 | d_gain_pct | |
152 | i_gain_pct | |
153 | p_gain_pct | |
154 | sample_rate_ms | |
155 | setpoint | |
a032d2de SP |
156 | |
157 | To adjust these parameters, some understanding of driver implementation is | |
158 | necessary. There are some tweeks described here, but be very careful. Adjusting | |
159 | them requires expert level understanding of power and performance relationship. | |
160 | These limits are only useful when the "powersave" policy is active. | |
161 | ||
162 | -To make the system more responsive to load changes, sample_rate_ms can | |
163 | be adjusted (current default is 10ms). | |
164 | -To make the system use higher performance, even if the load is lower, setpoint | |
165 | can be adjusted to a lower number. This will also lead to faster ramp up time | |
166 | to reach the maximum P-State. | |
167 | If there are no derivative and integral coefficients, The next P-State will be | |
168 | equal to: | |
169 | current P-State - ((setpoint - current cpu load) * p_gain_pct) | |
170 | ||
171 | For example, if the current PID parameters are (Which are defaults for the core | |
172 | processors like SandyBridge): | |
173 | deadband = 0 | |
174 | d_gain_pct = 0 | |
175 | i_gain_pct = 0 | |
176 | p_gain_pct = 20 | |
177 | sample_rate_ms = 10 | |
178 | setpoint = 97 | |
179 | ||
180 | If the current P-State = 0x08 and current load = 100, this will result in the | |
181 | next P-State = 0x08 - ((97 - 100) * 0.2) = 8.6 (rounded to 9). Here the P-State | |
182 | goes up by only 1. If during next sample interval the current load doesn't | |
183 | change and still 100, then P-State goes up by one again. This process will | |
184 | continue as long as the load is more than the setpoint until the maximum P-State | |
185 | is reached. | |
186 | ||
187 | For the same load at setpoint = 60, this will result in the next P-State | |
188 | = 0x08 - ((60 - 100) * 0.2) = 16 | |
189 | So by changing the setpoint from 97 to 60, there is an increase of the | |
190 | next P-State from 9 to 16. So this will make processor execute at higher | |
191 | P-State for the same CPU load. If the load continues to be more than the | |
192 | setpoint during next sample intervals, then P-State will go up again till the | |
193 | maximum P-State is reached. But the ramp up time to reach the maximum P-State | |
194 | will be much faster when the setpoint is 60 compared to 97. | |
195 | ||
196 | Debugging Intel P-State driver | |
197 | ||
198 | Event tracing | |
199 | To debug P-State transition, the Linux event tracing interface can be used. | |
200 | There are two specific events, which can be enabled (Provided the kernel | |
201 | configs related to event tracing are enabled). | |
202 | ||
203 | # cd /sys/kernel/debug/tracing/ | |
204 | # echo 1 > events/power/pstate_sample/enable | |
205 | # echo 1 > events/power/cpu_frequency/enable | |
206 | # cat trace | |
207 | gnome-terminal--4510 [001] ..s. 1177.680733: pstate_sample: core_busy=107 | |
208 | scaled=94 from=26 to=26 mperf=1143818 aperf=1230607 tsc=29838618 | |
209 | freq=2474476 | |
210 | cat-5235 [002] ..s. 1177.681723: cpu_frequency: state=2900000 cpu_id=2 | |
211 | ||
212 | ||
213 | Using ftrace | |
214 | ||
215 | If function level tracing is required, the Linux ftrace interface can be used. | |
216 | For example if we want to check how often a function to set a P-State is | |
217 | called, we can set ftrace filter to intel_pstate_set_pstate. | |
218 | ||
219 | # cd /sys/kernel/debug/tracing/ | |
220 | # cat available_filter_functions | grep -i pstate | |
221 | intel_pstate_set_pstate | |
222 | intel_pstate_cpu_init | |
223 | ... | |
224 | ||
225 | # echo intel_pstate_set_pstate > set_ftrace_filter | |
226 | # echo function > current_tracer | |
227 | # cat trace | head -15 | |
228 | # tracer: function | |
229 | # | |
230 | # entries-in-buffer/entries-written: 80/80 #P:4 | |
231 | # | |
232 | # _-----=> irqs-off | |
233 | # / _----=> need-resched | |
234 | # | / _---=> hardirq/softirq | |
235 | # || / _--=> preempt-depth | |
236 | # ||| / delay | |
237 | # TASK-PID CPU# |||| TIMESTAMP FUNCTION | |
238 | # | | | |||| | | | |
239 | Xorg-3129 [000] ..s. 2537.644844: intel_pstate_set_pstate <-intel_pstate_timer_func | |
240 | gnome-terminal--4510 [002] ..s. 2537.649844: intel_pstate_set_pstate <-intel_pstate_timer_func | |
241 | gnome-shell-3409 [001] ..s. 2537.650850: intel_pstate_set_pstate <-intel_pstate_timer_func | |
242 | <idle>-0 [000] ..s. 2537.654843: intel_pstate_set_pstate <-intel_pstate_timer_func |