操作系统实验1

【实验题目】

先来先服务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）程序中进程调度时间变量描述如下：

    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, … ,Tn，S1, … ,Sn；算法选择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<<"\"<cout<<"FCFS:"<cout<cout<cout<cout<for(i=0;i{

cout<cout<cout<cout<}

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

cout<<"\"<cout<<"SJF:"<cout<cout<cout<cout<for(i=0;i{

cout<cout<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].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;

    // 最先到达的进程

    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); // 更新显示

}

【效果截图】

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