操作系统作业调度--操作系统

一、目的和要求

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．（**）用曲线图或柱形图表示出以上数据，分析算法的优点和缺点。

二、实验内容

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct jcb{
    int id;
    char status;

    int arrtime;
    int reqtime;
    int startime;
    int finitime;

    float TAtime,TAWtime;
    float prio;
}   jobarr[24],jobfin[24],job[24];
int systime=0;
//主菜单
void menu()
{
    printf("__________***************_________
");
    printf("|     1.调用文本写入数据         |
");
    printf("|________________________________|
");
    printf("|     2.调用伪随机数的产生数据   |
");
    printf("|________________________________|
");
    printf("|     3.调用自己输入模拟数据     |
");
    printf("__________***************_________
");
}
//调度算法菜单
void menu0()
{
   printf("
________********_______
");
    printf("|      1.FCFS算法调度   |
");
    printf("|_______________________|
");
    printf("|      2.SJF算法调度    |
");
    printf("|_______________________|
");
    printf("|      3.HRRF算法调度   |
");
    printf("|_______________________|
");
    printf("|      0.退出算法调度   |
");
    printf("________********_______
");
}
//短作业优先排序
void sort(int n)
{
    int i,j; 
    struct jcb temp;
    for(i=2;i<n;i++) 
    for(j=i+1;j<=n;j++) 
    if(jobarr[i].reqtime>jobarr[j].reqtime) //根据最短的要求服务时间排序
    { 
       temp=jobarr[i]; 
       jobarr[i]=jobarr[j]; 
       jobarr[j]=temp; 
    } 
}
//先到先服务排序
void sort0(int n)
{
    int i,j; 
    struct jcb temp;
    for(i=2;i<n;i++) 
    for(j=i+1;j<=n;j++) 
    if(job[i].arrtime>job[j].arrtime) //根据到达时间排序
    { 
       temp=job[i]; 
       job[i]=job[j]; 
       job[j]=temp; 
    } 
}
//自己输入模拟数据
void shoushu()
{
        int n;
    printf("作业个数:");
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        printf("
第%d个作业:",i+1);
        printf("
输入id:");
        scanf("%d",&job[i].id);
        printf("到达时间:");
        scanf("%d",&job[i].arrtime);
        printf("要求服务时间:");
        scanf("%d",&job[i].reqtime);
        jobarr[i]=job[i];
    }
}
//文本写入数据
int ReadFile()
{
    int m=0;
    int i=1;
    FILE *fp;     //定义文件指针
    fp=fopen("4.txt","r");  //打开文件
    if(fp==NULL)
    {
        printf("File open error !
");
        exit(0);
    }
    printf("
 id    作业到达时间     作业运行所需要时间
");
    while(!feof(fp))
    {
        fscanf(fp,"%d%d%d",&job[i].id,&job[i].arrtime,&job[i].reqtime);  //fscanf()函数将数据读入
        printf("
%3d%12d%15d",job[i].id,job[i].arrtime,job[i].reqtime);  //输出到屏幕
        i++;
    };

    if(fclose(fp))     //关闭文件
    {
        printf("Can not close the file !
");
        exit(0);
    }
    m=i-1;
    return m;

}
//伪随机数的产生数据
int Pseudo_random_number()
{
    int i,n;
    srand((unsigned)time(0));  //参数seed是rand()的种子，用来初始化rand()的起始值。
    //输入作业数
    n=rand()%23+5;
    for(i=1; i<=n; i++)
    {
        job[i].id=i;
        //作业到达时间
        job[i].arrtime=rand()%29+1;
        //作业运行时间
        job[i].reqtime=rand()%7+1;
    }
    printf("
 id    作业到达时间     作业运行所需要时间
");
    for(i=1; i<=n; i++)
    {
        printf("
%3d%12d%15d",job[i].id,job[i].arrtime,job[i].reqtime);
    }
    return n;

}
//先来先服务算法FCFS
void FCFS()
{
    int i=1,j=1;
    float sumTA=0,sumTAW=0;
    printf("-----------先来先服务算法FCFS-------------
");
    printf("
 id    作业到达时间     作业运行所需要时间
");
    while(job[j].id!=NULL)
    {
        printf("
%3d%12d%15d",job[j].id,job[j].arrtime,job[j].reqtime);  //输出到屏幕
        j++;
    }
    sort0(j-1);
        printf("

 id    作业到达时间   作业完成时间   运行时间  作业周转时间  带权作业周转时间
");
        while(job[i].id!=NULL)
    {
        if(i==1)  //第一个作业先到达，先被调度
        {
            job[i].startime=job[i].arrtime;
        }
        else   //其他作业被调度
        {
            if(job[i-1].finitime>=job[i].arrtime)  //如果上一个作业的完成时间大于下一个到达时间，则下一个开始时间为上一个作业的完成时间
                job[i].startime=job[i-1].finitime;
            else
                job[i].startime=job[i].arrtime;   //否则下一个开始时间即它的到达时间
        }
        job[i].finitime=job[i].startime+job[i].reqtime; //计算完成时间
        job[i].TAtime=job[i].finitime-job[i].arrtime; //计算周转时间
        job[i].TAWtime=job[i].TAtime/job[i].reqtime;   //计算带权周转时间
        sumTA+=job[i].TAtime;
        sumTAW+=job[i].TAWtime;
        printf("
%3d%12d%13d%14d%12.0lf%14.2lf",job[i].id,job[i].arrtime,job[i].finitime,job[i].reqtime,job[i].TAtime,job[i].TAWtime); 
        i++;
    }
        printf("
平均作业周转时间= %.2lf",sumTA/(i-1));
        printf("
平均带权作业周转时间= %.2lf",sumTAW/(i-1));
}
//最短作业优先算法SJF
void SJF()
{
    int i=1,j=1;
    float sumTA=0,sumTAW=0;
    printf("-----------最短作业优先算法SJF-------------
");
    printf("
 id    作业到达时间     作业运行所需要时间
");
    while(job[j].id!=NULL)
    {
        printf("
%3d%12d%15d",job[j].id,job[j].arrtime,job[j].reqtime);  //输出到屏幕
        jobarr[j]=job[j];
        j++;
    }
    sort(j-1);
    printf("

 id    作业到达时间   作业完成时间   运行时间  作业周转时间  带权作业周转时间
");
    while(jobarr[i].id!=NULL)
    {
        if(i==1)
        {
            jobarr[i].startime=jobarr[i].arrtime;
        }
        else
        {
            if(jobarr[i-1].finitime>=jobarr[i].arrtime)
                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].TAWtime=jobarr[i].TAtime/jobarr[i].reqtime;
        sumTA+=jobarr[i].TAtime;
        sumTAW+=jobarr[i].TAWtime;
        printf("
%3d%12d%13d%14d%12.0lf%14.2lf",jobarr[i].id,jobarr[i].arrtime,jobarr[i].finitime,jobarr[i].reqtime,jobarr[i].TAtime,jobarr[i].TAWtime); 
        i++;
    }
        printf("
平均作业周转时间= %.2lf",sumTA/(i-1));
        printf("
平均带权作业周转时间= %.2lf",sumTAW/(i-1));
}
//最高响应比排序
void sort1(int n,int k)
{
    int i,j; 
    struct jcb temp;
    for(i=k;i<n;i++) 
    for(j=i+1;j<=n;j++) 
    if(jobfin[i].prio<jobfin[j].prio) 
    { 
       temp=jobfin[i]; 
       jobfin[i]=jobfin[j]; 
       jobfin[j]=temp; 
    } 
}
//响应比最高者优先HRRF算法
void HRRF()
{
    int i=1,j=1,k=1;
    float sumTA=0,sumTAW=0;
    printf("-----------响应比最高者优先HRRF算法-------------
");
    printf("
 id    作业到达时间     作业运行所需要时间
");
    while(job[j].id!=NULL)
    {
        printf("%3d%12d%15d
",job[j].id,job[j].arrtime,job[j].reqtime);  //输出到屏幕
        jobfin[j]=job[j];
        j++;
    }
    while(jobfin[k].id!=NULL)
    {
        i=k;  
        if(k==1)
        {
            jobfin[i].startime=jobfin[i].arrtime;
            jobfin[i].finitime=jobfin[i].startime+jobfin[i].reqtime;
            jobfin[i].TAtime=jobfin[i].finitime-jobfin[i].arrtime;
            jobfin[i].TAWtime=jobfin[i].TAtime/jobfin[i].reqtime;
        }
        else
        {
        printf("
id   最高响应比
");
        while(jobfin[i].id!=NULL)
        {
            if(jobfin[k-1].finitime>=job[i].arrtime)
            {
                jobfin[i].startime=jobfin[k-1].finitime;
                jobfin[i].prio=(jobfin[i].startime-jobfin[i].arrtime)/(jobfin[i].reqtime/1.0)+1;
            }
            else
            {
                jobfin[i].startime=0;    
                  jobfin[i].prio=0;
            }
            i++;
        }
        sort1(j-1,k);
        for(i=k;i<j;i++)
            printf("%3d%10.2lf
",jobfin[i].id,jobfin[i].prio);
        jobfin[k].finitime=jobfin[k-1].finitime+jobfin[k].reqtime;
        jobfin[k].TAtime=jobfin[k].finitime-jobfin[k].arrtime;
        jobfin[k].TAWtime=jobfin[k].TAtime/jobfin[k].reqtime;
        }
        k++;
    }
        printf("

 id    作业到达时间   作业完成时间   运行时间  作业周转时间  带权作业周转时间
");
        for(i=1;i<j;i++)
        {
            printf("
%3d%12d%13d%14d%12.0lf%14.2lf",jobfin[i].id,jobfin[i].arrtime,jobfin[i].finitime,jobfin[i].reqtime,jobfin[i].TAtime,jobfin[i].TAWtime); 
            sumTA+=jobfin[i].TAtime;
            sumTAW+=jobfin[i].TAWtime;
        }
        printf("
平均作业周转时间= %.2lf",sumTA/(i-1));
        printf("
平均带权作业周转时间= %.2lf",sumTAW/(i-1));
}
void main0()
{
    int tmp;
    while(1)
    {
    menu0();
    printf("
请选择菜单项:");
    scanf("%d",&tmp);
    switch (tmp)
    {
    case 1:
        FCFS();
        break;
    case 2:
        SJF();
        break;
    case 3:
        HRRF();
        break;
    case 0:
        return;
    }
    }
}
main()
{
    int tmp;
    while(1)
    {
    menu();
    printf("
请选择菜单项:");
    scanf("%d",&tmp);
    switch (tmp)
    {
    case 1:
        ReadFile();
        break;
    case 2:
        Pseudo_random_number();
        break;
    case 3:    
        shoushu();
        break;
    }
    main0();
    printf("
");
    }
}