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


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

    13物联网  201306104148 李小娜

    一、 实验目的

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

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

    二、 实验内容和要求

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

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

         作业调度算法:

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

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

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

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

         作业的状态可以是等待WWait)、运行RRun)和完成FFinish)三种之一。每个作业的最初状态都是等待W

    2.1 模拟数据的生成

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

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

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

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

    2.2 模拟程序的功能

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

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

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

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

    2.3 模拟数据结果分析

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

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

    2.4 其他要求

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

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

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

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

      1.流程图

         

     2.源程序

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #define MAX 100
    typedef struct 
    {
    char name[4];//进程名
    int  starttime;//到达系统时间
    int needtime;//运行时间
    int runtime;//周转时间
    int endtime;//完成时间
    int waittime;//等待时间
    double XYB;//响应比
    double DQZZ_Time;//带权周转时间
    }pr;
     
    pr a[MAX];
    
    void input(int n)
    {
        int i;
        for(i=0;i<n;i++)
        {
        printf("name:");
        scanf("%s",&a[i].name);
        printf("
    ");
    
        printf("starttime:");
        scanf("%d",&a[i].starttime);
        printf("
    ");
    
        printf("needtime:");
        scanf("%d",&a[i].needtime);
        printf("
    ");
        }
    }
    
    void FCFS(int n)//先来先服务
    {
        int i,j,time1,time2; 
        char temp[4];    
         for(i=0;i<n-1;i++) 
         {   
             for(j=0;j<n-i-1;j++)
                 if(a[j].starttime>a[j+1].starttime)
                 {
                    time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
                 }
         }
        for(i=0;i<n;i++) 
         {    
         //第一个进程       
             if(i==0)       
             {             
                 a[i].runtime=a[i].needtime;     
                 a[i].endtime=a[i].starttime+a[i].runtime;   
             }        
             else    
             {            
                 if(a[i].starttime>a[i-1].endtime)    
                 {               
                     a[i].runtime=a[i].needtime;   
                     a[i].endtime=a[i].starttime+a[i].runtime;     
                 }           
                 else           
                 {                
                     a[i].runtime=a[i].needtime+a[i-1].endtime-a[i].starttime;         
                     a[i].endtime=a[i].starttime+a[i].runtime;          
                 }        
             }   
             a[i].DQZZ_Time=a[i].runtime*1.0/a[i].needtime;  
         }
    }
    
    //最短作业优先,假设在前3个作业运行完之前所有作业均已到达
    void SJF(int n)
    {
    int i,j,time1,time2;
    int b=0,c=0,d=0; 
    char temp[4]; 
    
    //先按到达时间排序
        for(i=0;i<n-1;i++)  
        {   
               for(j=0;j<n-i-1;j++)
                 if(a[j].starttime>a[j+1].starttime)
                 {
                    time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
                 }
        }
    
        a[0].endtime=a[0].starttime+a[0].needtime;
    
        for(i=1;i<n;i++)
        {
            if(a[i].starttime<a[0].endtime) 
                b++;      //作业到达但第0个作业还在运行时
                //用b统计需等待作业0运行的作业个数
        }
       
          for(i=1;i<b+1;i++)
          {//已经到达的但要等待第0个作业运行完的作业按最短运行时间排序
              for(j=1;j<b+1-1;j++)
              {
              if(a[j].needtime>a[j+1].needtime) 
              { 
                       time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
              } 
              }
        }
        
        if(a[1].starttime>a[0].endtime) a[1].endtime=a[1].starttime+a[1].needtime;
        else a[1].endtime=a[0].endtime+a[1].needtime;
    
        for(i=2;i<n;i++)
        {
            if(a[i].starttime<a[1].endtime) 
              c++;      //作业到达但第1个作业还在运行时
                //用c统计需等待作业1运行的作业个数
        }
    
     for(i=2;i<c+2;i++)
        {//已经到达的但要等待第1个作业运行完的作业按最短运行时间排序
             for(j=2;j<c+2-1;j++)
              {
              if(a[j].needtime>a[j+1].needtime) 
              { 
                       time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
              } 
              }           
        }
    
        if(a[2].starttime>a[1].endtime) a[2].endtime=a[2].starttime+a[2].needtime;
        else a[2].endtime=a[1].endtime+a[2].needtime;
    
            for(i=3;i<n;i++)
        {
            if(a[i].starttime<a[2].endtime) 
             d++;      //作业到达但第2个作业还在运行时
                //用d统计需等待作业2运行的作业个数
        }
    
     for(i=3;i<d+3;i++)
        {//已经到达的但要等待第2个作业运行完的作业按最短运行时间排序
             for(j=3;j<d+3-1;j++)
              {
              if(a[j].needtime>a[j+1].needtime) 
              { 
                       time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
              } 
              }             
        }
    
        for(i=0;i<n;i++)
        {
          if(a[i].starttime>a[i-1].endtime)
          {                                      
            a[i].endtime=a[i].starttime+a[i].needtime; 
            a[i].runtime=a[i].needtime;
          }
          else
          {
             a[i].endtime=a[i-1].endtime+a[i].needtime;
             a[i].runtime=a[i].endtime-a[i].starttime; 
          }
          a[i].DQZZ_Time=a[i].runtime*1.0/a[i].needtime; 
        }
    }
    
    
    //最高响应比优先,只写了按到达时间的顺序前4个作业有效    
    void HRRF(int n)
    {
       int i,j,time1,time2;
       char temp[4]; 
    
    //先按到达时间排序
        for(i=0;i<n-1;i++)  
        {   
               for(j=0;j<n-i-1;j++)
                 if(a[j].starttime>a[j+1].starttime)
                 {
                    time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
                 }
        }
    
        a[0].endtime=a[0].starttime+a[0].needtime;
    
        for(i=1;i<n;i++)
        {
         a[i].waittime=a[0].endtime-a[i].starttime;
         a[i].XYB=1+(a[i].waittime/a[i].needtime);
        }
        //运行完作业0后,剩下的作业按响应比高到低排序
        for(i=1;i<n-1;i++)
        {
            for(j=1;j<n-i-1;j++)
            {
            if(a[j].XYB<a[j+1].XYB)
            {
                    time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
            }
            }
        }
    
        a[1].endtime=a[0].endtime+a[1].needtime;
        for(i=2;i<n;i++)
        {
         a[i].waittime=a[1].endtime-a[i].starttime;
         a[i].XYB=1+(a[i].waittime/a[i].needtime);
        }
        //运行完作业1后,剩下的作业按响应比高到低排序
        for(i=2;i<n-1;i++)
        {
            for(j=2;j<n-i-1;j++)
            {
            if(a[j].XYB<a[j+1].XYB)
            {
                    time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
            }
            }
        }
    
        a[2].endtime=a[1].endtime+a[2].needtime;
        for(i=3;i<n;i++)
        {
         a[i].waittime=a[2].endtime-a[i].starttime;
         a[i].XYB=1+(a[i].waittime/a[i].needtime);
        }
        //运行完作业2后,剩下的作业按响应比高到低排序
        for(i=3;i<n-1;i++)
        {
            for(j=3;j<n-i-1;j++)
            {
            if(a[j].XYB<a[j+1].XYB)
            {
                    time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
            }
            }
        }
    
        a[3].endtime=a[2].endtime+a[3].needtime;
        for(i=4;i<n;i++)
        {
         a[i].waittime=a[3].endtime-a[i].starttime;
         a[i].XYB=1+(a[i].waittime/a[i].needtime);
        }
        //运行完作业3后,剩下的作业按响应比高到低排序
        for(i=4;i<n-1;i++)
        {
            for(j=4;j<n-i-1;j++)
            {
            if(a[j].XYB<a[j+1].XYB)
            {
                    time1=a[j].starttime;
                    a[j].starttime=a[j+1].starttime;
                    a[j+1].starttime=time1;
                    time2=a[j].needtime;
                    a[j].needtime=a[j+1].needtime;
                    a[j+1].needtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
            }
            }
        }
    
        for(i=0;i<n;i++)
        {
          if(a[i].starttime>a[i-1].endtime)
          {                                      
            a[i].endtime=a[i].starttime+a[i].needtime; 
            a[i].runtime=a[i].needtime;
          }
          else
          {
             a[i].endtime=a[i-1].endtime+a[i].needtime;
             a[i].runtime=a[i].endtime-a[i].starttime; 
          }
          a[i].DQZZ_Time=a[i].runtime*1.0/a[i].needtime; 
        }
    }
    
    void output(int n)
    {    
        
       int sum_Time=0;//作业总周转时间
       double sum_DQ=0;//作业总带权周转时间
       int i;   
       printf("	name  starttime  needtime  runtime  endtime 	DQZZ_Time
    ");
        for(i=0;i<n;i++)
        {
        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);
        sum_Time+=a[i].runtime;  
        sum_DQ+=a[i].DQZZ_Time;
        } 
         printf("平均作业周转时间为:%.2lf
    ",sum_Time*1.0/n);  
         printf("平均带权作业周转时间为:%.2lf
    ",sum_DQ*1.0/n);  
         printf("
    ");
    }
    
    int main()
    {
        int n,i;
        printf("请输入进程数n:");
        scanf("%d",&n);
        input(n);
        output(n);
        while(1)
        {
        printf("1.先来先服务FCFS
    2.最短作业优先SJF
    3.最高响应比优先
    4.退出
    ");
        scanf("%d",&i);
        if(i==1)
        {
        printf("				1.先来先服务FCFS
    ");
        FCFS(n);
        output(n);
        }
        if(i==2)
        {
        printf("				2.最短作业优先SJF
    ");
        SJF(n);
        output(n);
        }
        if(i==3)
        {
        printf("				3.最高响应比优先
    ");
        HRRF(n);
        output(n);
        }
        if(i==4)
        {
        exit(0);
        }
        }
    }

        3.运行结果及分析

                                                         输入数据及显示

     

     

                        先来先服务FCFS

     

                      最短作业优先SJF

     

                    最高响应比优先HRRF

     

                        退出

     

    四、 实验总结

         这次实验考核了作业调度中的先来先服务,最短作业优先及最高响应比优先的相关算法,计算能力及综合性都较高,所以在做实验时遇到了很多坎。

    大多问题都是出现在知道如何算算法,但不知怎样用代码实现。网上找资料看别人如何实现的,可是发现看不懂别人代码的思想,最后在借鉴了网上代码的基础上,按着自己的想法重新编写,但所写的代码具有局限性,并没有完全实现功能。

  • 相关阅读:
    变量与基本数据类型的练习
    04-各数据类型的常用操作
    常用函数
    03-python流程控制
    02-Python输入输出及运算符
    02-补充:逻辑运算符
    线程
    tcp实现并发效果
    生产消费者作业
    作业4.22
  • 原文地址:https://www.cnblogs.com/dmbs/p/4957929.html
Copyright © 2020-2023  润新知