Linux内核分析——第四章进程调度

　　　　　　　　　　　　　　　第四章进程调度

4.1 多任务

　　1、多任务操作系统就是能同时并发的交互执行多个进程的操作系统。

　　2、多任务操作系统使多个进程处于堵塞或者睡眠状态，实际不被投入执行，这些任务尽管位于内存，但是并不处于可运行状态。

　　3、多任务系统分类：

　　　　（1）非抢占式多任务

　　　　（2）抢占式多任务

　　4、Linux提供了抢占式的多任务模式。在此模式下，由调度程序来决定什么时候停止一个进程的运行，以便其他进程能够得到执行机会。这个强制的挂起动作叫做抢占。进程被抢占之前能够运行的时间是预先设置好的，叫进程的时间片。时间片实际上就是分配给每个可运行进程的处理器时间段。

　　5、在非抢占式多任务模式下，除非进程自己主动停止运行，否则它会一直执行。进程主动挂起自己的操作称为让步。但这种机制有很多缺点：调度程序无法躲每个进程该执行多长时间作出统一规定，所以进程独占的处理器时间可能会超过用户的预料：更糟的是，一个绝不做出让步的悬挂进程就能使系统崩溃。

4.2Linux的进程调度

　　1、O(1)调度器拥有数以十计的多处理器的环境，但缺少交互进程。

　　2、反转楼梯最后期限调度算法（RSDL），吸取了队列理论，公平调度。又被称为完美公平调度算法（CFS）。

4.3策略

　　1、决定调度程序在何时让进程运行。

4.3.1 I/O消耗型和处理器消耗型的进程

　　1、进程可以分为：

　　　　（1）I/O消耗型：进程的大部分时间用来提交I/O请求或者等待I/O请求，经常处于可运行状态但是运行时间很短，等待更多的请求时最后总会阻塞。

　　　　（2）处理器消耗型：把时间大多用在执行代码上，除非被抢占，否则通常都会不停地运行。因为它们没有太多的I/O需求。不属于I/O驱动类型。

　　2、调度策略：尽量降低它们的调度频率，延长其运行时间。

　　3、调度策略通常要在两个矛盾的目标中间寻找平衡：

　　　　（1）进程调度迅速（响应时间短）

　　　　（2）最大系统利用率（高吞吐量）

　　4、Linux倾向于优先调度I/O消耗型进程。

4.3.2 进程优先级

　　1、调度算法中最基本的一类就是基于优先级的调度，这是一种根据进程的价值和其对处理器时间的需求来对进程分级的想法。

　　2、调度程序总是选择时间片未用尽而且优先级最高的进程运行。

　　3、 Linux采用了两种不同的优先级范围：

　　　　（1）nice

　　　　　　范围[-20,19]，默认值为0；nice值越大，优先级越低；

　　　　　　Linux系统中nice值代表时间片的比例，可以通过ps-el命令查看系统中进程列表，结果中标记NI的一列及时进程对应的nice值。

　　　　（2）实时优先级

　　　　　　其值可以配置，默认变化范围是[0,99]；值越高优先级越高；

　　4、任何实时进程的优先级都高于普通的进程，也就是说实时优先级和nice优先级处于互不相交的两个范畴。

　　5、通过命令ps-eo state,uid,pid,ppid,rtprio,time,comm.查看系统中的进程列表以及对应的实时优先级（位于RTPRIO列下），其中如果有进程对应列显示“-”则说明它不是实时进程。

4.3.3 时间片

　　1、时间片表示进程在被抢占前所能持续运行的时间。

　　2、I/O消耗型进程不需要很长的时间片，而处理器消耗型进程希望时间片越长越好。

　　3、Linux的CFS调度器没有直接分配时间片到进程，而是将处理器的使用比划分给进程。这样一来，进程所获得的处理器时间和系统负载密切相关。这个比例受nice值影响，nice值作为权重来调整进程所使用的处理器时间使用比。

　　4、Linux系统是抢占式的，是否要将一个进程立刻投入运行（也就是抢占当前进程），是完全由进程的优先级和是否有时间片来决定。

　　5、CFS调度器：抢占时机取决于新的可执行程序消耗了多少处理器使用比，如果消耗的使用比当前进程小：新程序立刻投入运行，抢占当前进程，否则推迟。

4.3.4 调度策略的活动

　　1、文字编辑程序显然是 1/0 消耗型的，因为它大部分时间都在等待用户的键盘输入（无论用户的输入速度有多快，都不可能赶上处理的速度）用户总是希望按下键系统就能马上响应。

　　2、视频编码程序是处理器消耗型的。

　　3、CFS总是会毫不犹豫地让文本编辑器在需要时被投入运行，而让视频处理程序只能在剩下的时刻运行。

4.4 Linux调度算法

4.4.1 调度器类

　　1、Linux调度器是以模块方式提供，目的是允许不同类型的进程可以有针对性地选择调度算法。这种模块化结构被称为调度器类，它允许多种不同的可动态添加的调度算法并存，调度属于自己范畴的进程。

　　2、基础的调度器代码定义在kernel/sched.c文件中。

　　3、每个调度器有一个优先级，会按照优先级顺序遍历调度类，选择优先级最高的调度器类。

　　4、完全公平调度CFS是一个针对普通进程的调度类。

4.4.2 Unix系统中的进程调度

　　1、Unix使用的调度算法是分配绝对的时间片，这样就会引发固定的切换频率，不利于公平性。而Linux采用的CFS完全摒弃了时间片，分配给进程一个处理器使用比重，保证恒定的公平性和变动的切换频率。

4.4.3 公平调度

　　1、CFS的做怯是允许每个进程运行一段时间、循环轮转、选择运行最少的进程作为下一个运行进程，而不再采用分配给每个进程时间片的做法了，在所有可运行进程总数基础上计算出一个进程应该运行多久。而不是依靠nice 值来计算时间片。

　　2、nice 值在 CFS 中被作为进程获得的处理器运行比的权重：越高的nice 值（越低的优先级）进程获得更低的处理器使用权重。

　　3、目标延迟：无限小调度周期的近似值

　　4、最小粒度：每个进程获得的时间片底线，默认为1ms。

　　5、任何进程所获得的处理器时间是由它自己和其他所有可运行进程nice 值的相对差值决定的。

4.5 Linux调度的实现

　　1、CFS调度算法的实现：

　　四个组成部分：

　　　　（1）时间记账

　　　　（2）进程选择

　　　　（3）调度器入口

　　　　（4）睡眠和唤醒

4.5.1 时间记账

　　1、所有的调度器都必须对进程运行时间做记账。

　　2、CFS 使用调度器实体烦结构（定义在文件＜linux/sched.h＞的 struct_sched _entity 中）来追踪进程运行记账。

　　3、CFS 使用 vruntime 变量来记录一个程序到底运行了多长时间以及它还应该再运行多久。

　　4、定义在kemeVsched_fair.c 文件中的 update_curr(）函数实现了该记账功能。

　　6、update_ currO 计算了当前进程的执行时间，并且将其存放在变量delta_exec 中。update_ curr（）是由系统定时器周期性调用。

4.5.2 进程选择

　　1、CFS调度算法的核心：选择具有最小vruntime的任务。

　　2、CFS使用红黑树来组织可运行进程队列，并利用其迅速找到最小vruntime值的进程。

　　3、Linux中，红黑树被称为rbtree，是一个自平衡二叉搜索树，是一种以树节点形式存储的数据，这些数据会对应一个键值，可以通过这些键值来快速检索节点上的数据，（重要的是，通过键值检索到对应节点的速度与整个树的节点规模成指数比关系）。

　　（1）挑选下一个任务

　　　　CFS的进程选择算法简单总结为“运行rbtree树种最左边叶子节点所代表的那个进程”。实现这一过程的函数是__pick_next_entity()。

　　　　__pick_next_entity()函数本身不会遍历树找到最左叶子节点，该值缓存在rb_leftmost字段中，函数返回值就是CFS选择的下一个运行进程。如果返回NULL，表示树空，没有可运行进程，这时选择idle任务运行。

　　（2）向树中加入进程

　　　　发生在进程被唤醒或者通过fork()调用第一次创建进程时。

　　　　函数enqueue_entity()：更新运行时间和其他一些统计数据，然后调用__enqueue_entity()。进行繁重的插入工作，把数据项真正插入到红黑树中：

　　　　link为null时循环终止，退出。

　　　　在父节点上调用rb_link_node()，使新插入的进程成为其子节点。

　　　　函数rb_insert_color()更新树的自平衡相关特性。

　　（3）从树中删除进程

　　　　删除动作发生在进程堵塞或终止时。

　　　　相关函数是dequeue_entity()和__dequeue_entity()：

　　　　rb_erase()函数删除进程

　　　　更新rb_leftmost缓存

　　　　如果删除的是最左节点，还要调用rb_next()按顺序遍历，找到新的最左节点。

4.5.3 调度器入口

　　1、进程调度的主要入口点函数是schedule()。它定义在文件kemel/sched.c中。

它会调用pick_next_task()；pick_next_task()会以优先级为序，从高到低依次检查每一个调度类，并且从最高优先级的调度类中选择最高优先级的进程。pick_next_task()会返回指向下一个可运行进程的指针，没有时返回NULL。

　　2、pick_next_task()函数实现会调用pick_next_entity()，而该函数会调用__pick_next_entity()函数。

4.5.4 睡眠和唤醒

　　1、休眠（被阻塞）的进程处于一个特殊的不可执行状态。

　　2、进程休眠有很多原因，但肯定都是为了等待一些事件。

　　3、休眠的一个常见的原因就是文件I/O——如进程对一个文件执行了read（）操作，而这需要从磁盘里读取。

　　4、内核的操作都相同：进程把自己标记成休眠状态，从可执行红黑树中移出，放入等待序列，然后调用schedule()选择和执行一个其他进程

　　5、唤醒的过程：进程被设置为可执行状态，然后再从等待队列中移到可执行红黑树中。

　　6、休眠有两种相关的进程状态：

　　　　（1）TASK_INTERRUPTIBLE

　　　　（2）TASK_UNINTERRUPTIBLE

　　唯一区别是处于TASK_UNINTERRUPTIBLE的进程会忽略信号，而处于TASK_INTERRUPTIBLE状态的进程如果接收到一个信号，会被提前唤醒并响应该信号

　　7、等待队列

　　　　等待队列是由等待某些事件发生的进程组成的简单链表

　　　　休眠通过等待队列进行处理。

　　　　内核用wake_queue_head_t来表示等待队列。

　　　　等待队列可以通过DECLARE_WAITQUEUE()静态创建，也可以由init_waitqueue_head()动态创建。

　　8、进程通过执行以下几个步骤将自己加入到一个等待队列中：

　　　　1）调用宏DEFINE_WAIT()创建一个等待队列的选项。

　　　　2）调用add_wait_queue()把自己加入到队列中。

　　　　3）调用prepare_to_wait()方法将进程的状态变更为TASK_INTERRUPTIBLE或TASK_UNINTERRUPTIBLE。

　　　　4）如果状态被设置成TASK_INTERRUPTIBLE，则信号唤醒进程。

　　　　5）当进程被唤醒的时候，会再次检查条件是否为真，真则退出循环，否则再次调用schedule()并且一直重复这步动作。

　　　　6）当条件满足后，进程将自己设置为TASK_RUNNING并调用finish_wait()方法把自己移出等待序列。

函数inotify_read()：负责从通知文件描述符中读取信息。

　　9、唤醒操作通过函数wake_up()进行，它会唤醒指定的等待队列上的所有进程。它调用try_to_wake_up()，该函数负责将进程设置成TASK_RUNNING状态，调用enqueue_task()将此进程放入红黑树中，如果被唤醒的进程优先级比正在执行的进程优先级高，设置need_resched标志。通常哪段代码促成等待条件达成，它就负责随后调用wake_up()函数。

　　10、关于休眠有一点需要注意，存在虚假的唤醒。有时候进程被唤醒并不是因为它所等待的条件达成了才需要用一个循环处理来保证它等待的条件真正达成。

4.6 抢占和上下文切换

　　1、上下文切换，也就是从一个可执行进程切换到另一个可执行进程，由定义在 kernel/ sched.c 中的 context_switch（）函数负责处理。

　　2、每当一个新的进程被选出来准备投入运行的时候， schedule()就会调用该函数。它完成了两项基本的工作：

　　　　（1）调用声明在＜asm/mmu_ context.h＞中的 switch_mm()，该函数负责把虚拟内存从上一个进程映射到新进程中。

　　　　（2）调用声明在 <asm/system.h> 中的 switch_to()，该函数负责从上一个进程的处理器状态切换到新进程的处理器状态。这包括保存、恢复栈信息和寄存器信息，还有其他任何与体系结构相关的状态信息，都必须以每个进程为对象进行管理和保存。

　　3、内核提供了一个need_resched标志来表明是否需要重新执行一次调度。当某个进程应该被抢占时，scheduler_tick()会设置这个标志：当一个优先级高的进程进入可执行状态时，try_to_wake_up()会设置这个标志。内核检查这个标志确认其被设置，调用schedule()来切换到一个新的进程。该标志对于内核来说是一个信息，表示youqitajinc应当被运行了，要尽快调用调度程序。再返回用户空间以及从中断返回时，内核也会检查标志。每个进程都包含一个need_resched标志，因为访问进程描述符里的数值比访问一个全局变量要快。

4.6.1 用户抢占

　　1、内核即将返回用户空间的时候，如果need_resched标志被设置，会导致schedule()被调用，此时会发生用户抢占。

　　2、用户抢占在以下情况时产生：

　　　　（1）从系统调返回用户空间时；

　　　　（2）从中断处理程序返回用户空间时；

4.6.2 内核抢占

　　1、Linux完整地支持内核抢占。

　　2、只要重新调度是安全的，内核就可以在任何时间抢占正在执行的任务。

　　3、内核抢占会发生在：

　　　　（1）中断处理程序正在执行，且返回内核空间之前

　　　　（2）内核代码再一次具有可抢占性的时候。

　　　　（3）如果内核中的任务显式地调用 schedule()

　　　　（4）如果内核中的任务阻塞（这同样也会导致调用schedule()）。

4.7 实时调度策略

　　1、Linux提供了两种实时调度策略：SCHED_FIFO和 SCHED_RR。而普通的、非实时的调度策略是SCHED_NORMAL。

　　2、SCHED_FIFO 实现了一种简单的、先入先出的调度算法。

　　3、SCHED_RR 是带有时闹片的 SCHED_FIFO，一种实时轮流调度算法。

　　4、这两种实时算法实现的都是静态优先级。内核不为实时进程计算动态优先级，这能保证给定优先级别的实时进程总能抢占优先级比它低的进程。

　　5、软实时：内核调度进程，尽力使进程在它的限定时间到来前进行，但内核不保证总能满足这些进程的要求。

　　6、硬实时：系统保证在一定条件下，可以满足任何调度的要求。

　　7、优先级范围

　　　　（1）实时：

　　　　范围：0~[MAX_RT_PRIO-1]。

　　　　　　默认MAX_RT_PRIO=100，所以默认实时优先级范围为[0,99]

　　　　（2）SCHED_NORMAL:

　　　　　　范围：
[MAX_RT_PRIO]~[MAX_RT_PRIO+40]

　　　　　　默认情况下，nice值从-20到+19对应的是从100到139的实时优先级范围。

4.8 与调度相关的系统调用

4.8.1 与调度策略和优先级相关的系统调用

　　1、sched_setparam（）和sched__getparam（）分别用于设置和获取进程的实时优先级

　　2、nice()函数可以将给定进程的静态优先级增加一个给定的量，只有超级用户才能在调用它时使用负值，从而提高进程的优先级。

　　3、nice（）函数会调用内核的 set_ user_ nice（）函数，这个函数会设置进程的 task_struct 的 static_prio 和prio 值。

4.8.2 与处理器绑定有关的系统调用

　　1、Linux调度程序提供强制的处理器绑定机制。也就是说，虽然它尽力通过一种软的亲和性试图使进程尽量在同一个处理器上运行，但它也允许用户强制指定“这个进程无论如何都必须在这些处理器上运行”。这种强制的亲和性保存在进程task_struct的cpus_allowed这个位掩码标志中。

　　2、进程只运行在指定处理器上，对处理器的指定是由该进程描述符的 cpus_allowed 域设置的。

4.8.3 放弃处理器时间

　　1、Linux通过 sched_yieldO 系统调用，提供了一种让进程显式地将处理器时间让给其他等待执行进程的机制。

　　2、内核代码为了方便，可以直接调用yield()，先要确定给定进程确实处于可执行状态，然后再调用 sched__yield()。

　　3、用户空间的应用程序直接使用
sched__yield（）系统调用就可以了。

巴特西

Linux内核分析——第四章进程调度

最新文章

热门文章

巴特西

Linux内核分析——第四章 进程调度

最新文章

热门文章

Linux内核分析——第四章进程调度