From: 全面解析Linux 内核 3.10.x - 进程调度

Linux 调度器 - Volker Seeker · 爱丁堡大学 2013.05.12

本文档包含了Linux内核如何处理进程调度注意事项。
它们涵盖一般调度器框架、调度类、完全公平调度（CFS）算法、软实时调度以及负载均衡的实时和CFS。
在此文档中采用的Linux内核版本是3.1.10，使用的终端设备为搭载android 4.2的Nexus 7;

1、进程调度

现代的Linux内核需要支撑多任务的。因此，一个以上的进程被允许存在于任何给定的时间，每一个进程被允许执行，就好像它是唯一的处理上系统。 进程调度协调哪些进程运行时在，它具有以下任务：

• 在所有当前正在运行的进程之间共享CPU
• 选取适当的进程来运行下一步，如果需要，考虑调度类/策略以及进程优先级
• 在多核SMP系统上平衡调度

1.1、Linux 的进程/线程

Linux的进程是一组共享一个线程组ID（TGID）和任何的线程资源必要和在两者之间不区分。内核调度各个线程，而不是进程。因此，术语“任务”将被用于所述文档的其余部分，以指一个线程。task_struct中（在include/linux/sched.h中）在Linux中使用的数据结构，其中包含所有的 关于特定任务的信息。

2、任务/进程分类

2.1、CPU 受限和I/O受限

传统上总是将进程分类为I/O受限或CPU受限，I/O受限表示频繁的使用I/O设备，并花费很多时间等待I/O操作完成，CPU受限则表示某些线程/进程需要大量的CPU时间来做计算。

2.2 实时任务/进程 VS 正常任务/进程

Linux 上运行的任务可以列为实时 (RT) 或正常的任务。实时任务有严格的时间要求，因此优先接收任何其他任务系统。不同的调度策略用于RT和正常的任务中的实现通过使用调度类调度程序。

2.3 任务/进程优先级

内核较高优先级有一个数值较小的值。实时优先级的范围从1（最高）- 99，而正常优先级的范围从100 - 139（最低）。不过，有使用系统调用或调度程序库函数来确定优先事项时的混乱。在那里，数值的顺序可以颠倒或映射到不同的值 （nice值）。

3、调度类

Linux 调度器是模块化，使不同的算法/策略，安排不同类型任务。算法实现被包裹在一个所谓的调度类。调度类提供了一个接口到主调度程序框架，它可用于处理依据任务实现的算法。
此调度类的相关定义可以在include/linux/sched.h 中发现:

struct sched_class {
    const struct sched_class *next;

    void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
    void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
    void (*yield_task) (struct rq *rq);
    bool (*yield_to_task) (struct rq *rq, struct task_struct *p, bool preempt);

    void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags);

    struct task_struct * (*pick_next_task) (struct rq *rq);
    void (*put_prev_task) (struct rq *rq, struct task_struct *p);

#ifdef CONFIG_SMP
    int  (*select_task_rq)(struct task_struct *p, int sd_flag, int flags);

    void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
    void (*post_schedule) (struct rq *this_rq);
    void (*task_waking) (struct task_struct *task);
    void (*task_woken) (struct rq *this_rq, struct task_struct *task);

    void (*set_cpus_allowed)(struct task_struct *p,
                 const struct cpumask *newmask);

    void (*rq_online)(struct rq *rq);
    void (*rq_offline)(struct rq *rq);
#endif

    void (*set_curr_task) (struct rq *rq);
    void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
    void (*task_fork) (struct task_struct *p);

    void (*switched_from) (struct rq *this_rq, struct task_struct *task);
    void (*switched_to) (struct rq *this_rq, struct task_struct *task);
    void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
                 int oldprio);

    unsigned int (*get_rr_interval) (struct rq *rq,
                     struct task_struct *task);

#ifdef CONFIG_FAIR_GROUP_SCHED
    void (*task_move_group) (struct task_struct *p, int on_rq);
#endif
};

除了第一个成员外，此结构的所有成员都是由使用的函数指针来实现调度类框架对用的hook(钩子函数)实现。
在内核中的所有现有调度类是按优先级的排序的列表中调度类。被称为该结构的第一个成员下一步是一个指针，指向下一个调度类具有较低的优先级，该列表中。使用列表来优先考虑不同类型在别人面前的任务。在当前Linux 版本中，其初始流程如下所示︰

stop_sched_class → rt_sched_class → fair_sched_class → idle_sched_class → NULL

Stop 以及 idel 是两个特殊的调度类，Stop 调度类的原理是利用每cpu(per-cpu)变量配置每CPU停止一切任务操作，Idel调度类的原理是利用idle任务(其实就是swapper进程)。 which is run if no other task is runnable. The other two are for
the previously mentioned real time and normal tasks

4、主要数据结构 Runqueue

系统中每个CPU都有自己的运行队列，所有的runqueue结构都放在每CPU变量中并且被定义在kernel/sched.c，保留了可追踪所有可运行任务对应CPU相关的调度统计以及负载均衡调度域的信息；另外它还有：
- CPU对同步锁的调度操作。
raw_spinlock_t lock；
- 一个指向正在运行任务的task指针，以及idel 任务指针，stop任务指针。
struct task_struct *curr, *idle, *stop;
- fair(公平调度)以及实时调度类的运行队列数据结构。
struct cfs_rq cfs;
struct rt_rq rt;

5、调度器框架

5.1、调度器入口指针

所有的进程调度器的入口指针都是schedule()函数，定在在kernel/sched.c文件中。这个函数调用内核进程是通过调用进程调度器，从而决定运行那个进程，然后运行它。
schedul()函数的主要目标是找到下一个需要运行的任务，并且将CPU分配给此任务。最后，它执行上下文切换到这个新的任务。如果没有其它任务(上一级的上一级任务)的优先级超过当前任务，那么schedul()函数就reschedul回来；
关于schedul函数的细节请看下面代码：

    static void __sched __schedule(void)
    {
        struct task_struct *prev, *next;
        unsigned long *switch_count;
        struct rq *rq;
        int cpu;

    need_resched:
        preempt_disable();
        cpu = smp_processor_id();
        rq = cpu_rq(cpu);
        rcu_note_context_switch(cpu);
        prev = rq->curr;

        schedule_debug(prev);

        if (sched_feat(HRTICK))
            hrtick_clear(rq);

        raw_spin_lock_irq(&rq->lock);

        switch_count = &prev->nivcsw;
        if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
            if (unlikely(signal_pending_state(prev->state, prev))) {
                prev->state = TASK_RUNNING;
            } else {
                deactivate_task(rq, prev, DEQUEUE_SLEEP);
                prev->on_rq = 0;

                /*
                 * If a worker went to sleep, notify and ask workqueue
                 * whether it wants to wake up a task to maintain
                 * concurrency.
                 */
                if (prev->flags & PF_WQ_WORKER) {
                    struct task_struct *to_wakeup;

                    to_wakeup = wq_worker_sleeping(prev, cpu);
                    if (to_wakeup)
                        try_to_wake_up_local(to_wakeup);
                }
            }
            switch_count = &prev->nvcsw;
        }

        pre_schedule(rq, prev);

        if (unlikely(!rq->nr_running))
            idle_balance(cpu, rq);

        put_prev_task(rq, prev);
        next = pick_next_task(rq);
        clear_tsk_need_resched(prev);
        rq->skip_clock_update = 0;

        if (likely(prev != next)) {
            rq->nr_switches++;
            rq->curr = next;
            ++*switch_count;

            context_switch(rq, prev, next); /* unlocks the rq */
            /*
             * The context switch have flipped the stack from under us
             * and restored the local variables which were saved when
             * this task called schedule() in the past. prev == current
             * is still correct, but it can be moved to another cpu/rq.
             */
            cpu = smp_processor_id();
            rq = cpu_rq(cpu);
        } else
            raw_spin_unlock_irq(&rq->lock);

        post_schedule(rq);

        sched_preempt_enable_no_resched();
        if (need_resched())
            goto need_resched;
    }

自从Linux 内核可抢占以后，总是高优先级的任务会在内核空间执行代码段。当一个任务在抢占后进入内核空间执行的时候，暂停它的唯一条件就是当有新的任务进行schedul()操作。因此，首先schedul()函数通过调用preempt_dsiabel()关闭抢占，所以线程的调度不能在当前关键操作的时候进行抢占。
其次，它建立了一种通过锁住当前CPU运行队列当只有一个线程在特定的时间片允许修改当前运行的队列的锁机制，确保的资源的唯一性。
然后，schedul()函数检查在上一个时间片中上一个任务的执行状态。如果在”内核态”下是没有运行并且没在被抢占，那么意味着可以移除当前的运行队列。然而，如果有noblocking(操作未完成，函数返回)的挂起信号，那么就降状态设置为“TASK_RUNNING”并且将此排在左侧。意思就是上一个任务获取另一个任务并且改变要被执行的任务。
移除一个正在执行的任务是通过调用下面函数；

static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
{
    update_rq_clock(rq);
    sched_info_dequeued(p);
    p->sched_class->dequeue_task(rq, p, flags);
}

下一个动作是判断是否有正在运行的任务存在在当前的CPU运行队列。如果没有，调用idle_balance()。
get_prev_task()是一个当切换CPU的时候可以给给定的任务进行通知的调度类的钩子函数。

5.2、调用调度器

---

By: Keven - 点滴积累