操作系统实验分析解析

操作系统实验报告一

【实验题目】

先来先服务FCFS和短作业优先SJF进程调度算法

【实验目的】

通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】

问题描述：

设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, …,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

程序要求如下：

1）进程个数n；每个进程的到达时间T1, …,T n和服务时间S1, … ,S n；选择算法1-FCFS，2-SJF。

2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；

3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；

4）输出：要求输出计算出来的每个进程的周转时间，带权周转时

间，所有进程的平均周转时间，带权平均周转时间。

实现提示：

用C++语言实现提示：

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

static int MaxNum=100;

int ArrivalTime[MaxNum];

int ServiceTime[MaxNum];

int FinishTime[MaxNum];

int WholeTime[MaxNum];

double WeightWholeTime[MaxNum];

double AverageWT_FCFS,AverageWT_SJF;

double AverageWWT_FCFS,AverageWWT_SJF;

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

变量初始化；

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

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

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

按格式输出调度结果。

【实验要求】

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

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

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

【源代码】

一、在VisualC++6.0中实现。

【程序代码】

#include

#include

#define Number 5

void main()

{

int daoda[Number],fuwu[Number],i;

for(i=0;i

{

cout<<"请输入第"<

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

}

struct statedd //声明结构

{

bool doneF,doneS;

int daoda,fuwu;

float wancheng,zhouzhuan,daiquan,wan,zhou,dai;

};

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

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

int j,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

int first=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

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

float Fz=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<

cout<

cout<

"<

}

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

cout<<"\t"<

cout<<"SJF:"<

cout<

cout<

cout<

cout<

for(i=0;i

{

cout<

cout<

cout<

cout<

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

}

【效果截图】

二、在Visual Studio 2008中基于对话框模式实现，最终生成exe可执行文件。【主要代码】

void Csc20101114Dlg::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

struct statedd

{

bool doneF;

bool doneS;

int daoda;

int fuwu;

float wancheng;

float zhouzhuan;

float daiquan;

float wan;

float zhou;

float dai;

};

statedd process[5];

int timeflyF=0;

int timeflyS=0;

int circle;

int circle2;

int nextproF;

int nextproS;

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].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].dai =0;

process[4].daoda = daodaE;

process[4].fuwu = fuwuE;

// 最先到达的进程

int minnum=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[nextproS].fuwu;

timeflyS += process[nextproS].fuwu;

process[nextproS].doneS=true;

} // circle2

// 更新变量，显示

wan1A = process[0].wancheng;

wan1B = process[1].wancheng;

wan1C = process[2].wancheng;

wan1D = process[3].wancheng;

wan1E = process[4].wancheng;

zhou1A = process[0].zhouzhuan;

zhou1B = process[1].zhouzhuan;

zhou1C = process[2].zhouzhuan;

zhou1D = process[3].zhouzhuan;

zhou1E = process[4].zhouzhuan;

zhou1P = (zhou1A+zhou1B+zhou1C+zhou1D+zhou1E)/5;

dqzhou1A = process[0].daiquan;

dqzhou1B = process[1].daiquan;

dqzhou1C = process[2].daiquan;

dqzhou1D = process[3].daiquan;

dqzhou1E = process[4].daiquan;

dqzhou1P = (dqzhou1A+dqzhou1B+dqzhou1C+dqzhou1D+dqzhou1E)/5;

wan2A = process[0].wan;

wan2B = process[1].wan;

wan2C = process[2].wan;

wan2D = process[3].wan;

wan2E = process[4].wan;

zhou2A = process[0].zhou;

zhou2B = process[1].zhou;

zhou2C = process[2].zhou;

zhou2D = process[3].zhou;

zhou2E = process[4].zhou;

zhou2P = (zhou2A+zhou2B+zhou2C+zhou2D+zhou2E)/5;

dqzhou2A = process[0].dai;

dqzhou2B = process[1].dai;

dqzhou2C = process[2].dai;

dqzhou2D = process[3].dai;

dqzhou2E = process[4].dai;

dqzhou2P = (dqzhou2A+dqzhou2B+dqzhou2C+dqzhou2D+dqzhou2E)/5;

UpdateData(false); // 更新显示

}

【效果截图】

输入各进程的到达时间和服务时间，点击“计算”按钮：