操作系统进程调度实验报告1

一、实验目的
通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。

二、实验要求
编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法（先来先服务算法，短作业算法）分别进行模拟调度。

三、实验内容
编程实现如下算法
1．先来先服务算法；
2．短作业算法
四、实验代码
1．先来先服务算法
#include"stdio.h"
#include"stdlib.h"
typedef struct PCB //定义进程控制块
{ char name[10]; //进程名
char state; //运行状态
int ArriveTime; //到达时间
int StartTime; //进程开始时间
int FinishTime; //进程结束时间
int ServiceTime; //服务时间
float WholeTime; //周转时间
float WeightWholeTime;//带权周转时间
double AverageWT_FCFS; //平均周转时间
double AverageWWT_FCFS;//带权平均周转时间
struct PCB *next; //指向下个进程
}pcb;
double x=0,y=0;
int i;
int time; //计时器
int n; //进程个数
pcb *head=NULL,*p,*q; //进程链表指针
void run_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);
}
void FCFS() //找到当前未完成的进程
{
int i;
p=head;
for(i=0;i<n;i++)
{
if(p->state=='F')
{ q=p; //标记当前未完成的进程
run_FCFS(q);
}
p=p->next;
}
}
void getInfo() //获得进程信息并创建进程
{
int num;
printf("\n进程个数:");
scanf("%d",&n);
for(num=0;num<n;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->ArriveTime < time)
time=p->ArriveTime;
q->next=p;
p->StartTime=0;
p->FinishTime=0;
p->WholeTime=0;
p->WeightWholeTime=0;
p->next=NULL;
p->state='F';
q=p;
}
}
void main()
{
printf("先来先服务FCFS算法模拟\n");
getInfo();
p=head;
FCFS();
}
2．短作业调度算法
#include<iostream>
#include<stdio.h>
#include<iomanip>
#include<queue>
#include<deque>
using namespace std;
class JCB
{
public:
int start,end,arrive,runtime,zhou,weizhou;
string name;
char state;
void Show()
{
cout.width(9);cout<<name;
cout.width(9);cout<<arrive;
cout.width(11);cout<<runtime;
cout.width(13);cout<<start;
cout.width(10);cout<<end;
cout.width(10);cout<<zhou;
cout.width(9);cout<<(double)zhou/runtime<<endl;
}
bool operator<(const JCB& node)const
{
return arrive<node.arrive;
}
};
int main()
{
int num;
deque<JCB> Q;
JCB jcb;
cout<<"（SJF）请输入作业数目：";
cin>>num;
for(int i=1; i<=num; i++)
{
cout<<"\n请输入作业名，到达时间，运行时间：";
cin>>>>jcb.arrive>>jcb.runtime;
jcb.state='W';
Q.push_back(jcb);
}
deque<JCB>::iterator it,jt,current;
current=Q.begin();
current->start=current->arrive;
current->end=current->start+current->runtime;
current->zhou=current->end-current->arrive;
current->state='R';
for(int i=2; i<=num; i++)
{
int flag=0;
for(it=Q.begin(); it!=Q.end(); it++)
{
if(flag==0)
for(jt=Q.begin(); jt!=Q.end(); jt++)
if(jt->state=='W') break;
if(it->state=='W'&&it->arrive<=current->end&&it->runtime<jt->runtime)
{ jt=it; flag=1;}
}
if(jt->arrive<=current->end)
jt->start=current->end;
else jt->start=jt->arrive;
jt->end=jt->start+jt->runtime;
jt->zhou=jt->end-jt->arrive;
jt->state='R';
current=jt;
}
cout<<"\n作业名到达时间服务时间开始执行时间完成时间周转时间带权周转时间"<<endl;
cout.setf(ios::left);
double sum=0;
while(!Q.empty())
{
jcb=Q.front();
jcb.Show();
sum+=(double )jcb.zhou/jcb.runtime;
Q.pop_front();
}
cout<<"\n短作业优先算法(SJF)平均带权周转时间："<<sum/num<<endl;
return 0;
}
五、实验结果
1.执行结果
2.结果分析
先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。

以上就是本次进程调度实验的依据。

六、实验总结
通过本次实验我们了解到调度算法的不同，更加明白算法本身可以节约时间，而且不同的函数之间在调用的时候要注意很多的问题。

比如，进行先
来先服务调度算法时，到达时间是它的判断标准，到达时间在前的先执行；
而短作业调度算法的执行标准是以每个进程运行时间的长短，在已经到达的进程中选择运行时间短的优先执行。

在此过程中，我们加深了对进程调度的了解和认识。