实验二 进程调度

实验一 进程调度

一、 实验目的

多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

二、 实验要求

1． 设计进程调度算法，进程数不定

2． 包含几种调度算法，并加以实现

3． 输出进程的调度过程——进程的状态、链表等。

三、 参考例

1．题目——优先权法、轮转法

简化假设

1） 进程为计算型的（无I/O ）

2） 进程状态：ready 、running 、finish

3） 进程需要的CPU 时间以时间片为单位确定

2．算法描述

1） 优先权法——动态优先权

当前运行进程用完时间片后，其优先权减去一个常数。

2） 轮转法

四、 实验流程图 开始 键盘输入进程数n ，和调度方法的选择 优先权法？ 轮转法

产生n 个进程，对每个进程产生一个PCB ，并用

随机数产生进程的优先权及进程所需的CPU 时间

按优先权大小，把n 个进程拉成一个就绪队列

撤销进程就绪队列为空？

结束 N Y

Y

注意：

1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。

2．进程数n 不要太大通常取4~8个

3．使用动态数据结构

4．独立编程

5．至少三种调度算法

6．若有可能请在图形方式下，将PCB 的调度用图形成动画显示。

五．实验过程：

（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：

进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)

进程0 1 50 2

进程1 2 10 4

进程2 1 15 0

进程3 3 28 5

进程4 2 19 1

进程5 3 8 7

输出: 进程执行流等待时间，平均等待时间

本程序包括:FIFO 算法，优先数调度算法，时间片轮转调度算法

产生n

需的时间片数，已占用CPU 的时间片数置为0

按进程产生的先后次序拉成就绪队列链

=0？ 撤销该进程

就绪队列为空吗？ =轮转时间片数？

N

Y Y

Y 结束 N

（2）程序代码

#include

#include

#include

const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数

//定义进程结构体

typedef struct node

{

char name[20];

int status;

int time;

int privilege;

int finished;

int wait_time; }pcb;

pcb pcbs[MAXPCB];

int quantity;

//初始化函数

void initial()

{

int i;

for(i=0;i

{

strcpy(pcbs[i].name,"");

pcbs[i].status=0;

pcbs[i].time=0;

pcbs[i].privilege=0;

pcbs[i].finished=0;

pcbs[i].wait_time=0;

}

quantity=0;

}

//读数据函数

int readData()

{

FILE *fp;

char fname[20];

int i;

cout<<"请输入进程流文件名:";

cin>>fname;

if((fp=fopen(fname,"r"))==NULL)

{

cout<<"错误,文件打不开,请检查文件名"<

}

else

{

while(!feof(fp))

{

fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,

&pcbs[quantity].time,&pcbs[quantity].privilege);

quantity++;

} //输出所读入的数据

cout<<"输出所读入的数据"<

cout<<"进程名进程状态所需时间优先数"<

for(i=0;i

{

cout<<" "<

}

return(1);

}

return(0);

}

//重置数据,以供另一个算法使用

void init()

{

int i;

for(i=0;i

{

pcbs[i].finished=0; pcbs[i].wait_time=0;

}

}

//先进先出算法

void FIFO()

{

int i,j; int total;

//输出FIFO算法执行流

cout<

cout<<"FIFO算法执行流:"<

for(i=0;i

{

cout<<" "<

for(j=i+1;j

{ pcbs[j].wait_time+=pcbs[i].time; }

}

total=0;

for(i=0;i

{ total+=pcbs[i].wait_time; }

cout<<"总等待时间:"<

}

//优先数调度算法

void privilege()

{

int i,j,p;

int passed_time=0;

int total;

int queue[MAXPCB];

int current_privilege=1000;

for(i=0;i

{

current_privilege=1000;

for(j=0;j

{

if((pcbs[j].finished==0)&&(pcbs[j].privilege

{ p=j;

current_privilege=pcbs[j].privilege;

}

}

queue[i]=p;

pcbs[p].finished=1;

pcbs[p].wait_time+=passed_time;

passed_time+=pcbs[p].time;

}

//输出优先数调度执行流

cout<

cout<<"优先数调度执行流:"<

cout<<"进程名等待时间"<

for(i=0;i

{

cout<<" "<

}

total=0;

for(i=0;i

{ total+=pcbs[i].wait_time; }

cout<<"总等待时间:"<

}

//时间片轮转调度算法

void timer()

{

int i,j,number,flag=1;

int passed_time=0;

int max_time=0;

int round=0;

int queue[1000];

int total=0;

while(flag==1)

{

flag=0;

number=0;

for(i=0;i

{

if(pcbs[i].finished==0)

{ number++; j=i; }

}

if(number==1)

{ queue[total]=j; total++; pcbs[j].finished=1; }

if(number>1)

{

for(i=0;i

{

if(pcbs[i].finished==0)

{ flag=1;

queue[total]=i;

total++;

if(pcbs[i].time<=block_time*(round+1))

{

pcbs[i].finished=1;

}

}

}

}

round++;

}

if(queue[total-1]==queue[total-2])

{ total--; }

cout<

cout<<"时间片轮转调度执行流:"<

for(i=0;i

{

cout<

cout<

}

}

//显示

void version()

{

cout<<" /********************* 进程调度********************/";

cout<

//主函数

void main()

{

int flag;

version();

initial();

flag=readData();

if(flag==1)

{ FIFO();

init();

privilege();

init();

timer();

}

}

（3）运行结果：

输入进程流文件名1.txt即可得出以下输出结果：