作业调度实验报告.docx
《作业调度实验报告.docx》由会员分享，可在线阅读，更多相关《作业调度实验报告.docx（31页珍藏版）》请在冰点文库上搜索。
作业调度实验报告
作业调度实验报告
实验二作业调度
一.实验题目
1、编写并调试一个单道处理系统的作业等待模拟程序。
作业调度算法：
分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。
（1）先来先服务算法：
按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。
（2）最短作业优先算法：
是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。
（3）响应比高者优先算法：
是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。
2、编写并调度一个多道程序系统的作业调度
图一.先来先服务流程图
4）源程序:
#include
#include
#include
#definegetpch（type）（type*）malloc（sizeof（type））
#defineNULL0
intn;
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（）//初始化界面
{
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\t\t\t计算机学院软件四班\n"）;
printf（"\t\t\t\t\t蓝小花\n"）;
printf（"\t\t\t\t\t3204007102\n"）;
printf（"\t\t\t\t\t完成日期：
2006年11月17号"）;
printf（"\n\n\n\t\t请输入任意键进入演示过程\n"）;
getch（）;
}
voidinital（）//建立作业控制块队列,先将其排成先来先服务的模式队列
{
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;
T2+=p->cltime;
disp（p,m）;//调用disp（）函数,显示作业运行情况
times+=p->needtime;
p->state='F';
printf（"\n%shasbeenfinished!
\npressanykeytocontinue...\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（）函数
}
}//for
final（）;//调用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）{
i--;//printf（"\ntime=%d:
\tnoJCBsubmib...wait...",time）;
times++;
if（times>100）{printf（"\nruntimeistoolong...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（）;//调用running（）函数
}
voidmune（）
{
intm;
system（"cls"）;
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\t选择所要操作:
"）;
scanf（"%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;//初始化周转时间,带权周转时间.
inttimes=0;//初始化开始运行时间
intfreesa=100,disksa=5;//预定内存的大小为100k,磁带数量为5个.
structjcb//作业控制块
{
charusername[10];//用户名
charname[10];//作业名
intreachtime;//作业到达时间
intstarttime;//作业开始时间
intruntime;//已经运行了的时间
intneedtime;//作业需要运行的时间
intfrees;//作业要占用的内存
intdisks;//作业所需磁带
intfinishtime;//作业完成时间
floatcycletime;//作业周转时间
floatcltime;//作业带权周转时间
charstate;//作业状态
structjcb*next;//结构体指针
}*ready=NULL,*start=NULL,*p,*q,*r,*s,*t;
typedefstructjcbJCB;
voidinital（）//建立作业控制块队列,先将其排成先来先服务的模式队列
{
inti;
printf（"\n输入作业数:
"）;
scanf（"%d",&n）;
for（i=0;i{
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"）;
printf（"\t\t*********************************************\t\t\n"）;
printf（"\n\t\t1.多道作业调度演示."）;
printf（"\n\t\t0.退出程序"）;
printf（"\n\t\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完成日期：
2006年12月"）;
sc
升级会员 