实验三 进程调度模拟程序

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

专业 13物联网  姓名 张欣怡 学号 201306104135

1. 目的和要求

实验目的

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

实验要求

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

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

 

2. 实验内容

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

 

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

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

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

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

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

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

 

3. 实验原理及核心算法 

“轮转法”有简单轮转法、多级反馈队列调度算法。

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

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

 

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

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

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

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

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
/*进程控制块数据结构*/
typedef struct node 
{
  char name[10];/*进程名*/
 int prio;     /*进程优先级*/ 
 int round;    /*进程分配的时间片*/ 
 int cputime;  /*进程消耗的CUP时间*/
 int needtime; /*进程需要的CUP时间*/
 int count;    /*进程运行时间*/
 char state;   /*进程的状态：'R':运行,'W'：等待,'F'：结束*/
 struct node *next;/*指向下一个进程的指针*/     
}PCB;

PCB *finish,*ready,*tail,*run;/*指向三个队列的队首的指针，tail为就绪队列的队尾指针*/

int N;/*定义进程的数目*/

/*
函数功能： 将进程就绪队列中第一个放进就绪队列 
函数原型： void firstin(void)
函数参数： void 
函数返回值：void
*/
void firstin(void)
{
    if(ready!=NULL)
    {
     run=ready;
     ready=ready->next;
     run->state='R';
     run->next=NULL;
   }
   else
   {
     run=NULL;
     
   }
   
}
 

/*
函数功能：输出单个进程信息的函数 
函数原型：void prt2(char a,PCB *p)
函数参数：char a :a=='p'为优先级，=='r'为时间片轮转 
          PCB *p 为指向待输出的进程控制块的指针     
函数返回值：void
*/
void prt2(char a,PCB *p)
{
  printf("%-10s,%-10d,%-10d,%-10d,%-10d,%-5c
",p->name,p->cputime,p->needtime,p->count,p->round,p->state);
}



/*
函数功能：输出所有进程信息的函数 
函数原型：void prt(char algo)
函数参数：char a :a=='p'为优先级，=='r'为时间片轮转 
函数返回值：void
*/
void prt(char algo)
{
  PCB *p;
  if(run!=NULL)
  {
  prt2(algo,run);
  }
  
  p=ready;
  while(p!=NULL)
  {
   prt2(algo,p);
   p=p->next;
  }
  
  p=finish;
  while(p!=NULL)
  {
  prt2(algo,p);
  p=p->next;
  }
  getchar();
}


/*
函数功能：时间片轮转算法调度将进程插入到就绪队列算法 
函数原型：void insert2(PCB *q)
函数参数：PCB *q 待插入的队列进程控制块  
函数返回值：void
*/
 void insert2(PCB *q)
 {
 tail->next=q;
 tail=q;
 q->next=NULL;
 }


/*
函数功能：采用时间片轮转法进程调度法时，进程初始化函数 
函数原型：void rcreate_task(char algo)
函数参数：char algo:  R
函数返回值：void
*/
void rcreate_task(char algo)
{
  PCB *p;
 int i,time;
 char na[10];
 ready=NULL;
 finish=NULL;
 run=NULL;
 for(i=0;i<N;i++)
 {
  p=(PCB*)malloc(sizeof(PCB));
  printf("
Enter the name of process
");
  scanf("%s",na);
   printf("Enter the time of process
");
  scanf("%d",&time);
  strcpy(p->name,na);
  p->cputime=0;
  p->needtime=time;
  p->count=0;
  p->state='W';
  p->round=2;
  if(ready!=NULL)
  {
  insert2(p);
  }
  else
  {
    p->next=ready;
    ready=p;
    tail=p;
  }
 printf("Output the waiting processes information
");
 prt(algo);
  }
 run=ready;
 ready=ready->next;
 run->state='R';
     
}


/*
函数功能：采用时间片轮转法进程调度法时，进程调度函数 
函数原型：void roundrun(char algo)
函数参数：char algo:  R
函数返回值：void
*/
void roundrun(char algo)
{
  while(run!=NULL)
  {
  run->cputime=run->cputime+1;
  run->needtime=run->needtime-1;
  run->count=run->count+1;
  if(run->needtime==0)
  {
    run->next=finish;
   finish=run;
   run->state='F';
   run=NULL;
   if(ready!=NULL)
   {
      firstin();
    }         
   }
   else
   {
     if(run->count==run->round)
     {
     run->count=0; 
     if(ready!=NULL)
   {        
      run->state='W';
      insert2(run);
      firstin();
   }
    }
   }
   prt(algo);
  }  
}



/*main 函数*/

void main()
{
  char algo='r';
  printf("Please enter the number of processes N:
");
  scanf("%d",&N);
  rcreate_task(algo);
  roundrun(algo);
}

 

总结：时间片算法程序想法是参考网上的，看了网上的程序也不是很能理解。多级反馈调度算法还是不懂。