   load_balance (),  ,  
  .

static int load_balance(int this_cpu, runqueue_t *this_rq,

struct sched_domain *sd, enum idle_type idle)

{

struct sched_group *group;

runqueue_t *busiest;

unsigned long imbalance;

int nr_moved;

spin lock(&this rq->lock);

group = find_busiest_group(sd, this_cpu, Simbalance, idle) ;

if ('group)

goto out_balanced;

busiest = find_busiest_queue(group);

if (!busiest)

goto out_balanced;

nr moved =0;

if (busiest->nr running > 1) (

double_lock_balance(this_rq, busiest);                     [
nr_moved = move_tasks(this rq, this cpu, busiest,
imbalance, sd, idle) ;

spin unlock(&busiest->lock) ;

}

spin_unlock(&this_rq->lock);

if (!nr_moved) {

sd->nr balance failed++;

if (unlikely(sd->nr_balance_f ailed > sd->cache_nice_tries+2)) {
int wake = 0;

spin_lock(&busiest->lock) ;

if (!busiest->active balance) {

busiest->active balance =1;

busiest->push cpu = this cpu;

wake = 1;

}
spin_unlock(&busiest->lock) ;

if (wake)

wake_up_process(busiest->migration_thread) ;

sd->nr_balance failed = sd->cache nice tries;

}
} else

sd->nr balance failed = 0;

sd->balance_interval = sd->min_interval;

return nr_moved;

86                                                                            4