完整word版操作系统作业调度实验报告多道批处理.docx
《完整word版操作系统作业调度实验报告多道批处理.docx》由会员分享，可在线阅读，更多相关《完整word版操作系统作业调度实验报告多道批处理.docx（29页珍藏版）》请在冰豆网上搜索。
完整word版操作系统作业调度实验报告多道批处理
计算机学院计算机科学与技术专业07班
姓名学号教师评定_________________
实验题目作业调度
一、实验目的
本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。
二、实验内容和要求
1、为单道批处理系统设计一个作业调度程序
（1）、编写并调试一个单道处理系统的作业调度模拟程序。
（2）、作业调度算法：
分别采用先来先服务（FCFS），最短作业优先（SJF）的调度算法。
（3）、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU时限等因素。
（4）、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：
作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W（Wait）、运行R（Run）和完成F（Finish）三种状态之一。
每个作业的最初状态总是等待W。
（5）、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，并比较各种算法的优缺点。
2、模拟批处理多道操作系统的作业调度
（1）写并调试一个作业调度模拟程序。
（2）作业调度算法：
分别采用先来服务（FCFS）调度算法。
（3）在批处理系统中，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求，所需要的资源是否得到满足。
作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可占用处理机运行。
作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。
但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业要求，那么，作业调度必须按一定的算法在这些作业中作出选择。
当作业正常运行完毕或因发生错误非正常终止时，作业进入完成状态，此时，系统将收回该作业所占用的全部资源，并清除有关的JCB。
并输出显示作业运行情况及作业输出结果。
三、实验设计方案及原理
假设在单道批处理环境下有四个作业JOB1、JOB2、JOB3、JOB4，已知它们进入系统的时间、估计运行时间。
分别采用先来先服务（FCFS），最短作业优先（SJF）调度算法，计算出作业的平均周转时间和带权的平均周转时间。
作业p的周转时间：
p->ttime=p->ftime-p->atime
作业的平均周转时间：
total=全部进程的周转时间/进程个数
作业p的带权周转时间：
p->wtime=p->ttime/p->ntime
作业的平均带权周转时间：
W=全部进程的带权周转时间/进程个数
1、先来先服务调度算法（FCFS）：
每次调度都是从后备作业队列中，选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，这每次调度是从就绪队列中，选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件阻赛后，才放弃处理机。
2、最短作业优先（SJF）：
每次从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，并比较各种算法的优缺点。
3、多道作业调度算法：
将作业按FCFS原则排好队，在输入井中按作业到达的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业时，那么顺序挑选后面的作业，把不能满足要求的放回输入井尾部等待，当作业执行结束进入完成状态时，做好释放资源等善后工作。
四、流程图
1、FCFS算法和SJF算法:
2.多道作业调度算法
五、给出程序中源程序名和执行程序名：
源程序名：
FCFSandSJF,执行程序名：
fcfsandsjf.cpp
源程序名：
DUODAO执行程序名：
duodao.cpp
六、程序清单
1.FCFS和SJF算法
#include"stdio.h"
#include
#include
#definegetpch（type）（type*）malloc（sizeof（type））
structjcb{
charname[10];
charstate;
intatime;//作业到达时间
intbtime;//作业开始运行时间
intftime;//作业完成时间
intntime;//作业估计运行时间
intrtime;//作业执行时间
intttime;//周转时间
floatwtime;//带权周转时间（周转时间/估计运行时间）
structjcb*link;
}*ready=NULL,*p;//ready指向队头，p指向正被调度的作业
typedefstructjcbJCB;
intT=0;//初始化时间量
floattotal;//记录所有作业的总时间
doubleweight;//记录所有作业的带权周转时间
voidsort（）/*建立对作业进行到达时间排列函数*/
{
JCB*first,*second;
intinsert=0;
if（（ready==NULL）||（（p->atime）<（ready->atime）））/*作业到达时间最短的,插入队首*/
{
p->link=ready;
ready=p;
T=p->atime;//更改时间量
}
else/*作业比较到达时间,插入适当的位置中*/
{
first=ready;
second=first->link;
while（second!
=NULL）
{
if（（p->atime）<（second->atime））/*若插入作业比当前队尾作业到达时间短,*/
{/*插入到当前队尾作业前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else/*插入作业到达时间最长,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if（insert==0）first->link=p;
}
}
voidshortjob（）//获取队列中的最短作业
{
JCB*pr,*min,*qr;
min=ready;//min指向作业对头
qr=ready;
pr=ready->link;
while（pr!
=NULL）
{
if（（pr!
=NULL）&&（T>=pr->atime）&&（pr->ntime）<（min->ntime））
{//当插入作业到达时间要比时间量T小
min=pr;//min指向pr
qr->link=pr->link;//qr的下一个指向pr的下一个
pr->link=ready;
pr=pr->link;
}
else//当pr的需要时间不小于min的需要时间
{qr=pr;
pr=pr->link;}
ready=min;//把最终获取的min的需要时间赋给ready，开始执行
}
}
voidinput（）/*建立作业控制块函数*/
{
inti;
printf（"\n请输入4个作业：
"）;
for（i=0;i<4;i++）
{
printf（"\n请输入作业号NO.%d：
\n",i）;
p=getpch（JCB）;
printf（"输入作业名：
"）;
scanf（"%s",p->name）;
printf（"\n输入作业到达时间：
"）;
scanf（"%d",&p->atime）;
printf（"\n输入作业运行时间：
"）;
scanf（"%d",&p->ntime）;
printf（"\n"）;
p->rtime=0;
p->btime=0;
p->ftime=0;
p->ttime=0;
p->wtime=0;
p->state='W';
p->link=NULL;
sort（）;
}
}
intspace（）/*查看作业个数*/
{
intl=0;
JCB*pr=ready;
while（pr!
=NULL）
{
l++;
pr=pr->link;
}
return（l）;
}
voiddisp（JCB*pr）/*建立作业显示函数，用于显示当前作业*/
{
printf（"\nqname\tstate\tatime\tntime\tbtime\trtime\tftime\tttime\twtime\n"）;
printf（"|%s\t",pr->name）;
printf（"|%c\t",pr->state）;
printf（"|%d\t",pr->atime）;
printf（"|%d\t",pr->ntime）;
printf（"|%d\t",pr->btime）;
printf（"|%d\t",pr->rtime）;
printf（"|%d\t",pr->ftime）;
printf（"|%d\t",pr->ttime）;
printf（"|%.2f\t",pr->wtime）;
printf（"\n"）;
}
voidcheck（）/*建立作业查看函数*/
{
JCB*pr;
printf（"\n****当前正在运行的作业是:
%s",p->name）;/*显示当前运行作业*/
disp（p）;
pr=ready;
printf（"\n****当前就绪队列状态为:
\n"）;/*显示就绪队列状态*/
while（pr!
=NULL）
{
disp（pr）;
pr=pr->link;
}
}
voiddestroy（）
{
printf（"\n作业[%s]已完成。
\n",p->name）;
free（p）;
}
voidrunning（JCB*pr）//计算各个时间
{
if（T>=pr->atime）pr->btime=T;//插入作业的到达时间比时间量小，T为该作业的开始时间
elsepr->btime=pr->atime;//否则该作业到达时间为它的开始时间
pr->ftime=pr->btime+pr->ntime;
pr->ttime=p->ftime-p->atime;
pr->wtime=（float）pr->ttime/（float）pr->ntime;
total+=pr->ttime;
weight+=pr->wtime;
T=pr->ftime;//T为该上一个作业的完成时间
}
voidrunning1（JCB*pr）//分离出要执行的当前作业
{
if（T>=pr->atime）pr->btime=T;
elsepr->btime=pr->atime;
}
voidrunning2（JCB*pr）//判断运行时间和需要运行时间的关系
{
while（pr->rtimentime）
{
pr->state='R';
（pr->rtime）=（pr->ntime）;
}
printf（"\n\n****该作业执行完毕时的状态：
\n"）;
pr->state='F';
disp（pr）;
destroy（）;
}
intmain（）
{
inti,len,h=0;
charch;
total=0;
weight=0;
printf（"*********************************************************\n"）;
printf（"\n"）;
printf（"FCFS算法或SJF算法\n"）;
printf（"*********************************************************\n"）;
input（）;
len=space（）;
printf（"\n选择算法:
"）;
scanf（"%d",&i）;
switch（i）
{
case1:
printf（"FCFS算法：
\n"）;break;
case2:
printf（"SJF算法：
\n"）;break;
default:
printf（"FAULSE"）;
}
if（i==1||i==2）
{
while（（len!
=0）&&（ready!
=NULL））
{
ch=getchar（）;
if（i==2）shortjob（）;
h++;
printf（"\nTheexecutenumber:
%d\n",h）;
p=ready;/*将队首指针赋给p*/
ready=p->link;/*ready指向原p的下一个进程*/
p->link=NULL;/*p的link赋空*/
p->state='R';
p->btime=p->atime;
running1（p）;
check（）;
running（p）;
running2（p）;
printf（"\n按任一键继续..."）;
ch=getchar（）;
}
printf（"\n\n作业已完成。
\n"）;
ch=getchar（）;
printf（"\n******************************************************\n"）;
printf（"\n平均周转时间：
%f",total/（float）4）;
printf（"\n平均带权周转时间：
%lf",weight/（float）4）;
printf（"\n******************************************************\n"）;
}
}
2.多道作业调度算法：
#include"stdio.h"
#include
#include
#definegetpch（type）（type*）malloc（sizeof（type））
#definesource15
structjcb{
charusername[10];
charjobname[10];
charstate;
intatime;//作业到达时间
intntime;//作业估计运行时间
intrtime;//作业的运行时间
intnsource;//作业所需系统资源
intasource;//已分配的资源
intneed1;
structjcb*link;
}*ready=NULL,*p;//ready指向就绪队列的队头，p指向正被调度的作业
typedefstructjcbJCB;
intrsource=15;//剩下资源
intnum,i=0;//num为作业个数，i为记录不能满足作业要求调度的次数
voiddestroy（JCB*pr）
{
free（pr）;
}
voidsort（）/*建立对作业进行到达时间排列函数*/
{
JCB*first,*second;
intinsert=0;
if（（p->nsource<=source）&&（rsource>=0）&&（p->nsource>p->asource））
{//需要资源要在系统资源范围内，分配资源要在需要资源范围内，剩下资源不能小于0
if（（ready==NULL）||（（p->atime）<（ready->atime）））/*作业到达时间最短的,插入队首*/
{
p->link=ready;
ready=p;
}
else/*作业比较到达时间,插入适当的位置中*/
{
first=ready;
second=first->link;
while（second!
=NULL）
{
if（（p->atime）<（second->atime））/*若插入作业比当前队尾作业到达时间短,*/
{/*插入到当前队尾作业前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else/*插入作业到达时间最长,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if（insert==0）first->link=p;
}
}
else
destroy（p）;
}
voidsort1（）/*对作业进行排列函数*/
{
JCB*first;
if（ready==NULL）/*如果就绪队列为空*/
{
ready=p;/*将新建作业放入队列中，将ready指向队首作业*/
}
else/*队列中有作业在等待，将新建作业插入到队尾*/
{
first=ready;/*first指针指向队首作业*/
while（first->link!
=NULL）first=first->link;/*当first指针没有指向队尾时，指针后移*/
first->link=p;/*将p指向的作业插入队尾*/
}
}
voidinput（）/*建立作业控制块函数*/
{
inti;
printf（"\n请输入作业个数:
"）;
scanf（"%d",&num）;
for（i=0;i{
printf（"\n请输入作业号NO.%d：
\n",i）;
p=getpch（JCB）;
printf（"输入作业用户名:
"）;
scanf（"%s",p->username）;
printf（"\n输入作业名:
"）;
scanf（"%s",p->jobname）;
printf（"\n输入作业到达时间:
"）;
scanf（"%d",&p->atime）;
printf（"\n输入作业运行时间:
"）;
scanf（"%d",&p->ntime）;
printf（"\n输入作业所需资源:
"）;
scanf（"%d",&p->nsource）;
printf（"\n输入作业已分配资源:
"）;
scanf（"%d",&p->asource）;
printf（"\n"）;
p->need1=p->nsource-p->asource;//还需要资源=需要资源-已分配资源
p->state='W';
p->link=NULL;
sort（）;
}
}
intspace（）/*查看作业个数*/
{
intl=0;
JCB*pr=ready;
while（pr!
=NULL）
{
l++;
pr=pr->link;
}
return（l）;
}
voiddisp（JCB*pr）/*建立作业显示函数，用于显示当前作业*/
{
printf（"\n用户N\t作业N\t状态S\t到达T\t服务T\t所需S\t已分S\t还需S\n"）;
printf（"|%s\t",pr->username）;
printf（"|%s\t",pr->jobname）;
printf（"|%c\t",pr->state）;
printf（"|%d\t",pr->atime）;
printf（"|%d\t",pr->ntime）;
printf（"|%d\t",pr->nsource）;
printf（"|%d\t",pr->asource）;
printf（"|%d\t",pr->need1）;
printf（"\n"）;
}
voidcheck（）
{
JCB*pr;
printf（"\n****当前正在运行的作业是：
%s",p->jobname）;
disp（p）;
pr=ready;
printf（"\n****当前输入井队列状态为：
\n"）;/*显示就绪队列状态*/
while（pr!
=NULL）
{
disp（pr）;
pr=pr->link;
}
}
voidrunning（JCB*p）//对输入井队列中满足资源要求的作业进行服务
{
while（p->rtimentime）
{
（p->rtime）++;
}
p->state='F';
printf（"\n****作业运行完成后状态:
\n"）;
disp（p）;
printf（"\n用户名[%s]的作业[%s]已完成。
\n",p->username,p->jobname）;
}
voidrunning1（）//计算剩下资源
{
JCB*pr;
for（pr=ready;pr!
=NULL;pr=pr->link）
{rsource=rsource-pr->asource;}
}
voidrunning2（JCB*pr）
{
if（pr->need1<=rsource）
{
check（）;
rsource-=pr->need1;
pr->asource+=pr->need1;
pr->need1=0;
printf（"\t********************************************\n"）;
printf（"\n分配给作业后所剩的资源是：
%d\n",rsource）;
running（pr）;
rsource=rsource+pr->nsource;
printf（"\n释放后的资源是：
%d\n",rsource）;
destroy（pr）;
}
else
{
printf（"该作业不能满足要求，调度下一个作业"）;
sort1（）;
i++;
}
}
voidmain（）
{
升级会员 