Skip to contentSkip to conversation

sched: move update_curr() in check_preempt_wakeup() to avoid redundant call

PATCH In review Jupyung Lee 2 participants 4 messages Nov 17, 2009 – Dec 9, 2009

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 sched: move update_curr() in check_preempt_wakeup() to avoid redundant call

Impact: micro-optimization

If a RT task is woken up while a non-RT task is running, check_preempt_wakeup() is called to check whether the new task can preempt the old task. The function returns quickly without going deeper because it is apparent that a RT task can always preempt a non-RT task.

In this situation, check_preempt_wakeup() always calls update_curr() to update vruntime value of the currently running task. However, the function call is unnecessary and redundant at that moment because (1) a non-RT task can always be preempted by a RT task regardless of its vruntime value, and
(2) update_curr() will be called shortly when the context switch between two occurs.

By moving update_curr() in check_preempt_wakeup(), we can avoid redundant call to update_curr(), slightly reducing the time taken to wake up RT tasks.

---
 kernel/sched_fair.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)
kernel/sched_fair.c +2 -2
index 37087a7..32256c0 100644
@@ -1596,8 +1596,6 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
 	int sync = wake_flags & WF_SYNC;
 	int scale = cfs_rq->nr_running >= sched_nr_latency;
 
-	update_curr(cfs_rq);
-
 	if (unlikely(rt_prio(p->prio))) {
 		resched_task(curr);
 		return;
@@ -1655,6 +1653,8 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
 
 	BUG_ON(!pse);
 
+	update_curr(cfs_rq);
+
 	if (wakeup_preempt_entity(se, pse) == 1) {
 		resched_task(curr);
 		/*
Signature · 1 line
1.6.5.GIT
#1 lore raw
Quoted 7 lines · Jupyung Lee

Impact: micro-optimization

If a RT task is woken up while a non-RT task is running, check_preempt_wakeup() is called to check whether the new task can preempt the old task. The function returns quickly without going deeper because it is apparent that a RT task can always preempt a non-RT task.

Quoted 8 lines

In this situation, check_preempt_wakeup() always calls update_curr() to update vruntime value of the currently running task. However, the function call is unnecessary and redundant at that moment because (1) a non-RT task can always be preempted by a RT task regardless of its vruntime value, and
(2) update_curr() will be called shortly when the context switch between two occurs.

By moving update_curr() in check_preempt_wakeup(), we can avoid redundant call to update_curr(), slightly reducing the time taken to wake up RT tasks.

So far so good, but then you let me figure out why you placed it where you did.

Anyway, I think the patch is good and took the patch, thanks!

Quoted 27 lines
---
 kernel/sched_fair.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)
kernel/sched_fair.c +2 -2
index 37087a7..32256c0 100644
@@ -1596,8 +1596,6 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
 	int sync = wake_flags & WF_SYNC;
 	int scale = cfs_rq->nr_running >= sched_nr_latency;
 
-	update_curr(cfs_rq);
-
 	if (unlikely(rt_prio(p->prio))) {
 		resched_task(curr);
 		return;
@@ -1655,6 +1653,8 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
 
 	BUG_ON(!pse);
 
+	update_curr(cfs_rq);
+
 	if (wakeup_preempt_entity(se, pse) == 1) {
 		resched_task(curr);
 		/*
#2 lore raw

Hi Peter,

Quoted 14 lines · Peter Zijlstra
Quoted 12 lines · Jupyung Lee

Impact: micro-optimization

If a RT task is woken up while a non-RT task is running, check_preempt_wakeup() is called to check whether the new task can preempt the old task. The function returns quickly without going deeper because it is apparent that a RT task can always preempt a non-RT task.

In this situation, check_preempt_wakeup() always calls update_curr() to update vruntime value of the currently running task. However, the function call is unnecessary and redundant at that moment because (1) a non-RT task can always be preempted by a RT task regardless of its vruntime value, and
(2) update_curr() will be called shortly when the context switch between two occurs.

Quoted 6 lines
Quoted 2 lines

By moving update_curr() in check_preempt_wakeup(), we can avoid redundant call to update_curr(), slightly reducing the time taken to wake up RT tasks.

So far so good, but then you let me figure out why you placed it where you did.

Currently, in check_preempt_wakeup(), update_curr(cfs_rq) is located as follows:

-----------------------------------------------------------------------------------------

   update_curr(cfs_rq);

   if (unlikely(rt_prio(p->prio))) {   .... /* A */
       resched_task(curr);
       return;
   }

if (unlikely(p->sched_class != &fair_sched_class)) .... /* B */

       return;

if (unlikely(se == pse)) .... /* C */

       return;

if (sched_feat(NEXT_BUDDY) && scale && !(wake_flags &
WF_FORK)) .... /* D */

       set_next_buddy(pse);

if (test_tsk_need_resched(curr)) .... /* E */

       return;

if (unlikely(p->policy != SCHED_NORMAL)) .... /* F */

       return;
   if (unlikely(curr->policy == SCHED_IDLE)) {  .... /* G */
       resched_task(curr);
       return;
   }

   if ((sched_feat(WAKEUP_SYNC) && sync) ||  .... /* H */
       (sched_feat(WAKEUP_OVERLAP) &&
        (se->avg_overlap < sysctl_sched_migration_cost &&
         pse->avg_overlap < sysctl_sched_migration_cost))) {
       resched_task(curr);
       return;
   }

   if (sched_feat(WAKEUP_RUNNING)) {  .... /* I */
       if (pse->avg_running < se->avg_running) {
           set_next_buddy(pse);
           resched_task(curr);
           return;
       }
   }

if (!sched_feat(WAKEUP_PREEMPT)) .... /* J */

       return;
   find_matching_se(&se, &pse);

   BUG_ON(!pse);

   if (wakeup_preempt_entity(se, pse) == 1) {  .... /* K */
       resched_task(curr);

-----------------------------------------------------------------------------------------

Among operations A to L, only 'K' is dependent on update_curr(), which updates curr->vruntime; wakeup_preempt_entity() compares curr->vruntime with se->vruntime.
Thus, it is straightforward to move update_curr() just above 'K'. It allows us to avoid
unnecessary function call to update_curr() when we do not go up to 'K'. As I said above, calling the function update_curr() here is unnecessary and redundant
except the case 'K' because it will be called shortly when the context switch between two occurs.

Quoted 2 lines

Anyway, I think the patch is good and took the patch, thanks!

Thanks.

Jupyung

#3 lore raw

[tip:sched/urgent] sched: Move update_curr() in check_preempt_wakeup() to avoid redundant call

In reply to Jupyung Lee
Commit-ID:  a65ac745e47e91f9d98dbf07f22ed0492e34d998
Gitweb:     http://git.kernel.org/tip/a65ac745e47e91f9d98dbf07f22ed0492e34d998
Author:     Jupyung Lee <[email protected]>
AuthorDate: Tue, 17 Nov 2009 18:51:40 +0900
Committer:  Ingo Molnar <[email protected]>
CommitDate: Wed, 9 Dec 2009 10:03:06 +0100

sched: Move update_curr() in check_preempt_wakeup() to avoid redundant call

If a RT task is woken up while a non-RT task is running, check_preempt_wakeup() is called to check whether the new task can preempt the old task. The function returns quickly without going deeper because it is apparent that a RT task can always preempt a non-RT task.

In this situation, check_preempt_wakeup() always calls update_curr() to update vruntime value of the currently running task. However, the function call is unnecessary and redundant at that moment because (1) a non-RT task can always be preempted by a RT task regardless of its vruntime value, and (2) update_curr() will be called shortly when the context switch between two occurs.

By moving update_curr() in check_preempt_wakeup(), we can avoid redundant call to update_curr(), slightly reducing the time taken to wake up RT tasks.

[ Place update_curr() right before the wake_preempt_entity() call, which
is the only thing that relies on the updated vruntime ]

LKML-Reference: <[email protected]>

---
 kernel/sched_fair.c |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)
kernel/sched_fair.c +2 -2
index 44ec80c..4dec185 100644
@@ -1651,8 +1651,6 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
 	int sync = wake_flags & WF_SYNC;
 	int scale = cfs_rq->nr_running >= sched_nr_latency;
 
-	update_curr(cfs_rq);
-
 	if (unlikely(rt_prio(p->prio))) {
 		resched_task(curr);
 		return;
@@ -1710,6 +1708,8 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
 
 	BUG_ON(!pse);
 
+	update_curr(cfs_rq);
+
 	if (wakeup_preempt_entity(se, pse) == 1) {
 		resched_task(curr);
 		/*