操作系统期末大题复习

目录

 

处理器调度算法计算题

PV操作

PV互斥信号量

互斥信号量

银行家算法

死锁检查算法

缺页置换算法

分页管理

段式存储管理

页式管理


处理器调度算法计算题

1.设有按P1、P2、P3、P4次序到达的4个进程,CPU阵法时间如表所示,采用先到先得服务算法和最短作业优先算法,画出甘特图,并计算各自的平均等待时间。

进程 CPU阵发时间/ms
P1 20
P2 8
P3 5
P4 18

(1)采用先到先得服务算法,甘特图如下:

   P1 

P2

P3

P4

     0                                     20        28        33                                                                                 51 

 平均等待时间=(0 +20+28 +33 )/4 ms = 20.25 ms。

(2)采用最短作业优先算法,甘特图如下:

P3

   P2

P4

P1

    0         5                         13                                         31                                                        51 

    平均等待时间=(0+5+ 13 +31)/4 ms = 12.25 ms。

2.设有周期性实时任务集如下表所示,用EDF算法和RMS算法是否可以调度?画出相应的Gantt图。

任务

发生周期Ti

处理时间Ci

A

30

10

B

40

15

C

50

5

答:由于

因而采用EDF算法一定可以调度,其Gantt图为:

由于

 

因而采用RMS算法不可调度。

3.设有4个作业J1、J2、J3、J4,其提交时刻与运行时间如下。试采用先到先服务、最短作业优先、最高响应比优先算法,分别求出各个作业的周转时间,带权周转时间,以及所有作业的平均周转时间,平均带权周转时间。

操作系统期末大题复习_第1张图片

1. 执行时间顺序为J1-J2-J3-J4

作业的平均周转时间=(120+160+160+188)/4=157 min  约为2.62h

平均带权周转时间=(120/120+160//60+160/30+188/48)/4=3.23

2. SJB执行时间顺序为J1-J3-J4-J2,如图所示。

作业的平均周转时间=(120+238+100+128)/4=146.5min约为2.44h

平均带权周转时间=(120/120+238/60+100/30+128/48)/4=2.74

3. HRN执行时间顺序为J1-J3-J2-J4,如图所示。

作业的平均周转时间=(120+190+100+188)/4=149.5min约为2.49h

平均带权周转时间=(120/12/+190/60+100/30+188/48)/4=2.85

PV操作

4.关于读者/写者问题,有人给出如下改进解法: 由于s以及读者和写者对s的操作,读者和写者都不会无限等待,因而算法不会出现饿死现象,是一个公平的解法

semaphore r_w_w, mutex, s; (初值均为1)

int count; (初值为0)

读者活动:

P(s);

P(mutex);

count++;

if (count= =1)

P(r_w_w);

V(mutex);

V(s);

{读操作}

P(mutex);

count--;

If (count= =0)

V(r_w_w);

V(mutex);

写者活动:

P(s);

P(r_w_w);

{写操作}

V(r_w_w);

V(s);

PV互斥信号量

5.用P、v操作解决读者和写者之间的同步问题,且写者优先。

    这里仍需设置 readcount 记录读者数,rmutex是读者互斥访问 readcount 的信号量,rwmutex是读者与写者互斥访问文件的信号量。另外再设 writecount 记录写者数,wmutex是写者互斥访问 writecount 的信号量。为了使写者优先,需要再设置两个信号量z和x,z控制所有读者按照FCFS策略排队。x使一个读者和一个写者竞争访问文件。只要在x上等待的写者能继续执行,其他写者便可以直接竞争写者之间文件的互斥访问权,从而实现写者优先。

int readcount, writecount;

semaphore rmutex =1, wmutex = 1, rwmutex = 1, z = 1 ,x = 1 ;

void reader( ){

while(1){

        p(z);              //所有读进程在z上排队

  p(x);              //—个读进程与一个写进程在x上竞争

        p(mutex);      //读进程互斥访问readcount

  ++readcount;

  if(readcount= = 1) p(rwmutex ) ;

  v(mutex);

        v(z);     

  v(x);

read data;        //临界区

p(rmutex);

}

}

void writer( ){

while(1){

    p(wmutex);                   //写进程互斥访问writecount

     ++ writecount;

if(writecount==1) p(x);    //一个写进程在x上排队

v(wmutex);

p(rwmutex);                     //其他写进程在rwmutex上排队

write data;

v(rwmutex);

p(wmutex);

--writecount;

if(writecount==0) v(x);     //写进程都写完时,通过v(x)允许读进程读

v(wmutex);

}

}

互斥信号量

6.某单位为节省开支,决定建造男女共用的单性洗浴间。为满足社会风化要求,洗浴间在任何时刻均不允许不同性别的人同时进入。编写一个管程,实现对洗浴间的管理。假定洗浴e中同性别人数没有限制。该管程中包括如下外部函数:

woman_wants_to_enter;

man_wants_to_enter;

woman_leave;

man_leave。

操作系统期末大题复习_第2张图片

操作系统期末大题复习_第3张图片

银行家算法

7.在银行家算法中,若出现如下资源分配情况:

         Allocation        Need          Available 

        A  B  C  D      A  B  C  D       A  B  C  D

P0:   0  0  3  2      0  0  1  2         1  6  2  3

P1:   1  0  0  0      1  7  5  0

P2:   1  3  5  4      2  3  5  6

P3:   0  3  3  2      0  6  5  2

P4:   0  0  1  4      0  6  5  6

试问:

(1)当前状态是否安全?

(2)如果进程P2提出安全请求Request[2]=(1,2,2,2),系统能否将资源分配给它?说明原因.

解:

(1)当前状态是安全状态。可以找到一个安全进程序列<p0,p3,p4,p1,p2>,它使Finish[i]=true,因而可以断言系统当前处于安全状态.

(2)系统不能将资源分配给它。运行银行家算法,由于Request[2]=(1, 2, 2, 2)

         Allocation        Need          Available 

        A  B  C  D      A  B  C  D       A  B  C  D

P0:   0  0  3  2      0  0  1  2          0  4  0  1

P1:   1  0  0  0      1  7  5  0

P2:   2  5  7  6      1  1  3  4

P3:   0  3  3  2      0  6  5  2

P4:   0  0  1  4      0  6  5  6

运行安全性检测算法,Work=Available=(0, 4, 0, 1),Finish[i]=false,此时所有Need[i]£Work[i]均不成立,结果Finish[i]均为false,不存在安全进程序列,系统处于不安全状态。系统将取消资源分配并恢复原来状态,进程p2等待。

死锁检查算法

8.某系统采用死锁检测手段发现死锁,设系统中资源类集合为{A,B,C},资源类A中共有8个实例,资源类B中共有6个实例,资源类C中共有5个实例.又设系统中进程集合为{p1,p2,p3,p4,p5,p6},某时刻系统状态如下:

        Allocation        Need          Available 

         A  B  C        A  B  C         A  B  C

p1:     1  0  0        0  0  0         2  2  1

p2:     3  2  1        0  0  0

p3:     0  1  2        2  0  2

p4:     0  0  0        0  0  0

p5:     2  1  0        0  3  1

p6:     0  0  1        0  0  0

  1. 在上述状态下系统依次接受如下请求:Request[1]=(1,0,0);Request[2]=(2,1,0);Request[4]=(0,0,2)。给出系统状态变化情况,并说明没有死锁。
  2. 在由(1)所确定的状态下系统接收如下请求:Request[1]=(0,3,1),说明此时已发生死锁,并找出参与死锁的进程。

解:

(1)①系统接受请求:Request[1]=(1,0,0),Request[1]< Available,可以执行分配,那么系统状态变为:

        Allocation        Need          Available 

         A  B  C        A  B  C         A  B  C

p1:    2  0  0        0  0  0         1  2  1

p2:     3  2  1       0  0  0

p3:     0  1  2       2  0  2

p4:     0  0  0       0  0  0

p5:     2  1  0        0  3  1

p6:     0  0  1        0  0  0

在该状态下运行死锁检测算法,可以找到一个进程序列<p4,p1,p2,p3,p5,p6>,它使Finish[i]=true,对于所有1≤i≤6,因而可以断言系统当前没有进入死锁状态。

②系统接受请求:Request[2]=(2,1,0),Request[2]>Available,系统只接受请求,无法实现资源分配,那么系统状态变为:

        Allocation        Need          Available 

         A  B  C        A  B  C         A  B  C

p1:    2  0  0        0  0  0            1  2  1

p2:    3  2  1        2  1  0

p3:     0  1  2        2  0  2

p4:     0  0  0        0  0  0

p5:     2  1  0        0  3  1

p6:     0  0  1        0  0  0

在该状态下运行死锁检测算法,可以找到一个进程序列<p4,p1,p2,p3,p5,p6>,它使Finish[i]=true,对于所有1≤i≤6,因而可以断言系统当前没有进入死锁状态。

③系统接受请求:Request[4]=(0,0,2),Request[4]>Available,系统只接受请求,无法实现资源分配,那么系统状态变为:

        Allocation        Need          Available 

         A  B  C        A  B  C         A  B  C

p1:    2  0  0        0  0  0         1  2  1

p2:    3  2  1        2  1  0

p3:     0  1  2        2  0  2

p4:     0  0  0        0  0  2

p5:     2  1  0        0  3  1

p6:     0  0  1        0  0  0

在该状态下运行死锁检测算法,可以找到一个进程序列< p1,p2,p3, p4,p5,p6>,它使Finish[i]=true,对于所有1≤i≤6,因而可以断言系统当前没有进入死锁状态。

(2)在(1)状态下系统接收如下请求:Request[1]=(0,3,1),Request[1]>Available,系统只接受请求,无法实现资源分配,则系统状态变为:

        Allocation        Need          Available 

         A  B  C        A  B  C         A  B  C

p1:    2  0  0        0  3  1         1  2  1

p2:    3  2  1        2  1  0

p3:     0  1  2        2  0  2

p4:     0  0  0        0  0  2

p5:     2  1  0        0  3  1

p6:     0  0  1        0  0  0

在该状态下运行死锁检测算法,找不到一个进程序列使Finish[i]=true,对于所有1≤i≤6,因为存在i∈{1,2,3,5},使Finish[i]=false,因而可以断言系统已经进入死锁状态,进程p1,p2,p3,p5卷入死锁.

缺页置换算法

9.设某进程页面的访问序列为4,3,2,1,4,3,5,4,3,2,1,5,当分配给该进程的内存页框数分别为3和4时,对于先进先出,最近最少使用,最佳页面置换算法,分别发生多少次缺页中断?

答:

分配的页框数为3时:

FIFO:

4

3

2

1

4

3

5

4

3

2

1

5

4

4

4

1

1

1

5

5

5

5

5

5

3

3

3

4

4

4

4

4

2

2

2

2

2

2

3

3

3

3

3

1

1

×

×

×

×

×

×

×

×

×

共缺页9次

LRU:

4

3

2

1

4

3

5

4

3

2

1

5

4

4

4

1

1

1

5

5

5

2

2

2

3

3

3

4

4

4

4

4

4

1

1

2

2

2

3

3

3

3

3

3

5

×

×

×

×

×

×

×

×

×

×

共缺页10次

OPT:

4

3

2

1

4

3

5

4

3

2

1

5

4

4

4

4

4

4

4

4

4

2

2

2

3

3

3

3

3

3

3

3

3

1

1

2

1

1

1

5

5

5

5

5

5

×

×

×

×

×

×

×

共缺页7次

分配的页框数为4时:

FIFO:

4

3

2

1

4

3

5

4

3

2

1

5

4

4

4

4

4

4

5

5

5

5

1

1

3

3

3

3

3

3

4

4

4

4

5

2

2

2

2

2

2

3

3

3

3

1

1

1

1

1

1

2

2

2

×

×

×

×

×

×

×

×

×

×

共缺页10次

LRU:

4

3

2

1

4

3

5

4

3

2

1

5

4

4

4

4

4

4

4

4

4

4

4

5

3

3

3

3

3

3

3

3

3

3

3

2

2

2

2

5

5

5

5

1

1

1

1

1

1

1

1

2

2

2

×

×

×

×

×

×

×

×

共缺页8次

OPT:

4

3

2

1

4

3

5

4

3

2

1

5

4

4

4

4

4

4

4

4

4

4

1

1

3

3

3

3

3

3

3

3

3

3

3

2

2

2

2

2

2

2

2

2

2

1

1

1

5

5

5

5

5

5

×

×

×

×

×

×

共缺页6次

分页管理

10.请求分页管理系统中,假设某进程的页表内容如下表所示。 

   页面大小为4KB,一次内存的访问时间是100ns,一次快表(TLB)的访问时间是10ns,处理一次缺页的平均时间为108ns(已含更新TLB和页表的时间),进程的驻留集大小固定为2,采用最近最少使用置换算法(LRU)和局部淘汰策略。假设:

①TLB初始为空;

②地址转换时先访问TLB,若TLB未命中,再访问页表(忽略访问页表之后的TLB更新时间);

③有效位为0表示页面不在内存,产生缺页中断,缺页中断处理后,返回到产生缺页中断的指令处重新执行。设有虚地址访问序列137H 、565H、15A5H,请问: 

页号

页框号

有效位(存在位)

0

101H

1

1

--

0

2

254H

1

(1) 依次访问上述三个虚地址,各需多少时间?给出计算过程。  

(2) 基于上述访问序列,虚地址258H的物理地址是多少?请说明理由。   

(1)根据页式管理的工作原理,应先考虑页面大小,以便将页号和页内位移分解出来。页面大小为4KB,即212,则得到页内位移占虚地址的低12位,页号占剩余高位。可得三个虚地址的页号P如下(十六进制的一位数字转换成4位二进制,因此,十六进制的低三位正好为页内位移,最高位为页号): 

 137H:P=0,访问快表10ns,因初始为空,访问页表100ns得到页框号,合成物理地址后访问主存100ns,共计10ns+100ns+100ns=210ns。 

 565H:P=0,访问快表,因第一次访问已将该页号放入快表,因此花费10ns便可合成物理地址,访问主存100ns,共计10ns+100ns=110ns。 

 15A5H:P=1,访问快表10ns,落空,访问页表100ns落空,进行缺页中断处理108ns,合成物理地址后访问主存100ns,共计10ns+100ns+108ns+100ns≈108ns。 

 (2)访问1565H时,1号页面在内存中,页框号与15A5H相同。前面当访问虚地址15A5H时,访问页表发现1号页不在内存中,产生缺页中断,合法驻留集为2,必须从页表中淘汰一个页面,根据题目的置换算法,最近访问的都是0号页的内容,0号页不应被淘汰。应淘汰2号页面,因此1号页面装入时对应的页框号为254H。由此可得1565H的物理地址为254565H。 

段式存储管理

11.在某个段式存储管理系统中,进程P的段表如下表,求表中各逻辑地址对应的物理地址

段号

段内位移

0

430

1

15

2

500

3

400

4

112

解:

段号

段内位移

物理地址

0

430

680

1

15

2365

2

500

越界

3

400

1750

4

112

越界

页式管理

12.在某页式管理系统,某进程页表如下,已知页面大小为1024B,试将逻辑地址1012、2248、3010、4020、5018转化为相应的物理地址。

页号

页框号

0

5

2

8

2

8

3

1

4

6

解:

逻辑地址

页号

页内地址

页框号

物理地址

1012

0

1012

5

5*1024+1012=6132

2248

2

200

8

8*1024+200=8392

3010

2

962

8

8*1024+962=9154

4020

3

948

1

1*1024+948=1972

5018

4

922

6

6*1024+922=7066

你可能感兴趣的:(操作系统,操作系统期末复习,操作系统)