进程调度算法实验报告Word文档格式.docx
《进程调度算法实验报告Word文档格式.docx》由会员分享，可在线阅读，更多相关《进程调度算法实验报告Word文档格式.docx（18页珍藏版）》请在冰豆网上搜索。
amount;
for（i=0;
i<
i++）
cout<
请输入进程名，进程到达时间，进程运行时间:
cin>
f[i].id;
f[i].atime;
f[i].runtime;
}
i++）
//按进程到达时间的先后排序
{
//如果两个进程同时到达，按在屏幕先输入的先运行
for（j=0;
j<
amount-i-1;
j++）
{
if（f[j].atime>
f[j+1].atime）
{diao=f[j].atime;
f[j].atime=f[j+1].atime;
f[j+1].atime=diao;
huan=f[j].id;
f[j].id=f[j+1].id;
f[j+1].id=huan;
}
进程:
f[i].id<
从"
f[i].atime<
开始"
"
在"
<
f[i].atime+f[i].runtime<
之前结束。
f[i+1].atime=f[i].atime+f[i].runtime;
2.短进程优先算法
#include<
stdio.h>
#definen5
#definenum5
#definemax65535
typedefstructpro
{intPRO_ID;
intarrive_time;
intsum_time;
intflag;
}Pro;
//整数排序
intbubble（inttemp[]）
{
inti,j,tem=0;
for（i=1;
num;
{intlastX=1;
for（j=0;
num-i;
{if（temp[j]>
temp[j+1]）
{tem=temp[j];
temp[j]=temp[j+1];
temp[j+1]=tem;
lastX=0;
}
}
if（lastX==1）break;
}
returntemp[0];
}
//进程排序
Probubble（Prop[]）
inti,j;
Protemp={0};
Pros[num];
for（i=0;
{s[i]=p[i];
{
intlastX=1;
{
if（s[j].sum_time>
s[j+1].sum_time）
{
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
returns[0];
voidSPF（intp）
if（n>
0）
inti,j,k,l,tc=0;
Proseq[n];
Protemp_seq[n];
printf（"
短进程优先调度算法SPF\n"
）;
请依次输入5个进程的进程号、到达时间和执行时间\n"
成员变量用逗号隔开；
进程间用回车隔开\n"
for（i=0;
n;
i++）{
scanf（"
%d,%d,%d"
&
seq[i].PRO_ID,&
seq[i].arrive_time,&
seq[i].sum_time）;
调度顺序是：
\n"
//初始化tc
inttemp[num];
temp[i]=seq[i].arrive_time;
tc=bubble（temp）;
//tc是断点啊
//flag表示对应i的pro的队列情况
//-1表示未进入过队列，0表示在队列中，1表示被清除了
seq[i].flag=-1;
i++）{
j++）{
if（seq[j].flag!
=1&
&
seq[j].arrive_time<
=tc）{
seq[j].flag=0;
for（j=0;
temp_seq[j]=seq[j];
=0）{
temp_seq[j].sum_time=max;
l=bubble（temp_seq）.PRO_ID;
if（l==seq[j].PRO_ID）{
k=j;
tc=tc+bubble（temp_seq）.sum_time;
seq[k].flag=1;
%d"
l）;
SPF（n）;
3.时间片轮转调度算法
头文件RR.h
iostream>
string.h>
stdlib.h>
ctype.h>
#defineMaxNum100
typedefstructpcb//定义进程控制块
charName[MaxNum];
intarrivetime;
//到达时间
intruntime;
//运行时间
intwholetime;
//固定运行时间
intFinishTime;
//完成时间
doubleWeightTime;
//周转时间
doubleWeightWholeTime;
//带权周转时间
charstate;
//运行后的状态
structpcb*next;
}PCB;
//全局变量
intN;
//实际进程数
doubleSumWT;
//周转时间之和
doubleSumWWT;
//带权周转时间之和
doubleAverageWT;
//平均周转时间
doubleAverageWWT;
//平均带权周转时间
typedefstruct//定义队列，封装头结点，指针分别指向队头和队尾
PCB*front,*rear;
}queue;
queue*init（）//进程队列置空
queue*head;
head=（queue*）malloc（sizeof（queue））;
head->
front=NULL;
rear=NULL;
returnhead;
intempty（queue*head）//检验队列是否为空
return（head->
front?
0:
1）;
queue*append（queue*head,charc[MaxNum],inta,intr,chars）//进程队列入队，往后插入
PCB*p;
p=（PCB*）malloc（sizeof（PCB））;
strcpy（p->
Name,c）;
p->
arrivetime=a;
runtime=r;
wholetime=r;
state=s;
//p->
FinishTime=0;
WeightTime=0;
WeightWholeTime=0;
next=NULL;
if（empty（head））
head->
front=head->
rear=p;
else
rear->
next=p;
queue*creat（queue*head）//创建进程队列
charc[MaxNum];
chars='
R'
;
inta,r,i;
printf（"
请输入共有几个进程：
scanf（"
N）;
for（i=1;
=N;
请输入第%d个进程的进程名:
i）;
getchar（）;
gets（c）;
请输入第%d个进程的到达时间:
a）;
请输入第%d个进程的服务时间:
r）;
head=append（head,c,a,r,s）;
voidprint（queue*head）//输入创建的进程队列
p=head->
front;
if（!
p）
时间片轮转调度队列为空!
while（p）
Name=%sarrivetime=%druntime=%dstate=%c"
p->
Name,p->
arrivetime,p->
runtime,p->
state）;
p=p->
next;
/*******************时间片轮转法调度算法的实现**************************/
voidRR（queue*head,intq）
intt=head->
front->
arrivetime,lt=head->
arrivetime;
if（head->
runtime<
q）
t=t+head->
runtime;
t=t+q;
/****进程队列为不空才可调度*****/
while（!
empty（head））
PCB*p1,*p2;
\n时刻进程运行后的状态\n"
/*第一种情况：
当前运行的时间小于最后一个进程到达时间做一下操作*/
while（t<
lt）
p1=head->
printf（"
%2d%s"
t,p1->
Name）;
p1->
runtime=p1->
runtime-q;
//1.运行时间小于0，删除队首
if（p1->
=0）
p1->
state='
C'
printf（"
%c\n"
p1->
FinishTime=t;
WeightTime=p1->
FinishTime-p1->
WeightWholeTime=p1->
WeightTime/p1->
wholetime;
SumWT+=p1->
WeightTime;
SumWWT+=p1->
WeightWholeTime;
时刻%2d进程%s运行结束,进程%s周转时间=%5.2f,带权周转时间=%5.2f\n"
Name,p1->
WeightTime,p1->
WeightWholeTime）;
head->
front=p1->
free（p1）;
//2.运行时间大于0，向后找位置插入
else
p2=p1->
while（p2->
next&
p2->
arrivetime!
=t）
p2=p2->
//此时无新进入队列的进程，有两种情况：
1.不用找位置往后插入，队首不变，不做操作
//2.找位置往后插入
if（p2->
PCB*p3=p1,*p4;
while（p3->
p3->
arrivetime<
t）
{
p4=p3;
p3=p3->
}
if（p3->
arrivetime>
if（p4!
=p1）//p1插在p4后，头为p1->
next
{
head->
p1->
next=p4->
p4->
next=p1;
}
else//不做操作
p4=p3=p2=NULL;
else
p4=p3=p2=NULL;
//此时有新进入队列的进程时：
p1插在新进入队列的进程p2后，队首为p1->
else
head->
p1->
next=p2->
p2->
//时刻变化
if（head->
t=t+head->
t=t+q;
/*************第一种情况结束**************/
/******************第二种情况：
当期运行的时间大于最后一个进程到达的时间做以下操作*********************/
while（t>
=lt）
p1->
//printf（"
时刻%2d进程%s运行结束"
pname）;
//2.运行时间大于0，直接插在队尾
//若原队列只有一个进程，不必往队尾插
if（!
p1->
next）
front=p1;
//若原队列有多个进程
rear=p1;
//时刻变化，队列为空时不做时刻变化
if（empty（head））
return;
if（head->
t=t+head->
t=t+q;
/*******第二种情况结束*********/
主程序Main.cpp
#include"
RR.h"
intq;
head=init（）;
head=creat（head）;
\n您输入的时间片轮转进程队列为:
print（head）;
\n请输入时间片轮转调度的时间片为:
q）;
//时间片轮转调度
RR（head,q）;
AverageWT=SumWT/N;
AverageWWT=SumWWT/N;
平均周转时间=%5.2f,平均带权周转时间=%5.2f"
AverageWT,AverageWWT）;
运行结果：
先来先服务：
短进程：
时间片轮：
心得体会：
这次的实验与上次的实验相比，在很多方面都有更多的难度，所以我们参考了别人很多的程序然后稍作了修改。
但是由于自身知识不够，所以没能将三个算法都弄到一个大程序中，只能通过三个程序来实现，这一点是我们的不足。
虽然如此，我们还是有了一定的收获，比如更加深刻了解到了先来先服务、短进程、时间片轮这三种作业的原理，而且这一过程中我们觉得时间片轮调度算法更具优势。
升级会员 