zoukankan      html  css  js  c++  java
  • 实验三

    实验三 进程调度模拟程序

    1.    目的和要求

    1.1.           实验目的

    用高级语言完成一个进程调度程序,以加深对进程的概念及进程调度算法的理解。

    1.2.           实验要求

    1.2.1例题:设计一个有 N个进程并发执行的进程调度模拟程序。

    进程调度算法:采用最高优先级优先的调度算法(即把处理机分配给优先级最高的进程)和先来先服务(若优先级相同)算法。

    (1).  每个进程有一个进程控制块(PCB)表示。进程控制块包含如下信息:进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。

    (2).  进程的优先级及需要的运行时间可以事先人为地指定,进程的运行时间以时间片为单位进行计算。

    (3).  每个进程的状态可以是就绪 r(ready)、运行R(Running)、或完成F(Finished)三种状态之一。

    (4).  就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。

    (5).  如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待调度。

    (6).  每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB,以便进行检查。   

    (7).  重复以上过程,直到所要进程都完成为止。

    思考:作业调度与进程调度的不同?

    1.2.2实验题A:编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对N(N不小于5)个进程进行调度。

    “最高优先级优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

    (1). 静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。

    (2). 动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定规则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1,并且进程等待的时间超过某一时限(2个时间片时间)时增加其优先数等。

    (3). (**)进程的优先数及需要的运行时间可以事先人为地指定,(也可以由随机数产生)。

    (4). (**)在进行模拟调度过程可以创建(增加)进程,其到达时间为进程输入的时间。

    0.

    1.2.3实验题B:编写并调试一个模拟的进程调度程序,采用“基于时间片轮转法”调度算法对N(N不小于5)个进程进行调度。 “轮转法”有简单轮转法、多级反馈队列调度算法。

    (1). 简单轮转法的基本思想是:所有就绪进程按 FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片长度相同。如果运行进程用完它的时间片后还未完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程。直至所有的进程运行完毕。(此调度算法是否有优先级?)

     (2). 多级反馈队列调度算法的基本思想是:

    将就绪队列分为N级(N=3~5),每个就绪队列优先数不同并且分配给不同的时间片:队列级别越高,优先数越低,时间片越长;级别越小,优先数越高,时间片越短。

    系统从第一级调度,当第一级为空时,系统转向第二级队列,.....当处于运行态的进程用完一个时间片,若未完成则放弃CPU,进入下一级队列。

    当进程第一次就绪时,进入第一级队列。

    (3). (**)考虑进程的阻塞状态B(Blocked)增加阻塞队列。进程的是否阻塞和阻塞的时间由产生的“随机数”确定(阻塞的频率和时间长度要较为合理)。注意进程只有处于运行状态才可能转换成阻塞状态,进程只有处于就绪状态才可以转换成运行状态。

    2.    实验内容

    根据指定的实验课题:A(1),A(2),B(1)和B(2)

    完成设计、编码和调试工作,完成实验报告。

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

    3.    实验环境

    可以选用Turbo C作为开发环境。也可以选用Windows下的VB,CB等可视化环境,利用各种控件较为方便。自主选择实验环境。

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

         动态优先数(优先数只减不加):

            

    #include "stdio.h"
    #include <stdlib.h>
    #include <conio.h>
    #define getpch(type) (type*)malloc(sizeof(type))
    #define N 3
    int count;
    struct pcb { /* 定义进程控制块PCB */
           char name[10];
           char status; //状态
           int prio; //优先级
           int ntime; //需要时间
           int rtime; //实际运行时间
           int atime; //到达时间
           struct pcb* link;
    }*ready=NULL,*p;
     
    typedef struct pcb PCB;
     
    struct pcb2 { /* 定义进程控制块PCB2 */
           char name[10];
           char status;
           int prio;
           int atime;
           int ntime;
           int runtime;
           int restime;
    }pcb[24];
       
    sort() /* 进程进行优先级排列函数*/
    {
      PCB *first, *second;
      int insert=0;
      if((ready==NULL)||((p->prio)>(ready->prio))) /*优先级最大者,插入队首*/
      {
        p->link=ready;
        ready=p;
      }
      else /* 进程比较优先级,插入适当的位置中*/
      {
        first=ready;
        second=first->link;
        while(second!=NULL)
        {
          if((p->prio)>(second->prio)) /*若插入进程比当前进程优先数大,*/
          { /*插入到当前进程前面*/
            p->link=second;
            first->link=p;
            second=NULL;
            insert=1;
          }
          else /* 插入进程优先数最低,则插入到队尾*/
          {
            first=first->link;
            second=second->link;
          }
        }
        if(insert==0) first->link=p;
      }
    }
      
     
     
    input() /* 建立进程控制块函数*/
    {
      int i,num;
      /*clrscr();  */   /*清屏*/
      printf("
     请输入进程数?");
      scanf("%d",&num);
      for(i=0;i<num;i++)
      {
        printf("
     进程号No.%d:
    ",i);
        p=getpch(PCB);  /*宏(type*)malloc(sizeof(type)) */
        printf("
     输入进程名:");
        scanf("%s",p->name);
        /*printf("
     输入进程优先数:");
        scanf("%d",&p->prio); */
        p->prio=N;
        printf("
     输入进程运行时间:");
        scanf("%d",&p->ntime);
        printf("
    ");
        p->rtime=0;
        p->status='r';
        p->link=NULL;
        sort(); /* 调用sort函数*/
     
      }
     
    }
    sort2()
    {
        int i,j;
        struct pcb2 t;
        for(i=0;i<count-1;i++) //按进程到达时间的先后排序
        {                               //如果两个进程同时到达,按在屏幕先输入的先运行
            for(j=i+1;j<count;j++)
            {
                if(pcb[j].atime< pcb[i].atime)
                {
                    t=pcb[j];
                    pcb[j]=pcb[i];
                    pcb[i]=t;
                }
     
            }
        }
    }
    QueueSort()
    {
        int i;
        struct pcb2 t;
        t=pcb[0];
        for(i=1;i<count;i++)
            pcb[i-1]=pcb[i];
        pcb[0].restime--;
        pcb[count-1]=t;
     
    }
    QueueSort1()
    {
        int i;
     
        for(i=1;i<count;i++)
            pcb[i-1]=pcb[i];
        count--;
     
    }
    input2()
    {
        int i,num;
        int timeflag=0;
        int timepiece=2;
        int T;
        int k;
        char ch;
      printf("
     请输入进程数:");
      scanf("%d",&num);
      count=num;
      for(i=0;i<num;i++)
      {
        printf("
     进程号No.%d:
    ",i);
        printf("
     输入进程名:");
        scanf("%s",pcb[i].name);
        printf("
     输入进程到达时间:");
        scanf("%d",&pcb[i].atime);
         
        printf("
     输入进程运行时间:");
        scanf("%d",&pcb[i].ntime);
        printf("
    ");
        pcb[i].runtime=0;
        pcb[i].status='r';
        pcb[i].restime=pcb[i].ntime;
       
      }
      sort2();
      printf("
    
    --------------FCFS排序之后-----------------
    ");
      printf("进程名  到达时间  需要运行时间
    ");
      for(i=0;i<num;i++)
      {
         printf("%s  %d  %d 
    ",pcb[i].name,pcb[i].atime,pcb[i].ntime);
      }
      while(count>=0)
        {
            if(timeflag==T)
            {
                timeflag=0;
                if(pcb[0].restime==0)
                {
                printf("进程%s已完成
    ",pcb[0].name);
                 
     
                if(count!=0){
                    QueueSort1();
                    printf("当前正在运行进程是:%s
    ",pcb[0].name);
                }
                if(count>=1)
                    for(k=1;k<count;k++)
                    printf("进程%s正在等待
    ",pcb[k].name);
                if(count==0){
                    pcb[0].restime--;
                    count--;
                }
                }
                else{
                    QueueSort();
                    if(count!=0){
                    //QueueSort1();
                    printf("当前正在运行进程是:%s
    ",pcb[0].name);
                    }
                    if(count>=1)
                    for(k=1;k<count;k++)
                    printf("进程%s正在等待
    ",pcb[k].name);
                }             
            }
            else{
                if(pcb[0].restime==0)
                {
                printf("进程%s已完成
    ",pcb[0].name);
                if(count!=0){
                    QueueSort1();
                    printf("进程%s正在运行
    ",pcb[0].name);
                }
                if(count>=1)
                    for(k=1;k<count;k++)
                    printf("进程%s正在等待
    ",pcb[k].name);
                }
                else{
                    pcb[0].restime--;
                    if(count!=0)
                    printf("进程%s正在运行
    ",pcb[0].name);
                 
                    if(count>=1)
                    for(k=1;k<count;k++)
                    printf("进程%s正在等待
    ",pcb[k].name);
                }
            }
            timeflag++;
            printf("
     按任一键继续......");
            ch=getchar();
            ch=getchar();
        }
         printf("
    
     全部进程已经完成.
    ");
    }
    input1()
    {
        int choose;
        printf("1)最高优先数 or 2)时间片轮转");
        scanf("%d",&choose);
        if(choose==1)
            input();
        else if(choose==2)
            input2();
    }
    int space()
    {
      int l=0; PCB* pr=ready;
      while(pr!=NULL)
      {
      l++;
      pr=pr->link;
      }
      return(l);
    }
     
     
    disp(PCB * pr) /*单个进程显示函数*/
    {
       
      printf("|%s	",pr->name);
      printf("|%c	",pr->status);
      printf("|%d	",pr->prio);
      printf("|%d	",pr->ntime);
      printf("|%d	",pr->rtime);
      printf("
    ");
    }
     
    void printbyprio(int prio)
    {
      PCB* pr;
      pr=ready;
      printf("
     ****当前第%d级队列(优先数为%d)的就绪进程有:
    ",(N+1)-prio,prio); /*显示就绪队列状态*/
      printf("
     qname 	status	 prio 	ndtime	 runtime 
    ");
      while(pr!=NULL)
      {
        if (pr->prio==prio) disp(pr);
        pr=pr->link;
      }
    }
     
    check() /* 显示所有进程状态函数 */
    {
      PCB* pr;
      int i;
      printf("
     /\/\/\/\当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
       printf("
     qname 	status	 prio 	ndtime	 runtime 
    ");
      disp(p);
       
      printf("
     当前就绪队列状态为:
    "); /*显示就绪队列状态*/
      for(i=N;i>=1;i--)
        printbyprio(i);
      /*
      while(pr!=NULL)
      {
        disp(pr);
        pr=pr->link;
        }
      */
    }
     
     
    destroy() /*进程撤消函数(进程运行结束,撤消进程)*/
    {
      printf("
     进程 [%s] 已完成.
    ",p->name);
      free(p);
    }
     
     
    running() /* 运行函数。判断是否完成,完成则撤销,否则置就绪状态并插入就绪队列*/
    {
      int slice,i;
      slice=1;//时间片,避免进程睡眠
      for(i=1;i<((N+1)-p->prio);i++)
        slice=slice*2;//再次调度,时间片*2
         
      for(i=1;i<=slice;i++)
      {
         (p->rtime)++;
         if (p->rtime==p->ntime)
           break;
            
      }
      if(p->rtime==p->ntime)
          destroy(); /* 调用destroy函数*/
      else
      {
        if(p->prio>1) (p->prio)--;
        p->status='r';
        sort(); /*调用sort函数*/
      }
    }
    void cteatpdisp()
    /*显示(运行过程中)增加新进程后,所有就绪队列中的进程*/
    {
      
      int i;
        
      printf("
     当增加新进程后,所有就绪队列中的进程(此时无运行进程):
    "); /*显示就绪队列状态*/
      for(i=N;i>=1;i--)
        printbyprio(i);
    }
    void creatp()
    {
         char temp;
         printf("
    Creat one  more process?type Y (yes)");
         scanf("%c",&temp);
         if (temp=='y'||temp=='Y')
         {
            input();
            cteatpdisp();
         }
          
    }       
          
     
    main() /*主函数*/
    {
      int len,h=0;
      char ch;
      input1();
      len=space();
      while((len!=0)&&(ready!=NULL))
      {
        ch=getchar();
        /*getchar();*/
        h++;
        printf("
     The execute number:%d 
    ",h);
        p=ready;
        ready=p->link;
        p->link=NULL;
        p->status='R';
        check();
        running();
        creatp();
        printf("
     按任一键继续......");
        ch=getchar();
      }
      printf("
    
     进程已经完成.
    ");
      ch=getchar();
      ch=getchar();
    } <br><br><br>
  • 相关阅读:
    BZOJ5057 : 区间k小值5
    Urozero Autumn 2016. UKIEPC 2016
    BZOJ2808 : 那些年我们画格子
    BZOJ4970 : [ioi2004]empodia 障碍段
    XVII Open Cup named after E.V. Pankratiev. XXI Ural Championship
    BZOJ4316 : 小C的独立集
    网络流(3)——找到最小st-剪切
    网络流(2)——用Ford-Fullkerson算法寻找最大流
    网络流(1)——网络、流网络和网络流
    退而求其次(4)——椭圆中的最大矩形
  • 原文地址:https://www.cnblogs.com/maijinjun/p/5487697.html
Copyright © 2011-2022 走看看