作业调度实验报告.docx

作业调度实验报告.docx

《作业调度实验报告.docx》由会员分享，可在线阅读，更多相关《作业调度实验报告.docx（17页珍藏版）》请在冰豆网上搜索。

作业调度实验报告

欢迎阅读

实验二作业调度

一.实验题目

1、编写并调试一个单道处理系统的作业等待模拟程序。

作业调度算法：

分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。

1）先来先服务算法：

按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。

2）最短作业优先算法：

是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行

时间最短的作业

（3）响应比高者优先算法：

是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。

2、编写并调度一个多道程序系统的作业调度模拟程序。

作业调度算法：

采用基于先来先服务的调度算法。

可以参考课本中的方法进行设计。

对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

二.实验目的：

本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解

三.实验过程

<一>单道处理系统作业调度

1）单道处理程序作业调度实验的源程序:

zuoye.c

执行程序:

zuoye.exe

2）实验分析：

1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU时限等因素。

2、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：

作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W（Wait）、运行R（Run）和完成F（Finish）三种状态之一。

每个作业的最初状态总是等待W。

3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。

3）流程图:

图一.先来先服务流程图

4）源程序:

#include

#include

#include

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

#defineNULL0intn;

floatT1=0,T2=0;

inttimes=0;

structjcb//作业控制块

{

charname[10];//作业名

intreachtime;//intstarttime;//intneedtime;//floatsuper;//intfinishtime;//floatcycletime;//floatcltime;//

charstate;//

structjcb*next;//}*ready=NULL,*p,*q;typedefstructjcbJCB;voidinize（）//{

作业到达时间

作业开始时间作业需要运行的时间作业的响应比作业完成时间作业周转时间作业带权周转时间作业状态结构体指针

初始化界面

*\t\t

printf（"\n\n\t\t

\n"）;

printf（"\t\t\t\t实验二作业调度\n"）;

*\t\t\n"）

printf（"\t\t********************************************

printf（"\n\n\n\t\t\t\t\t计算机学院软件四班\n"）;printf（"\t\t\t\t\t蓝小花\n"）;printf（"\t\t\t\t\t3204007102\n"）;

printf（"\t\t\t\t\t

printf（"\n\n\n\t\t

getch（）;

}

voidinital（）

//

完成日期：

2006年11月17号"）;请输入任意键进入演示过程\n"）;

建立作业控制块队列,先将其排成先来先服务的模式队

{

inti;

printf（"\n输入作业数:

"）;

scanf（"%d",&n）;

for（i=0;i

{

p=getpch（JCB）;

printf（"\n输入作业名:

"）;scanf（"%s",p->name）;

getch（）;p->reachtime=i;

printf（"作业默认到达时间:

%d",i）;printf（"\n输入作业要运行的时间:

"）;scanf（"%d",&p->needtime）;

p->state='W';p->next=NULL;

if（ready==NULL）ready=q=p;

else{q->next=p;q=p;

}

}

}

voiddisp（JCB*q,intm）//显示作业运行后的周转时间及带权周转时

间等

{

if（m==3）//显示高响应比算法调度作业后的运行情况{

printf（"\n作业%s正在运行，估计其运行情况：

\n",q->name）;

printf（"开始运行时刻：

%d\n",q->starttime）;

printf（"完成时刻：

%d\n",q->finishtime）;

printf（"周转时间：

%f\n",q->cycletime）;

printf（"带权周转时间：

%f\n",q->cltime）;

printf（"相应比:

%f\n",q->super）;

getch（）;

}

else//显示先来先服务,最短作业优先算法调度后作业的运行情况

{

printf（"\n作业%s正在运行，估计其运行情况：

\n",q->name）;

printf（"开始运行时刻：

%d\n",q->starttime）;

printf（"完成时刻：

%d\n",q->finishtime）;

printf（"周转时间：

%f\n",q->cycletime）;

printf（"带权周转时间：

%f\n",q->cltime）;getch（）;

}

}

voidrunning（JCB*p,intm）//运行作业

{

if（p==ready）//先将要运行的作业从队列中分离出来{

ready=p->next;

p->next=NULL;}else

{q=ready;while（q->next!

=p）q=q->next;

q->next=p->next;

}

计算作业运行后的完成时间,周转

p->starttime=times;//时间等等

p->state='R';

p->finishtime=p->starttime+p->needtime;

p->cycletime=（float）（p->finishtime-p->reachtime）;

p->cltime=（float）（p->cycletime/p->needtime）;

T1+=p->cycletime;

调用disp（）函数,显示作业运行情况

T2+=p->cltime;disp（p,m）;//times+=p->needtime;

p->state='F';printf（"\n%scontinue...\n",p->name）;

free（p）;//getch（）;

}

voidsuper（）//

{

JCB*padv;padv=ready;do{if（padv->state=='W'&&padv->reachtime<=times）

padv->super=（float）（times-padv->reachtime+padv->needtime）/padv->needtime

padv=padv->next;

}while（padv!

=NULL）;

}

voidfinal（）//最后打印作业的平均周转时间,平均带权周转时间{

floats,t;

t=T1/n;

s=T2/n;

getch（）;

作业已经全部完成!

"）;

printf（"\n\n

printf（"\n%d个作业的平均周转时间是：

%f",n,t）;

printf（"\n%d个作业的平均带权周转时间是%f：

\n\n\n",n,s）;

}

voidhrn（intm）//高响应比算法

{

JCB*min;inti,iden;system（"cls"）;inital（）;

for（i=0;i

{

p=min=ready;iden=1;

super（）;

do{if（p->state=='W'&&p->reachtime<=times）if（iden）

{min=p;iden=0;

}

elseif（p->super>min->super）min=p;p=p->next;

}while（p!

=NULL）;

if（iden）

{

i--;times++;

//printf（"\ntime=%d:

\tnoJCBsubmib...wait...",time）;

if（times>1000）

{printf（"\nruntimeistoolong...error..."）;getch（）;}}

else

{running（min,m）;//调用running（）函数}

}//forfinal（）;//调用running（）函数

}

voidsjf（intm）//最短作业优先算法

{

JCB*min;

inti,iden;system（"cls"）;inital（）;for（i=0;i

p=min=ready;iden=1;

do{if（p->state=='W'&&p->reachtime<=times）if（iden）{

min=p;iden=0;

}

elseif（p->needtimeneedtime）min=p;p=p->next;

}while（p!

=NULL）;

if（iden）{

JCB

i--;//printf（"\ntime=%d:

\tno

submib...wait...",time）;

times++;

too

if（times>100）{printf（"\nruntimeislong...error"）;getch（）;}

}

else{

running（min,m）;//调用running（）函数

}

}//for

final（）;//调用running（）函数

}

voidfcfs（intm）//先来先服务算法

{

inti,iden;system（"cls"）;

inital（）;for（i=0;i

{p=ready;iden=1;

do{if（p->state=='W'&&p->reachtime<=times）iden=0;if（iden）p=p->next;

}while（p!

=NULL&&iden）;

if（iden）

{

i--;

printf（"\n没有满足要求的进程,需等待"）;times++;

if（times>100）{printf（"\n时间过长"）;getch（）;}}

else{

running（p,m）;//调用running（）函数

}

}

final（）;//}voidmune（）{intm;system（"cls"）;

调用running（）函数

printf（"\n\n\t\t

*\t\t

\n"）;

printf（"\t\t\t\t

作业调度演示\n"）;

printf（"\t\t*********************************************\t\t\n"）;

printf（"\n\n\n\t\t\t1.

printf（"\n\t\t\t2.

printf（"\n\t\t\t3.

printf（"\n\t\t\t0.printf（"\n\n\t\t\t\tscanf（"%d",&m）;switch（m）

{

case1:

fcfs（m）;getch（）;system（"cls"）;mune（）;break;

case2:

sjf（m）;getch（）;system（"cls"）;mune（）;break;

case3:

先来先服务算法."）;最短作业优先算法."）;响应比高者优先算法"）;退出程序."）;

选择所要操作:

"）;

hrn（m）;getch（）;system（"cls"）;

mune（）;

break;

case0:

system（"cls"）;break;default:

printf（"getch（）;

选择错误,重新选择."）;

system（"cls"）;

mune（）;

}

}

main（）//主函数

{

inize（）;

mune（）;

}

5）调试结果:

1.选择操作的界面

2.输入操作初始信息:

3.先来先服务算法作业调度结果:

（调度顺序:

a->b->c->d->e）

4.最短作业优先算法作业调度结果（调度顺序:

a->d->b->e->c）

5.高响应比算法作业调度结果:

（调度顺序a->b->d->c->e）

<二>多道处理系统作业调度

1）多道处理程序作业调度实验的源程序:

duodao.c

执行程序:

duodao.exe

2）实验分析：

采用多道程序设计方法的操作系统，在系统中要经常保留多个运行的作业，以提高系统效率。

作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业，并为这些被选中的作业分配所需的系统资源。

对被选中运行的作业必须按照它们各自的作业说明书规定的步骤进行控制。

采用先来先服务算法算法模拟设计作业调度程序。

（1）、作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可占用处理器运行。

作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。

但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业的要求，那么，作业调度必须按一定的算法在这些作业中作出选择。

先来先服务算法是按照作业进入输入井的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业时，那么顺序挑选后面的作业。

（2）假定某系统可供用户使用的主存空间共100k，并有5台磁带机。

3）流程图:

4）源程序:

#include

#include

#include

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

#defineNULL0

intj=0;

intn,i;//n为需要输入的作业数量

floatT1=0,T2=0;//初始化周转时间,带权周转时间.

p=getpch（JCB）;printf（"\n输入用户名:

"）;scanf（"%s",p->username）;printf（"输入作业名:

"）;scanf（"%s",p->name）;

getch（）;p->reachtime=i;printf（"作业默认到达时间:

%d",i）;printf（"\n输入作业要运行的时间:

"）;

scanf（"%d",&p->needtime）;

printf（"输入作业运行要占用的内存:

"）;

scanf（"%d",&p->frees）;

printf（"输入作业运行所需磁带:

"）;

scanf（"%d",&p->disks）;

p->runtime=0;

p->state='W';p->next=NULL;

先将其按到达的先后顺序排成后备序列

if（ready==NULL）ready=q=p;//

else{q->next=p;q=p;

}

}

}intspace（）//计算内存中作业的个数

{intl=0;JCB*pr=start;while（pr!

=NULL）

{l++;pr=pr->next;

}

return（l）;

}

voidapply（）//把符合条件的作业调用内存,并给他们分配资源,

{intlen;p=ready;

while（p!

=NULL）

{if（p->frees<=freesa&&p->disks<=disksa）

{freesa-=p->frees;disksa-=p->disks;r=p;p=p->next;

if（r==ready）//先将符合条件的作业从队列中分离出来{

ready=r->next;r->next=NULL;

}else

{

q=ready;while（q->next!

=r）q=q->next;q->next=r->next;

}

if（start==NULL）start=s=r;//将其插到start队列,else{

s->next=r;s=r;

}

}

else

{

p=p->next;

}

}

len=space（）;

printf（"\n\t此时有%d道作业在内存\n\n",len）;

}

voiddisp（JCB*pr）/*建立作业显示函数*/

{

printf（"|%s\t",pr->username）;printf（"|%s\t",pr->name）;printf（"|%c\t",pr->state）;

printf（"|%d\t",pr->reachtime）;printf（"|%d\t",pr->needtime）;printf（"|%d\t",pr->runtime）;

printf（"|%d\t",pr->frees）;

printf（"|%d\t",pr->disks）;

printf（"\n"）;

}

voidcheck（）//显示作业状况

{

printf（"\n作业%s于完成%d个作业后运行完毕,其完成后的情况:

",q->name,j）;

j++;

printf（"\n用户名****作业名****状态****到达时间*需运行时间*已运行时

间*需占用内存*需磁带数量\n"）;

disp（q）;

s=start;

printf（"\n\t\t*********当前进入内存的作业状态*********"）;

printf（"\n用户名****作业名****状态****到达时间*需运行时间*已运行时

间*需占用内存*需磁带数量\n"）;

while（s!

=NULL）

{

disp（s）;

s=s->next;

}

r=ready;

printf（"*\n\n\t\t*********当前后备作业表中作业的状态**********"）;

printf（"\n用户名****作业名****状态****到达时间*需运行时间*已运行时

间*需占用内存*需磁带数量\n"）;

while（r!

=NULL）

{

disp（r）;

r=r->next;

}

运行作业

}

voidrunning（）//

{

for（t=start;t!

=NULL;）

{start=t->next;

q=t;

q->next=NULL;

q->state='R';q->runtime++;t=start;

times++;

if（q->runtime==q->needtime）

{

q->finishtime=times;q->starttime=q->finishtime-q->needtime;q->cycletime=q->finishtime-q->reachtime;q->cltime=（q->cycletime）/（q->needtime）;

T1+=q->cycletime;

T2+=q->cltime;

freesa+=q->frees;

disksa+=q->disks;

check（）;//调用check（）显示正在运行的,就绪的以及后备的作业信息free（q）;//释放作业

apply（）;//分配作业

getch（）;

}

else

{for（s=start;s->next!

=NULL;）s=s->next;s->next=q;

}

}

}

main（）//主函数

{

intm;

printf（"\n\n\t\t*********************************************\t\t\n"）;

printf（"\t\t\t\t实验三

（2）多道作业调度\n"）;

*\t\t\n"）;

printf（"\t\t*

printf（"\n\t\t1.多道作业调度演示."）;

printf（"\n\t\t0.printf（"\n\t\t\tprintf（"\n\n\n\t\t\t\t\tprintf（"\t\t\t\t\t

退出程序"）;选择所要的操作:

"）;

计算机学院软件四班\n"）;

蓝小花\n"）;

printf（"\t\t\t\t\t3204007102\n"）;

printf（"\t\t\t\t\tscanf（"%d",&m）;

完成日期：

2006年12月"）;

switch（m）{

case1:

system（"cls"）;

inital（）;

apply（）;

running（）;

getch（）;

system（"cls"）;

main（）;

break;

case0:

system（"cls"）;

break;

default:

system（"cls"）;

main（）;

}

}

5）调试结果:

1）界面跟前面的其他几个实验的界面大同小异,这里就不在重复出现界面.下面输出的是作业的初始信息:

2）调度作业,此时的作业情况如下:

3）按回车键,相当于作业继续调度,如下:

4）重复3>,直至作业运行结束;

四.思考题：

1.写出每种算法的调度策略，最后比较各种算法的优缺点。

答:

①FCFS算法总是把处理机分配给最先进入就绪队列的进程，一个进程一旦分得处理机，便执行下去，直到该进程完成或阻塞时，才释放处理机。

优点:

实现简单.缺点:

没考虑进程的优先级