进程调度算法的模拟实现Word下载.docx

进程调度算法的模拟实现Word下载.docx

《进程调度算法的模拟实现Word下载.docx》由会员分享，可在线阅读，更多相关《进程调度算法的模拟实现Word下载.docx（34页珍藏版）》请在冰豆网上搜索。

显示每种进程调度算法情况.

（6）平均周转时间与平均带权周转时间的计算结果.

（7）退出系统模块。

3。

2系统流程图

3系统详细设计

（1）系统主界面设计（包含登陆模块设计）

首先将各种进程调度算法放入不同的头文件，在主函数引用，是系统结构更加清晰。

设置一个mean（）方法，让用户选择不同的进程调度算法，mean（）方法返回一个char类型字符，以便在主函数的switch语句中选择调用不同的进程调度方法.

（2）系统模块

1.先来先服务算法

对于先到达的进程优先分配CPU,按照先来先服务的原则依次执行各进程。

算法:

voidFCFS（fcfs*p，intN）

｛floatsumzztime=0，sumdqzztime=0,avzztime,avdqzztime;

floatarrivetime=0,servicetime=0,starttime=0，finishtime=0,zztime=0，dqzztime=0;

sort（p,N）；

deal（p，arrivetime,servicetime,starttime,finishtime,zztime，dqzztime，N）；

Print（p,arrivetime,servicetime,starttime,finishtime，zztime,dqzztime,N）;

for（intk=0;

k〈=N—1;

k++）

｛

sumzztime=sumzztime+p［k].zztime；

sumdqzztime=sumdqzztime+p[k］。

dqzztime;

｝

avzztime=sumzztime/N；

printf（"

\n该算法的平均周转时间为：

%-。

2f\t”,avzztime）；

avdqzztime=sumdqzztime/N;

printf（”该算法的平均带权周转时间为:

%—.2f\t\n\n"

，avdqzztime）；

｝

短进程优先算法

先找到运行时间最短的程序，然后执行，再从剩余的程序中找到运行时间最短的在执行，依次每次都执行运行时间最短的,直到程序执行完毕。

voidsjff（sjf＊p,intN1）

｛

floatsumzztime=0，sumdqzztime=0，avzztime，avdqzztime；

floatarrivetime=0,servicetime=0，starttime=0,finishtime=0，zztime=0，dqzztime=0;

deal（p,arrivetime，servicetime,starttime，finishtime，zztime，dqzztime,N1）;

Print（p,arrivetime,servicetime，starttime,finishtime,N1）;

for（intk=0；

k<

=N1—1；

sumzztime=sumzztime+p[k］。

zztime;

sumdqzztime=sumdqzztime+p[k]。

}

avzztime=sumzztime/N1；

printf（”\n该算法的平均周转时间为：

%—.2f\t"

，avzztime）；

avdqzztime=sumdqzztime/N1；

该算法的平均带权周转时间为:

avdqzztime）；

}

3.时间片轮转算法

按照轮转的次序分配给每个程序一定的时间执行,执行完成后执行后面的进程,依次循环执行直到所有进程执行完成。

算法：

voidtt（rr*p，intN2）

｛floatsumzztime=0，sumdqzztime=0,avzztime=0,avdqzztime=0；

inttimeprice=0;

floatarrivetime=0，servicetime=0,starttime=0,finishtime=0，zztime=0，dqzztime=0，lefttime=0；

ptt（p，arrivetime，servicetime,starttime,finishtime,zztime，dqzztime,avzztime，avdqzztime，lefttime,timeprice,N2）；

printf（”\n综合信息为:

\n”）；

Print（p,arrivetime,servicetime,starttime，finishtime，zztime,dqzztime，N2）;

=N2-1;

zztime；

sumdqzztime=sumdqzztime+p[k］.dqzztime；

avzztime=sumzztime/N2；

\n该算法的平均周转时间为:

％—。

2f\t"

avzztime）；

avdqzztime=sumdqzztime/N2；

printf（”该算法的平均带权周转时间为：

％-.2f\t\n"

，avdqzztime）;

getchar（）；

｝

4。

最高响应比优先算法

按照优先级从高到低依次执行程序.

intHRN（intpre）

{

intcurrent=1，i，j;

/＊优先权=（等待时间+服务时间）/服务时间＊/

for（i=0;

i<

N4;

i++）

JCB［i]。

waiTime=JCB[pre］。

finTime—JCB[i］。

arrTime;

/＊等待时间=上一个作业的完成时间—到达时间＊/

JCB[i］。

priority=（JCB［i］。

waiTime+JCB［i］.serTime）/JCB[i]。

serTime;

i〈N4;

if（!

JCB［i］。

finish）

{

current=i；

/*找到第一个还没完成的作业*/

break；

}

for（j=i;

j<

N4；

j++）/*和后面的作业比较＊/

{

if（!

JCB[j］。

finish）/*还没完成（运行）*/

if（JCB[current].arrTime〈=JCB［pre］.finTime）/*如果作业在上一个作业完成之前到达*/

｛

if（JCB［j].arrTime〈=JCB[pre]。

finTime＆&

JCB[j］.priority〉JCB［current].priority）

current=j;

/＊找出到达时间在上一个作业完成之前，优先权高的作业＊/

｝

else/*如果作业是在上一个作业完成之后到达＊/

{

if（JCB[j］。

arrTime〈JCB［current]。

arrTime）

/＊找出比较早到达的一个*/

if（JCB［j].arrTime==JCB[current］。

arrTime）/＊如果同时到达*/

if（JCB［j］。

priority>

JCB［current]。

priority）

current=j；

/＊找出服务时间比较短的一个＊/

returncurrent；

/＊返回当前作业＊/

4结果与分析

4.1测试方案

（1）测试方案

（一）

在主界面输入1，选择先来先服务调度算法，然后输入进程数目5，然后输入各个进程信息，观察测试结果。

（2）测试方案

（二）

在主界面输入2，选择最短进程优先调度算法，然后输入进程数目5，然后输入各个进程信息，进程信息与测试方案

（一）保持一致,观察测试结果，对比方案一.

（3）测试方案（三）

在主界面输入3，选择时间片轮转调度算法，然后输入进程数目5，然后输入各个进程信息，进程信息与测试方案

（一）保持一致，观察测试结果，对比方案一和二。

（4）测试方案（四）

在主界面输入4，选择时间片轮转调度算法，然后输入进程数目5,然后输入各个进程信息，进程信息与测试方案

（一）保持一致，观察测试结果，对比方案一和二和三.

2测试结果

（1）测试方案

（一）结果。

输入测试进程数5，测试用例分别为（A04），（B13）,（C25）,（D32），（E44），测试结果见图（图4—1先来先服务调度算法）

图4—1先来先服务调度算法

由运行结果可以看出，短作业D的服务时间最短，但带权周转时间高达5。

5,而长作业C的服务时间为5，带权周转时间仅为2，因此先来先服务算法比较有利于长作业，而不利于短作业

（2）测试方案

（2）结果。

输入测试进程数5，测试用例分别为（A04），（B13），（C25），（D32）,（E44）,测试结果见图（图4—2短作业优先调度算法）

图4—2短作业优先调度算法

由运行结果可以看出，短作业优先算法每次都从未完成的队列中选取服务时间最短的作业进行调度。

通过比较，短作业优先算法的平均带权周转时间小于先来先服务算法,提高了系统的吞吐量.因此，相对于短作业较多或者较为重要的系统中，可选这短作业优先调度算法。

（3）测试方案（三）结果.

输入测试进程数5，测试用例分别为（A04），（B13），（C25）,（D32）,（E44），测试结果见图（图4-3。

1,4—3.2,4-3。

3时间片轮转调度算法）

图4-3.1时间片轮转调度算法

图4—3。

2时间片轮转调度算法

图4—3.3时间片轮转调度算法

从多次运行结果来看，时间片轮转调度算法不同的时间片对结果有很大的影响.

（4）测试方案（四）结果.

输入测试进程数5，测试用例分别为（A04），（B13）,（C25）,（D32），（E44），测试结果见图（图4-4最高响应比优先调度算法）

图4-4最高响应比优先调度算法

由运行结果可以看出，该算法既照顾了短作业，有考虑了作业到达的先后次序，不会使长作业长期得不到服务。

因此,该算法是一个很好的折衷

4.3测试结果分析

四种调度算法各有优劣.先来先服务算法比较有利于长进程，而不利于短进程，有利于CPU繁忙的进程，而不利于I/O繁忙的进程。

短作业优先调度算法相比FCFS算法，该算法可改善平均周转时间和平均带权周转时间,缩短进程的等待时间,提高系统的吞吐量。

缺点是对长进程非常不利,可能长时间得不到执行，且未能依据进程的紧迫程度来划分执行的优先级，以及难以准确估计进程的执行时间，从而影响调度性能.时间片轮转调度算法的特点是简单易行、平均响应时间短,但不利于处理紧急作业。

在时间片轮转算法中，时间片的大小对系统性能的影响很大，因此时间片的大小应选择恰当.高响应比优先调度策略是对FCFS方式和SJF方式的一种综合平衡，同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。

5设计小结

经过一周的努力，课程设计基本完成了，这次课程设计培养了我们耐心、慎密、全面地考虑问题的能力,从而加快了问题解决的速度、提高了个人的工作效率，以及锻炼围绕问题在短时间内得以解决的顽强意志。

课程设计是我们专业课程知识综合应用的实践训练,也是为我们以后的工作夯实基础。

通过改程序对操作系统的基础知识了解得更透彻了,同时对磁盘调度的四种算法——先来先服务算法，短进程优先调度算法，时间片轮转调度算法，动态优先级调度有了更深刻的理解和掌握,使我能够为进程调度选择适当的算法，提高CPU工作效率.进行进程调度程序设计的过程中,得到老师的大力指导和同学的支持，在此向他们表示感谢。

经过自己的动手操作和同学老师的指导我成功的做出了课程设计自己感到很高兴。

在编写程序的过程中，我们的能力得到了提高，同时养成了科学、严谨的作风和习惯。

为此要感谢信息学院开设了这门操作系统课程设计，为我们提供了进一步学习算法、操作系统和巩固C语言程序计设的平台.

6参考文献

［1］严蔚敏,吴伟民。

数据结构[M］。

清华大学出版社，1997.

［2］张尧学，史美林.计算机操作系统教程［M]。

清华大学出版社，2000.

[3］孙静宇。

计算机操作系统课程设计指导书[M］。

太原理工出版社，2006.

［4]汤小丹，梁红兵，哲凤屏,汤子赢。

计算机操作系统（第五版）[M］.西安:

西安电子科技大学出版社，2007。

［5］何钦铭，颜晖.C语言程序设计［M］。

北京:

高等教育出版社，2008.

[6]胡学刚，数据结构（C语言版）[M]。

高等教育出版社，2008。

［7]张小进，Linux系统应用基础教程［M］.北京：

机械工业出版社,2008.

［8］孟庆昌，C语言程序设计[M].北京：

人民邮电出版社,2006.

7附录程序代码

Main.cpp

＃include〈cstdlib〉

＃include<

iostream>

#include<

iomanip〉

#include"

fcfs。

h”//先来先服务

＃include”sjf。

h”//短作业优先

rr.h”//时间片轮转

hrrn.h”//高响应比优先"

usingnamespacestd；

charmenu（）//用来输出相关信息的函数

｛

charcse1；

while

（1）

system（”cls”）；

fflush（stdin）；

cout<

〈endl;

cout〈<

endl；

cout〈〈”\t”<

<

"

”〈〈"

\t进程调度算法模拟"

〈<

\t\t”〈〈”"

〈〈endl;

cout〈〈"

\t”〈〈”"

endl;

\t"

"

\t\t1.先来先服务调度算法”〈〈"

\t\t”<

””〈<

”\t\t2。

短作业优先调度算法"

〈〈"

\t\t”〈〈””<

”\t”<

”"

〈"

\t\t3。

时间片轮转调度算法"

\t\t\t”<

〈endl；

”\t”〈〈””〈〈endl;

〈”\t”<

〈”"

〈”\t\t4.最高响应比优先调度算法"

”\t\t"

〈〈””<

\t”〈〈"

”\t"

〈””<

〈”\t\t0.退出系统"

”\t\t”〈〈"

cout〈〈endl；

\t\t请输入您的选择（0/1/2/3/4）：

”;

cse1=getchar（）;

if（cse1<

’0’|｜cse1>

’4'

）

｛cout〈<

o（╯□╰）o您的输入有误！

请重新输入正确的字符o（╯□╰）o”〈〈endl；

cout〈〈endl;

system（"

PAUSE”）；

else

returncse1；

intmain（intargc,char＊argv[］）

switch（menu（））

case'

1’:

{fcfsRun（）;

break；

}

2’：

{sjfRun（）；

break;

3’：

{rrRun（）;

}

4'

:

｛hrrnRun（）;

0'

：

{exit（0）;

｝

system（"

returnEXIT_SUCCESS;

h

stdio。

h〉

stdlib。

usingnamespacestd;

structfcfs｛//定义先来先服务调度算法结构体

charname［10］；

/./作业名

floatarrivetime;

//作业到达时间

floatservicetime；

//作业服务

floatstarttime；

//作业开始时间

floatfinishtime;

//作业完成时间

floatzztime;

//带权周转时间

floatdqzztime；

//平均带权周转时间

}；

fcfsa［100］；

//定义存放进程的数组

voidinput（fcfs*p,intN）//输入处理

{

inti;

cout〈〈endl；

请您输入进程的名字到达时间服务时间：

（例如：

a0100）\n\n”）；

i〈=N-1；

i++）

{

printf（”请您输入进程％d的信息：

i+1）;

scanf（”\t\t\t％s％f％f”,＆p［i].name,＆p［i］。

arrivetime，&

p[i］.servicetime）；

}

}

voidPrint（fcfs*p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,floatzztime，floatdqzztime,intN）//屏幕输出处理

intk；

\n\n调用先来先服务算法以后进程运行的顺序是：

）；

％s"

，p[0］.name）；

for（k=1；

N；

printf（"

-->

，p［k]。

name）;

｝

\n具体进程调度信息：

\n”）;

\t进程名到达时间服务时间开始时间结束时间周转时间带权周转时间\n"

for（k=0；

k〈=N—1；

printf（”\t%s\t％—.2f\t％-。

2f\t%-.2f\t％—.2f\t％—.2f\t%—.2f\n"

，p[k］.name，p［k]。

arrivetime,

p［k].servicetime,p［k］.starttime，p［k]。

finishtime,p［k］。

zztime，p[k].dqzztime）；

getchar（）;

//此处必须要有这个函数，否则就看不到显示器上面的输出，可以看到的结果只是一闪而过的一个框剪

voidsort（fcfs＊p,intN）//按进程的到达时间进行排序

for（inti=0;

i〈=N—1;

for（intj=0；

j〈=i；

j++）

if（p[i].arrivetime〈p[j]。

arrivetime）

｛

fcfstemp;

temp=p[i］;

p[i]=p[j]；

p［j］=temp;

｝

voiddeal（fcfs＊p,floatarrivetime，floatservicetime,floatstarttime，floatfinishtime,float＆zztime，float＆dqzztime，intN）//运行阶段，根据先来先服务的原则进行处理

intk;

k〈=N-1；

｛

if（k==0）

{

p[k]。

starttime=p[k]。

arrivetime；

finishtime=p[k]。

arrivetime+p［k].servicetime；

else