实验二 作业调度模拟程序

一，实验目的 

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

2，进行程序设计的训练。

 

二，实验内容和要求

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

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

作业调度算法：

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

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

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

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

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

 

三、主要程序及其解释

#include<stdio.h>
#include<string.h>
#include<conio.h>
#define N 100

struct ajob
{
    char name[10];

    float requesttime;
    float arrivetime;
    float starttime;
    float finishtime;
    float turnroundtime;
    float turnroundxs;

    float rp;
    char status;
};

typedef struct ajob JOB;

int input(JOB job[],int n);
void output(JOB job[],int n);
void select(JOB job[],int n);
void FCFS(JOB job[],int n);
void SJF(JOB job[],int n);
void HRRN(JOB job[],int n);

int main(void)
{
   JOB job [N];  
   int n;  
   
   n=input(job,n);
   output(job,n);
   
   select(job,n);
   output(job,n);

   getch();
   return 0;
}

int input(JOB job[],int n)
{
    int i;

    printf("n:");
    scanf("%d",&n);

    for(i=0;i<n;i++)
    {
        printf("\nname:",i+1);
        scanf("%s",job[i].name);

        printf("\narrivetime:",i+1);
        scanf("%f",&job[i].arrivetime);

        printf("\nrequesttime:",i+1);
        scanf("%f",&job[i].requesttime);

        job[i].status='n';
        job[i].starttime=0;
        job[i].finishtime=0;
    }
    printf("\n");
    return n;
}

void output(JOB job[],int n)
{
    int i;
    printf("\tname    arrivetime    requesttime    starttime    finishtime    turnroundtime    turnroundxs");
    for(i=0;i<n;i++)
    {
        printf("\nname%d",i+1);
        printf("\t %s",job[i].name);
        printf("\t %.2f",job[i].arrivetime);
        printf("\t %.2f",job[i].requesttime);
        printf("\t %.2f",job[i].starttime);
        printf("\t %.2f",job[i].finishtime);    
        printf("\t %.2f",job[i].turnroundtime);
        printf("\t %.2f",job[i].turnroundxs);    
    }
    printf("\n");
}

void select(JOB job[],int n)
{
    int k;

    printf("\n select:\n 1:先来先服务FCFS 2:短作业优先SJF 3:最高响应比优先HRRN\n");
    scanf("%d",&k);
    
    switch(k)          
    {
    //选择"1"的时候调用的是FCFS算法 
    case 1:FCFS(job,n);
        break;
        
    //选择"2"的时候调用的是SJF算法 
    case 2:SJF(job,n);
        break; 

    //选择"3"的时候调用的是HRN算法
    case 3:HRRN(job,n);
        break; 
    default:printf("\n wrong!");
    }
};
   
void move(JOB *pa,JOB *pb)
{
    strcpy(pa->name,pb->name);
    pa->arrivetime=pb->arrivetime;
    pa->requesttime=pb->requesttime;
    pa->starttime=pb->starttime;
    pa->finishtime=pb->finishtime;
    pa->turnroundtime=pb->turnroundtime;
    pa->turnroundxs=pb->turnroundxs;
}

void arrivetimesort(JOB job[],int n)
{
    int i,j;
    JOB jobtemp;
    for(j=1;j<n;j++)
        for(i=0;i<n-j;i++)
            if(job[i].arrivetime>job[i+1].arrivetime)
            {
                move(&jobtemp,&job[i]);
                move(&job[i],&job[i+1]);
                move(&job[i+1],&jobtemp);
            }
}

void FCFS(JOB job[],int n)
{
    int i;
    int now=0;
    arrivetimesort(job,n);
    for(i=0;i<n;i++)
    {
        if(job[i].arrivetime<=now)
            job[i].starttime=now;
        else
            job[i].starttime=job[i].arrivetime;
        now=job[i].starttime+job[i].requesttime;
        job[i].finishtime=now;
        job[i].turnroundtime=job[i].finishtime-job[i].arrivetime;
        job[i].turnroundxs=job[i].turnroundtime/job[i].requesttime;
    };
};

JOB *nextSJF(JOB job[],int n,int *now)
{
    JOB *p;
    int i;
    for(i=0;i<n;i++)
        if(job[i].status=='n')
        {
            p=&job[i];
            break;
        }
        if(job[i].arrivetime>*now)
            *now=job[i].arrivetime;
        for( ;i<n;i++)
        {
            if((job[i].arrivetime<=*now)&&(job[i].status=='n')&&(job[i].requesttime<p->requesttime))
                p=&job[i];
        }
        return p;
};

void SJF(JOB job[],int n)
{
    JOB *jobrun[N];
    int i,j;
    int now=0;

    arrivetimesort(job,n);
    for(i=0;i<n;i++)
    {
        jobrun[i]=nextSJF(job,n,&now);
        jobrun[i]->starttime=now;
        now+=jobrun[i]->requesttime;
        jobrun[i]->finishtime=now;
        jobrun[i]->turnroundtime=jobrun[i]->finishtime-jobrun[i]->arrivetime;
        jobrun[i]->turnroundxs=jobrun[i]->turnroundtime/jobrun[i]->requesttime;
        jobrun[i]->status='f';
    }
};

JOB *nextHRRN (JOB job[],int n,int *now)
{
    JOB *p;
    int i;
    float rp;
    for(i=0;i<n;i++)
        if(job[i].status=='n')
        {
            p=&job[i];
            break;
        }
        if(job[i].arrivetime>*now)
            *now=job[i].arrivetime;

        rp=1;
        while(job[i].arrivetime<=*now){
            job[i].rp=1+(*now-job[i].arrivetime)/job[i].requesttime;
            i++;
            if(job[i].rp>rp)
            {
                rp=job[i].rp;
                p=&job[i];
            }
        }
        return p;
};

void HRRN(JOB job[],int n)
{
    JOB *jobrun[N];
    int i;
    int now=0;
    arrivetimesort(job,n);
    for(i=0;i<n;i++)
    {
        jobrun[i]=nextHRRN(job,n,&now);
        jobrun[i]->starttime=now;
        now+=jobrun[i]->requesttime;
        jobrun[i]->finishtime=now;
        jobrun[i]->turnroundtime=jobrun[i]->finishtime-jobrun[i]->arrivetime;
        jobrun[i]->turnroundxs=jobrun[i]->turnroundtime/jobrun[i]->requesttime;
        jobrun[i]->status='f';
    }
};

运行结果

四，实验总结

纠结甚久，甚至不知道我需要做些什么，百度看书看代码，方法有很多不同的，但总有些代码自己不理解，不过百度里的代码倒是让我学会一种输入输出的方法，也不算无所得了。照着自己的理解，写出零零散散的代码，这里想用数组，那里用指针，很乱。

后来老师给我们讲解了一个代码，思路清晰了很多，按着老师的方法把自己写的零散的东西修改了过来，不过这个过程也找出了好一些问题，百度和询问学霸后终于成功运行。时间花的多，不过也值得。

这个代码给我印象最深的是运用了冒泡法排序，并不是因为它的难度，而是这是我们学过的知识，没有老师的提醒下，我却压根没想到，这是不懂的温故和运用，我认为这很值得自己反省。