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
34 It also may not be physically possible to maintain maximum CPU capacity for too
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
140 called for is new, to set parameters of the policy, like the minimum and maximum
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.
235 	BIOS/HW-based mechanisms.
252 	Maximum possible operating frequency the CPUs belonging to this policy
261 	P-state to another, in nanoseconds.
264 	work with the `ondemand`_ governor, -1 (:c:macro:`CPUFREQ_ETERNAL`)
283 	In the majority of cases, this is the frequency of the last P-state
302 	This attribute is read-write and writing to it will cause a new scaling
310 	Maximum frequency the CPUs belonging to this policy are allowed to be
313 	This attribute is read-write and writing a string representing an
321 	This attribute is read-write and writing a string representing a
322 	non-negative integer to it will cause a new limit to be set (it must not
347 Some governors expose ``sysfs`` attributes to control or fine-tune the scaling
349 tunables, can be either global (system-wide) or per-policy, depending on the
351 per-policy, they are located in a subdirectory of each policy directory.
358 ---------------
368 -------------
378 -------------
385 -------------
399 the allowed maximum (that is, the ``scaling_max_freq`` policy limit).  In turn,
401 Per-Entity Load Tracking (PELT) metric for the root control group of the
402 given CPU as the CPU utilization estimate (see the *Per-entity load tracking*
408 where ``util`` is the PELT number, ``max`` is the theoretical maximum of
409 ``util``, and ``f_0`` is either the maximum possible CPU frequency for the given
410 policy (if the PELT number is frequency-invariant), or the current CPU frequency
415 "IO-wait boosting".  That happens when the :c:macro:`SCHED_CPUFREQ_IOWAIT` flag
417 to go up to the allowed maximum immediately and then draw back to the value
438 ------------
444 time in which the given CPU was not idle.  The ratio of the non-idle (active)
452 invoked asynchronously (via a workqueue) and CPU P-states are updated from
455 relatively often and the CPU P-state updates triggered by it can be relatively
480 	If this tunable is per-policy, the following shell command sets the time
487 	will set the frequency to the maximum value allowed for the policy.
506 	setting the frequency to the allowed maximum) to be delayed, so the
507 	frequency stays at the maximum level for a longer time.
510 	at the cost of additional energy spent on maintaining the maximum CPU
515 	governor (including the maximum value used when the ``up_threshold``
524 		f * (1 - ``powersave_bias`` / 1000)
538 	The performance of a workload with the sensitivity of 0 (memory-bound or
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
547 	target, so as to avoid over-provisioning workloads that will not benefit
551 ----------------
560 battery-powered).  To achieve that, it changes the frequency in relatively
561 small steps, one step at a time, up or down - depending on whether or not a
567 	Frequency step in percent of the maximum frequency the governor is
594 ----------------
596 The CPUfreq governor `interactive` is designed for latency-sensitive,
597 interactive workloads. This governor sets the CPU speed depending on
604         When speed is at or above hispeed_freq, wait for
605         this long before raising speed in response to continued high load.
613         uses delay 80000 uS until CPU speed 1.3 GHz, at which speed delay
614         200000 uS is used until speed 1.5 GHz, at which speed (and above)
619         If non-zero, immediately boost speed of all CPUs to at least
625         On each write, immediately boost speed of all CPUs to
628         hispeed_freq according to load as usual. Its a write-only file.
631         Length of time to hold CPU speed at hispeed_freq
632         on a write to boostpulse, before allowing speed to drop according to
640         An intermediate "high speed" at which to initially ramp
643         then speed may be bumped higher.  Default is the maximum speed allowed
656 ----------
665 "Turbo-Core" or (in technical documentation) "Core Performance Boost" and so on.
670 The frequency boost mechanism may be either hardware-based or software-based.
671 If it is hardware-based (e.g. on x86), the decision to trigger the boosting is
674 limits).  If it is software-based (e.g. on ARM), the scaling driver decides
678 -------------------------------
683 but provides a driver-specific interface for controlling it, like
688 trigger boosting (in the hardware-based case), or the software is allowed to
689 trigger boosting (in the software-based case).  It does not mean that boosting
700 --------------------------------
730      single-thread performance may vary because of it which may lead to
736 -----------------------
738 The AMD powernow-k8 scaling driver supports a ``sysfs`` knob very similar to
745 implementation, however, works on the system-wide basis and setting that knob
765 .. [1] Jonathan Corbet, *Per-entity load tracking*,