【操作系统】 作业调度模拟程序 实验二

实验一、作业调度模拟程序实验

商业软件工程 201406114116 黄敏鹏

一、        实验目的

（1）加深对作业调度算法的理解；

（2）进行程序设计的训练。

二、        实验内容和要求

实验内容

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

实验要求

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

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

一、       模拟数据的生成

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	为了方便模拟调度过程，作业使用什么方式的数据结构存放和表示？	由作业说明书在系统中生成一个称为作业控制块(job control block，JCB)的表格。该表格登记该作业所要求的资源情况、预计执行时间和执行优先级等。从而，操作系统通过该表了解到作业要求，并分配资源和控制作业中程序和数据的编译、链接、装入和执行等。
4	操作系统中，常用的作业调度算法有哪些？	先来先服务算法、最短作业优先算法、最短剩余时间优先算法、最高响应比优先算法、轮转调度算法、多级反馈队列调度算法、优先级法调度算法
5	如何编程实现作业调度算法？
6	模拟程序的输入如何设计更方便、结果输出如何呈现更好？

 

五、       其他要求

1．            完成报告书，内容完整，规格规范。

2．            实验须检查，回答实验相关问题。

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

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

1.      原理分析及流程图

作业调度算法：

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

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

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

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

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

程序运行截图：

输入数据：

功能选择页面：

最高响应比排序：

先到先服务排序：

短作业优先排序：

源代码如下：

#include<windows.h>
#include<dos.h>
#include<time.h>
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include<string.h> 

struct jcb {
    char name[10];    /*作业号*/
    int arrtime;      /* 作业到达时间*/
    int reqtime;      /*作业要求服务时间*/
    int waiTime;      /*等待时间*/
    int startime;     /*开始运行时间*/
    int finitime;     /*结束运行时间*/
    int TAtime;       /*周转时间*/
    int TTAWtime;     /*带权周转时间*/
    int priority;     /*优先权*/
    int finish;       /*是否已经完成*/
}jobarr[24],jobfin[24],job[24];

int systime=0;    //系统时间
int intarr=0;     //记录jobarr[]的元素个数
int intfin;       //记录jobfin[]的元素个数
int intjob;       //记录job[]的元素个数

void intputjobarr();
void putoutAlljobarr();
void sort();
void simulateCohort();
int HRN(int pre);
void runing(int i, int times, int pre, int staTime, int endTime);
void print(int i,int times);
void check( );
void SortByreqtime(int,jcb*);
void SJF(int);
int FindTheShortarrtimejobarray(int, int);
int DeleteTheUsedJobById(jcb, int);
void SortByarrtime(int, jcb*);

/*
    主函数
*/
void main()
{
    system("mode con cols=100 lines=30");  //窗口宽度高度
    system("title -huangMP-116");           //设置窗口标题
    int n;
    int choose;
    printf("
	作业的个数 : ");
    scanf("%d",&n);
    while(intarr<n){
        intputjobarr();
    }    
    do{
        system("cls");
        printf("
	0.最高响应比    1.先到先服务    2.短作业优先    3.结束程序

	");
        printf("请选择服务:");
        scanf("%d",&choose);
        switch(choose){
        case 0:
            check();
            putoutAlljobarr();
            break;
        case 1:
            simulateCohort();
            putoutAlljobarr();
            break;
        case 2:
            SJF(intarr);
            putoutAlljobarr();
            break;
        case 3:
            exit(0);
            break;
        }
    }while(1);
}

/*--------------------------------------------------------------------------------------
    先到先服务 开始
    优先权 = 到达时间
*/
void sort(){
    jcb k;
    for(int i=0;i<intarr;i++){
        for(int j=0;j<intarr-1;j++){
            if(jobarr[j].arrtime>jobarr[j+1].arrtime){
                k=jobarr[j];
                jobarr[j]=jobarr[j+1];
                jobarr[j+1]=k;
            }
        }
    }
}
void simulateCohort(){
        jobarr[0].startime=jobarr[0].arrtime;
        jobarr[0].finitime=jobarr[0].startime+jobarr[0].reqtime;
        jobarr[0].TAtime=jobarr[0].finitime-jobarr[0].arrtime;
        jobarr[0].TTAWtime=float(jobarr[0].TAtime)/jobarr[0].reqtime;
    for(int i=1;i<intarr;i++){
        if(jobarr[i].arrtime<jobarr[i-1].finitime)
            jobarr[i].startime=jobarr[i-1].finitime;
        else
            jobarr[i].startime=jobarr[i].arrtime;
        jobarr[i].finitime=jobarr[i].startime+jobarr[i].reqtime;
        jobarr[i].TAtime=jobarr[i].finitime-jobarr[i].arrtime;
        jobarr[i].TTAWtime=float(jobarr[i].TAtime)/jobarr[i].reqtime;
    }
}
float sjp(int n){
    int i,first=0,count,flag[20],k,min;
    float time=0,weight_time=0;
    //调度第一个到达内存的进程
    for(i=1;i<n;i++)
    {
        if(jobarr[first].arrtime>jobarr[i].arrtime) 
            first=i;
        flag[i]=0;
    }
    flag[first]=1;
    time=(float)jobarr[first].reqtime;
    weight_time=1;
    printf("%s   %d    %d    %d
",jobarr[first].name,jobarr[first].arrtime,jobarr[first].reqtime,weight_time);
    //jobarr_temp[0]=jobarr[first];
    count=n-1;
    while(count)
    {
        k=0;
        min=32767; //设置一个较大的阈值，
        for(i=0;i<n;i++) //找到一个未被访问的，作业较短的且已经到达内存的作业调度 
            if((i!=first)&&(flag[i]==0)&&(time>=jobarr[i].arrtime)&&(min>jobarr[i].reqtime))
            {
                k=i;
                min=jobarr[i].reqtime;
                
            }
            flag[k]=1; //访问后置标记为访问
            time+=jobarr[k].reqtime;
            weight_time+=(time-jobarr[k].arrtime)/jobarr[k].reqtime;
            
            printf("%s   %d    %d    %d
",jobarr[k].name,jobarr[k].arrtime,jobarr[k].reqtime,(time-jobarr[k].arrtime)/jobarr[k].reqtime);
            count--; //每调度一个作业，count减1
    }
    return weight_time/=n;
}
/*
    先到先服务 结束
*/

/*--------------------------------------------------------------------------------------
    最高响应比  开始
    优先权 =(等待时间+服务时间)/服务时间
*/
int HRN(int pre) {
    int current=1,i,j;
    for(i=0; i<intarr; i++)  {
        jobarr[i].waiTime=jobarr[pre].finitime-jobarr[i].arrtime; /*等待时间 =上一个业的完成时间-到达时间*/
        jobarr[i].priority=(jobarr[i].waiTime+jobarr[i].reqtime)/jobarr[i].reqtime;
    }
    for(i=0; i<intarr; i++)
    {
        if(!jobarr[i].finish)
        {
            current=i;  /*找到第一个还没完成的作业*/
            break;
        }
    } 
    for( j=i; j<intarr; j++) /*和后面的作业比较*/
    {
        if( !jobarr[j].finish) /* 还没完成(运行)*/
        {
            if(jobarr[current].arrtime<=jobarr[pre].finitime)  /*如果作业在上一个作业完成之前到达*/
            {
                if(jobarr[j].arrtime<=jobarr[pre].finitime && jobarr[j].priority>jobarr[current].priority )
                    current=j;/* 找出到达时间在上一个作业完成之前，优先权高的作业*/
            }
            else /* 如果作业是在上一个作业完成之后到达*/
            {
                if(jobarr[j].arrtime<jobarr[current].arrtime)
                        current=j;  /* 找出比较早到达的一个*/
                if(jobarr[j].arrtime==jobarr[current].arrtime) /* 如果同时到达*/
                    if(jobarr[j].priority>jobarr[current].priority)
                        current=j; /*找出服务时间比较短的一个*/
            }
        }
    }
    return current;/*返回当前作业*/
}
void runing(int i, int times, int pre, int staTime, int endTime) {
    if(times==0)
    {
        jobarr[i].startime=jobarr[i].arrtime;
        jobarr[i].finitime=jobarr[i].startime+jobarr[i].reqtime;
        jobarr[i].TAtime=jobarr[i].reqtime;
        jobarr[i].TTAWtime=1.0;
        staTime=jobarr[i].startime;
    }else{
        if(jobarr[i].arrtime>jobarr[pre].finitime)
            jobarr[i].startime=jobarr[i].arrtime;
        else
            jobarr[i].startime=jobarr[pre].finitime;
        jobarr[i].finitime=jobarr[i].startime+jobarr[i].reqtime;
        jobarr[i].TAtime=jobarr[i].finitime-jobarr[i].arrtime;
        jobarr[i].TTAWtime=float(jobarr[i].TAtime)/jobarr[i].reqtime;
    }
    if(times==intarr-1)
        endTime=jobarr[i].finitime;
    jobarr[i].finish=1;
}
void check( ) {
    int i;
    int staTime, endTime;
    int current=0, times=0, pre=0;   jobarr[pre].finitime=0;
    jobarr[pre].finitime=0;
    for(i=0; i<intarr; i++)
    {
        jobarr[i].finish=0;
    } 
    for(times=0; times<intarr; times++)
    {
        current=HRN(pre);
        runing(current, times, pre, staTime, endTime);
        pre=current;
    }
}  
/*
    最高响应比优先  结束
  */

/*--------------------------------------------------------------------------------------
    短作业优先  开始
    优先权 = 最短服务时间
  */
void SJF(int n) {
    int i = 0;
    int arrfinish = 0;
    int finArrCount = 0;
    arrfinish = jobarr[i].arrtime + jobarr[i].reqtime;
    jobarr[i].finitime = arrfinish;
    jobarr[i].TAtime = arrfinish - jobarr[i].arrtime;
    jobarr[i].TTAWtime = jobarr[i].TAtime/jobarr[i].reqtime;
    n = DeleteTheUsedJobById(jobarr[i], n);
    while(n) {
        //得到jobfin数组元素个数
        finArrCount = FindTheShortarrtimejobarray(n, arrfinish);
        if(finArrCount == 0) {
            SortByarrtime(n, jobarr);
            if(arrfinish <= jobarr[i].arrtime)
                arrfinish = jobarr[i].arrtime + jobarr[i].reqtime;
            else
                arrfinish = arrfinish + jobarr[i].reqtime;
            jobarr[i].finitime = arrfinish;
            jobarr[i].TAtime = arrfinish - jobarr[i].arrtime;
            jobarr[i].TTAWtime = jobarr[i].TAtime/jobarr[i].reqtime;
            n = DeleteTheUsedJobById(jobarr[i], n);
            continue;
        }
        while(finArrCount) {
            arrfinish = arrfinish + jobfin[i].reqtime;
            jobfin[i].finitime = arrfinish;
            jobfin[i].TAtime = arrfinish - jobfin[i].arrtime;
            jobfin[i].TTAWtime = jobfin[i].TAtime/jobfin[i].reqtime;
            for(int j=0; j < n; j++) {
                if(strcmp(jobfin[i].name,jobarr[j].name) == 0) {
                    jobarr[j] = jobfin[i];
                }
            }
            n = DeleteTheUsedJobById(jobfin[i], n);
            i++;
            finArrCount--;
        }
        i=0;
    }
}
//组织服务时间最短的作业数组
int FindTheShortarrtimejobarray(int n, int arrfinish) {
    jcb temp;
    int finArrCount = 0;
    temp = jobarr[0];
    for(int i=0; i < n; i++) {
        if(jobarr[i].arrtime <= arrfinish) {
            jobfin[finArrCount] = jobarr[i];
            finArrCount++;
        }
    }
    SortByreqtime(finArrCount, jobfin);
    return finArrCount;
}
//通过服务时间排序
void SortByreqtime(int n, jcb temp1[24]) {
    int i, j;
    jcb temp;
    for (j = 0; j < n - 1; j++) {
        for (i = 0; i < n - 1 - j; i++)
        {
            if(temp1[i].reqtime > temp1[i + 1].reqtime)
            {
                temp = temp1[i];
                temp1[i] = temp1[i+1];
                temp1[i+1] = temp;
            }
        }
    }
}
//通过id删除
int DeleteTheUsedJobById(jcb idJob, int n) {
    jcb temp;
    for(int i=0; i < n; i++) {
        if(strcmp(idJob.name,jobarr[i].name) == 0)
            break;
    }
    for( ; i < n - 1; i++) {
        temp = jobarr[i];
        jobarr[i] = jobarr[i+1];
        jobarr[i+1] = temp;
    }
    return n-1; 
}
void SortByarrtime(int n, jcb temp[24]) {
    int i, j;
    jcb temp1;
    for (j = 0; j < n - 1; j++) {
        for (i = 0; i < n - 1 - j; i++)
        {
            if(temp[i].arrtime > temp[i + 1].arrtime)
            {
                temp1 = temp[i];
                temp[i] = temp[i+1];
                temp[i+1] = temp1;
            }
        }
    }
}
/*
    短作业优先  结束
  */

/*
    向jobarr输入一个作业
*/
void intputjobarr(){
    printf("
第 %d 个作业:
",intarr+1);
    printf("	输入作业名:");
    scanf("%s",&jobarr[intarr].name);
    printf("	到达时间:");
    scanf("%d",&jobarr[intarr].arrtime);
    printf("	要求服务时间:");
    scanf("%d",&jobarr[intarr].reqtime);
    intarr++;
}
/*
    输出所有作业信息    
*/
void putoutAlljobarr(){
    system("cls");    
    printf("
----------------------------------------------------------------------------

");
    printf("    作业名    到达时间    要求服务时间    调度时间    完成时间    周转时间    带权周转时间
");
    for(int i=0;i<intarr;i++){
        printf("    %6s    %8d    %12d    %8d    %8d    %8d    %8d
",jobarr[i].name,jobarr[i].arrtime,jobarr[i].reqtime,jobarr[i].startime,jobarr[i].finitime,jobarr[i].TAtime,jobarr[i].TTAWtime);
    }    
    int sumTAtime=0.0, sumTTAWtime=0.0, aveTAtime, aveTTAWtime;
    for(i=0; i<intarr; i++)
    {
        sumTAtime+=jobarr[i].TAtime;
        sumTTAWtime+=jobarr[i].TTAWtime;
    }
    aveTAtime=sumTAtime/intarr;  aveTTAWtime=sumTTAWtime/intarr;
    printf("
( 服务时间和 : 平均带权周转时间 : 平均带权周转时间 )    %5d%5d%5d
",sumTAtime,aveTAtime,aveTTAWtime);     
    printf("
----------------------------------------------------------------------------


");
    
    system("pause");
}