操作系统实验二 作业调度

一、实验目的

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

     （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
4	操作系统中，常用的作业调度算法有哪些？
5	如何编程实现作业调度算法？
6	模拟程序的输入如何设计更方便、结果输出如何呈现更好？

  2. 原理分析及流程图

         存储结构：结构体数组，文件读取；

         主要算法：先来先服务算法（FCFS）；

                       最短作业优先算法（SJF）；

                       最高响应比算法（HRRF）；

结构体：

struct jcb{
    char name[10];        //work name       
    int reachtime;       
    int starttime;
    int needtime;
    int finishtime;
    float cycletime;        //周转时间
    float weightedtime;        //带权周转时间
    float response;            //响应比
    char state;                //状态
    struct jcb *next;        //结构体指针
}*ready=NULL,*p,*q;
typedef struct jcb JCB;

主要函数：

void disp(JCB *q,int m){      //显示作业运行后的周转时间及带权周转时间等
    if(m==3){                    //显示高响应比算法调度作业后的运行情况 
        printf("
作业%s正在运行，其运行情况为：
",q->name);
        printf("开始运行时刻：%d
",q->starttime);
        printf("完成时刻：%d
",q->finishtime);
        printf("周转时间：%f
",q->cycletime);
        printf("带权周转时间：%f
",q->weightedtime);
        printf("响应比：%f
",q->response);
        getch();
    }
    else{                         //显示先来先服务，最短作业优先算法调度后作业的运行情况 
         printf("
作业%s正在运行，其运行情况为：
",q->name);
         printf("开始运行时刻：%d
",q->starttime);
        printf("完成时刻：%d
",q->finishtime);
        printf("周转时间：%f
",q->cycletime);
        printf("带权周转时间：%f
",q->weightedtime);
        getch();
    }
} 
void running(JCB *p,int m){                //运行作业 
    if(p==ready){                    //先将要运行的作业从队列中分离出来 
        ready=p->next;
        p->next=NULL;
    }
    else{
        q=ready;
        while(q->next!=p){
            q=q->next;
        }
        q->next=p->next;
    }
    p->starttime=time;
    p->state='R';
    p->finishtime=p->starttime+p->needtime;
    p->cycletime=(float)(p->finishtime-p->reachtime);
    p->weightedtime=(float)(p->cycletime/p->needtime);
    T1=T1+p->cycletime;
    T2=T2+p->weightedtime;
    disp(p,m);
    time=p->needtime+time;
    p->state='F';
    printf("
%s has been finished!
 press any key to continue...
",p->name);
    free(p);
    getch();
}

void response(){            //计算队列中作业的高响应比 
    JCB *padv;
    padv=ready;
    do{
        if(padv->state=='W'&&padv->reachtime<=time)
        padv->response=(float)(time-padv->reachtime+padv->needtime)/padv->needtime;
        padv=padv->next;
    }while(padv!=NULL);
}

void final(){                    //最后打印作业的平均周转时间，平均带权周转时间 
    float s,t;
    t=T1/n;
    s=T2/n;
    getch();
    printf("

作业已全部完成！");
    printf("
%d个作业的平均周转时间是：%f",n,t);
    printf("
%d个作业的平均带权周转时间是%f：


",n,s);
}
void hrrn(int m){               //高响应比算法 
    JCB *min;
    int i,iden;
    system("cls");
    input();
    for(i=0;i<n;i++){
        p=min=ready;
        iden=1;
        response();
        do{
            if(p->state=='W'&&p->reachtime<=time){
                if(iden){
                    min=p;
                    iden=0;
                }
                else if(p->response>min->response)
                {
                    min=p;
                } 
                p=p->next;
            }
        }while(p!=NULL);
            
        if(iden){
            i--;
            time++;
            if(time>1000){
                printf("
 runtime is too long .. error..");
                getch();
            }
        }
        else{
            running(min,m);
        }
    }
        final();
}
void sjf(int m){                //最短作业优先 
    JCB *min;
    int i,iden;
    system("cls");
    input();
    for(i=0;i<n;i++){
        p=min=ready;
        iden=1;
        response();
        do{
            if(p->state=='W'&&p->reachtime<=time)
                if(iden){
                    min=p;
                    iden=0;
                }
            else if(p->response>min->response){
                min=p;
            }
            p=p->next;
        }while(p!=NULL);
        if(iden){
            i--;
            time++;
            if(time>1000){
                printf("
 runtime is too long .. error..");
                getch();
            }
            else{
                running(min,m);
            }

        }
    }
    final();
} 
void fcfs(int m){            //先来先服务 
    int i,iden;
    system("cls");
    input();
    for(i=0;i<n;i++){
        p=ready;
        iden=1;
        do{
            if(p->state=='W'&&p->reachtime<=time) iden=0;
            if(iden) p=p->next;
        }while(p!=NULL&&iden);
        if(iden){
            i--;
            printf("
没有满足要求的进程，需等待");
            time++;
            if(time>100){
                printf("
时间过长");
                getch();
            } 
            else{
                running(p,m);
            }
        }
    }
    final();
}

测试结果：

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

感想：      这次的实验难度稍微比较大，只能一个算法算法做做，在整合，至能做个大概。

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