OS(A)之进程调度模拟算法

进程调度模拟算法

一、实验目的

    进程调度是处理机管理的核心内容。本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。

二、实验内容

    1.设计进程控制块PCB 的结构，通常应包括如下信息：

        进程名、进程优先数（或轮转时间片数）、进程已占用的CPU 时间、进程到完成还需要的时间、进程的状态、当前队列指针等。

    2.编写两种调度算法程序：

        优先数调度算法程序

        循环轮转调度算法程序

    3.按要求输出结果。

三、实验过程

（一）进程控制块结构如下：

       NAME——进程标示符

       PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）

       CPUTIME——进程累计占用CPU 的时间片数

       NEEDTIME——进程到完成还需要的时间片数

       STATE——进程状态

       NEXT——链指针

     注：1. 为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；

            2. 各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。

（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：

       RUN——当前运行进程指针

       READY——就需队列头指针

       TAIL—— 就需队列尾指针

       FINISH—— 完成队列头指针

（三）程序说明

       1. 在优先数算法中，进程优先数的初值设为：

              50-NEEDTIME每执行一次，优先数减1，CPU 时间片数加1，进程还需要的时间片数减1。

              在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。

       2. 程序的模块结构提示如下：

              整个程序可由主程序和如下7 个过程组成：

              （1）INSERT1——在优先数算法中，将尚未完成的PCB 按优先数顺序插入到就绪队列中；

              （2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；

              （3）FIRSTIN——调度就绪队列的第一个进程投入运行；

              （4）PRINT——显示每执行一次后所有进程的状态及有关信息。

              （5）CREATE——创建新进程，并将它的PCB 插入就绪队列；

              （6）PRISCH——按优先数算法调度进程；

              （7）ROUNDSCH——按时间片轮转法调度进程。

       主程序定义PCB 结构和其他有关变量。

（四）运行和显示

       程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIME 值。

       每次显示结果均为如下5 个字段：

       name cputime needtime priority state

      注： 1．在state 字段中，"R"代表执行态，"W"代表就绪（等待）态，"F"代表完成态。

              2．应先显示"R"态的，再显示"W"态的，再显示"F"态的。

              3．在"W"态中，以优先数高低或轮转顺序排队；在"F"态中，以完成先后顺序排队。

四、实验结果

   • 上机调试

 

 

 

 

 

 

 

 

   • 遇到的主要问题和解决方法

        在利用指针处理时很困难，也经历了很艰难的过程，实验中设计了结构指针用来指向PCB结构，PCB结构中又有链表指针。

五、实验总结

        通过本次试验对优先数调度算法和时间片轮转调度算法实现的过程，有了很清楚的认识、理解。随后通过设计PCB结构，模拟进程调度，加深了对进程的理解。

六、源代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include<windows.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;/*指向三个队列的队首的指针，
                                finish为完成队列头指针，
                                ready为就绪队列头指针，                                
                                tail为就绪队列的队尾指针，
                                run为当前运行进程头指针*/

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


void firstin(void);                //调度就绪队列的第一个进程投入运行；
 void print1(char a);            //打印表头行信息
void print2(char chose,PCB *p);    //打印每一行的状态信息
void print(char chose);            //打印每执行一次算法后所有的进程的状态信息
void insert_prio(PCB *q);        //在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中；        
void prior_init(char chose);    //进程优先级法初始化将进程按优先级插入到就绪队列里                                
void priority(char chose);        //进程优先级算法总函数
void insert_rr(PCB *q);            //在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；                                
void roundrun_init(char chose);    //循环轮转法初始化将就绪队列保存为FIFO队列                                
void roundrun(char chose);        //循环轮转法总算法





void main()//主函数
{
        char chose=' ';
        while((chose!='q')&&(chose!='Q'))
    {
            fflush(stdin);
            printf("选择进程优先级算法请输入P，选择循环轮转算法请输入R，退出请输入Q
");
            printf("请输入你的选择：");
            scanf("%c",&chose);
            if((chose!='q')&&(chose!='Q'))
        {
                system("cls");
                if((chose=='P')||(chose=='p'))
            {
                    
                    prior_init(chose);
                    priority(chose);
                    system("cls");
            } 
   
                else if((chose=='r')||(chose=='R'))
            {
                            
                    roundrun_init(chose);
                    roundrun(chose);
                    system("cls");
   
            }
        }
    }
        printf("谢谢使用！
");
}

void firstin(void)//调度就绪队列的第一个进程投入运行；
{
    if(ready!=NULL)
    {
     run=ready;
     ready=ready->next;
     run->state='R';
     run->next=NULL;
   }
   else
   {
     run=NULL;
     
   }
   
}








void print1(char a)//打印表头行信息
{
if(toupper(a)=='P')
{
printf("name  cputime  needtime priority state 
");
}
else
{
printf("name  cputime  needtime count round state 
"); 
}    
}








void print2(char chose,PCB *p)//打印每一行的状态信息
{
if(toupper(chose)=='P')
{
   printf("%s	%d	%d	%d	%c
",p->name,p->cputime,p->needtime,p->prio,p->state);
   
}
else
{
printf("%s	%d	%d	%d	%d	%c
",p->name,p->cputime,p->needtime,p->count,p->round,p->state);
}
}
void print(char chose)//打印每执行一次算法后所有的进程的状态信息
{
PCB *p;
print1(chose);
if(run!=NULL)
{
print2(chose,run);
}

p=ready;
while(p!=NULL)
{
   print2(chose,p);
   p=p->next;
}

p=finish;
while(p!=NULL)
{
print2(chose,p);
p=p->next;
}

}
void insert_prio(PCB *q)/*在优先数算法中,将尚未
                        完成的PCB按优先数顺序插入到就绪队列中；*/
{
PCB *p,*s,*r; /*p,r用来控制就绪队列滚动，S指向插入的队列*/
 
s=q;
p=ready;
r=p;

if(s->prio>ready->prio)// 要插入的进程的优先级大于ready的优先级
{
   s->next=ready;
ready=s;          
}
else//要插入的进程的优先级不大于ready的优先级
{
   while(p)
   {
        if(p->prio>=s->prio)
    {
        r=p;
        p=p->next;
    }
        else
            break;
    
   } //找到要插入的位置
s->next=p;
r->next=s;
}
}



void prior_init(char chose)/*进程优先级法初始化
                        将进程按优先级插入到就绪队列里*/
{
            PCB *p;
            int i,time;
            char na[10];
            ready=NULL;
            finish=NULL;
            run=NULL;
            printf("输入进程 的个数 N:
");
            scanf("%d",&N);
for(i=0;i<N;i++)
{
p=(PCB*)malloc(sizeof(PCB));
   printf("输入第%d个进程名
",i+1);
scanf("%s",na);
   printf("完成进程需要的时间片数
");
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='W';
p->prio=50-time;//设置进程优先值初值

if(ready==NULL)
{
   ready=p;
   ready->next=NULL;
}
else
{
    insert_prio(p);
}
printf("当前就绪队列的进程的信息
");
print(chose);
}
printf("%d个进程已按优先级从高到低进到就绪队列中
",N);
                    printf("按回车键开始模拟优先级算法.....
");
                    fflush(stdin);
                    getchar();
firstin();
}
void priority(char chose)//进程优先级算法总函数
{
    int i=1;

while(run!=NULL)
{
    run->cputime+=1;
    run->needtime-=1;
    run->prio-=1;
if(run->needtime==0)
{
      run->next=finish;
      finish=run;
      run->state='F';
      run->prio=0;
      run=NULL;
      firstin();        
}
else
{
     if((ready!=NULL)&&(run->prio<ready->prio))
     {
        run->state='W';
        insert_prio(run);
        run=NULL;
        firstin();
     }
}


   print(chose);
   
   
}

getchar();
}
void insert_rr(PCB *q)//在轮转法中，将执行了一个时间片单位（为2），
                    //但尚未完成的进程的PCB，插到就绪队列的队尾；
{
    tail->next=q;
    tail=q;
    q->next=NULL;
}
void roundrun_init(char chose)/*循环轮转法初始化
                              将就绪队列保存为FIFO队列*/
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
    printf("		循环轮转算法模拟全过程

");
                    printf("输入进程 的个数 N:
");
                    scanf("%d",&N);
for(i=0;i<N;i++)
{
p=(PCB*)malloc(sizeof(PCB));
   printf("输入第%d个进程名
",i+1);
scanf("%s",na);
   printf("完成进程需要的时间片数
");
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)
{
insert_rr(p);
}
else
{
    p->next=ready;
    ready=p;
    tail=p;
}
printf("当前就绪队列的进程的信息
");
print(chose);
}
    printf("%d个进程已按FIFO进到就绪队列中
",N);
                    printf("按回车键开始模循环轮转算法.....
");
                    fflush(stdin);
                    getchar();
run=ready;
ready=ready->next;
run->state='R';
     
}
void roundrun(char chose)//循环轮转法总算法
{
    int i=1;
while(run!=NULL)
{
run->cputime+=1;
run->needtime-=1;
run->count+=1;
if(run->needtime==0)
{
    run->next=finish;
   finish=run;
   run->state='F';
   run->prio=0;
   run=NULL;
   if(ready!=NULL)
   {
      firstin();
    }         
   }
   else
   {
     if(run->count==run->round)
     {
     run->count=0; 
     if(ready!=NULL)
   {        
      run->state='W';
      insert_rr(run);
      firstin();
   }
    }
   }
  
   print(chose);
   
   
}
getchar();

}