linux 调度器负载均衡

每个cpu上都有一个运行队列rq，运行队列里面又具体再分成rt_rq、cfs_rq等，

在运行的过程中每个cpu上面task数量是不同的，这个用负载来衡量。cpu上rq内task

越多，代表这个cpu 负载越重。

负载均衡就是用来将task均匀分布在每个cpu上，使每个cpu负载大致均衡，提升task相应速度。

负载均衡中有两个主要的操作，pull和push。

当本地rq上task数量较少时，执行pull操作，从其他rq上取task到本地rq运行。

push是本地rq上task数量较多，需要push到其他rq上运行。

RT调度器中，RT task按照优先级依次插入每个cpu的rt_rq 优先级队列中，

task的出队入队操作比较简单，就是队列的操作，
因此它的负载均衡的处理也比较简单，我们先看下RT调度器的负载均衡。

/*
遍历所有cpu，将其他cpu上第二高的rt task 移到当前cpu上，
这样就可以从当前cpu上选择一个最高优先级的rt task运行(未考虑cpu affine???)
1、进程是其所在的run_queue中优先级第二高的（优先级最高的进程必定正在运行，不需要移动）；
2、进程的优先级比当前run_queue中最高优先级的进程还要高；
3、进程允许在当前CPU上运行（没有亲和性限制affine）；
*/
static int pull_rt_task(struct rq *this_rq)
{
int this_cpu = this_rq->cpu, ret = 0, cpu;
struct task_struct *p;
struct rq *src_rq;

if (likely(!rt_overloaded(this_rq)))
return 0;

/*
遍历this_rq的cpu set，将目标cpu第二高优先级的task移到this_rq
*/
for_each_cpu(cpu, this_rq->rd->rto_mask) {
if (this_cpu == cpu)
continue;

src_rq = cpu_rq(cpu);

/*
* Don't bother taking the src_rq->lock if the next highest
* task is known to be lower-priority than our current task.
* This may look racy, but if this value is about to go
* logically higher, the src_rq will push this task away.
* And if its going logically lower, we do not care
*/
//等待src_rq 主动push ?
if (src_rq->rt.highest_prio.next >=
this_rq->rt.highest_prio.curr)
continue;

/*
* We can potentially drop this_rq's lock in
* double_lock_balance, and another CPU could
* alter this_rq
*/
double_lock_balance(this_rq, src_rq);

/*
* Are there still pullable RT tasks?
*/
//src_rq 中运行的rt task数量太少，没有必要pull
if (src_rq->rt.rt_nr_running <= 1)
goto skip;
//查找srq_rq中第二高优先级task，可能是同优先级的其他未运行task也可能是更低的优先级task
p = pick_next_highest_task_rt(src_rq, this_cpu);

/*
* Do we have an RT task that preempts
* the to-be-scheduled task?
*/
//将所有cpu遍历一遍，找到可以迁移task中优先级最高的rt task
if (p && (p->prio < this_rq->rt.highest_prio.curr)) {
WARN_ON(p == src_rq->curr);
WARN_ON(!p->on_rq);

/*
* There's a chance that p is higher in priority
* than what's currently running on its cpu.
* This is just that p is wakeing up and hasn't
* had a chance to schedule. We only pull
* p if it is lower in priority than the
* current task on the run queue
*/
if (p->prio < src_rq->curr->prio)
goto skip;

ret = 1;

deactivate_task(src_rq, p, 0);//将p移到src_rq的尾部
set_task_cpu(p, this_cpu);
activate_task(this_rq, p, 0); //将p移到所在rq的队尾，同时将p加入this_rq的task cache list中
/*
* We continue with the search, just in
* case there's an even higher prio task
* in another runqueue. (low likelihood
* but possible)
*/
}
skip:
double_unlock_balance(this_rq, src_rq);
}

return ret;
}

/* Return the second highest RT task, NULL otherwise */
static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu)
{
struct task_struct *next = NULL;
struct sched_rt_entity *rt_se;
struct rt_prio_array *array;
struct rt_rq *rt_rq;
int idx;

//leaf_rt_rq_list 遍历
for_each_leaf_rt_rq(rt_rq, rq) {
array = &rt_rq->active;
idx = sched_find_first_bit(array->bitmap);
next_idx:
if (idx >= MAX_RT_PRIO)
continue;
if (next && next->prio <= idx)
continue;
list_for_each_entry(rt_se, array->queue + idx, run_list) {//遍历优先级队列queue
struct task_struct *p;

//实体是否为task
if (!rt_entity_is_task(rt_se))
continue;

p = rt_task_of(rt_se);
//p未运行，并且所在cpu属于rq的cpu set，就是找到了合适的task
if (pick_rt_task(rq, p, cpu)) {
next = p;
break;
}
}
//获取下个优先级队列
if (!next) {
idx = find_next_bit(array->bitmap, MAX_RT_PRIO, idx+1);
goto next_idx;
}
}

return next;
}

/*
* If the current CPU has more than one RT task, see if the non
* running task can migrate over to a CPU that is running a task
* of lesser priority.
*/
/*
把当前run_queue中多余的实时进程推给其他run_queue
1、每次push一个进程，这个进程的优先级在当前run_queue中是第二高的（优先级最高的进程必定正在运行，不需要移动）；
2、目标run_queue上正在运行的不是实时进程（是普通进程），或者是top-N中优先级最低的实时进程，且优先级低于被push的进程；
3、被push的进程允许在目标CPU上运行（没有亲和性限制）；
4、满足条件的目标run_queue可能存在多个（可能多个CPU上都没有实时进程在运行），应该选择与当前CPU最具亲缘性的一组CPU中的第一个CPU所对应的run_queue作为push的目标（顺着sched_domain--调度域--逐步往上，找到第一个包含目标CPU的sched_domain。见后面关于sched_domain的描述）；

*/
static int push_rt_task(struct rq *rq)
{
struct task_struct *next_task;
struct rq *lowest_rq;
int ret = 0;

//当前rq未超载，直接返回
if (!rq->rt.overloaded)
return 0;
//从当前rq中选择一个task push给其他运行队列
next_task = pick_next_pushable_task(rq);
if (!next_task)
return 0;

retry:
if (unlikely(next_task == rq->curr)) {
WARN_ON(1);
return 0;
}

/*
* It's possible that the next_task slipped in of
* higher priority than current. If that's the case
* just reschedule current.
*/

if (unlikely(next_task->prio < rq->curr->prio)) {
resched_task(rq->curr);
return 0;
}

/* We might release rq lock */
get_task_struct(next_task);

/* find_lock_lowest_rq locks the rq if found */
//查找负载最小的运行队列
lowest_rq = find_lock_lowest_rq(next_task, rq);
//未找到lowest_rq, 是否要继续查找
if (!lowest_rq) {
struct task_struct *task;
/*
* find_lock_lowest_rq releases rq->lock
* so it is possible that next_task has migrated.
*
* We need to make sure that the task is still on the same
* run-queue and is also still the next task eligible for
* pushing.
*/
task = pick_next_pushable_task(rq);
//无法迁移的话直接退出
if (task_cpu(next_task) == rq->cpu && task == next_task) {
/*
* The task hasn't migrated, and is still the next
* eligible task, but we failed to find a run-queue
* to push it to.  Do not retry in this case, since
* other cpus will pull from us when ready.
*/
goto out;
}

if (!task)
/* No more tasks, just exit */
goto out;

/*
* Something has shifted, try again.
*/
//最初选定的next_task 已经发生改变，重新选择一个pushable task
put_task_struct(next_task);
next_task = task;
goto retry;
}

deactivate_task(rq, next_task, 0);//从rq中移除next_task
set_task_cpu(next_task, lowest_rq->cpu);//设置next_task 移到lowset-rq->cpu
activate_task(lowest_rq, next_task, 0);//将next_task 添加到lowset_rq中
ret = 1;

resched_task(lowest_rq->curr);//重新调度lowest_rq 的task

double_unlock_balance(rq, lowest_rq);

out:
put_task_struct(next_task);

return ret;
}

/* Will lock the rq it finds */
//task is the push task,rq is current cpu rq
static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
{
struct rq *lowest_rq = NULL;
int tries;
int cpu;

for (tries = 0; tries < RT_MAX_TRIES; tries++) {
cpu = find_lowest_rq(task);

if ((cpu == -1) || (cpu == rq->cpu))
break;

lowest_rq = cpu_rq(cpu);

/* if the prio of this runqueue changed, try again */
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.
*/
if (unlikely(task_rq(task) != rq ||
!cpumask_test_cpu(lowest_rq->cpu,
tsk_cpus_allowed(task)) ||
task_running(rq, task) ||
!task->on_rq)) {

double_unlock_balance(rq, lowest_rq);
lowest_rq = NULL;
break;
}
}

/* If this rq is still suitable use it. */
//两个rq都是实时进程，并且lowest_rq 正在运行的task优先级更高，
//不需要其他进一步调整，直接返回lowest_rq,
if (lowest_rq->rt.highest_prio.curr > task->prio)
break;

/* try again */
double_unlock_balance(rq, lowest_rq);
lowest_rq = NULL;
}

return lowest_rq;
}

//查找负载最小的运行队列，task是pushed task
static int find_lowest_rq(struct task_struct *task)
{
struct sched_domain *sd;
struct cpumask *lowest_mask = __get_cpu_var(local_cpu_mask);
int this_cpu = smp_processor_id();//当前运行的cpu
int cpu      = task_cpu(task);//task所在cpu

if(this_cpu!=cpu){
printk(KERN_ERR "this_cpu:%d task cpu:%d\n",this_cpu,cpu);
}
if (sched_enable_hmp)
return find_lowest_rq_hmp(task);

/* Make sure the mask is initialized first */
if (unlikely(!lowest_mask))
return -1;
//task不允许在其他cpu运行
if (task->nr_cpus_allowed == 1)
return -1; /* No other targets possible */

//查找task 优先级最低的cpu set
if (!cpupri_find(&task_rq(task)->rd->cpupri, task, lowest_mask))
return -1; /* No targets found */

/*
* At this point we have built a mask of cpus representing the
* lowest priority tasks in the system.  Now we want to elect
* the best one based on our affinity and topology.
*
* We prioritize the last cpu that the task executed on since
* it is most likely cache-hot in that location.
*/
//找到一组cpu后根据cpu亲缘关系跟拓扑结构选择最优的cpu，
//基于cache原因，优先选择task上次执行的cpu
if (cpumask_test_cpu(cpu, lowest_mask))
return cpu;

/*
* Otherwise, we consult the sched_domains span maps to figure
* out which cpu is logically closest to our hot cache data.
*/
if (!cpumask_test_cpu(this_cpu, lowest_mask))
this_cpu = -1; /* Skip this_cpu opt if not among lowest */

rcu_read_lock();
//从跟task所在cpu具有亲缘关系的sched_domain中查找
for_each_domain(cpu, sd) {
if (sd->flags & SD_WAKE_AFFINE) {
int best_cpu;

/*
* "this_cpu" is cheaper to preempt than a
* remote processor.
*/
if (this_cpu != -1 &&
cpumask_test_cpu(this_cpu, sched_domain_span(sd))) {
rcu_read_unlock();
return this_cpu;
}

best_cpu = cpumask_first_and(lowest_mask,
sched_domain_span(sd));
if (best_cpu < nr_cpu_ids) {
rcu_read_unlock();
return best_cpu;
}
}
}
rcu_read_unlock();

/*
* And finally, if there were no matches within the domains
* just give the caller *something* to work with from the compatible
* locations.
*/
if (this_cpu != -1)
return this_cpu;

cpu = cpumask_any(lowest_mask);
if (cpu < nr_cpu_ids)
return cpu;
return -1;
}