admin-guide/pm/cpufreq.rst

19 different clock frequency and voltage configurations, often referred to as
28 In some situations it is desirable or even necessary to run the program as fast
29 as possible and then there is no reason to use any P-states different from the
31 available).  In some other cases, however, it may not be necessary to execute
34 It also may not be physically possible to maintain maximum CPU capacity for too
35 long for thermal or power supply capacity reasons or similar.  To cover those
36 cases, there are hardware interfaces allowing CPUs to be switched between
37 different frequency/voltage configurations or (in the ACPI terminology) to be
40 Typically, they are used along with algorithms to estimate the required CPU
41 capacity, so as to decide which P-states to put the CPUs into.  Of course, since
42 the utilization of the system generally changes over time, that has to be done
44 to as CPU performance scaling or CPU frequency scaling (because it involves
59 Scaling governors implement algorithms to estimate the required CPU capacity.
63 Scaling drivers talk to the hardware.  They provide scaling governors with
65 access platform-specific hardware interfaces to change CPU P-states as requested
72 to use the same performance scaling algorithm implemented in exactly the same
78 feedback registers, as that information is typically specific to the hardware
81 to bypass the governor layer and implement their own performance scaling
89 CPUs.  That is, for example, the same register (or set of registers) is used to
90 control the P-state of multiple CPUs at the same time and writing to it affects
98 The ``CPUFreq`` core maintains a pointer to a struct cpufreq_policy object for
101 corresponding to them point to the same struct cpufreq_policy object.
110 First of all, a scaling driver has to be registered for ``CPUFreq`` to work.
111 It is only possible to register one scaling driver at a time, so the scaling
112 driver is expected to be able to handle all CPUs in the system.
115 CPUs are registered earlier, the driver core invokes the ``CPUFreq`` core to
118 the scaling driver, the ``CPUFreq`` core will be invoked to take note of them
121 In any case, the ``CPUFreq`` core is invoked to take note of any logical CPU it
122 has not seen so far as soon as it is ready to handle that CPU.  [Note that the
126 otherwise and the word "processor" is used to refer to the physical part
132 a new policy directory in ``sysfs``, and the policy pointer corresponding to
133 the given CPU is set to the new policy object's address in memory.
136 pointer of the new CPU passed to it as the argument.  That callback is expected
137 to initialize the performance scaling hardware interface for the given CPU (or,
139 to, represented by its policy object) and, if the policy object it has been
140 called for is new, to set parameters of the policy, like the minimum and maximum
143 that belong to the same policy (including both online and offline CPUs).  That
144 mask is then used by the core to populate the policy pointers for all of the
147 The next major initialization step for a new policy object is to attach a
148 scaling governor to it (to begin with, that is the default scaling governor
150 later via ``sysfs``).  First, a pointer to the new policy object is passed to
151 the governor's ``->init()`` callback which is expected to initialize all of the
152 data structures necessary to handle the given policy and, possibly, to add
153 a governor ``sysfs`` interface to it.  Next, the governor is started by
156 That callback is expected to register per-CPU utilization update callbacks for
157 all of the online CPUs belonging to the given policy with the CPU scheduler.
161 scheduler's perspective).  They are expected to carry out computations needed
162 to determine the P-state to use for the given policy going forward and to
163 invoke the scaling driver to make changes to the hardware in accordance with
169 previously, meaning that all of the CPUs belonging to them were offline.  The
171 to use the scaling governor previously used with the policy that became
176 need to re-initialize the policy object at all.  In that case, it only is
177 necessary to restart the scaling governor so that it can take the new online CPU
183 Consequently, if |intel_pstate| is used, scaling governors are not attached to
185 to register per-CPU utilization update callbacks for each policy.  These
187 governors, but in the |intel_pstate| case they both determine the P-state to
194 when the last CPU belonging to the given policy in unregistered.
206 Each ``policyX`` directory is pointed to by ``cpufreq`` symbolic links
209 associated with (or belonging to) the given policy.  The ``policyX`` directories
211 attributes (files) to control ``CPUFreq`` behavior for the corresponding policy
216 and what scaling governor is attached to the given policy.  Some scaling drivers
217 also add driver-specific attributes to the policy directories in ``sysfs`` to
224 	List of online CPUs belonging to this policy (i.e. sharing the hardware
229 	If the platform firmware (BIOS) tells the OS to apply an upper limit to
244 	Current frequency of the CPUs belonging to this policy as obtained from
247 	This is expected to be the frequency the hardware actually runs at.
252 	Maximum possible operating frequency the CPUs belonging to this policy
256 	Minimum possible operating frequency the CPUs belonging to this policy
260 	The time it takes to switch the CPUs belonging to this policy from one
261 	P-state to another, in nanoseconds.
263 	If unknown or if known to be so high that the scaling driver does not
268 	List of all (online and offline) CPUs belonging to this policy.
272 	be attached to this policy or (if the |intel_pstate| scaling driver is
274 	applied to this policy.
276 	[Note that some governors are modular and it may be necessary to load a
277 	kernel module for the governor held by it to become available and be
281 	Current frequency of all of the CPUs belonging to this policy (in kHz).
286 	the CPU is actually running at (due to hardware design and other
289 	Some architectures (e.g. ``x86``) may attempt to provide information
298 	The scaling governor currently attached to this policy or (if the
300 	provided by the driver that is currently applied to this policy.
302 	This attribute is read-write and writing to it will cause a new scaling
303 	governor to be attached to this policy or a new scaling algorithm
304 	provided by the scaling driver to be applied to it (in the
305 	|intel_pstate| case), as indicated by the string written to this
310 	Maximum frequency the CPUs belonging to this policy are allowed to be
314 	integer to it will cause a new limit to be set (it must not be lower
318 	Minimum frequency the CPUs belonging to this policy are allowed to be
322 	non-negative integer to it will cause a new limit to be set (it must not
327 	is attached to the given policy.
330 	be written to in order to set a new frequency for the policy.
340 Scaling governors are attached to policy objects and different policy objects
342 may lead to suboptimal results in some cases).
347 Some governors expose ``sysfs`` attributes to control or fine-tune the scaling
348 algorithms implemented by them.  Those attributes, referred to as governor
350 scaling driver in use.  If the driver requires governor tunables to be
360 When attached to a policy object, this governor causes the highest frequency,
361 within the ``scaling_max_freq`` policy limit, to be requested for that policy.
363 The request is made once at that time the governor for the policy is set to
370 When attached to a policy object, this governor causes the lowest frequency,
371 within the ``scaling_min_freq`` policy limit, to be requested for that policy.
373 The request is made once at that time the governor for the policy is set to
381 to set the CPU frequency for the policy it is attached to by writing to the
391 It runs entirely in scheduler context, although in some cases it may need to
398 RT or deadline scheduling classes, the governor will increase the frequency to
404 CPU frequency to apply is computed in accordance with the formula
413 This governor also employs a mechanism allowing it to temporarily bump up the
416 is passed by the scheduler to the governor callback which causes the frequency
417 to go up to the allowed maximum immediately and then draw back to the value
423 	Minimum time (in microseconds) that has to pass between two consecutive
427 	The purpose of this tunable is to reduce the scheduler context overhead
442 In order to estimate the current CPU load, it measures the time elapsed between
445 time to the total CPU time is taken as an estimate of the load.
447 If this governor is attached to a policy shared by multiple CPUs, the load is
451 The worker routine of this governor has to run in process context, so it is
454 governor is minimum, but it causes additional CPU context switches to happen
460 It generally selects CPU frequencies proportional to the estimated load, so that
461 the value of the ``cpuinfo_max_freq`` policy attribute corresponds to the load of
463 corresponds to the load of 0, unless when the load exceeds a (configurable)
465 it is allowed to use (the ``scaling_max_freq`` policy limit).
473 	Typically, it is set to values of the order of 10000 (10 ms).  Its
474 	default value is equal to the value of ``cpuinfo_transition_latency``
475 	for each policy this governor is attached to (but since the unit here
481 	represented by it to be 750 times as high as the transition latency::
487 	will set the frequency to the maximum value allowed for the policy.
488 	Otherwise, the selected frequency will be proportional to the estimated
492 	If set to 1 (default 0), it will cause the CPU load estimation code to
497 	taken into account when deciding what frequency to run the CPUs at.
498 	Then, to make that happen it is sufficient to increase the "nice" level
499 	of those tasks above 0 and set this attribute to 1.
502 	Temporary multiplier, between 1 (default) and 100 inclusive, to apply to
506 	setting the frequency to the allowed maximum) to be delayed, so the
514 	Reduction factor to apply to the original frequency target of the
522 	the effective frequency to apply is given by
533 	On Family 16h (and later) AMD processors there is a mechanism to get a
535 	hardware.  That value can be used to estimate how the performance of the
536 	workload running on a CPU will change in response to frequency changes.
539 	IO-bound) is not expected to increase at all as a result of increasing
541 	(CPU-bound) are expected to perform much better if the CPU frequency is
546 	will cause the governor to select a frequency lower than its original
547 	target, so as to avoid over-provisioning workloads that will not benefit
560 battery-powered).  To achieve that, it changes the frequency in relatively
568 	allowed to set (the ``scaling_max_freq`` policy limit), between 0 and
571 	This is how much the frequency is allowed to change in one go.  Setting
572 	it to 0 will cause the default frequency step (5 percent) to be used
573 	and setting it to 100 effectively causes the governor to periodically
578 	Threshold value (in percent, 20 by default) used to determine the
590 	It effectively causes the frequency to go down ``sampling_down_factor``
600 Some processors support a mechanism to raise the operating frequency of some
605 Different names are used by different vendors to refer to this functionality.
606 For Intel processors it is referred to as "Turbo Boost", AMD calls it
609 term "frequency boost" is used here for brevity to refer to all of those
613 If it is hardware-based (e.g. on x86), the decision to trigger the boosting is
614 made by the hardware (although in general it requires the hardware to be put
617 whether or not to trigger boosting and when to do that.
629 means that either the hardware can be put into states in which it is able to
630 trigger boosting (in the hardware-based case), or the software is allowed to
633 permission to use the frequency boost mechanism (which still may never be used
639 The only values that can be written to this file are 0 and 1.
644 The frequency boost mechanism is generally intended to help to achieve optimum
647 it may lead to problems in certain situations.
649 For this reason, many systems make it possible to disable the frequency boost
650 mechanism in the platform firmware (BIOS) setup, but that requires the system to
651 be restarted for the setting to be adjusted as desired, which may not be
657      That may not be desirable on systems that switch to power sources of
658      limited capacity, such as batteries, so the ability to disable the boost
663      performance or energy consumption (or both) and the ability to disable
666   3. To examine the impact of the frequency boost mechanism itself, it is useful
667      to be able to run tests with and without boosting, preferably without
672      single-thread performance may vary because of it which may lead to
674      frequency boost mechanism before running benchmarks sensitive to that
680 The AMD powernow-k8 scaling driver supports a ``sysfs`` knob very similar to
688 for one policy causes the same value of it to be set for all of the other