现代操作系统：进程与线程（七）

2.3.2 Scheduling in Interactive System交互式系统的进程调度

 

以下算法也可以用于批处理系统，但在这种情况下，使用这些调度算法带来的增益可能无法抵消其带来的额外复杂性。

Round Robin（RR, RR, RR, RR）时间片轮转调度算法

轮循是一种重要的抢占式策略，它本质上是FCFS的抢占式版本。RR的一个优点是，它并不事先知道每个过程需要多长时间，但是大致近似于SJF。

当时间片轮转程序将一个进程转换为运行态时，计时器被设定为q毫秒，参数q是时间片轮转算法的一个关键参数。如果时间过期了（即q时间消耗完毕）则OS会抢占当前正在运行的进程，FCFS + 运行时间控制 = RR。

  • RR抢占需要一个时钟中断，以便OS可以在计时器到期时接管控制权；
  • 当前运行的进程被移动到就绪状态（我最喜欢的图表中的抢占弧），它被放置在就绪列表的最后；
  • 就绪列表前面的进程从列表中移除并转移至运行态；

注意，在FCFS中，就绪列表被当作队列处理。事实上，许多作者将就绪进程列表称为就绪队列。但我不把这个术语用于任意进程调度器。对于一些调度算法，就绪列表不是以FIFO方式访问的，所以我发现术语队列具有误导性。对于FCFS和RR，准备队列这个术语是合适的。

当一个进程被创建或解除阻塞时，它同样被放置在就绪列表的后面（就是进程不管从哪里到达就绪态，都被丢在就绪队列的末尾）。注意，RR的计时器长度是10毫秒，如果你有一份1小时的工作，然后又有一份1小时的工作，这种方法很有效，这是它近似于SJF的意义。

当q的数值变得非常大时，RR接近FCFS。事实上，如果q大于任何进程在终止或阻塞之前运行的最长时间，那么RR就是FCFS。看到这一点的一个好方法是看我最喜欢的图表，并注意三个运行的弧线。它们由三个条件触发：进程终止、进程阻塞（通常用于I/O）和进程被抢占。如果出现的第一个触发条件是永不抢占，我们可以擦除该弧，然后RR变成FCFS。当q的数值变得非常小时，RR接近于后面要提到的PS（Processor Sharing）处理器共享调度算法。

问：我们应该将q设置为多少比较合适？

答：需要权衡。小q使系统响应更快，一个长CPU绑定的作业不能将一个短作业延迟太长时间。大q使系统更高效，因为有更少的进程切换。对于q来说，合理的时间是几十毫秒，或者对于快速系统来说可能是几毫秒。这意味着另一个任务最多可以将您的任务从接收到某些注意的时间延迟q（加上上下文切换时间CS，这远远小于1ms）。

 

PID

ArriveTime

RunTime

A

0

12

B

0

5

C

0

3

D

0

6

当q=1时，平均等待时间18.5，调度产生了26次（一秒一次切换）；A-B-C-D

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

A

0

12

0

20+6=26

26

2.17

B

0

5

1

4*3+3*1+2=17

17

3.4

C

0

3

2

2*4+3=11

11

3.67

D

0

6

3

18+2=20

20

3.33

 

 

 

 

 

18.5

3.14

 

当q=4时，平均等待时间22.5，调度产生了8次（四秒一次切换）。只有等到时钟中断产生才切换，所有即使C在第11秒已经完成了，但是D仍然要等到12秒才能开始。

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

A

0

12

0

26

26

 

B

0

5

4

20

20

 

C

0

3

8

11

11

 

D

0

6

11

22

22

 

 

 

12+5+3+6=26

 

 

19.75

 

 

 

Homework 9

Q：Round-robin schedulers normally maintain a list of all ready processes, with each process occurring exactly once in the list. What would happen if a process occurred more than once in the list? Can you think of any reason for allowing this? RR通常维护所有就绪进程的列表，每个进程在列表中只出现一次。如果一个进程在列表中出现不止一次，会发生什么?你能想出允许这样做的理由吗?

A：显而易见它可以得到N倍的相对于其它进程的运行时间，如果一个进程具有很高的优先级需要被紧急处理时可以在进程列表中以出现多次的形式加快该进程的处理速度。

Q：Give an argument favoring a large q quantum; give an argument favoring a small q quantum.

A：大q希望产生调度的次数足够少，当系统中的进程切换需要花费大量的资源时且每个进程所需要的运行时间都相对较大时可以使用一个更大的q值；而当系统中的进程所需运算时间相对较少即大部分作业为短作业时，可以使用一个更小的q值实现更快的处理效率。

 

Breaking Ties in RR Scheduling打破时间片轮转的平局状态

        假设我们现在希望运行一个就绪的进程（例如，当前正在运行的进程已经终止）。回想一下，在RR中调度就绪列表是一个队列，所以我们应该先运行先进入就绪队列的进程。但是我们应该怎么处理平局呢?（例如，如果同时创建三个进程会怎么样？）我们需要一个打破平局的规则，为了简单起见，在本过程中我们将始终使用下面的tie-breaking规则来打破RR调度中的平局情况。这个规则并没有在实践中使用（但在我的考试和作业中使用）。

Process

Creation Time

A

3

B

1

C

3

202 RR tie-break规则：如果两个或多个进程具有相同的优先级（在RR中，这意味着它们都在同一个周期进入就绪状态），我们将它们按照创建时间的顺序放入队列。如果进入就绪状态的进程也具有相同的创建时间，那么我们将优先级赋予名称按字母顺序排列的进程。对于右边的例子，B的优先级最高，A的优先级次之，C的优先级最低。

 

Homework 10

考虑右边表中的进程集合，所有时间都以毫秒为单位，CPU时间是整个进程所需的总时间（不包括任何上下文切换时间），创建时间是创建进程的时间。P1在问题开始时生成，而P3在5毫秒后生成。假设每个进程都不执行I/O，也就是说，没有进程阻塞。当RR调度使用q=1，如果q=2，如果q=3，如果q=100时，每个进程什么时候结束？首先假设（不现实地）上下文切换时间为零。假设它是0.1。

Process

CPU Time

Creation Time

P1

20

0

P2

3

3

P3

2

5

q = 1ms时，从0ms开始只有P1在就绪队列中，所以0-1，1-2，2-3三个时间片都只能分配给P1，此时在第3ms P2被创建进入就绪态，P1从运行态被转为就绪态，此时它们在同一个周期中进入了就绪队列，按202准则还是P1先运行，所以P2的开始时间是4，此时可以发现3-4给P1，4-5给P2，在5ms时P3进入就绪队列，按202原则P2，P3同时进入队列P3排在P2的后面，那么后面的顺序就开始变成P1-P2-P3了，因此P3的首次运行时间是7，此时P2只要再运行一次就结束了，因此P2在10结束，接下来就是P1和P3轮换。

0-3 P1  /

3-4 P1  P2

4-5 P2  P1

5-6 P1  p2 p3

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

25

25

1.25

P2

3

3

4

10

7

2.33

P3

5

2

7

11

6

3

上下文切换一次消耗0.1s，则整体上出现了8次上下文的切换。

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

25.8

25.8

1.29

P2

3

3

4.1

10.6

7.6

2.53

P3

5

2

7.4

11.7

6.7

3.35

 

        q = 2ms时，P1拥有0-2，2-4两个时间片，当3时P2进入就绪队列，因此P2从4开始拥有4-6的时间片，P3在5时进入就绪队列排在P1的后面，因此6-8的时间片给P1，8-10的时间片给P3，10-12给P2，虽然11时P2已经结束（这里你要问一下老师进程结束后是否直接开始调度工作，如果等待时间片结束就是12，不等待直接调度就是11，先假设11吧）。

0-2 P1  /

2-4 P1  P2

Time = 4ms   P2 P1

4-6 P2  P1 P3

Time = 6ms  P1 P3 P2

6-8 P1  P3 P2

Time = 8ms  P3 P2 P1

8-10 P3  P2 P1

Time = 10ms  P2 P1

10-11 P2  P1

Time =11ms  P1

11- 25 P1  /

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

25

25

/

P2

3

3

4

11

8

/

P3

5

2

8

10

5

/

 

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

25.5

25.5

/

P2

3

3

4.1

11.4

8.4

/

P3

5

2

8.3

10.3

5.3

/

 

        q = 3ms时，P1拥有0-3，3-6两个时间片，然后P2执行6-9，P3执行9-11，剩余的都是P1的时间。

0-3   P1

3 P1 P2

3-6 P1   P2 P3

6   P2 P3 P1

6-9 P2   P3 P1

9  P3 P1

9-11 P3 P1

11 P1

11-25 P1

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

25

25

/

P2

3

3

6

9

6

/

P3

5

2

9

11

6

/

 

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

25.3

25.3

/

P2

3

3

6.1

9.1

6.1

/

P3

5

2

9.2

11.2

6.2

/

 

        q = 100ms时，P1拥有0-20，P2拥有20-23，P3拥有23-25很暴力，切两次。

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

20

20

/

P2

3

3

20

23

20

/

P3

5

2

23

25

20

/

 

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

20

20

/

P2

3

3

20.1

23.1

20.1

/

P3

5

2

23.2

25.2

20.2

/

 

对q=2重做前面的作业，做以下更改。进程P1运行3ms（毫秒）后，阻塞2ms，P1再也不会阻塞。也就是说，P1开始有一个3ms的CPU Burst，然后有一个2ms的I/O Burst，最后它有一个20-3 = 17ms的CPU Burst。P2从未阻塞；P3运行1ms后会阻塞1ms。假设上下文切换时间为零。

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

P1

0

20

0

25

25

/

P2

3

3

3

8

5

/

P3

5

2

8

13

8

/

 

 

 

Processor Sharing (PS, **, PS, PS) 处理器共享调度算法

合并就绪和运行状态，并允许所有就绪作业同时运行。然而，处理器会减慢速度，因此当同时运行n个作业时，每个作业的速度是单独运行时的1/n。

  • 不可能，因为进程切换的开销。
  • 具有理论性（易于分析）。用RR+qà0=PS。确保你理解了最后一点。例如，考虑最后一个家庭作业（没有上下文切换时间，没有阻塞），并考虑q=1, q=0.1, q =0.01等。

我个人感觉按Homework 10的那个例子，q越小相对于1而言就越可以把P2和P3的运行时间提前，那么当q趋近于0的时候，那么就相当于PS。

  • 显示3个进程（A, B, C）的PS情况，每个进程需要3秒的CPU时间。A从时间0开始，B从1秒开始，C从2秒开始。0-1给A，1-2同时处理A和B那么到2时A剩1.5；B剩2.5，2-3开始每一秒每个进程只能少1/3秒，要处理完A的1.5秒实际上需要4.5秒，那么在6.5秒时A被处理完毕，B剩余1，C剩余1.5，然后两秒后B处理完毕，C剩余0.5，再过0.5秒后C处理完毕。因此全部处理完毕需要：1 + 1 + 4.5 + 2 + 0.5 = 9秒。

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

A

0

3

0

6.5

6.5

/

B

1

30

1

8.5

7.5

/

C

2

3

2

9.0

7

/

0-1 A     A left 2

1-2 A+B  A left 1.5  B left 2.5

2-6.5 A+B+C  Ax  B 1  C 1.5

6.5-8.5  Ax Bx C 0.5

8.5-9.0  ax bx cx

  • 考虑三个从时间0开始的进程。一个需要1毫秒，第二个需要100毫秒，第三个需要10秒。计算RR q=1ms、PS、SJF和FCFS的总/平均等待时间。注意，这取决于进程碰巧被处理的顺序。这种效应对于FCFS是巨大的，对于具有适度q的RR是适度的，而对于PS和SRTN则不存在。

FCFS：不稳定的，如果ABC顺序改变总等待时间会变得很大；

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

/

A

0

1

0

1

1

/

B

0

100

1

101

101

/

C

0

10000

101

10101

10101

/

 

 

 

 

 

sum:10203

avg:3401

 

SJF：按这个顺序刚好等于FCFS，但是稳定的；

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

A

0

1

0

1

1

/

B

0

100

1

101

101

/

C

0

10000

101

10101

10101

/

 

 

 

 

 

sum:10203

avg:3401

 

RR：中庸，谁先谁后造成的影响实际上并不大；A最迟也能在3做完；

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

A

0

1

0

1

1

/

B

0

100

1

1+99*2+1=200

200

/

C

0

10000

2

10101

10101

/

 

 

 

 

 

sum:10301

avg:3433.7

 

PS：和SJF一样是稳定的；

JobID

ArriveTime

RunTime

StartTime

FinishTime

WaitTime

PowerWait

A

0

1

0

3

3

/

B

0

100

0

3+99*2=201

201

/

C

0

10000

0

10101

10101

/

 

 

 

 

 

sum:10302

avg:3434

0-3 ABC

3-3+99*2 AB

201-201+9900 A

Homework 11

CDC 6600计算机可以使用一种称为处理器共享的有趣的循环调度形式同时处理多达10个I/O处理器。进程切换发生在每条指令之后，例如指令1来自进程1，指令2来自进程2，等等。进程切换由专用硬件完成，开销为零。如果一个进程在没有竞争的情况下需要T秒才能完成，那么如果n个进程使用处理器共享，需要多少时间?

n*T

 

Variants of Round Robin 轮询的变体

  1. q状态依赖的时间片轮转：
  • 与RR相同，但q随系统状态动态变化；
  • 操作系统可能倾向于占用重要资源的进程，例如，不可交换内存；
  • 也许这应该被视为中期调度，因为你可能不会每次都重新计算q；
  1. 外部优先级：

RR，但进程可以以更高的优先级以得到更大的q，也就是说，一个进程可以获得比另一个进程更高的优先级。但这不是一个绝对的优先级:低优先级（即不那么重要）的进程可以运行，但没有高优先级的进程运行得多。

 

Priority Scheduling优先级调度算法

每一项工作都（以某种方式）被分配了优先级。

  • 优先级分配可能处于调度程序的外部，很显然如果你支付的越多那么对应的进程会具有一个更高级别的优先级，类似于上面提到的外部优先级；
  • 有时候高优先级认为是重要的任务，有时候小优先级被认为是重要的任务（基于基准定义）。Priority:1 2 3 4 5(high)；1 2 3 4 5(low)
  • 如果许多进程都具有最高的优先级，那么对这些进程一起使用时间片轮转调度算法。实际上我们会将优先级分组，然后在每个组中分别使用时间片轮转调度算法；
  • 优先级很容易让一些进程陷入饥饿，饥饿可以通过一些标准化的技术来避免；
  • 一种变体是动态更改优先级，以支持持有重要资源的进程（类似于上面的状态依赖RR）；
  • 许多策略都可以被认为是存在优先级调度的，例如：a. FCFS和RR都是基于到达时间的优先级调度，其优先级就是进程进入就绪列表的时间；b. SJF和SRTN是剩余时间优先级调度，其优先级就是每个任务完成CPU所需要运行的时间。

 

Two Examples to Do in Class课堂上要做的两个例子

  1. 1.      有A，B，C三个进程，每个进程的CPU Burst是3个时间单位且I/O Burst也是3个时间单位，显示FCFS调度算法的就绪队列。2-3-1  1-3-2
  2. 2.      使用q=2时的RR算法实现上述三个进程的调度流程。

我不太清楚每个进程在什么时候会出现一个I/O Burst，那么假设每个进程都是1-3-2的Burst Circle。

 

细节：

（1）      I/O硬件中断需不需要产生调度？新进程进入要不要调度？

（2）      I/O硬件中断的时候存不存在一个小顺序，就是Running先然后Blocked后？

0-1   A

1-2 B

2-3 C

3-4 /

4-5 A

5-6 A

6-8 B

8-10 C

 

Priority Aging—The Standard Technique to Prevent Starvation优先老化，防止饥饿

当有进程等待时，我们将不断提升它的优先级；因此，它最终将拥有最佳优先级，然后运行。

  • 饥饿意味着在一段时间之内，一些进程永远不会运行，因为它从来没有最高的优先级。正式的说法是，如果没有工作可以永远处于就绪状态，那么系统就不会挨饿；
  • 优先老化是用来防止饥饿的标准技术（假设所有的工作都终止了，或者策略是优先的）；
  • 可能有许多进程具有最大优先级；
  • 如果是，可以使用FIFO（如果一个工作没有终止，就有饿死的风险）或RR（抢先的等价）调度最大优先级；
  • 优先级老化类似于优先级调度，优先级是输入到就绪列表的时间。也就是说，它与FCFS/RR有相似性。
  • 我们可以将优先级老化应用于许多策略，特别是上述的优先级调度。

 

Homework 12

44. Five jobs are waiting to be run. Their expected run times are 9, 6, 3, 5, and X. In what order should they be run in order to minimize average response time? (Your answer will depend on X.)

首先确定调度方式，SJF是平均等待时间最小的进程调度算法，9，6，3，5，X，那么X可能位于哪些位置就有几种答案。

  1. X 3 5 6 9  
  2. 3 X 5 6 9  
  3. 3 5 X 6 9
  4. 3 5 6 X 9
  5. 3 5 6 9 X

 

45. Five batch jobs A through E arrive at a computer center at almost the same time. They have estimated running times of 10, 6, 2, 4, an 8 minutes. Their (externally determined) priorities are 3, 5, 2, 1, and 4, respectively, with 5 being the highest priority. For each of the following scheduling algorithms, determine the mean process turnaround time. Ignore context switching overhead.

a.     Round robin.

b.     Priority scheduling.

c.     First-come, first-served (run in the order 10, 6, 2, 4, 8).

d.     Shortest job first.

对于（a）假设系统是多程序的，并且每个作业都得到它公平的CPU份额。（请注意，当书中说RR与每个进程获得公平的共享时，它的意思是处理器共享PS）；对于（b）到（d），假设一次只运行一个作业，直到它完成。所有的作业都是完全CPU绑定的。

RR à PS

JobID

ArriveTime

RunTime

Priority

StartTime

FinishTime

WaitTime

A

0

10

3

0

30

30

B

0

6

5

0

24

24

C

0

2

2

0

10

10

D

0

4

1

0

18

18

E

0

8

4

0

28

28

 

 

 

 

 

 

Avg:22

Priority scheduling

JobID

ArriveTime

RunTime

Priority

StartTime

FinishTime

WaitTime

A

0

10

3

14

24

24

B

0

6

5

0

6

6

C

0

2

2

24

26

26

D

0

4

1

26

30

30

E

0

8

4

6

14

14

 

 

 

 

 

 

Avg:20

FCFS

JobID

ArriveTime

RunTime

Priority

StartTime

FinishTime

WaitTime

A

0

10

3

0

10

10

B

0

6

5

10

16

16

C

0

2

2

16

18

18

D

0

4

1

18

22

22

E

0

8

4

22

30

30

 

 

 

 

 

 

Avg:19.2

 

SJF

JobID

ArriveTime

RunTime

Priority

StartTime

FinishTime

WaitTime

A

0

10

3

20

30

30

B

0

6

5

6

12

12

C

0

2

2

0

2

2

D

0

4

1

2

6

6

E

0

8

4

12

20

20

 

 

 

 

 

 

Avg:14

posted on 2022-01-06 14:47  ThomasZhong  阅读(93)  评论(0)  编辑  收藏  举报

导航