Re: [PATCH] sched: fix lose fair sleeper bonus in switch_to_fair()

From: Wanpeng Li
Date: Tue Sep 08 2015 - 04:05:45 EST


On 9/8/15 3:57 PM, Byungchul Park wrote:
On Tue, Sep 08, 2015 at 03:30:08PM +0800, Wanpeng Li wrote:
On 9/8/15 3:11 PM, Byungchul Park wrote:
On Tue, Sep 08, 2015 at 02:42:52PM +0800, Wanpeng Li wrote:
On 9/8/15 2:32 PM, Byungchul Park wrote:
On Tue, Sep 08, 2015 at 03:14:26PM +0900, Byungchul Park wrote:
On Tue, Sep 08, 2015 at 01:38:08PM +0800, Wanpeng Li wrote:
On 9/8/15 1:28 PM, Byungchul Park wrote:
On Tue, Sep 08, 2015 at 11:46:01AM +0800, Wanpeng Li wrote:
On 9/7/15 10:02 PM, Peter Zijlstra wrote:
Please always Cc at least the person who wrote the lines you modify.

On Mon, Sep 07, 2015 at 05:45:20PM +0800, Wanpeng Li wrote:
The sleeper task will be normalized when moved from fair_sched_class, in
order that vruntime will be adjusted either the task is running or sleeping
when moved back. The nomalization in switch_to_fair for sleep task will
result in lose fair sleeper bonus in place_entity() once the vruntime -
cfs_rq->min_vruntime is big when moved from fair_sched_class.

This patch fix it by adjusting vruntime just during migrating as original
codes since the vruntime of the task has usually NOT been normalized in
this case.
Sorry, I cannot follow that at all. Maybe its me being sleep deprived,
but could you try that again?
When changing away from the fair class while sleeping, relative
vruntime is calculated to handle the case sleep when moved from
fair_sched_class and running when moved to fair_sched_class. The
i don't think relative vruntime is calculated to handle the special case
you mentioned. i think the calculation is necessary for all cases detaching
Please refer why the relative vruntime caculation is introduced to
switched_from_fair(): https://lkml.org/lkml/2011/1/17/129
hello,

it is just a bug caused by not calculating a relative vruntime when
detached a task from cfs_rq, which is necessary though.

a task from a cfs_rq.

absolute vruntime will be calculated in enqueue_entity() either the
task is running or sleeping when moved back. The fair sleeper bonus
i think absolute vruntime is calculated in enqueue_entuty() only when the
task is on rq. therefore in the case that the task is not on rq,
switched_to_fair() has to calculate the absolute vruntime instread.
Absolute vruntime is caculated in place_entity() which is called by
enqueue_entity() for DEQUEUE_SLEEP task.
as you may know, place_entity() is not for calculating an absolute
vruntime though.. anyway the important thing here is that, when a
sleeping task is moved back to fair class, enqueue_entity() for
DEQUEUE_SLEEP task won't be called.
you may talk about calling enqueue_entity() when the task is woken up,
not just when it is moved back. right?
Exactly.

even if yes, i think place_entity() should not be used directly for
calculating an absolute vruntime. it should be called after non/normalizing
operations.
The se->vruntime += cfs_rq->min_vruntime(in your switched_to_fair())
which means that se->vruntime is bigger than cfs_rq->min_vruntime,
it is not always true since se->vruntime can have a negative value (even
though it is a unsigned type.. i think it can be another problem) by
se->vruntime -= cfs_rq->min_vruntime in detach_task_cfs_rq().
Yeah, it can be negative.

however, fair sleeper bonus is min_vuntime - sysctl_sched_latency/2,
which means that max_vruntime() will select the absolute vruntime
which is caculated in your switched_to_fair() as the se->vruntime,
since se->vruntime can have a negative value, max_vruntime() may select
the fair sleeper bonused value.

by the way, this logic is unchanged by my patch. which part of my patch
changed this kind of logic?
However, if se->vruntime -= cfs_rq->min_vruntime is positive, the
behavior is different after your patch. e.g. se->vruntime(the
relative vruntime in switched_to_fair()) < min_vruntime -
sysctl_sched_latency/2

before your patch:

se->vruntime = min_vruntime - sysctl_sched_latency/2 (place_entity())
my patch is based on ff277d4 commit at tip/sched/core.

there's no change between before and after.

check it please.

and this logic seems to be no problem to me. :(

Your logic will lose fair sleeper bonus in the scenario which I pointed out.


after your patch:

se->vruntime += cfs->min_vruntime (switched_to_fair())
se->vruntime = se->vruntime (place_entity())


Regards,
Wanpeng Li

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/