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

实验二作业调度模拟程序

一、目的和要求

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	一个作业具备什么信息？	作业调度要考虑2个因素：1、接纳多少个作业。这个取决于多道程序度（Degree of Multiprogamming），即同时允许多少个作业在内存中运行。太多影响系统性能，太低降低了系统的资源利用率和吞吐率。2、接纳哪些作业。这个取决于调度算法，调度的算法很多，常见的就FCFS（先来先服务）、短作业优先调度算法、高优先权调度算法和基于时间片轮转的算法。
3	为了方便模拟调度过程，作业使用什么方式的数据结构存放和表示？JCB	先来先服务，
4	操作系统中，常用的作业调度算法有哪些？	先来先服务(FCFS, First Come First Serve)是最简单的调度算法，按先后顺序进行调度。轮转法(Round Robin)是让每个进程在就绪队列中的等待时间与享受服务的时间成正比例。多级反馈队列算法(Round Robin with Multiple Feedback)是轮转算法和优先级算法的综合和发展。
5	如何编程实现作业调度算法？	1 、在单位时间内运行尽可能多的作业。 2 、使处理机保持忙碌的状态。 3 、使 I / O 设备得以充分利用。 4 、对所有作业公平合理。
6	模拟程序的输入如何设计更方便、结果输出如何呈现更好？	用数组存储

二、 其他要求

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("
--------------------------
");
 
 
 }
 printf(" 
                      先来先服务算法                 
");
 print(a,n); 
 }  

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

void main() {  
    int j;  
     int choice;        
      printf("         



                =============================================    
");
printf("                                    作业调度模拟                    
");
 printf("                =============================================    ");

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

 printf("                =============================================    
");
scanf("%d",&j);
getchar();
printf("


                1.读入D盘中READFILE.txt的数据?（是请按1）
");
printf("                       2.读入随机数据数据?（是请按2）
");
printf("                         3.手动输入数据?（是请按3）
");
       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 !
");
        exit(0);
    }
    printf("
 id    作业到达时间     作业运行所需要时间
");
    while(!feof(fp))
    {
        fscanf(fp,"%d%d%d",&a[i].id,&a[i].arrivetime,&a[i].needtime);  //fscanf()函数将数据读入
        printf("
%3d%12d%15d",a[i].id,a[i].arrivetime,a[i].needtime);  //输出到屏幕
        i++;
    };

    if(fclose(fp))     //关闭文件
    {
        printf("Can not close the file !
");
        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("
 id    作业到达时间     作业运行所需要时间
");
    for(i=0; i<=n; i++)
    {
        printf("
%3d%12d%15d",a[i].id,a[i].arrivetime,a[i].needtime);
    }}


else{printf("请输入进程数量
");
  scanf("%d",&n); 
  getchar();
  for(int i=0;i<n;i++)
  {   printf("
--------------------------
");
  printf("输入第%d 个进程:",i+1);
  printf("
--------------------------
");
  printf("输入到达时间
");
  scanf("%d",&a[i].arrivetime);
  printf("输入服务时间:
");
    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("
         按最短作业优先算法完成进程调度.
");
print(a,n); 

}