Commit:     318e0893ce3f524ca045f9fd9dfd567c0a6f9446
Parent:     2de0b4639f4b1b6bfe31f795e5855f041f177170
Author:     Gregory Haskins <[EMAIL PROTECTED]>
AuthorDate: Fri Jan 25 21:08:10 2008 +0100
Committer:  Ingo Molnar <[EMAIL PROTECTED]>
CommitDate: Fri Jan 25 21:08:10 2008 +0100

    sched: pre-route RT tasks on wakeup
    In the original patch series that Steven Rostedt and I worked on together,
    we both took different approaches to low-priority wakeup path.  I utilized
    "pre-routing" (push the task away to a less important RQ before activating)
    approach, while Steve utilized a "post-routing" approach.  The advantage of
    my approach is that you avoid the overhead of a wasted activate/deactivate
    cycle and peripherally related burdens.  The advantage of Steve's method is
    that it neatly solves an issue preventing a "pull" optimization from being
    In the end, we ended up deploying Steve's idea.  But it later dawned on me
    that we could get the best of both worlds by deploying both ideas together,
    albeit slightly modified.
    The idea is simple:  Use a "light-weight" lookup for pre-routing, since we
    only need to approximate a good home for the task.  And we also retain the
    post-routing push logic to clean up any inaccuracies caused by a condition
    of "priority mistargeting" caused by the lightweight lookup.  Most of the
    time, the pre-routing should work and yield lower overhead.  In the cases
    where it doesnt, the post-router will bat cleanup.
    Signed-off-by: Gregory Haskins <[EMAIL PROTECTED]>
    Signed-off-by: Steven Rostedt <[EMAIL PROTECTED]>
    Signed-off-by: Ingo Molnar <[EMAIL PROTECTED]>
 kernel/sched_rt.c |   19 +++++++++++++++++++
 1 files changed, 19 insertions(+), 0 deletions(-)

diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index 95f36f6..ac7d067 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -151,8 +151,27 @@ yield_task_rt(struct rq *rq)
 #ifdef CONFIG_SMP
+static int find_lowest_rq(struct task_struct *task);
 static int select_task_rq_rt(struct task_struct *p, int sync)
+       struct rq *rq = task_rq(p);
+       /*
+        * If the task will not preempt the RQ, try to find a better RQ
+        * before we even activate the task
+        */
+       if ((p->prio >= rq->rt.highest_prio)
+           && (p->nr_cpus_allowed > 1)) {
+               int cpu = find_lowest_rq(p);
+               return (cpu == -1) ? task_cpu(p) : cpu;
+       }
+       /*
+        * Otherwise, just let it ride on the affined RQ and the
+        * post-schedule router will push the preempted task away
+        */
        return task_cpu(p);
 #endif /* CONFIG_SMP */
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at

Reply via email to