LINUX操作系统实验 进程调度算法的模拟

编写C程序模拟实现单处理机系统中的进程调度算法，实现对多个进程的调度模拟，要求采用常见进程调度算法（如先来先服务、时间片轮转和优先级调度等算法）进行模拟调度。

优先级调度代码：

#include "stdio.h" 
#include <stdlib.h> 
#define getpch(type) (type*)malloc(sizeof(type)) 

struct pcb { /* 定义进程控制块PCB */ 
  char name[10]; //进程名
  char state;    //进程状态："W"-就绪态，"R"-运行态
  int nice;      //进程优先级
  int ntime;     //需要运行时间
  int rtime;     //已经运行的时间
  struct pcb* link; 
}*ready=NULL,*p; 
typedef struct pcb PCB; 

char sort() /* 建立对进程进行优先级排列函数，优先数大者优先*/ 
{ 
  PCB *first, *second; 
  int insert=0; 
  if((ready==NULL)||((p->nice)>(ready->nice)))/*优先级最大者,插入队首*/ 
  { 
    p->link=ready; 
    ready=p; 
  } 
  else /* 进程比较优先级,插入适当的位置中*/ 
  { 
    first=ready; 
    second=first->link; 
    while(second!=NULL) 
    { 
      if((p->nice)>(second->nice)) /*若插入进程比当前进程优先数大,*/ 
      { /*插入到当前进程前面*/ 
        p->link=second; 
        first->link=p; 
        second=NULL; 
        insert=1; 
      } 
      else /* 插入进程优先数最低,则插入到队尾*/ 
      { 
        first=first->link; 
        second=second->link; 
      } 
    } 
    if(insert==0) first->link=p; 
  } 
} 

char input() /* 建立进程控制块函数*/ 
{ 
  int i,num; 
  printf("\n 请输入被调度的进程数目："); 
  scanf("%d",&num); 
  for(i=0;i<num;i++) 
  { 
    printf("\n 进程号No.%d:",i); 
    p=getpch(PCB); 
    printf("\n 输入进程名:"); 
    scanf("%s",p->name); 
    printf(" 输入进程优先数:"); 
    scanf("%d",&p->nice); 
    printf(" 输入进程运行时间:"); 
    scanf("%d",&p->ntime); 
    printf("\n"); 
    p->rtime=0;
    p->state='W'; 
    p->link=NULL; 
    sort(); /* 调用sort函数*/ 
  } 
} 

int space() 
{ 
  int l=0; PCB* pr=ready; 
  while(pr!=NULL) 
  { 
    l++; 
    pr=pr->link; 
  } 
  return(l); 
} 

char disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ 
{ 
  printf("\n qname \t state \t nice \tndtime\truntime \n"); 
  printf("%s\t",pr->name); 
  printf("%c\t",pr->state); 
  printf("%d\t",pr->nice); 
  printf("%d\t",pr->ntime); 
  printf("%d\t",pr->rtime); 
  printf("\n"); 
}

char check() /* 建立进程查看函数 */ 
{ 
  PCB* pr; 
  printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ 
  disp(p); 
  pr=ready; 
  if (pr!=NULL) 
    printf("\n ****当前就绪队列状态为:"); /*显示就绪队列状态*/
  else 
    printf("\n ****当前就绪队列状态为: 空\n"); /*显示就绪队列状态为空*/
  while(pr!=NULL) 
  { 
    disp(pr); 
    pr=pr->link; 
  } 
} 

char destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ 
{ 
  printf(" 进程 [%s] 已完成.\n",p->name); 
  free(p); 
}
 
char running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ 
{ 
  (p->rtime)++; 
  if(p->rtime==p->ntime) 
  destroy(); /* 调用destroy函数*/ 
  else 
  { 
    (p->nice)--; 
    p->state='W'; 
    sort(); /*调用sort函数*/ 
  } 
} 

main() /*主函数*/ 
{ 
  int len,h=0; 
  char ch; 
  input(); 
  len=space(); 
  while((len!=0)&&(ready!=NULL)) 
  { 
    ch=getchar(); 
    h++; 
    printf("\n The execute number:%d \n",h); 
    p=ready; 
    ready=p->link; 
    p->link=NULL; 
    p->state='R'; 
    check(); 
    running(); 
    printf("\n按任一键继续......"); 
    ch=getchar(); 
  } 
  printf("\n\n 所有进程已经运行完成！\n"); 
  ch=getchar(); 
}

包含先来先服务、时间片轮转和优先级调度算法调度的代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>

typedef struct node{
  char name[10];
  int prio;
  int round;
  int cputime;
  int needtime;
  int count;
  char state;
  struct node *next;
}PCB;

PCB *finish,*ready,*run,*r;
int N;

void firstin()
{
  run = ready;
  run->state = 'R';
  ready = ready->next;
}
   
void prt1(char a)
{
  if(a=='P'||a == 'p') 
    printf("进程号  cpu时间   所需时间  优先数   状态\n");
  else if(a =='r'||a =='R')
    printf("进程号  cpu时间   所需时间   记数   时间片   状态\n");
  else if(a=='f'||a=='F')
    printf("进程号   所需时间   状态\n");
}

void prt2(char a ,PCB *q)
{
     if(a=='P'||a == 'p')
     printf("%-10s%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->prio,q->state);
     else if(a == 'r'|| a == 'R')
     printf("%-10s%-10d%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);
     else if(a=='f'||a=='F')
     printf("%-10s%-10d%c\n",q->name,q->needtime,q->state);
}

void prt(char algo)
{
     PCB *p;
     prt1(algo);
     if(run != NULL&& !(algo == 'r'||algo  =='R'))//这个对RR不适应！！ 
         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 insert1(PCB *q)
{
   PCB *p1,*s,*r;
   int b;
   s = q;
   p1 = ready;
   r = p1;
   b = 1;
   while((p1 != NULL)&&b)
    {
       if(p1->prio >= s->prio)
       {
         r = p1;
         p1 = p1->next;
       }
       else b = 0;
    }
    if(r!= p1)
    {
      r->next = s;
      s->next = p1;
    }
    else
    {
      s->next = p1;
      ready = s;
    }
}

void creat1(char alg)
{
     PCB *p;
     int i,time;
     char na[10];
     ready = NULL;
     finish = NULL;
     run = NULL;
     printf("输入进程号和运行时间:\n");
     for(i = 1; i <= N; i++)
     {
       p = (PCB *)malloc(sizeof(PCB));
       scanf("%s",na);
       scanf("%d",&time);
       strcpy(p->name,na);
       p->cputime = 0;
       p->needtime = time;
       p->state = 'W';
       p->prio = 50-time;
       if(ready != NULL)
       insert1(p);
       else{
         p->next = ready;
         ready = p;
         }
     }
     //clrscr();
     if(alg =='p'||alg =='P')
       printf("   优先数算法输出信息:\n");
     else
       printf("   先来先服务算法输出信息:\n");
     printf("*****************************************\n");
     prt(alg);
     run = ready;
     ready = ready->next;
     run->state = 'R';
}

void creat2(char alg)
{
     PCB *p;
     int i,time,round;
     char na[10];
     ready = NULL;
     finish = NULL;
     run = NULL;
     printf("请输入时间片：");
     scanf("%d",&round);
     printf("输入进程号和运行时间:\n");
     for(i = 1; i <= N; i++)
     {
       p = (PCB *)malloc(sizeof(PCB));
       scanf("%s",na);
       scanf("%d",&time);
       strcpy(p->name,na);
       p->cputime = 0;
       p->needtime = time;
       p->state = 'W';
       p->count  = 0;
       p->round  = round;
       p->next = NULL;
        if(i == 1)/*按顺序插入到ready链表中*/
       r = ready = p;
       else
       r->next = p;
       r = p;  
     }
     //clrscr();
     printf("     时间片轮转算法输出信息:\n");
     printf("*****************************************\n");
     prt(alg);
}

void priority(char alg)  //优先数调度算法
{
     while(run != NULL)
     {
       run->cputime += 1;
       run->needtime -= 1;
       run->prio -= 3;
       if(run->needtime == 0)
        {
          run->next = finish;
          finish = run;
          run->state = 'F';
          run = NULL;
          if(ready != NULL)
          firstin();
        }
        else 
         if((ready != NULL) && (run->prio < ready->prio))
         {
            run->state = 'W';
            insert1(run);
            firstin();
         }
         prt(alg);
     }
}

void roundrun(char alg)  //时间片轮转调度算法
{
  bool flag;//当ready列里只有一个时做标记 
  while(N){
    flag = 1;//初始化为1 
    run = ready;//run每次运行ready的队头 
    run->count++;//每运行一次计数器加1 
    if(run->needtime < run->round)//当剩余时间小于时间片轮转时间时的情况 
            {
              run->cputime += run->needtime;
              run->needtime = 0;
            }
            else{
              run->cputime += run->round;
              run->needtime -= run->round;  
                }
         run->state = 'W';//变为等待 
        if(ready->next != NULL)
        ready = ready->next;
        else  flag = 0;//当ready剩一个时做标记 
        if(run->needtime == 0){//当run结束时放入finish队列里 
          run->next = finish;
          finish = run;
          run->state = 'F';
          N--;//进程数少1 
          }
          else{
          if(flag){//执行完如果不是剩一个的话，就把run放到队尾 
           r->next = run;
           r = run;
           r->next = NULL; 
                 }
              }
           if(N)ready->state = 'R';//结束时不应该有'R" 
           else
           ready = NULL;//结束时应该为空 
           prt(alg);//输出 
    }
}

void FCFSrun(char alg)  //先来先服务调度算法
{  
  PCB *p;
  while(run!=NULL)
  {
    run->cputime += run->needtime;
    run->needtime =0;               
    run->next = finish;
    finish = run;
    run->state = 'F';
    run = NULL;
    if(ready!=NULL)
      firstin();
      prt(alg);
    }
  }

main()
{
      char algo;
      //clrscr();
      printf("选择算法:P/R/F(优先数算法/时间片轮转算法/先来先服务算法)\n");
      scanf("%c",&algo);
      printf("输入进程数:\n");
      scanf("%d",&N);
      if(algo == 'P'||algo == 'p')
      {
        creat1(algo);
        priority(algo);
      }
      else if(algo == 'R'||algo == 'r')
      {
        creat2(algo);
        roundrun(algo);
      }
      else if(algo=='f'||algo=='F')
      {
         creat1(algo);
         FCFSrun(algo);     
      }
     system("echo 按任意键退出");
     system("read -n 1");
     return 0;
}