Linux Process Management && Process Scheduling Principle
目录
. 引言
. 进程优先级
. 进程的生命周
. 进程表示
. 进程管理相关的系统调用
. 进程调度
. 完全公平调度类
. 实时调度类
. 调度器增强
. 小结
1. 引言
在多处理器系统中,可以真正并行运行的进程数目,取决于物理CPU的数目
内核和处理器建立了多任务的"错觉",即可以并行做几种操作,这是通过以很短的间隔在系统运行的应用程序之间不停切换而做到的,这种系统管理方式引发了几个内核必须解决的问题
. 除非明确地要求,否则应用程序不能彼此干扰,例如
) 应用程序A的错误不能传播到应用程序B
) 确保程序不能随意读取、修改其他程序的内存
. CPU时间必须在各种应用程序之间尽可能公平地共享,其中一些程序可能比其他程序更重要
. 内核必须决定为各个进程分配多长时间,何时切换到下一个进程,这本质上是"哪个进程是下一个进程"的问题。这个决策是平台无关的
. 在内核从进程A切换到进程B时,必须确保进程B的执行环境与上一次撤销其处理器资源时完全相同(例如寄存器、虚拟地址空间的结构必须与此前相同)
这些任务是被称之为"调度器"的内核子系统的工作,CPU时间如何分配取决于"调度器策略",这与用于在各个进程之间切换的"任务切换机制"完全无关
2. 进程优先级
进程的"优先级"是一个大的概念,它包含了不同的关键度类别,以满足不同需求
. 实时进程
) 硬实时进程
硬实时进程有严格的时间限制,某些任务必须在指定的时限内完成。需要注意的是,这并不意味着所要求的时间范围特别短,而是系统必须保证"决不会超过某一特定的时间范围",即使在不大可能或条件不利的情况下也是如此 ) 软实时进程
软实时进程是硬实时进程的一种弱化形式,一个典型的例子是对CD的写入操作,CD写入进程接收的数据必须保持某一速率,因为数据是以连续流的形式写入介质的,如果系统负荷过高,数据流可能会暂时中断,这可能导致CD不可用,虽然对实时性也有一定的要求,但并不像飞机导航系统那样严重,而且大多数情况下写入进程在需要CPU时间的时候应该能够得到保证,因为实时进程至少优先于所有其他普通进程 . 非实时进程
大多数进程是没有特定时间约束的普通进程,但仍然可以根据重要性来分配优先级
这种方案称之为"抢占式多任务处理(preemptive multitasking)",各个进程都分配到一定的时间段可以执行。时间段到期后,内核会从进程回收控制权,让"下一个进程(由调度器决定)"。被抢占进程的运行环境,即所有CPU寄存器、页表都会保存起来,因此上一个进程的执行结果不会丢失。在之前被抢占的进程恢复执行时,其进程环境可以完全恢复。
时间片的长度会根据进程优先级而变化
3. 进程的生命周期
进程并不总是可以立即运行,有时候它必须等待来自外部信号源、不受其控制的异步中断事件(例如文本编辑器中等待键盘键入),在事件发生之前,进程无法运行
当调度器在进程之间切换时,必须知道系统中每个进程的状态,将CPU分配到无事可做的进程显然是没有意义的。进程在各个状态之间的转换也同样重要,例如如果一个进程在等待来自外设的数据,那么调度器的任务就是一旦数据已经到达,则需要将进程的状态由等待改为可运行
Linux是一个多用户,多任务的系统,可以同时运行多个用户的多个程序,就必然会产生很多的进程,而每个进程会有不同的状态
0x1: 进程的初始状态
进程是通过fork系列的系统调用(fork、clone、vfork)来创建的,内核(或内核模块)也可以通过kernel_thread函数创建内核进程。这些创建子进程的函数本质上都完成了相同的功能——将调用进程复制一份,得到子进程(可以通过选项参数来决定各种资源是共享、还是私有)
那么既然调用进程处于TASK_RUNNING状态(只有正在运行的进程才会进行系统调用,创建新进程),则子进程默认也处于TASK_RUNNING状态
另外,在系统调用调用clone和内核函数kernel_thread也接受CLONE_STOPPED选项,从而将子进程的初始状态置为TASK_STOPPED
0x2: 进程状态转换
进程自创建以后,状态可能发生一系列的变化,直到进程退出。而尽管进程状态有好几种,但是进程状态的变迁却只有两个方向(即状态图的迁移必须要经过中间TASK_RUNNING的转换)
. 从TASK_RUNNING状态变为非TASK_RUNNING状态
. 从非TASK_RUNNING状态变为TASK_RUNNING状态
/*
例如,如果给一个TASK_INTERRUPTIBLE状态的进程发送SIGKILL信号,这个进程将先被唤醒(进入TASK_RUNNING状态),然后再响应SIGKILL信号而退出(变为TASK_DEAD状态)。并不会从TASK_INTERRUPTIBLE状态直接退出
Linux进程迁移的这个原则要特别注意
*/
进程可能有以下几种状态
. TASK_RUNNING(ready): 可执行状态(READY状态)
同一时刻可能有多个进程处于可执行状态,这些进程的task_struct结构(进程控制块)被放入对应CPU的可执行队列中(一个进程最多只能出现在一个CPU的可执行队列中)。进程调度器的任务就是从各个CPU的可执行队列中分别选择一个进程在该CPU上运行
只要可执行队列不为空,其对应的CPU就不能偷懒,就要执行其中某个进程。一般称此时的CPU"忙碌(busy)"。对应的,CPU"空闲"就是指其对应的可执行队列为空,以致于CPU无事可做
/*
这里也可以引出一个话题,死循环程序会导致CPU占用高呢?因为死循环程序基本上总是处于TASK_RUNNING状态(进程处于可执行队列中)。除非一些非常极端情况(比如系统内存严重紧缺,导致进程的某些需要使用的页面被换出,并且在页面需要换入时又无法分配到内存),否则这个进程不会睡眠。所以CPU的可执行队列总是不为空(至少有这个进程存在),CPU也就不会"空闲"
*/ . TASK_RUNNING(run): 可执行状态(RUNNING状态)
要特别注意和TASK_RUNNING(ready)状态的区分,处于TASK_RUNNING(ready)状态的进程并不一定正在运行,只有在该状态的进程才在CPU上运行,能同时运行的进程数量取决于逻辑CPU的数量 . TASK_UNINTERRUPTIBLE: 不可中断的深度睡眠
与TASK_INTERRUPTIBLE状态类似,进程处于睡眠状态,但是此刻进程是不可中断的。不可中断,指的并不是CPU不响应"外部硬件的中断",而是指进程不响应"异步信号"
而TASK_UNINTERRUPTIBLE状态存在的意义就在于,内核的某些处理流程是不能被打断的。如果响应异步信号,程序的执行流程中就会被插入一段用于处理异步信号的流程(这个插入的流程可能只存在于内核态,也可能延伸到用户态),于是原有的流程就被中断了
/*
在进程对某些硬件进行操作时(比如进程调用read系统调用对某个设备文件进行读操作,而read系统调用最终执行到对应设备驱动的代码,并与对应的物理设备进行交互),可能需要使用TASK_UNINTERRUPTIBLE状态对进程进行保护,以避免进程与设备交互的过程被打断,造成设备陷入不可控的状态
比如read系统调用触发了一次磁盘到用户空间的内存的DMA,如果DMA进行过程中,进程由于响应信号而退出了,那么DMA正在访问的内存可能就要被释放了,所以需要使用TASK_UNINTERRUPTIBLE状态对其进行保护,要注意的是,TASK_UNINTERRUPTIBLE的进程是非常短暂的,因为要尽可能的让CPU的不可响应时间缩短到最短
*/
//linux系统中也存在容易捕捉的TASK_UNINTERRUPTIBLE状态。执行vfork系统调用后,父进程将进入TASK_UNINTERRUPTIBLE状态,直到子进程调用exit或exec . TASK_INTERRUPTIBLE: 可中断的睡眠状态
处于这个状态的进程因为等待某某事件的发生(比如等待socket连接、等待信号量),而被挂起。这些进程的task_struct结构被放入对应事件的等待队列中。当这些事件发生时(由外部中断触发、或由其他进程触发),对应的等待队列中的一个或多个进程将被唤醒
/*
通过ps命令我们会看到,一般情况下,进程列表中的绝大多数进程都处于TASK_INTERRUPTIBLE状态(除非机器的负载能力很高),因为CPU资源总是小于需要执行的进程
绝大多数情况下,进程处在睡眠状态时,总是应该能够响应异步信号的。否则将会发生,kill -9竟然杀不死一个正在睡眠的进程了,于是我们也很好理解,为什么ps命令看到的进程几乎不会出现TASK_UNINTERRUPTIBLE状态,而总是TASK_INTERRUPTIBLE状态
*/ . TASK_STOP(TASK_STOPPED or TASK_TRACED)
向进程发送一个SIGSTOP信号,它就会因响应该信号而进入TASK_STOPPED状态(除非该进程本身处于TASK_UNINTERRUPTIBLE状态而不响应信号)。(SIGSTOP与SIGKILL信号一样,是非常强制的。不允许用户进程通过signal系列的系统调用重新设置对应的"信号处理函数")(即不可通过编程方式实现屏蔽)
向进程发送一个SIGCONT信号,可以让其从TASK_STOPPED状态恢复到TASK_RUNNING状态 当进程正在被跟踪时,它处于TASK_TRACED这个特殊的状态。"正在被跟踪"指的是进程暂停下来,等待跟踪它的进程对它进行操作。比如在GDB中对被跟踪的进程下一个断点,进程在断点处停下来的时候就处于TASK_TRACED状态。而在其他时候,被跟踪的进程还是处于前面提到的那些状态
/*
对于进程本身来说,TASK_STOPPED和TASK_TRACED状态很类似,都是表示进程暂停下来。
而TASK_TRACED状态相当于在TASK_STOPPED之上多了一层保护,处于TASK_TRACED状态的进程不能响应SIGCONT信号而被唤醒。只能等到调试进程通过ptrace系统调用执行PTRACE_CONT、PTRACE_DETACH等操作(通过ptrace系统调用的参数指定操作),或调试进程退出,被调试的进程才能恢复TASK_RUNNING状态
*/ . TASK_DEAD(TASK_DEAD - EXIT_ZOMBIE)
进程在退出的过程中,处于TASK_DEAD状态。在这个退出过程中,进程占有的所有资源将被回收(除了task_struct结构,以及少数资源)。于是进程就只剩下task_struct这么个空壳,故称为僵尸
之所以保留task_struct,是因为task_struct里面保存了进程的退出码、以及一些统计信息。而其父进程很可能会关心这些信息。比如在shell中,$?变量就保存了最后一个退出的前台进程的退出码,而这个退出码往往被作为if语句的判断条件
/*
父进程可以通过wait系列的系统调用(如wait4、waitid)来等待某个或某些子进程的退出,并获取它的退出信息。然后wait系列的系统调用会顺便将子进程的尸体(task_struct)也释放掉
子进程在退出的过程中,内核会给其父进程发送一个信号,通知父进程来"收尸"(这个信号默认是"SIGCHLD"),但是在通过clone系统调用创建子进程时,可以设置这个信号 Unix/Linux 处理僵尸进程的方法:
找出父进程号,然后kill 父进程,之后子进程(僵尸进程)会被托管到其他进程,如init进程,然后由init进程将子进程的尸体(task_struct)释放掉
*/
进程的状态转换关系图如下
aaarticlea/png;base64,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" alt="" />
. 给一个TASK_INTERRUPTIBLE状态的进程发送SIGKILL信号,这个进程将先被唤醒(进入TASK_RUNNING状态),然后再响应SIGKILL信号而退出(变为TASK_DEAD状态)
. 而进程从TASK_RUNNING状态变为非TASK_RUNNING状态,则有两种途径:
) 响应信号而进入TASK_STOPED状态、或TASK_DEAD状态(SIGNAL信号)
) 执行系统调用主动进入TASK_INTERRUPTIBLE状态(如nanosleep系统调用)、或TASK_DEAD状态(如exit系统调用)
) 由于执行系统调用需要的资源得不到满足,而进入TASK_INTERRUPTIBLE状态或TASK_UNINTERRUPTIBLE状态(如select系统调用)
//显然,这几情况都只能发生在进程正在CPU上执行的情况下
系统将所有进程保存在一个"进程列表"中,无论其状态是运行、睡眠、或等待。但睡眠进程会特别标记出来,调度器会知道它们无法立即运行,同时睡眠进程会被分类到若干队列中,因此它们可在适当的时间唤醒(例如在进程等待的外部事件已经发生时)
0x3: 抢占式多任务处理
Linux进程管理的结构中还需要另外两个进程状态选项,这反映了所有现代CPU都至少有两种不同执行状态的事实
. 用户态
) 受到各种限制
) 禁止访问某些内存区域
) 进程通常都处于用户态,只能访问自身的数据,无法干扰系统中的其他应用程序,甚至也不会注意到自身之外其他进程的存在
. 核心态
) 具有无限的权利
这些区别是建立封闭"隔离罩"的一个重要前提,它维持着系统中现存的各个进程,防止它们与系统其他部分互相干扰
如果进程想要访问系统数据或功能,则必须切换到和心态,这只能在受控情况下完成,而且这种访问必须经由明确定义的路径(即系统调用)实现
从用户态切换到和心态的第二种方法是通过中断,此时切换是自动异步触发的,中断的发生是不可预测的。处理中断的操作,通常与中断发生时执行的进程无关(例如外部块设备向内存传输数据完毕后引发一个中断,但相关数据用于系统中运行的任何进程都是可能的),类似的,进入系统的网络数据报也是通过中断通知的,显然该网络数据包也未必是用于当前运行的进程。因此,在Linux执行中断操作时,当前运行的进程是不会察觉的
内核的抢占调度模型建立了一个层次结构,用于判断哪些进程状态可以由其他状态抢占
. 普通进程总是可能被抢占,在一个重要进程变为可运行时,例如编辑器接收到了等待已久的键盘输入(立即进入read状态),调度器可以决定是否立即执行该进程,即使当前进程仍然正常运行,对于实现良好的交互行为和低系统延迟,这种抢占起到了重要作用
. 如果系统处于和心态并正在处理系统调用,那么系统中的其他进程是无法夺取其CPU时间的。调度器必须等到系统调用结束,才能选择另一个进程执行,但中断可以中止系统调用
. 中断可以暂停处于用户态和和心态的进程,中断具有最高优先级,因为在中断触发后需要尽快处理
在内核2.5开发期间,内核抢占(kernel preemption)的选项添加到内核,该选项支持在紧急情况下切换到另一个进程,甚至当前是处于和心态执行系统调用(中断期间是不行的),从而保证"更平滑的"程序执行
Relevant Link:
http://zhengdl126.iteye.com/blog/1745108
http://blog.csdn.net/tianlesoftware/article/details/6457487
http://www.embeddedlinux.org.cn/html/xianchengjincheng/201304/14-2540.html
4. 进程表示
Linux内核涉及进程和程序的所有算法都围绕task_struct的数据结构建立,这是系统中主要的一个结构,关于task_struct结构体的相关知识,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/3865490.html
//搜索:struct task_struct
从总体上来说,该结构的内容可以分解为各个部分,每个部分表示进程的一个特定方面
. 状态和执行信息:
) 待决信号
) 使用的二进制格式(和其他系统二进制格式的任何仿真信息)
) PID
) 到父进程及其他有关进程的指针
) 优先级和程序执行有关的时间信息(例如CPU时间)
. 有关已经分配的虚拟内存的信息
. 进程身份凭据
) UID
) GID
) cred权限
. 进程操作的文件
. 线程信息记录该进程特定于CPU的运行时间数据
. 进程间通信IPC有关的信息
. 该进程所用的信号处理程序,用于响应到来的信号
对于Linux内核来说,通常情况下不会采取直接访问数据结构成员的方式读写数据,而是提供的相关的辅助函数(或系统调用)查询(或修改)这些数据
0x1: 命名空间
命名空间提供了虚拟化的一种轻量级形式,使得我们可以从不同的方面来查看运行系统的全局属性,该机制类似于Solaris中的zone、FreeBSD中的jail
关于命名空间的相关知识,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/4026781.html
//搜索:2. Linux命名空间
0x2: 进程关系
除了源于ID连接的关系之外,内核还负责管理建立在UNIX进程创建模型之上的"家族关系"
. 如果进程A分支形成进程B,进程A称之为父进程,而进程B则是子进程。如果进程B再次分支建立另一个进程C,进程A和进程C之间则称之为祖孙关系
. 如果进程A分支若干次形成几个子进程B1、B2、B3...,各个Bn进程之间的关系称之为兄弟关系
aaarticlea/png;base64,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" alt="" />
task_strut数据结构提供了两个链表表头,用于实现这些关系
struct task_struct
{
...
struct list_head children; //子进程链表
struct list_head sibling; //连接到父进程的子进程链表(兄弟链表)
...
}
5. 进程管理相关的系统调用
0x1: 进程复制
关于Linux进程(线程)复制的相关知识,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/3853854.html
0x2: 内核线程
内核线程是直接由内核本身启动的进程,内核线程实际上是将内核函数"委托"给独立的进程,与系统中其他进程"并行"执行(实际上,也并行与内核自身的执行)。内核线程通常称之为"内核守护进程",它们用于执行下列任务
. 周期性地将修改的内存页与页来源块设备同步,即数据写回(例如使用mmap的文件映射)
. 如果内存页很少使用,则写入交换区
. 管理延时动作(deferred action)
. 实现文件系统的事务日志
基本上,有两种类型的内核线程,它们对应于以下不同的API
. int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
/*
1. fn
产生的线程将执行用fn指针传递的函数
2. arg
而用arg指定的参数将自动传递给该函数
3. flag
flag中可以指定CLONE标志
*/
linux-2.6.32.63\arch\x86\kernel\process_32.c
调用kernel_thread()函数可以启动一个内核线程,其定义是特定于体系结构的,但函数原型都是相同的(API兼容)
线程启动后一直等待,该函数接下来负责帮助内核掉哟个deamonize以转换为守护进程,直至内核请求线程执行某一特定操作,这依次引发下列操作
) 该函数从内核线程释放其父进程(用户进程)的所有资源(例如内存上下文、文件描述符..),否则这些资源会一直锁定到线程结束,这是不可取的,因为守护进程通常运行到系统关机为止,因为守护进程只操作内核地址区域,它基本不需要这些用户态的资源
) deamonize阻塞信号的接收
) 将init用作守护进程的父进程
/*
* Create a kernel thread
*/
int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
{
struct pt_regs regs; memset(®s, , sizeof(regs)); //kernel_thread的第一个任务就是构建一个pt_regs实例,对其中的寄存器指定适当的值
regs.bx = (unsigned long) fn;
regs.dx = (unsigned long) arg; regs.ds = __USER_DS;
regs.es = __USER_DS;
regs.fs = __KERNEL_PERCPU;
regs.gs = __KERNEL_STACK_CANARY;
regs.orig_ax = -;
regs.ip = (unsigned long) kernel_thread_helper;
regs.cs = __KERNEL_CS | get_kernel_rpl();
regs.flags = X86_EFLAGS_IF | X86_EFLAGS_SF | X86_EFLAGS_PF | 0x2; /* Ok, create the new process.. */
return do_fork(flags | CLONE_VM | CLONE_UNTRACED, , ®s, , NULL, NULL);
}
EXPORT_SYMBOL(kernel_thread); . struct task_struct *kthread_create(int (*threadfn)(void *data), void *data, const char namefmt[], ...)
/*
1. namefmt
该函数创建一个新的内核线程,名字由namefmt给出
2. threadfn
最初该线程是停止的,需要使用wake_up_process启动它,此后,会调用threadfn给出的线程函数
3. data
作为参数传递给新线程
*/
linux-2.6.32.63\kernel\kthread.c . 宏kthread_run
参数和kthread_create相同,它会调用kthread_create创建新线程,但"立即"唤醒它 . kthread_create_cpu
可以将新线程绑定到特定的CPU . 线程启动后按周期性间隔运行,检测特定资源的使用,在用量超出或低于预置的限制值时采取相应动作,内核使用这类线程用于连续检测任务
内核线程会出现在系统进程列表中,但在ps的输出中由方括号包围,以便和普通进程区分,如果内核线程绑定到特定的CPU,CPU的编号在斜线后给出
可以看到,内核线程和用户态线程一样,在底层同样都是基于do_fork实现的
因为内核线程是由内核自身生成的,应该注意下面两个特别之处
. 它们在CPU的管态(supervisor mode)执行(即内核态),而不是用户态执行
. 它们只可以访问虚拟地址空间的内核部分,但不能访问用户空间
这为优化提供了一些余地,可遵循所谓的"惰性TLB处理(lazy TLB handling)",在这种模式下,内核线程不与任何特定的用户层进程关联,内核并不需要切换虚拟地址空间的用户层部分,保留旧设置即可,由于内核线程之前可能是任何用户层进程在执行,因此用户空间部分的内容本质上是随机的,内核线程绝不能修改其内容,为强调用户空间部分不能访问,mm设置为空指针,但由于内核必须知道用户空间当前包含了什么,所以在active_mm中保存了指向mm_struct的一个指针来描述它
我们可以从更加本质的角度来理解内核态和用户态,如果把内核理解为一个常驻进程,整个虚拟内存地址空间都是内核进程的内存空间,而用户态部分是由应用层的进程来决定的(也可以理解为为所有进程共享的),进程上下文的切换(谁在执行),用户态内存就映射到对应的进程。而这也是为什么在内核态中读写用户态内存需要慎重的原因,因为这个根据进程上下文不断变化的
0x3: 启动新程序
关于Linux进程启动的相关知识,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/3853854.html
//搜索:4. sys_execve()函数
0x4: 退出进程
进程必须用exit系统调用终止,这使得内核有机会将该进程使用的资源释放回系统,该调用的入口点是sys_exit函数,需要一个错误码作为其参数,以便退出进程,其定义是体系结构无关的
简单来说,该函数的实现就是将各个引用计数器减一,如果引用计数器归零而没有进程再使用对应的结构,那么将相应的内存区域返还给内存管理模块
Relevant Link:
http://www.cnblogs.com/LittleHann/p/3853854.html
6. 进程调度
0x1: 概观
内存中保存了对每个进程的唯一描述,并通过若干结构与其他进程连接起来。调度器面对的情况就是这样,调度器的任务是在程序之间共享CPU时间,创建并行执行的错觉,该任务分为两个不同的部分
. 调度策略
) 决定将哪个进程投入运行
) 何时运行
) 运行多长时间
. 上下文切换
调度器是在可运行态进程之间分配"有限"的处理器时间资源、确保进程能够有效工作的内核子系统,调度器是像Linux这样的多任务操作系统的基础,只有通过调度器的合理调度,系统资源才能最大程度地发挥作用,多进程才会有并发执行的效果
理解调度器要从它的原则入手,只要有可以执行的进程,那么就总会有进程正在执行,但是只要系统中可鱼腥的进程的数目比处理器的个数多,就注定某一给定时刻会有一些进程不能执行,这些进程在等待运行,在一组处于"可运行状态(TASK_RUNNING(ready))"的进程中选择一个来执行,这是调度器所需完成的基本工作
0x2: 调度器发展历史
从1991年Linux的第一版到后来的2.4内核系列,Linux的调度器都非常简陋,在每次进程切换时,内核扫描可运行进程的链表(TASK_RUNNING),计算进程的优先权,然后选择"最佳"进程来运行。这个算法的主要缺点是选择"最佳"进程所要消耗的时间与可运行的进程数量相关,因此,这个算法的开销太大,在运行数千个进程的高端系统中,要消耗太多的时间 正因为如此,在Linux2.5开发系列的内核中,调度程序做了大手术,开始采用一种叫做"O(1)调度程序"的新调度程序,它引入了许多强大的新特性和性能特性,这主要得益于"静态时间片算法"和"针对每一处理器的运行队列"。O(1)虽然在多处理器环境下能表现出近乎完美的性能和可扩展性,但该调度算法对于调度那些响应时间敏感的程序(交互进程)却反应迟钝 为了解决高效CPU调度和交互进行的可响应速度的平衡问题,在2.6内核中引入了新的调度算法,Linux 2.6 的调度算法就复杂多了,最后,"反转楼梯最后期限调度算法(Rotating Staircase Deadline Scheduler RSDL)",该算法吸取了队列理论,将公平调度的概念引入了Linux调度程序,并最终在2.6.23内核版本中替代了O(1)调度算法,被称为"完全公平调度算法(CFS)" 通过设计,该算法(完全公平调度算法(CFS))较好地解决了与可运行进程数量的比例关系,因为它在固定的时间内(与可运行的进程数量无关)选中要运行的进程。它也很好地处理了与处理器数量的比例关系,因为每个 CPU 都拥有自己的"可运行进程队列"。而且,新算法较好地解决了区分交互式进程和批处理进程的问题。因此,在高负载的系统中,用户感到在 Linux2.6 中交互应用的响应速度比早期的 Linux 版本要快
调度程序总能成功地找到要执行的进程,事实上,总是至少有一个可运行进程:即 init 进程,它的 PID 等于 0,而且它只有在 CPU 不能执行其他进程时才执行
0x3: 多任务系统分类
多任务操作系统就是能"同时"、"并发"、"交互"执行多个进程的操作系统,不论是在单处理器或者多处理器上,多任务操作系统都能够使多个进程处于堵塞或者睡眠状态,因此,现代Linux系统也许有100多个进程在内存,但是只有一个处于可运行状态
多任务系统可以划分为两类
. 抢占式多任务(preemtive multitasking)
在这个模式下,由调度器来决定什么时候停止一个进程的运行,以便其他进程能够得到执行机会,这个强制的挂起动作就叫做"抢占(preemption)",进程在被抢占之前能够运行的时间是预先设置好的,即"进程的时间片(timesllice)",时间片实际上就是分配给每个可运行进程的处理器时间段
有效管理时间片能使调度程序从系统全局的角度做出调度决定,这样还可以避免个别进程独占系统资源
现在操作系统对程序运行都采用了动态时间片计算的方式,并且引入了可配置的计算策略 . 非抢占式多任务(cooperative multitasking)
在非抢占多任务模式下,除非进程自己主动停止运行,否则它会一直运行下去,进程主动挂起自己的操作称之为让步(yielding)。这种机制有很多缺点,调度程序无法对每个进程该执行多长时间做出统一规定,所以进程独占的处理器时间可能超出用户的预料,甚至来说,如果进程永远不作出让步,则可能使系统崩溃
基于这些原因
需要明白的是,Linux实现的"公平"调度程序本身并没有采取时间片来达到公平调度,Linux调度器的一个杰出特性是,它不需要时间片概念,至少不需要传统的时间片
. 经典的调度器对系统中的进程分别计算时间片,使进程运行直至时间片用尽,在所有进程的所有时间片都已经用尽时,则需要重新计算
. 相比之下,当前的调度器只考虑进程的等待时间,即进程在就绪队列(run-queue)中已经等待了多长时间,对CPU时间需求最严格的进程被调度执行
调度器的一般原理是,按所能分配的计算能力,向系统中的每个进程提供最大的公正性。或者从另一个角度来说,它试图确保没有进程被亏待,每次调用调度器时,它会挑选具有最高等待时间的进程,把CPU提供给该进程,在这种情况下,那么进程的不公平待遇不会累积,不公平会均匀分配到系统中的所有进程,从本质上讲,这就是"饥饿算法"
下图简单说明了调度器如何记录哪个进程已经等待了多长时间,由于可运行进程是排队的,该结构被称之为"就绪队列"
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAVQAAACwCAIAAADfUgHCAAAgAElEQVR4nO29X2gb6X4+Phe6GXxh0MWALuzidjCIGF94AqFHJ/iUcXNwE59AJhttWTVpw84uOpw4uJixQwraVKqbUboLyjZ7bCYBe9n1WXNYD9EXNou60KbxoctJ1ANHEC1sAt2LBs0G9kZ70dy87+/iwe/vzcxoLMm2/nmeCyO9emfmnfE87/t5P38F+josy6rX6zTEQIAQUq1WCSGs5dWrV20fSyl1HMdxnFaPrVar9Xo9+NhisVgsFpsfzA8//ODb03Ec15gbdfNtd738GHbbV+lxCK7vIfkHCdVqVRCEWq3GWubm5pp8ayuViiAIlUqFb7QsSxRFy7IePnxovY67d++ybrVaTRCEarWKr4IgmKapqqosy66r2LbNPgiCYFkWpZQQYhgG+4lSWi6XXYMZHR31jpkQIsuyqqrBt0YIEQRBlmVFUTRNk2XZMAwcKIoifxX86j1cFEV2d/2LkPyDjGq1KkkS2F6pVCqVSj6fB6lqtZppmpTSYrEoy7JpmrquS5LEKOclv6qqjCQ3btzQNE3TNF3XcaqZmRnWs0nyo9vbb79tGIZhGDibYRhvv/22qqqaprGeGxsb/FfDMNLptPd+MTdhzJhHzF1omsZmPZBfEARN02q12uTkpG3bmNREUeTnSpCfEIKTSJJUqVRcd9e/CMk/yPjkk08EQRBFUdd1URQVRTl//jxoJoqiIAiU0q2tLbzfmqbxYgIjP+YISikISQjxyg62bS8uLrLPlmUJgnDs2DHDMHAhkF+SpMnJSXa4l0W2bVcqlVKpBOoChJBIJCLLsizLoigSQhRFmZ6eZjfCxizLMuYIXdexnguCoO+CJz+jummaJ0+eVBQFswabKwEmF2QyGVVVBUEwDAPDXlpaOph/UvcQkn9gYdv222+/jfVNVVVFUSilbP1UVRWLPMhPKQVjRVEcHx8Hz/FVURTwU9M0cNKyLCzXICSltFarLS8v48zgJE+P4JX/008/NTjoui4IAi+667o+Pz/PRoi/pVIJP7EJq1wu4+74HYRLjAew8tu2rSiKqqojIyOY5nhhxzAMRVGEXaytrZmmyWZS7Br6fdsfkn+QAbGfLYyEkKmpKVcfF/nZC+0V+3nyFwoFSqmiKJIk4deVlRXWE6x++vQpvjLy88svfX3lx9SAlXZ+fp7vRgjJ5/NshPyu3rZt9nlubg57eFEUGTNxadctg/xgvqZpkUgElMbazm4Z3XCDV65cURQFEyg0C6HYH6Kn8cUXXwiCMDMzc/78+QsXLiQSiYmJiUwms7i4ODMzg+V0a2treHj4ww8/PH/+PMj/j//4j6VS6fnz55FIpBH5NU0rlUrj4+Mu8tfr9VKplEqlBEG4evXqjRs3rl69ysg/Ojr6t3/7t+wFq9Vqsiz//ve/LxaLtm0nEglBEBKJxMbGRqFQyOfzIDAh5Be/+EWpVLp06VIkEslms7dv34Z+kSf/b37zm1QqFYvFVldX2dzhS/56vX79+vXt7e3t7e1KpfKnf/qnWPbn5+dTqRTr9ujRIyz7o6OjeDjr6+vxeLxQKDBpqK8Rkn9gYRhGJBJhUjG2uIQQSMVMHPCu/Pl8XlGUWq3mVX0z8q+traHFRX7IxhCMvQo/lx4e5GcCAq5o2/bdu3exW0E7ISSVStm2DQ0CiP3OO+/Q18m/s7ODBdy2baa29CV/rVazOYyPj7PP/P1KkgRBQ9f1S5cu4b6guVBVNSR/iN5FrVbb3t5mPGfbfhi02NroJT8QLPZns1nKkb9SqTCFX61WgzwPzR8mAqbwm5ubMwwDPaGW48eMvXqpVOLtfC6xHyP/9NNPKaU4LbrlcjnGVTZsL/ldFkpd18fGxthX7D7q9bppmthfYISnTp2CIoMQUqvVQvKH6HXwdn5sp7Ga8dTa2dmRJAnGMH7PH7zynzx5Ego/tvJnMhnWk+352UQAloqi+PjxY3YJaCL5AXs9C+jr5Hdp47FvZzfC2wjYCV3kx5Asy6p5YJqmbdtsrrRtGw/NNM10Oo2tPk4Skj9Er8Pr5JNOp6GyZjxhpr5KpcJLBIQQmLXZsYz8lUqlXC6zbvR1Ux9tbOd3GfC8qnhRFL13wZOft/bT18mPYcCoCeE/4ISgsaIopmmWSiWcBJZ8l6lPFEVJklzehyH5Q/Q6isUiIz8hRNd1aPshioOK1WrVtTaiJ3x+fMnvAhZw3s4PIYI5xvqa+rB/Zl+Zkc+78tu2HY/HDcOANh7kXFhYwFXY4DOZDESYWq3GDIeiKDLfJFEU8W4zCyVTGbA5gm2O2K25NibsyQQ4I/cLfMj/61//Op/PZzKZQqGAh/XixYtMJpPP5/P5/OrqKnqurq5mMplMJpPNZtmDKBQKaMlkMi9fvmSN2Ww2m81+/fXXaKlWq+j2/vvvs0uvrq7m8/kbN26wVQWN2Ww2l8uxN6larWJ4WA2AUqmEwbDhUUo/+OADND558gQtX3/9NcaWzWbR+PLly/wuYL5ilwAePXqExvX19cwunj17Ril1HAcjAdDNcRz2BB4/fuw69tatW2x4rJFdAkscDmfdcEJXI3+bAfjoo4+2trYopVtbW7lcbmNjg/n2l8vljY2NRgfu7OwUCoVCocAvg8Vi0Xe5q1arhUKB3Wy1Wl1bW+NPvry8XC6Xt7a2YJwHSqUSv8zs7OzMz8/zewcGQgjenHq9zk774sWLXC7Hj/C7774LfBj/P3K5HN6xer2OO9rZ2WHX4ln94YcfulwJS6VSOp1eXl5mr3f/ouHKz28LvV9ZI9sjAWw3xfdneyr+n40DvVIGe4f4wx8+fOhq/PTTT/nrosU1yHq9blkW31itViuVimvMTYIQwtRCbNiskb8KPEB9u/E3whr5q1QqFTxAvvHBgweuxtnZ2TZuIUQIHqHY35fgpYAQIdqDD/l52SxEb8JXEAsRoiX4kN933xUiRIgBgw/55+bmujKUECFCdBI+5L9x40ZXhnKAQOKXjz76CErykydPQpO8tra2s7PT78FYlNIBMDKHAL777rutra2NjQ28q7AxZTKZra0tbyalg8UAKvxg3ZUk6ebNm0yXDtX60tIS4rRM0+zrKSCdTnvt4SH6DqZpDg0NSZKk67plWeydhKMx3LGYN/SBY6DIX6vVEINtGIYvtzc2NhDv2e/x2INEfsdxYBzt9kA6CkII6M27q/DAGoZ3VVGUw2Dl4JC/Xq9LkiTLcgAr8vk85lEkcpAkqZl0lD2IgSE/PGqxxCEm5yjMAkhGJElSo1Udvs/wPqxUKrIss1wpBwgf8jeainocmUxmz8X81KlTfAdd15lXX39hc3Oz20M4AGDpW1hYQDg9vkqS1KfLT5NgzA+YvhGUwW9aR0ZGDnxa9CG/N9lLXyCRSOwpxicSCf4rnmn/Cv99DYi1LoeFWq0mSRKSBQwqXHkHfbG2tuaKdywUCiyA8qAwIOS/dOnSBx98ENwnm83+0z/9k6txeXn57Nmzfcf/vhuwC1jZfD1K6vX67Oxsx0fUIdi2HY1G9wwK+slPfsJHuFBKCSFzc3Pnzp07QLHIh/x9N+8iNU3wQ0FqCu8Ov16vI4XrYQ7w4NHve34s+41+dQlog4TFxcU9vTNt2+bzoDMgp6BvYGV7GASFH+wiwX28OaQYXDHhfYHBIH8j+YUPqh0w+LLaBV3XG+ndfAuftI1BIL+iKLquB3Rgedp9f3Vlre0L9Dv5WXof35/GxsY6P6TOAKkHgyGKYqP4Gm8uo/3Ah/yIAO8jKIoSzASkmmv0yPqR/JlMpt9NYrDLetsNw0Ba4YHEnis/Co00WoAxaR7UvO9D/mQyeSCn7hiCyY+nGaAphVzQX+Tvr9H6Au5YrhzY0IT3qbG5GQSTH9orVFLyxaGTv++0/cHkR3KoAOMKMlUOAJ36CMjAhfxfkUgEufTg7aNpmqIogxqzHEx+CKG+mmng0Mn/l3/5lwdy6o5BURQ+PZYX5XL50qVL0Wj0m2++8f7aj2L/t99+2+0htIkvvvhicnIymUyyBf+Pf/xjcRf4L/zhD3+YmpqamZlh2bUGBm+88UZwB8dx0un03/zN3/j++vz588Mlv8vA2PtgdZSCYZqmrw3JVRC2L9CnCr9KpTI6OtrkPDswJfF4nDx5spluMzMzvrJPqO13A1VimvHSn5iYcHEGCaqDjQU9iH4kP1KDN5l6FGDF+QaG/9lstpkdDSLQXD3xrh6gWXoQyI+H0oxv0urqqmvzjxpPffdu9R35WY3wVh+1bduiKPZpCIYXa2trTdrqoPvk/8veGkr7hA/5r1+/flBn7xgaifQuQLHP+5bl8/m+W/Yppf2VZxHqvUZx1nuiVquNjIz012TXCI7jNOlRCj00my5x4MF6ow2Ctp9SSggZHR1t5v2AJIlNPo7qd4N5jwPM5zNVtIH333//YD1buwjoMpp567BRAv/X1tYOXEQdEPJTSp88eTI6Ojo/P7/n5r9cLk9NTcXj8Vgsdu/evc4M7wji97//fSKRSCaTB6JCLhaLU1NTc3NzfaeQ9mJlZUWSpEKhsGc6tnK5jBf1pz/96YGLe4MQ2MNDURRkPmo0R6IWFdx++nfNX1lZ6XE9BYJzD3yQpmmiFN/BnrbzQKlfQRDu37/fqE+lUoGuhC98eIBwk9+27T5NbsMA/2dJkj788ENXGdYbN24gvV/f2fZc6HGFX6VSkSSpJcV+88Bm+JBO3mFYljU8PIzgFP5Fff78OaYGOEEe0v/ax5Gwv5RJjWDbdiwWE17HyMhI30Xv+qKXyQ8f1UOdXlvyF+hxOI6jqiq8G3nIsmwYxqH+l93kJ4T0XWBPIziOY7+OwXhdKKXz8/O9SX5sqToww87Pz8uyPBgqQEopIcT1rnbgoj57/gFOpTAw6E1fjI4xn1Jar9dhCR8Y/ncebvI7jvOTn/ykK0MJ0b+o1+tvvvnm4uJih73xt7a2ECkwGHvVDsNnz9+k+3GILqK7dYdM07x9+zb7CsX+pUuXujUe5AXirVSmaRqGEc4IwfAh/8bGRufHEaIldEXhx+fYh/1J13WkS+i6+z1UgLqus0I3oigiWHhgFD0HjoHV9g82Ok9+RE9pmsZ0UTC59wLzgfn5eQyGjRAusS4P+U4CiokAdxLbtn31683odLw1NYvFokvhUq1WA3QiIfn7EoVCocMvNJwjXCSH/2mPWE/z+bx3GsIIu+XW4TgOvJJZVRKXTsQwDJa/3LZtNs5YLMb6YO4ghLhuzZsXJJvNupz/i8ViwL37kD+bze51UyG6jGKx2En3xIDYR7ig9YLdsVFWbMQFdmWExWJREARVVQ3DQIW4hw8f8h0Mw1hcXLQsC8mLWAEvXu8mc+CP9ZJ/bm4O8eksFVK5XG6N/D2u8Lt79+7k5OTLly9d7Sh1vLOzUyqV1tbWHMfZ4ZDP5/eUaJaWli5fvsy3OI4TjUZdaXNOnDhx1Cpkf/DBBydOnPD9CYmleiHrVqMRUkoTicTFixc7NpIzZ84kEomVlZV0Oi0IwrVr11ZWVo4dOybLciwWe/r0KaX0yy+/XFlZOXny5E9/+tNkMolnuL6+/tlnn9HXE/7Isnz69OmPP/44EoksLS3dvn17aWlpaWlpZGRkaWlJVdXnz59TSuv1eiKR+OSTTzKZzNLSUiaTmZ6e/tWvfjU8PHz79u3jx4+nUinXOPuD/KVSyTAMrHXw7mSqXeh10QfZuJDthHjAziZJEvz/XSpiXdddeT6hPTp//jxfUDEgs/KgolgsNgom7X3yd36EhmEgxiQSiUD7CAdeTdNyuZyrZzKZRC5TfoT8qi7LsqZpxWIRwhfbw7tWfkVRxsfHcSG4BiqKwlZ+Xde9uzMf8r/55pv7u/eDx/T0NG4J0HX9ypUr+IAQHUIII/+ejl8sR4qqqnyWCOiKeSMW+7dBbIOPoCAIq6ur3a0nu7a21smrl0qlRgV2oPbrhRCpZDLpq32AqrLz5IetEVpSfRdzc3OunpFIBFHPAeQXBCESieA544SEEL4PKvlms1kW8oSWlsnfg8sanA4ty8IKXKlUkF+8Vquxu8WDrtVqLFbfBdM0EbPE3mOkjgW3mYno9OnTEBNgxILfJd39H6BxdHQUn7vwLCil3VD4Ye/qasS72CMxdr5JcpDlqcMlgLAsUUqr1SrKEyA+RxTFO3fuoA9UAIIgpNNpXjbB+But/HT3tTQMw7Xy12q1c+fOoTPSfuBfhn+QLMv9Sn6oSZDGCHOYt8YjyA/RAFFlExMTsEsjRkKSJOha2Uqlqip/s67ZEaGBgiAMDw/bti3LMt5+CA7dlXU7T36ozZgmCZMpHlEvLPuUS9PEArofPXrUlRFCwrcsa2NjA/MOyxO5vb1Nd99kjBb1V2AUQC5Z3gRAPeRHhW/Lsrzkn52dRRJ00zQVRZFl+f79+wgKVFXVKw73B/mxkzdNU1XVYPJjpgcxCCFY0l09YZ1GGR9MwOgPwQx9wHYI+Zgyjjj56W5OHixiExMTwdUQugKW9x5L39DQUMdiDXiIoijLsiiK6+vrPPmxw0cf27YrlQp4DvJj2HjxAsjP4NX253I5vMCICyaEtKztd21LegTZbFYURYgAFy9exNPB7UH3DvJTSjc3N0dHR588eXL69GnDMM6fP7+9vV0oFJhAiEcM7eijR4+y2WwkEkGSj4mJCfQhhGxubl67dk0QhDfeeCOVSo2MjCiKcvv2bYhq3SX/jz/+2GG/mqdPn4qimM1mq9UqDCjVavX48eOTk5O94OFDKX358mU8Hj979myVw+LiYiwW66R1plqtDg8PU0rfeecdllQeAkg6nXaNBOSv1+tTU1OpVOru3bszMzOJROKtt95iCQtkWR4fH//nf/7n0dFR/lhf8o+Njc3MzKyvr+OfMgimPgjwmE0hig8NDTGxHM8X5GeN0ORjF0B3E57jifAKP2j7sXx5tf2UUrby83NHqVTqqRWvA/DNHgmv/i7qPng0SozL/+sPG3ggpmliVVcUBV+xYzJNc3p6Go8LVn2I/ZRTAeDXnZ0d9irato1lnN0Cjo1EIq6r53I5150OAvnZnWOrKQgCVnLejMc0q0zbAQMh0xGyXEjoAEsBnxCuEfmZNRE4gqY+PFvfjQb+Hb3g5JNIJHxlMfzrOzNDVSoVkA06v/fee0/3gI0Eb2m5XMZu3zRNnrfBs5Vt25OTk65G7yEtk//atWuBN9hNwMgvy/L09LTLbYuJ/ZRS+FRRShn5YQJk2n628heLRXaGRuQfGhri1/leIP/a2lon+ZbJZAJ2zkhE03XhP6CwN9S9XR9hr6E/FH6UUy9DsHEcB2ISm9gY+ZkjBJK9eKd89h5j5093J2xZln3Jz8wzQC+Qv8MKv+np6YBfsbR295kYhpFOpxv9CjVwj2xPegf9Qf719XUwU9d1fv6GzRM0gP85f9TKykrzBRJYennXT6ZpukKsmMmwi+gk+W3b3rOqPNOedAUw8gWHouNV6ffktAcLH/L/wz/8Q+fHEYz/+Z//8Q1yJITw6lNvn5bSXTWpE+6FFFp/+MMfOqNxrFarsVjsd7/7XXA3x3FOnjzZFbm6Wq0mEonZ2dlXr14FdCOEpNPpv//7v+/YwHof/aHwC9EVQFHSZImobDbblchZaNSbnHeC9y9HDSH5QzQEv6vaE+VyufNq/1ZrVzby/z+aCMnflyiXy4ctY7fhFa8oysFWkgwGBJOWRogIpV4wTPYCfMifz+c7P44QLaEDCr82DHhIm9MxarUkmDD4RigdTfSHtj+EC4VC4VDFV4jTbfgvI7HPYQzJBQgmbdC4vSljIOFD/n/5l3/p/DhCtIR79+4hf8th4McffxwbGzt16lQbOwvHcaanp6enpw/bqPbxxx+PjY21d5WFhYWxsbFHjx4d+Kj6C+GePwSlr5eLSqVS+8l4Das7gn+BA7FKugpa7TOgCDYCnCqfzx+1SA0gJP9RB8KlEWSCGJj9h8HCa31oaIilSNmnd936+jobIc4Z4MzbDBCSgEgwpNmQZfmoTQEh+Y861tbWEOzAQqcuXbokSVLbNfCQ7EBRFGSqrNVqYNp+2DU6OsrXWa3VajMzM21PKEjTgIz6CAxDNF7vJCbpDPojh18IFw4wh9/o6KhL+wVdWnuJOhivXO1gV3sJv3Rdn5+fdzV+9tlnbacSwVLvOrYrCb+6i1Db35c4KG2/Kw8kQ9sZbwO0/Vj/21DRCYLgW9ZGVdU2uBqQxh93fXQMAT7k/+KLLzo/jhAt4aBCeg3DcCWTZmiPWr6rNADzYRvkj0QiL1688LZvb2+3N8KAja2iKGfOnGn1nH0KH/KfPXu28+MI0RJclQjahmmajQo0IZlkqyfk8yC60Db5WRYW77XaID/y6vj+hGwR3art1XmECr+jjqmpKW8jZOM2xH5Qy3diQgLpNuYsSZK88cL1er09okIr4btpQnKnIy32h+Q/UhgbG3OpzWGobzv1DUu4wjeiPlJ7i2qtVkPhBh4bGxttK/xgLHTxH1UujpTnb1+SX1EUXzkQidC87YgA8X1RPvzwQ99LWJbVI7UofHGAgT35fB7VENgJZ2dn21v2AcuywH+40CFpvG/+z+YxNjbGj9A0zbGxsbZVnjA98HeNuemoxfz4kH99fb3z42gJkiTxufcYGuVphKTna7hutONFBviezfpWKBQOamtaKBRY0nhgnwn58bRZhSlhF64isy0hHo/zg8Tntj0RsBh4T+hN4jbY6EtTX2fIH41Ge5n8jWSWlkAISSQSSGFcr9dLpVK1WiWEzM3NxeNxPrVxk9jZ2YnH45cuXcJXpt4rl8vxePzcuXM//vhjqyMsFArM9wT1Aiil//mf/xmNRn1NgMHASKamplzCIyEkHo+fOHHi6KT68iH/+++/3/lxtIRw5d/a2tq/kw8WQG/tIwBJ0FsSgxt5+PCXazXVH4bhmzrNsqxWtyfw5Gkkg6ASVqPLDR76cs9/gOS/fv26L8N7nPz7ATMTeisXuLqxVBlNkgFJVgNmJcuyvNnmg4canHKfzVB7/qfgw7u1tSUIQsAIkZKgDYGiHxGS/7rvJQaV/MViEUsfNr3BigPmk49SZb6cIYQg6zlOuOc+PB6Py7toxOqZmRl0gL99wNnAVdgmZFn2lQIwQjgsR6PRPXUlpmlGo1EMYD/Rjb2Po07++fl533d6UMm/s7Oj6zpLVR6ceAN5LyRJ2t7eRk14bx8EBdq2fenSpT1nE0LIyMiIYRiI9mlkT1laWuJHGLBQY3pCTv5bt2412gIYhoHI4ng8HjybQN4ZGxurVCqmaTa668FA35AfmzFeHe1Fo/aAn6CRDj6kB4O9NjY29q/txwTXSMQFr1yFEgKADXOwk4yqqo1UDI3OiQKNvvsOVrK9eX4iy2jAo8Nd977O+0DQH6Y+LN0osNcGDMOA3b49xOPxLhbk9cVBBfbYtt2oKDOedqsn9K16BCBspg1eybLsWyWlvTJhcENo9KuiKEensE8PBfY4jpNpAJTKbtuuu08sLi7Ozc01Glsmk+l8AZ87d+40ip85KBBCjojS+8iih8T+Wq1mNcDt27e7S35d1xuNzbKszruFHVRgT4ijjB4ifwACNHYdwOLiYq+J/SFC7B8h+fdGSP4QA4mQ/HujB8lfrVaPVAhKiMNAf+TwC8nvQqFQOFLBpyEOAz0U2OM4Ti6X+/zzz4uvY21t7ebNm90lfzKZ5NX7GNjGxga+thEAs08MJPkTicRhmzBC8OihwB54ffkik8k0Q/7aLlgLPLpZhma+J98nWHO+uLioaVqjsZmm2XkJvFQqdWsqPDzs6XEY4mDhQ/4ejGpuRuzf2dlhPnnMzZuFbcO1e3NzE5351LTBXh+0J8X+gURI/g7Dh/wTExOdH0cwmiF/NptF8AnyzyGTFLx0UZXJNM3R0VF05rM47enGH5K/MwjJ32H4kH94eLjz4whGM+Tn88+Dz47jgPysPR6PQ+APyd+DCMnfYQyO2D8yMsJ/Bbdd5E8mk4NB/o2NjV5OMdgeQvJ3GD7k//zzzzs/Dkqp4zilUunGjRu+/vN7kt/XPQHkL5VKpVJpa2vr+PHjIHmr5Hdp+9kJmfJ/f7feMgZS2x+Sv8PwIX/nX2WgVqsZjbEf8kMLqGkas8m1Sn5N0wLG1nm5YG1tLSR/iH3Ch/ynTp3q/DiC0YzYz5MfqSBQ14EX+xn6Xeyv1+u9NqT9IyR/h+FDjH1WPj8kKIrSPPlZZShN03wrOvU7+QcJm5ubTBED8j98+PDoBNV3ET7kHxoa6vw49oSmacHkTyaTrANSUzqOg/2CtzMywOAzSkocIPkrlYrdGM2f54ggmUyKoogsQKIoWpYViUQGz4WpB+FDDG9ppF7AnuQvFAqSJFmWhYyu2BKjMIvv2ZDw7+rVq8H5YWnr5Ec1KF9Eo9HmzxOAQQrsYVVDGCKRSK/lTRtI+BDjQKpBtAEUjcg1QDQaDSY/IQTq90KhwHSW5XLZN80OIWRnZyefz9+5c2fPWIbFxcVUKtVoYLlczlv+YWNjIxaLeZn/7NmzFp+KPwZJ2//tt99GIhH+Qf3sZz/r9qCOBHzIjxJrnUelUglIpNfdwJ7g9IGN5AIv/xslzGsVg0R+ups2k6FQKHR7REcCPuT/8ssvOz+OPbGn2H94aFvht7a2xl5oZLbEEqfr+j6F9lKpNEhl5Gu1mshV9et8lOTRhA/5z5492/lx7Il+JD/l9v9YqO/duwc1hCAIiqKE+j8G9lgaJeoOceDwIX8sFuv8OPZEn5IfNS0Y+QHTNNm7vrCwEKbipJzkv59iviFagg/5p6amOj+OPdFF8ufz+f0s0eC/a4tOCLFtG/OCJEmqqg6M9r49IKu/wIVahzhs+JD/V7/6VefHQSmt1+uFQiHfALFYrFvkz2QyqVSq0cDy+fzGxkbwGQJy4P/ud7/L5/MzMzNjY2PRaDSRSNy5c2fPQgD/8R//cevWrfZu59133/pcVRoAABb1SURBVD179mwqlUr0GOLxeDwe7/YofHDs2LH/9//+X3tPu5fRQ9p+Smkjdfp7770HG35XRgXVOkrBeoHKcwdyIdg7oBQUA8tjV6vVtrX9iqIMkqWgA7Btu9XK4n2B3iJ/APp0z98GSqUSU32rqupbliskfyfRHvkFrg6iaZq+uoxKpcLnoZBl2deIwxYe9jLIsrxnHfFarcbsJrque0P1fci/vb0dfNKuAF76Wschy3I0Gu38RrRSqcDjVRCE48ePu4SL/QT2hORvFe2RX9f1fD5PKQVpBUEwDCOZTPJ9DMNIp9PsqyzLqqpalrW4uMgvdZIkjY6O8joRX/K/88474Iiu6yhsu7y8zAbTFPn5qah3gJLJhmEoiiJJ0uzsrDeRJio3+ubYREivq1HX9ampKUVRvO3w/8XCa5pmtxTylUrFMAxsBBpJAa0iJH+raIn82LsZhiFJ0okTJ/BOSpKElZ9f/5FmbmdnB6lrDcNgFaKHhob46V6SpKdPnwpcQEqjld+2bUEQ2LGO4+Cd6W/y8zBN0zfpAB667yGYUL3t6XS60da6jQqwh4QnT54wKUBVVU3TvOpDQkiT9oImyV/ZRUtDrdVq7MCWnl6FQ/NH4a4Bx3FaGio7cE+3glZXfmSLtizr008/NU0TFaIRXbq9vc2YiX/Ezs4Owpnortiv6/ri4iJ/QkmSEJ/OjpVl2VfNjBkE/wWI/YIgEEKaJf9f/dVfNX+fXcFRIz/gOM7a2lomk0kmk7FYLJlM5vN5tqn7/vvvo9FoPB7f0/QQTP56vX7x4sVEIpHexYULFy5fvrzn8L766itZlhcXF9mBf/7nf77nYCillmVNTEwkk0l2oKqqq6urwQ//5cuXqVTq2LFjyWRyeXk5n8//4he/mJmZ2dNQsrW1NTc3hxtcXl4uFApnzpxZXl4OCPFolfw3b948fvx4Npv95S9/KUlSNpudmpoaHh6OxWLpdHplZYVS+vTp03g8PjExMTw8PDo6euvWrWvXro2MjEQikaGhoTfeeENVVUZ1SZLu37+fSqXYJWRZzmQyrut+++23Q0NDMD/FYjFJkv7rv/7r9OnTtPmVvzfde3kcTfLzePToEXOGlSRJ07RyuczylAcHKVqWFUB+TdO8b9Xi4uKevjdIl8y3VKtVURSDB1Or1aamplwHYr0K9l/OZrPeTRAiuANkB+R3dw2JECLLMr+uutAq+bE5NU1zfn4eCz72koIguKYY0zSxyEPyhw84IcQlxWDlZ+EtkO0TnuhbZLvTNI0lvymXy3iMzZK/N7X9PA6Q/MvLy/1Ifmj7Ic6B8K7AuAACwLnI9yf42Htd68HGAGuLbdsuSRVolE+BwTRNppTiAVVrwPNvVFEyWK7Z2NjwTe4C/jeabtogvyzLsiyPj4/jcrgdF/krlYooileuXEHdF+bgyER31lOSpGKxqGmaJElITi9JkjeDayKRsCwLmwicISQ/pY3JXygU+pf8+Axfg2g06oogbPQoAsgPpbTvTwKX+8gLRVGg2fZCFMUAw4Sqqr68wuIW8Py96x4AFjX6n+ZyuUaDAbV8f2qV/LDUEELefPNNcBjSmYv8cPGGKto1ZWezWf6EeBXhBGnbNowCvJmAUlqr1VZXVymlOBU4D3mQNk/+CxcuNH+fXUFIfq+pb3V1VfCgkUI4gPyNxPs9yd9oex8s+auq6sqGAGBVDHj+jdTSweR3EYZHrVY7KPLDzEYIOX78OFZgSZIwnZVKJXZTUMuVy2Us40ybq2na5OQkf0JJkhKJBDYFTJ/fKH07ExDorsjWgsKv97X9tVrNV7VbqVQaiaZQfnrbq9VqozdM13VW9otSahgG8nPtaW8zDKOZPs34BRqGEbz1BWq12tDQkJf809PT3s6HsfI3WsAppaIoBh/oO0PtmVjR99aox9blQi6Xa/SGINqq0TlbMvVh9iGEZDIZ3s7H1m30RBXJs2fPIr4Ts6RlWZZlzc7O8ueUJOnixYsw9bF9DfQXrtvBc2ON5XJ50Ex9HQP+H69evaK7Dhheejx9+lRRlEwm8/3334+Pj1cqFfSklP7v//4v37NarX7zzTd0N4gF08qLFy9cUsz3339f3UUikRgZGcFnFCyGXQqZiNghKysrST/89V//tVfKDSB/tVqNRqOsoiHDv//7v0ejUd8lmj2En//85y6bGSEknU4H54Pd3Nx86623XCR/8eLF+Pj49PR0APk1TfMq9qvVaiwWC9jz//d//3c8Hvcq9ovF4tDQ0MLCgu9RLZE/m81ubW1Bw18oFG7cuHHu3Dk8ung8/rOf/Wx4eBi0h53Ctu1qtVqr1YaHhy9cuJDNZrPZrEujIUnS//3f/3ntIMvLy7FY7OrVq/h6/fr1999/3/Vv2t7exn/BqyXxIf8777zT5H0OKmCkhYZGFEU4DvHkv379Ok8q0GlrawuTBQ4xDOP8+fP8aU3ThCKdJ3+pVHJJ2hDgYYLWdV0UxQcPHqD6IDOeF4vFth11AsiPX5nQyFqa8XGcm5tzqanS6bTrVL5IpVJ8UCMhZHZ2dk95p1gsQq/BmACDOfSgAQdCB6nrOuuWz+f3VGe24eFnmuaTJ0/4LQ+8Eho9EF4YdElDWL0buU6wxkYOC3CQ8x7blwq/DgBzsyiKuq5vbm5CimbklyTJu6tkxqdGemNGfkIINm+U0lKp5NoSO47DFDbQEsPBg58j9uPbH0x+Sunly5cxfwGCINy5c2fP01arVRjM2IEuN7WAA+HWhqNEUYzFYk3uifgDh4aGmixhBgmfHbhnesgwsOcoAis52MiTn70KqDKEcH0Ik9DugLqlUomfI5okP91dneCwLMtysVh02b0Olfy4CxZS2VI8FXRL0Lw2ry5F1Ep7BxqGgQPv37/f0jhZzsg9s4YdIfIvLS11fhy9CeSTv3DhAly1vXt+kF9RFEVRFhYWmNUdOHHiBK/rQkZ6SPLMqJtIJFxlah4+fIjzQEkjCEI0GoXXJ9MmVKvVtv38myF/CB5HiPyhwo/uOmlhtQfDsZ8E+V0WIzATn2VZhlTpFUGZ5xZcSrDy7+zs8EurZVksvoh57J06dYo17j/hj23bvo4uIRrBtu1GXgx9jZD8PqhWq3CQjkQihmEsLi5evnw5Eolsbm6C/IlE4sGDB6w/nDcJIalUamxszHEckP+7777j91CSJP3bv/0bPquqylRogiDcvXvXNYZMJhONRmOx2MjIyNWrVwM07a0C1qaedWHoQdi2ffPmzW6P4uARkj8IzEEFije6awkvl8v8CqzrOrT98OuilGKPcO3aNX6NhZMmPrvI75LhsctA8j8EbwpcOCelFJXI2rspWMI1TQuoKdabgNeDqxHuW7798/m87AGM6rDmADMzM95ufAdZlo+K2O9dhY4sQH74YIHtID94TiklhCC/AF4RtpwieAalPtjZmiT/5uYmcy4E+emu8wZeSro/hV+tVlNDtIg9yzr1I0Jtvz+Yss0wjMuXL7N1HuS/cOECOAnmI357cnJSVVVd19n+PJPJyLLMB2ZevHgRaRvgQYAXiye/bdu8cwvvbwv+YzbZD/lDhABC8vuD5du3LGt+fp7/Sdf1M2fOgK78zrlcLkP+5xX+vHDeKAWooij8JoI/p8vZnv0Ukj/E/uFDfte7HqIHUa/XwyLWIfaJUOEX4qigWq3euXOn1WxfA4yQ/H0JRHd3exT9B2Q9QJqd0NjpQ/6LFy92fhwhWkK4528P2WyWqWMQr3WUq6SFCr++xKGSv1wuWwOKubk5V8oDURR7syx1BxCSfw8gdyKlVFVV5sPTJG7dumVxajnfdDcsszoP35RSCMzE50MlP/JAHikcSEGEvoMP+W/fvt35cfQsBEHY2dlBehbGt4cPH+ID3P6BEydOIIwfPj+GYVy5coU39Zmmicxzmqax8gxIvMlfEUGEcCKCWxsDMwoe9srPvBUaVU/0YnNzkwXY8RGBtm3rug6nukbHsm4B7RDR8dnXYtoMeLGf4chGsoUKP39cv34dsRyCINy7dy8Wi504caJYLK6vr09NTU1MTPCdL1++nM1mp6enZ2dn19fXo9Ho2NjY+vr6L3/5S9dpv/rqK/q6JZ9SWq/X6/U6Guv1ejKZvH//fiaT8WaqwRt84Dd7dPAXf/EXSIw/NzeXz+f5jHr7x6tXr2ZmZtjC0PsIye8P27YFQbAsSxCEubk5y7Lg4YtQP1cEOFbITCYDIZ8l3pubm0MHsltY5t69e5qmqaqKPvjAnMnpbuQfsmKYpqlpWqVSOX/+vKqqGIMr/jdE87Bt+8KFC6GVhCEkf0OouwG88OtG7lT45Lo8veELPDU1BWkf1NV1naWXRmI/5GCFLzDZLRThXXmq1aqw6xrIAlQEQUD6UEQE7CewJ0QIIEzmEQQk23vw4IGqqojSxSa/UCjw3cB57CeR5BdgmRUBQggrUGFZFhLae/OuFQoF4XW/YJaAmbUg9VW4BQixH4Ta/oZAQi5BEIaGhqDJg7lIVdWJiQmQE6nXoYuan593pfpHlStezszlcnQ3mQfkfFe9MELIzMyMK9e9L/mFxgmqQ4RoBiH5/cFS8Qm7pRSgykZgfzweBzmhf0Ymn0gkoigK1PKSJCmKkkqlXPl8QH4UdUB6f1Cdjxp0HCckf4gOIPTw8wGYzwotOI6jqioL1zcMwxvdbds2S1BvvV44gQeKRjAjEyvV4rIz70n+MLAnxP4RKvz8USwWQTbY+R3HmZubw/78ypUrXvI7jnPt2rWJiYnx8fGhoaHh4eHFxUWWtKter6Ng66VLlwqFQrFYrHN4/vz58+fP+c0/T35CyNdffy0Elq8JEaINhOTfAyA/PiNLt+AptIzcOBMTE8wFsFarwTKHDoQQy7LwE0L0WQJfBn6p50tcaZo2Ojo6GOq90E+hp+BP/nAzyaAoCluTCSFws2MtUP7Dg+3p06euYwOybjK7HQP/q6vMy7Vr13ot/sRlEtJ1HSViXYAHBPuqaZpvZT5fwMeBb4HO1bcze2MJIbZtw7ECzx9OgexX71VczlSEkMePHzc5yL5GSP4QLYMQEolEYPvQNA0yTjKZhA8ve3l4hwVAURRvJkzW3zUDIuqOb0HpXphX3nvvPfj/Qh0jSRI4jD66rsuyjCEJgoB6R7Isnzp1ynVCXo6rVCqw6cbj8QN4TD0Pf/LbexVmC9FdEEK6GJGu6zqKAiMHIUIVkLBY5RKTFgoFbHwqlQqr/DU8PAy7KTtbKpVSFAWGFZ7tLrspalcjSyLSGfAQRREchhcm3ZUyYFixbRtKXFRMYgDVMU7MDoIgaJrWqOjdgMGH/BcuXOj8OEK0hC6a+mq1mqIojx8/FnYLUSPcKJ/Pu2KNTp06BS0Jn60QRWZ5Vi8sLEBWh5jA0p9C68nWf5hR6a6vNH09owlPfphaRFF8/PgxmA9uS5LE+2UTQjBh5XI5TChwxDz8R9gr8CH/r3/9686PI0RL6Bb5CSGIh/noo48ikcj09HQ8Ho9Go7lc7o033pAkiYnQhJDf/OY3kUgkFovlcrlcLpfNZoeHh996661MJpNKpRYXF9ET5K9Wq5FIpFQq3b9/v1gsFovF4eFhfMbWHX4TdDfiOJfLzczMsLIIoii+fPmSUlqpVIaGhm7evKmq6rNnz54/f57P54eHhwVBGBsb+9d//VecrV6vnzp1CsJLLpe7cuUKyD80NPT48eNnz54dYJWUnoUP+V2iUQgvPvvsM/YZImVwf9bBV56E4OqV4QOk+nq93sWqO7y8jS03+2qaJtPJpVIpr4USPgv8/SaTSQRNILRZ13VkPXCJ/YqiQLJA4nNUNOTJjw9s9UZshSiKqPMBRUAkEkHMFQupAvmxbcEYWIX1w3yEPQH/PX/oQBIAJIRhX5k7EA9UkgHVIYhCUp2enua71Wq1W7dusXwS2D+zQhG9WVGPhSHyNXBUVR0eHsZXJpxjk48VFY6PqqqeOXMG3k3soS0sLNDdMAocODk5Sfci/3vvvYdL41ee/Oxpj4+Ps+eJFAksdQI2LIz8zFlbFMWj8/L7k19vrs750YRhGFtbW1jM8ap5VwlCiCiKyAjAv46zs7N8N03TYrEYlGR4F03TfPjwIeaO/tp/jo+PMzMbpdQ0zfn5eZDftm1IBCxCEZ9xIMiPJ4YWFMYLJj+l1LKsRuQ3TdO27fHxcZAZXpVo5MfsIj+u0ptz7mEgJH8LsG0b/jkjIyOwOeFFrFQqlmW9++67/MtqmmahULAsC32w9MXjcbY2Amtra+wrrypHyEAn7655GIaRSqVkWUbIAzwdBEHAX6b2472SobqrVCpeV+V0Og3pwJXRKJj8MPI1Ij8wNjYGzrP5t1qt8ns0L/mhKazX60fB2h2K/S0ACwj8c5gamVmeJicnXU4phBBN0yBtKooiy3I0GoVhnO6a62ZnZyGXwjSt7+bPgo2q0Ujq9bqmad3a80NdD6sYa0F2I34z7+I52OslfzKZhKfAnuTHzIh9R61Wa7Tnx9Sg6zpED+zhsdeIxWL8zMvIj9wNiqJA8t/a2joKyZF9yP/b3/628+PoC4D8hJB6vR6NRicmJi5fvvzkyRP8evLkSXzY2dkplUqzs7Pb29v0dbH/7/7u79jZ6vV6sVhMJBLHjh27e/dusViUZfnatWvQdafT6QCdUy9E9ZXL5enp6Xq9Xi6XS6XS8ePHvR14ntfr9QcPHqysrLAcJ8CXX35JKSWEIOSRUvr1119nMpmhoSEX+W/duoXP/Dnz+Xwmk4lEImiBxv758+d0d5IihDx8+BA6QpeVEeS/fft2LBZbXFyMx+Nra2uO4/zZn/2ZayYaSAz+HR4gQH5N0yD00tdr3TPyA4ZhwAsN2ibIqLFYDEsQ4y1EU0EQmP4MocFQRzeidy+QnwECzrlz51ztSATqapyent5TroRc48qVDBcAb2d477CJEl56rj4wAXgFJVVV+WeIxZ99Dh7kAMCH/NevXw+jL3zB9EYov4tGhP1TP/LfvXsXAf/MfeXEiROmafKO6ENDQ5gg2Os7NzfXzPNnkUIhQrSHUOHXAnixn5EfGi/qR/5isUgpxSKGRlcRVKiX+FWrUqnEYjFk7O5ZhV+IwUBI/hbgS34GF/llWd7Y2IBqkAm6vKmPEKKq6ieffMKrmk3TjMViCBPstUi+EAOGkPwtgGn7g8kPJ3ZJko4fPy5JEr/F5Z18YCkslUouxV6TYn+PbPhD9C98yL++vh5uJn1hWVY0Gl1dXf3iiy94J790Oj02Nvbzn/8cX1dXV/P5fL1e/+1vfzs1NXX+/PmZXfzJn/zJzMzMxYsXoY6mlH788ceGYRBC7t69WyqVSqXS6dOn4T9//vz5RtWT4Al/RILPQhwSfMjvzVEV4vDgOE4bAdQ9pe0P0afwIT/UVCF6GWHe/hD7hw/5c7lc+FaFCDHw8CF/Op0OFX4hQgw8/Fd+vjg88iK5op3effddtDBVdrFYZN3QWK/XFQ7eszEnKjhpA9h0MK94AJotvpGlgrNt2zs8dkLeT4s1MhMaktIATNhZWFhAC1PCl0ol75j54aERSn7XCfn7ZSdEFlAAGhb+2Gw2i258IxseO/YoBJyHOFT4kH9zcxPZFADHcTY2NjY2Nvgkp1999RUaWV6kb775ZmMXeFMJIcVikTWiGyGkXC67joWXOxqfPXuGxnK5XCwWt7a2qtUqHyvi6saO/fzzz9nw6vW64zh//OMfXVVuvv32262tLV5JjkvwOs4ffvjBcZxyucy6vXr1ynEcx3F2dnZYo8PBt5Efiasb3/jq1SvXsT/88AP/8Pmz8ceGqv4Q+4QP+Y9CAqMQIUKEgT0hQhxRhOQPEeKIIiR/iBBHFP8fphtxAl6sgC0AAAAASUVORK5CYII=" alt="" />
所有的可运行进程都按时间在一个红黑树中排序,所谓时间即其等待时间,等待CPU时间最长的进程是最左侧的项,调度器下一次会考虑该进程,等待时间稍短的进程在该树上从左至右排序
红黑树是内核的标准数据结构,该数据结构对所包含的项提供了高效的管理,该树管理的进程数目增加时,查找、插入、删除操作需要的时间只会适度地增加
0x4: 调度策略
调度策略决定了调度程序在何时让什么进程运行,调度器的策略往往就决定系统的整体映像,并且,还要负责优化使用处理器时间,影响调度策略的因素有以下几个
. I/O消耗型和处理器消耗型的进程
) I/O消耗型:
进程的大部分时间用来提交I/O请求或等待I/O请求,这样的进程通常都是运行很短的一段时间,因为它在等待更多的I/O请求时最后总会阻塞(例如键盘、或者网络I/O),典型来说,大多数用户图形界面程序(GUI)都属于I/O密集型,它们大多数时间里都在等待来自鼠标或者键盘的用户交互操作 ) 处理器消耗型:
处理器消耗型进程把时间大多数用在执行代码上,除非被抢占,否则它们通常都一直不停地运行,对于这类处理器消耗型的进程,调度器策略往往是尽量降低它们的调度频率,而延长其运行时间,处理器消耗型进程的极端例子就是无限循环执行,更具代表性的是那些执行大量数学计算的程序,例如sshkeygen、MATLAB
/*
要明白的是,这种划分并非决定的,进程可以同时展现这两种行为,例如
1. X Windows服务: 既是I/O消耗型,也是处理器消耗型
2. 自处理器: 通常不断等待键盘输入,但在任一时刻可能又占用CPU进行大量拼写检查或者宏计算 调度策略通常要在两个矛盾的目标中间寻找平衡,进程迅速响应(响应时间短)和最大系统利用率(高吞吐量)。为了满足上述需求,调度器通常采用一套非常复杂的算法来决定最值得运行的进程投入运行
*/ . 进程优先级
调度算法中最基本的一类就是基于优先级的调度,这是一种根据进程的价值和其对处理器时间的需求来对进程分级的想法。通常的做法是(未被Linux完全采用,只是汲取了其中的精华思想)优先级高的进程先运行,低的后运行,相同优先级的进程按轮转方式进行调度(Round-Robin)。在某些系统中,优先级高的进程使用的时间片也较长,调度程序总是选择时间片未用尽而且优先级最高的进程运行。用户和系统都可以通过设置进程的优先级来影响系统的调度
Linux采用了两种不同的优先级范围
) nice值: - ~ +,默认值为0,越大的nice值意味着越低的优先级,相比于高nice值(低优先级)的进程,低nice值(高优先级)的进程可以获得更多的处理器时间
) 实时优先级: ~ (其值是可以配置的),与nice值相反,越高的实时优先级数值意味着进程优先级越高。任何实时进程的优先级都高于普通的进程,也就是说实时优先级数值和nice值互不相交,Linux实时优先级的实现参考了Unix的相关标准(特别是POSIX.1b)
/*
ps -el
N1列对应的就是进程的nice值 ps -eo state,uid,pid,ppid,rtprio,time,comm
RTPRIO列对应的实时优先级,如果显示"-"则说明不是实时进程
*/ . 时间片
时间片是一个数值,它表明进程在被抢占前所能持续运行的时间,调度策略必须规定一个默认的时间片,但这并不是一个简单的事情
) 时间片过长会导致系统对交互的响应表现欠佳
) 时间片太短会明显增大进程切换带来的处理器耗时(因为会有大量的时间用在进程上下文切换上),而这些进程真正能够用来运行的时间片却很短
) I/O消耗型和处理器消耗型的进程之间的矛盾也更加凸显出来
3.1) I/O消耗型不需要长的时间片
3.2) 处理器消耗型的进程则希望时间片越长越好(比如这样可以让它们的高速缓存命中率更高)
/*
综合考虑时间片下的各种矛盾因素,因为长时间片会导致系统交互表现变差,很多操作系统都很重视这点(特别是桌面操作系统),所以默认的时间片很短(例如10ms) 但是Linux的CFS调度器并没有直接分配时间片到进程,它是将处理器的"使用比例"分给了进程,这样一来,进程所获得的处理器时间其实就和系统负载强关联了,这个比例还进一步受到进程nice值的影响,nice值作为权重将调整进程所使用的处理器时间使用比
1. 更高nice值(更低优先级)的进程将被赋予低权重,从而丧失一小部分的处理器使用比
2. 更小nice值(更高优先级)的进程则被赋予高权重,从而抢得更多的处理器使用比
*/
Linux中使用的CFS调度器,其抢占时机取决于新的可运行程序消耗了多少处理器使用比,如果消耗的使用比比当前进程小,则新进程立刻投入运行(抢占当前进程)。否则,将推迟其运行 . 调度策略的活动
想象下面的系统场景,它拥有两个可运行的进程,一个文件编辑器程序和一个视频解码程序
在这样的场景下,理想情况是调度器应该给与文本编辑器程序相比视频解码程序更多的处理器时间,因为它属于交互式应用,第二是希望文本编辑器能在其被唤醒时(即用户打字时)抢占视频解码程序,这样才能确保文本编辑器具有很好的交互性能,以便能响应用户输入。Linux系统同样需要追求上述目标,它分配给进程一个给定的"处理器使用比",假如文本编辑器和视频解码器是仅有的两个运行进程,并且又具有同样的nice值,那么处理器的使用比都将是50%(它们平均分配了处理器时间),但因为因为文本编辑器将大量的时间用于等待用户输入,因此它肯定不会用到处理器的50%,同时,视频解码程序很容易用到超过50%的处理器时间,以便它能更快地完成解码任务 这里关键的问题是,当文本编辑器程序被唤醒时将如何处理,我们的首要目标是确保其能在用户输入发生时立刻运行,在上述场景中,一旦文本编辑器被唤醒,CFS注意到给它的处理器使用比是50%,但是实际使用却很少,特别是CFS发现文本编辑器比视频解码器运行的时间短得多,这样情况下,为了实现让所有进程能公平分享处理器,调度器会立刻抢占视频解码程序,让文本编辑器投入运行,文本编辑器运行后,立即处理了用户的击键输入后,又一次进入睡眠等待用户下一次输入。
因为文本编辑器并没有消费掉分配给它的50%处理器使用比,因此情况依旧,CFS总是会毫不犹豫地让文本编辑器在需要时被投入运行,而让视频解码程序只能在剩下的时刻运行
现在操作系统的调度器是混合了抢占式、非抢占式的综合体,即按动态时间片轮转,也可以允许进程主动yielding让出CPU控制权
0x5: 调度相关数据结构
可以用两种方法激活调度
. 直接的
进程主动睡眠、或出于其他原因放弃(yeilding)CPU
. 周期性机制
以固定的频率运行,按照一定的时间间隔检测是否有必要进行进程切换
调度器使用一系列数据结构,来排序和管理系统中的进程,调度器的工作方式与这些结构的设计密切相关,几个组件在许多方面彼此交互
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAX4AAAC9CAIAAAA7s4EFAAAgAElEQVR4nO2dQWgjWXrHi6AQCh0cdCjwoRscCoPjxguqDj1EGAdKTJi4nQ5dpu0FZ3qZTPVGsONOE6fsSbNRN/JmR5rMQb1pWFPbyyhML6PDTqVFyC5a9tAZZZllRwRSwQrs9mEOCaUM5KJc+vIqhz9+W12SylJVSSXb3+8kl6veeyrV+9d73/u+7wkuQRDE1BGSbgBBEBcRkh6CIBKApIcgiAQg6SEIIgFIegiCSACSHoIgEmCo9PR6Pf1V9vf3p9kygiDOMQOkhzEmCIIgCOIgfP8SJo+maZqmqao6Nzc30YoURdHGZH5+fvTyZVnGh8uXL0uSNG5dI+KrVJKkpaWlCdXlwzRNxhhjjH/A51gKdxxn+t2DmBxDpefhw4cD/1Uul23b5kcsyypPElmWy+WyYRiSJL3++usTrUtVVWlM7ty5E1ftiqKMW/tARqlrdXU1lrp8iKIoSVI6nfZqHw4qiqLreuiSBUFQVXWC/eAsY9u2qqqMsYH/1TTNsqz+44yxADXXdX1ggZ1OR9O00E31Mlh6RFHs9XqxVEBcHPAof/7556aHWEYriqKQ9AzDNE1BEIZJjyAIhmH0H6/VarIsDytTluWBP1yz2RRFMXRTX2lY/yFIz7BvQhDTh6QnAJIegpgUJD0BmKaZTqfPj/TEUjpBxAJJTwAw5A/7L0kPQYSHpCcAkh6CmBQkPQGcH+nRdZ2kh5gpSHoCIOkhiElB0hOAZVmxS4+iKF73PU673Y5rDWqA9Dx48ECSpJcvX556cXuS/PKXv/RV9/LlywnV1e122+12p9MZ9/b993//d7vdDuED1ev1UOm4F57KL3/5S9+3+7//+7/Ya5ky3/ve91Kp1CjP5MXk0qVLw+RgZ2dHkqT+4//1X/+VSqWeP38+8KoHDx4M03pBEMrlcuim/rqcgUc1TRulV4wfqzAGqVTK59LqDaSAc/3KykosdfGIkHG9bOG5G+KXME0TlYZ28B1GKpXyfbu5ubnYaxlGv+c0PNGDOfUtalmWIAjk5urFtm3cYV3XBUFQVXWYl7woivxPeDbbtg1voIEDItd1EfRTLBb7C/TVFeKFDSJJTy6XY1Pk+PiYf0YDplApftphPHv2LLT0CILgjXXyYppmQKXBeO/SMCqVimVZ+Ow4Tui6RsEwjP4G8P+qqioMd4fjkPT0o+t6xBct/7MfWZa10UIUa7VauPZHkp58Ph+u1vNEFOk5tcude0a8DyQ9/ei6Lg2aSU25DcViMdy1g6VHkqRRpOfw8DBcrecJkp4okPSEZhakxzTNOKWHMSYIAknPiJD0RAGaQtIzkBcvXtjDgZks2RaaplkoFBzHsW3btxiPmXXAtZGk52/+5m/Gbev5g6QnImRmHsa3vvWtwhC2trbS6fQsSI+iKLxVJQ97e3t7e3vHx8fDro0kPWTrcUl6IjNl6WGMqaraarWiF+W6brfbHZgNZwrMyIQrTjMzSc9YkPREwXGcUVzULMsaRaFGrHHg443VzAAkSeq3a/R6vYAl6olC0nPROSvSM9A5NXFGNzPH5c0M6RnojcIdDoAkST4vh2az2X+VqqoBbsGT40JLT6FQCFfreSJZ6fH6yIBHjx4ZhqFpmvBqUlFN09BDsCrBGOMeN7Zt8wkIfB29JkN430Rs5zBmSnp85HK5YSXAXwk3XJIkURT5/VcUZTqv5AstPbTC5SYtPRjwa5qGSYGqqtVqFf/yxj05jqOqKiJ9yuXyjRs34JCGCyVJ2tvbw5mapkF6arUaLp/oI56U9ODxhnAPqx0eswNLgH2nXC7n83nceWi9YRjlcvmTTz6JpanBkPRcdGZBeizLarfbjUZjY2NjdXX1/v37x8fHXHq+/PLLarW6srKytLT07NmzlZWV27dvX79+nQcJX79+HQ9Qr9dbX19Pp9PVavWv/uqvFhcXj4+PNzc35+bmGGO9Xu/LL7+M2GAfSUnPo0ePOp1Oo9GoVqvDTM5f+cpX3njjjdXV1UKhcHR0NPCc+/fvu67LGLt9+/bi4uI0Z9BXrlxZXV2dWnUDSUx6NjY2wtV6npgR6YGvh6ZpxWIRn33R3ngtY1BTr9cRjCPLsizLoijiAcJQSJIkTdNSqZSiKIqiwF8e064PPvggYoN9zP6EizGGmzDwV759+7Z78i1iX+rq9XoBFjrM8uKtcVzIzJwksyA9iqJg+wdJkvL5vCiKmqb1Sw8mXJqmVatVwzAwsXIcR5blWq2GxSZIj+t5r2iadsFtPYwx7DLWf06xWDRNU1VVn4EsFhYXF7GV0ECSWlnzYppmQHDysKQ/gKQnKrMgPaZpwsrAGDs+PsYTOXDUA3Gp1+u6JyuToii1Ws0wDAyLsIzNrT8zYmaOy68nupnZS71exy0dKEwR+c53vhOwJyIGrbFXOhamaQZvMBkwaktSejCUDfeuwLpM//FmsznlV8EsSI9lWaZpyrJsGMbGxgaGLT7pgZkZYfHVahXSYxgGklpg2IzXuyRJjuNwCwjMmVgRi92f+KxLT7vdhqBPf3NULBFMuVIfZ9jMjJwJw8RCVVVFUdwTkUJvwS8tyzI376PjYZ34+PgYBXLvDK8vBi5cXl7G1AOZAXRdl2V5oMvGKISTHphaoktPt9vlS+YosNFo+KQHO0Zird0wDNxzmHh80uO6LqTHdd12u41UL7D1IJdC6Ls0jFmQHl3XB77GRpGebDYLvx7c3mkKEIaoU6tuIMlIj2VZ0aUHjlvDHFVt20bHxuNSqVQkScJqKO8h7klaIz4B5h8wT37rrbd4gaIoKopy//59dFdZlvHYCYIwZelBm6NLT71e59KDqfX29rZPerrdbrlc5qZQWZZxB/iDiwkXPntvLIA0R2znMKYjPb1ezznBsixRFN9++23ILna7HmivDZAeDB5lWd7e3nZPFukh07Isf/zxx+HaORa6ro/y4DmOo2nas2fPfAc5/GB/wOepNzwZ6TEM4+233w5X69HR0Y9+9KOPPvrok08+kSRpbm7uyZMnz58/L5VK6+vr/Pv3er0f/ehH7XYb0vMXf/EXgiBcuXKlUCjkcjneQ15//fVMJnN0dPTs2bPf/u3fbrfbrVYrnU6n0+lGo/Fv//ZvvF5RFK9evbq5uXnp0qVOpyNJUi6Xq1ar05eezc3NWKTn29/+Nlr+9OnTtbW1arVar9crlUqn01leXuYTrkajsbq6urGx0e12m83m7//+7y8tLfGfOFh6rl+/zr9g7ClKJ2Fm/p//+Z9areZ9gP/93//dmzF2RAn74Q9/2H+QMVapVKrVav+qfK/Xw2r9v/zLv/RfWKvVOp1OjKvvp0rPs2fPlpaWstnswcHBH/3RH62trWGs9+jRI0EQ/uAP/mBra2thYWF+fr5UKrmuW6/Xr1y54i1hbW0tuA3JSI9pmmhxRIZl/H733XexqIl4fEyj+GwLIxqciWGObduWZa2trWFpWRRFVVV9sfyapsGKgbeTYRgoyrKs733ve+Han+yo58aNG/0HkRYTK+Ku67ZaLVmWeV2MseXlZdwWvLr54rp7Ij2O46yvr2PVjOesk2U5dkeSeKXHtm3DMJC1dtbi4/iQXFXVWNqGLKXBNfI+0u12uWUD/YjrJk8UWa1WfW+dU6VHVdUEpMe27VhcCodJD+yagiC4J/Pzzc1NDBHhgOuVHvQxxtilS5cMw0CH8Y6iEX8IeI5nuMDjQzqdDtf+ZG099Xp92L+45voG0rZtf/jhh/xPy7K8Hr24t4wxZxAJmpm96jmwHKxw45dN3AjSD35x/uC9//77EQsMfvDgKsG7QK/Xw5vY7ZMe/hPU6/VxpQduGSHb339o9AlX7NLju5U+6bl16xaMnfB5Gyg9y8vLsDHDLO37XuhRqVQK58D4ijXp0CqQ7ArXJJhmq6Lbej755BNfsuFMJjODNxZmTd5I7HoQZYkq+MHDjR1ow/JJD/xIL4r01Go1iAgURPDkpvZVwaVHFMV8Po8PiqL0Sw9jTBTF+fl5Xmb/2hl8fL1Rr1CfYUHJo3D+pGeaRJEexKwJg0B45zAw240IJuxjMaxeRVEGLvIWi8VhRUEvokgPHvhyuYwJteu64aSHxwyOy2yNevqrwHMJQ8PW1pZt23iqvNLjTfhy69Yt13Vh6xEEgS+aQnTwS8PPElMwflAI6xUWTnrimnCddaJID3bdDKEaA/dgGAg/OUQtYzHwEbp8+XJw2wLmladKj/du4MkPIT2+XTH6b1RA1zgD0pPL5RYXFzc2Nr72ta9VKpWDgwNst4jb9N577127do0/u5Zlzc/Pp1KptbW1brfLi8Ky1/Ly8vXr1x89egTpEQTBsixYnf/+7/8+XPuD7+8wZFlOpVIkPaNLj6IoA0/7yU9+sru7m8/nM5kM34OsXC63hjO6xYo/Qt1uN6DAUfjxj3986dIlby/NZrNbW1uVSiXciDuVSo0+6nn58mWpVGo0Gu5Jt3r8+DEaxu9quFHP/fv3cXNwVzudzoi3OgHpYYxZJ8AerCgKP4JwJJyJzK8ITeJrVTjIvYG81kfLslZXV+F9K5yMY73ZYeGIuLKywqVHlmUMfKbv15OgKTSpnJ79xLvChWdDOAlDiwuYCPnncC8M79xQluXoG88GL67D/sClBytc+NNn6+H0S8/KykpwG86YrceyrOfPn+NhGohv4qPruvcIX/kyTbPT6ei6jtRNCMJ+8uSJe5LsEt5iXstOuVw2DANrOnAtQ8x3lEchWelpNpu8dizt5fN5DCRxQ3if8cpNqVTyttm2bd6dDMOA3MNpC+mvMLWZhFZOwq/n/ffflyRplOnziBKMcH/+OUREG3o+fvS40kWKohj84MEZHZ/r9bpwYn/APR8mPfy3cBwnk8kEt+GMSc+4DHwu0aPwL74S3H8mYyxgyOd1dQndvMSlhz9S8BkpFovwHOHL5O7Ji467F6TTadETEi0IAl+kR9dyHOfq1asYVKKpMJBFb7CPCUWujzI2QdX4bNv2p59+ivcQ/uVVLtxJ13V7vR7WRpAebKz2DHw+o3Dqg4dxPdbR1tbWvD/fMOnByAh3WxTFra2t4Dacc+mZcRKfcOFZcV0XroClUgmxWhj34Rwej44l3g8//JAHo/BgN34mhuU7Ozuu6yLOy51YBuLpJ83wVc0/83xGfCmKG3qQgcQwjFKphNVV2FOTTZczyoMHfyhBENbW1rw3GaGRPhhjfFaIQe6pRjGSniRJXHo48JBE/AQMAV7p4cGioihubGzgocRBrwWX59aAdwyPS4LtLN4Gu7MkPc+fPxcEAaNp3CXXdb1uioIgpFIpnJCsqQ6Ee/DihaQnSRKUnm63WywW5+bm8HaSJOng4ODOnTtvvvnm/v7+5uamV3rm5uaazWaz2ZQk6c///M9h0ecHkfm0Xq/v7Ozs7OzU6/XXXnstk8m8++67uVwO64y7u7txbV/FSUp6vvjii93dXUEQdnd3S6XS4eHhRx991C89YHd3V5bl/f39ubm5zc3NhYWFTCazu7t77dq1zz77LMZW+egFMiPS4/WMHwuSnqj43CBHJK7XZq/X4/MgSZIsy9rZ2cGox9tdvW5QiqKsrKwgesu3omGeoGna4uIiohPwiOP4559/Hr3NvhpnYdTjum673RZP0u54pQdR6Rj1ILqSu4OIE8gi4iWTyQiBzIL0pNPpYetFqqoGGPJJeqKSrPQ0m02v9DDGcrmcoijwHvBKD6ZLWAq8fPkyzhEGOVLCOwEPgOM4cGXgEUDxMjvSc3R0xKvg0oPbBWOtZVmVSsV1Xe7/MWnpwULwMGZEem7evOlrWC6Xw5sP+5oNu5akJyozIj3wFWCMHR4ewvnb2135QqzjOIZh3L9/Hy4F3JMVYCgknARYI20zP4hYluht9jKi9BiGMVHp0TTt9u3b/FZw6YFk40bJspzJZHjWBJjPLl++HG+rRmdGpIdsPYnBDQRjEeOEyxsOwhhbWFhAP/FKj/cxxcgIkRze0CEengJ3p6tXr2JJHhZrOIkklaUwwOU9YtVYONd1fXFxkf+O4qtpD3AOHDj45MswDF+qrSlD0nPRSXaFC74YkiTxcQHcBZG9CEeazaZvaHZ4eIhRTH+B3CpUKBSMk/BdN+nF9clJj3CS2TqbzfJ/+US5XC5zJULSXu1kK9cEIem50Hz55ZfJSs8XX3xRLBb39/cvXbr06aefoklPnz7Fa3x9fd113e9///vNZpPn0CuVSrdv3y4WiwiOy+fzxWLxP/7jP1Dgzs7O4uLiO++889prrxWLRUEQNjc333nnHUScRG+wjwSlp9vtHh4ePn369ObNm9ls9j//8z+bzWaxWCwUCoIgfPTRR67r9nq9w8PDfD6P1AjvvvvuW2+9hQWmg4ODa9euhe540SHpudBgjTPBCRcItucBOOD2nwZzoPeI9+tMYo8XL5OQnrHymZmm6fu+six7u7RhGLAxq6qKMB2O4zgJ7v9J0nPRSdbMfNZJcNRz1iHpueiQ9ESBpCc0JD0XHZKeKJD0DAPZfuXhzIj0IK5YlmVkOPAxkY2PSXoASU8USHoC2NnZGbah8OxIz8LCQkDC2Ul5Mw9MKHvRIOmJgmmao2Rxv5jSEwA66SxID98yeyAB14aXHu/mHuGAf8ToDMsBPhbo83GxtLQkCAPu4Si/mXCSmiA6yPUF9vf34yq2n08//XTYQzYM7H45DJ6TPBiSnn6EVzf4HgXv5cHSMGKBydh63JP12hDcuHFD0zTkDJRG5sqVK6Fr9NXOt9NBxACmrCG4ceNGuOVnHr0ZO7u7u+Pe2BgZKPfBl4yS9Yakp58QyepxG8GVK1d8R7yMXjjyPYcgkvQQhI9+Q2MseaBJevpxHAd3mG+M03/zYUqTJKn/+M2bN0VRhNAMtGEjStbH3bt3BUHwHgkYOgVD0kOcAUh6Agg21Qt9u9GBWq0WMNUdZovsD8oJDUkPcQbQNE0O3Pj4IsMYkyRp2OgyQEQkTxJ4H4jd7/8vxCEWH/fB0rO0tETSQ8wOARsfE65n7+9+dF0fOE5BDNAwwQoYSQkxrawNXp3RNI2kh5gdSHqCIekhiIlA0hPM+ZEeVVUnmvmRIMaCpCeYSUjPQFuPO1HpgSUJaWgJYhYg6QkmnPQgHeXAq0zTHGicdic96pEkiUY9xOxA0hNMCOlxXTdgx4jEpEfTtK985Ss7Ozs5D1/96lfv3r27MWEODg4qQ3j48OGEKt3d3R1WaTDf+MY3xq0rXEWj82d/9mfBDSiVSg8fPpxE1fV6vVar4XOz2Wy1Wq1Wq9lsRi95Z2eHpCeA8yM97vBtyMeKGQkBvDMHsr+/P+nagWVZw9rg49mzZ94LsSNaiBr39/dHrPFUjo+P+bfg5eu6jjTmOAcZVKcGYwwhLIZh8AaUy+WxConlcT+vsECPp2H/LZfLIRJsxuKe7gZIDzEumBQkmKyXIM4QJD2xgR1pQu9U1f9q2tzcHPhSsm1b07T+8zHA4X96XU5lWUYggq7r/W71jLGHDx8iHsd5lXDfhSBOhaQnHhzHQSDvwsJCiMu73a4kSVwUMBnZ3t4eOFSGzwXGvW+//TYSJyEBhXSykTFjTJIkRVFQgiAIuq67fcFQpmkiTDmdTmuapus6DzSfm5sLWHwliIiQ9MQDtqwC4TYIRgkYawiCoKpqPp+3bdu2bd84xevuValUkKwHCSu8psFyuSyc7JbBTYOQnhcvXuAcmIQkSapUKq7rwqqCf7Xb7YCgRIKICElPDBwfH6dSKS49165dC1EIY+zx48eMsZ2dnbfeeqtarW5ubh6dgHP+93//9/nz55ubm8hpcP/+fcuy5ufnc7nc/Px8vV73tcq27W63W61WBUHY2Nh4/PixJEmXL1/+5je/iXNqtVq1Wp2fn19bW6tWq7quZ7PZo6Ojdrv9D//wDyQ9xOQg6YkBvu9w6IHP9va2JEnwH1UUBZffuHEDPR9p1fjJfNRj2/bR0RGvFFO2er2u6zrP2tU/6vGOoRzHsW0bm6lj/UtRFIy8fvzjH5P0EJODpCcqWNjyMe5GnVj/hnZg1qMoytzcnCzL/Ag/GdKDPHKXL1+GymBDXp7tBAV6pQdzMUy43n//fV6abduCIGQyGbgUGB4CvF0JIiIkPVFBD+9n3HJgc+GjDE3TlpeXffmxWq0WT1ANeWKMQXQYY4ZheCUPG2aapnn58mWoIR+dXb58mY/LYGOCfkFx8I1gwCbpISYESU8kGGPozNiHSBCEXC6H8ci4Ax+MnjBIQbH37t3j0gMJ2NvbQ+YnTIUMw3j77bf5OIuvoPNL8CfzpHfyTbjck9ni3bt3+XHYuTudDs22iMlB0hOJXq+naRp6NWYutVoNezCEkB4+6kG63KOjI2gHpkKu63a7XcaYL6EBRj347DgOP46Fc9d16/U6T4XpW1w3DAOiCU9IZOqFGOVyOVmWybWHmBAkPbHBpSfEta1WS1GUTCbzt3/7t4jz6vV6P//5z5eXl0ul0vXr119//XV+MqTn+Pi4VCp9//vfh7mnVCqVSqVCofCzn/2s2WweHBzIsry8vFytVvf29nj0k6Iom5ub+MwY297e7na7u7u7aHan0+l0OjAw/9M//VOn06GwKWJCkPTERhTpWVtbw4AFzjhw6nvw4AHP+y/Lcrlc7vV6fM+ZgaMeAI9EODebpplOp3EVZmr47D3fMIxarcbrgvXnwYMH2K4n9A0hiABIemIjivR4rSrePfMwP8L6FM7BwpPXXtMvPT4+//xz38Z7u7u73hNM06zVat4oCtu2P/roIz6XJIjYIemJjSjSEwyZe4nzB0lPbExOegji/EHSExskPQQxOiQ9sUHSQxCjQ9ITGyQ9BDE6JD2RaLVasizH4lJIEBcKkp5IBARS9CcDJAiCQ9ITlbjCRwniQkE9JCqxJM0giIsGSU8MYIblJVyOVIK4OJD0xECz2fTqzhtvvJF0iwhi1iHpiQdu8Umn0xT3QBCnQtITD3wznKWlpaTbQhBnAJKe2ECGrUKhkHRDCOIMQNITG0hzgw2tCIIIJjHpYeNzfHysBxKizHAM/BZYZX/vvfcmWuMkbmyU6ggiHIlJjyAI2Wx2Yxz+9E//tDICpVKJX3JwcFCpVMaqZRS+/vWv7+/v7+/v/97v/Z73eKlUunnzZuzVbWxs3L17d38Qf/iHf5h7lTfeeCNiXTdv3uyvaH19PTeEq1evLi0tkWARY5Gk9JDzy/nAl6aeIEYhGelptVqiKCZSNRE7JD1ECJKRnkajQdJzbiDpIUJA0kNEhaSHCEEy0tPpdEh6zg0kPUQIEjMzh5AexlhvfCbaJV6+fDlKGybXgIAmTa1Gkh4iBLMiPe+++656GnAXHpejo6NYGqxpWn+TFhYWRmkDttMaBvZTj4hpmrquq6q6tLSESrEFe3RO3YqLpIcIwaxITz6fV04DvXR0FEWRJCku92JJkmRZ9jXp3r17YzXJNE1fCYIglMvl6M2TZRly8+jRo/77EBqUGVw1SQ8RghmSnknUout6LNIDT+VGoxG9KB8xSs8k8pOJonjq1JikhwgBSc9IMMYkSZpx6dE0LXo5PkRRpFEPMQlIekbCcRxRFCchPXFJxoSkB/Pc4HNs2xZFMRaLFXFxSEx6dnZ2vG97wzAePXoUey2MsY2NjViKunr16t/93d/FUpQXXdclSYpezoSGHoZhjLIWKYqiruvxVk2cbxKTHl3XvdJzeHg4id1jYpSecrk8iVHPjEsPRjSnnkbSQ4xLYtKjqupMSQ9jTNM027Ydxxl4wixIT0DA7eQMLiQ9xCRIMnJ9pqTHPUkzKIqiaZr9AqTr+iQ2NR5dehhjoihCH/v/e16lh6zX5xWSnl/j3VFLFMX9/X3vfyVJKhaLsbdwrFFPLpdD22BU9urj7EuPZVn8F3/x4oX3X47jtNvt/ktM05RlediX4lnN4PQYkOSMH7dtW9d1x3Hq9XosC4tEaEh6XkHTNK8XMt9P3Z0N6alUKt7miaL45MkT/Gv2pQdmI5y2uLhoGAZ8kQzDUBSF31vGWLlcxrPBGBM8W0i3223viE9VVVEUJUlCCzVNw59XrlzxVb2zs4NCdF0XRZExls/nT125IybK+Zee3/iN30i9ym/91m8NzLaXyWRSqVR/GEQqlcpms6lUakITrlQqNSwBoI/FxcX+5qXTaWQXnHHpcV23VqvBXibLcqPRkGV5YWGhWCzmcjkuPRh7Pnny5ODgYHFxsdFoNBqNhw8fZjKZf/zHf+x0Ory0p0+fqqr6z//8z2ihqqoYIn3ta1/j5/R6vUaj8dd//deCIDx79iyfz8/NzX388ccLCwulUml3d3d3d3fM++Gn2+1GLOFicv6lJ5vNwnjMuyV/r/bjG/XwwQXelvV6PfYWouRh7fFx69atYc1Dy2OXHhiYTj3tVOnBveWzp4WFBcSUIDhG13Wf9Gials/nBUHQdd0wDFVVBUFYWFjweg/pui7L8ptvvikIgmVZOEcQhGvXrvFzMMt7+vQpkvbzO/ad73yHrEjJcv6lZ6wJFyKh+GAHEy48o5IkxRWJ6iXKhEsQhNXVVVh8Ztyvx7IsiCO0I5PJYLokyzK2jfZKDxwUHz9+LEkS7j9UxjRN74TLcRzLsnq9HtSkXC5DX54+feqz4/R6PR6VBlP92tqaJElk7kkQkp5f4zUzy7L8gx/8wPvfCQVSjCU9hUKBv7c1TfMOAWZcetxXW7i0tGQYhmEYpmkahqFpGpeecrkMK0yj0ZAkSVVVWIW8phl4QmiaZhjG+vo6fi+MoWRZzuVykiRxkWKM3bx5E1Z5frcZY3jNhLkpRByQ9Pz6TIRK+ro0J3HpQQsVRRm49n+2pCeXy8EkjFGPd8LFQzeazWa5XEa4P0zR3iREfD0rl8vhycFwyTAMxhi/P7ZtG4bx9a9/HX9KksTbiXn3GPeCiBWSnl8T4E/ozob08PWsfs6Q9Ni2nc1mBUEwTV9qmNsAAA01SURBVBPL54Zh9EvP5uamJEmGYXBLls/WhnwguVyOr0JCfW7cuMHV2SvT2Jwa+7UhvRHeNOPdESImSHpGJXHpCeasSA+SKP3lX/6lIAibm5uKoly9epVLj+M46XT6+fPnrutiCXx7e7tarV66dKlYLL58+RJFMca++93vZrPZdDpdLBZTqdQvfvGLdDq9vb1dLBaXl5c3NjY6nQ5jDAtkzWaz2WxCp/L5/Pz8/GeffZZIDkmCQ9IzKiQ9AYwuPVjYarVaXlsMlx5MrPglGKcIgiBJUv+AFKtazWZTFEWcCZv0wPVyWLV5S7gB+9SvRkwIkp5RIekJYES/HlhevAViiiQIwuHhIZIiQZIYY/v7+5gQlctlmITX19e9ZjgsC8BsBOmRZblcLl+9etVX77179+BJyI9Uq1WI2iTyqxGjQNIzKiQ9AYwew+U4ji8GzXEcWZa73a7jOLDyQGsePXrkHelYlrW6uuq91rZtWHkwflEUBV/fK0+O42iadvfu3f6WwNJEW+AmxQxJz7DASC/2mFiWFaP09Hszw2gagOu66FTuSa/zfUdVVS+U9EyZgMAuIllmSHq4Q00A/b68p7K1tRVLgxVFyWQyvvZcunQpuHZZljOZDHznJEnq/44wZERvHqQn+O6FgEdIBTOz0kPMLLMiPV988UW3263X681mszaEb37zm6lUamlpqTsOfFkkNFgoeeONN/7kT/7E16Qf/vCHqOUHP/jBwsLCo0ePAlrSarU2NzfX19ffe++9Wq3WbDZbrVa3241lkaXb7aJJ//qv/+qr9/j4uP9m7uzsrK+vD7vVXlqt1qm1k/QQ4zIr0hMM9z3FKsZEG+YDqyGoOiCGC44nkiQFD+8xNslkMonPAnRdF07iv6KXRtJDjMusSw9c5r1TmKl12na77ZviBZiZeexicHQ7skAATdMSFCBv1IggCBHDr0l6iHGZXelB0KDPdDK15xsh777aAzJR8XMKhUJwyVykhJN8QEkJEFa1QTqdjhJVQNJDjMuMSo/jONeuXeu32gYEOsQFvOz7q/Y5hnixbdvbh4OlpF9PBUH4/PPPJ/NtgujPEOLLfDg6JD3EuMyo9HiHBtOUHtu2h62jBQT7+PpwcCd0HKc/IVkmk5n+PlbeFDa+bzruQIykhxiXGZUexli3233nnXe8XeJ3f/d3J90qxlir1To6Ojo6OuLWZRAgDf1S8vjx44BafMkGs9nsvXv3ms3mBL5QEIwxX0vy+XyhUDg4OBi3MSQ9xLjMqPS4rttut9EfEMosjGBGiZFyuSwIAh98BbvbDxw7BLhH8rQ7IBa/nnD4Bj6hw7hJeohxmV3pOTg4EE4mLxCCSSQJHAgSmC8sLLgnU7+AFOK892KmtrS0dKqgIIBIlmVun55EiMYo8PjMnZ2dUxUzAJIeYlxmVHps206lUnysgR4ytSkJ5AZKB9UL6JAwG6uqCuP03t6e++rGL/00Gg2uqljkjivaY1wQsSkIQqvVwrcWRTGE+pD0EOMyi9LjOI4oivPz896DmqZNJ/U/bMaiKKI6xCUG9EZvil9FUSA9wXQ6He96GTRr+mZmUC6XuSck3wRxXPUh6SHGZRalB53/4OBgyk1yT1QAaclDXI5kVKOc6VuqW1hYCDfciA5jjH9Z27b5BHOsRa6kGk+cXRKTnnQ6PT8/v9UHt5W89tpr/f/N5XLYVyCXy93r46233rpz5869e/d2dnb6rz2VjY0NrFXxhhUKhWq1uru7e3BwUK1WP/jgg+qrfPDBB94SMpnMb/7mb25tbd27d2+sqn/nd37HW6+X6pjs7e2F+O57e3uFQqFQKOzu7uL+f/WrX8XXP5VKpZJKpabgckWcJxKTHuTu9gIzLYbuzhBOLROhmMMuDwCrTrIsh7iW4zUMjXstUgWj249+1Z07d9RXefLkybhV94OBp6qq2D+r/wTsG+El8ag04mwxK5uBdLtd9LqktqNFsrvos4ZTvZkD4HFVs7BTAoafSVmgiHPPrEgPxvlJ6Q76fCwx8RH9ktGSWTCd1Ot16GCyzSDOKzPxYGEpPSndcV0X/jixFJXNZiOu9cDQqyhK4pt5Y92dshcTkyB56XEch/vvTR+snQunJbsYnY2NjejLzPE2KTT4aQRBwL56yTaGOGckLz14ySfVzeCLLIpiXPsxbWxsRA+M8LpTJwsM51CfpNtCnCuSlJ5Go7G0tJRKpaYZnMVhjG1vbwuCkM1mY5zafPvb347FPtLtdldWVq5du9bpdKKXFoVGo4HN9vb29mjsQ8RFYtKDrQ7iMu6OC59nxe6DW6lU4lqigqE3tH9jjPB4i+9+97vJtoQ4NyQjPXwpPalV5BFTKYegVqvFOD3hyYNiKS0KjuNIkpTNZmngQ8RCMs80/PdCp2iICE/HMYkF7FarFa9lZHaWmWAXS2SUSpw/EpAepBNNSndc1y0Wi5Ozm3Jdi6tAvsw0C+qTy+VIfYhYmLb0MMZUVU1w7YYxlslkJhpmDaWIsUCeK7rdbsdYbAiQ7gOZhpJtCXHWmZ70MMY+/PDDhYWFVCr105/+dGr1emm1WktLS3/8x38c11L6QDBF+vTTT2MsE8tMV65cSdbP8OXLl8ViMZ1OZzIZMjkTUZiS9DDGuAdNUiECPEJq0m9sfNPYLeiMsXQ6PQnTeIiWzE6sGXFGmZL08ClDUuvEzklk/BR6C6RnEsYsWKkSNJNxuKvhKNsiE0Q/05CeTqeDxzSpRHbcLWU6nZaHgMZecq/XwxeZBUMv1CcRd1DiHDAN6dna2kr2XY1hyDSNoxOSHteThX4W1EdV1ShJQoiLzDSkZ35+PsH9XhJxX0Su+AmprWmaGPvMQjpkLLc7lKKQGJPJSk+73c5ms/Pz80lt9uK6rq7rqVRqY2NjoqtaPhzHESa5wVav11tbWxME4eOPP55QFSPyq1/9KpPJpNPp7e3tSQ9/+C8Y8FPSEOysEFV6bNu2LIsxhg/ef3HT8uSi0rvdbvD7Fu6L0xnveB96rAFNejVK07R0Oj0LEV4w4cc+yiuXy97fLp/Puye/qW+d1LIsy7I0TZMk6cWLF5aHcrmceAgu0U8k6bl16xbc5/gewbIH4QRJkuThRFlr393dFUUxoHDevIBzonSYRqOBQiRJ8tUyyncHof2qHcdJp9OyLJse9vf3T62xn9BDQsaYaZp813ld180+bt26dWoDBvor+d4ckB7oi1fTVVXFEyjLsq7rlUoFO9YCURSntnkkMTqRpOfatWuappXLZcuykC38yZMnmqZpmmYYBk8hvru7qw3i1I09T6VQKAzMIW+apm3bAyv1EdHz+PDwED1/xOr6iTgv29vb4xoXrgGI4A/tqXh0dCScxsrKSkADINMD93fE0qQsy9ixJ5/PI029KIr4AAFijCEVAQaAlUrFK0yKopD0zCCRpGd1dTXK5TCIRFmpKRQKER0UsUIc+vLDw8OIsWCapkWRnlqthp4ZemaHkUVo6alWq5IkOY7DAgkuRBTFYVvL4vJyuazr+sLCgq7rsmfnEv7wYNKHIyQ9Z4LkpSdKVOQ5kB5d16NIT71el2U5SgOiS0/0pNrDpIcxhlEt/sSEC+k7+DndblcURYzdwPz8vKIo4gkTtTYSoUlSenq93sLCQhQrKUnPOZaeL774otlsCoLw4MGDZrNZr9eXl5fr9fqHH36YTqePjo5KpRK/6s6dO4IgLC0tHR0dfetb32o2m41Go16vN5vNBw8e/OxnP4vYQiJ2kpQe13VVVSXpIekJGPVgSm7btmmaKysrpmlik3gYsPHr85gySZJEUcR3iXhjiUmTsPTIskzSQ9JzqvTgzzfffNM9sT17T4MYCYJgWZZt2zD06LqOhtm2nfi2QkQ/ydt6EpeeKD2HpGdq0lMulyuViuu6hmF47xji2vAt8CxZlsUzf8uyLIpigh6txDBIespaBL8ekp7JSU+324X7haZp5XJZURQ4HyGOhJ9Wq9VM0+x/luA3AGeLiM0jJgFJD0nPTEhPv8Px4eGhoih87xDuxeNzR8DB/meJT7iI2YSkh6RnJqTns88+8x381a9+xT+3Wq1KpXJ4eJj3sLGxUa1WIT29Xi+fz//iF79ot9vNZrPZbB4eHh4eHjYajaOjo5/85CcRW0jEDkkPSc9MSA+FWV00IklPNptVh6Bpmn0aiC+NKD3eaB1VVU+t1EfEYfnh4aEkSeVyedx6OYg/Ct2AfunpdrtjNQBrfFGk51Sn0BcvXgS3IcCbmTivRJKeN998UxkfSZKQwQe+GFGk54MPPhixUh5HyuvlRMl6g47X/wV99QYTxZ+7Xq/Dl5cjewJ3RyeK9GAhKeDmp1KpUxswzZQmxCyQwD5cjLFut4s8G/aJF8akcRzHtm2EGvleuVGKHdh470HUG0yUO9Dr9WzbNk0TLi34jmONeiLehF6vp2maYRjDxr+qqn7yySeTawBxRkl+R12CIC4gJD0EQSQASQ9BEAlA0kMQRAKQ9BAEkQAkPQRBJABJD0EQCfD/TSKmpFZ/048AAAAASUVORK5CYII=" alt="" />
主调度器和周期性调度器合称为"通用调度器(generic scheduler)"或"核心调度器(core scheduler)",本质上,通用调度器是一个分配器,与其他两个组件交互(调度器类、CPU)
. 调度类用于判断接下来运行哪个进程,内核支持不同的调度策略(完全公平调度、实时调度、无事可做时调度空闲进程),调度类这种设计架构使得能够以模块化方法实现这些策略,即一个调度器类的代码不需要和其他类的代码交互
在调度器被调用时,它会查询调度器类,得知接下来运行哪个进程
每个进程都有且只属于一个调度器类,各个调度器类负责管理所属的进程,通用调度器自身完全不涉及进程管理,其工作完全委托给调度器类 . 在选中将要运行的进程之后,必须执行底层"任务切换",这需要与CPU的密切交互
1. task_struct的成员
各进程的task_struct有几个成员与调度有关
struct task_struct
{
..
int prio, static_prio, normal_prio;
unsigned int rt_priority;
const struct sched_class *sched_class;
struct sched_entity se;
unsigned int policy;
cpumask_t cpus_allowed;
..
}
关于task_struct中和调度器相关数据结构的知识,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/3865490.html
//搜索:0x1: struct task_struct
2. 调度器类
调度器类(task_struct->sched_class)提供了"通用调度器"和各个"调度方法"之间的关联,全局调度器请求的各个操作都可以通过这个指针实现,这使得无须了解不同调度器类的内部工作原理,即可创建通用调度器
\linux-2.6.32.63\include\linux\sched.h
struct sched_class
{
/*
对各个调度器类,都必须提供struct sched_class的一个实例
调度类之间的层次结构是平坦的
1. 实时进程最重要
2. 完全公平进程次之
3. 空闲进程只有在CPU无事可做时才处于活动状态 next成员将不同调度类的sched_class实例,按上述顺序连接起来,这个层次结构在编译时就已经建立,不能在内核运行时修改
*/
const struct sched_class *next; //enqueue_task向就绪队列(TASK_RUNNING(ready))添加一个新进程,在进程从睡眠状态变为可运行状态时,即发生该操作
void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup, bool head); //dequeue_task将一个进程从就绪队列中去除,在进程从可运行状态切换到不可运行状态时,就会发生该操作。内核有可能因为其他理由将进程从就绪队列(红黑树)去除,例如进程的优先级可能需要改变
void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep); //在进程想要自愿放弃对处理器的控制权时,可使用sched_yield系统调用,这导致内核调用yield_task
void (*yield_task) (struct rq *rq); //在必要的情况下,会调用check_preempt_curr,用一个新唤醒的进程来抢占当前进程,例如在用wake_up_new_task唤醒新进程时,会调用该函数
void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags); //pick_next_task用于选择下一个将要运行的进程
struct task_struct * (*pick_next_task) (struct rq *rq); //put_prev_task在用另一个进程代替当前运行的进程之前调用
void (*put_prev_task) (struct rq *rq, struct task_struct *p); #ifdef CONFIG_SMP
int (*select_task_rq)(struct rq *rq, struct task_struct *p, int sd_flag, int flags); unsigned long (*load_balance) (struct rq *this_rq, int this_cpu, struct rq *busiest, unsigned long max_load_move, struct sched_domain *sd, enum cpu_idle_type idle, int *all_pinned, int *this_best_prio); int (*move_one_task) (struct rq *this_rq, int this_cpu, struct rq *busiest, struct sched_domain *sd, enum cpu_idle_type idle);
void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
void (*post_schedule) (struct rq *this_rq);
void (*task_waking) (struct rq *this_rq, 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 //在进程的调度策略发生变化时,需要调用set_curr_task
void (*set_curr_task) (struct rq *rq); //task_tick在每次激活周期性调度器时,由周期性调度器使用
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, int running);
void (*switched_to) (struct rq *this_rq, struct task_struct *task, int running);
void (*prio_changed) (struct rq *this_rq, struct task_struct *task, int oldprio, int running); 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
};
用户层应用程序无法直接与调度类交互,它们只知道内核定义的常量SCHED_xyz,这些常量和可用的调度类之间提供适当的映射(即调度策略和调度类之间存在对应的映射),这是内核的工作
. SCHED_NORMAL、SCHED_BATCH、SCHED_IDLE: 映射到fair_sched_class
. SCHED_RR、SCHED_FIFO: 映射到re_sched_class
//fair_sched_class(公平调度器)、re_sched_class(实时调度器)都是strcut sched_class的实例,这是Linux中两个主要的调度器
3. 就绪队列
核心调度器用于管理活动进程(TASK_RUNNING)的主要数据结构称之为"就绪队列",各个CPU都有自身的就绪队列,各个活动进程有且只能出现在一个就绪队列中,在多个CPU上同时运行一个进程是不可能的。就绪队列是全局调度器(核心调度器)许多操作的起点
/*
This is the main, per-CPU runqueue data structure.
Locking rule: those places that want to lock multiple runqueues (such as the load balancing or the thread migration code), lock acquire operations must be ordered by ascending &runqueue.
*/
struct rq
{
/* runqueue lock: */
spinlock_t lock; /*
nr_running and cpu_load should be in the same cacheline because remote CPUs use both these fields when doing load calculation.
nr_running指定了队列上可运行进程的数量,不考虑其优先级或调度类
*/
unsigned long nr_running;
#define CPU_LOAD_IDX_MAX 5
//用于跟踪此前的负荷状态
unsigned long cpu_load[CPU_LOAD_IDX_MAX];
#ifdef CONFIG_NO_HZ
unsigned long last_tick_seen;
unsigned char in_nohz_recently;
#endif
/*
capture load from *all* tasks on this cpu:
load提供了就绪队列当前负荷的度量,队列的负荷本质上与队列上当前活动进程的数目成正比,其中的各个进程又有优先级作为权重,每个就绪队列的虚拟时钟的速度即基于该信息
*/
struct load_weight load;
unsigned long nr_load_updates;
u64 nr_switches; //cfs是嵌入的子就绪队列,用于完全公平调度器
struct cfs_rq cfs;
//rt是嵌入的子就绪队列,用于实时调度器
struct rt_rq rt; #ifdef CONFIG_FAIR_GROUP_SCHED
/* list of leaf cfs_rq on this cpu: */
struct list_head leaf_cfs_rq_list;
#endif
#ifdef CONFIG_RT_GROUP_SCHED
struct list_head leaf_rt_rq_list;
#endif /*
This is part of a global counter where only the total sum over all CPUs matters. A task can increase this counter on one CPU and if it got migrated afterwards it may decrease it on another CPU.
Always updated under the runqueue lock:
*/
unsigned long nr_uninterruptible; //curr指向当前运行的进程的task_struct实例
struct task_struct *curr;
//idle指向空闲进程的task_struct实例,该进程也称之为空闲进程,在其他可运行进程时执行
struct task_struct *idle;
unsigned long next_balance;
struct mm_struct *prev_mm; //clock用于实现就绪队列自身的时钟,每次调用周期性调度器时,都会更新clock的值
u64 clock;
u64 clock_task; atomic_t nr_iowait; #ifdef CONFIG_SMP
struct root_domain *rd;
struct sched_domain *sd; unsigned long cpu_power; unsigned char idle_at_tick;
/* For active balancing */
int post_schedule;
int active_balance;
int push_cpu;
/* cpu of this runqueue: */
int cpu;
int online; unsigned long avg_load_per_task; struct task_struct *migration_thread;
struct list_head migration_queue; u64 rt_avg;
u64 age_stamp;
u64 idle_stamp;
u64 avg_idle;
#endif #ifdef CONFIG_IRQ_TIME_ACCOUNTING
u64 prev_irq_time;
#endif /* calc_load related fields */
unsigned long calc_load_update;
long calc_load_active; #ifdef CONFIG_SCHED_HRTICK
#ifdef CONFIG_SMP
int hrtick_csd_pending;
struct call_single_data hrtick_csd;
#endif
struct hrtimer hrtick_timer;
#endif #ifdef CONFIG_SCHEDSTATS
/* latency stats */
struct sched_info rq_sched_info;
unsigned long long rq_cpu_time;
/* could above be rq->cfs_rq.exec_clock + rq->rt_rq.rt_runtime ? */ /* sys_sched_yield() stats */
unsigned int yld_count; /* schedule() stats */
unsigned int sched_switch;
unsigned int sched_count;
unsigned int sched_goidle; /* try_to_wake_up() stats */
unsigned int ttwu_count;
unsigned int ttwu_local; /* BKL stats */
unsigned int bkl_count;
#endif
};
系统的所有就绪队列都在runqueues数组中,该数组的每个元素分别对应于系统中的一个CPU,在单处理器系统中,由于只需要一个就绪队列,数组只有一个元素
\linux-2.6.32.63\include\linux\sched.c
static DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
内核也定义了一些便利的宏
#define for_each_domain(cpu, __sd) \
for (__sd = rcu_dereference(cpu_rq(cpu)->sd); __sd; __sd = __sd->parent) #define cpu_rq(cpu) (&per_cpu(runqueues, (cpu)))
#define this_rq() (&__get_cpu_var(runqueues))
#define task_rq(p) cpu_rq(task_cpu(p))
#define cpu_curr(cpu) (cpu_rq(cpu)->curr)
#define raw_rq() (&__raw_get_cpu_var(runqueues))
4. 调度实体
由于调度器可以操作比进程更一般性的实体,因此需要一个适当的数据结构来描述此类实体
/*
CFS stats for a schedulable entity (task, task-group etc) Current field usage histogram:
4 se->block_start
4 se->run_node
4 se->sleep_start
6 se->load.weight
*/
struct sched_entity
{
/*
for load-balancing
load指定了权重,决定了各个实体占队列总负荷的比例,计算负荷权重是调度器的一个重要工作,CFS所需的虚拟时钟的速度最终依赖于负荷
*/
struct load_weight load; //run_node是标准的树节点,使得实体可以在红黑树上排序
struct rb_node run_node;
struct list_head group_node; //on_rq表示该实体当前是否在就绪队列中接受调度
unsigned int on_rq; /*
在进程运行时,我们需要记录消耗的CPU时间,以用于完全公平调度器
1. exec_start: 当前时间
1. sum_exec_runtime: CPU消耗的时间,跟踪运行时间是由update_curr不断累积完成的,调度器中许多地方都会用到这个函数 新进程加入就绪队列时,或者周期性调度器中,每次调用时,会计算当前时间和exec_start之间的差值,exec_start则更新到当前时间,差值则被加到sum_exec_runtime
*/
u64 exec_start;
u64 sum_exec_runtime; //在进程执行期间虚拟时钟上流逝的时间数量由vruntime统计
u64 vruntime; /*
在进程被撤销CPU时,其当前sum_exec_runtime值被保存到prev_sum_exec_runtime,此后,在进程重新再次抢占时又需要这个数据(prev_sum_exec_runtime)
需要注意的是,在prev_sum_exec_runtime中保存sum_exec_runtime的值,sum_exec_runtime并不重置,而是继续增长
*/
u64 prev_sum_exec_runtime; u64 last_wakeup;
u64 avg_overlap; u64 nr_migrations; u64 start_runtime;
u64 avg_wakeup; u64 avg_running; //调度器统计
#ifdef CONFIG_SCHEDSTATS
u64 wait_start;
u64 wait_max;
u64 wait_count;
u64 wait_sum;
u64 iowait_count;
u64 iowait_sum; u64 sleep_start;
u64 sleep_max;
s64 sum_sleep_runtime; u64 block_start;
u64 block_max;
u64 exec_max;
u64 slice_max; u64 nr_migrations_cold;
u64 nr_failed_migrations_affine;
u64 nr_failed_migrations_running;
u64 nr_failed_migrations_hot;
u64 nr_forced_migrations; u64 nr_wakeups;
u64 nr_wakeups_sync;
u64 nr_wakeups_migrate;
u64 nr_wakeups_local;
u64 nr_wakeups_remote;
u64 nr_wakeups_affine;
u64 nr_wakeups_affine_attempts;
u64 nr_wakeups_passive;
u64 nr_wakeups_idle;
#endif //组调度
#ifdef CONFIG_FAIR_GROUP_SCHED
struct sched_entity *parent;
/* rq on which this entity is (to be) queued: */
struct cfs_rq *cfs_rq;
/* rq "owned" by this entity/group: */
struct cfs_rq *my_q;
#endif
}; struct sched_rt_entity {
struct list_head run_list;
unsigned long timeout;
unsigned int time_slice;
int nr_cpus_allowed; struct sched_rt_entity *back;
#ifdef CONFIG_RT_GROUP_SCHED
struct sched_rt_entity *parent;
/* rq on which this entity is (to be) queued: */
struct rt_rq *rt_rq;
/* rq "owned" by this entity/group: */
struct rt_rq *my_q;
#endif
};
由于每个task_struct都嵌入了sched_entity的一个实例,所以进程是可调度实体
0x6: 处理优先级
从用户层的角度来看,优先级就是一些数字,但是从内核的角度来看,内核处理优先级非常复杂
1. 优先级的内核表示
在用户空间可以通过nice命令设置进程的静态优先级,这会最终调用内核的系统调用nice()
内核使用一个简单的数值范围(0 ~ 139),用来表示内部优先级,值越低,优先级越高,0~99专供实时进程使用,nice(-20 ~ 19)映射到范围100~139,这也是"实时进程一定高于普通进程"的内部原理
aaarticlea/png;base64,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" alt="" />
. sched.h
#define MAX_USER_RT_PRIO 100
#define MAX_RT_PRIO MAX_USER_RT_PRIO #define MAX_PRIO (MAX_RT_PRIO + 40)
#define DEFAULT_PRIO (MAX_RT_PRIO + 20) . sched.c
#define NICE_TO_PRIO(nice) (MAX_RT_PRIO + (nice) + 20)
#define PRIO_TO_NICE(prio) ((prio) - MAX_RT_PRIO - 20)
#define TASK_NICE(p) PRIO_TO_NICE((p)->static_prio)
2. 计算优先级
我们知道,优先级的计算涉及到动态优先级(task_struct->prio)、普通优先级(task_struct->normal_prio)、静态优先级(task_struct->static_prio),它们互相彼此关联
. static_prio是计算的起点
\linux-2.6.32.63\kernel\sched.c . 计算普通优先级
普通优先级需要根据普通进程和实时进程进行不同的计算
/*
__normal_prio - return the priority that is based on the static prio
*/
static inline int __normal_prio(struct task_struct *p)
{
return p->static_prio;
} /*
Calculate the expected normal priority: i.e. priority without taking RT-inheritance into account. Might be boosted by interactivity modifiers.
Changes upon fork, setprio syscalls, and whenever the interactivity estimator recalculates.
*/
static inline int normal_prio(struct task_struct *p)
{
int prio; if (task_has_rt_policy(p))
//实时进程计算普通优先级,由于更高的rt_priority值表示更高的实时优先级(对用户态来说),内核内部优先级表示则刚好相反,越低的值表示的优先级越高
prio = MAX_RT_PRIO- - p->rt_priority;
else
//对普通进程来说,直接返回静态优先级
prio = __normal_prio(p);
return prio;
} /*
Calculate the current priority, i.e. the priority taken into account by the scheduler. This value might be boosted by RT tasks, or might be boosted by interactivity modifiers.
Will be RT if the task got RT-boosted. If not then it returns p->normal_prio.
*/
static int effective_prio(struct task_struct *p)
{
//计算普通优先级
p->normal_prio = normal_prio(p);
//If we are RT tasks or we were boosted to RT priority, keep the priority unchanged. Otherwise, update priority to the normal priority
/*
通过优先级数值,检测当前进程是否为实时进程,即是否小于MAX_RT_PRIO
之所以要通过数值来进行判断,这是因为对于临时提高至实时优先级的非实时进程来说,这是有必要的,这种情况可能发生在使用实时互斥量(RT-Mutex)
*/
if (!rt_prio(p->prio))
return p->normal_prio;
return p->prio;
}
/*
梳理一下针对不同类型进程上述计算的结果
1. 非实时进程
1) static_prio: static_prio = static_prio
2) normal_prio: normal_prio = static_prio
3) prio: prio = static_prio
2. 优先级提高的非实时进程
1) static_prio: static_prio = static_prio
2) normal_prio: normal_prio = static_prio
3) prio: prio = prio不变
3. 实时进程
1) static_prio: static_prio = static_prio
2) normal_prio: normal_prio = MAX_RT_PRIO-1 - p->rt_priority;
3) prio: prio = prio不变
*/
在新建进程用wake_up_new_task唤醒时,或者使用nice系统调用改变静态优先级时,则使用上述算法设置p->prio,需要注意的是,在进程分支出子进程时
. 子进程的静态优先级(static_prio)继承自父进程
. 子进程的动态优先级(prio)则设置为父进程的普通优先级(normal_prio)
这确保了实时互斥量引起的优先级提高(prio提高)不会传递到子进程
3. 计算负荷权重
进程的重要性不仅是由优先级指定的,而且还需要考虑保存在task_struct->se.load负荷权重。set_load_weight负责根据"进程类型"及其"静态优先级"计算负荷权重,即优先级是最根本的源头,由优先级及其类型决定负荷权重,然后最终由负荷权重+优先级决定重要性
\linux-2.6.32.63\kernel\sched.h
struct load_weight
{
unsigned long weight, inv_weight;
};
进程每降低一个nice值,则多获得10%的CPU时间(权重),每升高一个nice值,则放弃10%的CPU时间,为了执行这个策略,内核将优先级转换为权重值
/*
Nice levels are multiplicative, with a gentle 10% change for every nice level changed.
I.e. when a CPU-bound task goes from nice 0 to nice 1, it will get ~10% less CPU time than another CPU-bound task that remained on nice 0. The "10% effect" is relative and cumulative: from _any_ nice level, if you go up 1 level, it's -10% CPU usage, if you go down 1 level it's +10% CPU usage. (to achieve that we use a multiplier of 1.25.
If a task goes up by ~10% and another task goes down by ~10% then the relative distance between them is ~25%.)
*/
static const int prio_to_weight[] = {
/* -20 */ , , , , ,
/* -15 */ , , , , ,
/* -10 */ , , , , ,
/* -5 */ , , , , ,
/* 0 */ , , , , ,
/* 5 */ , , , , ,
/* 10 */ , , , , ,
/* 15 */ , , , , ,
};
对内核使用的范围[0, 39]中的每个nice级别(-19~20),该数组中都有一个对应项,各数组之间的乘数因子是1.25,关于使用该因子的原因,可以考虑下列例子
进程A和进程B在nice级别0运行,因此两个进程的CPU权重相同,即都是50%,nice级别为0的进程,其权重值通过查表可知为1024,每个进程的份额是1024 / (1024 + 1024) = 0.5
如果进程B的优先级加1,那么其CPU权重应该减少10%(准确地说是需要将每个nice之间的权重差值增幅为10%),即A进程得到CPU权重55%,B进程得到45%
假定"nice = 0"和"nice = 1"的乘数因子为1.25,1024 / 1.25 = 820,此时进程A得到的CPU权重为 1024 / (1024 + 820) = 0.55,而进程B得到的CPU权重为 820 / (1024 + 820) = 0.45,这样就产生了10%的差值
static void set_load_weight(struct task_struct *p)
{
//执行转换的代码也需要考虑实时进程,实时进程的权重是普通进程的两倍
if (task_has_rt_policy(p))
{
p->se.load.weight = ;
p->se.load.inv_weight = WMULT_CONST;
return;
} /*
SCHED_IDLE tasks get minimal weight:
SCHED_IDLE得到的权重最小
*/
if (p->policy == SCHED_IDLE)
{
p->se.load.weight = WEIGHT_IDLEPRIO;
p->se.load.inv_weight = WMULT_IDLEPRIO;
return;
} p->se.load.weight = prio_to_weight[p->static_prio - MAX_RT_PRIO];
p->se.load.inv_weight = prio_to_wmult[p->static_prio - MAX_RT_PRIO];
}
不仅进程,而且就绪队列也关联到一个负荷权重,每次进程被加到就绪队列时,内核会调用inc_nr_running,这不仅确保就绪队列能够跟踪记录有多少进程在运行,而且还将进程的权重添加到就绪队列的权重中
static inline void inc_cpu_load(struct rq *rq, unsigned long load)
{
update_load_add(&rq->load, load);
} static inline void update_load_add(struct load_weight *lw, unsigned long inc)
{
lw->weight += inc;
lw->inv_weight = ;
}
在进程从就绪队列移除时,会调用对应的函数(dec_nr_running、dec_cpu_load、update_load_sub)
static void dec_nr_running(struct rq *rq)
{
rq->nr_running--;
} static inline void dec_cpu_load(struct rq *rq, unsigned long load)
{
update_load_sub(&rq->load, load);
} static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
{
lw->weight -= dec;
lw->inv_weight = ;
}
0x7: 核心调度器
我们知道,调度器的实现基于两个函数: 周期性调度函数、主调度函数。它们根据现有的"进程优先级"分配"CPU时间(负荷权重)",这也是Linux的调度被称为"优先调度"的原因,主调度器和周期性调度器合称为"通用调度器(generic scheduler)"或"核心调度器(core scheduler)",本质上,通用调度器是一个分配器,与其他两个组件交互(调度器类、CPU)
1. 周期性调度器
周期性调度器在scheduler_tick中实现,如果系统正在活动中,内核会按照频率HZ自动调用该函数,如果没有进程在等待调度,那么在计算计算机电力供应不足的情况下,也可以关闭该调度器以减少电能消耗,该函数有以下两个主要任务
. 管理内核中与整个系统和各个进程的调度相关的统计量,其间执行的只要操作是对各种计数器加一
. 激活负责当前进程的调度类的周期性调度方法(Linux下的调度算法采用调度类的模块封装思想)
\linux-2.6.32.63\kernel\sched.c
/*
This function gets called by the timer code, with HZ frequency.
We call it with interrupts disabled.
It also gets called by the fork code, when changing the parent's timeslices.
*/
void scheduler_tick(void)
{
int cpu = smp_processor_id();
struct rq *rq = cpu_rq(cpu);
struct task_struct *curr = rq->curr;
sched_clock_tick(); spin_lock(&rq->lock);
//update_rq_clock处理就绪队列时钟的更新,本质上就是增加struct rq当前实例的时钟时间戳,该函数必须处理硬件时钟的一些奇异之处
update_rq_clock(rq);
/*
update_cpu_load负责更新就绪队列的cpu_load[]数组(struct rq->cpu_load[]),本质上相当于将数组中先前存储的CPU负荷值向后移动一个位置,将当前就绪队列的负荷值记入数组的第一个为自豪
除此之外,该函数还引入了一些取平均值的技巧,以确保符合数组的内容不会呈现出太多的不连续跳变
*/
update_cpu_load(rq); /*
由于调度器的模块化结构,主题工程实际上比较简单,因为主要的工作可以完全委托给特定调度器类的方法
task_tick的实现方式取决于底层的调度器类
*/
curr->sched_class->task_tick(rq, curr, );
spin_unlock(&rq->lock); perf_event_task_tick(curr, cpu); #ifdef CONFIG_SMP
rq->idle_at_tick = idle_cpu(cpu);
trigger_load_balance(rq, cpu);
#endif
}
2. 主调度器
在内核中的很多地方,如果要将CPU分配给与当前活动进程不同的另一个进程,都会直接调用主调度函数(schedule)。在从系统调用返回后,内核也会检查当前进程是否设置了重调度标志(TIF_NEED_RESCHED),如果是这样,则内核会调用schedule,该函数假定当前活动进程一定会被另一个进程取代
/*
schedule() is the main scheduler function.
*/
asmlinkage 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_sched_qs(cpu);
//在prev中保存一个指向(仍然)活动进程的task_struct的指针
prev = rq->curr;
switch_count = &prev->nivcsw; release_kernel_lock(prev);
need_resched_nonpreemptible: schedule_debug(prev); if (sched_feat(HRTICK))
hrtick_clear(rq); spin_lock_irq(&rq->lock);
//类似于周期性调度器,内核也利用主调度的这个时机来更新就绪队列的时钟
update_rq_clock(rq);
//清除当前运行进程task_struct中的重调度标志(TIF_NEED_RESCHED)
clear_tsk_need_resched(prev); //因为调度器的模块化结构,主调度的大部分工作可以委托给调度类
if (prev->state && !(preempt_count() & PREEMPT_ACTIVE))
{
/*
如果当前进程原来处于可中断睡眠状态但现在接收到信号,那么它必须再次提升为运行进程
进程状态转换的原则是: 只有非运行到运行状态的双向转换,所以从可中断睡眠状态到被调度之前,需要先转换到运行态(TASK_RUNNING)
*/
if (unlikely(signal_pending_state(prev->state, prev)))
prev->state = TASK_RUNNING;
//否则,用相应调度器类的方法使进程停止活动(deactive_task实质上最终调用了sched_class->dequeue_task)
else
deactivate_task(rq, prev, );
switch_count = &prev->nvcsw;
} pre_schedule(rq, prev); if (unlikely(!rq->nr_running))
idle_balance(cpu, rq); /*
put_prev_task首先通知调度器类当前运行的进程将要被另一个进程代替
需要注意的是,这不等价于把进程从就绪队列中移除,而是提供一个时机,执行一些统计工作并更新统计量
*/
put_prev_task(rq, prev);
//调度类还必须选择下一个应该执行的进程,该工作由,该工作由pick_next_task负责
next = pick_next_task(rq);
/*
要注意的是,不一定必然选择一个新进程,也可能其他进程都在睡眠,当前只有一个进程能够运行,这样它自然就被留在CPU上,但如果已经选择了一个新进程,那么必须准备并执行硬件级的进程切换
*/
if (likely(prev != next))
{
sched_info_switch(prev, next);
perf_event_task_sched_out(prev, next, cpu); rq->nr_switches++;
rq->curr = next;
++*switch_count; /*
unlocks the rq
context_switch是一个接口,供访问特定于体系结构的方法,它负责执行底层上下文切换
*/
context_switch(rq, prev, next);
/*
the context switch might have flipped the stack from under us, hence refresh the local variables.
*/
cpu = smp_processor_id();
rq = cpu_rq(cpu);
} else
spin_unlock_irq(&rq->lock); post_schedule(rq); if (unlikely(reacquire_kernel_lock(current) < ))
goto need_resched_nonpreemptible; preempt_enable_no_resched();
//检测当前进程的重调度未是否设置,并跳转到need_resched标号代码位置,重新开始搜索一个新的进程
if (need_resched())
goto need_resched;
}
EXPORT_SYMBOL(schedule);
3. 与fork的交互
每当使用fork系统调用或其变体之一(本质还是调用了内核的do_fork)建立新进程时,调度器有机会用sched_fork函数挂钩到该进程(在copy_process中被调用)
/*
* fork()/clone()-time setup:
*/
void sched_fork(struct task_struct *p, int clone_flags)
{
int cpu = get_cpu(); /*
1. 初始化新进程与调度相关的字段
2. 建立数据结构
*/
__sched_fork(p); /*
We mark the process as running here. This guarantees that nobody will actually run it, and a signal or other external event cannot wake it up and insert it on the runqueue either.
*/
p->state = TASK_RUNNING; /*
Revert to default priority/policy on fork if requested.
3. 确定进程优先级
*/
if (unlikely(p->sched_reset_on_fork))
{
if (p->policy == SCHED_FIFO || p->policy == SCHED_RR)
{
p->policy = SCHED_NORMAL;
p->normal_prio = p->static_prio;
} if (PRIO_TO_NICE(p->static_prio) < )
{
p->static_prio = NICE_TO_PRIO();
p->normal_prio = p->static_prio;
set_load_weight(p);
} /*
* We don't need the reset flag anymore after the fork. It has
* fulfilled its duty:
*/
p->sched_reset_on_fork = ;
} /*
Make sure we do not leak PI boosting priority to the child.
通过使用父进程的普通优先级(normal_prio)作为子进程的动态优先级(prio),内核确保没有将提供的优先级泄露到子进程(即只取父进程的normal_prio)
因为在使用实时互斥量时进程的动态优先级可以临时修改,该效应不能转移到子进程
*/
p->prio = current->normal_prio; //如果优先级不在实时范围中,则进程总是从完全公平调度类开始执行
if (!rt_prio(p->prio))
p->sched_class = &fair_sched_class; if (p->sched_class->task_fork)
p->sched_class->task_fork(p); set_task_cpu(p, cpu); #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
if (likely(sched_info_on()))
memset(&p->sched_info, , sizeof(p->sched_info));
#endif
#if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
p->oncpu = ;
#endif
#ifdef CONFIG_PREEMPT
/* Want to start with kernel preemption disabled. */
task_thread_info(p)->preempt_count = ;
#endif
plist_node_init(&p->pushable_tasks, MAX_PRIO); put_cpu();
}
在do_fork中调用的wake_up_new_task唤醒新进程时,则是调度器与进程创建逻辑交互的第二个时机,内核会调用调度类的task_new函数,这将导致新进程被加入到相应类的就绪队列中
4. 上下文切换
内核选择新进程之后,必须处理与多任务相关的技术细节,这些字节总称为上下文切换(context switching),辅助函数context_switch(schedule()->context_switch())是一个分配器,它会调用所需的特定于体系结构的方法
/*
context_switch - switch to the new MM and the new thread's register state.
*/
static inline void context_switch(struct rq *rq, struct task_struct *prev, struct task_struct *next)
{
struct mm_struct *mm, *oldmm; //在进程切换之前,prepare_task_switch会调用每个体系结构都必须定义的prepare_arch_switch挂钩,这使得内核执行特定于体系结构的代码,为切换做事先准备
prepare_task_switch(rq, prev, next);
trace_sched_switch(rq, prev, next);
mm = next->mm;
oldmm = prev->active_mm;
/*
For paravirt, this is coupled with an exit in switch_to to combine the page table reload and the switch backend into one hypercall.
*/
arch_start_context_switch(prev); //上下文切换本身通过特定于处理器的函数完成(switch_mm、switch_to)
if (unlikely(!mm))
{
next->active_mm = oldmm;
atomic_inc(&oldmm->mm_count);
//enter_lazy_tlb通知底层体系结构不需要切换虚拟地址空间的用户空间部分,这种加速上下文切换的技术称之为"惰性TLB"
enter_lazy_tlb(oldmm, next);
}
else
/*
switch_mm更换通过task_struct->mm描述的内存管理上下文,该工作的细节取决于处理器,主要包括
1. 加载页表
2. 刷出地址转换后备缓冲器(部分或全部)
3. 向内存管理单元(MMU)提供新的信息
*/
switch_mm(oldmm, mm, next); //内核线程没有自身的用户空间内存上下文,可能在某个随机进程地址空间的上部执行,其task_struct->mm为NULL,从当前进程"借来"的地址空间记录在active_mm中
if (unlikely(!prev->mm))
{
//如果前一进程的是内核线程(即prev->mm为NULL),则其active_mm指针必须被重置为NULL,以断开与借用的地址空间的联系
prev->active_mm = NULL;
rq->prev_mm = oldmm;
}
/*
* Since the runqueue lock will be released by the next
* task (which is an invalid locking op but in the case
* of the scheduler it's an obvious special-case), so we
* do an early lockdep release here:
*/
#ifndef __ARCH_WANT_UNLOCKED_CTXSW
spin_release(&rq->lock.dep_map, , _THIS_IP_);
#endif /*
Here we just switch the register state and the stack.
switch_to切换处理器寄存器内容(CPU registered)和内核栈(kernel stack),因为虚拟地址空间的用户部分在switch_mm中已经变更,其中也包括了用户态下的用户栈
switch_to的工作在不同的体系结构下可能差别很大,代码通常都使用汇编语言编写 由于用户空间进程的寄存器内容在进入核心态时保存在内核栈上,在上下文切换期间无需显式操作,而因为每个进程首先都是从核心态开始执行(在调度期间控制权传递到新进程)(从核心态返回)
在返回用户空间时,会使用内核栈上保存的值自动恢复寄存器数据
*/
switch_to(prev, next, prev); //switch_to之后的代码只有在当前进程下一次被选择运行时才会运行(有可能下一次还是选择当前进程,但是也是一次有效的调度选择) //barrier是一个编译器指令,确保switch_to、finish_task_switch语句的执行顺序不会因为任何可能的优化而改变
barrier();
/*
this_rq must be evaluated again because prev may have moved CPUs since it called schedule(), thus the 'rq' on its stack frame will be invalid.
this_rq必须重新计算,因为在调用schedule()之后prev可能已经移动到其他CPU,因此栈帧上的rq可能是无效的
*/
//finish_task_switch完成一些清理工作,使得能够正确地释放锁
finish_task_switch(this_rq(), prev);
}
finish_task_switch的复杂之处在于,调度过程可能选择了一个新进程,而清理则必须针对此前的活动进程(即被调度之前的那个进程),内核必须使得该进程(被调度后的新进程)能够与context_switch例程(调度前的旧进程)通信,这可以通过switch_to宏实现,每个体系结构都必须实现它,而且有一个异乎寻常的调用约定,即通过3个参数传递2个变量,这是因为上下文切换不仅涉及2个进程,而是3个进程
aaarticlea/png;base64,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" alt="" />
假定3个进程A、B、C在系统上运行,在某个时间点,内核决定从进程A切换到进程B,然后从进程B到进程C,再接下来从进程C切换回进程A,在每个switch_to调用之前,next和prev指针位于各进程的栈上,prev指向当前运行的进程,而next指向将要运行的下一个进程,为执行从prev到next的切换,switch_to的前两个参数足够了,对进行A来说,prev指向进程A而next指向进程B
在进程A被选中再次执行时,会出现一个问题,控制权返回至swtich_to之后的点,如果栈准确地恢复到切换之前的状态,那么prev和next仍然指向切换之前的值,即next = B、prev = A,在这种情况下,内核无法知道实际上在进程A之前运行的是进程C
因此,在新进程被选中时,底层的进程切换例程必须将此前执行的进程提供给context_switch,由于控制流会回到该函数的中间(即swtich_to之后),这无法用普通的函数返回值来做到,因此使用了3个参数的宏,但逻辑上的效果是相同的,仿佛switch_to是带有两个参数的函数,而且返回了一个指向此前运行进程的指针
switch_to宏实际执行的代码如下
prev = switch_to(prev, next);
//返回的prev值并不是用作参数的prev值,而是上一个执行的进程,内核实现该行为的的方式依赖于底层的体系结构,但内核显然可以通过考虑两个进程的核心态栈来重建所要的信息,对可以访问所有内存的内核而言,这两个栈显然是同时可用的
惰性FPU模式
由于上下文切换的速度对系统性能的影响很大,所以内核使用了一种技巧来减少所需的CPU时间
. 浮点寄存器(及其他内核未使用的扩充寄存器,例如IA-32平台上的SSE2寄存器)除非有应用程序实际使用,否则不会保存
. 除非有应用程序需要,否则这些寄存器也不会恢复
这称之为惰性FPU技术,由于使用了汇编语言代码,因此其实现依平台而有所不同,但基本原理是一样的
Relevant Link:
我们知道,Linux的调度器采用调度类的模块化方式架构,目前内核中有实现以下四种
. static const struct sched_class fair_sched_class: 完全公平调度类
. static const struct sched_class rt_sched_class: 实时调度类
. static const struct sched_class idle_sched_class: CPU空闲时调度类
. static const struct sched_class stop_sched_class: stop_sched_class
我们接下来着重学习完全公平调度类、和实时调度类
7. 完全公平调度类
核心调度器(由主调度器、周期性调度器组成)必须知道有关完全公平调度器的所有信息
\linux-2.6.32.63\kernel\sched_fair.c
//All the scheduling class methods:
static const struct sched_class fair_sched_class =
{
.next = &idle_sched_class,
.enqueue_task = enqueue_task_fair,
.dequeue_task = dequeue_task_fair,
.yield_task = yield_task_fair, .check_preempt_curr = check_preempt_wakeup, .pick_next_task = pick_next_task_fair,
.put_prev_task = put_prev_task_fair, #ifdef CONFIG_SMP
.select_task_rq = select_task_rq_fair, .load_balance = load_balance_fair,
.move_one_task = move_one_task_fair,
.rq_online = rq_online_fair,
.rq_offline = rq_offline_fair, .task_waking = task_waking_fair,
#endif .set_curr_task = set_curr_task_fair,
.task_tick = task_tick_fair,
.task_fork = task_fork_fair, .prio_changed = prio_changed_fair,
.switched_to = switched_to_fair, .get_rr_interval = get_rr_interval_fair, #ifdef CONFIG_FAIR_GROUP_SCHED
.task_move_group = task_move_group_fair,
#endif
};
//调度类中的函数由主调度器调用
我们接下来逐个学习这些函数在CFS(完全公平调度器)中的实现方式
0x1: 数据结构
我们知道,主调度器的每个就绪队列中都嵌入了一个cfs_rq结构的实例(同时也嵌入了一个rt_rq实例)
\linux-2.6.32.63\kernel\sched.c
/*
CFS-related fields in a runqueue
*/
struct cfs_rq
{
//load维护了所有队列上可运行进程的累积负荷值
struct load_weight load;
//nr_running计算了队列上可运行进程的数目
unsigned long nr_running; u64 exec_clock;
//min_vruntime跟踪记录队列上所有进程的最小虚拟运行时间,这个值是实现与就绪队列相关的虚拟时钟的基础
u64 min_vruntime; //tasks_timeline是一个基本成员,用于在按时间排序的红黑树中管理所有进程
struct rb_root tasks_timeline;
//rb_leftmost总是设置为指向树最左边的结点,即最需要被调度的进程
struct rb_node *rb_leftmost; struct list_head tasks;
struct list_head *balance_iterator; /*
'curr' points to currently running entity on this cfs_rq.
curr指向当前执行进程的可调度实体
It is set to NULL otherwise (i.e when none are currently running).
*/
struct sched_entity *curr, *next, *last; unsigned int nr_spread_over; #ifdef CONFIG_FAIR_GROUP_SCHED
struct rq *rq; /* cpu runqueue to which this cfs_rq is attached */ /*
* leaf cfs_rqs are those that hold tasks (lowest schedulable entity in
* a hierarchy). Non-leaf lrqs hold other higher schedulable entities
* (like users, containers etc.)
*
* leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This
* list is used during load balance.
*/
struct list_head leaf_cfs_rq_list;
struct task_group *tg; /* group that "owns" this runqueue */ #ifdef CONFIG_SMP
/*
* the part of load.weight contributed by tasks
*/
unsigned long task_weight; /*
* h_load = weight * f(tg)
*
* Where f(tg) is the recursive weight fraction assigned to
* this group.
*/
unsigned long h_load; /*
* this cpu's part of tg->shares
*/
unsigned long shares; /*
* load.weight at the time we set shares
*/
unsigned long rq_weight;
#endif
#endif
};
0x2: CFS操作
1. 虚拟时钟
我们知道,完全公平调度算法依赖于虚拟时钟,用以度量等待进程在完全公平系统中所能得到的CPU时间,但是struct cfs_rq中并不保存任何有关虚拟时钟的信息,这是因为所有的必要信息都可以根据现存的实际时钟与每个进程相关的负荷权重推算出来。所有与虚拟时钟有关的计算都在update_curr中执行,该函数在系统中的很多地方被调用
aaarticlea/png;base64,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" alt="" />
/*
Update the current task's runtime statistics. Skip current tasks that are not in our scheduling class.
对于运行在nice级别为0的进程来说,根据定义虚拟时间和物理时间是相等的
对于不同的优先级时,必须根据进程的负荷权重重新衡定时间
*/
static inline void __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr, unsigned long delta_exec)
{
unsigned long delta_exec_weighted; schedstat_set(curr->exec_max, max((u64)delta_exec, curr->exec_max)); curr->sum_exec_runtime += delta_exec;
schedstat_add(cfs_rq, exec_clock, delta_exec);
/*
忽略舍入和溢出检查,calc_delta_fair所做的计算就是下列公式
delta_exec_weighted = delta_exec * (NICE_0_LOAD) / curr->load.weight
Linux的逆向权重值在计算中体现了作用
1. 越重要的进程会有越高的优先级(越低的nice值),会得到更大的权重,因此最后计算得到的累加的虚拟运行时间会越小
2. 根据公式可知,nice 0的进程优先级为120,则虚拟时间和物理时间是相等的,即current->load.weight = NICE_0_LOAD的情况
*/
delta_exec_weighted = calc_delta_fair(delta_exec, curr); curr->vruntime += delta_exec_weighted;
//设置min_vruntime,必须保证该值是单调递增的
update_min_vruntime(cfs_rq);
} static void update_curr(struct cfs_rq *cfs_rq)
{
//确定就绪队列的当前执行进程
struct sched_entity *curr = cfs_rq->curr;
//获取主调度器就绪队列的实际时钟值,该值在每个调度周期都会更新
u64 now = rq_of(cfs_rq)->clock_task;
unsigned long delta_exec; if (unlikely(!curr))
return; /*
Get the amount of time the current task was running since the last time we changed load (this cannot overflow on 32 bits):
内核会计算当前和上一次更新负荷统计量时两次的时间差
*/
delta_exec = (unsigned long)(now - curr->exec_start);
if (!delta_exec)
return; //执行实际的虚拟时钟工作,__update_curr需要更新当前进程在CPU上执行花费的物理时间和虚拟时间
__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);
}
}
完全公平调度器的真正关键点是,红黑树的排序过程是根据下列键进行的
\linux-2.6.32.63\kernel\sched_fair.c
static inline s64 entity_key(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
return se->vruntime - cfs_rq->min_vruntime;
}
键值较小的节点,排序位置就更靠左,因此会被更快地调度。用这种方法,内核实现了下面两种动态制衡的对立机制
. 在进程运行时,其vruntime稳定地增加,它在红黑树中总是向右移动的,
因为越重要的进程vruntime增加越慢,因为越重要的进程会有越高的优先级(越低的nice值),会得到更大的权重,因此最后计算得到的累加的虚拟运行时间会越小。这样其被调度的机会要大于次要进程,这正好是我们所希望看到的 . 如果进程进入睡眠(例如交互式进程等待键盘输入),则其vruntime保持不变,因为每个队列的min_vruntime同时会增加,那么睡眠进程醒来后(等待事件已经发生),在红黑树中的位置会更靠左,因为其键值变得更小了
//上述两种效应是同时发生的,呈现一种动态制衡的效果
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAASIAAAB9CAIAAACJc/l3AAAZdUlEQVR4nO2dQWgb2R3G30FQBh1cBJ2igw1qBxcT1y2egA/qYtpxF9LEh3rS2AU3uXiaiiVetohxli1oF6vGo3YLdpqyYhy6KklYUbZDxNKUuRkLesjqNDTawy5sLsuIQi/KJZf3evjQY3Yk2fJYsmX5/U7SePTmjTyf3nv/93/fI0wgEAwYctYVEAhGHyEzgWDgCJkJBANHyEwgGDhCZgLBwBEyEwgGjpCZQDBwhMyGCN/3DcM461oI+o+Q2bBAKU2lUoSQhw8fnnVdBH1mSGXWaDR83z/bOjiO43neqV3ONE1CCCFElmVK6aldV3AKDKnMKpWKoihncmlJkmq1GmNMURRN007zuqSF67qndl3BKTCkMqvX66fZkgQhhFSrVcaYZVmn1qrwpgwUi8XTua7gdDgzmXmeZxiGYRjJZNJxHMuyZFnWNA19xVqt5jgOa0UFbNteWFhQVbWb9izLMgwDqnAcxzRNftAwDMdx+MFms8nPxF/j8Ti/rqqqhJDr16/j47Zto0DDMDRN0zTNsiy8NQyjXq+H7gXNYARwXU4mk4lWjmA4OTOZKYqCcciVK1fwbGmaho4TpbRSqciyzBhzHAd/nZ6eJoRYltWxNMuyCCF47hVFkSSJMaZpWiwWg7oMw8DBer1OCIGoULJhGLg6r9X8/DwLdBpN04zFYrIso3qSJOE1xOD7Po7Isry8vBzhq6CUBnuMhJBUKhWhHMHQcsYyg6Li8Tj6abZtY2RSLpeDMkPLdojMKKWKouzu7tZqNULIgwcPGGOapm1vb+OEbjJbX19nXx+G8U5jUGa/+c1veGUeP37MGGs0GgsLC7iKoijPnz+v1+s//vGPI3wVf/3rXwkh8Xg8FosRQhKJxDe+8Y3nz59HKEownJylzBBS4w0Xa8nM87xcLheUGVdFN5kxxizLymazGOTgiKZpfJDDZVapVNoLPFJm+Xw+VBnGGGQW7O/FYrEIX8Xi4qJpmpRSXdcJIbZtZzIZXdcjFCUYTs5SZniI22VGKY0gM9/3l5aWZFnmM7wdZea6bt9lJsuy53m+70ebhGg2m3jBZUYpFTH9UWJ0ZMZaHVH0MFkXme3s7PRdZvyza2trJ/lOuMxOUohgCBkpmS0uLvIeI+sis1wu11+ZoZuKg5OTkyf5ToTMRpUzk5mqqhh+uK7LZ6Idx5EkiVJaLBbxV8/z+EPMw+7duH//Pm/KcH6pVMJrHs2TJElVVXTJJEmCzHhl8HpiYiJ40DTNQqGAykiSxOuwtLTEGPN9X5ZljM0QUImMkNmoMqTT00EajUbwred5V69eTQc4Un6carX66tWrvtew2WxWq9Vqtfry5cuTlCNkNqqcA5ldHHRdFwmNoF6vj9JiBSGzISJyrHL02NnZGaVfHCEzwTCSzWYJISMzeShkJhhGpqamCCGKooxGgyZkJhg6KKU8sWY0etEDkRmllGc2CATHBU0Zz6IegWepnzKjlHqep+s6z5EXCI4LUhSC9BhytG0bgkR26JG9TSyqopQe0mDatn14RkSP9E1mvu/funWLfzV9qZzgAoLJwyC9/GQj/aBSqbBWkgNU1LElfPbsGRK+4UNxSEgTmg/mPETjpDLzfd+2bTRf/HvhyVMCwbHwfR+P0OTkJCFEVVU8V0cupUfK29zcnG3bkJBpmrZtz83N8V98z/NM01QUBQt5sTre8zxVVYNFYQUwykGWrKIoWFtsGIaiKBGakBPJzLZtnmcU+vmRD0VVVeuYrK+vH15m34lQSY5hGCevwMl/RM8dlmUpimLbdqlUgrp831dV9fB+I6VUlmXTNPf399E6SZLkOA7mIXlLhf6h7/vpdJp/tl1mOI2vkcdHPM9bWVkJFdg7J5KZaZqhZb+DI5FIGF8HiyCHE1mWeT0JIZIkQXgdT8attXeWLnLWFZdZLyejKbNt23VdtFdQHU9GDYGcb9AuM1AoFAghuq6jHF3XT7KkvQ9js0ajUalUlpeXx8bG+HNzcHBw8pIFF5beZea6bjweJ4Ts7+8/evRoYmLCbXH16tVcLofTKKXlctl13Uql8oMf/KDc4g9/+EMymXzw4AE/EycXCoWZmZl8i7t3755krrzPkUbLsnh/uo8lCy4aPcoMQUUEKnzfx6Iq3nXXdT0oMwzGbNuempri5yiKguEWH3H5vq8oyuTkpNbCtm3HcSYmJizLiuYpOBAxIC4yiJIFF4RSqdR7CghfB1ipVAzD8FqYphlsozhwLgO6roc6jVh7tb29jTGhYRiWZcmyvLGxEXmmSrQ5gmEksswIIWoLRVE6yuy1117jr9vHZrAq29/f50VpmkYIKRaLtm1H6zoKmQmGkVKpJPecoR+UWbBTZ9t2R5kFD3aMNCqK8vTpU0IIKoBIJpYaC5kJRodGo3Es22mEdpEMycODhmHAcjOI7/ubm5v8LbqIoVls27Y//PDD4LwUISSTyWD5fITbETITjAKKoqTT6d3dXUmSisVioVAol8v5fP673/1uPp+HuYvrultbW4VC4cWLF/yDjUYjkUiEVujDRaZUKtVqNbiMVavVv//97+l0OlpsT8hMMApEmzUGcOwLHqGUcuf20JnRcgaEzASCgSNkJhAMHCEzgWDgCJkJBANHyEwgGDhCZgLBwBEyE4wgw+aHJWQmGBEcx+FbJqiq2jF5nWcV812RkTzVLstKpdK+SjqyzZaQmWBEUFU1l8th7TNpWak2Gg2uDeRVwaTAtm2chq1L2q0H1tfXg+mLvu/fu3dPkiTssXxchMwEowCyhy9dugRjNchJ1/XZ2VmeGQyZeZ43Pj7OWmuuTdP0PC8ej4daqsnJSWQVY0GaJElY5B6tQTs3Mnvx4kW5XK7VamdYB+S2DVu/fyR5+fJloVAIpRp2o9lsvv7661evXv3f//5XKBSWlpYIIVeuXCkUCn/605/4/8vzvImJiUePHv3xj3/c29t77bXXPvjgg/Hx8XQ6/bvf/S5YoOu63/ve9xhjkiTduXOn0Wjs7e299dZbkW/n3MisWCxymw3s1HyaV6/X6/iN7H11huAkNBqN3r1AYGWl63q9Xod1HPJ9Pc+bm5vjp6E1s20bm0tSSuHUQghJJpNo1lhr2Usmk2GM8V4i9kNnjEWwtWLnSGb1ej3kSPPRRx+dwnXhcMQvGq1rLjguvcvMNE1YWXGZGYaBhTCapi0vL/MzuSVjOp2Gr4GmaXA6mpubIy3jQ03TZFm+fPkyY4xvPSlJUiwWgwFHhGcgosz8/hEs9pCGAovtQkqD2dggmhdKqeM4+JkM+lX1vgiK25X1/Vu6CPQoM0qppml4NhCxwA6s+NIsywotLcM4LZ/PI/IB60WsksYKF5iFMMa2trbY11sztG/RiCKzdvvlk8CNTfBToXVhfHy8Wwl9356nWq12M8Y7pIYh+mutVy6X+3uPQ86xOo2MMS4zPA+O48AeJ7RQmhDiOM7m5ibUxR3+tre3QxMAIZlRSoO2c8cliszw43E6BB/W9gcXpqV9b80wEuuoE0mSulUSwSh+Zn+/ByGzw1ECrZnTImS5A5lJkhSPx2GbyQ+2x1pCMmOMXbp0KfLtDPvYrNlsNhqNRqPxn//8h/ufJpPJ5eXlcrl8yF4hJ9+VptFolMvlbDa7sLDwzW9+E5fe2NjoeGaj0Wg2my9fvmy0EJGSaCCYHJLZkRFmyOzLL7+MxWJvv/3222+/XSgU7ty5E5IZXBz/9a9/3b17N5vNbm1traysEEJ++9vfbm1tffrpp/xkLrP5+fn19fW9vb2NjY1bt27VarVkMnncmxp2mXGKxaKiKL1PXOi6LklSjxHhI2k2m7A3IkOz4xYflpx1RfoMOik3b94khFiWxQ3kD/8UZFYsFoNeHb7vz8/PWwEP/fZ/35GtmaIoGAI8fPiQd3COfVPH/cBZ4brusc6HKjouNY+M7/vwdeljmZFB6DVafHmYCcZ1OUfuvQTPqTt37vAwI3fdgXMjC0Qagx/sJrMbN26wVkyOO1ux1nN13Js6NzI7LoOQ2cnpo0QxkRjNBHfIaZfZed+14+xlxkdQvu/3svtbjwyPzCzL4mOMPgYzlpeXh6oT20dC8ygdt5I4X5y9zJaWlvACJnj9emiGR2bBrp2macft/XYjlUrhKRy9Bg0JipwRSAmILrNgHM/3fUopOriH7zLKGMMWifztzMwMb8Hah6cdS8Dc8bNnzw65ypnLDPeCEVRweIDvDW8Rd0ZaEF7wj+NIt8I9zwvuOzViDRqllN+dJElDMhg+CRFlRin94Q9/iPuvVquxWMyyLNM0E4mEoigPHjzY3t5OJpNfffWV53mJRAJPTC6Xm5iYyGazMzMz2Lr7/ffflyRpenp6f39/f38/kUj4vt9sNr/1rW+l0+l0Oj0/P7+4uJhOp7/zne/AQbbRaKRSqdnZ2Z/+9KdXrlwJ1uqrr74ql8tQO5dZpVKJEG9EZfb39/H2l7/85f7+/rVr11KplKIoqqoeHBz8/Oc/x18fPXqUSCQopX/+85/n5uZUVb1x48bY2Nja2tonn3xCCEmn04hcodO4sbFBCLl06VI2m52amvr2t7+dyWQymUw8Hn/06BFj7M6dO8vLywsLC8lksj2WTSmdmZkJ/t4HM/dGA3SJ4/F4vxr/syV6a5ZOp/GTjM0EKaXZbJZPpWOVQbVaDUZRTdPM5/MsYHrOGOP2y/wgss5wEHsFMMZ2dnYQq+XLGVzXbY/5IP2Mr4aATWyPe4SHQCSXv2atMQNvY/mOB0iLoZTmcjm5tSGwEshL4J1GyAzBNBx0HGdqaooxBmNqfIH89kmnHJdQnwocywp7+BmxAE90mcFSnDGG9DDGWDab5f/sk8iMBZ4z7MfBGKtUKpAZSuaEItqh0TOI1uuAGPBZJNpwzYN+ySybzbKAzND+Ix5NOm1wjl8QbNrIc1BG5okEx80CGXKiy6xYLOJfyxNSQjILNj59lBl6g3w7glCtLMsKaSxyxiPfnI5Xm1cGdJRZUFE9ygwa5jLzfT8Wi0kt2mfGkFf57Nmz4BfL5T0yjIzG2Elk5rouNkHnPbeBygxZ1awlJKwp6iihUC5i5A0Nfd9H/9MwDGxh3IvMuPKPlBkq5jjO7OwsC8iMUjo9PY3zsW6qY/UQXBmx4MeoEl1m+DdjqQ+OtMsMywr6IrPQ2MxxHIzN2n/zgmkEsVjsJHEqvi87thTpJjMo/7idRoSFHMfBzQbHZrxrKstyt96gkNk5IrrMKKUrKyupVOrx48c4ks/nv/jiC7xGhuVPfvKTycnJVCqFp2F7e3t3d5cx9uzZM+6+8Ktf/WpxcdH3/f39/Xg8jnj3L37xC5Sjqiq2MP3444/X19dx3a2trZmZGVistFes2WzyOSVeTjQ+/fTTRCKRSqXwVtO04H6qKysrCwsLq6urWKRDKf3973/Pc4sXFhZQ4XQ6PT09vbq6ioP//Oc/q9Xq1NQUJhueP3+O1e+U0lQqhUijaZpTU1Ovv/56KpU6ODjoWDchs3PEYKenD3kIeCMT7Be1tzy8hGM1SmjxCCHIQzsJh680xfJBPlV4SB/vuPhH7SQkZHaOOPsskEGAXE8yHFkgA0LI7BwxmjJjjHmeF2267LwgZHaOGFmZjTyU0tN3+BJEQ8hMIBg4QmYCwcARMhMIBo6QmUAwcITMBIKBI2QmEAwcITOBYOAImQkEA0fITCAYOKMgMzjwnHUtBIKunI3MLMs60i6XUmpZVjCZyGoR2sDbMAx4dYTQdb2bKaKqqofYklUqldAOGCsrK4fXENv8dCxNURSrE6ZpDmKfDcEQcgYyQ/r8kR6Xfmujbk3TTNMcGxvDcmasoQw2XzDY4W/5touaplUqlY6Fy7J8SGJxqVQKFdhx051ms0laLoJYetPRhom0NviRZVmW5cXFRWwGgJWvIvf3InAGMrMsS5Zlvp7aaAFDC+47AJnh6aSUzs3NYSF2yF6KtWTm+37If0bTtG7rzQ6XGSy6PM9DJQ3DwKLvEOVyOajG0G5aHF5bVVVlWcbmWvgeOjbCgtHjtGX24sWLy5cvu65br9fn5+evXbvmum46nX733XcZY7VaLWiNSgjZ29vDav8f/ehHsiw/fvz46dOn/MHd399fX18fHx8fGxv79a9//Ze//AXOBTdv3sTx73//+3y3AULI0tJSPp/P5/PxeHx2drZYLObz+Z/97GfBptUwjBs3buTzeaybdhwnmUz+7W9/c103aCnHGLt9+/a7776by+X+8Y9/HBwc5HK5N954w3Xdmzdv3rhxA9d9+fIldtza3d3d3d0dGxtbWlrK5XKO4xQKhUQi0a29FYwSpy2zlZUVvpMNf2R1XW83xuGdRvQbY7EYGj18NtjXwjaftm2vrKzAPIN3GnlrFnTaYIwFt7ctFotB6x7DMOD8gbYxeGbICyQej6PA4KgsJMVarWbbtmmaGI/Jsnz79m10F23bRpt5gq9TcD44bZndv3/ftu2gxlgXmYX275qZmcEL27YVRQn6GnCDndu3b8PfRpZlx3F6l1kooIIWBjLDhsVwKAnKzDAMLjNFUTBWpJSGbo3fIMZjmqatra3hd0EI7OJwBmMz7FQfNPnAT3voNM/z7ABwgzRNE40b/7iu6zDY0jSN+x/qug5JhGSGCARGd3x7W7j38OsahjE3NwfLUQhG13VuIIdhFVrahYUFVFvTNLSH9Xq9o35QSdM0+b20m5wKRpjTllmtVsPjqyiKLMuwJezopsgNbQBXAsLoPJKOdgyxhLt376IJsm0bTUd7a4bSELHE62w2GwyHGIZRKpUQUIHMKKWZTIYxpqoq32LCsqxcLodqQzmU0kql0tGWFFuH6i1QyX5/tYLh5bRllsvlIDP4mbK27hxwXdc0TQQ/TNOE0zBaMzQphmHU63W8hWgZYxsbGzDEbh+bsa97VAV3bQzNXBmGgbg8hIqD6EZymfF7QbWxZZRhGDs7Ox1nz9CacSPhjpbdghHmtGX26tWrcrlcKBQ2Nzc3Nzdd13316hUhBP6NITO5UqnEGHvy5EmpVPr888+Xl5cbjcaHH344PT39/vvvs9ZOubquy7L85ptv/vvf/8ZBFJJOpz/++OOO1ZBleXt7u+OfDMO4f/9+uVwOWpFiW6lkMvnw4UN+JpcZY2xnZ6dSqeTzeb77TFC9uq4nEoknT54cHBwcHBxcu3ZNyOxCcdoyKxQKiqKgr4hMiNXVVVmWFUVB88XbGZ7bwa2zMTnGGEMiCH+O27NA0N8jhLTvWsRP6DYvbJrm0tISAi28p7q+vt4+X7e5uWmaZrBnu7Cw4Pu+4zgYHFJKq9UqBpMI6+M0zLAbhoHTENgUjDBnkwXSy2m6rqMDBofw9kKCM2yKooQCD47jKIrSbVbKsqxu09O8FaWU8nMajQZUF6w8b/HsNizLQp3r9Xr7X0NE2H5NcL4YhdThCBy5pWg77TbAzWZTZCQKeuGCykwgOE2EzASCgSNkJhAMHCEzgWDgCJkJBANHyEwgGDjnT2Zw/jgykt7LOQLB6XBuZIYtm1lgi/dms9lt+/Zu6cisNdkd5OnTp5Au3uq6HvQa6GY0IhD0zjDKrNFotJsLvPHGG5lMBplZ8Xh8bW1tZWUlk8lUKpVCoYD1YPV63XVd13U/+OADQsibb77ptigWi3fv3m02m0iqvHfv3nvvvVcul8vl8tzc3L179/B6bW2tXC5/9tln/LqSJMEIBKmYyNi4evVqPB7/5JNPcE6z2XznnXdWV1f/+9//ntJ3JDhXDJ3MkO0ePIJFkLFYjOfmg9nZWRhUIbEw+BEkEx9yFTSJ+Ozs7CxPO+QWOr7v4yqSJKmqOj4+zj+Ltc/tlnWe52G9jEAQYuhkxpdIhsjlcqqqwrUGxOPxbiZwhzvqsK/nNGYymeDaZ+RG8lVtcNG6dOlSsPCONWSMpdPp3u5ScLEYOpnBX6D9eC6XQxY//DM8z1tcXOwoM6zaPDxlETn+aM0SiQQWtiEHP3iabdtI0l9fX2+vYXuIhStWIAgyXDKDhWPHCGEul0O/DsnvkiTdvHmz2xpKNEocLAwNOavytWRLS0towWA9ECyKu6bOzs6iKL6GxXGcy5cvt1fySJtXwQVkuGTGl5a1/6lWq8Hqw7Ztx3EIIe+99x7CgMEnG1JRW2Bk1VFmsDbACje8QPn8HDicIpd/fX2dywwLpbnpahAhM0FHhktmlNLp6eknT56Eju/u7r7zzjswOLBt+4svvojFYtevX9/c3Lx+/TrCjIyxzz77LJ1Of/TRR/yD3QZL9Xq9VCrJsry3t5dOpxstgmbgT58+TSaTm5ubqVSKzw00m82xsbFuM3K3bt2q1+tR714wsgyXzFgr0hh6WD3PMwyDD7rQmuVyOUyC8XmtxcXFkAAOj0lgem15efmQc7AKe2pqih/p1q31PG91dfXIGxRcQIZOZqzteYWXAWzAEaaHzBAC4QF93/fv37+Pj9AWQWe49rwQ9FFTqRR8strFA82bpplMJmGsAKl3O1M0ZYKODKPMGGP37t1rP4jGx3EcyIz3FTnFYlHTNPhAcmB9hYNQHebEuIPdW2+9hRkzbnIMawPYUSFy2Gg0fN9HCR1Hj6qqihijoBtDKrNu8Eg62pYIJcAKn3t1gGAGlq7rtVrN931d19v9RVRVDXoeCwS9cM5kJhCcR4TMBIKBI2QmEAwcITOBYOAImQkEA0fITCAYOEJmAsHAETITCAbO/wEnxi+Q/2+z9QAAAABJRU5ErkJggg==" alt="" />
2. 延迟跟踪
内核有一个固定的概念,称之为良好的调度延迟,即保证每个可运行的进程都应该至少运行一次的某个时间间隔
. sysctl_sched_lasency: 一个进程最少运行的时间,可通过/proc/sys/kernel/sched_latency_ns控制,默认值为20毫秒
. sched_nr_latency: 控制在一个延迟周期中处理的最大活动进程数目
//如果活动进程的数目超出sched_nr_latency上限,则延迟周期sysctl_sched_lasency也会成比例地线性扩展
__sched_period确定延迟周期的长度,通常就是sysctl_sched_lasency,但如果有更多进程在运行,其值有可能按比例线性扩展,在这种情况下
周期长度 = sysctl_sched_lasency * nr_running / sched_nr_latency
通过考虑各个进程的相对权重,将一个延迟周期的时间在活动进程之间进行分配,对于由某个可调度实体表示的给定进程,分配到的时间如下计算
/*
We calculate the wall-time slice from the period by taking a part proportional to the weight.
s = p*P[w/rw]
*/
static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq); for_each_sched_entity(se)
{
struct load_weight *load;
struct load_weight lw; cfs_rq = cfs_rq_of(se);
load = &cfs_rq->load; if (unlikely(!se->on_rq))
{
lw = cfs_rq->load; update_load_add(&lw, se->load.weight);
load = &lw;
}
slice = calc_delta_mine(slice, se->load.weight, load);
}
return slice;
}
我们知道,就绪队列的负荷权重是队列上所有活动进程负荷权重的累加和,结果时间段是按实际时间给出的,但内核有时候也需要知道等价的虚拟时间
/*
We calculate the vruntime slice of a to be inserted task
vs = s/w
*/
static u64 sched_vslice(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
/*
对权重weight的进程来说,实际时间段time对应的虚拟时间长度为: time * NICE_0_LOAD / weight
*/
return calc_delta_fair(sched_slice(cfs_rq, se), se);
}
0x3: 队列操作
接下来讨论CFS和全局调度器(核心调度器)交互所必须实现的各个方法,有两个函数可用来增删就绪队列的成员:
. enqueue_task_fair
. dequeue_task_fair
1. enqueue_task_fair
/*
The enqueue_task method is called before nr_running is increased. Here we update the fair scheduling stats and then put the task into the rbtree:
*/
static void enqueue_task_fair(struct rq *rq, struct task_struct *p, int wakeup, bool head)
{
struct cfs_rq *cfs_rq;
struct sched_entity *se = &p->se;
int flags = ; //判断指定入队的进程是否最近才被唤醒并转换为运行状态
if (wakeup)
flags |= ENQUEUE_WAKEUP; if (p->state == TASK_WAKING)
flags |= ENQUEUE_MIGRATE; for_each_sched_entity(se)
{
//通过struct sched_entity的on_rq成员判断进程是否已经在就绪队列上
if (se->on_rq)
break;
cfs_rq = cfs_rq_of(se);
//将具体工作委托给enqueue_entity完成
enqueue_entity(cfs_rq, se, flags);
flags = ENQUEUE_WAKEUP;
} hrtick_update(rq);
}
继续跟进enqueue_entity
static void enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
/*
Update the normalized vruntime before updating min_vruntime through callig update_curr().
*/
if (!(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_MIGRATE))
se->vruntime += cfs_rq->min_vruntime; /*
Update run-time statistics of the 'current'.
更新统计量
*/
update_curr(cfs_rq);
account_entity_enqueue(cfs_rq, se); if (flags & ENQUEUE_WAKEUP)
{
//如果进程此前在睡眠,那么在place_entity中首先会调整进程的虚拟运行时间
place_entity(cfs_rq, se, );
enqueue_sleeper(cfs_rq, se);
} update_stats_enqueue(cfs_rq, se);
check_spread(cfs_rq, se);
if (se != cfs_rq->curr)
//使用了内核的标准方法将进程置于红黑树中
__enqueue_entity(cfs_rq, se);
}
由于内核已经承诺在当前的延迟周期内使所有活动进程都至少执行一次,队列的min_vruntime用作基准虚拟时间,通过减去sysctl_sched_latency,则可以确保新唤醒的进程只有在当前延迟周期结束后才能运行。但如果睡眠的进程已经积累了比较的不公平值(即se_vruntime值比较大),则内核必须考虑这一点,如果se->vruntime比先前计算的差值更大,则将其作为进程的vruntime,这会导致进程在红黑树中处于比较靠左的位置
0x4: 选择下一个进程
选择下一个将要运行的进程由pick_next_task_fair执行(fair_sched_class调度器类的成员)
static struct task_struct *pick_next_task_fair(struct rq *rq)
{
struct task_struct *p;
struct cfs_rq *cfs_rq = &rq->cfs;
struct sched_entity *se; //如果nr_running计数器为0,即当前队列上没有可运行进程,则无事可做,函数可以立即返回
if (unlikely(!cfs_rq->nr_running))
return NULL; do
{
//将具体工作委托给pick_next_entity
se = pick_next_entity(cfs_rq);
set_next_entity(cfs_rq, se);
cfs_rq = group_cfs_rq(se);
} while (cfs_rq); p = task_of(se);
hrtick_start_fair(rq, p); return p;
}
继续跟进pick_next_entity
static struct sched_entity *pick_next_entity(struct cfs_rq *cfs_rq)
{
//如果最左边的进程可用,可以使用辅助函数first_fair立即确定,然后使用__pick_next_entity从红黑树中提取出sched_entity实例
struct sched_entity *se = __pick_next_entity(cfs_rq);
struct sched_entity *left = se; if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, left) < )
se = cfs_rq->next; /*
* Prefer last buddy, try to return the CPU to a preempted task.
*/
if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, left) < )
se = cfs_rq->last; clear_buddies(cfs_rq, se); return se;
}
0x5: 处理周期性调度器
/*
scheduler tick hitting a task of our scheduling class:
*/
static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
{
struct cfs_rq *cfs_rq;
struct sched_entity *se = &curr->se; for_each_sched_entity(se)
{
cfs_rq = cfs_rq_of(se);
//实际工作委托给entity_tick
entity_tick(cfs_rq, se, queued);
}
}
继续跟进entity_tick
static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
{
/*
Update run-time statistics of the 'current'.
使用update_curr更新统计量
*/
update_curr(cfs_rq); #ifdef CONFIG_SCHED_HRTICK
/*
* queued ticks are scheduled to match the slice, so don't bother
* validating it and just reschedule.
*/
if (queued) {
resched_task(rq_of(cfs_rq)->curr);
return;
}
/*
* don't let the period tick interfere with the hrtick preemption
*/
if (!sched_feat(DOUBLE_TICK) &&
hrtimer_active(&rq_of(cfs_rq)->hrtick_timer))
return;
#endif //如果nr_running计数器表明队列上可运行的进程少于2个(即1个或没有),则实际上无事可做(不需要调度)
if (cfs_rq->nr_running > || !sched_feat(WAKEUP_PREEMPT))
check_preempt_tick(cfs_rq, curr);
}
继续跟进check_preempt_tick
/*
Preempt the current task with a newly woken task if needed:
该函数的目的在于: 确保没有哪个进程能够比延迟周期中确定的份额运行的时间更长,该份额对应的实际时间长度在sched_slice中计算
*/
static void check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
{
unsigned long ideal_runtime, delta_exec; ideal_runtime = sched_slice(cfs_rq, curr);
/*
进程在CPU上已经运行的实际时间间隔由"sum_exec_runtime - prev_sum_exec_runtime"给出
因此抢占决策很容易做出
1. 如果进程运行时间比期望的时间间隔长,那么通过resched_task发出重调度请求,这会在task_struct中设置TIF_NEED_RESCHED标志,核心调度器会在下一个适当时机发起重调度
*/
delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
if (delta_exec > ideal_runtime) {
resched_task(rq_of(cfs_rq)->curr);
/*
* The current task ran long enough, ensure it doesn't get
* re-elected due to buddy favours.
*/
clear_buddies(cfs_rq, curr);
return;
} /*
* Ensure that a task that missed wakeup preemption by a
* narrow margin doesn't have to wait for a full slice.
* This also mitigates buddy induced latencies under load.
*/
if (!sched_feat(WAKEUP_PREEMPT))
return; if (delta_exec < sysctl_sched_min_granularity)
return; if (cfs_rq->nr_running > ) {
struct sched_entity *se = __pick_next_entity(cfs_rq);
s64 delta = curr->vruntime - se->vruntime; if (delta < )
return; if (delta > ideal_runtime)
resched_task(rq_of(cfs_rq)->curr);
}
}
0x6: 进程唤醒
当在try_to_wake_up、和wake_up_new_task中唤醒进程时,内核使用check_preempt_curr来查看是否新进程可以抢占当前运行的进程,对完全公平调度器处理的进程,则由check_preempt_wakeup函数执行该检测
//All the scheduling class methods:
static const struct sched_class fair_sched_class =
{
.next = &idle_sched_class,
.enqueue_task = enqueue_task_fair,
.dequeue_task = dequeue_task_fair,
.yield_task = yield_task_fair, .check_preempt_curr = check_preempt_wakeup,
新唤醒的进程不一定由完全公平调度器处理,如果新进程是一个实时进程,则会立即请求重调度,因为实时进程总是会抢占CFS进程
/*
* Preempt the current task with a newly woken task if needed:
*/
static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
{
struct task_struct *curr = rq->curr;
struct sched_entity *se = &curr->se, *pse = &p->se;
struct cfs_rq *cfs_rq = task_cfs_rq(curr);
int sync = wake_flags & WF_SYNC;
int scale = cfs_rq->nr_running >= sched_nr_latency; update_curr(cfs_rq); //判断新唤醒的进程是否为实时进程
if (unlikely(rt_prio(p->prio)))
{
resched_task(curr);
return;
} if (unlikely(p->sched_class != &fair_sched_class))
return; if (unlikely(se == pse))
return; if (sched_feat(NEXT_BUDDY) && scale && !(wake_flags & WF_FORK))
set_next_buddy(pse); /*
* We can come here with TIF_NEED_RESCHED already set from new task
* wake up path.
*/
if (test_tsk_need_resched(curr))
return; /*
* Batch and idle tasks do not preempt (their preemption is driven by
* the tick):
*/
if (unlikely(p->policy != SCHED_NORMAL))
return; /* Idle tasks are by definition preempted by everybody. */
if (unlikely(curr->policy == SCHED_IDLE)) {
resched_task(curr);
return;
} if ((sched_feat(WAKEUP_SYNC) && sync) ||
(sched_feat(WAKEUP_OVERLAP) &&
(se->avg_overlap < sysctl_sched_migration_cost &&
pse->avg_overlap < sysctl_sched_migration_cost))) {
resched_task(curr);
return;
} if (sched_feat(WAKEUP_RUNNING)) {
if (pse->avg_running < se->avg_running) {
set_next_buddy(pse);
resched_task(curr);
return;
}
} if (!sched_feat(WAKEUP_PREEMPT))
return; find_matching_se(&se, &pse); BUG_ON(!pse); if (wakeup_preempt_entity(se, pse) == ) {
resched_task(curr);
/*
* Only set the backward buddy when the current task is still
* on the rq. This can happen when a wakeup gets interleaved
* with schedule on the ->pre_schedule() or idle_balance()
* point, either of which can * drop the rq lock.
*
* Also, during early boot the idle thread is in the fair class,
* for obvious reasons its a bad idea to schedule back to it.
*/
if (unlikely(!se->on_rq || curr == rq->idle))
return;
if (sched_feat(LAST_BUDDY) && scale && entity_is_task(se))
set_last_buddy(se);
}
}
0x7: 处理新进程
对完全公平调度器需要考虑的最后一个操作是创建新进程时调用的挂钩函数: task_new_fair(),该函数的行为可使用sysctl_sched_child_runs_first控制,该参数用于判断新建子进程是否应该在父进程之前运行,这通常是有益的,特别是在copy on write的情况下,如果子进程随后会执行exec系统调用,则这样的操作会大大减少copy on write的发生
该参数的默认设置是1,但可以通过/proc/sys/kernel/sched_child_runs_first修改
8. 实时调度类
按照POSIX标准的强制要求,除了"普通"进程之外,Linux还支持两种实时调度类,调度器结构使得实时进程可以平滑地集成到内核中,而无须修改核心调度器,这是调度类模块架构带来的好处
0x1: 性质
实时进程与普通进程有一个根本的不同之处,即如果系统中有一个实时进程且可运行,那么调度器总是会选择它运行,除非有另一个优先级更高的实时进程,回想之前关于调度策略和调度器类的映射关系
. SCHED_NORMAL、SCHED_BATCH、SCHED_IDLE: 映射到fair_sched_class
. SCHED_RR、SCHED_FIFO: 映射到re_sched_class
//fair_sched_class(公平调度器)、re_sched_class(实时调度器)都是strcut sched_class的实例,这是Linux中两个主要的调度器
现有的两种实时调度器类,不同之处如下
. 循环进程(SCHED_RR): 有时间片,其值在进程运行时会减少,就像是普通进程,在所有的时间段都到期后,则该值重置为初始值,而进程则至于队列的末尾,这确保了在有几个优先级相同的SCHED_RR进程的情况下,它们总是依次执行
、 先进先出进程(SCHED_FIFO): 没有时间片,在被调度器选择执行后,可以运行任意长时间。很明显,如果实时进程编写得比较差,系统可能变得无法使用,很容易hang住
0x2: 数据结构
static const struct sched_class rt_sched_class =
{
.next = &fair_sched_class,
.enqueue_task = enqueue_task_rt,
.dequeue_task = dequeue_task_rt,
.yield_task = yield_task_rt, .check_preempt_curr = check_preempt_curr_rt, .pick_next_task = pick_next_task_rt,
.put_prev_task = put_prev_task_rt, #ifdef CONFIG_SMP
.select_task_rq = select_task_rq_rt, .load_balance = load_balance_rt,
.move_one_task = move_one_task_rt,
.set_cpus_allowed = set_cpus_allowed_rt,
.rq_online = rq_online_rt,
.rq_offline = rq_offline_rt,
.pre_schedule = pre_schedule_rt,
.post_schedule = post_schedule_rt,
.task_woken = task_woken_rt,
.switched_from = switched_from_rt,
#endif .set_curr_task = set_curr_task_rt,
.task_tick = task_tick_rt, .get_rr_interval = get_rr_interval_rt, .prio_changed = prio_changed_rt,
.switched_to = switched_to_rt,
};
和完全公平调度器一样,核心调度器的就绪队列也包含了用于实时进程的子就绪队列,是一个嵌入的strcut rt_rq实例
实时进程的就绪队列非常简单,只是一个链表
/*
This is the priority-queue data structure of the RT scheduling class:
*/
struct rt_prio_array
{
/*
include 1 bit for delimiter
active.bitmap位图中的每个比特位对应于一个链表,凡包含了进程的链表,对应的比特位则置为,如果链表中没有进程,则对应比特位不置位
*/
DECLARE_BITMAP(bitmap, MAX_RT_PRIO+);
//具有相同优先级的所有实时进程都保存在一个链表中,表头为active.queue[prio]
struct list_head queue[MAX_RT_PRIO];
}; /*
Real-Time classes' related field in a runqueue:
*/
struct rt_rq
{
struct rt_prio_array active;
unsigned long rt_nr_running;
#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
struct {
int curr; /* highest queued rt task prio */
#ifdef CONFIG_SMP
int next; /* next highest */
#endif
} highest_prio;
#endif
#ifdef CONFIG_SMP
unsigned long rt_nr_migratory;
unsigned long rt_nr_total;
int overloaded;
struct plist_head pushable_tasks;
#endif
int rt_throttled;
u64 rt_time;
u64 rt_runtime;
/* Nests inside the rq lock: */
spinlock_t rt_runtime_lock; #ifdef CONFIG_RT_GROUP_SCHED
unsigned long rt_nr_boosted; struct rq *rq;
struct list_head leaf_rt_rq_list;
struct task_group *tg;
struct sched_rt_entity *rt_se;
#endif
};
aaarticlea/png;base64,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" alt="" />
实时调度类中对应update_cur的是update_curr_rt,该函数将当前进程在CPU上执行花费的时间记录在sum_exec_runtime中,所有计算的单位都是实际时间,不需要虚拟时间
0x3: 调度器操作
实时进程的入队和离队都比较简单,只需以p->prio为索引访问queue数组queue[p>prio],即可获得正确的链表,将进程加入加入链表或从链表删除即可。如果队列中至少有一个进程,则将位图中对应的比特位置位,如果队列中没有进程,则清除位图中对应的比特位,需要注意的是,新进程总是排列在每个链表的末尾
对于实时进程来说,pick_next_task_rt负责选择下一个将执行的进程
static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq, struct rt_rq *rt_rq)
{
struct rt_prio_array *array = &rt_rq->active;
struct sched_rt_entity *next = NULL;
struct list_head *queue;
int idx; //sched_find_first_bit是一个标准函数,可以找到active.bitmap中第一个置位的比特位,这意味着最高的优先级(对应于较低的内核优先级数值)
idx = sched_find_first_bit(array->bitmap);
BUG_ON(idx >= MAX_RT_PRIO); queue = array->queue + idx;
next = list_entry(queue->next, struct sched_rt_entity, run_list); return next;
} static struct task_struct *_pick_next_task_rt(struct rq *rq)
{
struct sched_rt_entity *rt_se;
struct task_struct *p;
struct rt_rq *rt_rq; rt_rq = &rq->rt; if (unlikely(!rt_rq->rt_nr_running))
return NULL; if (rt_rq_throttled(rt_rq))
return NULL; do {
rt_se = pick_next_rt_entity(rq, rt_rq);
BUG_ON(!rt_se);
rt_rq = group_rt_rq(rt_se);
} while (rt_rq); p = rt_task_of(rt_se);
p->se.exec_start = rq->clock_task; return p;
} static struct task_struct *pick_next_task_rt(struct rq *rq)
{
struct task_struct *p = _pick_next_task_rt(rq); /* The running task is never eligible for pushing */
if (p)
dequeue_pushable_task(rq, p); #ifdef CONFIG_SMP
/*
We detect this state here so that we can avoid taking the RQ lock again later if there is no need to push
*/
rq->post_schedule = has_pushable_tasks(rq);
#endif return p;
}
9. 调度器增强
0x1: SMP调度
在多处理器系统上,内核必须考虑几个额外的问题,以确保良好的调度
. CPU负荷必须尽可能公平地在所有处理器上负载
. 进程与系统中某些处理器的亲和性(affinity)必须是可设置的,例如在4核CPU上,可以将计算密集型应用绑定到前3个CPU,而剩余的(交互式)进程则在第4个CPU上运行
进程对特定CPU的亲和性,定义在task_struct的cpus_allowed成员中,Linux提供了sched_setaffinity系统调用,可修改进程与CPU的现有分配关系
. 内核必须能够将进程从一个CPU迁移到另一个
1. 数据结构的扩展
在SMP系统上,每个调度器类的调度方法必须增加两个额外的函数
0x2: 调度域和控制组
我们知道,调度器并不直接与进程交互,而是处理"可调度实体",这使得可以实现"组调度": 进程置于不同的组中,调度器首先在这些组之间保证公平,然后在组中的所有进程之间保证公平
内核提供了控制组(control group),该特性使得通过通过特殊文件系统cgroups可以创建任意的进程集合,甚至可以分为多个层次
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAlwAAACDCAIAAADXiVI0AAAgAElEQVR4nO2dT4gbWX7H66BLoUODIAU6dG8ElV46Y/rQZeiDME0opaFnRji4vO4NNOtlkrIjwvTEi9D0EIJm6c4w0mQC6t0N3dR4Yy2TwX3YLaxAPFEOG8ciLLi1CVNgLSEm40OWql3IpXyIL085fOO3NfpTqpLqn9Tvcxg8rap6v6p69b7v/d7v/R7XZzAYDAaD0e/3+30ubgMYDAaDwUgKTBQZDAaDwfh/mCgyGAwGg/H/MFFkMBgMBuP/YaLIYDAYcw8hhBBiGIaqqqqqiqLIjUdRlLfffhunxG144mCiyGAwGPOKbduapimKIggCBE8QBEEQFEWpjUEURUEQlpaWcLwsy4qiGIZh23bcd5MImCgyGAzG/IFB4erqKsdxoihKkqRpmq7rHk+3LEvTtEqlAo3kOG5tbc0wDDZ2ZKLIYDAY84RpmoqiYJx38+ZN70LockFd1+FxFUVRUZSLLI1MFBkMBmM+sG1bVVWe5zmOq9VqwQ7sbNvWdV2SJCqNlmUFdfE5gokig8FgJB1CyNnZ2de+9rVyudzpdMKb/yOE9Hq909PT3d3dtbW1ZrN50eYamSgyGAxGoiGEwLfZaDSiLPfk5ITjOEmSLpQ3lYkig8FgJBeqiJVKJfqiK5UKz/OCIJimGXHpccFEkcFgMJJLXIpI0TQNunhBxotMFBkMBiOhaJoWryKCSqXCcZyqqjNexzRNl4uMnLw0TROrTdyvrOu6LMvusu0c7LoMfOdSFDVNG16L6p3l5WXEVuF0erWJz53BYDAiw7ZtLMOP25A+IQRRqcPxqHCxCoKAdlhRlOXlZfwvUBRFkiR6MMT17OyMnoLDZFm+fPkyPUxRFOgWThFFET8hWcGwhYZhIBHBuFvAikz6v9vb2+OOTJwoIvNQq9U6OzurviKfz29tbf32b//2+vr61tZWPp/f3d3d3d2tOjg8PDzzxt/8zd9Uq9VGo9FoNJxFoBRcH/8tlUr4tdFotFqtXq93QRwIkUFe8fz585aD09PT73//+873e3R09N5779F3NEw+ny+Xy9UhfvzjH7darXa7TRzEfd+MEbBXM4Cu65lMJiHBn4SQra2t73znO8N/t23btu0nT57gH//xH/9hmqZt291uN5VKvf322//93/9Nj79///5bb731+eefC4LwrW99a3NzM5VKlcvlO3fuFAoFHGOaJsdxr7322p/92Z+lUql8Pl+tVt96661UKnX9+vVqtYrDbNu+cuXK4eFhu93+9NNP9/b2NjY2Pv30U13Xd3d3c7nco0ePcOSvfvWrVCr1zjvv0BZga2sLcbadTqfVajkrXiJE0bZt0zQrlQo6IxzHpdNpQRAkSaLDweitMgwDRauqKghCOp2GbZIkISsSXnz0hs07hBC8bkVRsOKK47hUKuUczQ/npiKE4L/jLqvr+vBZeHeAlnX58mVFUVRVNU3TNE3WEIcN3riT/f195au88cYbSFGmjOeP//iPB66z2DraaDRm91gGiGEY+Xx+5E9w8+JDS6VSdGjI8zz1/cJ3ikFhu90WBEGWZZ7neZ6XZVmW5VKpRI/E1WRZposm8e98Pk9HivjLkydPFEXRNM00TUEQUBzaEOojPTk54XkeB9B8eNTggfDaOEXRNE3DMBRFgd7wPI+b1zSt2+3GaNhIut0ucgzSrEgcx+VyOQjkAn+Zs4MXraoqqj6eHnWbwHFN+3ThYRiGpmmapr322muiKFKNxDd569Yt9h4DwbZtwzDQp8Qbv3Tp0kBCanEqlpeXB64jSZIkSTR7J1iYruru7m7SYj6XlpZG/h2iiM+nXC6PFMVKpVKr1fDtd7tdeDsRRoTh0LAoFotFpC9HRjqO4z788EPDMGihiqLYto04IHhQR3qbNzY2eJ6n/0uboJH3EoMowiksSRJtlfL5vK7r9FaTDyFE13Vd19988036kXuZDb5o6Lp+584d2ofgeV6SJFVVdV2PXX6Q2grjS0mS0DPDe1QURdf1hWlbI8AwDEQ6SJK0srLi7IlDt2q1mu5gulLod+d8cZIkOfv+eImyLOOY2KvZLCRQFK9cuTLy715EEWBOsdPpQMkqlYqmaXhlxWIRx0AUNU07OzujXR/I5/Ck5t7enmEYsixDFId1hBCytLRERdEwDJ7n8b2PrIqRiqJpmpqmoQajez5fWjgSOgaCxr/22msYyMdtV2wYhoE5bVTiXC4ny7KqqnA4x23dWKCRGNngVQqCAP2O27TkomnajRs3nMNuQRDeeOMNOmiL5o3DFQFPAITZqcqiKL777rtJrnvjmFNRrNfr7qJYq9V6vR6GiXAQQilzuRyO0XUditXpdDiOq1Qq8ClyHDfsRCwWi3AyjxNFzJVgXIiIIUEQNjc3YcBwtykiUdR1nabsg1M4aS97diD5a2trdEjkPge2eBiGcfXqVaoo87sfDV5lPp+nDSs8P3HbFT+Y2aUh3xzHra+vK4pSqVSSM0FLpzAxb60oSiqVwrhEVVWMWeO20RP7+/tJcz65u0/Rp0yn0xNFsVQqYSYFrQREcXd3F8fAy6rrOvYAkWWZRpwM5/Q5OjpCcTgLooiOOA5A5CZGirVaDY7Wra0tTDGqqjpQaUMURcuyWq3WH/7hHy4tLRUKhXq93mq1ut1uEj6b8CCEdDqder1erVYLhYIoijdv3kToY9ymBc/Lly/Pzs7K5XI+n19aWtrc3Pyrv/qrVqtlWdYC3C+CODqdTrPZrFarpVJpY2OjUChUq9WBcLUFZqA+X7lyBSHZ8/U5/+pXv6IB7aiuX//613EjzWYzsdX1n/7pnzKZzPn5edyG/D9oz0f+9OjRo1wud//+/V6v99Of/rTVauHvI0Uxl8v91m/91q1bty5dupTNZq9duwZRpHOKhUJhfX3dtm1CyP7+/tbWVqPRyOVymUzmP//zP+mlms3m0dHRd7/73Wq1+vHHH8Mjev369cPDQ0Se02HlP/zDP6RSKdTher1+dHT0ta99rVqtrq6uplKpnZ0dZ989FFHEUBdhRVevXg2jiDni1q1bGDwh3DFuc4IBgWSZTAbej3npes8Ixkl0OlyW5cePH8dtVFh8/vnniO6jbo95n+lwYlkW4oDofOQPfvCDBEoj3L9xW9Hvv3JpNptNLwdDAuDwHKg2cL3s7Oxg4gnzvqhdEEUsTHQOkeFf5Xl+XA3EmE8URfgjC4XCwKtst9v0dPgzcrmcpmkjLxiwKNq2jYWcaDIW6SuaBUyzoSWtVCpzvSEL5BD3cvPmzYWReV/ANSeKYiaTcUZ+LwCEELRoCKz3tW/tPEIIQdxfOp1GLHSipBEhl7G77unifY+zIaZpQsk4blBiIEXOwRIhBDPBEEXEneDv3/ve99BxgdsTkSjw1dPTf/KTn0AR8UfTNDc2NgYmC6n7lLK1tTXO+CBF0TTN7e1tGkGTqLqVBBAiBe/BPD4c515uoihqmjaPdxEsiK3leR5TI3GbMxOQB7rTbL1ej9uiSMFWgvB8JCqSHOOteLsmU6R5Q8dxZII60zTv3bvn/At08YMPPuj3+/A8odO5srJCA1Con4ZmJ0dvZmVlRdd1p0z2ej3oKP0LRorOEqMQRWzcnMlkklOZkolhGLlcThCEuXtQm5ubTA6HMQwDnWhIY9zmTEm326UrxoZDDy4OA46QuM3p9/t90zTpaCn60ulGGWGnEaB5GKiTc1yYHq2cOGak420g5su27YGn5zLxEYwo0iWZCzzFEiCWZcHDPC8blWEAgR7PXBgcMVg/B2ksl8txm+MbTdMymQymZNj77b8KP8YzSYhvHGO1TqcTZaHUazox1/YiMaso0r2+hIu04dbsEEJUVcXwIslzNsjMi7mBiD/IeUTX9Ww2K8vyvHwL1F+akFFRosDoGQ7VJPh1KpVKJpOJsrnY29vz6zVdAGYSxXv37gmCcO3atXa7HZRBFwrLsvb399fW1kqlUtI6Ys+fPy+Xy8vLy/l8/uKsQJidX/ziF7u7u6IoFgqFZrOZzGWav/zlLxuNxtraWj6fbzQaCcyqmBy63W6j0cjn8+vr65988km8H4Ku68VicXNz8/DwMKS1T7Ztt1qtvb29zc3N69evX8C6Mb0oGoaxtLQ0Lz3ihLO2tpYcRw3Y39+XJClRJs0RmImBByVpukgIKRQKkiQl2UWRQEzTzGazSZjygHeXDvGDeo9PnjxBqNFiBI5NzZSiiPRx8zh9kkwePHgAL01CRKhWq21sbMRtxdyDOPK33norbkN+A2aJstls3IbMJdjbQZKkJAgGooUzmQzC36ZLSYiLINQTi1LoRoYXlmlEEfOIgiDM9Xq7pKHrOlazxN4PxSQic4kHAiFkeXk5IWMyGg1EE44w/IJgYyRqif1T7ff7pmki6x5NSYjcacjGN1zxcHytVrt69apzHyVBEO7evZuEO4qdaUTRmWKOESBQI5o2MBbwcuO1YcFoNBpJCENDdsqBXCGMKaDRZ8n5TJDuFTlistmsc88Qfgj8PZVKqa9gm6Y58S2KSN46ckkmY3bQcYtrYEEIQecx9hZ8kcBTjbcfCe8O9lmNy4YFI/kOFV3X4RodhkmgC/5EsdPp5HK57e3tsGMHXrx40e12W61Wr9frdDqWZVmW9fTpU+sVLssDCCGWKy7GE0Lw68uXL4d/jSBiwrKszc3NVCrlzHsbDe12O5PJRPByLyC9Xu/q1au5XC6WZS2/+MUvMpnM5ubmBYwkDJWzs7Ovf/3r7KkuGP5EEYkVIuhlYG9Jd8YNp+AAdMElhAS5G7ChpTREZGloZFmOPskWN34rakYgODNURcne3p4syxEXekGo1+suiaoZ84g/UYzMcXp2diaKojEGyN64pEd0ynPcuXQry2GwuQdS1gJsIAxcCg0WwzDo1mLR0O12I7u7qXn06JGiKOiyqKqqOUBSxIQn3CGEIJYq4nKTE9W8eCA7VRLWaTCCwocoWpYVWbsJUXQ5YKIojjsRqUfH/aooiku5kd0+ZoAiKIhSr9cTskONC81mExmnlFdgBzWEpOMfvV4vbjPdQPBnlGHbuq4XCgWPB9M9hMfh4v41TVPX9ZFjpsV2yCdkIwtGUPgQxeFE4+HhLorutdBdFE3TvHz58rhfEyKK/X4/n89HUxA4OjpKfvDU6ekpx3HOQQ9xgBCwhIuir03pAkGSJO/riSdOPbjoK84djnWkuPgYNU1zOZHneZfv7tq1aziGLjwHgiBUKhWXlHvYisEF70E06Ouw4fhiMJei2J9hpNh31ZvkiOLBwUGU39jwtpwJ5PT0dGCbNCemaSZfFPv9PsdxkU0YY/PVs7Mzj8criuI+6+kuis5Evs64x7fffts9+FZRlO3t7ZHKhGkLlx7bxsYGnNIDokiXH4z7ZhE+6qLE3jum6KazmcXFgIniV0iOKJbL5SgXZnj3sMXI6empy4TcvIjiRx999Cd/8ifRlPXw4UNf3lr3+t+fJIrpdHpcl8U9C4yiKI1GY9yv7qL47rvvjvsJzoNx5aIHMO7cvuuWe8MUi8XLly8nv2fJmIhvUYxm+MJEkYniMIshioSQYrEYTVmyLLuMrYeZURQ5jruwoojcCEwUFwAfohhlgOLJyUlIokgI2d7eHvcrE8Ukw0TRL3Aqej9+RlEc93aQviAkUbx9+/a4n6IURaSDZqK4APhekhGNKjSbzfBGijdu3Bj3U3JEcXNzk80pDsBE0S8Ri6KiKCN/QuB6SKJYLBbHVd3oR4oJSXLLmAV/oqiqajQrVZvNJib8ySi8RJ/iOxk+1zTNS5cujSvXpVEghCzwkox5iT5dAFFUVXV/fz+asiqVShJE0bbt8EaKiRLFyKIuGOHhTxQRUB6BMJTLZffQ8Imi6Fy7NoD7OkWc+MYbbyhfZX19PUpRjHjnpnq9npzsxuNYDFEURTGy6FOoQmSBNmykyCUpSzhjOnwnBL9z504mk7l//34Y1lC+8Y1vtFqt7ig6nc7e3l4qlRqZcvDFixc3btx4/Pjx2dlZs9kcvki73f6d3/mdcV/Rs2fPJElqjGF/fz+bzYadAti27Xw+/+GHH4ZaygC9Xo/juDt37kRZqF/+/u//fmlpqTSGjY2NVCr15Zdfxm2mG5iYj8zJZlnWysqK9yUZb7/99vLycu8VA2ra6/VcRPH69evjok9nEUXLslKp1Cyi+Omnn478VVXVAEXxww8/TKfT9+/fT6fTP/zhD72fyEgavkUR26YgF1oYBnkBGUpH/tRutyfGgBUKhXGtEkYbLm2WLMthO5AxwI1+xIPXmvAFyOOy91HiNnAC2KoiyhJrtZr3lIGYmHAiOuA8LN4XxzBRFAVBcDnXXRThy6lUKtpXcV8+CFHUxuNLFLE9b7/fNwzDZYKGkXym2U/RNE0sbo0re5Ou6+McNdi7zl0Uv/e9741r+ieKommaqqqGF5OiqirHcaqqhnR9F7DQm+XJDA942CJ+uYZhrK+vezwYk+7jqNVqjx8/dilIccWlXmmaNu4sLMx3F0X3eZZxojgxfY/3zsRANuZ8Ph9v1jckeXYn+YF1cTGNKPZffd6np6fBWoN2eRbnUqlUGqeXHg1w75aGCnobvhaWBQu+7eRH3MwjtM8R/ct1cY0kHxox53KAO+4Xn/pcCt6ssy/e6XTidVoMj/iHCbYeKopC69jZ2Rnm/hVFGQ4CIIRgjE7T7NVqNV3XdV2/d+9egCZNzZSi2O/3scVzsE8WrpJZPuBOpzOLSQj79KIKhmEEO6IyDCOuRtMJQo2YLgYOfACxjMLr9XrgjSCDksAcby4TTP1w8gygemNOrdlsItpIEASnGRj3I/feO++8g9bemZAvIaulpxfFfr9/7do1SZKC+s49eg4JIbNPZ2KxxyxXEEUxwK0lO50OKlCMM7UA3QIu2VuKzxfoGtMmI3oQ58K2NwoDPNtxQdFxzUQgZ+y4X8MQRXi5VFU1TfPjjz+GLmCXt1qt1mq16JE0vmnAjFqtViqVAjRpamYSxefPn+/v7wuCUCqV7t27N+NTRrzoxIvAxffo0aPhnwghHjes53nexcvqZa600+lks9m//uu/9lKcO61W6/d///fr9XpCtvAmhDQajcuXL7fb7cXe9CcavvOd72Sz2ZOTkxg1qdVqbWxsbG1tzehKYTixbfvb3/72W2+9NXLRC7Za/OY3vxn9R1SpVFwSRDx8+DCVSgVbDSzLOj4+fvbsWaPRkGV5ZWWl0WhsbGxwHFetVv/93/+93++Xy+VqtXrlypV0On10dLS1tcVx3MnJyenp6enp6bVr1xZBFIFhGNg5RZblCDaKc0lY431vXpdobE3TBEHwUo91XZ8xNQnCdjiOOzw8nOU6YdBoNDiOc4+PYEwkjFmGqUFlq1QqCbFnrjFNU5Zl9/XEWNgd/U6lmKsb92uwI0XbtmmQMPx81H060FYjPhwB2A8fPsTO7TRuXFGUarUaiEkzEoAo9vt9ZJnheX51dXUK3/rDhw+9H4xJr3E/HRwceLmIruvjfO6oxx7VfZY+INQXwpPARooQQoPsY3fqziOmaaKuPnjwIG5bfgN08eTkJG5D5hsoIsdx5+fn7kfiI3L6DyMgSlFExDKuiRDlGzduCIKAXLjohDnTTSPMZ3NzE+qII2u1mqqqm5ubgZg0I8GIYr/fNwwDnWKIv69z/fakxkXiyLLsPSB23EX8JgGZAqz1ROVIuN7QsHW2sbgvaI8nge83UYPXeQThpt5friiK3ld3BEKUoui8pq7rqqpeuXIFfX2Ez6iq+sknn1DDEFyzvLyMxaAYhMiyTAj5/PPPAzRpagITRaxd/fTTT/EgoP9eTlRVdW1tLRAbFEWZPTwEouhrX1Zfi0AIIYVCATUjrnBEX6C7x3HczZs3WUs6Edu28cREUUzsQoidnR20VuyF+oWudvDe3SGELC8vR/mlxyWKuGapVELpgiA4k94RQhBoKgjC+fk5TUZN96ZOSARDMKJIQ4/6/T4hBGlfPM4y8jzfbDYDMcMv46qFruvea4z35fbwp4mimMlksC4n+SMwulBEVdVUKhVgsPFCQgi5evUqejyCICR29s6yLPgqJElKrHInECTMmqK7c/v27ShrQvTRp85rXrp0Cc5CTDTSY6ALNJ4DjSF6GEjRsDiBNv1+X5bl1dVVp85bltVsNkul0vr6+traWr1e73Q6IwWy1+u9fPnSY0Hn5+e5XO7Zs2cjr+PLZkJIOp0+Pj72ddbI63zwwQeCILz33nsjD/j5z39+cHCwtra2tLS0u7vbaDS++OIL/FQsFq9cudLpdGa0ITzefPPNtbU15DH54osvDg4O8EIbjcbp6emLFy/iNjARoLYXCgVBEG7dutXpdHq9Hur/9vb2N77xDS9h1dHT6XTwQjc3N3/0ox/FbU5ysSyr0Wjk8/mVlZVkvsoBKpVKNps9ODjYHUU+nw9QFH/961/v7e0JglAsFjc3Nzc2NlRV7Xa7dHGXZVlffPGFaZp7e3u9Xu/999+HKPZ6vUePHiEb8P7+vmVZ//qv/xqISTMSgCg6h4nDoE8KFzy6A1h4YJrmFF3UcX0c+Dz9zt9gX/Lhv5um6TfjOfJgDVsriiIGWFjBM3AA4n3ma6U8IQTzxxgMJXDOLEo6nQ6NF6hUKiOH0eVyOeFJZXVdz2QyLKJqGGRdgd8LqwtmuZqqqrPk2/IOPtJosgSjhccFTdOkgz+0+Wj2s9ksPR4jxXK5jJXZOAwpgRLymQQgivDDuD9lhKdi5UYqlcLAeYrsLeNEcbqNHsdtlKPrerlc9nUpCu4UDSXqRKlUcrlNSZLmdA82XdexDunCNqa1Wi2dTmNGxOUVDyQMS6bD/Pz8HM0ZMjolfzAUATRCAns1cxw340pizJhEo4txQQh59uwZ5B+oquoM9UA/w7btkfl1Y7ScEoAo+trdmxBy/fp1mn9PURRN07x/gYZhjGx/JUly3wVmnDEjW6jpRBFymM1mfd1arVZLpii22+2JQ3naA8Ati6KY/O0MZwR1hvaC79y540s/DMPgeX5nZyeZqgPfBm4t7O3hEgtesSRJ2LIKXW3MrM9+cQRhJSonHGOAAERR13VfCm/bNsbLdDiVzWbhepo6+xrP8wF2wHVd9xgQi/5OpVKh8cepVKpWqyWkyzMLvjL9Y5cDQRAymQw28Ulmoz8Lpmm+++671DWkqurUISqrq6tJDsOhbn9keU6mkWGAJeR0ruejjz7C3+EVDGR7E/SKAswQyQicwJZkeAfhqWhwsepzfX2dOhsFQZBleWQojQvB9rxM03Tfbtc0TWzOkslk8P3AG1yr1ZaWlhYgnI8QsrS0NMWJx8fHdE0OdvyZ6/4B5mY0TUPgXCaTmUULKb1eDxdMsjTevXuXyoOqqoFnwE8UhmHcunWLfsuhvhQ4UZMcXnfBmUkUX7x4cXp66ndxyXCs6cuXLy3LQsDe6elpqVT6gz/4g3w+n8/nNzc3ETFVrVYbjca1a9cODw8ty3IWOsvqlmfPnmWz2f/5n/8Z+Puvf/3rbrfb7XbPzs4ajUaj0fj2t7+NwC1Yhd3eT09P2+22M6r2+Pj4zTff9GWDZVl/8Rd/MfUtBA4hZHt7+y//8i+nO33gVUqSJEnS2toaIm/Pzs663e6XX34ZrM2BYFlWt9ttt9uNRqNUKr3++uv5fL5QKJRKJUTb/vKXvwy2OBQEle31eklTR0JIr9fDJ1Aqla5evVosFuv1eqPRGBdMPi988cUXZ2dn+/v7hUJhZWVldXX1T//0T5vN5oD/nxCCQMoAiyaE3L9///XXXw/wmowAmUkUm80mz/O+aowoivV63fvxdHdTRVFyuRwNZ0Ivm8Ys0VxB2Jpr4mU1TaO5hTiO297exjiPXjOdTtOJT2QP9+sl9g4hJJ/Ph3Hl6cC0R7BNHvaFpnl8UqkUnjN2U6vVatGv28XUEcCeJxjj4nVHn/QV8+IJD0VGqCGiTvDd3bhxY17CrHRdx2QhRsDIN+L+XdNELYEbk5CF6oxhZhLFo6MjlyWiw0CBpo7gwooW7BmtvoL6XZ3wkxg+BdDL5nI5THB632t0FpKzDSwWt/h6rb7A8/zss88G3h11W1ECH4ggLKhSqezt7Q1UA8wRRva6R2IYBrojwU6QhwQhBDm96AwCvKxhvLhZ0DStUqlsbW3RN453jYwq7udipZ0gCAvsN2YMM5Molkol75N5dFv5qYvr9XrDC1mQnJPWb9u2K95At7Hf72uaNrzjc7FYnKVx9Jutplwue4/gDRWksY+4FcAboXuQDigWYhwURbly5YrqExom6uwqrays0GqQtPYO0gg752XaCcJDzcbTlmUZryCyfgYKwiJaVVWd2VKwGthvVwO98PDGweilJaQ3zKDMJIrOJZkT0XVdEITAawBCWAP/6orF4izBZkgZ7L2PCUd00hroGHH6NkGlUhH8oCjKwBXivicfGIaB8U3chkzDT37yE6eXEkiS5Fy4dnx87Fyd5uX7HV7TRn3yiqLQDL0cxy0tLTkrwNSNQ6PRCHXXJ7QSUyzXZoTKTKJ46dKloOyYGl3Xw1j0s7u7O2MziiGsRz9kq9XivCVQZVwcnj59GrcJs4KdEI6Pj8Wv4tRLOANkVzCLOXKiBBdUVVV7RVD+22KxGPZ0KeYs2YefKKYXxWq1evv27YmHEUKazWYgjqB/+Zd/CWlv+uPj44HtNQLJ6nl2duZxK6uXL19ubW3t7e3NXujUlMvlRMX7MCjf+ta3EPb8ox/9aDFGFS9evOg56Ha7p5NARtkBQp2//L3f+73wLk5pt9vpdPrq1aveU0AzQmV6UfQ4VYAxUCDOKxq8Tvnggw8CcTnu7+9f8M7a2dkZF06UHSMoDMPI5XJzlyx3foms/2GaJsdxH3zwQTTFMdwJffH+7u5uULn+huN6fEX6uFCv1wfiXCzLCqrp2dvbS/6E1v7+fkIifRgudDodTJ5NkdSQkWRqtVpCNk5iTCmK3k1Tx+UAABGDSURBVPOxbW1tBTXnt7a2NnCpfD4fyEix2+0OJCDtdDocF0yPAQsAvNiJpSbR+8cIIaurq4vhl7sIOOOG2FsLHASFRvxgscQlyhIZ45im3cdSNo/jvwCd/sNxB+HNgUEUA6mmCOxWFGXiZ4aFHNE7cmu1GptNnFNu376d2ERxcwqCX1go+IVlGlFEpUlCovf3338/pCtDFAPxoCLXq8cnhpXFsxfqC1EUDw8PIy6UEQgnJyfwpjJpDAQs2I9rmcR0u8wygsW3KNq2vbq6WigU3CtNu93O5XKffPLJDLZ9BULIz3/+86CuNkyn03EGf758+bLZbAaViokQ0m63vXxm9Xo9nU5HvGq71WoFEm3LiB6kJ202m6VSSRCEnZ2dn/70p3EbNa/Ytn3t2rVMJnN+fh6LAY8fP85ms1evXk1UVqCLhm9R9JIMkBCCTRJmMGwQ0zR3d3edRWCnyqCuTwgJKkrWBaRmda/xSCkZqhmMhQT5XB48eBC3IfOKpmlT7FUeLGiIWAsQI/5EkfoW3A8LYyPNYVHkZt4Ie4CBtfZhTH1jzbL7kDGMfNwjQSD4vGRzZviCECJJUvLDnpMDmpRQU9h4BLEFQQXtM/ziWxS9RILouh54U1ur1ZyiiAFrsPu8S5Lk/CQqlcpASOrsIEap1WpNPCakNAVOkGuUBRQsJPDWoJ83kJiCMRI8sYT0EbGfjHNPgmiI+74TgW9RlCQplmZU1/WPP/6Y/i9yPQdbxMA2qmGIYr/fV1X16OjI/ZgIvkyWX2rhIYRomiZJUjqdZuv9k8k4cUJa1Gq1Gp0eeibuZxY6AS/eD3bo5gJ2WAy1CIhiGD2AyJ6SC0ikzoaJCw8hZHt7Gym5WWRj7HjXHk3T7t+/H5q0hUXcDzgAfIji8+fP3Se6bNv+3d/93ZlNipNut9toNBC/Y9t2sVh8/PhxLJY8fPgwvIvrup7JZOZlZyLGjBBCOp0O3Vbetu1//ud/jtuoZPH5559/9tlnIV18Fo15+vRp9E7UUAnpIQeID1GcuKWwKIrVanVWi0ZBCOF5PoJpNmxtEUGHGrn/XQ5YW1sLz4wZN8ZizDvpdFqSpCQsNU4Ioig2Go3ALzu7hAiCgK3xLiyBv5SJ+BDFQqHgHswmimJIjkHy1VjT8HIiRxaQCfV1eZ7lcjk8UWRjxAtOp9PBbsBMGvv9vqqqU4e2odUOTxIqlQqyiIRXxHwR9MsfgQ9RjHHLU2gVaq3fTe39gs3b8G9N08IbUcmyLAjCuNfcaDQkSYqmEjAuJti3GRGqAS75nS9M0+R53vtG5dHLAPaS1HU9+qKTTHhVwqsoEkKuXLky7qdQTey/6sphGIoxVnhlYZ9SWq6Lbs2IruuCIIwbDoa0l5NpmmxkwKAQQiCN7suEFhi0LV6cQ3G1/lijhS4yY5jAq4RXddE0beTOJoSQWq0WbPKaYUzTpEPDCIqjqKoaaoYLl+BPy7IGkgnMDiFEFEW2RRRjANq4GIaBEUncFkUE8ZDpNLbG3oGu65gzituQ5BJgrfAqipIkjQyigTMzynaWEBLZQgKMSmNZz0tCSEzM1iYy3MGa8YuzeAODsHEfeMzN/FfBCjGkUGaMI5BawfX7fS/TCTdu3Pi3f/u34UrD8/zOzk7YOcna7TaKCPDOXXjy5Mnf/d3fobizs7Ow765SqYwchXe73Wq1GtRkz9OnT1Op1M2bNyN4gIw5hRDS6XTq9XqhUJBl+fT0dOEzU9u2PfBFxNaiT+L+/ftPnjyJ24r5YJYqEeLkXFCgNwf3qSiKEaQE1HV9bW0t7FKcrKyshDrVRwiJ5tExFgZEqCYhF2gYkFEbesfckHtjwZYthsfUdWOyKM5YQCBAFC3L4nk+Au+faZqXL1+m/47AW7u7uzvOYTWQfG46vEcTMBgU4piqIIQsUogWAtmcX0Sc7bcfeJ7XNC1uK+aGKerGZFFUVXXkCENRlGgi1jATpmlar9eLbEdsOoGqKEoEM6ZPnz4d9/4C2XaY53k2TGTMAubXP/roo7gNCYaDg4OBLyLu1tsrgiCIosjGi97xWzcmiCIhRJKkYVUwDIPn+Xq97re8KdA0DT4cdO4iTtcZjSi6IEnS7KnPAxluMi4yhBBZltPptCzLUzQ0SaNQKMzjMJEQgkGCoihxGzI3+K0bE0QRq+aHu1SiKAqCENmCX9yYbdvRt+wIr43GcYSVJwNvET30RfJcMeaXu3fvCoIgCEKlUpnrCNV8Pk//HXOb7R8ECaOtYHjEe92YIIo3b97MZDIDyduePXtWLBYj26TN1/0ExfPnz+FBNU2zUChEs6/Fo0eP0un07u6u85YJISsrK1tbWy9evJjimr1e78MPPwzORsZFx7btZrNZKpVoRY3lC50a27avXbv253/+5/05lENKtVpNp9P7+/v/+7//G7ct84H3GuImioSQJERnSJIEG0LKNj6STqfDcZyvRxkI8I0MOGyR/3CKhKXYlS2MTMcMBrBtWxAEePPitsUTWAjf6/VibqRnRtM07P4WtyFzg8ca4iaKaIudTpLofSaEEJrK4dKlS5GVa9s28vBGViJFVdWByBo8hGaz6fdSWPAbwe4ijAsLIUSWZZ7n4VNNvp8fmQ7jbZ2DgiVE9YXHGuImis7U2P1XOhFeJu6RYEbNNE1d13d3d6Msmu7FMaxS0VOr1fyOFAkhLOiUEQ2GYdD04u+9917c5kwm7vaZEQ9e6oabKGJgTv+3Xq97zyUfFBBFQoiiKPv7+1EWje5kv98fGX8bNrNnEsEwMfk9d8bCQAipVCpLS0vJjMEhhFDD4m2OPR7m5XjTNFkkqi8m1hMfGW2KxWL084uEEBSqaVpkoT0DIC14xHvrHBwczDIox8QJGyYyouezzz7z0vREDza9QQR77G3xxAMmHg/a7TbbcNEv7o96rCh+/PHHAydfwKmpbrfbbDYfPXqUyWQiFsV//Md/TKfTP/jBD+hfNE0b2QEnhJyeng7Ex7bb7aOjo4VPXMlIMpZlra+vr6ysfP/735/YEoXN48ePU6nU3bt3+zH5Tgfscf91JOOufHJywvP84eEh8rgyPDLuOY8VxVwuR0+LJtXZSFRV1V4RS+kxeiAxp0vfQqPRGLmTlKZpgiBEPNfLYHiEELK1tSUIgizLMWaQoOutE9IEuzTKLoy7OIIimR/VF2OryrgfaKhnvI44JDkLJNXZFGDlflyLUgbeXKfT8bKTlGVZLHkNI1FYluWMUI3egHa7jdUL/cSI4nS4XB8r+llaVO+Me8ijRVHX9Z2dnf6rNG9xZVTBMjsYEMtIiBBCe7ixuyKR+nWiQlerVTaVyEgghmHIshyLKB4cHNDtPpLWBI9k3Fku10f2MfiWGF4Y9/BHi6Isy8hrit0VhnOPRQNdyR6XKPb7/Vqtpuu6LMtnZ2exGGCapiiKCIUVRXFiAHA+n2cRp4yEc3JyEmUO1UKhQF4l34mRiXZ6Ocvl+oZhsJGiL0a+hdGiKEkSlorXarUYc1UYhiGKIib24rIBKIpyeHgYS9GEEJ7nZVm2LAseEhfvqGmaUaY4YDCmo9VqcRzH87wkSRH04c7Pz/GPaJpXX03wxLM8XpwxBSNfxAhRNAwjm80+f/7cR6VbaDqdzu3bt6NMMjdAu93O5XLvv/8+0jY+ePBg5GG2bW9vbx8fH0dsHoMxBZZlIYfq6urq1tbW3/7t345rpGaBEOKMG4+sYXUp0eNh406ZaM+Pf/zjer0+5c1cSAbexdhAm1KpFHvWUyRkij1sBP7buFZJAkLIxKTksiwLgjD8jhmMhIPpxjCqLiaAoIvRNKkjcT/F18Un2nP//n0WieoX5xMeLYqEEOxj6anehQOibDiOm303wRlBVp3YA23cIYRIksQWZjDmHeR0DKTxQTtG5TaC9tTdmEAu6+VcFonqF+cT5gYet6ZppmlWKpVCoeC/EgYJIQSiOHJxXpRgYUar1YrXDFiCufTYc7EyGCGB8DpBEGb3zWCYSOcso2lSxxHI1bxfBNtesj00vEMf8qAoon8hiiKiT2MEUhRj3CmFEKIoyurqarxmYI8eURSxUJeFmDIWFXhT0+n0LDM4pmligTVt76JpUl2Y/SLe7TEMY5HSv039HKYo5TeiSFcE0kG3p6oXGmj63YMtoySdTsf+TNDzHe4rxLL2i8EIlY8++ggRqtOlF0fUOm09QmpG3ZvXAaY7y/vpA9De81R3kBQCfCAey/qNKPI8D6+Fux3RYFkWx3HHx8fJmcnb2tpKgvbcvXs3k8mkUql0Ov1Hf/RHlmWtrq5ms9nkPCgGIygQoUq9Vi9fvvSYgvjBgweCICDTKQi8AfXVzk40Y9yNzFh6u92e64SoE190GMUNiuLArsJxAVGMPfzVSTqdToIoAvhGMpkMsmcxVyrjIrC7uysIgnsYDn7C/o7Ovwfbek7R1I4zw+V+A7RhviYXfdWKwIseFEXqg/ZlVuBAFL2k+oyMjY2N5IgieRWFhFcWtzkMRhQ8fvwYUzzjpNEwDEEQRo4mg206fTWy7ma43G9QNmiahpw+c8EUFSPY0ke4T4E4Fe+++64WBO+88w6MqdVqfs91Dpt0XR/4+9SDqkKhkBz5IYSIopgcdzeDERlIdIXKj06886dxMWgBtpu+WtiJZoy8R/dfp7ipVCqFyUVFUZK8hNHj/Yb6cr8iipIkKa/I5/OKN2RZ5pIEkvGD4b87f/VFKpWa7lxRFOm/K5VKbWZwEbQLPM9Pcc1qtYp/uFfBReXJkydxm8CYCUIIBoUcxzmTEiNkHR/F8ClOInAnjrN84mETL+LlsgMUi0VooSRJSU4a7v0Gfd2+L74iilOPhIK1iRDy+PFjzn88sRomm5ubPM9PcWI2m42jb+AJPhmoqiq8Wm2iqqrzv2EgSdLwHx88eBB4NZ4C+jU5/8EYifOh6bpOCIEoZjKZ4ec28Jy3t7fDe4knJyfjZj2dhymKMi5sYuDWPMZ5uJhE09zMnSh6PDhAG4IRxcDBnGISQn4oR0dHyXk+/X6fELK6umpZ1hRxp8+fP2+32yNP7PV67Tj44Q9/eHp62mg0jo6O6vX66elps9k8Sgy7u7uFSNjf3y8UCjs7O3t7e+l0Op1OLy8vX46WcrlcrVa/+c1vVkdxcHBQTgCNRqP5inv37jm7eq+//npziJOvks1mT7xxfn7+9BU/+9nPBn792c9+9nSInZ2d7373u5aDL7/8cviw5eVlWZZ7vZ41hGmaT58+/a//+i/Lsi5fvryysmJZFiHEtm3btnGM36nTw8NDPJ85EkXvxwdoAxNFrxwlTBT7/X4+n4/bBMaFwzAMPSaOj48lVzCn8Nprr438yQnHcdOFTdDTAQ2/4F9F74eHKIpLS0v0f3med38awyRcFAdqmq9TAjTjN6Ioy3JylkDYts1Pu2g3JJgoMhgJB+7TkS6QgYYPEWpTY7yCrgI0HBSLxVqtZrjy8OFD/tXOWS7UajVMnbpcsFKpyLKsKIqu6wjycCFKUXR5/kGd4vf6Xhi7S0bsYCY8bit+Q7fbTU6nATBRZDCceBfFpaWlAJtRJ/1+v1QqOTv0zp+ciKI4EAg60masRXa5F+JHG6KcU3R/BRNPCfZg7yRXFBkTIUnqNDAYseNdFM/PzwNsRp30+/3PPvtsZHq5AZMqlQrtZ488AH+v1WrqVzcAmMU8JooTYaLIYDAWBO+iGB7jynW3fNwx7n+fghhF0YvZ3o8P7/0yUWQwGAuCbduNRuPly5fDPwXYaLozrtCJxo87cuKVfXH9+vXbt29PfbpfJr6F4V+93GaoL5eJIoPBWHyCbTfHMa5EvxaO/Cmum5qFiTZ7uU1fj252mCgyGIzFJ9h2cxwjSxxnj4uF4+yP5aZmZOK7mHib7oy82iwGM1FkMBiLzyytpHdGFudijIuFI0+J675mwd1mL0/GnXHFTW0wE0UGg3EhmLqV9MVAWe5muJg37sRYbmpGxtns/pqme62zP5n/A6EUBXFYY8hrAAAAAElFTkSuQmCC" alt="" />
0x3: 内核抢占和低延迟相关工作
1. 内核抢占
我们知道,在系统调用后返回到用户态之前,后者内核中某些指定的点上,都会调用调度器,这确保除了一些明确指定的情况之外,内核是无法中断的(因为外设引发的硬件中断除外),这是不同于用户进程的地方。
这种情况可能会带来"系统体验"的问题,在编译内核的时候启用对内核抢占的支持,可以解决此问题,如果高优先级的进程有事情需要完成,那么在启动内核抢占的情况下,不仅用户空间应用程序可以被中断,内核也可以被中断
2. 低延迟
10. 小结
. 在CPU关中断的情况下,进程的调度是不受影响的,调度器仍然可以正常工作
. 在CPU关中断的情况下,如果主动调用睡眠系统调用放弃CPU权利,这个进程不受影响,因为睡眠的唤醒是依靠信号相关的系统调用完成的,而系统调用的"软中断"响应不受关中断的影响
. 在CPU关中断的情况下,内核是无法响应外设(例如网卡、内存、硬盘)的中断请求的,即如果这个时候内核中发生了一次缺页中断(PAGE FAULT),但是硬盘外设发起的数据传输请求是无法得到响应的(执行失败、或者延迟DELAY),即这个PAGE FAULT无法得到FIX,内核代码在回到之前发生PAGE FAULT的地方准备再次执行的时候,对应的内存页面依然还是无效的,这就导致了KERNEL的一个不一致状态
. 在CPU关中断的情况下,不能使用vmalloc在LKM代码中申请内存,因为vmalloc分配的是一段"可分页内存(pageable memory)",在内存使用紧张的时候,swap可能会将vmalloc分配的一部分内存换出到磁盘上的swap分区中,如果在之后的某个时刻,内核其他地方的代码需要访问这块被换出的内存,就会触发"缺页中断",但是因为缺页中断的响应是响应硬盘外设的中断,这个时候CPU是无法响应这个中断请求的,这有可能导致Kernel Panic
一个好的做法是使用kmalloc来申请内存,但是kmalloc的问题在于它只能申请一段连续的内存,而且上限有限,很多时候不能满足需求,同时,还需要注意使用GFP_ATOMIC标志,这是一个原子操作且保证在分配的时候不睡眠
Copyright (c) 2014 LittleHann All rights reserved
Linux Process Management && Process Scheduling Principle的更多相关文章
- Performance Tuning Using Linux Process Management Commands
[root@bigdata-server-02 /]# ps --help all Usage: ps [options] Basic options: -A, -e all processes -a ...
- Project Management Process
Project Management ProcessDescription .............................................................. ...
- Java Business Process Management(业务流程管理) 初识环境搭建
一.简介 (一)什么是jbpm JBPM,全称是Java Business Process Management(业务流程管理),它是覆盖了业务流程管理.工作流.服务协作等领域的一个开源的.灵活的.易 ...
- linux 终端报错 Out of memory: Kill process[PID] [process name] score问题分析
从Out of memory来看是内存超出了,后面的 Kill process[PID] [process name] score好像和进程有关了,下面我们就一起来看看linux 终端报错 Out o ...
- 【转】bug management process
What is Bug? A bug is the consequence/outcome of a coding fault What is Defect? A defect is a variat ...
- linux内核打印"BUG: scheduling while atomic
linux内核打印"BUG: scheduling while atomic"和"bad: scheduling from the idle thread"错误 ...
- SAP Process Integration - High Level ERP/Integration Process --- Cargill Process Concept Design
Customer Industry: Commercial off-the-shelf (COTS) application ,, Food Ingredients or Agricultural S ...
- [Java][Android][Process] 分享 Process 运行命令行封装类型
我在以前的文章中提到,使用Java不会有一个问题,创建运行命令来创建太多进程后创建进程行语句. [Android] ProcessBuilder与Runtime.getRuntime().exec分别 ...
- Error:Execution failed for task ':app:processAnzhiDebugAndroidTestResources'. > No slave process to process jobs, aborting
环境 Android Studio 3.0 错误 Error:Execution failed for task ':app:processAnzhiDebugAndroidTestResources ...
随机推荐
- FineUI大版本升级,外置ExtJS库、去AXD化、表格合计行、表格可编辑单元格的增删改、顶部菜单框架
这是一篇很长的文章,在开始正文之前,请允许我代表目前排名前 20 中唯一的 .Net 开源软件 FineUI 拉下选票: 投票地址: https://code.csdn.net/2013OSSurve ...
- HTML5 — 让拖放变的流行起来
先上 Demo,尽量用 chrome,代码可参考 Github. 在 HTML5 出现之前,页面元素的拖放需要监听 mousedown.mouseover 以及 mouseup 等一系列事件,然后改变 ...
- C# 7.0 新特性3: 模式匹配
本文参考Roslyn项目Issue:#206,及Docs:#patterns. 1. C# 7.0 新特性1: 基于Tuple的“多”返回值方法 2. C# 7.0 新特性2: 本地方法 3. C# ...
- variable-precision SWAR算法介绍
BITCOUNT命令是统计一个位数组中非0进制位的数量,数学上称作:”Hanmming Weight“ 目前效率最好的为variable-precision SWAR算法,可以常数时间内计算出多个字节 ...
- 网页样式——各种炫酷效果持续更新ing...
1.evanyou效果-彩带的实现,效果如下 注:这个主要用的是Canvas画布实现的,点击背景绘制新的图形,代码如下: /*Html代码:*/ <canvas id=">< ...
- 迷你DVD管理器
import java.text.*; import java.util.*; class DVDSet { String[] name=new String[50]; //定义一个DVD数组 boo ...
- error_reporting()
定义和用法 error_reporting() 设置 PHP 的报错级别并返回当前级别. 语法 error_reporting(report_level) 如果参数 level 未指定,当前报错级别将 ...
- python基础-基本数据类型总结_整型(int)_字符型(str)_day3
一.基本数据类型 1.整型(int) ps1:数字 int ,所有的功能,都放在int里a1 = 123a1 = 456 ps2: int 将字符串转换为数字 # -int # 将字符串转换为数字 ...
- eclipse下package的命名规范
Java的包名都有小写单词组成,类名首字母大写:包的路径符合所开发的 系统模块的 定义,比如生产对生产,物资对物资,基础类对基础类.以便看了包名就明白是哪个模块,从而直接到对应包里找相应的实现. 由于 ...
- 理解 charging ic spec
如何選擇1個適合您的 charging ic 呢? 主要考量以下 parameters charging ic 的 IIN, VIN charging ic 給 battery 的 IIN, VIN ...