Lines Matching +full:no +full:- +full:idle +full:- +full:on +full:- +full:init
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
43 repeatedly on a regular basis. The activity by which this happens is referred
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
69 driver. That design is based on the observation that the information used by
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
77 based on information provided by the hardware itself, for example through
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
104 of its user space interface is based on the policy concept.
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
158 The utilization update callbacks will be invoked by the CPU scheduler on
159 important events, like task enqueue and dequeue, on every iteration of the
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
166 on the configuration and capabilities of the scaling driver and the governor.
172 "inactive" (and is re-initialized now) instead of the default governor.
175 other CPUs sharing the policy object with it are online already, there is no
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
215 and their behavior generally does not depend on what scaling driver is in use
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.
261 P-state to another, in nanoseconds.
264 work with the `ondemand`_ governor, -1 (:c:macro:`CPUFREQ_ETERNAL`)
287 In the majority of cases, this is the frequency of the last P-state
306 This attribute is read-write and writing to it will cause a new scaling
317 This attribute is read-write and writing a string representing an
325 This attribute is read-write and writing a string representing a
326 non-negative integer to it will cause a new limit to be set (it must not
351 Some governors expose ``sysfs`` attributes to control or fine-tune the scaling
353 tunables, can be either global (system-wide) or per-policy, depending on the
355 per-policy, they are located in a subdirectory of each policy directory.
362 ---------------
372 -------------
382 -------------
389 -------------
397 should be changed for a given policy (that depends on whether or not the driver
400 The actions of this governor for a particular CPU depend on the scheduling class
405 Per-Entity Load Tracking (PELT) metric for the root control group of the
406 given CPU as the CPU utilization estimate (see the *Per-entity load tracking*
414 policy (if the PELT number is frequency-invariant), or the current CPU frequency
418 CPU frequency for tasks that have been waiting on I/O most recently, called
419 "IO-wait boosting". That happens when the :c:macro:`SCHED_CPUFREQ_IOWAIT` flag
442 ------------
448 time in which the given CPU was not idle. The ratio of the non-idle (active)
456 invoked asynchronously (via a workqueue) and CPU P-states are updated from
459 relatively often and the CPU P-state updates triggered by it can be relatively
461 reduces the CPU idle time (even though the CPU idle time is only reduced very
479 to ``cpuinfo_transition_latency`` on each policy this governor is
483 If this tunable is per-policy, the following shell command sets the time
497 treat the CPU time spent on executing tasks with "nice" levels greater
498 than 0 as CPU idle time.
514 at the cost of additional energy spent on maintaining the maximum CPU
528 f * (1 - ``powersave_bias`` / 1000)
537 On Family 16h (and later) AMD processors there is a mechanism to get a
540 workload running on a CPU will change in response to frequency changes.
542 The performance of a workload with the sensitivity of 0 (memory-bound or
543 IO-bound) is not expected to increase at all as a result of increasing
545 (CPU-bound) are expected to perform much better if the CPU frequency is
551 target, so as to avoid over-provisioning workloads that will not benefit
555 ----------------
564 battery-powered). To achieve that, it changes the frequency in relatively
565 small steps, one step at a time, up or down - depending on whether or not a
602 ----------
611 "Turbo-Core" or (in technical documentation) "Core Performance Boost" and so on.
616 The frequency boost mechanism may be either hardware-based or software-based.
617 If it is hardware-based (e.g. on x86), the decision to trigger the boosting is
620 limits). If it is software-based (e.g. on ARM), the scaling driver decides
624 -------------------------------
629 but provides a driver-specific interface for controlling it, like
634 trigger boosting (in the hardware-based case), or the software is allowed to
635 trigger boosting (in the software-based case). It does not mean that boosting
636 is actually in use at the moment on any CPUs in the system. It only means a
646 --------------------------------
649 CPU performance on time scales below software resolution (e.g. below the
661 That may not be desirable on systems that switch to power sources of
663 mechanism while the system is running may help there (but that depends on
675 the boosting functionality depends on the load of the whole package,
676 single-thread performance may vary because of it which may lead to
682 -----------------------
684 The AMD powernow-k8 scaling driver supports a ``sysfs`` knob very similar to
691 implementation, however, works on the system-wide basis and setting that knob
695 That knob is still supported on AMD processors that support its underlying
711 .. [1] Jonathan Corbet, *Per-entity load tracking*,