Gregory Haskins [Fri, 25 Jan 2008 20:08:10 +0000 (21:08 +0100)]
Isolate the search logic into a function so that it can be used later
in places other than find_locked_lowest_rq().

Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

index 5de1aeb..ffd0272 100644 (file)
@@ -263,54 +263,66 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq,

-/* Will lock the rq it finds */
-                                     struct rq *this_rq)
{
-       struct rq *lowest_rq = NULL;
int cpu;
-       int tries;
+       struct rq *lowest_rq = NULL;

-       for (tries = 0; tries < RT_MAX_TRIES; tries++) {
-               /*
-                * Scan each rq for the lowest prio.
-                */
-                       struct rq *rq = &per_cpu(runqueues, cpu);
+       /*
+        * Scan each rq for the lowest prio.
+        */
+               struct rq *rq = cpu_rq(cpu);

-                       if (cpu == this_rq->cpu)
-                               continue;
+               if (cpu == rq->cpu)
+                       continue;

-                       /* We look for lowest RT prio or non-rt CPU */
-                       if (rq->rt.highest_prio >= MAX_RT_PRIO) {
-                               lowest_rq = rq;
-                               break;
-                       }
+               /* We look for lowest RT prio or non-rt CPU */
+               if (rq->rt.highest_prio >= MAX_RT_PRIO) {
+                       lowest_rq = rq;
+                       break;
+               }

-                       /* no locking for now */
-                       if (rq->rt.highest_prio > task->prio &&
-                           (!lowest_rq || rq->rt.highest_prio > lowest_rq->rt.highest_prio)) {
-                               lowest_rq = rq;
-                       }
+               /* no locking for now */
+               if (rq->rt.highest_prio > task->prio &&
+                   (!lowest_rq || rq->rt.highest_prio > lowest_rq->rt.highest_prio)) {
+                       lowest_rq = rq;
}
+       }
+
+       return lowest_rq ? lowest_rq->cpu : -1;
+}
+
+/* Will lock the rq it finds */
+                                     struct rq *rq)
+{
+       struct rq *lowest_rq = NULL;
+       int cpu;
+       int tries;

-               if (!lowest_rq)
+       for (tries = 0; tries < RT_MAX_TRIES; tries++) {
+               cpu = find_lowest_rq(task);
+
+               if (cpu == -1)
break;

+               lowest_rq = cpu_rq(cpu);
+
/* if the prio of this runqueue changed, try again */
-               if (double_lock_balance(this_rq, lowest_rq)) {
+               if (double_lock_balance(rq, lowest_rq)) {
/*
* We had to unlock the run queue. In
* the mean time, task could have
* migrated already or had its affinity changed.
* Also make sure that it wasn't scheduled on its rq.
*/