Lines Matching defs:capacity
149 * The margin used when comparing utilization with CPU capacity.
827 * where n denotes the nth task and cpu_scale the CPU capacity.
829 * For example, for a CPU with 1024 of capacity, a simplest series from
1552 /* The node has spare capacity that can be used to run more tasks. */
1571 /* Total compute capacity of CPUs on a node */
1765 * The load is corrected for the CPU capacity available on each node.
1962 * If a move to idle is allowed because there is capacity or load
1989 * If dst node has spare capacity, then check if there is an
4215 static inline int task_fits_capacity(struct task_struct *p, long capacity)
4217 return fits_capacity(uclamp_task_util(p), capacity);
4223 unsigned long capacity = capacity_orig_of(cpu);
4225 if (capacity == max_capacity) {
4229 return task_fits_capacity(p, capacity);
5865 * half of the spare capacity of their CPU, tiny tasks have the
6547 * maximize capacity.
6604 * that the task fits with cpu's capacity.
6674 * Amount of capacity of a CPU that is (estimated to be) used by CFS tasks
6677 * The unit of the return value must be the one of capacity so we can compare
6678 * the utilization with the capacity of the CPU that is available for CFS task
6687 * current capacity (capacity_curr <= capacity_orig) of the CPU because it is
6705 * available capacity. We allow utilization to overshoot capacity_curr (but not
6706 * capacity_orig) as it useful for predicting the capacity required after task
6800 * estimation of the spare capacity on that CPU, by just
6836 * Utilization (estimated) can exceed the CPU capacity, thus let's
6837 * clamp to the maximum CPU capacity to ensure consistency with
6890 * Returns the current capacity of cpu after applying both
6916 * The capacity state of CPUs of the current rd can be driven by CPUs
6954 * spare capacity in each performance domain and uses it as a potential
6965 * the maximum spare capacity in a performance domain is guaranteed to be among
7043 * Skip CPUs that cannot satisfy the capacity request.
7046 * much capacity we can get out of the CPU; this is
7062 * Find the CPU with the maximum spare capacity in
7710 * C_i is the compute capacity of CPU i, typically it is the
7816 /* The group has spare capacity that can be used to run more tasks. */
7824 * SD_ASYM_CPUCAPACITY only: One task doesn't fit with CPU's capacity
7829 * SD_ASYM_PACKING only: One local CPU with higher capacity is available,
8596 unsigned long group_misfit_task_load; /* A CPU has a task too big for its capacity */
8611 unsigned long total_capacity; /* Total capacity of all groups in sd */
8657 * average uses the actual delta max capacity(load).
8673 unsigned long capacity = scale_rt_capacity(cpu);
8678 if (!capacity) {
8679 capacity = 1;
8682 cpu_rq(cpu)->cpu_capacity = capacity;
8685 sdg->sgc->capacity = capacity;
8686 sdg->sgc->min_capacity = capacity;
8687 sdg->sgc->max_capacity = capacity;
8694 unsigned long capacity, min_capacity, max_capacity;
8706 capacity = 0;
8724 capacity += cpu_cap;
8740 capacity += sgc->capacity;
8748 sdg->sgc->capacity = capacity;
8754 * Check whether the capacity of the rq has been noticeably reduced by side
8756 * Return true is the capacity is reduced
8765 * help that task: we can migrate the task to a CPU of higher capacity, or
8808 * group_has_capacity returns true if the group has spare capacity that could
8810 * We consider that a group has spare capacity if the * number of task is
8812 * available capacity for CFS tasks.
8815 * capacity in meaningful for the load balancer.
8816 * As an example, an available capacity of 1% can appear but it doesn't make
8840 * with the exact right number of tasks, has no more spare capacity but is not
8863 * per-CPU capacity than sched_group ref.
9013 sgs->group_capacity = group->sgc->capacity;
9050 * We can use max_capacity here as reduction in capacity on some
9108 * group because tasks have all compute capacity that they need
9124 * the spare capacity which is more stable but it can end up
9125 * that the group has less spare capacity but finally more idle
9139 * per-CPU capacity. Migrating tasks to less capable CPUs may harm
9276 sgs->group_capacity = group->sgc->capacity;
9322 /* Select group with the highest max capacity */
9457 /* Select group with the highest max capacity */
9468 * If there is spare capacity at NUMA, try to select
9494 * up that the group has less spare capacity but finally more
9627 * In case of asym capacity, we will try to migrate all load to
9648 * Try to use spare capacity of local group without overloading it or
9655 * capacity. This might end up creating spare capacity
9666 * higher than capacity because of migrations but the
9733 * reduce the group load below the group capacity. Thus we look for
9923 unsigned long capacity, load, util;
9956 capacity = capacity_of(i);
9961 * eventually lead to active_balancing high->low capacity.
9962 * Higher per-CPU capacity is considered better than balancing
9965 if (env->sd->flags & SD_ASYM_CPUCAPACITY && capacity_of(env->dst_cpu) < capacity && nr_running == 1) {
9973 * which is not scaled with the CPU capacity.
9983 * capacity, so that the load can be moved away
9985 * lower capacity.
9993 if (load * busiest_capacity > busiest_load * capacity) {
9995 busiest_capacity = capacity;
10069 * It's worth migrating the task if the src_cpu's capacity is reduced
10070 * because of other sched_class or IRQs if more capacity stays
10864 * capacity; kick the ILB to see if there's a better CPU to run
10892 * When ASYM_CPUCAPACITY; see if there's a higher capacity CPU
10903 * ensure tasks have enough CPU capacity.