操作系统作业调度模拟程序

实验二作业调度模拟程序

一、目的和要求

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

一、       实验准备

二、       其他要求

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

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

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

二、实验内容

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

三、实验环境

可以采用TC，也可以选用Windows下的利用各种控件较为方便的VB，VC等可视化环境。也可以自主选择其他实验环境。

四、实验原理及核心算法参考程序段

#include<stdio.h>
#include<stdlib.h>
#include <IOSTREAM>
#include<conio.h>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include <numeric>
#include <cstdlib>
#include <numeric>
#include<time.h>
#define MAX 100
 typedef struct process_jcb{
     char name;
    int arrivetime;
    int waittime;
int finishtime;
int needtime;
int roundtime;
     float Talltime;
    int starttime;
    int id;
     struct process_jcb *link;
 }JCB;
JCB *p,*q,*head=NULL;
int n;//录入作业个数
 struct process_jcb a[100];
 JCB inital(struct process_jcb a[],int n);
 void print(struct process_jcb a[],int n);
 void Fcfs(struct process_jcb a[],int n);
void SJFS(struct process_jcb a[],int n);

void ReadFile();

 struct process_jcb *sortarrivetime(struct process_jcb a[],int n);
  struct  process_jcb *sortservetime(struct process_jcb a[],int n);
 //按服务时间进行冒泡排序
 struct process_jcb *sortservetime(struct process_jcb a[],int n)
{
  int i,j;
  struct process_jcb t;
  int flag;
  for(i=1;i<n;i++)
  {
    flag=0;
    for(j=1;j<n-i;j++)
    {
      if(a[j].needtime>a[j+1].needtime)    //将到达时间短的交换到前边
      {
        t=a[j];
        a[j]=a[j+1];
        a[j+1]=t;
        flag=1;//交换
      }
    }
    if(flag==0)//如果一趟排序中没发生任何交换，则排序结束
    {
      break;
    }
  }
  return a;    //返回排序后进程数组
}

 struct process_jcb *sortarrivetime(struct process_jcb a[],int n)//对到达时间进行排序
 {  int i,j;
 struct process_jcb t;
 int flag;
 for(i=1;i<n;i++)
 {  flag=0;
 for(j=0;j<n-i;j++)
 {    if(a[j].arrivetime>a[j+1].arrivetime) 

  {   t=a[j];
 a[j]=a[j+1];
 a[j+1]=t;
 flag=1;
 }
 }    if(flag==0)     break;
 }   return a;
 }  

 void Fcfs(struct process_jcb a[],int n)
 {  int i; 

 a[0].finishtime=a[0].arrivetime+a[0].needtime;
 a[0].roundtime=a[0].finishtime-a[0].arrivetime;
 a[0].Talltime=a[0].roundtime/a[0].needtime;
 for(i=1;i<n;i++)
 {   if(a[i].arrivetime<a[i-1].finishtime)
 {     a[i].finishtime=a[i-1].finishtime+a[i].needtime;
 a[i].roundtime=a[i].finishtime-a[i].arrivetime;
 a[i].Talltime=a[i].roundtime/a[i].needtime;
 }
 else   {       a[i].finishtime=a[i].arrivetime+a[i].needtime;
 a[i].roundtime=a[i].finishtime+a[i].arrivetime;
 a[i].Talltime=a[i].roundtime/a[i].needtime; 

   }
 printf("\n--------------------------\n");

 }
 printf(" \n                      先来先服务算法                 \n");
 print(a,n);
 }  

 void print(struct process_jcb a[],int n)
 {  int i;
 printf("\n--------------------------\n");
 printf("       到达时间：| 服务时间：| 完成时间：| 周转时间：|带权周转时间\n ");
 for(i=0;i<n;i++)
 {   printf("\n--------------------------\n");
 printf("作业%d:",i+1);
 printf("       %.2d       % .2d        % .2d          % .2d          % .2f\n",a[i].arrivetime,a[i].needtime,a[i].finishtime,a[i].roundtime,a[i].Talltime);
 }
 printf("\n");
 } 

void main() {
    int j;
     int choice;
      printf("         \n\n\n\n                =============================================    \n");
printf("                                    作业调度模拟                    \n");
 printf("                =============================================    ");

printf("\n                                  1.先到先服务算法\n");
printf("                                  2.最短作业优先算法\n");

 printf("                =============================================    \n");
scanf("%d",&j);
getchar();
printf("\n\n\n                1.读入D盘中READFILE.txt的数据?（是请按1）\n");
printf("                       2.读入随机数据数据?（是请按2）\n");
printf("                         3.手动输入数据?（是请按3）\n");
       scanf("%d",&choice);
       getchar();
if(choice==1){//文件读取的方式
    int i=0;
    FILE *fp;     //定义文件指针
   fp=fopen("D:\\readfile.txt","r"); //打开文件
    if(fp==NULL)
    {
        printf("File open error !\n");
        exit(0);
    }
    printf("\n id    作业到达时间     作业运行所需要时间\n");
    while(!feof(fp))
    {
        fscanf(fp,"%d%d%d",&a[i].id,&a[i].arrivetime,&a[i].needtime);  //fscanf()函数将数据读入
        printf("\n%3d%12d%15d",a[i].id,a[i].arrivetime,a[i].needtime);  //输出到屏幕
        i++;
    };

    if(fclose(fp))     //关闭文件
    {
        printf("Can not close the file !\n");
        exit(0);
    }
   n=i;
}
else if(choice==2)//伪随机数的方式
{
int i;
    srand((unsigned)time(0));  //参数seed是rand()的种子，用来初始化rand()的起始值。
    //输入作业数
    n=rand()%23+1;
    printf("%d",n);

    for(i=0; i<=n; i++)
    {
        a[i].id=i;
        //作业到达时间
        a[i].arrivetime=rand()%29+1;
        //作业运行时间
       a[i].needtime=rand()%7+1;
    }
    printf("\n id    作业到达时间     作业运行所需要时间\n");
    for(i=0; i<=n; i++)
    {
        printf("\n%3d%12d%15d",a[i].id,a[i].arrivetime,a[i].needtime);
    }}

else{printf("请输入进程数量\n");
  scanf("%d",&n);
  getchar();
  for(int i=0;i<n;i++)
  {   printf("\n--------------------------\n");
  printf("输入第%d 个进程:",i+1);
  printf("\n--------------------------\n");
  printf("输入到达时间\n");
  scanf("%d",&a[i].arrivetime);
  printf("输入服务时间:\n");
    scanf("%d",&a[i].needtime);
  getchar();

 }
}

switch(j)

{case 1: //system("CLS");
sortarrivetime(a,n);Fcfs(a,n);break;
case 2://system("CLS");
 sortservetime( a, n);    SJFS(a,n);break;

}
}

void SJFS(struct process_jcb a[],int n)//最短作业优先
{

 int i;

  a[0].finishtime=a[0].arrivetime+a[0].needtime;    //完成时间=到达时间-服务时间
  a[0].roundtime=a[0].finishtime-a[0].arrivetime;    //周转时间=完成时间-提交时间
  a[0].Talltime=a[0].roundtime/a[0].needtime;    //带权时间=周转时间/服务时间

  for(i=1;i<n;i++)
  {
    if(a[i].arrivetime<a[i-1].finishtime)    //当前到达时间在上一个作业结束时间之前
    {
      a[i].finishtime=a[i-1].finishtime+a[i].needtime;    //完成时间=上一个完成时间+服务时间
      a[i].roundtime=a[i].finishtime-a[i].arrivetime;        //周转时间=完成时间-到达时间
      a[i].Talltime=a[i].roundtime/a[i].needtime;        //带权时间=周转时间/服务时间
    }
    else    //当前到达时间在上一个作业结束时间之后
    {
      a[i].finishtime=a[i].arrivetime+a[i].needtime;
      a[i].roundtime=a[i].finishtime-a[i].arrivetime;
     (float) a[i].Talltime=(float)a[i].roundtime/(float)a[i].needtime;
    }

  }

    printf("\n         按最短作业优先算法完成进程调度.\n");
print(a,n); 

}