第三章 处理器调度与死锁－－笔记

处理器调度

原因

       处理器调度的好坏会影响系统性能，像吞吐量和响应时间（这个自不必说）

层次

高级调度

      又称作业调度，以作业（Job）而不是进程作为调度对象，粗暴来讲 Job = 程序 + 数据 + 作业说明书 ...

      Do What：将外存上的后备队列中作业掉入内存，为之新建进程，插入内存就绪队列。

中级调度

       以对象为进程

       Do What: 将内存中的进程挂起到外存，将外存中的进程掉入内存，插入就绪队列。

低级调度

       又称进程调度，以对象为进程

       Do What: 1. 保存CPU上下文信息，如PC、寄存器等到PCB中

                       2. 按算法选取内存就绪队列中的进程

                       3. 为选中的进程恢复CPU上下文信息，PCB中的信息到PC、寄存器等中

       调度方式: 1. 非抢占, 已获分配处理器的进程不得被其他进程剥夺，直至完成或发生某事件，如I/O，P操作阻塞等

                        2. 抢占，抢占原则：优先级、短进程优先、时间片

                          （书上把“时间片”列为抢占原则中的一个，我觉得欠妥，因为用到事件的调度算法主要是轮转和多

                             级反馈队列，轮转不涉及抢占，多级反馈队列虽然有抢占，但是只是在高级队列中的进程可以抢

                             占低级队列中的进程，当一个进程用完他的时间片却还没执行完毕时，他会掉到下级反馈队列的

                             末尾，感觉时间片和抢占没什么关系的样子。）

既然，调度分三种，那么自然不同的调度方式，就会有不同的调度模型啦。下面主要介绍三种模型：

华丽丽的分割线。。。

-------------------------------------------------------------------------------------------------------------------------

调度模型

低级调度模型

          上图 ! 结合概念，看看图中的模型：

          低级调度模型里面的就绪队列是使用FCFS的，维护无耗费

            

高级、低级调度结合模型

           这个模型里面的就绪队列是按优先级，使用优先队列维护的，每次维护的复杂度为O(logn)

           

高级、中级、低级调度结合模型

           这个模型就更复杂了，加入了中级调度之后，比上面一个模型，多了两个步骤：把就绪挂起队列添加到内存就     绪队列的末尾；把内存就绪队列挂起到外存。图就不画了，想看看书上的。@参考文献 [1]

调度算法准则

          面向用户

                  平均周转时间、平均带权周转时间、响应时间、截止时间、优先级......

                  (周转时间 = 完成时间－到达时间, 响应时间＝等待时间＋服务时间, 带权周转时间＝周转时间 / 服务时间)

          面向系统

                  吞吐量、CPU等资源的利用率

常见调度算法

FCFS

                 先来先服务，利于长作业、长进程，CPU密集型。

S(J)PF

                 用于作业：SJF－－最短作业优先－－从外存的后备队列中挑选估计运行时间最短的作业，纳入内存，新                                       建进程，插入就绪队列末尾。

                 用于进程：SPF－－最短进程优先－－从内存就绪队列中挑选～～最短的进程，分配处理器，运行。

高优先权优先调度

                 用于作业：从外存后备队列选取若干最高优先权的作业，纳入内存，新建进程，插入就绪队列末尾。

                 用于进程：从内存就绪队列中选取最高优先权的进程，分配处理器，运行。

                 Extra：优先权分为：静态优先权、动态优先权；分为抢占的，和不抢占的。

高响应比优先调度

                 响应比：Rp = (等待时间＋服务时间)／服务时间＝响应时间／服务时间

                 考虑周到－－考虑了先来先服务的准则（服务时间相同时）、照顾短作业（等待时间相同时）、长作业不                    会完不成（等待时间增减，Rp增加）。

轮转

                 按FCFS排成一个队列，每个进程获得一个时间片。若当前执行进程的时间片用完却没执行完毕，就插入                     到就绪队列末尾。

                 时间片过短－进程多次获得处理器，上下文切换频繁，开销大

                 时间片过长－每个进程一次就执行完，蜕化成FCFS了

多级反馈队列调度

                 看图 !  越往下的就绪队列，优先级越低，但是其中进程能获得的时间片越长，最后一个就绪队列使用轮                      转，此种调度方法不需知道进程的服务时间。里面的流程，请自行脑补。

           

死锁

原因

         1. 竞争非剥夺资源

         2. 进程间推进顺序非法

必要条件

         1）互斥条件 

         2）请求和保持条件（进程占有了某些资源，还想请求某些资源）

         3)  非剥夺资源 

         4）环路等待条件 －－其实 2) 、 4)  是等价的

解决办法（简要）

         （1）死锁预防：至少破坏一个死锁必要条件

         （2）避免死锁：防止系统进入不安全状态

         （3）死锁检测 和 解除：动态检测死锁，确定与死锁有关的进程和资源－－找到所有的 "进程－资源环"（自己                     编的），解环－－挂起一些进程，拿走资源，让剩下的进程继续运行

                你自己推一推就会发现，诶 ?  好像死锁预防的破坏条件，和避免死锁的防止进入不安全状态差不多嘛 ! 的            确是差不多，书上说死锁预防的效果好一些，但是牺牲了进程的并发。

解决办法（具体）

（1）死锁预防

         1. 消除 “请求和保持条件”：如果不能为一个进程一次性分配所有需要的资源，那么一个也不分配

         2. 消除 “非剥夺资源”：允许运行中的进程的资源被抢占

         3. 消除“环路等待条件”：为所有的资源编号，每个进程必须按序号递增的顺序请求需要的资源。

（2）避免死锁

安全状态:

       所谓安全状态，是指系统自此状态出发，能够找到某种进程顺序，为每个进程分配资源，最后使得所有进程顺利执行的状态。进入了不安全状态就代表即将死锁。关键在于：如何使系统不进入不安全状态。

银行家算法:

               这是Dijkstra提出的，避免死锁的经典算法。好像还沿用至今，用于银行的现金贷款。算法非常直观。华丽丽的分割线。。。

-------------------------------------------------------------------------------------------------------------------------

算法简述:

设资源数目为m、进程数目为n

-------------------------------------------------------------------------------------------------------------------------

involved data structure:

      Available:    长度为m的一维数组，Available[j] 表示系统现有 j 类资源的个数

      Max:            nxm矩阵，Max[i][j] 表示进程 i 需要 j 类资源的最大数目

      Allocation:   nxm矩阵，Allocation[i][j]表示进程 i 已获得 j 类资源的数目

      Need:          nxm矩阵，Need[i][j] 进程 i 仍需 j 类资源的数目

-------------------------------------------------------------------------------------------------------------------------

Banker's Algorithm:

      1. Main Algorithm

      进程 i 发来请求，说需要  j 类资源，个数为

      (1)  若     则 跳至 (2)；否则出错

      (2)  若    则跳至 (3)；否则 Pi 须等待

      (3)  试探，把资源分配给进程 Pi，修改下列数据结构的值 (先备份)

            

            

           

     (4) 检测安全性，若安全，则真正如此分配；若不安全，撤销操作。让进程 Pi 等待去吧

     2. Algorithm for checking safety           

      1. 初始化两个数组: work := Available、finish := false;

     2. 若能找到满足两个条件的进程：(1) finish[i] = false; (2) Need[i][j] <= work[j]；执行步骤 3，否则执行步骤 4

     3. Pi 获得资源顺利执行； work[j] = work[j] + Allocation[i][j]；finish[i] = true; 跳至步骤 2

     4. 如果对所有的i，finish[i] = true，则表示处于安全状态，否则处于不安全状态

-------------------------------------------------------------------------------------------------------------------------

（3）死锁检测 和 解除

         死锁检测:

         1. 画资源分配图

         2. 死锁定理:  S状态为死锁状态的充分条件－－S状态的资源分配图是不可完全简化的

         嗯，你发现我在水了吧－－图的结构没说啊 ?!  怎么简化啊 ?!  这部分的内容请看 文献[1] P112~113

       

         死锁解除:

         常采用的解除死锁的两种方法: 

 (1) 剥夺资源：从其他进程剥夺足够数量的资源给死锁进程；我称之为强势解环

         (2) 撤销进程：逐个撤销死锁进程，直至死锁消失；我称之为暴力解环

References:

[1] 计算机操作系统（第三版）汤小丹、梁红兵、哲凤屏、汤子瀛 编著