第四章 进程调度

第四章 进程调度

调度程序负责决定将哪一个进程投入运行，何时运行以及运行多长时间，可以看做在可运行态进程之间分配有限的处理器时间资源的内核子系统。

多任务

多任务操作系统就是能同时并发地交互执行多个进程的操作系统。对单处理器和多处理器来说有微妙的区别。
多任务系统分为两类：非抢占式多任务（cooperative multitasking）和抢占式多任务（preemptive multitasking）。抢占式，强制挂起进程的动作叫抢占（preemption）。时间片（timeslice）实际上是分配给每个可运行进程的处理器时间段。非抢占式，进程主动挂起的操作称为让步（yielding）。

Linux的进程调度

经典调度程序的是O(1)调度程序。
经过不断的发展，在2.6.23内核版本中，使用完全公平调度算法，简称CFS。

策略

I/O消耗型和处理器消耗型

进程可以分为这两类，但是这两类之间有交集。
前者进程的大部分时间用来提交I/O请求或是等待I/O请求。经常处于可运行的状态，但都是很短的一段时间。多数图形用户界面程序（GUI）。
后者把大多数的时间大多用在执行代码上。执行大量数学运算的程序，MATLAB。
交互式应用，即I/O消耗进程受到优待，因为要保证用户体验。

进程优先级

最基本的一类是基于优先级的调度。通常的做法（并未被Linux所采用）优先级高的先运行，低的后运行，相同按轮转方式进行调度。
Linux采用了两种不同的优先级范围。
第一种是nice值，范围从-20到+19，默认为0。越大优先级越低。低nice（高优先级）的进程可以获得更多的处理器时间。
第二种是实时优先级，默认从0-99。与nice意义相反，越大意味着优先级越高。任何实时进程的优先级都高于普通的进程，实时优先级和nice优先级处于互不相交的两个范畴。

时间片

一个数值，表明进程被抢占前所能持续运行的时间。
Linux的CFS调度器并没有直接分配时间片到进程，而是将处理器的使用比划分给了进程。进程所获得的处理器时间和系统负载密切相关，nice值也会作为权重调整进程所使用的处理器时间使用比。
其抢占时机取决于新的可运行程序消耗了多少处理器使用比。如果消耗的使用比比当前进程小，则新进程立刻投入运行，抢占当前进程。否者推迟运行。

调度策略的活动

相当于一个具体的例子。
假设在Linux中，仅有两个可运行的且具有相同nice值的进程：一个文字编辑程序和一个视频解码程序。前者是I/O消耗型的，后者是处理器消耗型的。

处理器的使用比是%50，它们平分了处理器时间。一旦文本编辑器被唤醒（此时视频解码器正在使用处理器），由于文本编辑器使用的处理器时间肯定低于%50，会发生抢占，文本编辑器投入运行。文本编辑器处理了用户的击键输入后，又一次进入睡眠，视频解码器投入运行。CFS保证文本编辑器在需要时被投入运行，视频处理器在剩余的时刻运行。

Linux调度算法

调度器类

Linux调度器以模块的方式提供，调度器类（scheduler classes）。
完全公平调度（CFS）是一个针对普通进程的调度类，称为SCHED_NORMAL，定义在kernel/sched_fair.c。

Unix系统中的调度

在Unix中，优先级以nice值形式输出给用户空间，但是导致许多反常的问题。将nice值映射到时间片有许多需要考虑的问题…
CFS采用的方法是对时间片的分配方式进行根本性的重新设计（就进程调度而言）：完全摒弃时间片而是分配给进程一个处理器使用比重。

公平调度

CFS允许每个进程运行一段时间、循环轮转、选择运行最少的进程作为下一个运行进程。在所有可运行的进程总数的基础上计算出一个进程应该运行多久。nice值作为进程获得处理器运行比的权重。
目标延迟、最小粒度。
近乎完美的多任务，不是完美的公平。

Linux调度的实现

CFS的实现，相关代码位于kernel/sched_fair.c。
四个组成部分，时间记账、进程选择、调度器入口、睡眠和唤醒。

时间记账

调度器实体结构

CFS没有时间片的概念，但是也必须维护每个进程运行的时间记账，以此确保每个进程只在公平分配给它的处理器时间内运行。使用调度器实体结构完成这一工作（定义在<linux/sched.h>的struct_sched_entity中)。

struct sched_entity{
	struct load_weight load;
	struct rb_bode runnode;
	struct list_head group_node;
	unsigned int on_rq;
	u64 exec_start;
	u64 vruntime;
	/*此处省略许多变量*/
}

进程描述符struct task_struct中包含了一个se的成员变量，这个变量是调度器实体结构。

虚拟实时

vruntime变量存放进程的虚拟运行时间，计算经过了所有可运行进程总数的标准化，以ns为单位，和定时器节拍不再相关。vruntime变量用来记录一个程序到底运行了多长时间以及它应该再运行多久。

/*update_curr()  kernel/sched_fair.c*/
static void update_curr(struct cfs_rq *cfs_rq)
{
	struct sched_entity *curr=cfs_rq->curr;
	u64 now=rq_of(cfs_rq)->clock;
	unsigned long delta_exec;
	
	if(unlikely(!curr))
		return;
	delta_exec=(unsigned long)(now-curr->exec_start;
	if(!delta_exec)
		return;
	__update_curr(cfs_rq,curr,delta_exec);
	curr->exec_start=now;

	if(entity_is_task(curr)){
		struct task_struct *curtask=task_of(curr);
		trace_sched_stat_runtime(curtask,delta_exec,curr->vruntime);
		cpuacct_charge(curtask,delta_exec);
		account_group_exec_runtime(curtask,delta_exec);
	}
} 

update_curr()计算了当前进程的执行时间，存放在delta_exec变量中，又将运行时间传递给了__update_curr()，由后者根据当前可运行进程总数对运行时间进行加权计算。最终将权重和当前运行进程的vruntime相加。
update_curr()是由系统定时器定期调用的，可以准确的测量给定进程的运行时间。

进程选择

CFS调度算法的核心：选择具有最小vruntime的任务。
Linux使用红黑树来组织可运行进程队列。在linux中红黑树被称为rbtree，是一个自平衡二叉搜索树。

挑选下一个任务（进程）

CFS选择算法简单总结为：运行rbtree树中最左边叶子节点所代表的那个进程。
实现这一过程的函数是__pick_next_entity()。
不进行遍历树的操作，最左叶子节点已经被缓存在rb_leftmost字段中。
没有可运行的进程的话，CFS调度器会选择idle任务进行。

向树中加入进程

发生在进程变为可运行状态（被唤醒）或者通过fork()调用第一次创建进程时。
enqueue_entity()更新运行时间和其他一些统计数据，然后调用__enqueue_entity()进行频繁的插入操作，把数据项真正插入到红黑树中。
平衡二叉树的基本规则是，如果键值小于当前节点的键值，则需转向树的左分支，相反如果大于，则转向右分支。如果一旦走过右边分支，说明插入的节点不会是新的最左节点，将标志leftmost设置为0。如果一直向左移动，leftmost维持1，说明有一个新的最左节点，更新rb_leftmost缓存。调用rb_link_node()插入节点，rb_insert_color()更新树的自平衡相关属性。

从树中删除进程

发生在进程阻塞（变为不可运行）或者终止时（结束运行）。
dequeue_entity()函数更新一些数据，调用__dequeue_entity()删除进程。删除进程容易的多，rbtree实现了rb_erase()函数，可以完成所有的工作。还要更新rb_leftmost缓存，如果最左节点删除后，要调用rb_next()找到下一个最左节点。

调度器入口

主要入口点是schedule()，定义在kernel/sched.c中，会调用调度器类的pick_next_task()函数，找到下一个需要运行的进程。schedule()和具体的调度类相关联。
CFS是普通进程的调度类，而系统的绝大多数进程都是普通进程。优化小技巧，如果CFS类的可运行进程数量等于所有的可运行进程数量，直接调用CFS类对应的函数。
pick_next_task()会调用pick_next_entity()，而该函数又会调用前面的__pick_next_entiy()函数选择下一个要运行的进程。

睡眠和唤醒

休眠（被阻塞）的进程处于一个特殊的不可执行的状态。进程休眠的原因有多种，但肯定都是为了等待一些事件。内核的操作：进程把自己标记成睡眠状态，从可执行红黑树中移出，放入等待队列，调用schedule()选择和执行一个其它进程。唤醒的过程则相反：进程被设置为可执行状态，然后从等待队列移到可执行红黑树中。
休眠相关的两种状态为：TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE，但是位于同一个等待队列上。

等待队列

等待队列是由某些事件发生的进程组成的简单列表。内核用wake_queue_head_t来代表等待队列。等待队列可以通过DECLARE_WAITQUEUE()静态创建，也可以由init_waitqueue_head()动态创建。为了避免产生竞争条件，休眠和唤醒的实现很严苛。
进程把自己加入等待队列的操作如下：

1. 调用宏DEFINE_WAIT()创建一个等待队列的项。
2. 调用add_wait_queue()把自己加入到队列中。在事件发生时，对等待队列执行wake_up操作。
3. 调用prepare_to_wait()方法把进程的状态变更。
4. 如果状态是TASK_INTERRUPTIBLE，信号唤醒进程（伪唤醒，唤醒不是因为事件的发生）。
5. 当进程被唤醒的时候，会检查条件是否为真。为真，退出循环，否则再次调用schedule()并一直重复这一步操作。
6. 当条件满足时，进程将自己设置为TASK_RUNING并调用finish_wait()方法把自己移出队列。

代码描述如下：

DEFINE_WAIT(wait);
/*q是休眠的等待队列*/
add_wait_queue(q,&wait);
/*condition是等待的事件*/
while(!condition){	
	prepare_to_wait(&q,&wait,TASK_INTERRUPTIBLE);
	if(signal_pending(current))
		/*处理信号*/
	schedule();
}
finish_wait(&q,&wait);

进程休眠之前条件达成，进程不会错误的休眠。内核代码在循环体中需要完成一些其它的任务，如锁的释放和获取，或者其它事件。
inotify_read()负责从通知文件描述符中获取信息，其代码就是上面的一个流程，位于 fs/notify/inotify/inotify_user.c 中。

唤醒

通过函数wake_up()进行，会唤醒指定等待队列上的所有进程。
会调用try_to_wake_up()，负责将进程设置为TASK_RUNING状态，调用enqueue_task()将此进程放入红黑树中。如果被唤醒的进程优先级比当前优先级高，还要设置need_resched标志。

抢占和上下文切换

上下文切换，也就是从一个可执行进程切换到另一个可执行进程，由定义在kernel/sched.c中的context_switch()函数负责处理。每当一个新的进程被选出来准备投入运行时，schedule()就会调用该函数。
完成两项基本的工作，切换虚拟内存和切换状态：

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

内核提供了一个need_resched标志来表明是否需要重新执行一次调度（即执行一次schedule()调用）。当进程被抢占时，scheduler_tick()会设置这个标志；当一个优先级高的进程进入可执行状态时，try_to_wake_up()也会设置这一标志。

用户抢占

内核返回用户空间时，如果need_resched标志被设置，会导致schedule()被调用，此时就会发生用户抢占。
在内核返回用户空间时，它知道自己是安全的，因此它可以继续执行当前进程，也可以选择一个新的进程。
用户抢占发生在下面两种情况：

1. 从系统调用返回用户空间时。
2. 从中断处理程序返回用户空间时。

内核抢占

只要重新调度是安全的，内核就可以在任何时间抢占正在执行的任务。
只要没有持有锁，重新调度就是安全的。
为每个进程引入了preempt_count计数器，初始值为0，每次使用锁时加1，释放锁时减1。
进程显式地调用schedule()时，应该确保自己是可以安全的被抢占的。
内核抢占发生在：

1. 中断处理程序正在执行，且返回内核空间之前。
2. 内核代码再一次具有可抢占性的时候。
3. 内核的任务显示地调用schedule()
4. 内核的任务阻塞（会导致调用schedule()）

实时调度策略

两种实时调度策略：SCHED_FIFO和SCHED_RR。
被一个特殊的实时调度器管理，定义在kernel/sched_rt.c文件中。
实时进程的优先级要高于普通进程。
SCHED_FIFO实现了一种简单的、先入先出的调度算法：不使用时间片。一旦处于可执行状态，就会一直执行，直到自己受阻塞或显示地释放处理器。只有更高优先级的任务才可以进行抢占。
SCHED_RR与SCHED_FIFO大体相同，但是使用了时间片，是一种实时轮流调度算法。时间片只用来调度同一优先级的进程。
实时优先级调度算法从0到MAX_RT_PRIO-1。默认情况下，MAX_RT_PRIO为100，即默认的优先级是从0-99。nice的值共享了这个取值空间，从MAX_RT_PRIO到MAX_RT_PRIO+40，即nice的值从-20到+19直接对应的是从100到139的实时优先级范围。

与调度相关的系统调用

与调度策略和有限级相关的系统调用

sched_setscheduler()和sched_getseduler()分别用于设置和获取进程的调度策略和实时优先级。读取或改写tast_struct的policy和rt_priority。
sched_setparam()
sched_getparam()
sched_get_priority_max()
sched_get_priority_min()
对于一个普通的进程，nice()可以将给定的进程的静态优先级增加一个量。只有超级用户才可以使用负值。

与处理器绑定（processor affinity）有关的系统调用

可以设置进程在特定的一些处理器上面运行。在task_struct的cpu_allowes这个位掩码中实现，每一位对应一个系统可用的处理器，默认情况下所有位都被设置，进程可以在所有可用的处理器上运行。用户可以通过sched_setaffinity()设置不同的一个或几个位组合的位掩码，而调用sched_getaffinity()则返回当前cpus_allowed位掩码。
进程创建时会继承父进程的相关掩码。

放弃处理器时间

sched_yield()，提供了一种让进程显示地将处理器时间让给其它等待执行进程的机制，实现是将进程从活动队列移到过期队列或者移到活动队列末尾实现的。实时进程不会过期。
为了方便，内核代码可以直接调用yield()。用户空间的应用程序使用sched_yield()即可。