zoukankan      html  css  js  c++  java
  • 实验二 作业调度模拟实验

    实验二、作业调度模拟实验

    13物联网  201306104129 钟广智

    一、 实验目的

         (1)加深对作业调度算法的理解;

         (2)进行程序设计的训练。

    二、 实验内容和要求

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

    单道批处理系统的作业调度程序。作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所运行的时间等因素。

         作业调度算法:

    1) 采用先来先服务(FCFS)调度算法,即按作业到达的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。

    2) 短作业优先 (SJF) 调度算法,优先调度要求运行时间最短的作业。

    3) 响应比高者优先(HRRN)调度算法,为每个作业设置一个优先权(响应比),调度之前先计算各作业的优先权,优先数高者优先调度。RP (响应比)= 作业周转时间 / 作业运行时间=1+作业等待时间/作业运行时间

    每个作业由一个作业控制块JCB表示,JCB可以包含以下信息:作业名、提交(到达)时间、所需的运行时间、所需的资源、作业状态、链指针等等。

         作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种之一。每个作业的最初状态都是等待W。

    2.1 模拟数据的生成

    1. 允许用户指定作业的个数(2-24),默认值为5。

    2. 允许用户选择输入每个作业的到达时间和所需运行时间。

    3. (**)从文件中读入以上数据。

    4. (**)也允许用户选择通过伪随机数指定每个作业的到达时间(0-30)和所需运行时间(1-8)。 

    2.2 模拟程序的功能

    1. 按照模拟数据的到达时间和所需运行时间,执行FCFS, SJF和HRRN调度算法,程序计算各作业的开始执行时间,各作业的完成时间,周转时间和带权周转时间(周转系数)。

    2. 动态演示每调度一次,更新现在系统时刻,处于运行状态和等待各作业的相应信息(作业名、到达时间、所需的运行时间等)对于HRRN算法,能在每次调度时显示各作业的响应比R情况。

    3. (**)允许用户在模拟过程中提交新作业。

    4. (**)编写并调度一个多道程序系统的作业调度模拟程序。 只要求作业调度算法:采用基于先来先服务的调度算法。 对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

    2.3 模拟数据结果分析

    1. 对同一个模拟数据各算法的平均周转时间,周转系数比较。

    2. (**)用曲线图或柱形图表示出以上数据,分析算法的优点和缺点。

    2.4 其他要求

    1. 完成报告书,内容完整,规格规范。

    2. 实验须检查,回答实验相关问题。

    注:带**号的条目表示选做内容。

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

      1.流程图

         

    2、源程序

      1 #include<stdio.h>
      2 #include<stdlib.h>
      3 #include<string.h>
      4 #define MAX 100
      5 typedef struct 
      6 {
      7 char name[4];//进程名
      8 int  starttime;//到达系统时间
      9 int needtime;//运行时间
     10 int runtime;//周转时间
     11 int endtime;//完成时间
     12 int waittime;//等待时间
     13 double XYB;//响应比
     14 double DQZZ_Time;//带权周转时间
     15 }pr;
     16  
     17 pr a[MAX];
     18 
     19 void input(int n)
     20 {
     21     int i;
     22     for(i=0;i<n;i++)
     23     {
     24     printf("name:");
     25     scanf("%s",&a[i].name);
     26     printf("
    ");
     27 
     28     printf("starttime:");
     29     scanf("%d",&a[i].starttime);
     30     printf("
    ");
     31 
     32     printf("needtime:");
     33     scanf("%d",&a[i].needtime);
     34     printf("
    ");
     35     }
     36 }
     37 
     38 void FCFS(int n)//先来先服务
     39 {
     40     int i,j,time1,time2; 
     41     char temp[4];    
     42      for(i=0;i<n-1;i++) 
     43      {   
     44          for(j=0;j<n-i-1;j++)
     45              if(a[j].starttime>a[j+1].starttime)
     46              {
     47                 time1=a[j].starttime;
     48                 a[j].starttime=a[j+1].starttime;
     49                 a[j+1].starttime=time1;
     50                 time2=a[j].needtime;
     51                 a[j].needtime=a[j+1].needtime;
     52                 a[j+1].needtime=time2;
     53                 strcpy(temp,a[j].name);   
     54                 strcpy(a[j].name,a[j+1].name); 
     55                 strcpy(a[j+1].name,temp); 
     56              }
     57      }
     58     for(i=0;i<n;i++) 
     59      {    
     60      //第一个进程       
     61          if(i==0)       
     62          {             
     63              a[i].runtime=a[i].needtime;     
     64              a[i].endtime=a[i].starttime+a[i].runtime;   
     65          }        
     66          else    
     67          {            
     68              if(a[i].starttime>a[i-1].endtime)    
     69              {               
     70                  a[i].runtime=a[i].needtime;   
     71                  a[i].endtime=a[i].starttime+a[i].runtime;     
     72              }           
     73              else           
     74              {                
     75                  a[i].runtime=a[i].needtime+a[i-1].endtime-a[i].starttime;         
     76                  a[i].endtime=a[i].starttime+a[i].runtime;          
     77              }        
     78          }   
     79          a[i].DQZZ_Time=a[i].runtime*1.0/a[i].needtime;  
     80      }
     81 }
     82 
     83 //最短作业优先,假设在前3个作业运行完之前所有作业均已到达
     84 void SJF(int n)
     85 {
     86 int i,j,time1,time2;
     87 int b=0,c=0,d=0; 
     88 char temp[4]; 
     89 
     90 //先按到达时间排序
     91     for(i=0;i<n-1;i++)  
     92     {   
     93            for(j=0;j<n-i-1;j++)
     94              if(a[j].starttime>a[j+1].starttime)
     95              {
     96                 time1=a[j].starttime;
     97                 a[j].starttime=a[j+1].starttime;
     98                 a[j+1].starttime=time1;
     99                 time2=a[j].needtime;
    100                 a[j].needtime=a[j+1].needtime;
    101                 a[j+1].needtime=time2;
    102                 strcpy(temp,a[j].name);   
    103                 strcpy(a[j].name,a[j+1].name); 
    104                 strcpy(a[j+1].name,temp); 
    105              }
    106     }
    107 
    108     a[0].endtime=a[0].starttime+a[0].needtime;
    109 
    110     for(i=1;i<n;i++)
    111     {
    112         if(a[i].starttime<a[0].endtime) 
    113             b++;      //作业到达但第0个作业还在运行时
    114             //用b统计需等待作业0运行的作业个数
    115     }
    116    
    117       for(i=1;i<b+1;i++)
    118       {//已经到达的但要等待第0个作业运行完的作业按最短运行时间排序
    119           for(j=1;j<b+1-1;j++)
    120           {
    121           if(a[j].needtime>a[j+1].needtime) 
    122           { 
    123                    time1=a[j].starttime;
    124                 a[j].starttime=a[j+1].starttime;
    125                 a[j+1].starttime=time1;
    126                 time2=a[j].needtime;
    127                 a[j].needtime=a[j+1].needtime;
    128                 a[j+1].needtime=time2;
    129                 strcpy(temp,a[j].name);   
    130                 strcpy(a[j].name,a[j+1].name); 
    131                 strcpy(a[j+1].name,temp); 
    132           } 
    133           }
    134     }
    135     
    136     if(a[1].starttime>a[0].endtime) a[1].endtime=a[1].starttime+a[1].needtime;
    137     else a[1].endtime=a[0].endtime+a[1].needtime;
    138 
    139     for(i=2;i<n;i++)
    140     {
    141         if(a[i].starttime<a[1].endtime) 
    142           c++;      //作业到达但第1个作业还在运行时
    143             //用c统计需等待作业1运行的作业个数
    144     }
    145 
    146  for(i=2;i<c+2;i++)
    147     {//已经到达的但要等待第1个作业运行完的作业按最短运行时间排序
    148          for(j=2;j<c+2-1;j++)
    149           {
    150           if(a[j].needtime>a[j+1].needtime) 
    151           { 
    152                    time1=a[j].starttime;
    153                 a[j].starttime=a[j+1].starttime;
    154                 a[j+1].starttime=time1;
    155                 time2=a[j].needtime;
    156                 a[j].needtime=a[j+1].needtime;
    157                 a[j+1].needtime=time2;
    158                 strcpy(temp,a[j].name);   
    159                 strcpy(a[j].name,a[j+1].name); 
    160                 strcpy(a[j+1].name,temp); 
    161           } 
    162           }           
    163     }
    164 
    165     if(a[2].starttime>a[1].endtime) a[2].endtime=a[2].starttime+a[2].needtime;
    166     else a[2].endtime=a[1].endtime+a[2].needtime;
    167 
    168         for(i=3;i<n;i++)
    169     {
    170         if(a[i].starttime<a[2].endtime) 
    171          d++;      //作业到达但第2个作业还在运行时
    172             //用d统计需等待作业2运行的作业个数
    173     }
    174 
    175  for(i=3;i<d+3;i++)
    176     {//已经到达的但要等待第2个作业运行完的作业按最短运行时间排序
    177          for(j=3;j<d+3-1;j++)
    178           {
    179           if(a[j].needtime>a[j+1].needtime) 
    180           { 
    181                    time1=a[j].starttime;
    182                 a[j].starttime=a[j+1].starttime;
    183                 a[j+1].starttime=time1;
    184                 time2=a[j].needtime;
    185                 a[j].needtime=a[j+1].needtime;
    186                 a[j+1].needtime=time2;
    187                 strcpy(temp,a[j].name);   
    188                 strcpy(a[j].name,a[j+1].name); 
    189                 strcpy(a[j+1].name,temp); 
    190           } 
    191           }             
    192     }
    193 
    194     for(i=0;i<n;i++)
    195     {
    196       if(a[i].starttime>a[i-1].endtime)
    197       {                                      
    198         a[i].endtime=a[i].starttime+a[i].needtime; 
    199         a[i].runtime=a[i].needtime;
    200       }
    201       else
    202       {
    203          a[i].endtime=a[i-1].endtime+a[i].needtime;
    204          a[i].runtime=a[i].endtime-a[i].starttime; 
    205       }
    206       a[i].DQZZ_Time=a[i].runtime*1.0/a[i].needtime; 
    207     }
    208 }
    209 
    210 
    211 //最高响应比优先,只写了按到达时间的顺序前4个作业有效    
    212 void HRRF(int n)
    213 {
    214    int i,j,time1,time2;
    215    char temp[4]; 
    216 
    217 //先按到达时间排序
    218     for(i=0;i<n-1;i++)  
    219     {   
    220            for(j=0;j<n-i-1;j++)
    221              if(a[j].starttime>a[j+1].starttime)
    222              {
    223                 time1=a[j].starttime;
    224                 a[j].starttime=a[j+1].starttime;
    225                 a[j+1].starttime=time1;
    226                 time2=a[j].needtime;
    227                 a[j].needtime=a[j+1].needtime;
    228                 a[j+1].needtime=time2;
    229                 strcpy(temp,a[j].name);   
    230                 strcpy(a[j].name,a[j+1].name); 
    231                 strcpy(a[j+1].name,temp); 
    232              }
    233     }
    234 
    235     a[0].endtime=a[0].starttime+a[0].needtime;
    236 
    237     for(i=1;i<n;i++)
    238     {
    239      a[i].waittime=a[0].endtime-a[i].starttime;
    240      a[i].XYB=1+(a[i].waittime/a[i].needtime);
    241     }
    242     //运行完作业0后,剩下的作业按响应比高到低排序
    243     for(i=1;i<n-1;i++)
    244     {
    245         for(j=1;j<n-i-1;j++)
    246         {
    247         if(a[j].XYB<a[j+1].XYB)
    248         {
    249                 time1=a[j].starttime;
    250                 a[j].starttime=a[j+1].starttime;
    251                 a[j+1].starttime=time1;
    252                 time2=a[j].needtime;
    253                 a[j].needtime=a[j+1].needtime;
    254                 a[j+1].needtime=time2;
    255                 strcpy(temp,a[j].name);   
    256                 strcpy(a[j].name,a[j+1].name); 
    257                 strcpy(a[j+1].name,temp); 
    258         }
    259         }
    260     }
    261 
    262     a[1].endtime=a[0].endtime+a[1].needtime;
    263     for(i=2;i<n;i++)
    264     {
    265      a[i].waittime=a[1].endtime-a[i].starttime;
    266      a[i].XYB=1+(a[i].waittime/a[i].needtime);
    267     }
    268     //运行完作业1后,剩下的作业按响应比高到低排序
    269     for(i=2;i<n-1;i++)
    270     {
    271         for(j=2;j<n-i-1;j++)
    272         {
    273         if(a[j].XYB<a[j+1].XYB)
    274         {
    275                 time1=a[j].starttime;
    276                 a[j].starttime=a[j+1].starttime;
    277                 a[j+1].starttime=time1;
    278                 time2=a[j].needtime;
    279                 a[j].needtime=a[j+1].needtime;
    280                 a[j+1].needtime=time2;
    281                 strcpy(temp,a[j].name);   
    282                 strcpy(a[j].name,a[j+1].name); 
    283                 strcpy(a[j+1].name,temp); 
    284         }
    285         }
    286     }
    287 
    288     a[2].endtime=a[1].endtime+a[2].needtime;
    289     for(i=3;i<n;i++)
    290     {
    291      a[i].waittime=a[2].endtime-a[i].starttime;
    292      a[i].XYB=1+(a[i].waittime/a[i].needtime);
    293     }
    294     //运行完作业2后,剩下的作业按响应比高到低排序
    295     for(i=3;i<n-1;i++)
    296     {
    297         for(j=3;j<n-i-1;j++)
    298         {
    299         if(a[j].XYB<a[j+1].XYB)
    300         {
    301                 time1=a[j].starttime;
    302                 a[j].starttime=a[j+1].starttime;
    303                 a[j+1].starttime=time1;
    304                 time2=a[j].needtime;
    305                 a[j].needtime=a[j+1].needtime;
    306                 a[j+1].needtime=time2;
    307                 strcpy(temp,a[j].name);   
    308                 strcpy(a[j].name,a[j+1].name); 
    309                 strcpy(a[j+1].name,temp); 
    310         }
    311         }
    312     }
    313 
    314     a[3].endtime=a[2].endtime+a[3].needtime;
    315     for(i=4;i<n;i++)
    316     {
    317      a[i].waittime=a[3].endtime-a[i].starttime;
    318      a[i].XYB=1+(a[i].waittime/a[i].needtime);
    319     }
    320     //运行完作业3后,剩下的作业按响应比高到低排序
    321     for(i=4;i<n-1;i++)
    322     {
    323         for(j=4;j<n-i-1;j++)
    324         {
    325         if(a[j].XYB<a[j+1].XYB)
    326         {
    327                 time1=a[j].starttime;
    328                 a[j].starttime=a[j+1].starttime;
    329                 a[j+1].starttime=time1;
    330                 time2=a[j].needtime;
    331                 a[j].needtime=a[j+1].needtime;
    332                 a[j+1].needtime=time2;
    333                 strcpy(temp,a[j].name);   
    334                 strcpy(a[j].name,a[j+1].name); 
    335                 strcpy(a[j+1].name,temp); 
    336         }
    337         }
    338     }
    339 
    340     for(i=0;i<n;i++)
    341     {
    342       if(a[i].starttime>a[i-1].endtime)
    343       {                                      
    344         a[i].endtime=a[i].starttime+a[i].needtime; 
    345         a[i].runtime=a[i].needtime;
    346       }
    347       else
    348       {
    349          a[i].endtime=a[i-1].endtime+a[i].needtime;
    350          a[i].runtime=a[i].endtime-a[i].starttime; 
    351       }
    352       a[i].DQZZ_Time=a[i].runtime*1.0/a[i].needtime; 
    353     }
    354 }
    355 
    356 void output(int n)
    357 {    
    358     
    359    int sum_Time=0;//作业总周转时间
    360    double sum_DQ=0;//作业总带权周转时间
    361    int i;   
    362    printf("	name  starttime  needtime  runtime  endtime 	DQZZ_Time
    ");
    363     for(i=0;i<n;i++)
    364     {
    365     printf("%8s%10d%10d%10d%10d	%10lf
    ",a[i].name,a[i].starttime,a[i].needtime,a[i].runtime,a[i].endtime,a[i].DQZZ_Time);
    366     sum_Time+=a[i].runtime;  
    367     sum_DQ+=a[i].DQZZ_Time;
    368     } 
    369      printf("平均作业周转时间:%.2lf
    ",sum_Time*1.0/n);  
    370      printf("平均带权作业周转时间:%.2lf
    ",sum_DQ*1.0/n);  
    371      printf("
    ");
    372 }
    373 
    374 int main()
    375 {
    376     int n,i;
    377     printf("请输入进程数:");
    378     scanf("%d",&n);
    379     input(n);
    380     output(n);
    381     while(1)
    382     {
    383     printf("1.先来先服务FCFS
    2.最短作业优先SJF
    3.最高响应比优先
    4.退出
    ");
    384     scanf("%d",&i);
    385     if(i==1)
    386     {
    387     printf("				1.先来先服务FCFS
    ");
    388     FCFS(n);
    389     output(n);
    390     }
    391     if(i==2)
    392     {
    393     printf("				2.最短作业优先SJF
    ");
    394     SJF(n);
    395     output(n);
    396     }
    397     if(i==3)
    398     {
    399     printf("				3.最高响应比优先
    ");
    400     HRRF(n);
    401     output(n);
    402     }
    403     if(i==4)
    404     {
    405     exit(0);
    406     }
    407     }
    408 }

    3、运行结果

    四、实验总结

          本次实验主要考查作业调度中的先来先服务,最短作业优先及最高响应比优先的相关算法。在实验钟我大概知道怎样算算法,但却不知到怎样用代码实现。经过询问同学,大概知道了要怎样写,但代码扔有一些漏洞,也并没有完全实现功能。

  • 相关阅读:
    tp3.2和tp5的区别
    tp(调试模式,空操作,跨控制器调用,跨方法跳转--redirect(),框架语法,创建model模型)
    tp 连表查 分页 模糊查询
    thinkphp if和eq的区别
    js 面向对象例子
    JS字符串转换为JSON的四种方法笔记
    json在php中的使用之如何转换json为数组
    window.frames用法
    php js 数组排序
    控件常用
  • 原文地址:https://www.cnblogs.com/ZhiGe/p/5051225.html
Copyright © 2011-2022 走看看