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

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

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

进程调度算法的模拟实现

进程调度算法的模拟实现

编辑整理：

尊敬的读者朋友们：

这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（进程调度算法的模拟实现）的内容能够给您的工作和学习带来便利。

同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。

本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为进程调度算法的模拟实现的全部内容。

操作系统课程设计报告

题目:

进程调度算法的模拟实现_

专业

计算机科学与技术

学生姓名

班级

学号

指导教师

发放日期

2015.1.30

信息工程学院

进程调度算法的模拟实现

1概述

选择一个调度算法，实现处理机调度，进程调度算法包括：

先来先服务算法，短进程优先算法,时间片轮转算法，动态优先级算法。

可选择进程数量，本程序包括四种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现）,进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。

2设计原理

2.1先来先服务（FCFS）算法

每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存,为它们分配资源创建进程，然后放入就绪队列

2。

2时间片轮转法（RR）算法

系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

时间片的大小从几ms到几百ms。

当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

2。

3短作业优先（SJF）算法

短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它,使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。

2。

4最高优先权优先（HRRN）算法

优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法.动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。

3详细设计与编码

3.1模块设计

（1）进入系统模块，进入登陆界面。

（3）菜单选择模块。

选择相应的进程调度方式,选择相应的数字，进入相应的功能。

（4）算法模块。

选择相应的进程调度算法。

（5）显现输出模块。

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

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

（7）退出系统模块。

3。

2系统流程图

3。

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）；

｝

2。

短进程优先算法

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

算法:

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；k++）

｛

sumzztime=sumzztime+p[k］。

zztime;

sumdqzztime=sumdqzztime+p[k]。

dqzztime;

}

avzztime=sumzztime/N1；

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

%—.2f\t"，avzztime）；

avdqzztime=sumdqzztime/N1；

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

%—.2f\t\n\n",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）;

for（intk=0;k<=N2-1;k++）

｛

sumzztime=sumzztime+p[k］。

zztime；

sumdqzztime=sumdqzztime+p[k］.dqzztime；

}

avzztime=sumzztime/N2；

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

％—。

2f\t",avzztime）；

avdqzztime=sumdqzztime/N2；

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

％-.2f\t\n"，avdqzztime）;

getchar（）；

｝

4。

最高响应比优先算法

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

算法：

intHRN（intpre）

{

intcurrent=1，i，j;/＊优先权=（等待时间+服务时间）/服务时间＊/

for（i=0;i

｛

JCB［i]。

waiTime=JCB[pre］。

finTime—JCB[i］。

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

JCB[i］。

priority=（JCB［i］。

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

serTime;

｝

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

｛

if（!

JCB［i］。

finish）

{

current=i；/*找到第一个还没完成的作业*/

break；

}

｝

for（j=i;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）

current=j;/＊找出比较早到达的一个*/

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,然后输入各个进程信息，进程信息与测试方案

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

4。

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

#include

#include"fcfs。

h”//先来先服务

＃include”sjf。

h”//短作业优先

#include"rr.h”//时间片轮转

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

usingnamespacestd；

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

｛

charcse1；

while

（1）

{

system（”cls”）；

fflush（stdin）；

cout<〈endl;

cout〈

cout〈〈”\t”<<"”〈〈"\t进程调度算法模拟"〈<"\t\t”〈〈”"〈〈endl;

cout〈〈"\t”〈〈”"<

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

cout〈<"\t"<<""〈

cout<<"\t"〈<””〈<”\t\t2。

短作业优先调度算法"〈〈"\t\t”〈〈””<〈endl;

cout〈<”\t”<<”"〈〈endl;

cout<〈"\t"〈<”"〈〈"\t\t3。

时间片轮转调度算法"〈〈"\t\t\t”<<""<〈endl；

cout<<”\t”〈〈””〈〈endl;

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

cout<<"\t”〈〈""〈

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

cout<〈endl；

cout〈〈endl；

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

”;

cse1=getchar（）;

if（cse1<’0’|｜cse1>’4'）

｛cout〈

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

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

cout〈〈endl;

system（"PAUSE”）；

}

else

break；

}

returncse1；

｝

intmain（intargc,char＊argv[］）

｛

while

（1）

{

switch（menu（））

{

case'1’:

{fcfsRun（）;

break；

}

case'2’：

{sjfRun（）；

break;

}

case'3’：

{rrRun（）;

break；

}

case'4':

｛hrrnRun（）;

break;

}

case'0'：

{exit（0）;

}

｝

｝

system（"PAUSE”）；

returnEXIT_SUCCESS;

｝

fcfs。

h

＃include

h〉

#include

h〉

usingnamespacestd;

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

charname［10］；/./作业名

floatarrivetime;//作业到达时间

floatservicetime；//作业服务

floatstarttime；//作业开始时间

floatfinishtime;//作业完成时间

floatzztime;//带权周转时间

floatdqzztime；//平均带权周转时间

}；

fcfsa［100］；//定义存放进程的数组

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

{

inti;

cout〈〈endl；

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

（例如：

a0100）\n\n”）；

for（i=0;i〈=N-1；i++）

{

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

\t",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；

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

"）；

printf（"％s"，p[0］.name）；

for（k=1；k

{

printf（"-->％s"，p［k]。

name）;

｝

cout〈〈endl；

printf（"\n具体进程调度信息：

\n”）;

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

for（k=0；k〈=N—1；k++）

｛

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;i++）

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;

for（k=0；k〈=N-1；k++）

｛

if（k==0）

{

p[k]。

starttime=p[k]。

arrivetime；

p[k]。

finishtime=p[k]。

arrivetime+p［k].servicetime；}

else

{