操作系统实验.docx

操作系统实验.docx

《操作系统实验.docx》由会员分享，可在线阅读，更多相关《操作系统实验.docx（16页珍藏版）》请在冰豆网上搜索。

操作系统实验

操作系统实验报告一

【实验题目】

先来先服务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）输出：

要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

实现提示：

用C++语言实现提示：

1）程序中进程调度时间变量描述如下：

staticintMaxNum=100;

intArrivalTime[MaxNum];

intServiceTime[MaxNum];

intFinishTime[MaxNum];

intWholeTime[MaxNum];

doubleWeightWholeTime[MaxNum];

doubleAverageWT_FCFS,AverageWT_SJF;

doubleAverageWWT_FCFS,AverageWWT_SJF;

2）进程调度的实现过程如下：

Ø变量初始化；

Ø接收用户输入n，T1,…,Tn，S1,…,Sn；算法选择1-FCFS，2-SJF；

Ø按照选择算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；

Ø计算所有进程的平均周转时间和平均带权周转时间；

Ø按格式输出调度结果。

【实验要求】

1）上机前认真复习FCFS和SJF进程调度调度算法，熟悉进程调度的执行过程；

2）上机时独立编程、调试程序；

3）根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图）。

【源代码】

一、在VisualC++6.0中实现。

【程序代码】

#include

#include

#defineNumber5

voidmain（）

{

intdaoda[Number],fuwu[Number],i;

for（i=0;i

{

cout<<"请输入第"<

";

cin>>daoda[i]>>fuwu[i];

}

structstatedd//声明结构

{

booldoneF,doneS;

intdaoda,fuwu;

floatwancheng,zhouzhuan,daiquan,wan,zhou,dai;

};

stateddprocess[Number];//声明结构变量，这里为数组

inttimeflyF=0,timeflyS=0;//定义两个类似于秒表的变量

intj,k,nextproF,nextproS;

//获取数据

for（i=0;i

{

process[i].doneF=false;

process[i].doneS=false;

process[i].wancheng=0;

process[i].zhouzhuan=0;

process[i].daiquan=0;

process[i].wan=0;

process[i].zhou=0;

process[i].dai=0;

process[i].daoda=daoda[i];

process[i].fuwu=fuwu[i];

}

//获取最先到达的进程下标first

intfirst=0;

for（i=1;i

{

if（daoda[first]>daoda[i]）

first=i;

}

process[first].doneF=true;

process[first].doneS=true;

process[first].wancheng=process[first].fuwu+process[first].daoda;

process[first].wan=process[first].fuwu+process[first].daoda;

timeflyF+=process[first].daoda+process[first].fuwu;

timeflyS+=process[first].daoda+process[first].fuwu;

//接下去到达的进程

//********************************************************************

//fcfs********************************************************

for（j=1;j

{

nextproF=Number+1;

for（k=0;k

{

if（!

process[k].doneF）

{

if（process[k].daoda<=timeflyF）//到达

{

if（nextproF==Number+1）

nextproF=k;

else

{

if（process[nextproF].daoda>process[k].daoda）

nextproF=k;//获取到达时刻最先的进程

}//else

}//if2

}//if1

}//for

//处理

process[nextproF].wancheng=process[nextproF].fuwu+timeflyF;

timeflyF+=process[nextproF].fuwu;

process[nextproF].doneF=true;

}//circle2

//SJF**********************************************

for（j=1;j

{

nextproS=Number+1;

for（k=0;k

{

if（!

process[k].doneS）

{

if（process[k].daoda<=timeflyS）//到达

{

if（nextproS==Number+1）

nextproS=k;

else

{

if（process[nextproS].fuwu>process[k].fuwu）

nextproS=k;//获取服务时间最小的进程

}//else

}//if2

}//if1

}//for

//处理

process[nextproS].wan=process[nextproS].fuwu+timeflyS;

timeflyS+=process[nextproS].fuwu;

process[nextproS].doneS=true;

}//circle2

//******************************************************************************

floatFz=0,Fdq=0,Sz=0,Sdq=0;//

for（i=0;i

{//----------------------------------------------------

process[i].zhouzhuan=process[i].wancheng-process[i].daoda;

Fz+=process[i].zhouzhuan;

process[i].daiquan=process[i].zhouzhuan/process[i].fuwu;

Fdq+=process[i].daiquan;

//----------------------------------------------------

process[i].zhou=process[i].wan-process[i].daoda;

Sz+=process[i].zhou;

process[i].dai=process[i].zhou/process[i].fuwu;

Sdq+=process[i].dai;

}

//=========================输出==================================

//-------------------------------------------------------------------

cout<<"\t"<

cout<<"FCFS:

"<

cout<

cout<

cout<

cout<

for（i=0;i

{

cout<

cout<

:

fixed）<

（2）<

cout<

:

fixed）<

（2）<

cout<

:

fixed）<

（2）<

}

cout<<"平均周转时间为：

"<

:

fixed）<

（2）<

cout<<"平均带权周转时间为：

"<

:

fixed）<

（2）<

//-------------------------------------------------------------------

cout<<"\t"<

cout<<"SJF:

"<

cout<

cout<

cout<

cout<

for（i=0;i

{

cout<

cout<

:

fixed）<

（2）<

cout<

:

fixed）<

（2）<

cout<

:

fixed）<

（2）<

}

cout<<"平均周转时间为：

"<

:

fixed）<

（2）<

cout<<"平均带权周转时间为：

"<

:

fixed）<

（2）<

cout<<"\t"<

}

【效果截图】

二、在VisualStudio2008中基于对话框模式实现，最终生成exe可执行文件。

【主要代码】

voidCsc20101114Dlg:

:

OnBnClickedjisuan（）

{

//TODO:

在此添加控件通知处理程序代码

//test

/*daodaA=0;

daodaB=1;

daodaC=2;

daodaD=3;

daodaE=4;

fuwuA=4;

fuwuB=3;

fuwuC=5;

fuwuD=2;

fuwuE=4;

UpdateData（false）;*/

//test

structstatedd

{

booldoneF;

booldoneS;

intdaoda;

intfuwu;

floatwancheng;

floatzhouzhuan;

floatdaiquan;

floatwan;

floatzhou;

floatdai;

};

stateddprocess[5];

inttimeflyF=0;

inttimeflyS=0;

intcircle;

intcircle2;

intnextproF;

intnextproS;

UpdateData（true）;//获取数据

process[0].doneF=false;

process[0].doneS=false;

process[0].wancheng=0;

process[0].zhouzhuan=0;

process[0].daiquan=0;

process[0].wan=0;

process[0].zhou=0;

process[0].dai=0;

process[0].daoda=daodaA;

process[0].fuwu=fuwuA;

process[1].doneF=false;

process[1].doneS=false;

process[1].wancheng=0;

process[1].zhouzhuan=0;

process[1].daiquan=0;

process[1].wan=0;

process[1].zhou=0;

process[1].dai=0;

process[1].daoda=daodaB;

process[1].fuwu=fuwuB;

process[2].doneF=false;

process[2].doneS=false;

process[2].wancheng=0;

process[2].zhouzhuan=0;

process[2].daiquan=0;

process[2].wan=0;

process[2].zhou=0;

process[2].dai=0;

process[2].daoda=daodaC;

process[2].fuwu=fuwuC;

process[3].doneF=false;

process[3].doneS=false;

process[3].wancheng=0;

process[3].zhouzhuan=0;

process[3].daiquan=0;

process[3].wan=0;

process[3].zhou=0;

process[3].dai=0;

process[3].daoda=daodaD;

process[3].fuwu=fuwuD;

process[4].doneF=false;

process[4].doneS=false;

process[4].wancheng=0;

process[4].zhouzhuan=0;

process[4].daiquan=0;

process[4].wan=0;

process[4].zhou=0;

process[4].dai=0;

process[4].daoda=daodaE;

process[4].fuwu=fuwuE;

//最先到达的进程

intminnum=min（daodaA,min（daodaB,min（daodaC,min（daodaD,daodaE））））;

for（circle=0;circle<5;circle++）

{

if（minnum==process[circle].daoda）

{

process[circle].doneF=true;

process[circle].doneS=true;

process[circle].wancheng=process[circle].fuwu+process[circle].daoda;

process[circle].wan=process[circle].fuwu+process[circle].daoda;

process[circle].zhouzhuan=process[circle].wancheng-process[circle].daoda;

process[circle].zhou=process[circle].wan-process[circle].daoda;

process[circle].daiquan=process[circle].zhouzhuan/process[circle].fuwu;

process[circle].dai=process[circle].zhou/process[circle].fuwu;

timeflyF+=process[circle].daoda+process[circle].fuwu;

timeflyS+=process[circle].daoda+process[circle].fuwu;

break;

}

}

//接下去到达的进程

//fcfs********************************************************

for（circle2=0;circle2<5;circle2++）

{

nextproF=8;

for（circle=0;circle<5;circle++）

{

if（!

process[circle].doneF）

{

if（process[circle].daoda<=timeflyF）//到达

{

if（nextproF==8）

nextproF=circle;

else

{

if（process[nextproF].daoda>process[circle].daoda）

nextproF=circle;//获取到达时刻最先的进程

}

}

}

}

//处理

process[nextproF].wancheng=process[nextproF].fuwu+timeflyF;

process[nextproF].zhouzhuan=process[nextproF].wancheng-process[nextproF].daoda;

process[nextproF].daiquan=process[nextproF].zhouzhuan/process[nextproF].fuwu;

timeflyF+=process[nextproF].fuwu;

process[nextproF].doneF=true;

}//circle2

//SJF**********************************************

for（circle2=0;circle2<5;circle2++）

{

nextproS=8;

for（circle=0;circle<5;circle++）

{

if（!

process[circle].doneS）

{

if（process[circle].daoda<=timeflyS）//到达

{

if（nextproS==8）

nextproS=circle;

else

{

if（process[nextproS].fuwu>process[circle].fuwu）

nextproS=circle;//获取服务时间最小的进程

}

}

}

}

//处理

process[nextproS].wan=process[nextproS].fuwu+timeflyS;

process[nextproS].zhou=process[nextproS].wan-process[nextproS].daoda;

process[nextproS].dai=process[nextproS].zhou/process[nextpro