程序操作系统实验大纲(三个实验)学生版

《计算机操作系统》实验

教学大纲

课程编码：509311 课程类别：专业核心课

适用专业：计算机科学与技术专业主要教学内容：操作系统基本原理

课程总学时：78 实验学时：14

【实验目标要求】

操作系统是计算机教学中最重要的环节之一，也是计算机专业学生的一门重要的专业课程。操作系统课程主要内容包括：进程管理、处理机调度与死锁、存储管理、设备管理、文件系统、操作系统接口、网络操作系统、操作系统安全性以及Unix系统内核结构。由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果。

培养计算机专业的学生的系统程序设计能力，是操作系统课程的一个非常重要的环节。通过操作系统上机实验，可以培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解。使学生更好地掌握操作系统的基本概念、基本原理、及基本功能，具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。

【实验学习要求】

认真学习教学过程中讲授的与实验相关的内容，提前做好实验预习。按实验指导书要求事先编好程序；准备好需要输入的中间数据；估计可能出现的问题；预计可能得到的运行结果。做到在每个实验前明确实验目的、掌握实验的基本内容及操作方法；在实验中正确使用实验设备，认真观察、分析实验结果；实验后要根据要求做好总结，上交实验报告。

【实验计划】

【实验教材及主要参考资料】

教材：

《计算机操作系统》，汤子赢等编著，西安电子科技大学出版社，2002

《操作系统教程题解与实验指导》，孟静编著，高等教育出版社，2003

参考资料：

《操作系统实验指导书》，傅秀芬编著，广东工业大学出版科

中山大学OSCAI ：https://www.360docs.net/doc/aa15419925.html,/os/

《操作系统教程》，陈向群等编著，北京大学出版社，2001

《Windows操作系统原理》，尤晋元等编著，机械工业出版社，2001

《计算机操作系统教程》，周长林等编著，高等教育出版社，2002

【实验任务】

实验一、单处理器系统的进程调度

一、实验目的

通过模拟进程控制方法及单处理机系统的进程调度，了解进程的结构，进程的创建与撤消，进程的组织及进程的状态及其转换，掌握进程调度策略。

二、实验学时

4学时

三、实验内容

本实验为单机模拟进程调度算法，在程序设计时不需真正地建立线程或者进程。实验模拟创建若干进程（人为输入或随机数产生），选择一种或几种单处理机的进程调度算法，如FCFS（先来先服务），SPF（短进程优先），RR（时间片轮转法），优先级算法等，模拟进行进程调度。每进行一次调度，都打印一次运行进程、就绪队列、以及各个进程的PCB，并能在进程完成后及时撤消该进程。

四、算法描述

设计一个按优先数调度算法实现处理器调度的程序。

(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例：

队首标志

K2K3K4K5

(4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：

优先数-1

要求运行时间-1

来模拟进程的一次运行。

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。

(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。

(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。

(8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

图1-1 流程图

五、参考程序

#include "stdio.h"

#include

#include

#define getpch(type) (type*)malloc(sizeof(type))

#define NULL 0

struct pcb { /* 定义进程控制块PCB */

char name[10];

char state;

int super;

int ntime;

int rtime;

struct pcb* link;

}*ready=NULL,*p;

typedef struct pcb PCB;

void sort() /* 建立对进程进行优先级排列函数*/

{

}

void input() /* 建立进程控制块函数*/

{

int i,num;

printf("\n 请输入进程数量?");

scanf("%d",&num);

for(i=0;i

{

printf("\n 进程号No.%d:\n",i);

p=getpch(PCB);

printf("\n 输入进程名:");

scanf("%s",p->name);

printf("\n 输入进程优先数:");

scanf("%d",&p->super);

printf("\n 输入进程运行时间:");

scanf("%d",&p->ntime);

printf("\n");

p->rtime=0;p->state='w';

p->link=NULL;

sort(); /* 调用sort函数*/

}

}

int space()

{

int l=0; PCB* pr=ready;

while(pr!=NULL)

{

l++;

pr=pr->link;

}

return(l);

}

void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/

{

printf("\n qname \t state \t super \t ndtime \t runtime \n");

printf("|%s\t",pr->name);

printf("|%c\t",pr->state);

printf("|%d\t",pr->super);

printf("|%d\t",pr->ntime);

printf("|%d\t",pr->rtime);

printf("\n");

}

void check() /* 建立进程查看函数*/

{

PCB* pr;

printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);

pr=ready;

printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/

while(pr!=NULL)

{

disp(pr);

pr=pr->link;

}

}

void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/

{

printf("\n 进程[%s] 已完成.\n",p->name);

free(p);

}

void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/

{

(p->rtime)++;

if(p->rtime==p->ntime)

destroy(); /* 调用destroy函数*/

else

{

(p->super)--;

p->state='w';

sort(); /*调用sort函数*/

}

}

void main() /*主函数*/

{

int len,h=0;

char ch;

input();

len=space();

while((len!=0)&&(ready!=NULL))

{

ch=getchar();

h++;

printf("\n The execute number:%d \n",h);

p=ready;

ready=p->link;

p->link=NULL;

p->state='R';

check();

running();

printf("\n 按任一键继续......");

ch=getchar();

}

printf("\n\n 进程已经完成.\n");

ch=getchar();

}

要求：

1、完成上述实验示例程序，按照优先级算法补充出sort()子程序的内容。

2、若修改优先数时增加下列原则：进程等待的时间超过某一时限时增加其优先数，参考上述例程，写出程序。

六、选做题

完成FCFS或SPF算法。

七、思考题

编写一个多道程序系统的作业调度模拟程序,可采用任一调度算法。对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

实验二、资源分配

一、实验目的

本实习要求学生编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁的发生。

二、实验学时

4学时

三、实验内容

利用银行家算法实现进程的动态资源分配。对进程运行过程中提出的资源请求进行检查，若分配后系统处于安全状态，则满足请求，否则拒绝申请。

四、算法描述

1．银行家算法基本思想

先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。若请求合法，则进行试分配。最后对试分配后的状态调用安全性检查算法进行安全性检查。若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。

2．银行家算法中用到的主要数据结构

可利用资源向量int Available[j] j为资源的种类。

最大需求矩阵int Max[i][j] i为进程的数量。

分配矩阵int Allocation[i][j]

需求矩阵int need[i][j]= Max[i][j]- Allocation[i][j]

申请各类资源数量int Request i[j] i进程申请j资源的数量

工作向量int Work[x] int Finish[y]

3．银行家算法bank()

进程i发出请求申请k个j资源，Request i[j]=k

(1) 检查申请量是否不大于需求量：Request i[j]<=need[i,j],若条件不符重新输入，不允许申请大于需求量。

(2) 检查申请量是否小于系统中的可利用资源数量：Request i[j]<=available[i,j]，若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源。

(3) 若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：

Available[i,j]= Available[i,j]- Request i[j]；

Allocation[i][j]= Allocation[i][j]+ Request i[j]；

need[i][j]= need[i][j]- Request i[j]；

(4) 试分配后，执行安全性检查，调用safe()函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。

(5) 用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请。

4．安全性检查算法（safe()函数）

(1) 设置两个向量：

工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work= Available。

Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=0；当有足够的资源分配给进程时，再令Finish[i]=1。

(2) 在进程中查找符合以下条件的进程：

条件1：Finish[i]=0；

条件2：need[i][j]<=Work[j]

若找到，则执行步骤(3)否则，执行步骤(4)

(3) 当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work[j]= Work[j]+ Allocation[i][j]；

Finish[i]=1；

goto step 2；

(4) 如果所有的Finish[i]=1都满足，则表示系统处于安全状态，否则，处于不安全状态。5．算法流程图

图2 银行算法模拟流程

五、实验主要步骤

1．启动C/C++语言环境，新建文件。

2．设计一个3个并发进程共享10个同类资源的系统，进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。

3．设计用银行家算法，实现资源分配的两个资源分配程序，应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。

4．确定一组各进程依次申请资源数的序列，在相同的情况下分别运行上述两种资源分配程序，观察运行结果。

5．打印资源申请情况：

六、参考程序

#include

#include

#include

#include

//定义全局变量

const int x=10,y=10; //常量，便于修改

int Available[x]; //各资源可利用的数量

int Allocation[y][y]; //各进程当前已分配的资源数量

int Max[y][y]; //各进程对各类资源的最大需求数

int Need[y][y]; //尚需多少资源

int Request[x]; //申请多少资源

int Work[x]; //工作向量，表示系统可提供给进程继续运行所需的各类资源数量

int Finish[y]; //表示系统是否有足够的资源分配给进程，1为是

int p[y]; //存储安全序列

int i,j; //i表示进程，j表示资源

int n,m; //n为进程i的数量,m为资源j种类数

int l=0; //l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是安全的

int counter=0;

//函数声明

void chushihua(); //初始化函数

void safe(); //安全性算法

void show(); //函数show,输出当前状态

void bank(); //银行家算法

void jieshu(); //结束函数

void chushihua()

cout<<"输入进程的数量: ";//从此开始输入有关数据

cin>>n;

cout<<"输入资源种类数: ";

cin>>m;

cout<

for (j=0; j

{

cout<<"输入资源"<

cin>>Available[j]; //输入数字的过程...

Work[j]=Available[j]; //初始化Work[j]，它的初始值就是当前可用的资源数}

cout<

for (i=0; i

{

for (j=0; j

{

cout<<" 输入进程"<

cin>>Allocation[i][j];

}

cout<

Finish[i]=0;//初始化Finish[i]

}

cout<

for (i=0; i

{

for (j=0; j

{

cout<<" 输入进程"<

cin>>Max[i][j];

if(Max[i][j]>=Allocation[i][j]) //若最大需求大于已分配，则计算需求量

Need[i][j] = Max[i][j]-Allocation[i][j];

else

Need[i][j]=0;//Max小于已分配的时候，此类资源已足够不需再申请

}

cout<

}

cout<

}

//安全性算法函数

void safe()

{

}

//显示当前状态函数

void show() //函数show,输出当前资源分配情况

{

int i,j; //局部变量

int All[y]; //各种资源的总数量

int L1; //局部变量L1

cout<<"当前的状态为："<

cout<<"各种资源的总数量:"<

for (j=0;j

{

cout<<" 资源"<

All[j]=Available[j]; //总数量=可用的+已分配的

for (i=0;i

cout<

}

cout<

for (j=0;j

cout<<" 资源"<

cout<

for(i=0;i<=m;i++)

{

for (j=i;j

cout<

for(L1=0;L1

{

cout<<"进程"<

for (j=i;j

cout<

}

}

cout<

for(i=0;i<=m;i++)

{

for (j=i;j

cout<

for(L1=0;L1

{

cout<<"进程"<

for (j=i;j

cout<

}

}

//银行家算法函数

void bank()

{

cout<

int k=0; //用于输入进程编号

bool r=false; // 初值为假，输入Y继续申请则置为真

do{//输入请求

cout<<"输入申请资源的进程(0-"<

cin>>k;

cout<

while(k>n-1) //输入错误处理

{

cout<

cout<

cin>>k;

cout<

}

cout<

for (j=0; j

{

do{ //do……while 循环判断申请输入的情况

cout<<"进程"<

cin>>Request[j];

cout<

if(Request[j]>Need[k][j]){ //申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目）

cout<<"申请大于需要量!"<

cout<<"申请的资源"<

cout<<"重新输入!"<

}

else //先判断是否申请大于需求量，再判断是否申请大于可利用量

if(Request[j]>Available[j]){ //申请大于可利用量，应该阻塞等待？…… ？？？

cout<<"\n没有那么多资源，目前可利用资源"<

Finish[k]=0; //该进程等待

goto ppp; //goto语句跳转，结束本次申请

}

}while(Request[j]>Need[k][j]); //Request[j]>Available[j]||

}

//改变Avilable、Allocation、Need的值

for (j=0; j

Available[j] = Available[j]-Request[j];

Allocation[k][j] = Allocation[k][j]+Request[j];

Need[k][j] = Need[k][j]-Request[j];

Work[j] = Available[j];

}

//判断当前状态的安全性

safe(); //调用安全性算法函数

if (l

{

l=0;

cout<<"\n试分配后，状态不安全,所以不予分配!恢复原状态"<

//恢复数据

for (j=0; j

{

Available[j] = Available[j]+Request[j];

Allocation[k][j] = Allocation[k][j]-Request[j];

Need[k][j] = Need[k][j]+Request[j];

Work[j] = Available[j];

}

for (i=0; i

Finish[i]=0; //进程置为未分配状态

}

else

{

l=0;

cout<<"\n申请资源成功!!!"<

for(j=0;j

{

if(Need[k][j]==0);

else { //有一种资源还没全部申请到，则该进程不可执行，不能释放拥有的资源l=1; //置l为1，作为判断标志

break;

}

}

if(l!=1){ //进程可以执行，则释放该进程的所有资源

for (j=0;j

Available[j]=Available[j]+Allocation[k][j];

Allocation[k][j]=0;

}

cout<<"该进程已得到所有需求资源，执行后将释放其所有拥有资源！"<

}

l=0; //归零

cout<<"\n安全的状态!"<

cout<<"安全序列为: ";

cout<

for (i=1; i

cout<<"==>>"<<"进程"<<"("<

Finish[i]=0; //所有进程置为未分配状态

}

cout<

}

show(); //显示当前状态

ppp: //申请大于可利用量，应该阻塞等待,结束本次资源申请，GOTO 语句跳转至此cout<

char* b=new char; //输入y/n，判断是否继续申请<

cin>>b;

cout<

cout<<"-------------------------------------------"<

cout<

if(*b=='y'||*b=='Y')

r=true;

else{

r=false; //输入非Y 则令R =false

jieshu(); //调用结束函数

}

} while (r==true);

}

//结束函数

void jieshu()

{

cout<

cout<<"\t\t 演示计算完毕"<

cout<

}

//主函数

int main()

{

cout<

chushihua(); //初始化函数调用

cout<

show(); //输出当前状态

safe(); //判断当前状态的安全性

if (l

{

cout<<"\n当前状态不安全，拒绝申请！"<

cout<

return 0;

}

else

{

int i; //局部变量

l=0;

cout<

cout<<"进程"<<"("<

for (i=1; i>"<<"进程"<<"("<

for (i=0; i

cout<

}

bank(); //调用银行家算法函数

cout<<"\t\t 演示计算完毕"<

return 0;

}

要求：

1、完成上述实验示例程序，按照银行家算法流程补充出safe()函数即安全性检测算法的内容。

2、分析各子程序的功能及实现过程，并简要说明。

七、思考题：

1、银行家算法实现死锁避免的缺陷在哪里？

2、如何实现并发执行的进程对资源的动态申请和动态分配？

实验三、请求页式存储管理

实验目的：

用C/C++编写和调试虚拟内存管理的模拟程序，通过虚存管理的地址转换过程和各种页面淘汰算法的编程实现，加深对存储管理方案的理解。

实验内容：

（1）设计页表。

分页式虚拟存储系统是把作业的副本存放在磁盘上，当作业被选中时，可把作业的开始几页先装入主存且启动执行。为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表的格式为：

页号标志主存块号在磁盘上的位置

（2）地址计算。

作业执行时，指令中的逻辑地址指出了参加运算的操作数存放的页号和单元号，硬件的地址转换机构按页号查页表，若该页对应标志为“1”，则表示该页已在主存，这时根据关系式：

绝对地址=块号*块长+单元号

计算出欲访问的主存单元地址。按计算出的绝对地址可以取到操作数，完成一条指令的执行。若访问的页标志为“0”，则表示该页不在主存，这时硬件发“缺页中断”信号，由OS按该页在磁盘

上的位置，把该页信息从磁盘读出装入主存后再重新执行这条指令。

（3）设计“地址转换”程序模拟硬件的地址转换工作。

当访问的页在主存时，则形成绝对地址，但不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行。当访问的页不在主存时，则输出“*该页页号”，表示产生了一次缺页中断，执行缺页中断程序。该模拟程序的算法如图3.1所示。

图 3.1 地址转换模拟流程图

(4) 缺页中断模拟。

如果访问页不在主存且页表未满，则调入一页并打印页表情况；如果该页不在主存且页表已满，则产生缺页中断，模拟算法如图3.2所示。

实验中采用FIFO算法进行页面淘汰。把在主存的页的页号按进入主存的先后次序排成队列，每次总是调出队首页。用数组存放页号的队列。若分配给该作业的物理块数为m，则数组由m 个元素组成，p[0]，p[1]……p[m-1]，队首指针head，队尾指针tail。当装入新页时，将其页号装入数组。

实验主要步骤：

1. 启动C语言环境，新建文件。

2. 假定主存的每块长度为128个字节；现有一个共七页的作业，其中的第0页至第3页已经

装入主存，其余三页未装入主存，主存；该作业的页表为：

如果作业依次执行的指令序列（操作，页号，单元号）为：

(+, 0, 070)、(+, 1, 050)、(*, 2, 015) 、(存, 3, 021)、(取, 0, 056)、(—, 6, 040)、(移位, 4, 053)、(+, 5, 023)、(存, 1, 037)、(取, 2, 078)、(+, 0, 070)、(+, 4, 001)、(存, 6, 084)。

运行设计的地址转换程序，显示或打印运行结果。因仅模拟地址转换，并不模拟指令的执行，故可不考虑上述指令序列中的操作。

3. 编写程序运行。

思考题：

请采用合适的方法编写程序完成主存空间的分配和回收

#include "stdio.h"

#include "string.h"

#define SizeOfBlock 128

#define M 4

struct info /*页表*/

{

int flag;

long block;

long disk;

}pagelist[SizeOfPage];

long po;

long P[M];

void init_ex ()

{

po=0;

P[0]=0;P[1]=1;P[2]=2;P[3]=3;

memset(pagelist,0,sizeof(pagelist));

pagelist[0].flag=1;

pagelist[0].block=5;

pagelist[0].disk=011;

pagelist[1].flag=1;

pagelist[1].block=8;

pagelist[1].disk=012;

pagelist[2].flag=1;

pagelist[2].block=9;

pagelist[2].disk=013;

pagelist[3].flag=1;

pagelist[3].block=1;

pagelist[3].disk=021;

}

void work_ex()

{

long p,q,i;

char s[100];

int stop=0;

do

{

printf("请输入指令的页号、单元号：\n");

if (scanf("%ld%ld",&p,&q)!=2)

{

scanf("%s",s);

if (strcmp(s,"exit")==0)

{

stop=1;

}

}

else

{

if (pagelist[p].flag)

printf("绝对地址=%ld\n",pagelist[p].block*SizeOfBlock+q); else

{ printf("* %ld\n",p);

pagelist[P[po]].flag=0;

printf("out %ld\n",P[po]);

printf("in %ld\n",p);

pagelist[p].block=pagelist[P[po]].block;

pagelist[p].flag=1;

P[po]=p;

po=(po+1)%M;

}

}

}while (!stop);

printf("数组P 的值为：\n");

for (i=0;i

{

printf("P[%ld]=%ld\n",i,P[i]);

}

}

int main()

{

init_ex();

work_ex();

return 0;

}