您的位置:澳门新葡8455最新网站 > 澳门新葡8455最新网站 > 操作系统高响应比优先进轨范拟算法,实验二告

操作系统高响应比优先进轨范拟算法,实验二告

发布时间:2019-11-10 13:03编辑:澳门新葡8455最新网站浏览(200)

      那学期刚早先学习操作系统,收到一个功课,百度有关高响应比优先(H冠道昂CoraN,Highest Response Ratio Next卡塔尔的CPU进度调解模拟算法,基本思维:短作业优先调整算法 + 动态优先权机制;既思量作业的实践时间也酌量作业的守候时间,综合了先来先服务(FCFS,First Come First Served卡塔尔和最短作业优先(SJF,Shortest Job First卡塔尔二种算法的表征。

                                                                                     实验生机勃勃、作业调节模拟程序实验

      之后通过多番揣摩... ...决定分界面用命令行算了,反正啥也不会...

                                                                                13物联网工程    刘烨(Yang Wei卡塔尔   201206104146

      关于响应比:

    风流浪漫、 实验目标

        LANDCRUISER =  (推断运维时刻 + 等待时间) / 揣摸运营时刻 = 1 + 等候时间/估量运营时刻;

    (1卡塔尔加深对学业调解算法的通晓;

      响应比高者优先开展调整;

    (2卡塔 尔(英语:State of Qatar)实行程序设计的练习。 

     

    二、 实验内容和供给

      关于要求中的周转时间、带权周转时间、平均运营时间和平均带权周转时间:

    用高级语言编写叁个或多个作业调节的模拟程序。

        周转时间 =(作业实现的小时 - 作业提交时间卡塔 尔(英语:State of Qatar);

    单道批管理系统的功课调整程序。作业生龙活虎投入运作,它就据有计算机的任何能源直到作业成功截至,因而调整作业时不用思谋它所急需的财富是或不是拿走满意,它所运维的岁月等要素。

        带权周转时间 = 作业周转时间 / 作业运维时刻;

         作业调整算法:

        平均运维时间 = (周转时间1+周转时间2+...+周转时间n卡塔尔/ n;

    1) 选取先来先服务(FCFS卡塔尔调节算法,即按作业到达的前后相继次序进行调治。总是第生机勃勃调节在系统中等待时间最长的学业。

        平均带权周转时间 = (带权周转时间1+带权周转时间2+...+带权周转时间n卡塔尔/ n;

    2) 短作业优先 (SJF) 调解算法,优先调整必要运转时刻最短的课业。

     

    3) 响应比高者优先(H传祺奥迪Q7N)调节算法,为各样作业设置叁个优先权(响应比),调解以前先总计各作业的优先权,优先数高者优先调治。RP (响应比)= 作业周转时间 / 作业运维时刻=1+作业等待时间/作业运行时刻

      开端,用vector存款和储蓄提交的课业结构体指针,本身设置一个体系时间,究竟模拟不容许时间流速一毛同样,接下去正是不要技能含量的选项了,关于测量试验数据,想了想好难输,还得投机编,于是用随机函数产生多少;再在主函数参数中提供一个传递生成数据数量的参数。

    各种作业由二个作业调控块JCB代表,JCB能够分包以下音讯:作业名、提交(达到卡塔尔时间、所需的周转时刻、所需的财富、作业状态、链指针等等。

      谈起此处得说一下,关于java先生(对的,java先生卡塔尔说的有关main()的有些动静:

    三、 实验方法、步骤及结果测量检验

    1 int main(int argc, char** argv){ ////argc为参数个数, argv为接下来传的参数
    2     ...
    3     return 0;
    4 }
    
    1. 源程序名:实验二 改进版.c

     

    可推行程序名:纠正版.exe

    举个例子在指令行中调用该函数,***.exe 100,那时候有八个参数,三个为"***.exe", 另贰个便是"100"了,分别在argv[0]和argv[1]中。

    1. 规律深入分析及流程图

      首先是数量变化,用为必要格式,所以要小拍卖一下,以为这种办法能够在刷ACM题被难点玄学时接纳,一个为职业代码,贰个为投机的代码,最近未试过:

       此番实验重要用了协会体数组来促成。首先定义叁个JCB模块用于存放作业音讯,如到达时刻,运转时刻等。后来逐一函数分别达成相应的学业调解。当中用到冒泡排序将作业按到达时刻依然运营时刻排序。

     1 #include "bits/stdc++.h"
     2 using namespace std;
     3 
     4 int ch_to_int(char* s){
     5     int ans = 0, len = strlen(s);
     6     for(int i = 0; i < len; i++) ans = ans*10 + s[i]-'0';
     7     return ans;
     8 }
     9 int main(int argc, char** argv){
    10     int k, N, tj/*0~23*/, ys/*0~59*/, tmp;
    11     freopen("test.txt", "w", stdout);
    12     srand(time(NULL));   //以系统时间为种子生成真正的随机数
    13     N = k = ch_to_int(argv[1]);
    14     while(k--){
    15         tmp = (rand() + 24)%24 * 100 + (rand() + 6)%6*10 + (rand() + 10)%10;
    16         printf("%04d %dn", tmp, (rand() + N)%N + 1);
    17     }
    18     return 0;
    19 }
    

    澳门新葡8455最新网站 1

     

    1. 尤为重要程序段及其表明:

      调整算法:

    #include<stdio.h>

     1 #include "bits/stdc++.h"
     2 #include "windows.h"
     3 using namespace std;
     4 typedef long long ll; 
     5 
     6 //(所有时间以分钟为单位存储,需要时转化) 
     7 
     8 ll systemTime;    //自定义系统当前时间
     9 
    10 struct Task{
    11     int Tij; //提交时间 
    12     int Ysi; //预计运行时间 
    13     ll waitingTime;  //等待时间
    14     int id; //作业号
    15     
    16     ll prior(){
    17         return 1 + waitingTime*1.0/Ysi;
    18     }
    19     
    20     Task(int T, int Y){
    21         Tij = T;
    22         Ysi = Y;
    23         waitingTime = 0;
    24     }
    25     ll aroundTime(){
    26         return systemTime - Tij + Ysi;
    27     }
    28     
    29     double priorTime(){
    30         return aroundTime()*1.0/Ysi;
    31     }
    32     void disp(int ord){
    33         printf("--调度次序: %d --作业号: %04d --调度时间:%02d%02d --周转时间: %d min(s) --带权周转时间%.2f  ...n", 
    34             ord, id, (systemTime/100 + systemTime/60)%24, systemTime%60, aroundTime(), priorTime());
    35     }
    36 };
    37 
    38 int cmp1(const Task* a, const Task* b){
    39     return (a->Tij) < (b->Tij);
    40 }
    41 
    42 int main(){
    43     vector<Task*> taskArr;    ///以不定长数组存储作业队列
    44     
    45     int Tij, Ysi, order;
    46     ll ave_aroundTime = 0;
    47     double ave_prior_aroundTime = 0;
    48     
    49     freopen("test.txt", "r", stdin);
    50     system(".\生成测试数据.exe 1024");    //调用测试数据生成程序
    51     
    52     while(cin>>Tij>>Ysi) taskArr.push_back(new Task(Tij%100 + Tij/100*60, Ysi));
    53     
    54     ////按提交时间进行排序并编号 
    55     sort(taskArr.begin(), taskArr.end(), cmp1);
    56     std::vector<Task*>::iterator pos;
    57     for(pos = taskArr.begin(); pos != taskArr.end(); pos++){
    58         (*pos)->id = pos - taskArr.begin();
    59     }
    60     
    61     std::vector<Task*>::iterator willRun;  //指向即将运行程序 
    62     systemTime = (*taskArr.begin())->Tij;    ///将系统当前时间设置为最早提交的作业时间 
    63     order = -1;
    64     while(!taskArr.empty()){
    65         bool flag = false; ///判定是否有新的程序提交 
    66         willRun = taskArr.begin();
    67         for(pos = taskArr.begin(); pos != taskArr.end(); pos++){
    68             if((*pos)->Tij > systemTime) break;
    69             willRun = (*willRun)->prior() < (*pos)->prior() ? pos : willRun;
    70             flag = true;
    71         }
    72         if(!flag){
    73             willRun = taskArr.begin();
    74             systemTime = (*willRun)->Tij;
    75         }
    76         
    77         (*willRun)->disp(++order);
    78         
    79         ave_aroundTime += (*willRun)->aroundTime();  //总周转 
    80         ave_prior_aroundTime += (*willRun)->priorTime();  //总带权周转 
    81         
    82         for(pos = taskArr.begin(); pos != taskArr.end(); pos++){  //更新等待时间 
    83             if((*pos)->Tij < systemTime){
    84                 (*pos)->waitingTime += (*willRun)->Ysi;
    85             }
    86         }
    87 
    88         systemTime += (*willRun)->Ysi;  //系统时间增加 
    89 
    90         taskArr.erase(willRun); //结束则删除 
    91         
    92         //Sleep(10);
    93     }
    94     cout<<ave_aroundTime<<' '<<ave_prior_aroundTime<<endl;
    95     printf("n----平均周转时间: %.2f --平均带权周转时间: %.2f ...n作业结束..", ave_aroundTime*1.0/order, ave_prior_aroundTime/order);
    96 
    97     return 0;
    98 } 
    

    #include <stdlib.h>

    加油( ̄▽ ̄)"

    int i,k,num,m,n;

    #define N  24

    struct JCB{

            char name[10];      //作业名

            float arrive;           //作业提交时间  

            float run;           //作业运转时刻  

            float start;          //起先时间       

            float finish;       //达成时刻       

            float zhouzhuan;         //周转时间       

            float weight;       //带权周转时间  

    }jcb[N],temp;

    void input()                //客户输入模块

    {

        int i;  

        do{

            printf("nt请输入作业数(2-24):");

            scanf("%d",&num); 

            printf("n");

            if(num<2||num>24)

    {

                printf("t请重新输入!n");

            }

        }

        while(num<2||num>24);

        for(i=0;i<num;i++){

            printf("t第%d个作业名:",i+1);   

            scanf("%s",&jcb[i].name);   

            printf("nt请输入作业提交时间:");   

            scanf("%f",&jcb[i].arrive);   

            printf("nt请输入作业运转时刻:");   

            scanf("%f",&jcb[i].run);   

            printf("n");

        }

    }

    void output()             //输出模块

    {

        float   numT=0;  

    float numW=0;

    float avgT=0;  //平均周转时间

    float avgW=0;   //平均带权作业周转时间

        printf("-----------------------------------------------------------------------n");

        printf(" 作业名  提交时间  运转时刻  开首时间  达成时间  周转时间  带权周转时间n");

        for(i=0;i<num;i++)

        {

            printf("   %-8s%-10.2f%-10.2f%-10.2f%-10.2f%-10.2f%-10.2f",jcb[i].name,jcb[i].arrive,jcb[i].run,jcb

     

            [i].start,jcb[i].finish,jcb[i].zhouzhuan,jcb[i].weight);

            printf("n");

            numT=numT+jcb[i].zhouzhuan;

            numW=numW+jcb[i].weight; 

        }

        printf("-----------------------------------------------------------------------n");

        avgT=numT/num;

        avgW=numW/num;

        printf("平均作业周转时间:%.2fn",avgT);

        printf("n");

        printf("平均带权作业周转时间:%.2fn",avgW); 

        printf("n");

    }

     float addallruntime()//获得全体作业运营时刻

     {

        int i;

         float allruntime=0.0;

               for(i=0;i<num;i++)

               {             

                   allruntime=allruntime+jcb[i].run;

               }

               return allruntime;

     }

     

    void fcfsrunning()

    {

        for(k=0;k<num;k++)

        {

            if(k==0)/*运维第八个作业*/

            {

                jcb[k].start=jcb[k].arrive;    

                jcb[k].finish=jcb[k].arrive+jcb[k].run; 

            }

            else

            {

                if(jcb[k].arrive>=jcb[k-1].finish)/*现阶段作业运维完,但背后作业没达到*/

                {

                    jcb[k].start=jcb[k].arrive;     

                    jcb[k].finish=jcb[k].arrive+jcb[k].run;

                }

                else/*当前作业没运转完,前面作业已达到*/

                {

                    jcb[k].start=jcb[k-1].finish;     

                    jcb[k].finish=jcb[k-1].finish+jcb[k].run; 

                }

            }

                

        }

        for(k=0;k<num;k++)

        {

            jcb[k].zhouzhuan=jcb[k].finish-jcb[k].arrive;   

            jcb[k].weight=jcb[k].zhouzhuan/jcb[k].run;

        }

    }

    void FCFS()     //先来先服务

    {

        int i,j;

        for(j=0;j<num;j++)    //冒泡排序,按达到时间排序

        {

            for(i=0;i<num-j-1;i++)

            {

                if(jcb[i].arrive>jcb[i+1].arrive) 

                {

                    temp=jcb[i];     

                    jcb[i]=jcb[i+1];     

                    jcb[i+1]=temp;

                }

            }

        } 

        fcfsrunning();  

        output();

    void SJF(float allruntime)  //非抢占

    {

    float mintime=0; struct JCB jtemp={0};

     

        int  min=0;

    int startwork=0;

    float i;

    int k;

    for (i=0;i<allruntime;)

     

      {

             mintime=jcb[startwork].run;//借使三个剩余时间的最小值

             for(k=startwork;k<num;k++)

             {

                

                 if(jcb[k].run<=mintime&&jcb[k].arrive<=i)

                {

                     mintime=jcb[k].run;

                     min=k;

                 }

                 

             }

             jcb[min].start=i;

            

             jcb[min].finish=jcb[min].start+jcb[min].run;

             jcb[min].zhouzhuan=jcb[min].finish-jcb[min].arrive;

             jcb[min].weight=jcb[min].zhouzhuan/jcb[min].run;

             

             jtemp=jcb[startwork];

             jcb[startwork]=jcb[min];

             jcb[min]=jtemp;

             

             startwork++;

             

             i=i+mintime;

         }

    output();

    }

    void HRRF(float allruntime)

     { 

         float maxrb=0;

         struct  JCB  jtemp={0};  

         int z=0;

         float time=0;

         int startwork=0;

         float i;

         int k;

         for(i=0;i<allruntime;)

         {

             maxrb=(i-jcb[startwork].arrive)/jcb[startwork].run+1;//假若是最高响应比

             

             for(k=startwork;k<num;k++)

             {              

                 if(jcb[k].arrive<=i&&(i-jcb[k].arrive)/jcb[k].run+1>=maxrb)//若此作业的最高响应比更加高,则将其记为更加高

                 {

                     time=jcb[k].run;              

                     z=k;

                 }          

             }

             jcb[z].start=i;

             jcb[z].finish=jcb[z].start+jcb[z].run;

             jcb[z].zhouzhuan=jcb[z].finish-jcb[z].arrive;

             jcb[z].weight=jcb[z].zhouzhuan/jcb[z].run;

             

             jtemp=jcb[startwork];

             jcb[startwork]=jcb[z];

             jcb[z]=jtemp; 

             startwork++;

             i=i+time;

         }

     output();

     }

    main()

    {

        int n;

    澳门新葡8455最新网站,float allruntime=0.0;   

        input(); 

    allruntime=addallruntime();

        do{

           printf("tt作业调治模拟程序n"); 

            printf("----------------------------------------------------------------n");   

    printf("t请选拔调解算法(1~3):n"); 

            printf("tt1:FCFS(先来先服务)ntt2:SJF(短作业优先)ntt3:H讴歌MDXXC90F(最高响应比优先)ntt0:exit(退出)n");  

            scanf("%d",&n);   

            if(n!=0&&n!=1&&n!=2&&n!=3)

            {

                printf("nt请重新输入!!nn");

            }

            switch(n)

            {

                case 1:FCFS(); break;    

                case 2:SJF(allruntime); break;    

                case 3:HRRF(allruntime); break;    

                case 0: break;

            }

        }

        while(n!=0);

    }

    1. 运作结果及分析

    通常必得配运维结果截图,结果是还是不是顺应预期及其剖析。

       (截图需根据实际,截取有代表性的测量试验例子卡塔 尔(英语:State of Qatar)

    先来先服务(FCFS卡塔尔国:

    澳门新葡8455最新网站 2

    澳门新葡8455最新网站 3 

     短作业优先(SJF卡塔尔国:

     澳门新葡8455最新网站 4澳门新葡8455最新网站 5

    四、实验总括:

    生机勃勃初始毫无头绪,因为并不知晓哪些算出调治结果。后来看多五次例子,做了演习,然后老师授课五回后,开首掌握算法的经过。然而用程序表达出来照旧困难的。然则想参照他事他说加以考察英特网的,但由于许多是用链表写的,看得不太懂。后来察觉用数组的格局也是足以的。并且比较直观,没那么难通晓。可是写了先来先服务后,短作业优先就没那么轻便达成了。因为要相比较作业的运维时刻,后来用了冒泡排序算法先举行意气风发番排序,再稳步完成相应的供给。至于最高相应比优先,即便知情了什么算出调解结果,但程序完成不了.

    本文由澳门新葡8455最新网站发布于澳门新葡8455最新网站,转载请注明出处:操作系统高响应比优先进轨范拟算法,实验二告

    关键词:

上一篇:没有了

下一篇:绘制底工