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

实验二做业调度模拟程序

1、目的和要求

1. 实验目的

（1）加深对做业调度算法的理解；

（2）进行程序设计的训练。

2．实验要求

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

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

     做业调度算法：

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

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

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

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

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

 

1、       模拟数据的生成

1．            容许用户指定做业的个数（2-24），默认值为5。

2．            容许用户选择输入每一个做业的到达时间和所需运行时间。

3．            （**）从文件中读入以上数据。

4．            （**）也容许用户选择经过伪随机数指定每一个做业的到达时间（0-30）和所需运行时间（1-8）。

2、       模拟程序的功能

1．            按照模拟数据的到达时间和所需运行时间，执行FCFS, SJF和HRRN调度算法，程序计算各做业的开始执行时间，各做业的完成时间，周转时间和带权周转时间（周转系数）。

2．            动态演示每调度一次，更新如今系统时刻，处于运行状态和等待各做业的相应信息（做业名、到达时间、所需的运行时间等）对于HRRN算法，能在每次调度时显示各做业的响应比R状况。

3．            （**）容许用户在模拟过程当中提交新做业。

4．            （**）编写并调度一个多道程序系统的做业调度模拟程序。 只要求做业调度算法：采用基于先来先服务的调度算法。 对于多道程序系统，要假定系统中具备的各类资源及数量、调度做业时必须考虑到每一个做业的资源要求。

3、       模拟数据结果分析

1．            对同一个模拟数据各算法的平均周转时间，周转系数比较。

2．            （**）用曲线图或柱形图表示出以上数据，分析算法的优势和缺点。

1、       实验准备

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

 

2、       其余要求

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

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

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

2、实验内容

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

三、实验环境

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

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

#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); 

}