操作系统实验Word下载.docx

操作系统实验Word下载.docx

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

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

Ø

变量初始化；

接收用户输入n，T1,…,Tn，S1,…,Sn；

算法选择1-FCFS，2-SJF；

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

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

按格式输出调度结果。

【实验要求】

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

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

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

【源代码】

一、在VisualC++6.0中实现。

【程序代码】

#include<

iostream.h>

iomanip.h>

#defineNumber5

voidmain（）

{

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

for（i=0;

i<

Number;

i++）

{

cout<

<

"

请输入第"

i+1<

个进程的到达时间和服务时间，并以空格间隔:

;

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;

//获取数据

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;

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<

j++）

nextproF=Number+1;

for（k=0;

k<

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**********************************************

nextproS=Number+1;

for（k=0;

if（!

process[k].doneS）

=timeflyS）//到达

if（nextproS==Number+1）

nextproS=k;

else

{

if（process[nextproS].fuwu>

process[k].fuwu）

nextproS=k;

//获取服务时间最小的进程

}//else

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

timeflyS+=process[nextproS].fuwu;

process[nextproS].doneS=true;

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

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

//

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

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"

endl;

FCFS:

setw（10）<

进程ID"

"

完成时间"

周转时间"

带权周转时间"

for（i=0;

cout<

setiosflags（ios:

:

fixed）<

setprecision

（2）<

process[i].wancheng<

process[i].zhouzhuan<

process[i].daiquan<

}

平均周转时间为：

Fz/Number<

平均带权周转时间为：

Fdq/Number<

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

SJF:

process[i].wan<

process[i].zhou<

process[i].dai<

Sz/Number<

Sdq/Number<

【效果截图】

二、在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;

}

for（circle2=0;

circle2<

circle2++）

nextproF=8;

for（circle=0;

process[circle].doneF）

if（process[circle].daoda<

if（nextproF==8）

nextproF=circle;

process[circle].daoda）

nextproF=circle;

}

}

}

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

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

nextproS=8;

process[circle].doneS）

if（nextproS==8）

nextproS=circle;

process[circle].fuwu）

nextproS=circle;

}

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

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