sched/fair: Fix cpu_util_wake() for 'execl' type workloads
A ~10% regression has been reported for UnixBench's execl throughput test by Aaron Lu and Ye Xiaolong: https://lkml.org/lkml/2018/10/30/765 That test is pretty simple, it does a "recursive" execve() syscall on the same binary. Starting from the syscall, this sequence is possible: do_execve() do_execveat_common() __do_execve_file() sched_exec() select_task_rq_fair() <==| Task already enqueued find_idlest_cpu() find_idlest_group() capacity_spare_wake() <==| Functions not called from cpu_util_wake() | the wakeup path which means we can end up calling cpu_util_wake() not only from the "wakeup path", as its name would suggest. Indeed, the task doing an execve() syscall is already enqueued on the CPU we want to get the cpu_util_wake() for. The estimated utilization for a CPU computed in cpu_util_wake() was written under the assumption that function can be called only from the wakeup path. If instead the task is already enqueued, we end up with a utilization which does not remove the current task's contribution from the estimated utilization of the CPU. This will wrongly assume a reduced spare capacity on the current CPU and increase the chances to migrate the task on execve. The regression is tracked down to: commitd519329f72
("sched/fair: Update util_est only on util_avg updates") because in that patch we turn on by default the UTIL_EST sched feature. However, the real issue is introduced by: commitf9be3e5961
("sched/fair: Use util_est in LB and WU paths") Let's fix this by ensuring to always discount the task estimated utilization from the CPU's estimated utilization when the task is also the current one. The same benchmark of the bug report, executed on a dual socket 40 CPUs Intel(R) Xeon(R) CPU E5-2690 v2 @ 3.00GHz machine, reports these "Execl Throughput" figures (higher the better): mainline : 48136.5 lps mainline+fix : 55376.5 lps which correspond to a 15% speedup. Moreover, since {cpu_util,capacity_spare}_wake() are not really only used from the wakeup path, let's remove this ambiguity by using a better matching name: {cpu_util,capacity_spare}_without(). Since we are at that, let's also improve the existing documentation. Reported-by: Aaron Lu <aaron.lu@intel.com> Reported-by: Ye Xiaolong <xiaolong.ye@intel.com> Tested-by: Aaron Lu <aaron.lu@intel.com> Signed-off-by: Patrick Bellasi <patrick.bellasi@arm.com> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org> Cc: Dietmar Eggemann <dietmar.eggemann@arm.com> Cc: Juri Lelli <juri.lelli@redhat.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Morten Rasmussen <morten.rasmussen@arm.com> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Quentin Perret <quentin.perret@arm.com> Cc: Steve Muckle <smuckle@google.com> Cc: Suren Baghdasaryan <surenb@google.com> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Todd Kjos <tkjos@google.com> Cc: Vincent Guittot <vincent.guittot@linaro.org> Fixes:f9be3e5961
(sched/fair: Use util_est in LB and WU paths) Link: https://lore.kernel.org/lkml/20181025093100.GB13236@e110439-lin/ Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
parent
e1ff516a56
commit
c469933e77
|
@ -5674,11 +5674,11 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p,
|
||||||
return target;
|
return target;
|
||||||
}
|
}
|
||||||
|
|
||||||
static unsigned long cpu_util_wake(int cpu, struct task_struct *p);
|
static unsigned long cpu_util_without(int cpu, struct task_struct *p);
|
||||||
|
|
||||||
static unsigned long capacity_spare_wake(int cpu, struct task_struct *p)
|
static unsigned long capacity_spare_without(int cpu, struct task_struct *p)
|
||||||
{
|
{
|
||||||
return max_t(long, capacity_of(cpu) - cpu_util_wake(cpu, p), 0);
|
return max_t(long, capacity_of(cpu) - cpu_util_without(cpu, p), 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -5738,7 +5738,7 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p,
|
||||||
|
|
||||||
avg_load += cfs_rq_load_avg(&cpu_rq(i)->cfs);
|
avg_load += cfs_rq_load_avg(&cpu_rq(i)->cfs);
|
||||||
|
|
||||||
spare_cap = capacity_spare_wake(i, p);
|
spare_cap = capacity_spare_without(i, p);
|
||||||
|
|
||||||
if (spare_cap > max_spare_cap)
|
if (spare_cap > max_spare_cap)
|
||||||
max_spare_cap = spare_cap;
|
max_spare_cap = spare_cap;
|
||||||
|
@ -5889,8 +5889,8 @@ static inline int find_idlest_cpu(struct sched_domain *sd, struct task_struct *p
|
||||||
return prev_cpu;
|
return prev_cpu;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* We need task's util for capacity_spare_wake, sync it up to prev_cpu's
|
* We need task's util for capacity_spare_without, sync it up to
|
||||||
* last_update_time.
|
* prev_cpu's last_update_time.
|
||||||
*/
|
*/
|
||||||
if (!(sd_flag & SD_BALANCE_FORK))
|
if (!(sd_flag & SD_BALANCE_FORK))
|
||||||
sync_entity_load_avg(&p->se);
|
sync_entity_load_avg(&p->se);
|
||||||
|
@ -6216,10 +6216,19 @@ static inline unsigned long cpu_util(int cpu)
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* cpu_util_wake: Compute CPU utilization with any contributions from
|
* cpu_util_without: compute cpu utilization without any contributions from *p
|
||||||
* the waking task p removed.
|
* @cpu: the CPU which utilization is requested
|
||||||
|
* @p: the task which utilization should be discounted
|
||||||
|
*
|
||||||
|
* The utilization of a CPU is defined by the utilization of tasks currently
|
||||||
|
* enqueued on that CPU as well as tasks which are currently sleeping after an
|
||||||
|
* execution on that CPU.
|
||||||
|
*
|
||||||
|
* This method returns the utilization of the specified CPU by discounting the
|
||||||
|
* utilization of the specified task, whenever the task is currently
|
||||||
|
* contributing to the CPU utilization.
|
||||||
*/
|
*/
|
||||||
static unsigned long cpu_util_wake(int cpu, struct task_struct *p)
|
static unsigned long cpu_util_without(int cpu, struct task_struct *p)
|
||||||
{
|
{
|
||||||
struct cfs_rq *cfs_rq;
|
struct cfs_rq *cfs_rq;
|
||||||
unsigned int util;
|
unsigned int util;
|
||||||
|
@ -6231,7 +6240,7 @@ static unsigned long cpu_util_wake(int cpu, struct task_struct *p)
|
||||||
cfs_rq = &cpu_rq(cpu)->cfs;
|
cfs_rq = &cpu_rq(cpu)->cfs;
|
||||||
util = READ_ONCE(cfs_rq->avg.util_avg);
|
util = READ_ONCE(cfs_rq->avg.util_avg);
|
||||||
|
|
||||||
/* Discount task's blocked util from CPU's util */
|
/* Discount task's util from CPU's util */
|
||||||
util -= min_t(unsigned int, util, task_util(p));
|
util -= min_t(unsigned int, util, task_util(p));
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -6240,14 +6249,14 @@ static unsigned long cpu_util_wake(int cpu, struct task_struct *p)
|
||||||
* a) if *p is the only task sleeping on this CPU, then:
|
* a) if *p is the only task sleeping on this CPU, then:
|
||||||
* cpu_util (== task_util) > util_est (== 0)
|
* cpu_util (== task_util) > util_est (== 0)
|
||||||
* and thus we return:
|
* and thus we return:
|
||||||
* cpu_util_wake = (cpu_util - task_util) = 0
|
* cpu_util_without = (cpu_util - task_util) = 0
|
||||||
*
|
*
|
||||||
* b) if other tasks are SLEEPING on this CPU, which is now exiting
|
* b) if other tasks are SLEEPING on this CPU, which is now exiting
|
||||||
* IDLE, then:
|
* IDLE, then:
|
||||||
* cpu_util >= task_util
|
* cpu_util >= task_util
|
||||||
* cpu_util > util_est (== 0)
|
* cpu_util > util_est (== 0)
|
||||||
* and thus we discount *p's blocked utilization to return:
|
* and thus we discount *p's blocked utilization to return:
|
||||||
* cpu_util_wake = (cpu_util - task_util) >= 0
|
* cpu_util_without = (cpu_util - task_util) >= 0
|
||||||
*
|
*
|
||||||
* c) if other tasks are RUNNABLE on that CPU and
|
* c) if other tasks are RUNNABLE on that CPU and
|
||||||
* util_est > cpu_util
|
* util_est > cpu_util
|
||||||
|
@ -6260,8 +6269,33 @@ static unsigned long cpu_util_wake(int cpu, struct task_struct *p)
|
||||||
* covered by the following code when estimated utilization is
|
* covered by the following code when estimated utilization is
|
||||||
* enabled.
|
* enabled.
|
||||||
*/
|
*/
|
||||||
if (sched_feat(UTIL_EST))
|
if (sched_feat(UTIL_EST)) {
|
||||||
util = max(util, READ_ONCE(cfs_rq->avg.util_est.enqueued));
|
unsigned int estimated =
|
||||||
|
READ_ONCE(cfs_rq->avg.util_est.enqueued);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Despite the following checks we still have a small window
|
||||||
|
* for a possible race, when an execl's select_task_rq_fair()
|
||||||
|
* races with LB's detach_task():
|
||||||
|
*
|
||||||
|
* detach_task()
|
||||||
|
* p->on_rq = TASK_ON_RQ_MIGRATING;
|
||||||
|
* ---------------------------------- A
|
||||||
|
* deactivate_task() \
|
||||||
|
* dequeue_task() + RaceTime
|
||||||
|
* util_est_dequeue() /
|
||||||
|
* ---------------------------------- B
|
||||||
|
*
|
||||||
|
* The additional check on "current == p" it's required to
|
||||||
|
* properly fix the execl regression and it helps in further
|
||||||
|
* reducing the chances for the above race.
|
||||||
|
*/
|
||||||
|
if (unlikely(task_on_rq_queued(p) || current == p)) {
|
||||||
|
estimated -= min_t(unsigned int, estimated,
|
||||||
|
(_task_util_est(p) | UTIL_AVG_UNCHANGED));
|
||||||
|
}
|
||||||
|
util = max(util, estimated);
|
||||||
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Utilization (estimated) can exceed the CPU capacity, thus let's
|
* Utilization (estimated) can exceed the CPU capacity, thus let's
|
||||||
|
|
Loading…
Reference in New Issue