操作系统作业实验二报告.docx

操作系统作业实验二报告.docx

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

操作系统作业实验二报告

江南大学实验报告

课程名称操作系统实验名称作业调度实验实验日期20141211

班级信计1202姓名任航学号1130112211仪器编号

实验报告要求1．实验目的2．实验要求3．实验步骤4．程序清单5．运行情况5．实验体会

一、实验目的：

用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

二. 实验要求：

（1）编写并调试一个单道处理系统的作业调度模拟程序。

　　作业等待算法：

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

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

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

作业调度算法：

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

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

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

3.实验步骤.

4.程序清单：

单道批处理先来先服务算法：

#include

#include

#include

intn;//全局变量n

floatT1=0,T2=0;//分别用来表示周转时间和带权周转时间之和

inttimes=0;

structjcb//作业控制块

{

charname[10];//作业名

intreachtime;//作业到达时间

intstarttime;//作业开始时间

intneedtime;//作业需要运行的时间

intfinishtime;//作业完成时间

floatcycletime;//作业周转时间

floatcltime;//作业带权周转时间

charstate;//作业状态

structjcb*next;//结构体指针

}*ready=NULL,*p,*q;

typedefstructjcbJCB;

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

{

inti;

printf（"\n\t\t输入作业数:

"）;

scanf（"%d",&n）;

for（i=0;i

{

p=（JCB*）malloc（sizeof（JCB））;//声明结点

printf（"\t\t输入第%d个作业名:

",i+1）;

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

p->reachtime=i;//第一个0秒到，第二个1秒到

printf（"\t\t第%d个作业到达时间默认为:

%d",i+1,i）;

printf（"\n\t\t输入作业要运行的时间:

"）;

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

p->state='W';//状态初始化为等待

p->next=NULL;

if（ready==NULL）//如果是第一个结点的话执行

{

ready=q=p;

}

else//不是第一个结点

{

q->next=p;//链接起来

q=p;//q向后移动一个结点，ready始终指向第一个

}

}

}

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

{

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）//运行作业

{

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）;//调用disp（）函数,显示作业运行情况

times+=p->needtime;//累加时间量

p->state='F';//完成状态

printf（"\n%shasbeenfinished!

\npressanykeytocontinue...\n",p->name）;

free（p）;//释放

getch（）;

}

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

}

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

{

inti,iden;

system（"cls"）;

inital（）;

for（i=0;i

{

p=ready;//p指向第一个

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）;//调用running（）函数

}

}

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

}

intmain（）//主函数

{

printf（"\n\t\t先来先服务算法,按任意键继续..."）;

getch（）;

fcfs（）;

}

单道批处理最短作业优先算法：

#include

#include

#include

intn;//全局变量n

floatt1=0,t2=0;//分别用来表示周转时间和带权周转时间之和

inttimes=0;

structjcb//作业控制块

{

charname[10];//作业名

intreachtime;//作业到达时间

intstarttime;//作业开始时间

intneedtime;//作业需要运行的时间

floatsuper;//作业的响应比

intfinishtime;//作业完成时间

floatcycletime;//作业周转时间

floatcptime;//作业带权周转时间

charstate;//作业状态

structjcb*next;//结构体指针

}*head=NULL,*p,*q;

typedefstructjcbJCB;

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

{

inti;

printf（"\n\t\t输入作业数:

"）;

scanf（"%d",&n）;

for（i=0;i

{

p=（JCB*）malloc（sizeof（JCB））;//声明结点

printf（"\t\t输入第%d个作业名:

",i+1）;

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

p->reachtime=i;//默认第一个0秒到，第二个1秒到。

。

。

printf（"\t\t第%d个作业到达时间默认为:

%d",i+1,i）;

printf（"\n\t\t输入作业要运行的时间:

"）;

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

p->state='W';//状态初始化为等待

p->next=NULL;

if（head==NULL）//如果是第一个结点的话执行

{

head=q=p;

}

else//不是第一个结点

{

q->next=p;//链接起来

q=p;//q向后移动一个结点，ready始终指向第一个

}

}

}

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

{

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->cptime）;

getch（）;

}

voidrun（JCB*min）//min为正在运行作业

{

if（min==head）//先将要运行的作业从队列中分离出来，此时的min是min

{

head=min->next;

min->next=NULL;

}

else

{

q=head;//形成循环对列

while（q->next!

=min）q=q->next;

q->next=min->next;//分离出最小作业

}

min->starttime=times;//计算作业运行后的完成时间,周转时间等等

min->state='R';

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

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

min->cptime=（float）（min->cycletime/min->needtime）;

t1+=min->cycletime;//周转时间之和

t2+=min->cptime;//带全周转时间之和

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

times+=min->needtime;//累加时间量

min->state='F';//完成状态

printf（"\n%shasbeenfinished!

\npressanykeytocontinue...\n",min->name）;

free（min）;//释放

getch（）;

}

voidsuper（）//计算队列中作业的高响应比

{

JCB*padv;

padv=head;

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

}

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

{

JCB*min;//min表示最短作业

inti,iden;

system（"cls"）;

inital（）;

for（i=0;i

{

p=min=head;

iden=1;

do

{

if（p->state=='W'&&p->reachtime<=times）//第一个作业times=0

{

if（iden）//第一个作业iden=1

{

min=p;

iden=0;

}//iden=0

}

elseif（p->needtimeneedtime）//判断作业的长短，min

{

min=p;

}

p=p->next;

}

while（p!

=NULL）;//这个循环遍历作业队列，目的是找出最短的作业，最后p==null，min指向最短作业

if（iden）

{

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

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

times++;

if（times>100）

{

printf（"\nruntimeistoolong...error"）;

getch（）;

}

}

else

{

run（min）;//调用run（）函数

}

}

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

}

intmain（）//主函数

{

printf（"\n\t\t最短作业优先算法，按任意键继续..."）;

getch（）;

sjf（）;

}

运行结果：

单道批处理响应比高者优先算法：

#include

#include

#include

intn;//全局变量n

floatT1=0,T2=0;//分别用来表示周转时间和带权周转时间之和

inttimes=0;

structjcb//作业控制块

{

charname[10];//作业名

intreachtime;//作业到达时间

intstarttime;//作业开始时间

intneedtime;//作业需要运行的时间

floatsuper;//作业的响应比

intfinishtime;//作业完成时间

floatcycletime;//作业周转时间

floatcltime;//作业带权周转时间

charstate;//作业状态

structjcb*next;//结构体指针

}*ready=NULL,*p,*q;

typedefstructjcbJCB;

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

{

inti;

printf（"\n\t\t输入作业数:

"）;

scanf（"%d",&n）;

for（i=0;i

{

p=（JCB*）malloc（sizeof（JCB））;//声明结点

printf（"\t\t输入作业名:

"）;

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

p->reachtime=i;//第一个0秒到，第二个1秒到

printf（"\t\t第%d个作业到达时间默认为:

%d",i+1,i）;

printf（"\n\t\t输入作业要运行的时间:

"）;

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

p->state='W';//状态初始化为等待

p->next=NULL;

if（ready==NULL）//如果是第一个结点的话执行

{

ready=q=p;

}

else//不是第一个结点

{

q->next=p;//链接起来

q=p;//q向后移动一个结点，ready始终指向第一个

}

}

}

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

{

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（）;

}

voidrun（JCB*p）//运行作业

{

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;//带全周转时间之和

display（p）;//调用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（）//高响应比算法

{

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

if（times>1000）

{

printf（"\nruntimeistoolong...error..."）;

getch（）;

}

}

else

{

run（min）;//调用run（）函数

}

}

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

}

intmain（）//主函数

{

printf（"\t\t响应比高者优先算法，按任意键继续..."）;

getch（）;

hrn（）;

getch（）;

}

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

　　作业调度算法：

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

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

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

多道程序（基于先来先算服务）

#include

#include

#definegetjch（type）（type*）malloc（sizeof（type））

#defineN10

structjcb{/*定义作业控制块PCB*/

charname[10];

floatneedtime;/*运行时间*/

floatarrivetime;/*提交时刻*/

floatstorage[N];/*系统资源*/

structjcb*link;

}*ready=NULL,*pb=NULL,*p;

typedefstructjcbJCB;

floatTc,Ti,Wi,T=0;/*完成时刻,周转时间,带权周转时间,时间量*/

floatTiSum=0,WiSum=0;/*平均周转时间,带权a平均周转时间*/

floatsource[N];

intn;

voidinput（）;/*输入作业信息*/

intspace（）;/*返回就绪队列中作业的数目*/

voidfcfs（）;/*先来先服务算法*/

voiddisp（JCB*pr）;/*显示相应的作业*/

voidrunning（）;/*运行作业组*/

voiddestroy（）;/*撤销作业*/

voidinput（）/*建立作业控制块函数*/

{

inti,k,num;

printf（"请