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