【操作系统】进程优先权调度算法

【实验目的】

①理解有关进程控制块、进程队列的概念。

②掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。

 【实验内容】

①设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。

②建立进程就绪队列。

③编制两种进程调度算法：优先权调度和时间片轮转调度。

【实验步骤】

1.1 数据结构Struct pcb

{

int nam；//进程名

int priority；//优先权

int cputime；//CPU运行时间

int needtime；//进程运行所需时间

int count；//进程执行次数

int round；//时间片轮转轮次

state process；//进程状态

pcb*next;

}；

                               

1.2 程序流程图

 

1.3 实验代码

#include<stdio.h>

#include <dos.h>

#include<stdlib.h>

#include<conio.h>

#include<iostream>

#define P_NUM 5

#define P_TIME 50

enum state{

        ready,

        execute,

        block,

        finish

};

 

struct pcb

{

        int name;

        int priority;

        int cputime;

        int needtime;

        int count;

        int round;

        state process;

        pcb * next;

};

 

pcb * get_process()

{

        pcb *q;

        pcb *t;

        pcb *p;

        int i=0;

        printf("input name and time\n");

        while (i<P_NUM)

        {

                 q=(struct pcb *)malloc(sizeof(pcb));

                 scanf("%d",&q->name);

                 scanf("%d",&q->needtime);

                 q->cputime=0;

                 q->priority=P_TIME-q->needtime;

                 q->process=ready;

                 q->next=NULL;

                 if (i==0){

                         p=q;

                         t=q;

                 }

                 else{

                         t->next=q;

                         t=q;

                 }

                 i++;

        } //while

        return p;

}

 

void display(pcb *p)

{

                 printf("name\t");

                 printf("cputime\t");

                 printf("needtime\t");

                 printf("priority\t");

                 printf("state\n");

        while(p)

        {

                 printf("%d\t",p->name);

                 printf("%d\t",p->cputime);

                 printf("%d\t\t",p->needtime);

                 printf("%d\t\t",p->priority);

                 switch(p->process){

                         case ready:printf("ready\n");break;

                         case execute:printf("execute\n");break;

                         case block:printf("block\n");break;

                         case finish:printf("finish\n");break;

                 }

                 p=p->next;

        }

}

 

int process_finish(pcb *q)

{

        int bl=1;

        while(bl&&q)

        {

                 bl=bl&&q->needtime==0;

                 q=q->next;

        }

        return bl;

}

 

void cpuexe(pcb *q)

{

        pcb *t=q;

        int tp=0;

        while(q){

                 if (q->process!=finish)

                 {

                         q->process=ready;

                         if(q->needtime==0)

                         {

                                  q->process=finish;

                         }

                 }

                 if(tp<q->priority&&q->process!=finish)

                 {

                         tp=q->priority;

                         t=q;

                 }

                 q=q->next;

        }

        if(t->needtime!=0)

        {

                 t->priority-=3;

                 t->needtime--;

                 t->process=execute;

                 t->cputime++;

        }

}

 

void priority_cal()

{

        pcb * p;

        system("cls");

        p=get_process();

        int cpu=0;

        system("cls");

        while(!process_finish(p))

        {

                 cpu++;

                 printf("\ncpu运行时间:%d\n",cpu);

                 cpuexe(p);

                 display(p);

        }

        printf("\nAll processes have finished,press any key to exit\n");

        getch();

}

 

void display_menu()

{

        printf("选择相应算法:\n");

        printf("1 优先级调度算法\n");

        printf("2 时间片轮转算法\n");

        printf("3 退出\n");

}

 

pcb * get_process_round()

{

        pcb *q;

        pcb *t;

        pcb *p;

        int i=0;

        printf("输入名字与时间\n");

        while (i<P_NUM)

        {

                 q=(struct pcb *)malloc(sizeof(pcb));

                 scanf("%d",&q->name);

                 scanf("%d",&q->needtime);

                 q->cputime=0;

                 q->round=0;

                 q->count=0;

                 q->process=ready;

                 q->next=NULL;

                 if (i==0){

                 p=q;

                 t=q;

                }

                 else{

                 t->next=q;

                 t=q;

                 }

                 i++;

        } //while

        return p;

}

 

void cpu_round(pcb *q)

{

        q->cputime+=2;

        q->needtime-=2;

        if(q->needtime<0)

        {

                 q->needtime=0;

        }

        q->count++;

        q->round++;

        q->process=execute;

 

}

 

pcb * get_next(pcb * k,pcb * head)

{

        pcb * t;

        t=k;

        do

        {

                 t=t->next;

        }

        while (t && t->process==finish);

        if(t==NULL)

        {

                 t=head;

                 while (t->next!=k && t->process==finish)

                 {

                         t=t->next;

                 }

        }

        return t;

}

void set_state(pcb *p)

{

        while(p)

        {

                 if (p->needtime==0)

                 {

                         p->process=finish;

                 }

                

                 if (p->process==execute)

                 {

                         p->process=ready;

                 }

                 p=p->next;

        }

}

       

        void display_round(pcb *p)

        {

                 printf("name\t");

                 printf("cputime\t");

                 printf("needtime\t");

                 printf("priority\t");

                 printf("state\n");

                 while(p)

                 {

                         printf("%d\t",p->name);

                         printf("%d\t",p->cputime);            

                         printf("%d\t\t",p->needtime);

                         printf("%d\t\t",p->priority);

                         switch(p->process)

                         {

                                  case ready:printf("ready\n");break;

                                  case execute:printf("execute\n");break;

                                  case finish:printf("finish\n");break;

                         }

                 p=p->next;

                 }

        }

 

void round_cal()

{

        pcb * p;

        pcb * r;

        system("cls");

        p=get_process_round();

        int cpu=0;

        system("cls");

        r=p;

        while(!process_finish(p))

        {

                 cpu+=2;

                 cpu_round(r);

                 r=get_next(r,p);

                 printf("cpu:%d\n",cpu);

                 display_round(p);

                 set_state(p);

        }

}

 

int main()

{

        display_menu();

        int k;

        scanf("%d",&k);

        switch(k)

        {

                 case 1:priority_cal();break;

                 case 2:round_cal();break;

                 case 3:break;

                 display_menu();

                 scanf("%d",&k);

        }

}

 

1.4 实验结果

优先级调度算法

时间片轮转算法

【实验结果分析】

1.  该实验利用进程调度中的优先级算法调度进程，开始给每一个进程设定一个优先级数，对于优先级高的进程先调度，优先级低的进程后调度。

2.  时间片轮转：划分成一个时间片，就绪队列中的进程轮流运行一个时间片。当时间片结束时，进程让出CPU，等待下一次调度。

【实验体会总结】

1.     通过这个实验学会了用优先级调度算法：从就绪队列中选择一个优先权最高的进程，让其获得CPU执行，非抢占式，就是会一直执行下去，抢占式：如果有个优先级高的，会执行这个，原来的被迫退出cpu。

2.     头文件要引用正确，合理，int 和void  void是个无参的函数。