OS-Revision-处理机调度

处理机调度

这一章相对来说比较简单，主要考点就是调度算法。
而这些算法都是建立在初等数学的基础上的，不会特别难，一定要注意理解并且做题一定要细心。

概念

调度的本质就是一种资源分配。
而我们设计调度算法其实就是在设计一种处理机的分配策略。

调度层次

1.高级调度：
实现的功能是根据算法，将处于后备队列的作业从外存调入内存。同时为其创建进程、分配资源、放入就绪队列。
以作业为对象。

2.低级调度
低级调度就是我们的进程调度，其实就是根据算法从我们的就绪队列中挑选出进程分配处理机资源进行处理实现。
以进程为对象。

3.中级调度
其主要操作就是把暂时无法实现的进程地调出到外存，这样可以防止进程占用宝贵的资源。进程也就因此会处于"挂起"状态。而这些进程一旦又具备运行条件后也会由中级调度调回内存。
以进程为对象。

可以用下面一张图来表示三种调度的关系：

算法目标

1.资源利用率
ratio = CPU有效工作时间 / (CPU有效工作时间 + CPU空闲等待时间)
2.公平性
诸进程都应较为平等地获得处理机调度，但公平相对而言的，因为任务与任务间都重要性和紧急程度的区别。
3.平衡性
系统中有多类型的进程，或计算型、或I/O型，这种情况下我们应该保持CPU的相对繁忙。
4.策略强制执行
比如对于执行过程中制定的安全策略，必须要强制准确地执行。

对于用户而言，我们希望的算法拥有的特点：
1.平均周转时间短、平均带权周转时间短。
周转时间 = 作业完成的时间 - 作业进入就绪队列的时间
带权周转时间 = 周转时间 / 作业所需要的服务时间
2.响应时间快
总时间 = 数据从键盘输入到传送到处理器 + 处理器处理数据 + 会送到显示屏 的时间
3.截止时间的保证。
截止时间指某个任务的最晚开始时间或者最晚完成时间。实时系统中对此有很高的要求，否则会产生不可预料的后果。
4.优先权准则。

对于系统而言：
1.系统的吞吐量要高。
吞吐量指在单位时间内系统完成的作业数。
2.处理机的利用率高。
3.各类资源的平衡利用。
和上面讲过的平衡性类似。

前面用加粗字体表示了两个重要的“时间”概念。
而还有一个时间就是平均等待时间：
等待时间 = 获取到CPU的时间 - 进入就绪队列的时间
但计算这个时间有一点麻烦的就是：
在时间片轮转算法、多级队列反馈等算法下，一个作业无法一次性完成，那么会多次进入就绪队列，所以考得也比较少，因为比较麻烦。

调度算法

FCFS first come first serve 先来先服务调度算法

那么实现起来也很简单，我们对进程进入就绪队列的时间进行排序。按照时间从小到大分别进行执行即可。

优点很明显：实现起来较为简单，毕竟只要用到C语言最开始学到的冒泡排序即可。有利于长时间作业。
缺点就是不利于短时间作业。
例题如下：

先按照到达顺序排个序，就是A--B--C--D
A--
start:0   end:0+1 = 1
B--
start:max(A.end, B.arrived) = 1, end:1 + 100 = 101
C--
start:101, end:101 + 1 = 102
D--
start:102, end:102 + 100 = 202

周转时间就是： end - 到达时间
带权周转时间： 周转时间 / 运行时间（即我们概念里的服务时间）

验算一遍，得到下表的正确答案应该没什么问题：

SJF short job first 短作业优先调度算法

也是很简单的一种算法，我们为在调度队列里的进程根据其所需要的服务时间从小到大排序。还有一点要注意的就是当前时间是否可以执行此任务，就比如我们按序排好服务时间最少的是一个任务A，其arrived-time是10000，serve-time是1。
那么我们难道等到10000后来执行它？显然不可能。
因此这个排序是要基于到达时间和服务时间的联排，都是从小到大。
要维护一个变量就是当前时间，然后去寻找当前时间下可以运行的所需服务时间最少的任务。

优点：好的地方也是简单易于实现，且会对短作业很友好。
缺点：显然得对长作业不友好，且其实我们要事先知道进程的执行时间是一件比较困难的事。未考虑到作业的紧迫性这一特点。

例题：

FCFS我们就不再看了，主要看SJF。

当时间为0时，第一个任务A进入，虽然其服务时间不是最少的，但此时此刻只能运行它！
所以：
A--
start:0  end:0+4 = 4
当前时间为4，B C D E均已进入就绪队列，所以自此之后不断挑服务时间最少的即可
D--
start:4  end:4+2 = 6
B--
start:6  end:6+3 = 9
E--
start:9  end:9+4 = 13
C--
start:13 end:13+5 = 18

周转时间就是： end - 到达时间
带权周转时间： 周转时间 / 运行时间（即我们概念里的服务时间）

也很简单，就是要注意刚刚说的那个点，记得看当前时间和到达时间！

HRRN high response ratio next 高响应比优先算法

这个子算法归类于“高优先权算法”，只不过这里优先权被我们的响应比所具体化。

对于高优先权算法，我们可以分为两类：
1.非抢占式优先权算法
2.抢占式优先权调度算法
这里对何为抢占式进行一个简略的解释：
进程调度的非抢占方式：
系统一旦将CPU分配之后，一直到进程执行完成或自动进入阻塞状态
就是我们的FCFS,SJF,都是得到CPU后一次性就完成了。
进程调度的抢占方式：
只要进入就绪队列的进程优先权高于正在CPU上运行现进程的优先权，则将现进程放到就绪队列尾，并运行最高优先权进程
后续几种算法的困难点 ，就是当前在运行的进程会被打断。

优先权也可以进行分类：
静态优先权：创建进程时已确定并在运行过程中不变
相关因素：进程类型、进程对资源的需求、用户要求

动态优先权：随进程的推进或等待时间增加而改变
例如等待时间越长则提高优先权

静态优先权的题目就非常简单，和FCFS一样，根据分配的优先权进行排序，按序逐一进行即可，下面这个例题就不再赘述了：

然后着重来讲一下高响应比优先算法，此算法着重需要我们计算的就是响应比。
ratio = 响应时间 / 要求服务时间 = (要求服务时间 + 等待时间) / 要求服务时间 = 1 + 等待时间 / 要求服务时间
等待时间忘了的可以往前面翻一翻。

例题：

答案不重要，重要的会算响应比哈！

时间刚在800时，只有A进入，那么其余响应比均为0。
对于A：ratio = 1 + （800 - 800）/200 = 1
直接就运行A
A--
start:800  end:800+200 = 1000
时间到了1000，其余任务均已进入，要对这三个均进行响应比计算：
B.ratio = 1 + (1000 - 850) / 50 = 4
C.ratio = 1 + (1000 - 900) / 10 = 11
D.ratio = 1 + (1000 - 950) / 20 = 3.5
显然选最高选到了C
C--
start:800  end:1000+10 = 1010
以此类推即可，考试的时候千万小心别算错。

考试的时候还有一点就是这个1可以不加，少点麻烦。
当然，如果让那个你填表，那还是加上去吧，省得出错。

优点较多，懒得写了，缺点的话就是一直要算算算比较麻烦，直接上图：

RR Round Robin 时间片轮转算法

操作的具体步骤如下：
仍旧是将进程根据arrived time进行从小到大的排序。
第一个进程会先拿到时间片，但如果此进程在时间片内未能结束，即要求服务时间 > 时间片，那么此进程会先中断并且进入就绪队列的尾部。

此算法~~（是抢占式的！）~~ 很值得注意的一点就是，假设一个进程的剩余的所需服务时间加入比时间片要小，当此进程完成后，那么系统会立即执行切换：重新调度一个进程，分配新的时间片。

时间片长度的选取也要有讲究：
长度过长的话会退化为FCFS，但不能太短，否则会频繁进行系统调度和上下文切换会增大开销。

例题如下：
答案是错的！！！

比较容易，我们算一下。
【这里的第二个时间片B执行完是11s，而D刚好11s进入，我是默认B在就绪队列的后面，即到达的先插入，老师说都可以应该。A C B D也行。】

1. A 剩余10 - 3 = 7，当前时间 = 5 + 3 = 8，就绪队列 B A
2. B 剩余16 - 3 = 13， 当前时间 = 8 + 3 = 11，就绪队列A C D B
3. A 剩余7 - 3 = 4，当前时间 = 11 + 3 = 14， 就绪队列C D B A
4. C 剩余4 - 3 = 1，当前时间 = 14 + 3 = 17，就绪队列D B A C
5. D 剩余8 - 3 = 5，……，就绪队列B A C D
6. B 剩余13 - 3 = 10，……，就绪队列A C D B
7. A 剩余4 - 3 = 1，……，就绪队列C D B A
8. C 剩余1 - 1 = 0，……，就绪队列D B A 【只用了1s时间片立马切换！】
9. D 剩余5 - 3 = 2，……，就绪队列B A D
10.B 剩余10 - 3 = 7，……，就绪队列A D B
11.A 剩余1 - 1 = 0， ……，就绪队列 D B，同样立马切换
12.D 剩余2 - 2 = 0，……，队列B，立马切换
13.B 剩余7 - 3
14.B 剩余4 - 3
15.B 剩余1 - 1

对于第二小题，就是18s时有新任务的加入。
我们主要注意在第五个时间片的处理，因为18s就在这个时段
第五个时间片的就绪队列跟上E后面一致。

1. A 剩余10 - 3 = 7，当前时间 = 5 + 3 = 8，就绪队列 B A
2. B 剩余16 - 3 = 13， 当前时间 = 8 + 3 = 11，就绪队列A C D B
3. A 剩余7 - 3 = 4，当前时间 = 11 + 3 = 14， 就绪队列C D B A
4. C 剩余4 - 3 = 1，当前时间 = 14 + 3 = 17，就绪队列D B A C
5. D 剩余8 - 3 = 5，当前时间 = 17 + 3 = 20，就绪队列B A C E D

求周转时间那些量时可以画上一个时间轴，以免搞错。

接下来就是对RR算法的分析。
这是一种很适合实时系统的调度算法，且时间片越长越有利于缩短周转时间。但正如前面说的，太长的时间片就会退化为FCFS。
其是有利于交互性、事务性的进程的，也有利于I/O繁忙的进程。
缺点是调度开销大，一个进程在一个时间片完成不了要多次进行调度。

多级反馈队列调度算法

自己写也嫌麻烦，可以看一下图示：

我们设置多个队列，队列特性上面有讲到。
队列内部采用的仍旧是FCFS的调度算法，还有一点要注意的就是这同样也是一种抢占式的调度算法。
队列之间更像是结合了时间片和优先级的优势，即如果某进程在第一个队列完不成的话就会逐级掉落到下面的队列里，同时下面的队列优先级较低。

抢占规则：
低级队列只有等高级队列变空才能执行，例如如果第一队列里面有进程，第二队列里的进程不会调度，必须等第一队列变空才会调度第二队列里的进程
当高级队列有新进程进入，而当前是低级队列的进程运行，将立即发生抢占，被抢占进程放回低级队列末尾，记录进程剩余运行时间和在当前队列的剩余使用时间。

此算法的性能分析：

看一道例题：

t = 0时，只要A进程。
A先进入第一队列，花光时间片2，自己没结束（还剩7 - 2 = 5）且没有新进程进入。
所以A掉落到第二队列继续执行，虽然可以执行4，但执行到3时，B进程进入了！
所以被迫中断，因此t = 5时，A剩余2，第二队列可用时间片只剩1！

B运行完第一队列的时间片，C已经进入。
所以时间t = 7时，B剩余2，第二队列可用时间为4，且第二队列的就绪队列为 AB。

C完成第一队列，D并未进入。
t = 9时，C剩余11， 第二队列可用时间为4，第二队列的就绪队列为 ABC。

所以会先为A完成剩余的第二队列的1，然后A掉入第三队列。
t = 10时，A剩余1，第三队列可用时间片8，第三队列就绪队列A，第二队列就绪队列BC

还有2的时间D才会进入，所以会先执行第二队列的B。
t = 12时，B完成！ 第二队列就绪队列C，第三队列就绪队列A，D进入。
t = 12 B完

t = 14时，D剩余7，第二队列可用时间片4，第二队列就绪队列为 CD。

t = 18时，C剩余7，掉入第三队列。第三队列就绪队列AC
t = 22时，D剩余3，掉入第三队列，就绪队列ACD。

t = 23 A完
t = 30 C完
t = 33 D完

结束

实时调度

实时调度几个关键词：
开始截止时间：必须在指定时间之前开始
完成截止时间：必须在指定时间之前完成
实时任务：必须在截止时间之前开始或结束

系统处理能力的度量：

基本写题时不会故意给你一个没法处理的情况，这样考没意义。
但道理从假设里并不难看出，我们要求50s内完成，但最短都需60s，单处理机无法并行，所以无法执行。
基于此我们有上面那个公式：
所有任务的 处理时间 / 周期时间 求和只要小于等于1就可以处理。

刚刚我们强调了是单处理机，多处理机的话只要把1改为N处理机数目即可。

实时调度采用的是抢占式调度的机制。不能抢占的话如果某个进程的运行会耽误另外一个的截止时间却又无法中断它，那势必产生影响。
同时需要具有快速切换机制，可以从两方面看：
对中断的快速相应能力
快速的任务分配能力

实时调度算法的分类
1.非抢占式调度：比如非抢占式轮转调度，如RR。 非抢占式优先调度，就是为某些任务分配较高的优先级，然后根据优先级排序优先运行这些进程。

2.抢占式调度
基于时钟中断的抢占(毫秒)：
如果某进程优先级高于当前正在运行的进程，但并不会立马发生抢占。而是等到时钟中断后才将处理机分配给这个高优先级进程。
立即抢占(微秒)：
可以立马剥夺当前正在运行的进程的资源分配给请求中断的紧迫任务。

EDR 最早截止时间优先调度算法

根据任务的开始截止时间确定任务优先级
开始截止时间越早，优先级越高

给了一张比较简单的例图：这是非抢占式哈！

刚开始时只有任务1进入，运行A。
A完毕后，2和3均已进入。经检查，3的开始截止时间比2早，于是先运行3。
以此类推，比较好理解。

LLF 最低松弛度优先算法

概念理论的东西还是有点多，直接上图了，因为比较好理解：

因为这就是基于松弛度的，所以我们一定要理解的就是松弛度计算方式。
相当于是 开始截止时间 - 当前时间。

松弛度为0的时候一定要发生抢占，否则那个任务就无法在最晚截止时间完成！
接下来就看一道例题：

我们可以自行分析一下：

一开始时，A1要求在20完成，B1要求在50完成。
LaxityA1 = 20 - 10 = 10
LaxityB1 = 50 - 25 = 25
显然A1更紧迫，所以A1会运行至结束。

t = 10时
LaxityA2 = 40 - 10 - 10 = 20
LaxityB1 = 50 - 25 - 10 = 15
B1更加紧迫了，所以调度B1进行运行！

注意一点就是t = 30时
LaxityA2 = 40 - 10 - 30 = 0
LaxityB1 = 50 - （25 - 20） - 30 = 15 
所以会立马发生抢占！分配给A2运行

然后就到t = 40时
LaxityA3 = 60 - 10 - 40 = 10
LaxityB1 = 50 - 5 - 40 = 5
B1运行

t = 45时
LaxityA3 = 60 - 10 - 45 = 5
LaxityB2 = 100 - 25 - 45 = 30

然后就是A3立马运行，运行完10， t = 55
就是这样，以此类推

这里要自己掌握老师上课讲的“埋雷法”，就是在松弛度为0的位置埋上一颗雷。
防止自己错过呀，最后结果用一张表格来展示的话如下：
这张表格相对我们的分析做了一些优化：
就是有几个时间段，下一个A或者B根本还没开始，但用我们算松弛度的方式也是可以嗒，毕竟是初等数学，也没啥难的。

上表还可以画成更好看的一张图，如下所示：

emmmm，处理机调度还没结束，还有一点死锁的内容。
里面还涉及了迪杰斯特拉的银行家算法等等，也还挺重要的，明天补完！