调度器分析

最新推荐文章于 2024-09-30 16:58:10 发布

weijitao

最新推荐文章于 2024-09-30 16:58:10 发布

阅读量722

点赞数 1

分类专栏： Linux内核

本文链接：https://blog.csdn.net/weijitao/article/details/79517474

版权

Linux内核专栏收录该内容

19 篇文章 5 订阅

订阅专栏

Linux中有两种调度器，一个是主调度器，一个是周期性调度器。主调度器函数就是schedule函数，当进程打算睡眠或者其他原因放弃CPU时，就会直接调用此函数。周期性调度器就是schedule_tick函数，它在时钟中断中调用，以固定的频率运行。

周期性调度器

内核会按照频率HZ自动调用schedule_tick函数。周期性调度器不负责进程的切换，只是更新调度相关的信息，以备主调度器使用。

在分析schedule_tick函数之前，先看下一些重要的数据结构。

数据结构

runqueue

unsigned long expired_timestamp; /*记录expired数组中最早用完时间片的时间*/

unsigned long long timestamp_last_tick;

task_t *curr, *idle;

prio_array_t *active, *expired, arrays[2];

int best_expired_prio; /*记录expired数组中最高优先级*/

◆active队列对应还有时间片的进程，expired队列对应时间片耗尽必须重新分配时间片的进程。array二元数组是两类队列的容器。

◆一个runqueue对应一个cpu，一个cpu上只能同时运行一个进程，一个runqueue里面只有一个curr。

prio_array

struct prio_array {

unsigned int nr_active; /*本组中待处理进程的总数*/

unsigned long bitmap[BITMAP_SIZE]; /*用位图的方式表示某个优先级上有没有待处理的进程队列*/

struct list_head queue[MAX_PRIO]; /*与bitmap对应，存储所有待运行的进程*/

};

◆内核中进程有140种优先级，这里BITMAP_SIZE计算出来为5，unsigned long大小为32，这样32*5=160 > 140，每种优先级用1位表示，这样bitmap就足够表示内核的140种优先级，每个优先级上有没有待处理的进程。

函数分析

schedule_tick函数代码片段：

int cpu = smp_processor_id();

runqueue_t *rq = this_rq();

task_t *p = current;

unsigned long long now = sched_clock();

update_cpu_clock(p, rq, now);

rq->timestamp_last_tick = now;

if (p == rq->idle) { /*如果当前进程是idle进程*/

if (wake_priority_sleeper(rq))

goto out;

rebalance_tick(cpu, rq, SCHED_IDLE);

return;

}

如果当前进程是idle进程，需要检查wake_priority_sleeper函数，此函数会检查当前CPU是否存在一个逻辑兄弟cpu，且其运行队列上有可运行的进程，那么说明之前是因为兄弟cpu上有高优先级的进程在运行，为了不打扰此逻辑CPU，因此选择idle进程。wake_priority_sleeper函数会重新调度，选择合适的进程运行。

if (rt_task(p)) { /*当前进程是实时进程*/

if ((p->policy == SCHED_RR) && !--p->time_slice) {

p->time_slice = task_timeslice(p); /*重新计算时间片*/

p->first_time_slice = 0;

set_tsk_need_resched(p);

/* put it at the end of the queue: */

requeue_task(p, rq->active);

}

goto out_unlock;

}

如果当前进程是实时进程，调度策略为Round-Robin，且时间片已经用完了，则重新计算时间片。first_time_slice清零表明进程在退出时不会将剩余的时间片返还给父进程。设置TIF_NEED_RESCHED标志，并将进程插入active队列的末尾。

/*Normal进程*/

if (!--p->time_slice) { /*时间片已用完*/

dequeue_task(p, rq->active); /*从活跃队列中删除*/

set_tsk_need_resched(p);

p->prio = effective_prio(p); /*计算动态优先级*/

p->time_slice = task_timeslice(p);

p->first_time_slice = 0;

if (!rq->expired_timestamp) /*为0表示第一个切换到expired队列中的进程*/

rq->expired_timestamp = jiffies;

/*不是交换进程；或者expired队列中的进程等待了足够长的时间*/

if (!TASK_INTERACTIVE(p) || EXPIRED_STARVING(rq)) {

enqueue_task(p, rq->expired);

if (p->static_prio < rq->best_expired_prio)

rq->best_expired_prio = p->static_prio;

} else

enqueue_task(p, rq->active);

} else {

if (TASK_INTERACTIVE(p) && !((task_timeslice(p) -

p->time_slice) % TIMESLICE_GRANULARITY(p)) &&

(p->time_slice >= TIMESLICE_GRANULARITY(p)) && /*进程的剩余时间片过长*/

(p->array == rq->active)) {

requeue_task(p, rq->active);

set_tsk_need_resched(p);

}

如果当前进程不是实时进程，且时间片已用完。将此进程从active队列中删除，并设置TIF_NEED_RESCHED标志，重新计算动态优先级和时间片。

●TASK_INTERACTIVE宏用来判断一个进程是否为交互式进程。基于nice值来判断，nice值越高，优先级越低，交互性也越低。

#define TASK_INTERACTIVE(p) ((p)->prio <= (p)->static_prio - DELTA(p))

如果一个进程的交互性越强，在其时间片用完之后，不会移到expired队列中，而是插入原来的队列中。这样交互式进程可以快速的响应用户。

●EXPIRED_STARVING宏用来判断expired队列中的进程是否等待了足够长的时间，以避免expired队列中的进程等待太久而没有机会执行到。

#define EXPIRED_STARVING(rq) \

((STARVATION_LIMIT && ((rq)->expired_timestamp && \

(jiffies - (rq)->expired_timestamp >= \

STARVATION_LIMIT * ((rq)->nr_running) + 1))) || \

((rq)->curr->static_prio > (rq)->best_expired_prio))

条件1：当前时间(jiffies)减去expired队列中等待最久的时间(expired_timestamp)之差大于STARVATION_LIMIT * ((rq)->nr_running) + 1)。说明进程已经等待了足够长的时间。

条件2：当前进程的优先级比expired中最高的优先级要低。

上述两个条件只要有一个满足就说明expired队列中的进程等待了足够长的时间。

如果进程不是交互进程，或者expired队列中进程等待了足够长的时间，就会将其插入expired队列中，否则插入active队列。

如果当前进程不是实时进程，且时间片还没有用完。剩余的时间片过长，大于进程的时间片粒度，则将其插入active队列的末尾，这实际就是Round-Robin策略。

主调度器

主调度器函数为schedule函数，它主要是选择一个进程以替换当前正在运行的进程，当进程缺少自己申请的相应资源时，就会调用schedule函数让出处理器。

下面分析schedule函数代码实现：

if (likely(!current->exit_state)) {

if (unlikely(in_atomic())) {

printk(KERN_ERR "scheduling while atomic: "

"%s/0x%08x/%d\n",

current->comm, preempt_count(), current->pid);

dump_stack();

}

如果当前进程正在运行，且处于原子态，那么就不能切换给其他进程。这也是为什么不能再中断中调用可能睡眠的函数的原因。

need_resched:

preempt_disable(); /*关内核抢占*/

prev = current;

need_resched_nonpreemptible:

rq = this_rq();

/*idle进程里面调用了休眠函数，导致被调度*/

if (unlikely(prev == rq->idle) && prev->state != TASK_RUNNING) {

printk(KERN_ERR "bad: scheduling from the idle thread!\n");

dump_stack();

}

/*计算prev运行时间*/

now = sched_clock();

if (likely((long long)(now - prev->timestamp) < NS_MAX_SLEEP_AVG)) {

run_time = now - prev->timestamp;

if (unlikely((long long)(now - prev->timestamp) < 0))

run_time = 0;

} else

run_time = NS_MAX_SLEEP_AVG;

run_time /= (CURRENT_BONUS(prev) ? : 1);

spin_lock_irq(&rq->lock); /*关闭当前cpu中断，并获取spinlock锁*/

if (unlikely(prev->flags & PF_DEAD)) /*检查进程是否已终止*/

prev->state = EXIT_DEAD;

上面代码部分首先关内核抢占，如果prev进程是idle进程，但不是运行状态，这说明idle进程里面调用了休眠函数，导致被调度了，因此会有相应的警告信息。

接着就是计算prev进程的运行时间，并将其值转换为纳秒。

最后检查prev进程是否已经终止，如果为真，就设置state为EXIT_DEAD。

switch_count = &prev->nivcsw; /*当前进程上下文切换次数*/

if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {

switch_count = &prev->nvcsw;

if (unlikely((prev->state & TASK_INTERRUPTIBLE) && unlikely(signal_pending(prev))))

prev->state = TASK_RUNNING; /*设置为可运行进程，保留在可运行队列中*/

else {

if (prev->state == TASK_UNINTERRUPTIBLE)

rq->nr_uninterruptible++;

deactivate_task(prev, rq); /*从运行队列中移除进程*/

}

prev->state不为0表示prev进程是不可运行的状态（TASK_RUNNING为0）。如果prev进程是不可运行状态，且在没有在内核态被抢占，那么就会进入此段代码执行。
当prev进程是可中断的睡眠状态时，并且有挂起的信号需要处理，则设置prev的state字段为TASK_RUNNING，prev为可运行进程，保留在可运行队列中。否则将prev进程从运行队列中移除。

上面的部分是对prev进程也就是当前进程的处理，下面开始选择next进程，即使替换当前进程运行的一个进程。

cpu = smp_processor_id();

if (unlikely(!rq->nr_running)) { /*运行队列中没有可运行进程*/

go_idle:

idle_balance(cpu, rq); /*从其他运行队列中迁移可运行进程到当前队列中*/

if (!rq->nr_running) { /*迁移失败*/

next = rq->idle;

rq->expired_timestamp = 0;

wake_sleeping_dependent(cpu, rq); /*调度可运行cpu中的可运行进程*/

if (!rq->nr_running)

goto switch_tasks;

}

} else { /*运行队列中有可运行进程*/

if (dependent_sleeper(cpu, rq)) {

next = rq->idle;

goto switch_tasks;

}

if (unlikely(!rq->nr_running))

goto go_idle; /*跳转到go_idle重新尝试迁移进程*/

}

如果运行队列中没有可运行进程，那么调用idle_balance函数从其他运行队列中迁移可运行进程到当前队列中。调用此函数后，再判断当前队列中是否有可运行进程，如果还是没有可运行进程，说明迁移失败了，选择idle进程作为next进程。调用wake_sleeping_dependent函数重新调度可运行CPU中的可运行进程。

如果运行对列中有可运行进程，不能简单的选择从当前队列中选择一个优先级高的进程来运行。如果这个cpu有一个逻辑兄弟cpu，且逻辑兄弟Cpu上运行着一个优先级要比选择的进程优先级高的进程，那么久不能打扰逻辑兄弟CPU上这个正在运行的进程（因为两个逻辑兄弟CPU共用一个mmu和一级cache），因此这个cpu上选择运行idle，也就是next选择为rq->idle。

上面的这两种情况为了正确的选择一个next进程。如果选择到了合适的next进程，就直接跳转到switch_tasks标签处执行进程切换。

array = rq->active;

if (unlikely(!array->nr_active)) { /*可运行进程数组中没有待执行的进程*/

schedstat_inc(rq, sched_switch);

rq->active = rq->expired;

rq->expired = array;

array = rq->active; /*交换active和expired域*/

rq->expired_timestamp = 0;

rq->best_expired_prio = MAX_PRIO;

}

如果运行队列的active进程组中没有待执行的进程，那么交换运行对列中的active域和expired域。

idx = sched_find_first_bit(array->bitmap); /*查找位图中首个可运行进程*/

queue = array->queue + idx;

next = list_entry(queue->next, task_t, run_list);

/*Normal进程，actived大于0说明是从TASK_INTERRUPTIBLE或者TASK_STOPPED状态唤醒的*/

if (!rt_task(next) && next->activated > 0) {

unsigned long long delta = now - next->timestamp;

if (unlikely((long long)(now - next->timestamp) < 0))

delta = 0;

if (next->activated == 1)

delta = delta * (ON_RUNQUEUE_WEIGHT * 128 / 100) / 128;

array = next->array;

dequeue_task(next, array);

recalc_task_prio(next, next->timestamp + delta);

enqueue_task(next, array);

}

next->activated = 0;

调用sched_find_first_bit函数查找active进程数组中优先级最高的进程的ID，通过此ID获取对应的进程next。

task_t结构体的activated字段值意义：

Activated值	含义
-1	从TASK_UNINTERRUPTIBLE状态唤醒
0	初始化
1	被系统调用服务程序或内核线性唤醒
2	被中断或者被延迟函数唤醒