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

一、目的和要求

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("__________***************_________\n");
printf("|     1.调用文本写入数据         |\n");
printf("|________________________________|\n");
printf("|     2.调用伪随机数的产生数据   |\n");
printf("|________________________________|\n");
printf("|     3.调用自己输入模拟数据     |\n");
printf("__________***************_________\n");
}
//调度算法菜单
void menu0()
{
printf("\n________********_______\n");
printf("|      1.FCFS算法调度   |\n");
printf("|_______________________|\n");
printf("|      2.SJF算法调度    |\n");
printf("|_______________________|\n");
printf("|      3.HRRF算法调度   |\n");
printf("|_______________________|\n");
printf("|      0.退出算法调度   |\n");
printf("________********_______\n");
}
//短作业优先排序
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("\n第%d个作业:",i+1);
printf("\n输入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 !\n");
exit(0);
}
printf("\n id    作业到达时间     作业运行所需要时间\n");
while(!feof(fp))
{
fscanf(fp,"%d%d%d",&job[i].id,&job[i].arrtime,&job[i].reqtime);  //fscanf()函数将数据读入
printf("\n%3d%12d%15d",job[i].id,job[i].arrtime,job[i].reqtime);  //输出到屏幕
i++;
};

if(fclose(fp))     //关闭文件
{
printf("Can not close the file !\n");
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("\n id    作业到达时间     作业运行所需要时间\n");
for(i=1; i<=n; i++)
{
printf("\n%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-------------\n");
printf("\n id    作业到达时间     作业运行所需要时间\n");
while(job[j].id!=NULL)
{
printf("\n%3d%12d%15d",job[j].id,job[j].arrtime,job[j].reqtime);  //输出到屏幕
j++;
}
sort0(j-1);
printf("\n\n id    作业到达时间   作业完成时间   运行时间  作业周转时间  带权作业周转时间\n");
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("\n%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("\n平均作业周转时间= %.2lf",sumTA/(i-1));
printf("\n平均带权作业周转时间= %.2lf",sumTAW/(i-1));
}
//最短作业优先算法SJF
void SJF()
{
int i=1,j=1;
float sumTA=0,sumTAW=0;
printf("-----------最短作业优先算法SJF-------------\n");
printf("\n id    作业到达时间     作业运行所需要时间\n");
while(job[j].id!=NULL)
{
printf("\n%3d%12d%15d",job[j].id,job[j].arrtime,job[j].reqtime);  //输出到屏幕
jobarr[j]=job[j];
j++;
}
sort(j-1);
printf("\n\n id    作业到达时间   作业完成时间   运行时间  作业周转时间  带权作业周转时间\n");
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("\n%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("\n平均作业周转时间= %.2lf",sumTA/(i-1));
printf("\n平均带权作业周转时间= %.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算法-------------\n");
printf("\n id    作业到达时间     作业运行所需要时间\n");
while(job[j].id!=NULL)
{
printf("%3d%12d%15d\n",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("\nid   最高响应比\n");
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\n",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("\n\n id    作业到达时间   作业完成时间   运行时间  作业周转时间  带权作业周转时间\n");
for(i=1;i<j;i++)
{
printf("\n%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("\n平均作业周转时间= %.2lf",sumTA/(i-1));
printf("\n平均带权作业周转时间= %.2lf",sumTAW/(i-1));
}
void main0()
{
int tmp;
while(1)
{
menu0();
printf("\n请选择菜单项:");
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("\n请选择菜单项:");
scanf("%d",&tmp);
switch (tmp)
{
case 1:
ReadFile();
break;
case 2:
Pseudo_random_number();
break;
case 3:
shoushu();
break;
}
main0();
printf("\n");
}
}

View Code