实验三 进程调度模拟程序

实验一、  进程调度模拟程序

物联网工程 刘烨 201306104146

一、 实验目的

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

二、 实验内容和要求

    设计一个有 N（N不小于5）个进程并发执行的进程调度模拟程序。

进程调度算法：“时间片轮转法”调度算法对N个进程进行调度。

完成两个算法(简单时间片轮转法、多级反馈队列调度算法)的设计、编码和调试工作，完成实验报告。

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

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

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

4) 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，应把它插入就绪队列等待下一次调度。

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

6) 重复以上过程，直到所要进程都完成为止。

 

三、 实验方法、步骤及结果测试

 

1. 源程序名：进程.c

可执行程序名：进程.exe

1. 原理分析及流程图

(1). 简单轮转法的基本思想是：

所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片长度相同。如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。直至所有的进程运行完毕。

 

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

将就绪队列分为N级（N＝3～5），每个就绪队列优先数不同并且分配给不同的时间片：队列级别越高，优先数越低，时间片越长；级别越小，优先数越高，时间片越短。

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

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

 

1. 主要程序段及其解释：

 

#include<stdio.h>

#include <stdlib.h>

int num;

#define N  24

struct JCB{

        char name[10];      //作业名

        float arrive;           //作业提交时间  

        float run;           //作业运行时间  

        char   state[30];   //作业状态    

        int priority;    //优先级

float cputime;  //已用cpu时间

int waitcount;//等待的时间片次数

}jcb[N],temp;

 

void input()                //用户输入模块

{

    int i;  

    do{

        printf("\n\t请输入作业数(2-24):");

        scanf("%d",&num); 

        printf("\n");

        if(num<2||num>24)

{

            printf("\t请重新输入!\n");

        }

    }

    while(num<2||num>24);

    for(i=0;i<num;i++){

        printf("\t第%d个作业名:",i+1);   

        scanf("%s",&jcb[i].name);   

        printf("\n\t请输入作业提交时间:");   

        scanf("%f",&jcb[i].arrive);   

        printf("\n\t请输入作业运行时间:");   

        scanf("%f",&jcb[i].run); 

 printf("\n\t请输入作业优先级:");   

        scanf("%d",&jcb[i].priority); 

        printf("\n");

 strcpy(jcb[i].state,"r");

jcb[i].cputime=0;

        jcb[i].waitcount=0;

 

    }

 

}

void output()             //输出模块

{

   int i=0;

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

    printf(" 作业名  提交时间  运行时间   已用cpu时间   优先级   状态  \n");

    for(i=0;i<num;i++)

    {

        printf("   %-8s%-10.2f%-10.2f%-10.2f%-15d%-10.2s%",jcb[i].name,jcb[i].arrive,jcb[i].run,jcb

 

        [i].cputime,jcb[i].priority,jcb[i].state);

        printf("\n");

       

    }

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

    

}

 int check(int num)//判断所有作业是否都调度完成

 {

      int count=0;

      int i=0;

      for(i=0;i<num;i++)

      {

          if(jcb[i].state[0]=='f')

              count++;

      }

      if(count==num)

      {

          return 1;

      }

      return 0;

  }

  int find(int num,int runtime)//找最高优先级进程

  {

      int i=0;

      int MAX=0;

     int k=0;

     for(i=0;i<num;i++)

     {

         if(jcb[i].arrive<=runtime&&jcb[i].state[0]=='r'&&jcb[i].priority>MAX)

         {

             MAX=jcb[i].priority;

             k=i;

         }

         

     }

     return k;

     

 }

 

void lunzhuan(int pian)  

{

   

  int k=0;

      int i=0;

      int runtime=0;

     output();

      do{

          

          k=find(num,runtime);

          jcb[k].priority--;

          

          jcb[k].cputime++;

          

          if(jcb[k].priority<0)

          {

              

              jcb[k].priority=0;

          }

          if(jcb[k].cputime*pian>=jcb[k].run)

          {

  strcpy(jcb[k].state,"f");

  }

          for(i=0;i<num;i++)

          {

              if(i==k)

             {

                  jcb[i].waitcount=0;

              }

              if(i!=k&&jcb[i].arrive<=runtime&&jcb[i].state[0]!='f')

              {

                jcb[i].waitcount++;

                  if(jcb[i].waitcount==2)

                  {

                      jcb[i].priority++;

                      jcb[i].waitcount=0;

                  }

              }

          }

          output();

          runtime++;

      }while(check(num)!=1);

}

  

main()

{

   

       int pian; 

    input(); 

printf("please input the time of piecetime:");

        scanf("%d",&pian);

       printf("\t\t进程调度模拟程序\n"); 

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

      lunzhuan(pian);

 

}

    

1. 运行结果及分析

 

 

四、实验总结

    参照上个实验，基本框架是相同的，都是用一个结构体来存储进程信息。然后输入输出模块与上次实验也差不多。而这次要求实现时间片调度算法。但需要多几个参数来判断，比如优先级，进程状态等。虽然可以输出结果，但好像并不准确，还需要继续完善。

 

转载于:https://www.cnblogs.com/46ly/p/5014551.html