Lines Matching full:it
29 In some situations it is desirable or even necessary to run the program as fast
32 available). In some other cases, however, it may not be necessary to execute
34 relatively long time without utilizing it entirely may be regarded as wasteful.
35 It also may not be physically possible to maintain maximum CPU capacity for too
45 to as CPU performance scaling or CPU frequency scaling (because it involves
57 interfaces for all platforms that support CPU performance scaling. It defines
72 platform-independent form in the majority of cases, so it should be possible
80 interface it comes from and may not be easily represented in an abstract,
91 control the P-state of multiple CPUs at the same time and writing to it affects
112 It is only possible to register one scaling driver at a time, so the scaling
122 In any case, the ``CPUFreq`` core is invoked to take note of any logical CPU it
123 has not seen so far as soon as it is ready to handle that CPU. [Note that the
131 for the given CPU and if so, it skips the policy object creation. Otherwise,
137 pointer of the new CPU passed to it as the argument. That callback is expected
139 more precisely, for the set of CPUs sharing the hardware interface it belongs
140 to, represented by its policy object) and, if the policy object it has been
146 CPUs in it.
149 scaling governor to it (to begin with, that is the default scaling governor
150 determined by the kernel configuration, but it may be changed later
154 a governor ``sysfs`` interface to it. Next, the governor is started by
176 other CPUs sharing the policy object with it are online already, there is no
177 need to re-initialize the policy object at all. In that case, it only is
178 necessary to restart the scaling governor so that it can take the new online CPU
194 (which happens when the kernel module containing it is unloaded, for example) or
242 support it.
261 The time it takes to switch the CPUs belonging to this policy from one
277 [Note that some governors are modular and it may be necessary to load a
278 kernel module for the governor held by it to become available and be
286 interface provided by it, which may or may not reflect the frequency
303 This attribute is read-write and writing to it will cause a new scaling
305 provided by the scaling driver to be applied to it (in the
315 integer to it will cause a new limit to be set (it must not be lower
323 non-negative integer to it will cause a new limit to be set (it must not
330 It returns the last frequency requested by the governor (in kHz) or can
381 This governor does not do anything by itself. Instead, it allows user space
382 to set the CPU frequency for the policy it is attached to by writing to the
388 This governor uses CPU utilization data available from the CPU scheduler. It
389 generally is regarded as a part of the CPU scheduler, so it can access the
392 It runs entirely in scheduler context, although in some cases it may need to
393 invoke the scaling driver asynchronously when it decides that the CPU frequency
398 invoking its utilization update callback for that CPU. If it is invoked by the
401 if it is invoked by the CFS scheduling class, the governor will use the
414 This governor also employs a mechanism allowing it to temporarily bump up the
429 of the governor which might be excessive without it.
432 and `conservative`_ governors (described below), as it is simpler and more
434 switches and similar is less significant, and it uses the scheduler's own CPU
443 In order to estimate the current CPU load, it measures the time elapsed between
452 The worker routine of this governor has to run in process context, so it is
455 governor is minimum, but it causes additional CPU context switches to happen
456 relatively often and the CPU P-state updates triggered by it can be relatively
457 irregular. Also, it affects its own CPU load metric by running code that
459 slightly by it).
461 It generally selects CPU frequencies proportional to the estimated load, so that
465 speedup threshold, in which case it will go straight for the highest frequency
466 it is allowed to use (the ``scaling_max_freq`` policy limit).
474 Typically, it is set to values of the order of 10000 (10 ms). Its
482 represented by it to be 750 times as high as the transition latency::
493 If set to 1 (default 0), it will cause the CPU load estimation code to
499 Then, to make that happen it is sufficient to increase the "nice" level
531 value of this attribute is 400 by default and it is used in a different
556 It estimates the CPU load in the same way as the `ondemand`_ governor described
557 above, but the CPU frequency selection algorithm implemented by it is different.
559 Namely, it avoids changing the frequency significantly over short time intervals
561 battery-powered). To achieve that, it changes the frequency in relatively
573 it to 0 will cause the default frequency step (5 percent) to be used
574 and setting it to 100 effectively causes the governor to periodically
591 It effectively causes the frequency to go down ``sampling_down_factor``
592 times slower than it ramps up.
607 For Intel processors it is referred to as "Turbo Boost", AMD calls it
609 As a rule, it also is implemented differently by different vendors. The simple
614 If it is hardware-based (e.g. on x86), the decision to trigger the boosting is
615 made by the hardware (although in general it requires the hardware to be put
616 into a special state in which it can control the CPU frequency within certain
617 limits). If it is software-based (e.g. on ARM), the scaling driver decides
624 the "boost" setting for the whole system. It is not present if the underlying
625 scaling driver does not support the frequency boost mechanism (or supports it,
626 but provides a driver-specific interface for controlling it, like
630 means that either the hardware can be put into states in which it is able to
632 trigger boosting (in the software-based case). It does not mean that boosting
633 is actually in use at the moment on any CPUs in the system. It only means a
647 scheduler tick interval) and it is demonstrably suitable for many workloads, but
648 it may lead to problems in certain situations.
650 For this reason, many systems make it possible to disable the frequency boost
667 3. To examine the impact of the frequency boost mechanism itself, it is useful
673 single-thread performance may vary because of it which may lead to
682 the global ``boost`` one. It is used for disabling/enabling the "Core
689 for one policy causes the same value of it to be set for all of the other
693 hardware feature, but it may be configured out of the kernel (via the
695 ``boost`` knob is present regardless. Thus it is always possible use the