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