操作系统实验指导书江西农业大学.docx

操作系统实验指导书江西农业大学.docx

《操作系统实验指导书江西农业大学.docx》由会员分享，可在线阅读，更多相关《操作系统实验指导书江西农业大学.docx（30页珍藏版）》请在冰点文库上搜索。

操作系统实验指导书江西农业大学

操作系统实验指导书（江西农业大学）

————————————————————————————————作者：

————————————————————————————————日期：

课程号：

0540251

适用专业：

软件工程

制定人：

邓泓、熊焕亮、李光泉

教研室：

软件开发教研室

江西农业大学软件学院

2010年7月

前言

操作系统是计算机的核心和灵魂。

操作系统软件的设计对整个计算机的功能和性能起着至关重要的作用，所以此门课也是必不可少的，是面向计算机科学与技术、网络工程、软件工程等大多数计算机专业本科生和研究生开设的一门计算机专业课程。

操作系统是计算机系统的核心，《操作系统》课程是计算机科学与技术专业的重要必修课。

本课程的目的是使学生掌握现代计算机操作系统的基本原理、基本设计方法及实现技术，具有分析现行操作系统和设计、开发实际操作系统的基本能力。

操作系统实验是操作系统课程的重要组成部分，属于学科基础实验范畴。

作为与相关教学内容配合的实践性教学环节，应在操作系统理论课教学过程中开设。

操作系统是计算机科学与技术专业必修的专业基础课程，操作系统实验的作用是：

理解操作系统的设计和实现思路，掌握典型算法.基本要求是:

理解进程的概念，理解死锁，掌握银行家算法；掌握请求页式存储管理的实现原理及页面置换算法。

学生应具有高级语言编程能力、具有数据结构等基础知识.

实验要求

为了顺利完成操作系统课程实验，学生应做到：

（1）实验前，认真学习教材以及实验指导书的相关内容，提前做好实验准备.

（2）实验结束一周后提交实验报告。

实验报告内容应包括：

实验目的、实验内容、设计思路和流程框图,源程序（含注释）清单、测试结果以及实验总结.

（3）遵守机房纪律,服从辅导教师指挥，爱护实验设备。

实验的验收将分为两个部分.第一部分是上机操作，随机抽查程序运行和即时提问；第二部分是提交书面的实验报告。

此外杜绝抄袭现象,一经发现雷同,双方成绩均以0分计算。

实验内容安排

实验

第一次上机（2课时）

第二次上机（2课时）

实验一

熟悉进程调度相关内容；

熟悉最高优先数的调度算法的示例

编写“多级反馈队列轮转法"模拟程序

实验二

熟悉银行家算法

实验三

熟悉页面置换相关内容；

熟悉LRU算法的示例

编写FIFO模拟程序

实验一进程调度实验

【开发语言及实现平台或实验环境】

C++/C#

MicrosoftVisualStudio6。

0/MicrosoftVisualStudio。

NET2003

【实验目的】

（1）加深对进程的概念及进程调度算法的理解；

（2）在了解和掌握进程调度算法的基础上，编制进程调度算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

【实验要求】

（1）了解进程调度；

（2）理解利用进程调度算法进行调度的原理；

（3）会使用某种编程语言.

【实验原理】

一、例题：

设计一个有N个进程其行的进程调度算法。

进程调度算法：

采用最高优先数的调度算法（即把处理机分配给优先数最高的进程）.

每个进程有一个进程控制块（PCB）表示。

进程控制块可以包含如下信息:

进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为的指定（也可以由随机数产生）。

进程的到达时间为进程的输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1表示。

如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤销该进程，如果运行一个时间片后,进程的已占用CPU时间还未达到所需要的运行时间,也就是进程还需要继续运行，此时应该将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU.

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。

重复以上过程，直到所要的进程都完成为止.

分析:

  使用固定队列与静动态优先级结合每个优先级为0～0xFF,并且以小的数字为高优先级,大的数字为低优先级,

  每次皆使用循环得到最高优先级的进程并执行,然后将其动态优先级设置为最低,并将其他进程动态优先级提高，

  以使得每个进程都有机会运行。

进程的优先级与运行时间由随机数产生.

二、代码试例

＃include〈stdlib.h>

#include〈stdio。

h〉

＃include〈time.h〉

/*常量和状态定义*/

#definePRO_NUM0x05

＃defineMAX_TIME0xFF

/*状态宏＊/

#defineWAIT0x01

#defineRUN0x02

＃defineFINISH0x03

＃defineID_ERROR0x10

＃defineMIN_PRIOR0xFF

#defineMAX_PRIOR0x00

typedefunsignedintUint32;

/*进程PCB＊/

structPCB_Info

{

Uint32s_id；

Uint32s_static_prior;

Uint32s_dynamic_prior；

Uint32s_start_time;

Uint32s_need_time；

Uint32s_used_time;

Uint32s_state;

｝;

/*进程队列＊/

PCB_Infog_queue[5]；

Uint32g_time;

/*模拟进程执行函数＊/

voidSimulator（）;

/*初始化5个进程函数＊/

voidInit_Process（）；

/*初始化进程队列函数＊/

voidInit_Queue（）；

/＊创建进程函数＊/

Uint32Create_Process（Uint32pri,Uint32needtime）；

/＊系统运行函数＊/

voidRun_Process（）；

/＊得到最高优先级进程ID函数＊/

Uint32Get_PriProcess（）;

/*进程时间片执行函数＊/

voidWork_Process（Uint32id）;

/＊改变进程状态和优先级函数*/

voidChange_Process（Uint32id）;

/*打印进程状态函数*/

voidPrint_State（）；

/＊结束系统函数*/

voidEnd_Process（）；

/＊入口函数*/

intmain（intargc,char*argv［］）

｛

Simulator（）;

return0；

}

voidSimulator（）

{

Init_Process（）；

Run_Process（）;

End_Process（）；

｝

voidInit_Process（）

｛

inti;

Uint32id;

srand（（unsigned）time（NULL））;

Init_Queue（）;

for（i=0;i〈PRO_NUM；++i）

{

/*在这里修改随机数的范围，建议优先级取值为0到4之间,进程工作总时间为1到10之间*/

id=Create_Process（rand（）％4，1+rand（）％10）;

if（id!

=ID_ERROR）

｛

printf（”****＊＊***＊***＊＊**＊*＊*＊＊**＊***＊*＊＊*\n"）；

printf（”创建进程成功\n”）;

printf（"进程ID号为:

％d\n”,id）;

printf（”进程的静态优先权为:

％d\n”，g_queue[id］.s_static_prior）；

printf（”进程的动态优先权为:

%d\n"，g_queue［id]。

s_dynamic_prior）；

printf（”进程的到达时间为：

%d\n”,g_queue[id].s_start_time）；

printf（”进程需要时间为：

％d\n”，g_queue[id].s_need_time）;

printf（”进程已用CPU时间为:

％d\n"，g_queue［id]。

s_used_time）；

printf（”进程的状态为:

%d\n”,g_queue［id]。

s_state）；

printf（"\n”）;

}

else

{

printf（”创建进程失败\n"）；

}

｝

}

voidInit_Queue（）

{

inti;

for（i=0;i〈PRO_NUM;++i）

{

g_queue[i］.s_id=i；

g_queue［i］。

s_dynamic_prior=MIN_PRIOR；

g_queue[i].s_need_time=0；

g_queue［i］.s_start_time=0；

g_queue［i]。

s_static_prior=MIN_PRIOR；

g_queue［i]。

s_used_time=0；

g_queue[i].s_state=FINISH;

｝

｝

Uint32Create_Process（Uint32pri，Uint32needtime）

｛

inti=0；

Uint32id=ID_ERROR；

for（i=0;i

{

if（g_queue［i]。

s_state==FINISH）

｛

id=g_queue[i］。

s_id;

g_queue［i].s_dynamic_prior=MIN_PRIOR;

g_queue[i]。

s_need_time=needtime;

g_queue[i]。

s_start_time=g_time;

g_queue[i].s_state=WAIT;

g_queue［i]。

s_static_prior=pri;

g_queue［i］.s_used_time=0x0；

break；

｝

｝

returnid;

}

voidRun_Process（）

｛

Uint32id；

while（（id=Get_PriProcess（））！

=ID_ERROR）

｛

Work_Process（id）；

Change_Process（id）;

}

｝

voidPrint_State（）

{

inti；

printf（”时间进程ID\t状态已用时间需要时间开始时间静优先级动优先级\n"）;

for（i=0；i〈PRO_NUM；++i）

{

printf（"%d\t%d\t%d\t%d\t％d\t％d\t％d\t%d\n”，g_time,g_queue［i].s_id，g_queue［i].s_state，g_queue[i］。

s_used_time，g_queue[i］。

s_need_time,

g_queue[i].s_start_time,g_queue[i］。

s_static_prior,g_queue［i]。

s_dynamic_prior）;

}

｝

Uint32Get_PriProcess（）

｛

Uint32id=ID_ERROR；

inti,prev_id=ID_ERROR；

Uint32prior=MIN_PRIOR*2，temp_prior;

for（i=0；i

{

if（g_queue[i］。

s_state!

=FINISH）

{

temp_prior=g_queue[i］.s_dynamic_prior+g_queue［i］.s_static_prior;

if（temp_prior〈=prior）

｛

id=i；

prior=temp_prior；

}

｝

｝

returnid；

}

voidWork_Process（Uint32id）

{

++g_time；

g_queue［id］。

s_state=RUN；

++g_queue［id]。

s_used_time;

Print_State（）；

｝

voidChange_Process（Uint32id）

｛

inti；

if（g_queue［id］.s_need_time==g_queue［id]。

s_used_time）

{

g_queue［id]。

s_state=FINISH;

}

else

{

g_queue[id].s_dynamic_prior=MIN_PRIOR;

g_queue［id].s_state=WAIT；

}

for（i=0;i〈PRO_NUM；++i）

{

if（（i!

=id）&&（g_queue[i］.s_state！

=FINISH））

｛

g_queue［i]。

s_dynamic_prior>0?

--g_queue[i］。

s_dynamic_prior：

g_queue［i]。

s_dynamic_prior=0；

}

｝

}

voidEnd_Process（）

{

printf（”所有进程结束状态：

\n”）；

Print_State（）；

printf（"所有进程已经结束!

\n"）；

｝

三、实验题：

编写并调试一个模拟的进程调度程序,采用“多级反馈队列轮转法"调度算法对五个进程进行调度。

【思考题】

（1）哪种算法容易实现？

【参考文献】

1、汤子瀛编。

《计算机操作系统》。

北京：

西安电子科技大出版社,2004。

2、TanenbaumA。

SOperatingSystemDesignandImplementation清华大学出版社　1996年11月（影印版）；

3、陆松年 操作系统教程 电子工业出版社   2000年10月；

4、张尧学。

计算机操作系统教程（第二版）.清华大学出版社。

2000。

8。

实验二银行家算法模拟

【开发语言及实现平台或实验环境】

C语言

【实验目的】

（1）进一步理解利用银行家算法避免死锁的问题;

（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

（3）理解和掌握安全序列、安全性算法

【实验要求】

（1）了解和理解死锁；

（2）理解利用银行家算法避免死锁的原理；

（3）会使用某种编程语言.

【实验原理】

一、安全状态

指系统能按照某种顺序如（称为序列为安全序列），为每个进程分配所需的资源,直至最大需求，使得每个进程都能顺利完成.

二、银行家算法

假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j］=k。

系统按下述步骤进行安全检查:

（1）如果Requesti≤Needi则继续以下检查，否则显示需求申请超出最大需求值的错误。

（2）如果Requesti≤Available则继续以下检查，否则显示系统无足够资源,Pi阻塞等待。

（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：

Available［j］∶=Available［j］-Requesti［j]；

Allocation［i,j]∶=Allocation［i，j］+Requesti［j］；

Need[i,j]∶=Need[i,j］-Requesti［j］;

（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

若安全，才正式将资源分配给进程Pi，以完成本次分配;否则，将本次的试探分配作废,恢复原来的资源分配状态，让进程Pi等待。

三、安全性算法

（1）设置两个向量：

①工作向量Work：

它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available；

②Finish:

它表示系统是否有足够的资源分配给进程，使之运行完成.开始时先做Finish［i]∶=false;当有足够资源分配给进程时,再令Finish［i］∶=true。

（2）从进程集合中找到一个能满足下述条件的进程:

①Finish［i］=false;

②Need［i,j]≤Work［j］；若找到，执行步骤（3），否则，执行步骤（4）。

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

ØWork[j］∶=Work[i］+Allocation［i,j］；

ØFinish［i］∶=true；

Øgotostep2;

（4）如果所有进程的Finish［i]=true都满足，则表示系统处于安全状态；否则,系统处于不安全状态。

【实验步骤】

参考实验步骤如下：

（1）参考图1-1所示流程图编写安全性算法。

（2）编写统一的输出格式.

每次提出申请之后输出申请成功与否的结果。

如果成功还需要输出变化前后的各种数据，并且输出安全序列.

（3）参考图1—2所示流程图编写银行家算法。

（4）编写主函数来循环调用银行家算法。

示例：

＃include〈stdio。

h>

intmain（）

｛

intclaim［5]［3］={｛7,5，3｝，{3，2，2｝，{9，0，2},｛2，2，2｝,｛4，3,3｝};//各线程最大需求量

intallocation[5］［3］=｛｛0，1,0｝，{2,0，0｝,｛3,0,2｝,{2，1，1}，{0,0，2}};//各线程已分配资源

inti,j，k，l=0,count=0,m=0；

intC_A[5][3］=｛{0,0，0｝，{0，0，0｝,{0,0，0}，{0，0,0}，｛0,0，0｝}；//各进程仍需要的各类资源

intresult［5］={—1,—1，—1,—1,-1};//存放预分配成功的线程

intcurrentavail［3]={3,3,2｝；//当前可分配资源

printf（"银行家总共拥有的各类资源的总数：

\nABC\n1057\n"）;

printf（”银行目前仍剩下的各类资源的数量：

\nABC\n332\n"）;

printf（”各进程对各类资源的最大需求量:

\nABC\n”）；

for（i=0;i〈5；i++）

{

printf（”P%d:

",i）；

for（j=0；j〈3;j++）

｛

printf（"％d"，claim[i］［j]）;

C_A［i］[j］=claim［i]［j］-allocation[i][j］;

}

printf（"\n"）；

}

printf（”各进程已分配到的各类资源:

\nABC\n"）;

for（i=0；i〈5;i++）

{

printf（”P％d:

”，i）；

for（j=0;j〈3;j++）

printf（”％d",allocation［i］[j］）;

printf（"\n”）；

｝

printf（”各进程仍需的各类资源数量:

\nABC\n”）;

for（i=0;i<5;i++）

｛

printf（"P%d:

"，i）；

for（j=0；j〈3;j++）

printf（"％d"，C_A[i]［j］）;

printf（"\n"）;

｝

while（result[l]==-1）//

{

for（k=0;k〈5;k++）

if（result［k］==—1）

{

for（j=0；j〈3；j++）

//判断各线程对各资源仍需量是否小于当前可分配资源总量,此量为正数才正常

if（C_A［k][j]〈=currentavail[j]＆＆C_A[k]［j]〉=0）

｛

//把满足条件的进程的已分配资源加到当前可分配资源中

currentavail［j]=currentavail[j］+allocation[k］[j］;

m++；

if（m==3）

{

result[l］=k;//只有ABC三类资源都满足才把相应的线程记入数组result中

m=0;

｝

｝

elsebreak;//否则退出循环，打印"系统不安全”

l++;

｝

for（i=0;i

if（result［i]！

=—1）

{

printf（”P％d->”,result[i］）;//把预分配成功的先打印出来

count++;

}

l=0；//清零,为下一轮的预分配做准备

}

if（count==5）

printf（”\n系统安全！

上行所示为其中一个进程安全序列\n"）；

else

printf（”\n系统不安全！

\n”）;

｝

结果如下：

银行家总共拥有的各类资源的总数:

ABC

1057

银行目前仍剩下的各类资源的数量：

ABC

332

各进程对各类资源的最大需求量：

ABC

P0：

753

P1：

322

P2：

902

P3:

222

P4：

433

各进程已分配到的各类资源：

ABC

P0：

010

P1:

200

P2：

302

P3：

211

P4：

002

各进程仍需的各类资源数量：

ABC

P0:

743

P1：

122

P2：

600

P3：

011

P4:

431

P1—〉P3-〉P4—>P0—>P2->

系统安全！

上行所示为其中一个进程安全序列

【思考题】

（1）在编程中遇到了哪些问题？

你是如何解决的？

（2）在安全性算法中,为什么不用变量Available，而又定义一个临时变量work？

【参考文献】

1、汤子瀛编。

《计算机操作系统》。

北京:

西安电子科技大出版社,2004.

2、TanenbaumA。

SOperatingSystemDesignandImplementation清华大学出版社　1996年11月（影印版）；

3、陆松年 操作系统教程 电子工业出版社   2000年10月；

4、张尧学。

计算机操作系统教程（第二版）.清华大学出版社.2000。

8。

实验三请求页式存储管理中常用页面置换算法模拟

【开发语言及实现平台或实验环境】

C++/C#

MicrosoftVisualStudio6.0/MicrosoftVisualStudio.NET2003

【实验目的】

（1）了解内存分页管理策略