08级操作系统课程设计报告书.docx

08级操作系统课程设计报告书.docx

《08级操作系统课程设计报告书.docx》由会员分享，可在线阅读，更多相关《08级操作系统课程设计报告书.docx（43页珍藏版）》请在冰豆网上搜索。

08级操作系统课程设计报告书

课程设计报告书

2011/2012学年第1学期

课程名称：

操作系统实践课程设计

专业班级：

学号：

姓名：

指导教师：

课程设计指导教师评语

成绩：

____________

指导教师签字：

________________

题目1进程调度算法的模拟

1．1题目的主要研究内容及预期达到的目标

（1）编程序模拟实现进程调度算法中的FCFS、SJF和高响应比优先算法。

（2）基本完成了模拟实现FCFS、SJF和HRN调度算法。

1．2题目研究的工作基础或实验条件

（1）硬件环境：

windows系统

（2）软件环境：

VisualC++

1．3设计思想

（1）FCFS:

将系统中所有的就绪进程按照FCFS原则，排成一个队列。

每次调度时将CPU分派给队首进程，让其执行一个时间片。

时间片的长度从几个ms到几百ms。

在一个时间片结束时，发生时钟中断。

调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程。

进程可以未使用完一个时间片，就出让CPU（如阻塞）。

（2）SJF：

对预计执行时间短的作业（进程）优先分派处理机。

通常后来的短作业不抢先正在执行的作业。

（3）HRN：

HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。

　　响应比R定义如下：

R=（W+T）/T=1+W/T

　　其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。

1．4流程图

1．5主要程序代码

#include

#include

#include

#defineN100

typedefstructJCB

{

intID;/*作业标识数*/

intrequesttime;/*作业运行所需时间*/

intruntime;/*作业实际运行所需时间*/

intpriority;/*作业优先数*/

intquick;/*作业紧迫程度*/

}JCB;

JCBjcb[N];

intjcbnum;/*后备作业数*/

voidinit（）;/*赋值函数*/

voidFCFS（）;/*定义FCFS函数*/

voidSJF（）;/*定义SJF函数*/

voidHRN（）;/*定义HRN函数*/

voidmain（）/*main函数*/

{

inti=0;

init（）;

cout<<"=============================="<

cout<<"|1:

FCFS2:

SJF|"<

cout<<"|3:

HRN|"<

cout<<"=============================="<

while（i<=0||i>=5）/*while循环选择算法*/

{

cout<<"Pleaseselectanumber（1,2,3,4）:

"<

cin>>i;

}

switch（i）/*switch语句选择执行函数*/

{

case1:

FCFS（）;break;

case2:

SJF（）;break;

case3:

HRN（）;break;

}

}

voidinit（）/*对定义的变量进行赋值的函数*/

{

inti=0;

while（i<=0||i>=2000）

{

cout<<"InputtheJCBnumber:

（1--2000）"<

cin>>i;

}

jcbnum=i;

for（i=0;i

{

jcb[i].ID=i+1;

jcb[i].priority=rand（）%100+1;

jcb[i].quick=rand（）%5+1;

jcb[i].requesttime=rand（）%1000+1;

}

}

voidFCFS（）/*FCFS函数*/

{

inti;intw=0,t=0;

intWaittime=0;/*给waitime赋值*/

cout<<"Thisisfristcomefistserver:

"<

for（i=0;i

{

cout<<"TheNO."<

Waittime+=jcb[i].requesttime;

w=（Waittime-t）/（jcb[i].requesttime）;

cout<<"带权周转时间为：

"<

t++;

}

}

voidSJF（）/*SJF函数*/

{

inti,j,dest,Waittime,w,t=0;/*定义的变量*/

cout<<"Thisisshortestjobfirst:

"<

while（jcbnum>0）

{

dest=0;

for（i=0;i

if（jcb[dest].requesttime>jcb[i].requesttime）/*条件语句*/

dest=i;

cout<<"TheNO."<

Waittime+=jcb[dest].requesttime;

w=（Waittime-t）/（jcb[dest].requesttime）;

cout<<"带权周转时间为：

"<

t++;

for（j=dest;j

{

jcb[j].ID=jcb[j+1].ID;

jcb[j].requesttime=jcb[j+1].requesttime;

}

jcbnum--;

}

}

voidHRN（）/*HRN函数*/

{

inti,j,dest;/*定义的变量*/

intwaittime=0;/*给waitime赋值*/

cout<<"ThisisHighestresponseratiofirst"<

while（jcbnum>0）

{

dest=0;

for（i=0;i

if（waittime/（jcb[dest].requesttime）>（waittime/（jcb[i].requesttime）））/*条件语句*/

dest=i;

cout<<"TheNO."<

waittime+=jcb[dest].requesttime;/*给waittime赋新值*/

for（j=dest;j

{

jcb[j].ID=jcb[j+1].ID;

jcb[j].requesttime=jcb[j+1].requesttime;

}

jcbnum--;

}

}

1．6运行结果及分析

（1）FCFS算法运行结果

（2）SJF算法运行结果：

（3）HRN算法运行结果

1．7心得体会

整个设计中最麻烦的就是程序模块的划分和各模块之间接口设计，编程经常犯想当然的错误，出现了不少奇怪的错误。

再调试中尝试使用了分割法,对错误模块进行定位,再进行排查.

在算法实现上要有一定的思路体现设计的目的。

同时上机调试也是十分重要的，在调试的过程中能够不断的发现在编写算法时应该注意的一些细节和算法语句的非法使用，在调试过程中通过对算法的不断测试、更正、扩充功能、修饰细节，使算法程序不断的得到完善。

题目2银行家算法的实现

1．1题目的主要研究内容及预期达到的目标

（1）编程序模拟实现银行家算法。

（2）基本完成了模拟实现银行家算法。

1．2题目研究的工作基础或实验条件

（1）硬件环境：

windows系统

（2）软件环境：

C语言

1．3设计思想

（1）银行家算法

假设在进程并发执行时进程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等待。

（2）安全性算法

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．4流程图

1．5主要程序代码

#include

usingnamespacestd;

#defineMAXPROCESS50/*最大进程数*/

#defineMAXRESOURCE100/*最大资源数*/

intAVAILABLE[MAXRESOURCE];/*可用资源数组*/

intMAX[MAXPROCESS][MAXRESOURCE];/*最大需求矩阵*/

intALLOCATION[MAXPROCESS][MAXRESOURCE];/*分配矩阵*/

intNEED[MAXPROCESS][MAXRESOURCE];/*需求矩阵*/

intREQUEST[MAXPROCESS][MAXRESOURCE];/*进程需要资源数*/

boolFINISH[MAXPROCESS];/*系统是否有足够的资源分配*/

intp[MAXPROCESS];/*记录序列*/

intm,n;/*m个进程,n个资源*/

voidInit（）;

boolSafe（）;

voidDijkstra（）;

intmain（）

{Init（）;

Safe（）;

Dijkstra（）;

}

voidInit（）/*初始化算法*/

{inti,j;

cout<<"请输入进程的数目:

";

cin>>m;

cout<<"请输入资源的种类:

";

cin>>n;

cout<<"请输入每个进程最多所需的各资源数,按照"<

for（i=0;i

for（j=0;j

cin>>MAX[i][j];

cout<<"请输入每个进程已分配的各资源数,也按照"<

for（i=0;i

{for（j=0;j

{cin>>ALLOCATION[i][j];

NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];

if（NEED[i][j]<0）

{

cout<<"您输入的第"<

"<

j--;

continue;

}

}

}

cout<<"请输入各个资源现有的数目:

"<

for（i=0;i

{cin>>AVAILABLE[i];

}

}

voidDijkstra（）/*银行家算法*/

{inti,cusneed;

charagain;

while

（1）

{cout<<"请输入要申请资源的进程号（注:

第1个进程号为0,依次类推）"<

cin>>cusneed;

cout<<"请输入进程所请求的各资源的数量"<

for（i=0;i

{cin>>REQUEST[cusneed][i];

}

for（i=0;i

{if（REQUEST[cusneed][i]>NEED[cusneed][i]）

{

cout<<"您输入的请求数超过进程的需求量!

请重新输入!

"<

continue;

}

if（REQUEST[cusneed][i]>AVAILABLE[i]）

{

cout<<"您输入的请求数超过系统有的资源数!

请重新输入!

"<

continue;

}

}

for（i=0;i

{

AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

}

if（Safe（））

{

cout<<"同意分配请求!

"<

}

else

{

cout<<"您的请求被拒绝!

"<

for（i=0;i

{AVAILABLE[i]+=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];

NEED[cusneed][i]+=REQUEST[cusneed][i];

}

}

for（i=0;i

{FINISH[i]=false;

}

cout<<"您还想再次请求分配吗?

是请按y/Y,否请按其它键"<

cin>>again;

if（again=='y'||again=='Y'）

{

continue;

}

break;

}

}

boolSafe（）/*安全性算法*/

{inti,j,k,l=0;

intWork[MAXRESOURCE];/*工作数组*/

for（i=0;i

Work[i]=AVAILABLE[i];

for（i=0;i

{FINISH[i]=false;

}

for（i=0;i

{

if（FINISH[i]==true）

{continue;

}

else

{

for（j=0;j

{

if（NEED[i][j]>Work[j]）

{break;

}

}

if（j==n）

{FINISH[i]=true;

for（k=0;k

{

Work[k]+=ALLOCATION[i][k];

}

p[l++]=i;

i=-1;

}

else

{continue;

}

}

if（l==m）

{cout<<"系统是安全的"<

cout<<"安全序列:

"<

for（i=0;i

{cout<

if（i!

=l-1）

{

cout<<"-->";

}

}

cout<<""<

returntrue;

}

}

cout<<"系统是不安全的"<

returnfalse;

}

1．6运行结果及分析

1．7心得体会

整个设计中最麻烦的就是程序模块的划分和各模块之间接口设计，编程经常犯想当然的错误，出现了不少奇怪的错误。

再调试中尝试使用了分割法,对错误模块进行定位,再进行排查.

在算法实现上要有一定的思路体现设计的目的。

同时上机调试也是十分重要的，在调试的过程中能够不断的发现在编写算法时应该注意的一些细节和算法语句的非法使用，在调试过程中通过对算法的不断测试、更正、扩充功能、修饰细节，使算法程序不断的得到完善。

题目3磁盘调度算法的模拟

1．1题目的主要研究内容及预期达到的目标

（1）编程序模拟实现磁盘调度算法中的FCFS、SSTF、SCAN和CSCAN算法。

（2）基本完成了模拟实现FCFS、SSTF、SCAN和CSCAN调度算法。

1．2题目研究的工作基础或实验条件

（1）硬件环境：

windows系统

（2）软件环境：

C语言

1．3设计思想

（1）先来先服务．（First-Come，First-Served，FCFS）:

这是一种简单的磁盘调度算法。

它根据进程请求访问磁盘的先后次序进行调度。

此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。

但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。

（2）最短寻道时间优先（ShortestSeekTimeFirst，SSTF）:

该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。

（3）扫描（SCAN）算法:

SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。

例如，当磁头正在自里向外移动时，SCAN算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。

这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。

这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。

由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。

（4）循环扫描（CSCAN）算法:

处理该进程的请求，致使该进程的请求被严重地推迟。

为了减少这种延迟，CSCAN算法规定磁头单向移动。

例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。

1．4流程图

（1）FCFS算法流程图：

（2）SSTF算法流程图：

（3）SCAN算法:

（4）CSCAN算法：

1．5主要程序代码

#include

#include

#include

#include

#include

typedefstruct{

intn;

intvisited;

}L;

voidfifo（ints[],inta,intn）;

voidzuijin（ints[],inta,intn）;

voidscan（ints[],inta,intn,intz）;

voidcscan（ints[],inta,intn,intz）;

inta;

intNG=0;

floatNsum=0;

voidmain（）{

intstring[50];

inti;

intj=0;

intn;

intf;

intN;

printf（"输入当前磁道号（0-200）:

"）;

scanf（"%d",&a）;

printf（"输入要访问的磁道数量（0-50）：

"）;

scanf（"%d",&n）;

for（j;j

printf（"输入寻道序列串：

"）;

scanf（"%d",&string[j]）;

}

printf（"-------------------------------------\n"）;

printf（"|0.退出|\n"）;

printf（"|1.先来先服务|\n"）;

printf（"|2.最短寻道时间优先|\n"）;

printf（"|3.电梯调度算法|\n"）;

printf（"|4.循环扫描算法|\n"）;

printf（"|5.返回菜单|\n"）;

printf（"-------------------------------------\n"）;

printf（"选择：

"）;

while（i!

=0）{

scanf（"%d",&i）;

switch（i）{

case0:

i=0;

break;

case1:

fifo（string,a,n）;

break;

case2:

zuijin（string,a,n）;

break;

case3:

printf（"输入磁头移动方向（0向内1向外）：

"）;

scanf（"%d",&f）;

scan（string,a,n,f）;

break;

case4:

printf（"输入磁头移动方向（0向内1向外）：

"）;

scanf（"%d",&f）;

cscan（string,a,n,f）;

break;

case5:

printf（"-------------------------------------\n"）;

printf（"|0.退出|\n"）;

printf（"|1.先来先服务|\n"）;

printf（"|2.最短寻道时间优先|\n"）;

printf（"|3.电梯调度算法|\n"）;

printf（"|4.循环扫描算法|\n"）;

printf（"|5.返回菜单|\n"）;

printf（"--------