实验三 进程调度模拟程序

#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\n",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("\nEnter the name of process\n");
  scanf("%s",na);
   printf("Enter the time of process\n");
  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\n");
 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:\n");
  scanf("%d",&N);
  rcreate_task(algo);
  roundrun(algo);
}