操作系统实验指导书计算机专业Word文档下载推荐.docx

资源描述

操作系统实验指导书计算机专业Word文档下载推荐.docx

《操作系统实验指导书计算机专业Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《操作系统实验指导书计算机专业Word文档下载推荐.docx（31页珍藏版）》请在冰豆网上搜索。

操作系统实验指导书计算机专业Word文档下载推荐.docx

大纲主撰人：

大纲审核人：

左风朝

一、学时、学分

课程总学时：

实验学时：

课程学分：

二、适用专业及年级

计算机科学与技术、软件工程、网络工程专业二、三年级

三、课程目标与基本要求

操作系统是计算机教学中最重要的环节之一，也是计算机及其相关专业学生的一门重要的专业课程。

操作系统课程主要内容包括：

进程管理、处理机调度与死锁、存储管理、设备管理、文件系统、操作系统接口、网络操作系统、操作系统安全性以及Unix系统内核结构。

由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。

要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果。

课程目标:

培养学生的系统程序设计能力，是操作系统课程的一个非常重要的环节。

通过操作系统上机实验，可以培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解。

使学生更好地掌握操作系统的基本概念、基本原理、及基本功能，具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。

基本要求:

1．通过对操作系统中经典算法的模拟，是学生深入理解算法的实现和应用，了解操作系统在计算机系统中的作用，培养学生在实验过程中发现问题、分析问题和解决问题的能力。

2．掌握系统程序设计的基本方法和有关开发环境的使用。

通过实验着重培养学生阅读参考资料、算法分析和设计、程序调试、处理实验数据以及分析与总结实验结果等方面的能力。

3．通过实验加深对计算机操作系统原理的理解，培养实事求是、踏实细致、严肃认真的科学态度和克服困难、坚韧不拔的工作作风，以及科学、良好的实验素质和习惯。

四、主要仪器设备

硬件：

台式计算机；

软件：

C、C++环境。

五、实验项目及教学安排

序号

实验项目名称

实验基本方法和内容

项目学时

项目

类型

每组

人数

教学要求

进程调度实验

用C/C＋＋编写和调试单处理器进程调度的模拟程序，观察调度过程，以加深对进程的概念及进程调度算法的理解。

设计型

必修

资源管理实验

用C/C++编写和调试系统动态分配资源的简单模拟程序，采用银行家算法，有效地防止和避免死锁的发生。

存储器管理实验

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

综合型

六、考核方式及成绩评定

认真学习教学过程中讲授的与实验相关的内容，提前做好实验预习。

按实验指导书要求事先编好程序；

准备好需要输入的中间数据；

估计可能出现的问题；

预计可能得到的运行结果。

做到在每个实验前明确实验目的、掌握实验的基本内容及操作方法；

在实验中正确使用实验设备，认真观察、分析实验结果；

实验后要根据要求做好总结，上交实验报告。

根据学生实验出勤情况、实验态度、实验报告成绩等评定实验成绩。

实验报告（含实验理论）占实验成绩的60%—40%，实验技能（含实验态度）占实验成绩的40%—60%。

各次实验成绩的平均值为最终实验成绩，占该课程考核总成绩的20％—30%。

七、实验教科书、参考书

1．实验教科书

自编实验指导书。

2．实验参考书

郁红英、李春强，计算机操作系统实验指导，清华大学出版社，2008.9

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

基本信息

实验课程：

计算机操作系统设课形式：

非独立

4实验项目：

进程调度

项目类型：

设计型项目学时：

实验目的

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

实验内容

本实验为单机模拟进程调度算法，在程序设计时不需真正地建立线程或者进程。

实验模拟创建若干进程（人为输入或随机数产生），选择一种或几种单处理机的进程调度算法，如FCFS（先来先服务），SPF（短进程优先），RR（时间片轮转法），优先级算法等，模拟进行进程调度。

每进行一次调度，都打印一次运行进程、就绪队列、以及各个进程的PCB，并能在进程完成后及时撤消该进程。

实验原理及设计

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

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

进程名

指针

要求运行时间

优先数

状态

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

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

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

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

状态——可假设有两种状态，“就绪”状态和“结束”状态。

五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

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

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程，用指针指出队列的连接情况。

例：

队首标志

PCB1

PCB2

PCB3

PCB4

PCB5

（4）处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：

优先数-1

要求运行时间-1

来模拟进程的一次运行。

提醒注意的是：

在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

（5）进程运行一次后，若要求运行时间0，则再将它加入队列（按优先数大小插入，且置队首标志）；

若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。

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

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

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

图1优先权进程调度流程图

实验条件

1、装有Windows操作系统的微型计算机；

2、BorlandC++软件。

实验过程

1、根据实验预习阶段的实验设计方案，编写应用程序。

参考代码如下。

#include"

stdio.h"

#include<

stdlib.h>

conio.h>

#definegetpch（type）（type*）malloc（sizeof（type））

#defineNULL0

structpcb{/*定义进程控制块PCB*/

charname[10];

charstate;

intsuper;

intntime;

intrtime;

structpcb*link;

}*ready=NULL,*p;

typedefstructpcbPCB;

voidsort（）/*建立对进程进行优先级排列函数*/

{

}

voidinput（）/*建立进程控制块函数*/

inti,num;

printf（"

\n请输入进程数量?

）;

scanf（"

%d"

num）;

for（i=0;

num;

i++）

\n进程号No.%d:

\n"

i）;

p=getpch（PCB）;

\n输入进程名:

%s"

p->

name）;

\n输入进程优先数:

p->

super）;

\n输入进程运行时间:

ntime）;

rtime=0;

state='

;

link=NULL;

sort（）;

/*调用sort函数*/

intspace（）

intl=0;

PCB*pr=ready;

while（pr!

=NULL）

l++;

pr=pr->

link;

return（l）;

voiddisp（PCB*pr）/*建立进程显示函数,用于显示当前进程*/

\nqname\tstate\tsuper\tndtime\truntime\n"

|%s\t"

pr->

|%c\t"

state）;

|%d\t"

rtime）;

voidcheck（）/*建立进程查看函数*/

PCB*pr;

\n****当前正在运行的进程是:

/*显示当前运行进程*/

disp（p）;

pr=ready;

\n****当前就绪队列状态为:

/*显示就绪队列状态*/

disp（pr）;

voiddestroy（）/*建立进程撤消函数（进程运行结束,撤消进程）*/

\n进程[%s]已完成.\n"

free（p）;

voidrunning（）/*建立进程就绪函数（进程运行时间到,置就绪状态*/

（p->

rtime）++;

if（p->

rtime==p->

ntime）

destroy（）;

/*调用destroy函数*/

else

super）--;

/*调用sort函数*/

voidmain（）/*主函数*/

intlen,h=0;

charch;

input（）;

len=space（）;

while（（len!

=0）&

（ready!

=NULL））

ch=getchar（）;

h++;

\nTheexecutenumber:

%d\n"

h）;

p=ready;

ready=p->

check（）;

running（）;

\n按任一键继续......"

\n\n进程已经完成.\n"

}

2、编译、链接、运行程序

实验要求

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

2、分析结果含义并写出自己的心得体会。

思考题

1、若实验内容中，在修改优先数时增加下列原则：

进程等待的时间超过某一时限时增加其优先数，参考上述例程，写出程序。

2、若采用基于时间片轮转的调度算法模拟进程调度，试设计算法与程序。

实验二　动态资源分配实验

资源分配

设计项目学时：

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

利用银行家算法实现进程的动态资源分配。

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

1．银行家算法基本思想

先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。

若请求合法，则进行试分配。

最后对试分配后的状态调用安全性检查算法进行安全性检查。

若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。

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

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

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

分配矩阵intAllocation[i][j]

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

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

工作向量intWork[x]intFinish[y]

3．银行家算法bank（）

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

（1）检查申请量是否不大于需求量：

Requesti[j]<

=need[i,j],若条件不符重新输入，不允许申请大于需求量。

（2）检查申请量是否小于系统中的可利用资源数量：

=available[i,j]，若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源。

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

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

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

need[i][j]=need[i][j]-Requesti[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；

gotostep2；

（4）如果所有的Finish[i]=1都满足，则表示系统处于安全状态，否则，处于不安全状态。

5、算法流程如图2所示。

6、具体实验设计

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

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

（3）打印输出银行家算法的资源申请情况和安全性状况。

图2银行算法模拟流程

iostream.h>

stdio.h>

string.h>

//定义全局变量

constintx=10,y=10;

//常量，便于修改

intAvailable[x];

//各资源可利用的数量

intAllocation[y][y];

//各进程当前已分配的资源数量

intMax[y][y];

//各进程对各类资源的最大需求数

intNeed[y][y];

//尚需多少资源

intRequest[x];

//申请多少资源

intWork[x];

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

intFinish[y];

//表示系统是否有足够的资源分配给进程，1为是

intp[y];

//存储安全序列

inti,j;

//i表示进程，j表示资源

intn,m;

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

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

intcounter=0;

//函数声明

voidchushihua（）;

//初始化函数

voidsafe（）;

//安全性算法

voidshow（）;

//函数show,输出当前状态

voidbank（）;

//银行家算法

voidjieshu（）;

//结束函数

voidchushihua（）

{

cout<

输入进程的数量:

//从此开始输入有关数据

cin>

输入资源种类数:

endl<

输入各种资源当前可用的数量（"

种）:

endl;

for（j=0;

j++）

{

输入资源"

可利用的数量Available["

Available[j];

//输入数字的过程...

Work[j]=Available[j];

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

}

输入各进程当前已分配的资源数量Allocation["

]["

for（i=0;

i++）

输入进程"

当前已分配的资源"

数量:

Allocation[i][j];

Finish[i]=0;

//初始化Finish[i]

输入各进程对各类资源的最大需求Max["

对资源"

的最大需求数:

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小于已分配的时候，此类资源已足够不需再申请

初始化完成"

//安全性算法函数

voidsafe（）

//显示当前状态函数

voidshow（）//函数show,输出当前资源分配情况

inti,j;

//局部变量

intAll[y];

//各种资源的总数量

intL1;

//局部变量L1

当前的状态为：

各种资源的总数量:

j++）

资源"

All[j]=Available[j];

//总数量=可用的+已分配的

i++）All[j]+=Allocation[i][j];

All[j]<

当前各种资源可用的量为（available）:

Available[j]<

各进程已经得到的资源量（allocation）:

for（i=0;

=m;

i++）

for（j=i;

j++）cout<

for（L1=0;

L1<

L1++）

进程"

Allocation[L1][j]<

各进程还需要的资源量（need）:

j++）c

展开阅读全文