• 实验二 作业调度模拟程序


     

    一、目的和要求

    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

    一个作业具备什么信息?

    作业由三部分组成,即程序、数据和作业说明书。一个作业可以包含多个程序和多个数据集,但必须至少包含一个程序。否则将不成为作业。

    3

    为了方便模拟调度过程,作业使用什么方式的数据结构存放和表示?JCB

    由作业说明书在系统中生成一个称为作业控制块(job control block,JCB)的表格。该表格登记该作业所要求的资源情况、预计执行时间和执行优先级等。从而,操作系统通过该表了解到作业要求,并分配资源和控制作业中程序和数据的编译、链接、装入和执行等。

    4

    操作系统中,常用的作业调度算法有哪些?

    先来先服务、轮转法、多级反馈队列列算法、优先级法、短作业优先法、最高响应

    5

    如何编程实现作业调度算法?

    6

    模拟程序的输入如何设计更方便、结果输出如何呈现更好?

           

     

    五、       其他要求

    1.            完成报告书,内容完整,规格规范。

    2.            实验须检查,回答实验相关问题。

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

    二、实验内容

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

    、实验环境

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

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

         单道FCFS算法:

            

      1 #include<stdio.h>
      2 #include<string.h>
      3 void shuru();
      4 void readfiles();
      5 void ran();
      6 typedef struct jcb
      7 {
      8     char name[10];
      9     char status;    //状态:开始s,等待d,就绪j
     10     int id;
     11     int arrtime;    //到达时间
     12     int reqtime;    //要求服务时间
     13     int startime;    //开始时间
     14     int finitime;    //完成时间
     15 
     16     float TAtime,TAWtime;    //周转时间、带权周转时间
     17     float prio;        //优先级
     18     float HRRF;            //响应比
     19 
     20 }jcb;
     21 
     22 
     23 
     24 jcb jcbs[100]; //最多100个作业
     25 int systime=0,bfsum,add,del;
     26 int intarr,infin,intjob,sumjcb;
     27 char T='A';              //T的默认值是A
     28 
     29 void sort(int choose)  //排序
     30 {
     31     int i,j;
     32     jcb temp;
     33     for(i=1;i<=sumjcb;i++)
     34     {
     35         for(j=i+1;j<=sumjcb;j++)
     36         {
     37             if(choose==1)
     38             {
     39                 if(jcbs[i].arrtime>jcbs[j].arrtime)
     40                 {
     41                     strcpy(temp.name,jcbs[i].name);
     42                     temp.status=jcbs[i].status;
     43                     temp.arrtime=jcbs[i].arrtime;
     44                     temp.reqtime=jcbs[i].reqtime;
     45                     temp.startime=jcbs[i].startime;
     46                     temp.finitime=jcbs[i].finitime;
     47                     temp.TAtime=jcbs[i].TAtime;
     48                     temp.TAWtime=jcbs[i].TAWtime;
     49                     temp.prio=jcbs[i].prio;
     50                     temp.id=jcbs[i].id;
     51                     temp.HRRF=jcbs[i].HRRF;
     52 
     53                     strcpy(jcbs[i].name,jcbs[j].name);
     54                     jcbs[i].status=jcbs[j].status;
     55                     jcbs[i].arrtime=jcbs[j].arrtime;
     56                     jcbs[i].reqtime=jcbs[j].reqtime;
     57                     jcbs[i].startime=jcbs[j].startime;
     58                     jcbs[i].finitime=jcbs[j].finitime;
     59                     jcbs[i].TAtime=jcbs[j].TAtime;
     60                     jcbs[i].TAWtime=jcbs[j].TAWtime;
     61                     jcbs[i].prio=jcbs[j].prio;
     62                     jcbs[i].id=jcbs[j].id;
     63                     jcbs[i].HRRF=jcbs[j].HRRF;
     64 
     65                     strcpy(jcbs[j].name,temp.name);
     66                     jcbs[j].status=temp.status;
     67                     jcbs[j].arrtime=temp.arrtime;
     68                     jcbs[j].reqtime=temp.reqtime;
     69                     jcbs[j].startime=temp.startime;
     70                     jcbs[j].finitime=temp.finitime;
     71                     jcbs[j].TAtime=temp.TAtime;
     72                     jcbs[j].TAWtime=temp.TAWtime;
     73                     jcbs[j].prio=temp.prio;
     74                     jcbs[j].id=temp.id;
     75                     jcbs[j].HRRF=temp.HRRF;
     76                 }
     77             }
     78             else if(choose==2)
     79             {
     80                 if(jcbs[i].reqtime>jcbs[j].reqtime)
     81                 {
     82                     strcpy(temp.name,jcbs[i].name);
     83                     temp.status=jcbs[i].status;
     84                     temp.arrtime=jcbs[i].arrtime;
     85                     temp.reqtime=jcbs[i].reqtime;
     86                     temp.startime=jcbs[i].startime;
     87                     temp.finitime=jcbs[i].finitime;
     88                     temp.TAtime=jcbs[i].TAtime;
     89                     temp.TAWtime=jcbs[i].TAWtime;
     90                     temp.prio=jcbs[i].prio;
     91                     temp.id=jcbs[i].id;
     92                     temp.HRRF=jcbs[i].HRRF;
     93 
     94                     strcpy(jcbs[i].name,jcbs[j].name);
     95                     jcbs[i].status=jcbs[j].status;
     96                     jcbs[i].arrtime=jcbs[j].arrtime;
     97                     jcbs[i].reqtime=jcbs[j].reqtime;
     98                     jcbs[i].startime=jcbs[j].startime;
     99                     jcbs[i].finitime=jcbs[j].finitime;
    100                     jcbs[i].TAtime=jcbs[j].TAtime;
    101                     jcbs[i].TAWtime=jcbs[j].TAWtime;
    102                     jcbs[i].prio=jcbs[j].prio;
    103                     jcbs[i].id=jcbs[j].id;
    104                     jcbs[i].HRRF=jcbs[j].HRRF;
    105 
    106                     strcpy(jcbs[j].name,temp.name);
    107                     jcbs[j].status=temp.status;
    108                     jcbs[j].arrtime=temp.arrtime;
    109                     jcbs[j].reqtime=temp.reqtime;
    110                     jcbs[j].startime=temp.startime;
    111                     jcbs[j].finitime=temp.finitime;
    112                     jcbs[j].TAtime=temp.TAtime;
    113                     jcbs[j].TAWtime=temp.TAWtime;
    114                     jcbs[j].prio=temp.prio;
    115                     jcbs[j].id=temp.id;
    116                     jcbs[j].HRRF=temp.HRRF;
    117                 }
    118             }
    119             else if(choose==3)
    120             {
    121                 if(jcbs[i].HRRF<jcbs[j].HRRF)
    122                 {
    123                     strcpy(temp.name,jcbs[i].name);
    124                     temp.status=jcbs[i].status;
    125                     temp.arrtime=jcbs[i].arrtime;
    126                     temp.reqtime=jcbs[i].reqtime;
    127                     temp.startime=jcbs[i].startime;
    128                     temp.finitime=jcbs[i].finitime;
    129                     temp.TAtime=jcbs[i].TAtime;
    130                     temp.TAWtime=jcbs[i].TAWtime;
    131                     temp.prio=jcbs[i].prio;
    132                     temp.id=jcbs[i].id;
    133                     temp.HRRF=jcbs[i].HRRF;
    134 
    135                     strcpy(jcbs[i].name,jcbs[j].name);
    136                     jcbs[i].status=jcbs[j].status;
    137                     jcbs[i].arrtime=jcbs[j].arrtime;
    138                     jcbs[i].reqtime=jcbs[j].reqtime;
    139                     jcbs[i].startime=jcbs[j].startime;
    140                     jcbs[i].finitime=jcbs[j].finitime;
    141                     jcbs[i].TAtime=jcbs[j].TAtime;
    142                     jcbs[i].TAWtime=jcbs[j].TAWtime;
    143                     jcbs[i].prio=jcbs[j].prio;
    144                     jcbs[i].id=jcbs[j].id;
    145                     jcbs[i].HRRF=jcbs[j].HRRF;
    146 
    147                     strcpy(jcbs[j].name,temp.name);
    148                     jcbs[j].status=temp.status;
    149                     jcbs[j].arrtime=temp.arrtime;
    150                     jcbs[j].reqtime=temp.reqtime;
    151                     jcbs[j].startime=temp.startime;
    152                     jcbs[j].finitime=temp.finitime;
    153                     jcbs[j].TAtime=temp.TAtime;
    154                     jcbs[j].TAWtime=temp.TAWtime;
    155                     jcbs[j].prio=temp.prio;
    156                     jcbs[j].id=temp.id;
    157                     jcbs[j].HRRF=temp.HRRF;
    158                 }
    159             }
    160             else 
    161                 printf("Error!
    ");
    162         }
    163     }
    164 }
    165 void ins()    //插入
    166 {
    167     int i;
    168     while(T!='E'&&T!='e')
    169     {
    170             printf("'I'nsert or 'D'elete or 'E'xit?
    ");
    171             getchar();
    172             scanf("%c",&T);
    173             if(T=='I'||T=='i')
    174             {
    175                 printf("你想插入多少个作业?
    ");
    176                 scanf("%d",&add);
    177                 bfsum=sumjcb;
    178                 sumjcb=sumjcb+add;
    179                 for(i=bfsum+1;i<=sumjcb;i++)
    180                 {
    181                     printf("
    第%d个作业:
    ",i);
    182                     getchar();
    183                     printf("输入作业名:
    ");
    184                     gets(jcbs[i].name);
    185                     printf("到达时间:
    ");
    186                     scanf("%d",&jcbs[i].arrtime);
    187                     printf("要求服务时间:
    ");
    188                     scanf("%d",&jcbs[i].reqtime);
    189                 }
    190             }
    191             else if(T=='D'||T=='d')
    192             {
    193                 printf("你想删除第几组?");
    194                 scanf("%d",&del);
    195                 for(i=del;i<=sumjcb-1;i++)
    196                 {
    197                     strcpy(jcbs[i].name,jcbs[i+1].name);
    198                     jcbs[i].arrtime=jcbs[i+1].arrtime;
    199                     jcbs[i].reqtime=jcbs[i+1].reqtime;
    200                 }
    201                 sumjcb--;
    202             }
    203     }
    204 }
    205 
    206 
    207 void printarr()    //打印
    208 {
    209     int i;
    210     printf("		name	artime	rqtime
    ");
    211     for(i=1;i<=sumjcb;i++)
    212     {
    213         printf("N  %d	",i);
    214         printf("	%s",jcbs[i].name);
    215         printf("	%d",jcbs[i].arrtime);
    216         printf("	%d
    ",jcbs[i].reqtime);
    217     }
    218     printf("						现在系统时间%d
    ",systime);
    219     
    220 }
    221 void printz()
    222 {
    223     int i;
    224     float sum1=0,sum2=0;    //计算平均周转时间、平均带权周转时间
    225     printf("		name	artime	rqtime	stime	ftime	TAtime		TAWtime
    ");
    226     for(i=1;i<=sumjcb;i++)
    227     {
    228         printf("N  %d	",i);
    229         printf("	%s",jcbs[i].name);
    230         printf("	%d",jcbs[i].arrtime);
    231         printf("	%d",jcbs[i].reqtime);
    232         printf("	%d",jcbs[i].startime);
    233         printf("	%d",jcbs[i].finitime);
    234         printf("	%f",jcbs[i].TAtime);
    235         printf("	%f
    ",jcbs[i].TAWtime);
    236     }
    237     for(i=1;i<=sumjcb;i++)
    238     {
    239         sum1=sum1+jcbs[i].TAtime;
    240     }
    241     for(i=1;i<=sumjcb;i++)
    242     {
    243         sum2=sum2+jcbs[i].TAWtime;
    244     }
    245     printf("
    平均周转时间=%f
    ",sum1/sumjcb);
    246     printf("
    平均带权周转时间=%f
    ",sum2/sumjcb);
    247     printf("						现在系统时间%d
    ",systime);
    248 }
    249 void sumofthey()
    250 {
    251     int i;
    252     jcbs[1].startime=jcbs[1].arrtime;
    253     jcbs[1].finitime=jcbs[1].arrtime+jcbs[1].reqtime;
    254     jcbs[1].TAtime=(float)(jcbs[1].finitime-jcbs[1].arrtime);
    255     jcbs[1].TAWtime=(float)(jcbs[1].TAtime/jcbs[1].reqtime);
    256     jcbs[1].HRRF=(float)(jcbs[1].TAtime/jcbs[1].reqtime);
    257     for(i=2;i<=sumjcb;i++)
    258     {
    259         jcbs[i].startime=jcbs[i-1].finitime;
    260         jcbs[i].finitime=jcbs[i].startime+jcbs[i].reqtime;
    261         jcbs[i].TAtime=(float)(jcbs[i].finitime-jcbs[i].arrtime);
    262         jcbs[i].TAWtime=(float)(jcbs[i].TAtime/jcbs[i].reqtime);
    263         jcbs[i].HRRF=(float)(jcbs[i].TAtime/jcbs[i].reqtime);
    264     }
    265 }
    266 void startit()
    267 {
    268     int n;
    269     printf("
    ");
    270     printf("			**************************
    ");
    271     printf("			**1.调用文本写入数据******
    ");
    272     printf("			**2.调用伪随机数产生数据**
    ");
    273     printf("			**3.调用自己输入模拟数据**
    ");
    274     printf("			**************************
    ");
    275     scanf("%d",&n);
    276     switch(n)
    277     {
    278     case 1:
    279         readfiles();
    280         sumofthey();
    281         break;
    282     case 2:
    283         ran();
    284         sumofthey();
    285         break;
    286     case 3:
    287         shuru();
    288         sumofthey();
    289         break;
    290     default:
    291         {
    292         printf("输入有误,请重新输入");
    293         break;
    294         }
    295     }
    296 }
    297 void ran()
    298 {
    299     int i;
    300     srand((unsigned)time(0));  //参数seed是rand()的种子,用来初始化rand()的起始值。
    301     sumjcb=rand()%23+5;
    302     for(i=1;i<=sumjcb;i++)
    303     {
    304         itoa(i,jcbs[i].name, 2);
    305      
    306         jcbs[i].arrtime=rand()%29+1;
    307     
    308         jcbs[i].reqtime=rand()%7+1;
    309     }
    310     printf("
     	id    	作业到达时间     	作业运行所需要时间
    ");
    311     for(i=1; i<=sumjcb; i++)
    312     {
    313         printf("
    	%s	%12d	%15d",jcbs[i].name,jcbs[i].arrtime,jcbs[i].reqtime);
    314     }
    315    printf("
    ");
    316 }
    317 
    318 void readfiles()
    319 {
    320     char szTest[1000] = {0};int i=0,n;
    321     FILE *fp=fopen("D:\File1.txt","r");
    322     //FILE *fout=fopen("D:\File2.txt","w");
    323     if(fp == NULL)
    324     {
    325         printf("ERROR!
    ");
    326         exit(0);
    327     }
    328     //fscanf(fp,"jcbsum=%d
    ",%n);
    329     while(!feof(fp))  
    330     {
    331         fscanf(fp,"%d%d%d",&jcbs[i].id,&jcbs[i].arrtime,&jcbs[i].reqtime);  //fscanf()函数将数据读入
    332         printf("
    %3d%12d%15d
    ",jcbs[i].id,jcbs[i].arrtime,jcbs[i].reqtime);  //输出到屏幕
    333         itoa(jcbs[i].id,jcbs[i].name,10);
    334         i++;
    335         /*memset(szTest, 0, sizeof(szTest));
    336         fscanf(fp,"@id=%d|",&i);
    337         fgets(fp,"name=%s|",jcbs[i].name);
    338         fscanf(fp,"arrtime=%d|reqtime=%d
    ",&jcbs[i].arrtime,&jcbs[i].reqtime);
    339         */
    340     //fscanf(fp,"%d",)
    341     }
    342     sumjcb=i;
    343     fclose(fp);
    344 }
    345 void shuru()
    346 {
    347     int i;
    348     printf("作业个数:
    ");
    349     scanf("%d",&sumjcb);
    350     for(i=1;i<=sumjcb;i++)
    351     {
    352         printf("
    第%d个作业:
    ",i);
    353         getchar();
    354         printf("输入作业名:
    ");
    355         gets(jcbs[i].name);
    356         printf("到达时间:
    ");
    357         scanf("%d",&jcbs[i].arrtime);
    358         printf("要求服务时间:
    ");
    359         scanf("%d",&jcbs[i].reqtime);
    360     }
    361     sumofthey();
    362 }
    363 void choosesort()
    364 {
    365     int n;
    366     printf("			*****************************
    ");
    367     printf("			*******1.FCFS算法调度********
    ");
    368     printf("			*******2.SJF算法调度*********
    ");
    369     printf("			*******3.HRRF算法调度********
    ");
    370     printf("			*******4.调用系统清屏********
    ");
    371     printf("			*******5.退出算法调度********
    ");
    372     printf("			*****************************
    ");
    373     scanf("%d",&n);
    374     switch(n)
    375     {
    376     case 1:
    377         printf("运行先来先服务算法FCFS
    ");
    378         sort(1);
    379         printf("
    经按到达时间排序后,未达到队列是
    ");
    380         printz();
    381         break;
    382     case 2:
    383         printf("运行最短作业优先算法FJS
    ");
    384         sort(2);
    385         printf("
    经按到达时间排序后,未达到队列是
    ");
    386         printz();
    387         break;
    388     case 3:
    389         printf("运行最高响应比优先算法HRRF
    ");
    390         sort(3);
    391         printf("
    经按到达时间排序后,未达到队列是
    ");
    392         printz();
    393         break;
    394     case 4:
    395         system("cls");
    396         break;
    397     case 5:
    398         exit(0);
    399         break;
    400     }
    401 }
    402 void main()
    403 {
    404     startit();
    405     choosesort();
    406     
    407 
    408 }
     
  • 相关阅读:
    如何从零开始开发一款嵌入式产品(20年的嵌入式经验分享学习)如何从零开始开发一款嵌入式产品(20年的嵌入式经验分享学习)
    shell命令【ulimit】
    ARM开发经典学习网站推荐
    [转]链表逆序
    [转]Rhythmbox中文乱码解决办法
    vi/vim 查找替换使用方法
    [转]程序员的十个层次 你属于哪一层?
    如何在程序中删除一个文件
    C/C++编译器错误代码大全
    R制作eset 的简单步骤
  • 原文地址:https://www.cnblogs.com/mxdmxdmxd78/p/5319710.html
Copyright © 2020-2023  润新知