sched: pending patches
cover sched: pending patches
PATCH 1/3 sched: symmetric sync vs avg_overlap
Reinstate the weakening of the sync hint if set. This yields a more symmetric usage of avg_overlap.
--- kernel/sched.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
kernel/sched.c +9 -3
@@ -2360,9 +2360,15 @@ static int try_to_wake_up(struct task_stif (!sched_feat (SYNC_WAKEUPS )) sync =0 ; -if (!sync && (current->se.avg_overlap < sysctl_sched_migration_cost && - p->se.avg_overlap < sysctl_sched_migration_cost)) - sync =1 ; +if (!sync) { +if (current->se.avg_overlap < sysctl_sched_migration_cost && + p->se.avg_overlap < sysctl_sched_migration_cost) + sync =1 ; + }else { +if (current->se.avg_overlap >= sysctl_sched_migration_cost || + p->se.avg_overlap >= sysctl_sched_migration_cost) + sync =0 ; + }#ifdef CONFIG_SMP if (sched_feat (LB_WAKEUP_UPDATE )) {
PATCH 2/3 sched: clear buddies more aggressively
In reply to Peter ZijlstraFrom: Mike Galbraith <[email protected]>
It was noticed that a task could get re-elected past its run quota due to buddy affinities. This could increase latency a little. Cure it by more aggresively clearing buddy state.
We do so in two situations:
- when we force preempt
- when we select a buddy to run
--- kernel/sched_fair.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)
kernel/sched_fair.c +12 -1
@@ -768,8 +768,14 @@ check_preempt_tick(struct cfs_rq *cfs_rq ideal_runtime =sched_slice (cfs_rq, curr); delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime; -if (delta_exec > ideal_runtime) +if (delta_exec > ideal_runtime) {resched_task (rq_of (cfs_rq)->curr); +/* +* The current task ran long enough, ensure it doesn't get +* re-elected due to buddy favours. +*/ +clear_buddies (cfs_rq, curr); + } } static void
@@ -1492,6 +1498,11 @@ static struct task_struct *pick_next_tasdo { se =pick_next_entity (cfs_rq); +/* +* If se was a buddy, clear it so that it will have to earn +* the favour again. +*/ +clear_buddies (cfs_rq, se);set_next_entity (cfs_rq, se); cfs_rq =group_cfs_rq (se); }while (cfs_rq);
PATCH 3/3 sched: fix buddie group latency
In reply to Peter ZijlstraSimilar to the previous patch, by not clearing buddies we can select entities past their run quota, which can increase latency. This means we have to clear group buddies as well.
Do not use the group clear for pick_next_task(), otherwise that'll get O(n^2).
--- kernel/sched_fair.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
kernel/sched_fair.c +8 -2
@@ -719,7 +719,7 @@ enqueue_entity(struct cfs_rq *cfs_rq, st__enqueue_entity (cfs_rq, se); } -static void clear_buddies (struct cfs_rq *cfs_rq,struct sched_entity *se) +static void __clear_buddies (struct cfs_rq *cfs_rq,struct sched_entity *se) {if (cfs_rq->last == se) cfs_rq->last =NULL ;
@@ -728,6 +728,12 @@ static void clear_buddies(struct cfs_rq cfs_rq->next =NULL ; } +static void clear_buddies (struct cfs_rq *cfs_rq,struct sched_entity *se) +{ +for_each_sched_entity (se) +__clear_buddies (cfs_rq_of (se), se); +} +static void dequeue_entity (struct cfs_rq *cfs_rq,struct sched_entity *se,int sleep) {
@@ -1502,7 +1508,7 @@ static struct task_struct *pick_next_tas* If se was a buddy, clear it so that it will have to earn * the favour again. */ -clear_buddies (cfs_rq, se); +__clear_buddies (cfs_rq, se);set_next_entity (cfs_rq, se); cfs_rq =group_cfs_rq (se); }while (cfs_rq);
Ingo Molnar
Appliedapplied to tip/sched/urgent, thanks Peter and Mike!
Ingo