计算机操作系统进操作系统程调度模拟实验Word下载.docx
《计算机操作系统进操作系统程调度模拟实验Word下载.docx》由会员分享，可在线阅读，更多相关《计算机操作系统进操作系统程调度模拟实验Word下载.docx（23页珍藏版）》请在冰点文库上搜索。
doubleWeightWholeTime[MaxNum];
doubleAverageWT_FCFS;
doubleAverageWWT_FCFS;
2）进程调度的实现过程如下：
Ø
变量初始化；
接收用户输入n，T1,…,Tn，S1,…,Sn；
按照选择算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；
计算所有进程的平均周转时间和平均带权周转时间；
按格式输出调度结果。
3、程序流程图
4、作业时间表
作业
到达时间
服务时间
开始时间
完成时间
周转时间
带权周转时间
A
20
1
B
4
13
33
29
2.23
C
8
34
26
D
18
200
234
216
1.08
平均周转时间T=（20+29+26+216）/4ms=72.75ms
平均带权周转时间W=（1+2.23+26+1.08）/4ms=7.5775ms
5、程序源代码
#include"
stdio.h"
stdlib.h"
typedefstructPCB//定义进程控制块
{charname[10];
//进程名
charstate;
//运行状态
intArriveTime;
//到达时间
intStartTime;
//进程开始时间
intFinishTime;
//进程结束时间
intServiceTime;
//服务时间
floatWholeTime;
//周转时间
floatWeightWholeTime;
//带权周转时间
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;
StartTime=time;
printf（"
\n时刻：
%d,当前开始运行作业%s\n\n"
time,p1->
name）;
time+=p1->
ServiceTime;
state='
T'
;
FinishTime=time;
WholeTime=p1->
FinishTime-p1->
ArriveTime;
WeightWholeTime=p1->
WholeTime/p1->
x+=p1->
WholeTime;
y+=p1->
WeightWholeTime;
到达时间开始时间服务时间完成时间周转时间带权周转时间\n"
）;
%6d%10d%10d%8d%10.1f%10.2f\n"
p1->
ArriveTime,p1->
StartTime,p1->
ServiceTime,p1->
FinishTime,p1->
WholeTime,p1->
WeightWholeTime）;
}
voidFCFS（）//找到当前未完成的进程
inti;
p=head;
for（i=0;
i<
n;
i++）
{
if（p->
state=='
F'
）
q=p;
//标记当前未完成的进程
run_FCFS（q）;
}
p=p->
next;
voidgetInfo（）//获得进程信息并创建进程
intnum;
\n进程个数:
"
scanf（"
%d"
&
n）;
for（num=0;
num<
num++）
p=（pcb*）malloc（sizeof（pcb））;
printf（"
依次输入：
\n进程名到达时间服务时间\n"
scanf（"
%s\t%d\t%d"
p->
name,&
ArriveTime,&
ServiceTime）;
if（head==NULL）
{head=p;
q=p;
time=p->
if（p->
ArriveTime<
time）time=p->
q->
next=p;
p->
StartTime=0;
FinishTime=0;
WholeTime=0;
WeightWholeTime=0;
next=NULL;
q=p;
voidmain（）
{printf（"
先来先服务FCFS算法模拟\n"
getInfo（）;
FCFS（）;
6、运行结果
3、短作业优先调度算法
1、实验提示
程序中进程调度时间变量描述如下：
charname[10];
floatarrivetime;
floatservicetime;
//服务时间
floatstarttime;
//开始时间
floatfinishtime;
//完成时间
floatzztime;
//周转时间
floatdqzztime;
//带权周转时间
2、程序流程图
总体流程图
详细流程图
3、作业时间表
3
21
2
30
2.31
平均周转时间T=（20+21+34+216）/4ms=72.75ms
平均带权周转时间W=（1+13+2.31+1.08）/4ms=4.3475ms
4、程序源代码
#include<
stdio.h>
structsjf//定义进程的结构体
charname[10];
};
sjfb[100];
//定义短作业优先算法进程的最大数量
voidSinput（sjf*p,intN）//输入函数
输入进程的名称、到达时间、服务时间:
（例如:
x0100）\n"
=N-1;
i++）
输入第%d进程的名称、到达时间、服务时间:
i+1）;
%s%f%f"
p[i].name,&
p[i].arrivetime,&
p[i].servicetime）;
voidSPrint（sjf*p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,floatzztime,floatdqzztime,intN）//输出函数
intk;
\n执行顺序:
\n"
%s"
p[0].name）;
for（k=1;
k<
N;
k++）
-%s"
p[k].name）;
\n进程名\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n"
for（k=0;
%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n"
p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime）;
voidSsort（sjf*p,intN）//按短作业优先算法排序
for（inti=1;
for（intj=1;
j<
=i;
j++）
if（p[i].servicetime<
p[j].servicetime）
{
sjftemp;
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
voidSdeal（sjf*p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,float&
zztime,float&
dqzztime,intN）//运行结果
if（k==0）
{
p[k].starttime=p[k].arrivetime;
p[k].finishtime=p[k].arrivetime+p[k].servicetime;
}
else
p[k].starttime=p[k-1].finishtime;
//开始时间=前一个进程的完成时间
p[k].finishtime=p[k-1].finishtime+p[k].servicetime;
//结束时间=前一个进程的完成时间+现在进程的服务时间
p[k].zztime=p[k].finishtime-p[k].arrivetime;
//周转时间=完成时间-到达时间
p[k].dqzztime=p[k].zztime/p[k].servicetime;
//带权周转时间=周转时间/服务时间
voidSJF（sjf*p,intN）
floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;
Ssort（p,N）;
Sdeal（p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N）;
SPrint（p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N）;
voidmain（）//主函数
intM;
------------短作业优先调度算法-----------\n"
输入进程数:
M）;
Sinput（b,M）;
SJF（b,M）;
5、运行结果
3、优先级调度算法
进程控制块结构
charname[20];
//进程名称
intpriority;
//优先级数
intgettime;
floatdotime;
intstarttime;
intfinishtime;
floatturntime;
floatptime;
2、作业时间表
进程
优先级
6
5
16
2.67
7
12
1.2
E
14
3、程序源代码
#include<
iostream.h>
iomanip.h>
structprocess//进程结构体
charname[20];
intn;
//进程的个数
floataverageturntime,averageptime;
//平均周转时间和平均加权周转时间
voidGetInProcess（process*pp）//对进程数组进行初始化
cout<
<
进程名称（字母）优先级数到达时间服务时间"
endl;
for（inti=0;
进程"
i+1<
:
cin>
>
pp[i].name;
pp[i].priority;
pp[i].gettime;
pp[i].dotime;
已经输入完毕.您刚才输入的内容如下:
-----------------------------------"
进程名称优先级数到达时间服务时间"
for（intj=0;
j++）
{
setw（4）<
pp[j].name;
setw（9）<
pp[j].priority;
pp[j].gettime;
pp[j].dotime;
voidProcessPriority（process*pp）//对此进程数组按优先级从小到大排序，级数越小优先级越高。
n-1;
intk=i;
for（intj=k+1;
if（pp[i].priority>
pp[j].priority）
k=j;
processt;
t=pp[k];
pp[k]=pp[i];
pp[i]=t;
voidPrintProcess（process*pp）//输出排序后的诸进程
{floats1,s2,sum1=0,sum2=0;
//sum1表示所有进程周转时间之和，sum2表示所有进程加权周转时间之和。
---------------------------------------------------------------------------"
进程名称优先级数到达时间服务时间开始时间完成时间周转时间加权周转时间"
pp[0].starttime=pp[0].gettime;
pp[0].finishtime=pp[0].starttime+pp[0].dotime;
pp[0].turntime=pp[0].finishtime-pp[0].gettime;
pp[0].ptime=pp[0].turntime/pp[0].dotime;
pp[i].starttime=pp[i-1].finishtime;
pp[i].finishtime=pp[i].starttime+pp[i].dotime;
pp[i].turntime=pp[i].finishtime-pp[i].gettime;
pp[i].ptime=pp[i].turntime/pp[i].dotime;
sum1=sum1+pp[i].turntime;
sum2=sum2+pp[i].ptime;
s1=sum1/n;
s2=sum2/n;
pp[i].name
<
pp[i].priority
pp[i].gettime
pp[i].dotime
setw（10）<
pp[i].starttime
pp[i].finishtime
pp[i].turntime
setw（12）<
pp[i].ptime
周转总时间sum1="
sum1<
平均周转时间s1="
s1<
'
.'
加权周转总时间sum2="
sum2<
平均加权周转时间s2="
s2<
cout<
intmain（）
{
请输入进程个数:
processa[100];
GetInProcess（a）;
ProcessPriority（a）;
PrintProcess（a）;
return0;
3、运行结果
升级会员 