admin-guide/pm/cpufreq.rst

1 .. SPDX-License-Identifier: GPL-2.0
20 Operating Performance Points or P-states (in ACPI terminology).  As a rule,
24 time (or the more power is drawn) by the CPU in the given P-state.  Therefore
29 as possible and then there is no reason to use any P-states different from the
30 highest one (i.e. the highest-performance frequency/voltage configuration
38 put into different P-states.
41 capacity, so as to decide which P-states to put the CPUs into.  Of course, since
64 information on the available P-states (or P-state ranges in some cases) and
65 access platform-specific hardware interfaces to change CPU P-states as requested
70 performance scaling algorithms for P-state selection can be represented in a
71 platform-independent form in the majority of cases, so it should be possible
80 platform-independent way.  For this reason, ``CPUFreq`` allows scaling drivers
88 In some cases the hardware interface for P-state control is shared by multiple
90 control the P-state of multiple CPUs at the same time and writing to it affects
93 Sets of CPUs sharing hardware P-state control interfaces are represented by
100 CPUs share the same hardware P-state control interface, all of the pointers
123 logical CPU may be a physical single-core processor, or a single core in a
135 Next, the scaling driver's ``->init()`` callback is invoked with the policy
142 the set of supported P-states is not a continuous range), and the mask of CPUs
151 the governor's ``->init()`` callback which is expected to initialize all of the
154 invoking its ``->start()`` callback.
156 That callback is expected to register per-CPU utilization update callbacks for
162 to determine the P-state to use for the given policy going forward and to
164 the P-state selection.  The scaling driver may be invoked directly from
172 "inactive" (and is re-initialized now) instead of the default governor.
176 need to re-initialize the policy object at all.  In that case, it only is
178 into account.  That is achieved by invoking the governor's ``->stop`` and
179 ``->start()`` callbacks, in this order, for the entire policy.
182 governor layer of ``CPUFreq`` and provides its own P-state selection algorithms.
184 new policy objects.  Instead, the driver's ``->setpolicy()`` callback is invoked
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
210 in :file:`/sys/devices/system/cpu/cpufreq` each contain policy-specific
217 also add driver-specific attributes to the policy directories in ``sysfs`` to
218 control policy-specific aspects of driver behavior.
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
233 	The existence of the limit may be a result of some (often unintentional)
235 	BIOS/HW-based mechanisms.
244 	Current frequency of the CPUs belonging to this policy as obtained from
261         Note, that failed attempt to retrieve current frequency for a given
275 	P-state to another, in nanoseconds.
278 	work with the `ondemand`_ governor, -1 (:c:macro:`CPUFREQ_ETERNAL`)
299 	Current frequency of all of the CPUs belonging to this policy (in kHz).
301 	In the majority of cases, this is the frequency of the last P-state
308 	more precisely reflecting the current CPU frequency through this
309 	attribute, but that still may not be the exact current CPU frequency as
321 	This attribute is read-write and writing to it will cause a new scaling
332 	This attribute is read-write and writing a string representing an
333 	integer to it will cause a new limit to be set (it must not be lower
340 	This attribute is read-write and writing a string representing a
341 	non-negative integer to it will cause a new limit to be set (it must not
366 Some governors expose ``sysfs`` attributes to control or fine-tune the scaling
368 tunables, can be either global (system-wide) or per-policy, depending on the
370 per-policy, they are located in a subdirectory of each policy directory.
377 ---------------
380 within the ``scaling_max_freq`` policy limit, to be requested for that policy.
387 -------------
390 within the ``scaling_min_freq`` policy limit, to be requested for that policy.
397 -------------
404 -------------
418 the allowed maximum (that is, the ``scaling_max_freq`` policy limit).  In turn,
420 Per-Entity Load Tracking (PELT) metric for the root control group of the
421 given CPU as the CPU utilization estimate (see the *Per-entity load tracking*
429 policy (if the PELT number is frequency-invariant), or the current CPU frequency
434 "IO-wait boosting".  That happens when the :c:macro:`SCHED_CPUFREQ_IOWAIT` flag
457 ------------
461 In order to estimate the current CPU load, it measures the time elapsed between
463 time in which the given CPU was not idle.  The ratio of the non-idle (active)
471 invoked asynchronously (via a workqueue) and CPU P-states are updated from
474 relatively often and the CPU P-state updates triggered by it can be relatively
484 it is allowed to use (the ``scaling_max_freq`` policy limit).
498 	If this tunable is per-policy, the following shell command sets the time
543 		f * (1 - ``powersave_bias`` / 1000)
557 	The performance of a workload with the sensitivity of 0 (memory-bound or
558 	IO-bound) is not expected to increase at all as a result of increasing
560 	(CPU-bound) are expected to perform much better if the CPU frequency is
566 	target, so as to avoid over-provisioning workloads that will not benefit
570 ----------------
579 battery-powered).  To achieve that, it changes the frequency in relatively
580 small steps, one step at a time, up or down - depending on whether or not a
587 	allowed to set (the ``scaling_max_freq`` policy limit), between 0 and
613 Frequency Boost Support
617 ----------
625 For Intel processors it is referred to as "Turbo Boost", AMD calls it
626 "Turbo-Core" or (in technical documentation) "Core Performance Boost" and so on.
628 term "frequency boost" is used here for brevity to refer to all of those
631 The frequency boost mechanism may be either hardware-based or software-based.
632 If it is hardware-based (e.g. on x86), the decision to trigger the boosting is
635 limits).  If it is software-based (e.g. on ARM), the scaling driver decides
638 The ``boost`` File in ``sysfs``
639 -------------------------------
642 the "boost" setting for the whole system.  It is not present if the underlying
643 scaling driver does not support the frequency boost mechanism (or supports it,
644 but provides a driver-specific interface for controlling it, like
647 If the value in this file is 1, the frequency boost mechanism is enabled.  This
649 trigger boosting (in the hardware-based case), or the software is allowed to
650 trigger boosting (in the software-based case).  It does not mean that boosting
652 permission to use the frequency boost mechanism (which still may never be used
655 If the value in this file is 0, the frequency boost mechanism is disabled and
660 Rationale for Boost Control Knob
661 --------------------------------
663 The frequency boost mechanism is generally intended to help to achieve optimum
668 For this reason, many systems make it possible to disable the frequency boost
677      limited capacity, such as batteries, so the ability to disable the boost
685   3. To examine the impact of the frequency boost mechanism itself, it is useful
691      single-thread performance may vary because of it which may lead to
693      frequency boost mechanism before running benchmarks sensitive to that
697 -----------------------
699 The AMD powernow-k8 scaling driver supports a ``sysfs`` knob very similar to
700 the global ``boost`` one.  It is used for disabling/enabling the "Core
701 Performance Boost" feature of some AMD processors.
706 implementation, however, works on the system-wide basis and setting that knob
713 ``boost`` knob is present regardless.  Thus it is always possible use the
714 ``boost`` knob instead of the ``cpb`` one which is highly recommended, as that
726 .. [1] Jonathan Corbet, *Per-entity load tracking*,