Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

sched: break out search for RT tasks

Browse source 
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: Gregory Haskins <ghaskins@novell.com>
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Gregory Haskins 2008-01-25 21:08:10 +01:00 committed by Ingo Molnar
parent e7693a362e
commit 07b4032c9e
1 changed files with 41 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

70
kernel/sched_rt.c
View file

@ -263,54 +263,66 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq,
static DEFINE_PER_CPU(cpumask_t, local_cpu_mask); static DEFINE_PER_CPU(cpumask_t, local_cpu_mask);
static int find_lowest_rq(struct task_struct *task)
{
int cpu;
cpumask_t *cpu_mask = &__get_cpu_var(local_cpu_mask);
struct rq *lowest_rq = NULL;
cpus_and(*cpu_mask, cpu_online_map, task->cpus_allowed);
/*
* Scan each rq for the lowest prio.
*/
for_each_cpu_mask(cpu, *cpu_mask) {
struct rq *rq = cpu_rq(cpu);
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;
}
/* 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 */ /* Will lock the rq it finds */
static struct rq *find_lock_lowest_rq(struct task_struct *task, static struct rq *find_lock_lowest_rq(struct task_struct *task,
struct rq *this_rq) struct rq *rq)
{ {
struct rq *lowest_rq = NULL; struct rq *lowest_rq = NULL;
int cpu; int cpu;
int tries; int tries;
cpumask_t *cpu_mask = &__get_cpu_var(local_cpu_mask);
cpus_and(*cpu_mask, cpu_online_map, task->cpus_allowed);
for (tries = 0; tries < RT_MAX_TRIES; tries++) { for (tries = 0; tries < RT_MAX_TRIES; tries++) {
/* cpu = find_lowest_rq(task);
* Scan each rq for the lowest prio.
*/
for_each_cpu_mask(cpu, *cpu_mask) {
struct rq *rq = &per_cpu(runqueues, cpu);
if (cpu == this_rq->cpu) if (cpu == -1)
continue;
/* 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;
}
}
if (!lowest_rq)
break; break;
lowest_rq = cpu_rq(cpu);
/* if the prio of this runqueue changed, try again */ /* 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 * We had to unlock the run queue. In
* the mean time, task could have * the mean time, task could have
* migrated already or had its affinity changed. * migrated already or had its affinity changed.
* Also make sure that it wasn't scheduled on its rq. * Also make sure that it wasn't scheduled on its rq.
*/ */
if (unlikely(task_rq(task) != this_rq || if (unlikely(task_rq(task) != rq ||
!cpu_isset(lowest_rq->cpu, task->cpus_allowed) || !cpu_isset(lowest_rq->cpu, task->cpus_allowed) ||
task_running(this_rq, task) || task_running(rq, task) ||
!task->se.on_rq)) { !task->se.on_rq)) {
spin_unlock(&lowest_rq->lock); spin_unlock(&lowest_rq->lock);
lowest_rq = NULL; lowest_rq = NULL;