先来先服务FCFS和短作业优先SJF进程调度算法.docx
《先来先服务FCFS和短作业优先SJF进程调度算法.docx》由会员分享，可在线阅读，更多相关《先来先服务FCFS和短作业优先SJF进程调度算法.docx（11页珍藏版）》请在冰豆网上搜索。
先来先服务FCFS和短作业优先SJF进程调度算法
计
算
机
操
作
系
统
实
验
报
告
班级：
过控12-01
姓名：
邹锦程
学号：
541213470163
实验一先来先服务FCFS和短作业优先SJF进程调度算法
一、实验目的
通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
二、实验内容
设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。
假设有n个进程分别在T1,…,Tn时刻到达系统，它们需要的服务时间分别为S1,…,Sn。
分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
三、要求
程序要求：
1）进程个数n；每个进程的到达时间T1,…,Tn和服务时间S1,…,Sn；选择算法1-FCFS，2-SJF。
2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间；
3）输出：
要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：
进程B开始运行”等等；
4）输出：
要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
实验要求
1）上机前认真复习FCFS和SJF进程调度调度算法，熟悉进程调度的执行过程；
2）上机时独立编程、调试程序；
3）根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图、发现的问题以及解决方法）。
四、源程序
#include
#include
typedefstructPCB//定义进程控制块
{
charname[10];//进程名
charstate;//运行状态
intArriveTime;//到达时间
intStartTime;//进程开始时间
intFinishTime;//进程结束时间
intServiceTime;//服务时间
floatWholeTime;//周转时间
floatWeightWholeTime;//带权周转时间
doubleAverageWT_FCFS;//平均周转时间
doubleAverageWWT_FCFS;//带权平均周转时间
structPCB*next;//指向下个进程
}pcb;
doublex=0,y=0;
inti;
inttime;
intn;
pcb*head=NULL,*p,*q;
voidrun_FCFS（pcb*p1）//运行未完成的进程
{
time=p1->ArriveTime>time?
p1->ArriveTime:
time;
p1->StartTime=time;
printf（"\n时刻：
%d,当前开始运行作业%s\n\n",time,p1->name）;
time+=p1->ServiceTime;
p1->state='T';
p1->FinishTime=time;
p1->WholeTime=p1->FinishTime-p1->ArriveTime;
p1->WeightWholeTime=p1->WholeTime/p1->ServiceTime;
x+=p1->WholeTime;
y+=p1->WeightWholeTime;
p1->AverageWT_FCFS=p1->WholeTime/n;
p1->AverageWWT_FCFS=p1->WeightWholeTime/n;
printf（"到达时间开始时间服务时间完成时间周转时间带权周转时间\n"）;
printf（"%6d%10d%10d%8d%10.1f%10.2f\n",p1->ArriveTime,p1->StartTime,p1->ServiceTime,p1->FinishTime,p1->WholeTime,p1->WeightWholeTime）;
printf（"\n平均周转时间平均带权周转时间\n"）;
printf（"%10.2f%10.2f\n",p1->AverageWT_FCFS,p1->AverageWWT_FCFS）;
}
voidFCFS（）//找到当前未完成的进程
{
inti;
p=head;
for（i=0;i{
if（p->state=='F'）
{
q=p;//标记当前未完成的进程
run_FCFS（q）;
}
p=p->next;
}
}
voidgetInfo（）//获得进程信息并创建进程
{
intnum;
printf（"\n进程个数:
"）;
scanf（"%d",&n）;
for（num=0;num{
p=（pcb*）malloc（sizeof（pcb））;
printf（"依次输入：
\n进程名到达时间服务时间\n"）;
scanf（"%s\t%d\t%d",&p->name,&p->ArriveTime,&p->ServiceTime）;
if（head==NULL）
{
head=p;q=p;time=p->ArriveTime;
}
if（p->ArriveTimeArriveTime;
q->next=p;
p->StartTime=0;
p->FinishTime=0;
p->WholeTime=0;
p->WeightWholeTime=0;
p->next=NULL;
p->state='F';
q=p;
}
}
intmain（）
{
printf（"先来先服务FCFS算法模拟\n"）;
getInfo（）;
p=head;
FCFS（）;
}
#include
#include
#include
#defineMaxNum100
usingnamespacestd;
structProcess_struct
{
intNumber;//进程编号
charName[MaxNum];//进程名称
intArrivalTime;//到达时间
intServiceTime;//开始运行时间
intFinishTime;//运行结束时间
intWholeTime;//运行时间
intrun_flag;//调度标志
intorder;//运行次序
doubleWeightWholeTime;//周转时间
doubleAverageWT_FCFS,AverageWT_SJF;//平均周转时间
doubleAverageWWT_FCFS,AverageWWT_SJF;//平均带权周转时间
}Process[MaxNum];
intN;//实际进程个数
intSJF（）;//短作业优先
intSJF（）
{//短作业优先算法
inttemp_time=0;//当期那时间
inti=0,j;
intnumber_schedul,temp_counter;//进程编号，当前已执行进程个数
floatrun_time;
run_time=Process[i].WholeTime;
j=1;
while（（j{
if（Process[j].WholeTime{
run_time=Process[i].WholeTime;
i=j;
}
j++;
}
//查找下一个被调度的进程
//对找到的下一个被调度的进程求相应的参数
number_schedul=i;
Process[number_schedul].ServiceTime=Process[number_schedul].ArrivalTime;
Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime+Process[number_schedul].WholeTime;
Process[number_schedul].run_flag=1;
temp_time=Process[number_schedul].FinishTime;
Process[number_schedul].order=1;
temp_counter=1;
while（temp_counter{
for（j=0;j{
if（（Process[j].ArrivalTime<=temp_time）&&（!
Process[j].run_flag））
{
run_time=Process[j].WholeTime;
number_schedul=j;
break;
}
}
for（j=0;j{
if（（Process[j].ArrivalTime<=temp_time）&&（!
Process[j].run_flag））
if（Process[j].WholeTime{
run_time=Process[j].WholeTime;
number_schedul=j;
}
}
//查找下一个被调度的进程
//对找到的下一个被调度的进程求相应的参数
Process[number_schedul].ServiceTime=temp_time;
Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime+Process[number_schedul].WholeTime;
Process[number_schedul].run_flag=1;
temp_time=Process[number_schedul].FinishTime;
temp_counter++;
Process[number_schedul].order=temp_counter;
}return0;
}
intPinput（）;//进程参数输入
intPoutput（）;//调度结果输出
main（）
{
system（"cls"）;
intoption;
printf（"********************主菜单************************\n"）;
printf（"*1使用短作业优先*\n"）;
printf（"*0退出*\n"）;
printf（"**************************************************\n"）;
//
system（"color1f"）;
scanf（"%d",&option）;
switch（option）
{
case0:
printf（"运行结束。
\n"）;
break;
case1:
printf（"对进程用短作业优先调度。
\n\n"）;
Pinput（）;
SJF（）;
Poutput（）;
break;
}
}
intPinput（）//进程参数输入
{
inti;
printf（"请输入进程个数:
\n"）;
scanf（"%d",&N）;
for（i=0;i{
printf（"***************************************\n"）;
printf（"请输入一个进程:
\n",i+1）;
printf（"请输入进程名称:
\n"）;
scanf（"%s",Process[i].Name）;
printf（"请输入到达时间:
\n"）;
scanf（"%d",&Process[i].ArrivalTime）;
printf（"请输入服务时间:
\n"）;
scanf（"%d",&Process[i].WholeTime）;
Process[i].ServiceTime=0;
Process[i].FinishTime=0;
Process[i].WeightWholeTime=0;
Process[i].order=0;
Process[i].run_flag=0;
system（"cls"）;
}return0;
}
intPoutput（）//调度结果输出
{
inti;
floatturn_round_time=0,f1,w=0;
printf（"进程名称到达T运行T开始运行T结束T执行顺序周转T带权周转T\n"）;
for（i=0;i{
Process[i].WeightWholeTime=Process[i].FinishTime-Process[i].ArrivalTime;
f1=Process[i].WeightWholeTime/Process[i].WholeTime;
turn_round_time+=Process[i].WeightWholeTime;
w+=f1;
printf（"时刻%d:
",Process[i].ServiceTime,Process[i].Name）;
printf（"%s%d%d%d%d%d%f%f\n",Process[i].Name,Process[i].ArrivalTime,Process[i].WholeTime,Process[i].ServiceTime,Process[i].FinishTime,Process[i].order,Process[i].WeightWholeTime,f1）;
}
printf（"average_turn_round_timer=%f\n",turn_round_time/N）;
printf（"weight_average_turn_round_timer=%f\n",w/N）;
return0;
}
五、结果
六感悟
FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。
SJF在实际情况中，占很大比例，为了能够使他们比长作业优先执行，而产生了短作业。
升级会员 