zoukankan      html  css  js  c++  java
  • 作业调度模拟程序

    一、目的和要求

    1. 实验目的

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

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

    2.实验要求

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

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

         作业调度算法:

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

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

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

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

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

    一、       模拟数据的生成

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

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

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

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

    二、       模拟程序的功能

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

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

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

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

    三、       模拟数据结果分析

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

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

    四、       实验准备

    序号

    准备内容

    完成情况

    1

    什么是作业?

    作业相当于一个程序。 任务相当于整个程序中的一段段可以并发执行的代码。 进程其实就是任务。从系统的角度看,作业则是一个比程序更广的概念。它由程序、数据和作业说明书组成。系统通过作业说明书控制文件形式的程序和数据,使之 执行和操作。而且,在批处理系统中,作业是抢占内存的基本单位。也就是说,批处理系统以作业为单位把程序和数据调入内存以便执行。

    2

    一个作业具备什么信息?

    作业由三部分组成,即程序、数据和作业说明书。一个作业可以包含多个程序和多个数据集,但必须至少包含一个程序。否则将不成为作业。

    3

    为了方便模拟调度过程,作业使用什么方式的数据结构存放和表示?JCB

    由作业说明书在系统中生成一个称为作业控制块(job control block,JCB)的表格。该表格登记该作业所要求的资源情况、预计执行时间和执行优先级等。从而,操作系统通过该表了解到作业要求,并分配资源和控制作业中程序和数据的编译、链接、装入和执行等。

    4

    操作系统中,常用的作业调度算法有哪些?

    先来先服务、轮转法、多级反馈队列列算法、优先级法、短作业优先法、最高响应

    5

    如何编程实现作业调度算法?

    6

    模拟程序的输入如何设计更方便、结果输出如何呈现更好?

           

     

    五、       其他要求

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

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

    二、实验内容

    根据指定的实验课题,完成设计、编码和调试工作,完成实验报告。

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #define MAX 100
    typedef struct 
    {
    char name[10];//进程名
    int  arrtime;//到达系统时间
    int reqtime;//运行时间
    int TAtime;//周转时间
    int finitime;//完成时间
    int waittime;//等待时间
    double XYB;//响应比
    double TAWtime;//带权周转时间
    }pr;
     
    pr a[MAX];
    void input(int n)
    {
        /*int m,i;
        printf("输入作业个数:",m);
        scanf("%d",&m);*/
    	int i;
        for(i=0;i<n;i++)
        {
        printf("第%d个作业
    ",i+1);
        printf("输入作业名:");
        scanf("%s",&a[i].name);
        printf("
    ");
    
        printf("到达时间:");
        scanf("%d",&a[i].arrtime);
        printf("
    ");
    
        printf("要求服务时间:");
        scanf("%d",&a[i].reqtime);
        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].arrtime>a[j+1].arrtime)
                 {
                    time1=a[j].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=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].TAtime=a[i].reqtime;     
                 a[i].finitime=a[i].arrtime+a[i].TAtime;   
             }        
             else    
             {            
                 if(a[i].arrtime>a[i-1].finitime)    
                 {               
                     a[i].TAtime=a[i].reqtime;   
                     a[i].finitime=a[i].arrtime+a[i].TAtime;     
                 }           
                 else           
                 {                
                     a[i].TAtime=a[i].reqtime+a[i-1].finitime-a[i].arrtime;         
                     a[i].finitime=a[i].arrtime+a[i].TAtime;          
                 }        
             }   
             a[i].TAWtime=a[i].TAtime*1.0/a[i].reqtime;  
         }
    }
    
    //最短作业优先,假设在前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].arrtime>a[j+1].arrtime)
                 {
                    time1=a[j].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
                 }
        }
    
        a[0].finitime=a[0].arrtime+a[0].reqtime;
    
        for(i=1;i<n;i++)
        {
            if(a[i].arrtime<a[0].finitime) 
                b++;      //作业到达但第0个作业还在运行时
                //用b统计需等待作业0运行的作业个数
        }
       
          for(i=1;i<b+1;i++)
          {//已经到达的但要等待第0个作业运行完的作业按最短运行时间排序
              for(j=1;j<b+1-1;j++)
              {
              if(a[j].reqtime>a[j+1].reqtime) 
              { 
                       time1=a[j].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
              } 
              }
        }
        
        if(a[1].arrtime>a[0].finitime) a[1].finitime=a[1].arrtime+a[1].reqtime;
        else a[1].finitime=a[0].finitime+a[1].reqtime;
    
        for(i=2;i<n;i++)
        {
            if(a[i].arrtime<a[1].finitime) 
              c++;      //作业到达但第1个作业还在运行时
                //用c统计需等待作业1运行的作业个数
        }
    
     for(i=2;i<c+2;i++)
        {//已经到达的但要等待第1个作业运行完的作业按最短运行时间排序
             for(j=2;j<c+2-1;j++)
              {
              if(a[j].reqtime>a[j+1].reqtime) 
              { 
                       time1=a[j].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
              } 
              }           
        }
    
        if(a[2].arrtime>a[1].finitime) a[2].finitime=a[2].arrtime+a[2].reqtime;
        else a[2].finitime=a[1].finitime+a[2].reqtime;
    
            for(i=3;i<n;i++)
        {
            if(a[i].arrtime<a[2].finitime) 
             d++;      //作业到达但第2个作业还在运行时
                //用d统计需等待作业2运行的作业个数
        }
    
     for(i=3;i<d+3;i++)
        {//已经到达的但要等待第2个作业运行完的作业按最短运行时间排序
             for(j=3;j<d+3-1;j++)
              {
              if(a[j].reqtime>a[j+1].reqtime) 
              { 
                       time1=a[j].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=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].arrtime>a[i-1].finitime)
          {                                      
            a[i].finitime=a[i].arrtime+a[i].reqtime; 
            a[i].TAtime=a[i].reqtime;
          }
          else
          {
             a[i].finitime=a[i-1].finitime+a[i].reqtime;
             a[i].TAtime=a[i].finitime-a[i].arrtime; 
          }
          a[i].TAWtime=a[i].TAtime*1.0/a[i].reqtime; 
        }
    }
    
    
    //最高响应比优先,只写了按到达时间的顺序前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].arrtime>a[j+1].arrtime)
                 {
                    time1=a[j].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
                 }
        }
    
        a[0].finitime=a[0].arrtime+a[0].reqtime;
    
        for(i=1;i<n;i++)
        {
         a[i].waittime=a[0].finitime-a[i].arrtime;
         a[i].XYB=1+(a[i].waittime/a[i].reqtime);
        }
        //运行完作业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].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
            }
            }
        }
    
        a[1].finitime=a[0].finitime+a[1].reqtime;
        for(i=2;i<n;i++)
        {
         a[i].waittime=a[1].finitime-a[i].arrtime;
         a[i].XYB=1+(a[i].waittime/a[i].reqtime);
        }
        //运行完作业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].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
            }
            }
        }
    
        a[2].finitime=a[1].finitime+a[2].reqtime;
        for(i=3;i<n;i++)
        {
         a[i].waittime=a[2].finitime-a[i].arrtime;
         a[i].XYB=1+(a[i].waittime/a[i].reqtime);
        }
        //运行完作业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].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=time2;
                    strcpy(temp,a[j].name);   
                    strcpy(a[j].name,a[j+1].name); 
                    strcpy(a[j+1].name,temp); 
            }
            }
        }
    
        a[3].finitime=a[2].finitime+a[3].reqtime;
        for(i=4;i<n;i++)
        {
         a[i].waittime=a[3].finitime-a[i].arrtime;
         a[i].XYB=1+(a[i].waittime/a[i].reqtime);
        }
        //运行完作业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].arrtime;
                    a[j].arrtime=a[j+1].arrtime;
                    a[j+1].arrtime=time1;
                    time2=a[j].reqtime;
                    a[j].reqtime=a[j+1].reqtime;
                    a[j+1].reqtime=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].arrtime>a[i-1].finitime)
          {                                      
            a[i].finitime=a[i].arrtime+a[i].reqtime; 
            a[i].TAtime=a[i].reqtime;
          }
          else
          {
             a[i].finitime=a[i-1].finitime+a[i].reqtime;
             a[i].TAtime=a[i].finitime-a[i].arrtime; 
          }
          a[i].TAWtime=a[i].TAtime*1.0/a[i].reqtime; 
        }
    }
    
    void output(int n)
    {    
        
       int sum_Time=0;//作业总周转时间
       double sum_DQ=0;//作业总带权周转时间
       int i;   
       printf("	name  arrtime  reqtime  TAtime  finitime 	TAWtime
    ");
        for(i=0;i<n;i++)
        {
        printf("%8s%10d%10d%10d%10d	%10lf
    ",a[i].name,a[i].arrtime,a[i].reqtime,a[i].TAtime,a[i].finitime,a[i].TAWtime);
        sum_Time+=a[i].TAtime;  
        sum_DQ+=a[i].TAWtime;
        } 
         printf("平均作业周转时间为:%.2lf
    ",sum_Time*1.0/n);  
         printf("平均带权作业周转时间为:%.2lf
    ",sum_DQ*1.0/n);  
         printf("
    ");
    }
    
    int main()
    {   /*int d,i,n;
    	printf("***************************
    ");
        printf("1、调用文本写入数据
    ");
        printf("2、调用伪随机数得产生数据
    ");
        printf("3、调用自己输入模拟数据
    ");
        printf("***************************
    ");
        scanf("%d",&d);
        if(d==3)
    */ 
    	int n,i;
        printf("输入作业个数:",n);
        scanf("%d",&n);
        input(n);
        output(n);
    
    	while(1)
        {
    		printf("**************************
     ");
    		printf("1、FCFS算法调度
    ");
    		printf(" 2、SJF算法调度
    ");
    		printf(" 3、HRRF算法调度
    ");
    		printf(" 4、退出算法调度
    ");
    		printf("***************************
     ");
    		printf("请选择菜单项: ");
    		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)
        {
    	printf("谢谢使用
    ");
        exit(0);
        }
        }
    }
    

      

    程序截图:

  • 相关阅读:
    把git项目放到个人服务器上
    关于fcitx无法切换输入法的问题解决
    博客变迁通知
    (欧拉回路 并查集 别犯傻逼的错了) 7:欧拉回路 OpenJudge 数据结构与算法MOOC / 第七章 图 练习题(Excercise for chapter7 graphs)
    (并查集) HDU 1856 More is better
    (并查集 不太会) HDU 1272 小希的迷宫
    (并查集 注意别再犯傻逼的错了) HDU 1213 How Many Tables
    (最小生成树 Kruskal算法) 51nod 1212 无向图最小生成树
    (并查集) HDU 1232 畅通工程
    (最小生成树 Prim) HDU 1233 还是畅通工程
  • 原文地址:https://www.cnblogs.com/qing8/p/5395775.html
Copyright © 2011-2022 走看看