Linux 4.12-rc2
[sfrench/cifs-2.6.git] / Documentation / admin-guide / pm / cpufreq.rst
1 .. |struct cpufreq_policy| replace:: :c:type:`struct cpufreq_policy <cpufreq_policy>`
2
3 =======================
4 CPU Performance Scaling
5 =======================
6
7 ::
8
9  Copyright (c) 2017 Intel Corp., Rafael J. Wysocki <rafael.j.wysocki@intel.com>
10
11 The Concept of CPU Performance Scaling
12 ======================================
13
14 The majority of modern processors are capable of operating in a number of
15 different clock frequency and voltage configurations, often referred to as
16 Operating Performance Points or P-states (in ACPI terminology).  As a rule,
17 the higher the clock frequency and the higher the voltage, the more instructions
18 can be retired by the CPU over a unit of time, but also the higher the clock
19 frequency and the higher the voltage, the more energy is consumed over a unit of
20 time (or the more power is drawn) by the CPU in the given P-state.  Therefore
21 there is a natural tradeoff between the CPU capacity (the number of instructions
22 that can be executed over a unit of time) and the power drawn by the CPU.
23
24 In some situations it is desirable or even necessary to run the program as fast
25 as possible and then there is no reason to use any P-states different from the
26 highest one (i.e. the highest-performance frequency/voltage configuration
27 available).  In some other cases, however, it may not be necessary to execute
28 instructions so quickly and maintaining the highest available CPU capacity for a
29 relatively long time without utilizing it entirely may be regarded as wasteful.
30 It also may not be physically possible to maintain maximum CPU capacity for too
31 long for thermal or power supply capacity reasons or similar.  To cover those
32 cases, there are hardware interfaces allowing CPUs to be switched between
33 different frequency/voltage configurations or (in the ACPI terminology) to be
34 put into different P-states.
35
36 Typically, they are used along with algorithms to estimate the required CPU
37 capacity, so as to decide which P-states to put the CPUs into.  Of course, since
38 the utilization of the system generally changes over time, that has to be done
39 repeatedly on a regular basis.  The activity by which this happens is referred
40 to as CPU performance scaling or CPU frequency scaling (because it involves
41 adjusting the CPU clock frequency).
42
43
44 CPU Performance Scaling in Linux
45 ================================
46
47 The Linux kernel supports CPU performance scaling by means of the ``CPUFreq``
48 (CPU Frequency scaling) subsystem that consists of three layers of code: the
49 core, scaling governors and scaling drivers.
50
51 The ``CPUFreq`` core provides the common code infrastructure and user space
52 interfaces for all platforms that support CPU performance scaling.  It defines
53 the basic framework in which the other components operate.
54
55 Scaling governors implement algorithms to estimate the required CPU capacity.
56 As a rule, each governor implements one, possibly parametrized, scaling
57 algorithm.
58
59 Scaling drivers talk to the hardware.  They provide scaling governors with
60 information on the available P-states (or P-state ranges in some cases) and
61 access platform-specific hardware interfaces to change CPU P-states as requested
62 by scaling governors.
63
64 In principle, all available scaling governors can be used with every scaling
65 driver.  That design is based on the observation that the information used by
66 performance scaling algorithms for P-state selection can be represented in a
67 platform-independent form in the majority of cases, so it should be possible
68 to use the same performance scaling algorithm implemented in exactly the same
69 way regardless of which scaling driver is used.  Consequently, the same set of
70 scaling governors should be suitable for every supported platform.
71
72 However, that observation may not hold for performance scaling algorithms
73 based on information provided by the hardware itself, for example through
74 feedback registers, as that information is typically specific to the hardware
75 interface it comes from and may not be easily represented in an abstract,
76 platform-independent way.  For this reason, ``CPUFreq`` allows scaling drivers
77 to bypass the governor layer and implement their own performance scaling
78 algorithms.  That is done by the ``intel_pstate`` scaling driver.
79
80
81 ``CPUFreq`` Policy Objects
82 ==========================
83
84 In some cases the hardware interface for P-state control is shared by multiple
85 CPUs.  That is, for example, the same register (or set of registers) is used to
86 control the P-state of multiple CPUs at the same time and writing to it affects
87 all of those CPUs simultaneously.
88
89 Sets of CPUs sharing hardware P-state control interfaces are represented by
90 ``CPUFreq`` as |struct cpufreq_policy| objects.  For consistency,
91 |struct cpufreq_policy| is also used when there is only one CPU in the given
92 set.
93
94 The ``CPUFreq`` core maintains a pointer to a |struct cpufreq_policy| object for
95 every CPU in the system, including CPUs that are currently offline.  If multiple
96 CPUs share the same hardware P-state control interface, all of the pointers
97 corresponding to them point to the same |struct cpufreq_policy| object.
98
99 ``CPUFreq`` uses |struct cpufreq_policy| as its basic data type and the design
100 of its user space interface is based on the policy concept.
101
102
103 CPU Initialization
104 ==================
105
106 First of all, a scaling driver has to be registered for ``CPUFreq`` to work.
107 It is only possible to register one scaling driver at a time, so the scaling
108 driver is expected to be able to handle all CPUs in the system.
109
110 The scaling driver may be registered before or after CPU registration.  If
111 CPUs are registered earlier, the driver core invokes the ``CPUFreq`` core to
112 take a note of all of the already registered CPUs during the registration of the
113 scaling driver.  In turn, if any CPUs are registered after the registration of
114 the scaling driver, the ``CPUFreq`` core will be invoked to take note of them
115 at their registration time.
116
117 In any case, the ``CPUFreq`` core is invoked to take note of any logical CPU it
118 has not seen so far as soon as it is ready to handle that CPU.  [Note that the
119 logical CPU may be a physical single-core processor, or a single core in a
120 multicore processor, or a hardware thread in a physical processor or processor
121 core.  In what follows "CPU" always means "logical CPU" unless explicitly stated
122 otherwise and the word "processor" is used to refer to the physical part
123 possibly including multiple logical CPUs.]
124
125 Once invoked, the ``CPUFreq`` core checks if the policy pointer is already set
126 for the given CPU and if so, it skips the policy object creation.  Otherwise,
127 a new policy object is created and initialized, which involves the creation of
128 a new policy directory in ``sysfs``, and the policy pointer corresponding to
129 the given CPU is set to the new policy object's address in memory.
130
131 Next, the scaling driver's ``->init()`` callback is invoked with the policy
132 pointer of the new CPU passed to it as the argument.  That callback is expected
133 to initialize the performance scaling hardware interface for the given CPU (or,
134 more precisely, for the set of CPUs sharing the hardware interface it belongs
135 to, represented by its policy object) and, if the policy object it has been
136 called for is new, to set parameters of the policy, like the minimum and maximum
137 frequencies supported by the hardware, the table of available frequencies (if
138 the set of supported P-states is not a continuous range), and the mask of CPUs
139 that belong to the same policy (including both online and offline CPUs).  That
140 mask is then used by the core to populate the policy pointers for all of the
141 CPUs in it.
142
143 The next major initialization step for a new policy object is to attach a
144 scaling governor to it (to begin with, that is the default scaling governor
145 determined by the kernel configuration, but it may be changed later
146 via ``sysfs``).  First, a pointer to the new policy object is passed to the
147 governor's ``->init()`` callback which is expected to initialize all of the
148 data structures necessary to handle the given policy and, possibly, to add
149 a governor ``sysfs`` interface to it.  Next, the governor is started by
150 invoking its ``->start()`` callback.
151
152 That callback it expected to register per-CPU utilization update callbacks for
153 all of the online CPUs belonging to the given policy with the CPU scheduler.
154 The utilization update callbacks will be invoked by the CPU scheduler on
155 important events, like task enqueue and dequeue, on every iteration of the
156 scheduler tick or generally whenever the CPU utilization may change (from the
157 scheduler's perspective).  They are expected to carry out computations needed
158 to determine the P-state to use for the given policy going forward and to
159 invoke the scaling driver to make changes to the hardware in accordance with
160 the P-state selection.  The scaling driver may be invoked directly from
161 scheduler context or asynchronously, via a kernel thread or workqueue, depending
162 on the configuration and capabilities of the scaling driver and the governor.
163
164 Similar steps are taken for policy objects that are not new, but were "inactive"
165 previously, meaning that all of the CPUs belonging to them were offline.  The
166 only practical difference in that case is that the ``CPUFreq`` core will attempt
167 to use the scaling governor previously used with the policy that became
168 "inactive" (and is re-initialized now) instead of the default governor.
169
170 In turn, if a previously offline CPU is being brought back online, but some
171 other CPUs sharing the policy object with it are online already, there is no
172 need to re-initialize the policy object at all.  In that case, it only is
173 necessary to restart the scaling governor so that it can take the new online CPU
174 into account.  That is achieved by invoking the governor's ``->stop`` and
175 ``->start()`` callbacks, in this order, for the entire policy.
176
177 As mentioned before, the ``intel_pstate`` scaling driver bypasses the scaling
178 governor layer of ``CPUFreq`` and provides its own P-state selection algorithms.
179 Consequently, if ``intel_pstate`` is used, scaling governors are not attached to
180 new policy objects.  Instead, the driver's ``->setpolicy()`` callback is invoked
181 to register per-CPU utilization update callbacks for each policy.  These
182 callbacks are invoked by the CPU scheduler in the same way as for scaling
183 governors, but in the ``intel_pstate`` case they both determine the P-state to
184 use and change the hardware configuration accordingly in one go from scheduler
185 context.
186
187 The policy objects created during CPU initialization and other data structures
188 associated with them are torn down when the scaling driver is unregistered
189 (which happens when the kernel module containing it is unloaded, for example) or
190 when the last CPU belonging to the given policy in unregistered.
191
192
193 Policy Interface in ``sysfs``
194 =============================
195
196 During the initialization of the kernel, the ``CPUFreq`` core creates a
197 ``sysfs`` directory (kobject) called ``cpufreq`` under
198 :file:`/sys/devices/system/cpu/`.
199
200 That directory contains a ``policyX`` subdirectory (where ``X`` represents an
201 integer number) for every policy object maintained by the ``CPUFreq`` core.
202 Each ``policyX`` directory is pointed to by ``cpufreq`` symbolic links
203 under :file:`/sys/devices/system/cpu/cpuY/` (where ``Y`` represents an integer
204 that may be different from the one represented by ``X``) for all of the CPUs
205 associated with (or belonging to) the given policy.  The ``policyX`` directories
206 in :file:`/sys/devices/system/cpu/cpufreq` each contain policy-specific
207 attributes (files) to control ``CPUFreq`` behavior for the corresponding policy
208 objects (that is, for all of the CPUs associated with them).
209
210 Some of those attributes are generic.  They are created by the ``CPUFreq`` core
211 and their behavior generally does not depend on what scaling driver is in use
212 and what scaling governor is attached to the given policy.  Some scaling drivers
213 also add driver-specific attributes to the policy directories in ``sysfs`` to
214 control policy-specific aspects of driver behavior.
215
216 The generic attributes under :file:`/sys/devices/system/cpu/cpufreq/policyX/`
217 are the following:
218
219 ``affected_cpus``
220         List of online CPUs belonging to this policy (i.e. sharing the hardware
221         performance scaling interface represented by the ``policyX`` policy
222         object).
223
224 ``bios_limit``
225         If the platform firmware (BIOS) tells the OS to apply an upper limit to
226         CPU frequencies, that limit will be reported through this attribute (if
227         present).
228
229         The existence of the limit may be a result of some (often unintentional)
230         BIOS settings, restrictions coming from a service processor or another
231         BIOS/HW-based mechanisms.
232
233         This does not cover ACPI thermal limitations which can be discovered
234         through a generic thermal driver.
235
236         This attribute is not present if the scaling driver in use does not
237         support it.
238
239 ``cpuinfo_max_freq``
240         Maximum possible operating frequency the CPUs belonging to this policy
241         can run at (in kHz).
242
243 ``cpuinfo_min_freq``
244         Minimum possible operating frequency the CPUs belonging to this policy
245         can run at (in kHz).
246
247 ``cpuinfo_transition_latency``
248         The time it takes to switch the CPUs belonging to this policy from one
249         P-state to another, in nanoseconds.
250
251         If unknown or if known to be so high that the scaling driver does not
252         work with the `ondemand`_ governor, -1 (:c:macro:`CPUFREQ_ETERNAL`)
253         will be returned by reads from this attribute.
254
255 ``related_cpus``
256         List of all (online and offline) CPUs belonging to this policy.
257
258 ``scaling_available_governors``
259         List of ``CPUFreq`` scaling governors present in the kernel that can
260         be attached to this policy or (if the ``intel_pstate`` scaling driver is
261         in use) list of scaling algorithms provided by the driver that can be
262         applied to this policy.
263
264         [Note that some governors are modular and it may be necessary to load a
265         kernel module for the governor held by it to become available and be
266         listed by this attribute.]
267
268 ``scaling_cur_freq``
269         Current frequency of all of the CPUs belonging to this policy (in kHz).
270
271         For the majority of scaling drivers, this is the frequency of the last
272         P-state requested by the driver from the hardware using the scaling
273         interface provided by it, which may or may not reflect the frequency
274         the CPU is actually running at (due to hardware design and other
275         limitations).
276
277         Some scaling drivers (e.g. ``intel_pstate``) attempt to provide
278         information more precisely reflecting the current CPU frequency through
279         this attribute, but that still may not be the exact current CPU
280         frequency as seen by the hardware at the moment.
281
282 ``scaling_driver``
283         The scaling driver currently in use.
284
285 ``scaling_governor``
286         The scaling governor currently attached to this policy or (if the
287         ``intel_pstate`` scaling driver is in use) the scaling algorithm
288         provided by the driver that is currently applied to this policy.
289
290         This attribute is read-write and writing to it will cause a new scaling
291         governor to be attached to this policy or a new scaling algorithm
292         provided by the scaling driver to be applied to it (in the
293         ``intel_pstate`` case), as indicated by the string written to this
294         attribute (which must be one of the names listed by the
295         ``scaling_available_governors`` attribute described above).
296
297 ``scaling_max_freq``
298         Maximum frequency the CPUs belonging to this policy are allowed to be
299         running at (in kHz).
300
301         This attribute is read-write and writing a string representing an
302         integer to it will cause a new limit to be set (it must not be lower
303         than the value of the ``scaling_min_freq`` attribute).
304
305 ``scaling_min_freq``
306         Minimum frequency the CPUs belonging to this policy are allowed to be
307         running at (in kHz).
308
309         This attribute is read-write and writing a string representing a
310         non-negative integer to it will cause a new limit to be set (it must not
311         be higher than the value of the ``scaling_max_freq`` attribute).
312
313 ``scaling_setspeed``
314         This attribute is functional only if the `userspace`_ scaling governor
315         is attached to the given policy.
316
317         It returns the last frequency requested by the governor (in kHz) or can
318         be written to in order to set a new frequency for the policy.
319
320
321 Generic Scaling Governors
322 =========================
323
324 ``CPUFreq`` provides generic scaling governors that can be used with all
325 scaling drivers.  As stated before, each of them implements a single, possibly
326 parametrized, performance scaling algorithm.
327
328 Scaling governors are attached to policy objects and different policy objects
329 can be handled by different scaling governors at the same time (although that
330 may lead to suboptimal results in some cases).
331
332 The scaling governor for a given policy object can be changed at any time with
333 the help of the ``scaling_governor`` policy attribute in ``sysfs``.
334
335 Some governors expose ``sysfs`` attributes to control or fine-tune the scaling
336 algorithms implemented by them.  Those attributes, referred to as governor
337 tunables, can be either global (system-wide) or per-policy, depending on the
338 scaling driver in use.  If the driver requires governor tunables to be
339 per-policy, they are located in a subdirectory of each policy directory.
340 Otherwise, they are located in a subdirectory under
341 :file:`/sys/devices/system/cpu/cpufreq/`.  In either case the name of the
342 subdirectory containing the governor tunables is the name of the governor
343 providing them.
344
345 ``performance``
346 ---------------
347
348 When attached to a policy object, this governor causes the highest frequency,
349 within the ``scaling_max_freq`` policy limit, to be requested for that policy.
350
351 The request is made once at that time the governor for the policy is set to
352 ``performance`` and whenever the ``scaling_max_freq`` or ``scaling_min_freq``
353 policy limits change after that.
354
355 ``powersave``
356 -------------
357
358 When attached to a policy object, this governor causes the lowest frequency,
359 within the ``scaling_min_freq`` policy limit, to be requested for that policy.
360
361 The request is made once at that time the governor for the policy is set to
362 ``powersave`` and whenever the ``scaling_max_freq`` or ``scaling_min_freq``
363 policy limits change after that.
364
365 ``userspace``
366 -------------
367
368 This governor does not do anything by itself.  Instead, it allows user space
369 to set the CPU frequency for the policy it is attached to by writing to the
370 ``scaling_setspeed`` attribute of that policy.
371
372 ``schedutil``
373 -------------
374
375 This governor uses CPU utilization data available from the CPU scheduler.  It
376 generally is regarded as a part of the CPU scheduler, so it can access the
377 scheduler's internal data structures directly.
378
379 It runs entirely in scheduler context, although in some cases it may need to
380 invoke the scaling driver asynchronously when it decides that the CPU frequency
381 should be changed for a given policy (that depends on whether or not the driver
382 is capable of changing the CPU frequency from scheduler context).
383
384 The actions of this governor for a particular CPU depend on the scheduling class
385 invoking its utilization update callback for that CPU.  If it is invoked by the
386 RT or deadline scheduling classes, the governor will increase the frequency to
387 the allowed maximum (that is, the ``scaling_max_freq`` policy limit).  In turn,
388 if it is invoked by the CFS scheduling class, the governor will use the
389 Per-Entity Load Tracking (PELT) metric for the root control group of the
390 given CPU as the CPU utilization estimate (see the `Per-entity load tracking`_
391 LWN.net article for a description of the PELT mechanism).  Then, the new
392 CPU frequency to apply is computed in accordance with the formula
393
394         f = 1.25 * ``f_0`` * ``util`` / ``max``
395
396 where ``util`` is the PELT number, ``max`` is the theoretical maximum of
397 ``util``, and ``f_0`` is either the maximum possible CPU frequency for the given
398 policy (if the PELT number is frequency-invariant), or the current CPU frequency
399 (otherwise).
400
401 This governor also employs a mechanism allowing it to temporarily bump up the
402 CPU frequency for tasks that have been waiting on I/O most recently, called
403 "IO-wait boosting".  That happens when the :c:macro:`SCHED_CPUFREQ_IOWAIT` flag
404 is passed by the scheduler to the governor callback which causes the frequency
405 to go up to the allowed maximum immediately and then draw back to the value
406 returned by the above formula over time.
407
408 This governor exposes only one tunable:
409
410 ``rate_limit_us``
411         Minimum time (in microseconds) that has to pass between two consecutive
412         runs of governor computations (default: 1000 times the scaling driver's
413         transition latency).
414
415         The purpose of this tunable is to reduce the scheduler context overhead
416         of the governor which might be excessive without it.
417
418 This governor generally is regarded as a replacement for the older `ondemand`_
419 and `conservative`_ governors (described below), as it is simpler and more
420 tightly integrated with the CPU scheduler, its overhead in terms of CPU context
421 switches and similar is less significant, and it uses the scheduler's own CPU
422 utilization metric, so in principle its decisions should not contradict the
423 decisions made by the other parts of the scheduler.
424
425 ``ondemand``
426 ------------
427
428 This governor uses CPU load as a CPU frequency selection metric.
429
430 In order to estimate the current CPU load, it measures the time elapsed between
431 consecutive invocations of its worker routine and computes the fraction of that
432 time in which the given CPU was not idle.  The ratio of the non-idle (active)
433 time to the total CPU time is taken as an estimate of the load.
434
435 If this governor is attached to a policy shared by multiple CPUs, the load is
436 estimated for all of them and the greatest result is taken as the load estimate
437 for the entire policy.
438
439 The worker routine of this governor has to run in process context, so it is
440 invoked asynchronously (via a workqueue) and CPU P-states are updated from
441 there if necessary.  As a result, the scheduler context overhead from this
442 governor is minimum, but it causes additional CPU context switches to happen
443 relatively often and the CPU P-state updates triggered by it can be relatively
444 irregular.  Also, it affects its own CPU load metric by running code that
445 reduces the CPU idle time (even though the CPU idle time is only reduced very
446 slightly by it).
447
448 It generally selects CPU frequencies proportional to the estimated load, so that
449 the value of the ``cpuinfo_max_freq`` policy attribute corresponds to the load of
450 1 (or 100%), and the value of the ``cpuinfo_min_freq`` policy attribute
451 corresponds to the load of 0, unless when the load exceeds a (configurable)
452 speedup threshold, in which case it will go straight for the highest frequency
453 it is allowed to use (the ``scaling_max_freq`` policy limit).
454
455 This governor exposes the following tunables:
456
457 ``sampling_rate``
458         This is how often the governor's worker routine should run, in
459         microseconds.
460
461         Typically, it is set to values of the order of 10000 (10 ms).  Its
462         default value is equal to the value of ``cpuinfo_transition_latency``
463         for each policy this governor is attached to (but since the unit here
464         is greater by 1000, this means that the time represented by
465         ``sampling_rate`` is 1000 times greater than the transition latency by
466         default).
467
468         If this tunable is per-policy, the following shell command sets the time
469         represented by it to be 750 times as high as the transition latency::
470
471         # echo `$(($(cat cpuinfo_transition_latency) * 750 / 1000)) > ondemand/sampling_rate
472
473
474 ``min_sampling_rate``
475         The minimum value of ``sampling_rate``.
476
477         Equal to 10000 (10 ms) if :c:macro:`CONFIG_NO_HZ_COMMON` and
478         :c:data:`tick_nohz_active` are both set or to 20 times the value of
479         :c:data:`jiffies` in microseconds otherwise.
480
481 ``up_threshold``
482         If the estimated CPU load is above this value (in percent), the governor
483         will set the frequency to the maximum value allowed for the policy.
484         Otherwise, the selected frequency will be proportional to the estimated
485         CPU load.
486
487 ``ignore_nice_load``
488         If set to 1 (default 0), it will cause the CPU load estimation code to
489         treat the CPU time spent on executing tasks with "nice" levels greater
490         than 0 as CPU idle time.
491
492         This may be useful if there are tasks in the system that should not be
493         taken into account when deciding what frequency to run the CPUs at.
494         Then, to make that happen it is sufficient to increase the "nice" level
495         of those tasks above 0 and set this attribute to 1.
496
497 ``sampling_down_factor``
498         Temporary multiplier, between 1 (default) and 100 inclusive, to apply to
499         the ``sampling_rate`` value if the CPU load goes above ``up_threshold``.
500
501         This causes the next execution of the governor's worker routine (after
502         setting the frequency to the allowed maximum) to be delayed, so the
503         frequency stays at the maximum level for a longer time.
504
505         Frequency fluctuations in some bursty workloads may be avoided this way
506         at the cost of additional energy spent on maintaining the maximum CPU
507         capacity.
508
509 ``powersave_bias``
510         Reduction factor to apply to the original frequency target of the
511         governor (including the maximum value used when the ``up_threshold``
512         value is exceeded by the estimated CPU load) or sensitivity threshold
513         for the AMD frequency sensitivity powersave bias driver
514         (:file:`drivers/cpufreq/amd_freq_sensitivity.c`), between 0 and 1000
515         inclusive.
516
517         If the AMD frequency sensitivity powersave bias driver is not loaded,
518         the effective frequency to apply is given by
519
520                 f * (1 - ``powersave_bias`` / 1000)
521
522         where f is the governor's original frequency target.  The default value
523         of this attribute is 0 in that case.
524
525         If the AMD frequency sensitivity powersave bias driver is loaded, the
526         value of this attribute is 400 by default and it is used in a different
527         way.
528
529         On Family 16h (and later) AMD processors there is a mechanism to get a
530         measured workload sensitivity, between 0 and 100% inclusive, from the
531         hardware.  That value can be used to estimate how the performance of the
532         workload running on a CPU will change in response to frequency changes.
533
534         The performance of a workload with the sensitivity of 0 (memory-bound or
535         IO-bound) is not expected to increase at all as a result of increasing
536         the CPU frequency, whereas workloads with the sensitivity of 100%
537         (CPU-bound) are expected to perform much better if the CPU frequency is
538         increased.
539
540         If the workload sensitivity is less than the threshold represented by
541         the ``powersave_bias`` value, the sensitivity powersave bias driver
542         will cause the governor to select a frequency lower than its original
543         target, so as to avoid over-provisioning workloads that will not benefit
544         from running at higher CPU frequencies.
545
546 ``conservative``
547 ----------------
548
549 This governor uses CPU load as a CPU frequency selection metric.
550
551 It estimates the CPU load in the same way as the `ondemand`_ governor described
552 above, but the CPU frequency selection algorithm implemented by it is different.
553
554 Namely, it avoids changing the frequency significantly over short time intervals
555 which may not be suitable for systems with limited power supply capacity (e.g.
556 battery-powered).  To achieve that, it changes the frequency in relatively
557 small steps, one step at a time, up or down - depending on whether or not a
558 (configurable) threshold has been exceeded by the estimated CPU load.
559
560 This governor exposes the following tunables:
561
562 ``freq_step``
563         Frequency step in percent of the maximum frequency the governor is
564         allowed to set (the ``scaling_max_freq`` policy limit), between 0 and
565         100 (5 by default).
566
567         This is how much the frequency is allowed to change in one go.  Setting
568         it to 0 will cause the default frequency step (5 percent) to be used
569         and setting it to 100 effectively causes the governor to periodically
570         switch the frequency between the ``scaling_min_freq`` and
571         ``scaling_max_freq`` policy limits.
572
573 ``down_threshold``
574         Threshold value (in percent, 20 by default) used to determine the
575         frequency change direction.
576
577         If the estimated CPU load is greater than this value, the frequency will
578         go up (by ``freq_step``).  If the load is less than this value (and the
579         ``sampling_down_factor`` mechanism is not in effect), the frequency will
580         go down.  Otherwise, the frequency will not be changed.
581
582 ``sampling_down_factor``
583         Frequency decrease deferral factor, between 1 (default) and 10
584         inclusive.
585
586         It effectively causes the frequency to go down ``sampling_down_factor``
587         times slower than it ramps up.
588
589
590 Frequency Boost Support
591 =======================
592
593 Background
594 ----------
595
596 Some processors support a mechanism to raise the operating frequency of some
597 cores in a multicore package temporarily (and above the sustainable frequency
598 threshold for the whole package) under certain conditions, for example if the
599 whole chip is not fully utilized and below its intended thermal or power budget.
600
601 Different names are used by different vendors to refer to this functionality.
602 For Intel processors it is referred to as "Turbo Boost", AMD calls it
603 "Turbo-Core" or (in technical documentation) "Core Performance Boost" and so on.
604 As a rule, it also is implemented differently by different vendors.  The simple
605 term "frequency boost" is used here for brevity to refer to all of those
606 implementations.
607
608 The frequency boost mechanism may be either hardware-based or software-based.
609 If it is hardware-based (e.g. on x86), the decision to trigger the boosting is
610 made by the hardware (although in general it requires the hardware to be put
611 into a special state in which it can control the CPU frequency within certain
612 limits).  If it is software-based (e.g. on ARM), the scaling driver decides
613 whether or not to trigger boosting and when to do that.
614
615 The ``boost`` File in ``sysfs``
616 -------------------------------
617
618 This file is located under :file:`/sys/devices/system/cpu/cpufreq/` and controls
619 the "boost" setting for the whole system.  It is not present if the underlying
620 scaling driver does not support the frequency boost mechanism (or supports it,
621 but provides a driver-specific interface for controlling it, like
622 ``intel_pstate``).
623
624 If the value in this file is 1, the frequency boost mechanism is enabled.  This
625 means that either the hardware can be put into states in which it is able to
626 trigger boosting (in the hardware-based case), or the software is allowed to
627 trigger boosting (in the software-based case).  It does not mean that boosting
628 is actually in use at the moment on any CPUs in the system.  It only means a
629 permission to use the frequency boost mechanism (which still may never be used
630 for other reasons).
631
632 If the value in this file is 0, the frequency boost mechanism is disabled and
633 cannot be used at all.
634
635 The only values that can be written to this file are 0 and 1.
636
637 Rationale for Boost Control Knob
638 --------------------------------
639
640 The frequency boost mechanism is generally intended to help to achieve optimum
641 CPU performance on time scales below software resolution (e.g. below the
642 scheduler tick interval) and it is demonstrably suitable for many workloads, but
643 it may lead to problems in certain situations.
644
645 For this reason, many systems make it possible to disable the frequency boost
646 mechanism in the platform firmware (BIOS) setup, but that requires the system to
647 be restarted for the setting to be adjusted as desired, which may not be
648 practical at least in some cases.  For example:
649
650   1. Boosting means overclocking the processor, although under controlled
651      conditions.  Generally, the processor's energy consumption increases
652      as a result of increasing its frequency and voltage, even temporarily.
653      That may not be desirable on systems that switch to power sources of
654      limited capacity, such as batteries, so the ability to disable the boost
655      mechanism while the system is running may help there (but that depends on
656      the workload too).
657
658   2. In some situations deterministic behavior is more important than
659      performance or energy consumption (or both) and the ability to disable
660      boosting while the system is running may be useful then.
661
662   3. To examine the impact of the frequency boost mechanism itself, it is useful
663      to be able to run tests with and without boosting, preferably without
664      restarting the system in the meantime.
665
666   4. Reproducible results are important when running benchmarks.  Since
667      the boosting functionality depends on the load of the whole package,
668      single-thread performance may vary because of it which may lead to
669      unreproducible results sometimes.  That can be avoided by disabling the
670      frequency boost mechanism before running benchmarks sensitive to that
671      issue.
672
673 Legacy AMD ``cpb`` Knob
674 -----------------------
675
676 The AMD powernow-k8 scaling driver supports a ``sysfs`` knob very similar to
677 the global ``boost`` one.  It is used for disabling/enabling the "Core
678 Performance Boost" feature of some AMD processors.
679
680 If present, that knob is located in every ``CPUFreq`` policy directory in
681 ``sysfs`` (:file:`/sys/devices/system/cpu/cpufreq/policyX/`) and is called
682 ``cpb``, which indicates a more fine grained control interface.  The actual
683 implementation, however, works on the system-wide basis and setting that knob
684 for one policy causes the same value of it to be set for all of the other
685 policies at the same time.
686
687 That knob is still supported on AMD processors that support its underlying
688 hardware feature, but it may be configured out of the kernel (via the
689 :c:macro:`CONFIG_X86_ACPI_CPUFREQ_CPB` configuration option) and the global
690 ``boost`` knob is present regardless.  Thus it is always possible use the
691 ``boost`` knob instead of the ``cpb`` one which is highly recommended, as that
692 is more consistent with what all of the other systems do (and the ``cpb`` knob
693 may not be supported any more in the future).
694
695 The ``cpb`` knob is never present for any processors without the underlying
696 hardware feature (e.g. all Intel ones), even if the
697 :c:macro:`CONFIG_X86_ACPI_CPUFREQ_CPB` configuration option is set.
698
699
700 .. _Per-entity load tracking: https://lwn.net/Articles/531853/