Lines Matching full:it
28 In some situations it is desirable or even necessary to run the program as fast
31 available). In some other cases, however, it may not be necessary to execute
33 relatively long time without utilizing it entirely may be regarded as wasteful.
34 It also may not be physically possible to maintain maximum CPU capacity for too
44 to as CPU performance scaling or CPU frequency scaling (because it involves
56 interfaces for all platforms that support CPU performance scaling. It defines
71 platform-independent form in the majority of cases, so it should be possible
79 interface it comes from and may not be easily represented in an abstract,
90 control the P-state of multiple CPUs at the same time and writing to it affects
111 It is only possible to register one scaling driver at a time, so the scaling
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
130 for the given CPU and if so, it skips the policy object creation. Otherwise,
136 pointer of the new CPU passed to it as the argument. That callback is expected
138 more precisely, for the set of CPUs sharing the hardware interface it belongs
139 to, represented by its policy object) and, if the policy object it has been
145 CPUs in it.
148 scaling governor to it (to begin with, that is the default scaling governor
149 determined by the kernel command line or configuration, but it may be changed
153 a governor ``sysfs`` interface to it. Next, the governor is started by
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
177 necessary to restart the scaling governor so that it can take the new online CPU
193 (which happens when the kernel module containing it is unloaded, for example) or
241 support it.
274 The time it takes to switch the CPUs belonging to this policy from one
294 [Note that some governors are modular and it may be necessary to load a
295 kernel module for the governor held by it to become available and be
303 interface provided by it, which may or may not reflect the frequency
321 This attribute is read-write and writing to it will cause a new scaling
323 provided by the scaling driver to be applied to it (in the
333 integer to it will cause a new limit to be set (it must not be lower
341 non-negative integer to it will cause a new limit to be set (it must not
348 It returns the last frequency requested by the governor (in kHz) or can
399 This governor does not do anything by itself. Instead, it allows user space
400 to set the CPU frequency for the policy it is attached to by writing to the
406 This governor uses CPU utilization data available from the CPU scheduler. It
407 generally is regarded as a part of the CPU scheduler, so it can access the
410 It runs entirely in scheduler context, although in some cases it may need to
411 invoke the scaling driver asynchronously when it decides that the CPU frequency
416 invoking its utilization update callback for that CPU. If it is invoked by the
419 if it is invoked by the CFS scheduling class, the governor will use the
432 This governor also employs a mechanism allowing it to temporarily bump up the
447 of the governor which might be excessive without it.
450 and `conservative`_ governors (described below), as it is simpler and more
452 switches and similar is less significant, and it uses the scheduler's own CPU
461 In order to estimate the current CPU load, it measures the time elapsed between
470 The worker routine of this governor has to run in process context, so it is
473 governor is minimum, but it causes additional CPU context switches to happen
474 relatively often and the CPU P-state updates triggered by it can be relatively
475 irregular. Also, it affects its own CPU load metric by running code that
477 slightly by it).
479 It generally selects CPU frequencies proportional to the estimated load, so that
483 speedup threshold, in which case it will go straight for the highest frequency
484 it is allowed to use (the ``scaling_max_freq`` policy limit).
492 Typically, it is set to values of the order of 2000 (2 ms). Its
499 represented by it to be 1.5 times as high as the transition latency
511 If set to 1 (default 0), it will cause the CPU load estimation code to
517 Then, to make that happen it is sufficient to increase the "nice" level
549 value of this attribute is 400 by default and it is used in a different
574 It estimates the CPU load in the same way as the `ondemand`_ governor described
575 above, but the CPU frequency selection algorithm implemented by it is different.
577 Namely, it avoids changing the frequency significantly over short time intervals
579 battery-powered). To achieve that, it changes the frequency in relatively
591 it to 0 will cause the default frequency step (5 percent) to be used
592 and setting it to 100 effectively causes the governor to periodically
609 It effectively causes the frequency to go down ``sampling_down_factor``
610 times slower than it ramps up.
625 For Intel processors it is referred to as "Turbo Boost", AMD calls it
627 As a rule, it also is implemented differently by different vendors. The simple
632 If it is hardware-based (e.g. on x86), the decision to trigger the boosting is
633 made by the hardware (although in general it requires the hardware to be put
634 into a special state in which it can control the CPU frequency within certain
635 limits). If it is software-based (e.g. on ARM), the scaling driver decides
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
648 means that either the hardware can be put into states in which it is able to
650 trigger boosting (in the software-based case). It does not mean that boosting
651 is actually in use at the moment on any CPUs in the system. It only means a
665 scheduler tick interval) and it is demonstrably suitable for many workloads, but
666 it may lead to problems in certain situations.
668 For this reason, many systems make it possible to disable the frequency 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
700 the global ``boost`` one. It is used for disabling/enabling the "Core
707 for one policy causes the same value of it to be set for all of the other
711 hardware feature, but it may be configured out of the kernel (via the
713 ``boost`` knob is present regardless. Thus it is always possible use the