进程调度算法论文优先级调度~

题目操作系统课程设计

实验一：进程调度算法

1.实验目的

通过优先权法和轮转算法的模拟加深对进程概念和进程调度过程的理解，掌握进程状态之间的切换，同时掌握进程调度算法的实现方法和技巧。2.实验内容

1）用C语言或C++语言来实现对n个进程采用优先权算法以及轮转算法的进程调度。

2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：（1）进程标识ID，其中0为闲逛进程，用户进程标识数为1，2，3…。

（2）进程优先级Priority，闲逛进程（idle）的优先级为0，用户进程的优先级大于0，且随机产生，标识数越大，优先级越高。

（3）进程占用CPU时间CPUtime，进程每运行一次，累计值等于4.

（4）进程总共需要运行时间Alltime，利用随机函数产生。

（5）进程状态，0-就绪态；1-运行态；2-阻塞态。

（6）队列指针next，用来将多个进程控制块PCB链接为队列。

3）优先数改变的原则

（1）进程在就绪队列中每呆一个时间片，优先数增加1。

（2）进程每运行一个时间片，优先数减3.

4）在调度前，系统中拥有的进程数PCB_number由键盘输入，经初始化后，所有的进程控制块PCB链接成就绪队列。

3.实验步骤

a)画出程序流程图

a)动态优先权的进程调度算法模拟流程

b)轮转法进程调度算法模拟流程

b)程序算法如下：

#include "stdafx.h"

#define NULL 0

#include

#include

#include

using namespace std;

/*进程PCB结构*/

struct PCB

{

int ID; //进程标识

int priority; //优先级

int CPUtime; // 进程占用CPU的时间

int ALLtime; // 进程总共需要运行的时间

int State; // 进程状态

struct PCB *next; // 指向下一节点的指针

};

typedef struct PCB pcb;

void init(); //产生idle进程，输入用户进程数目，

//调用insert（）

void print(PCB *pcb); //输出进程属性信息

void print_init(PCB *pcb);

void insert(); //生成进程属性信息,插入进程就绪队列

void run_priority(PCB *pcb); //运行进程,随机阻塞进程,产生新进程,插入就绪队列,唤醒阻塞进程

void run_loop(PCB *pcb); //运行进程,随机阻塞进程,产生新进程,插入就绪队列,唤醒阻塞进程

void block(PCB *pcb); //调用destroy(),将进程插入阻塞队列

void wakeup_priority(); //唤醒进程,插入就绪队列

void wakeup_loop(); //唤醒进程,插入就绪队列

void proc_priority(); //优先权调度算法模拟

void proc_loop(); //轮转法调度算法模拟

void update(PCB *pcb);//更新进程信息

PCB *ready_queue,*block_queue,*idleprocess; //就绪队列,阻塞队列及闲逛进程指针变量

int main(int argc, char* argv[])

{

int i=0;

while(1)

{

cout<<("\n Please select a number (1,2,0)");

cout<<("\n 1--priority");

cout<<("\n 2--loop");

cout<<("\n 0--exit\n");

cin>>i;

if(i==1)

{

cout<<("\nThis is an example for priority processing:\n");

init();

::proc_priority();

}

else if(i==2)

{

cout<<("\nThis is an example for round robin processing:\n");

init();

proc_loop();

}

else if(i==0)

exit(1);

}

return 0;

}

//输出所有PCB的初始值,此函数用于测试程序

void print_init(PCB *pcb)

{

PCB *temp=pcb->next ;

cout<<("\n ID priority CPUtime ALLtime

State\n");

while(temp!=NULL)

{

cout<<"\n"<<" "<ID<<" "<priority <<"

"<CPUtime <<" "<ALLtime;

if(temp->State ==0)

cout<<(" ready");

else if(temp->State ==1)

cout<<(" running");

else

cout<<(" blocked");

temp=temp->next ;

}

}

//输出进程属性信息

void print(PCB *pcb)

{

PCB *temp;

temp=pcb;

if(pcb->ID ==0)

cout<<("\n\t The idle process is running!");

else

{

cout<<"\n"<<" "<ID<<" "<priority <<" "<CPUtime <<" "<ALLtime;

if(temp->State ==0)

cout<<(" ready");

else if(temp->State ==1)

cout<<(" running");

else

cout<<(" blocked");

}

}

void insert_queue(PCB *queue,PCB *item)

{//将item插入到队列中,使得插入后队列中按照优先级从高到低有序

PCB *p,*q;

q=queue;

p=q->next ;

while(p!=0 && p->priority >= item->priority )

{

q=p;

p=p->next ;

}

if(p==0)

{//在队尾插入

item->next =0;

q->next =item;

}

else

{//在q之后,p之前插入

item->next =p;

q->next =item;

}

}

void pushback_queue(PCB *queue,PCB *item)

{//将item插入到队列尾部

PCB *p,*q;

q=queue;

p=q->next ;

while(p!=0)

{

q=p;

p=p->next ;

}

item->next =q->next ;

q->next =item;

}

//对queue中的节点进行排序,按照优先级从大到小void sort_queue(PCB *&queue)

{

PCB *temp=new PCB;

temp->next =0;

while(queue->next )

{

PCB *p;

p=queue->next ;

queue->next =p->next ;

::insert_queue (temp,p);

}

queue->next =temp->next;

delete temp;

}

//生成进程属性信息,插入进程就绪队列,显示进程信息void insert()

{

PCB *newp=0;

static long id=0;

newp=new PCB;

id++;

newp->ID =id;

newp->State =0;

newp->CPUtime =0;

newp->priority =rand()%3+1;

newp->ALLtime =rand()%3+1;

newp->next =NULL;

::pushback_queue (ready_queue,newp);//将新生成进程插入到就绪队列尾部

print(newp);

cout<<("\t建立： Creating-> ready\n");

}

//生成进程属性信息,插入进程就绪队列,显示进程信息

void insert(int n)

{

for(int i=1;i

{

insert();

}

}

//产生idle进程,输入用户进程数目,调用insert()

void init()

{

//为每个队列设立头结点,便于插入删除操作

block_queue=new PCB;

block_queue->next =0;

ready_queue=new PCB;

ready_queue->next =0;

//int i;

int pcb_number=-1;

idleprocess=NULL; //设置闲逛进程PCB各字段值

idleprocess=(PCB*)malloc(sizeof(PCB));

idleprocess->ID =0;

idleprocess->State =0;

idleprocess->CPUtime =0;

idleprocess->priority =0;

idleprocess->ALLtime =1;

idleprocess->next =NULL;

//闲逛进程放入就绪对列

idleprocess->next =ready_queue->next ;

ready_queue->next =idleprocess;

//也可假定初始时系统中只有一个idle进程

//输出初始时进程的个数

/* while(pcb_number<0)

{

cout<<("Input the number of the PCB to be started:");

cin>>pcb_number;

}

cout<<("\n ID priority CPUtime ALLtime State\n");

for(i=0;i

insert();

//insert(pcb_number);

*/

cout<<"就绪队列初始化成功！"<

::print_init (ready_queue);

cout<

}

//调用destory(),将进程插入阻塞队列

void block(PCB *pcb)

{//将pcb插入到阻塞队列

pcb->State =2; //将PCB所指进程的状态设置为阻塞

pcb->CPUtime -=2; //设进程执行半个时间片单位后被阻塞

// pcb->next =NULL;

print(pcb);

cout<<(" 变迁2：running->blocked\n");

//将pcb插入到阻塞队列

//插入方式参考唤醒条件

//因为是随机唤醒一个进程，所以简单的把它放置在阻塞队列的头部

pcb->next =block_queue->next ;

block_queue->next =pcb;

}

void update(PCB *pcb)

{//就绪队列中进程的优先级均增加1

PCB *temp=ready_queue->next ;

while(temp && temp->next )

{//就绪队列的最后一个是闲逛进程

temp->priority ++;

temp=temp->next ;

}

}

void run_priority(PCB *pcb)

{

//如果pcb是闲逛进程，则不作处理，再次放入就绪队列ready_queue

if(pcb->ID ==0)

{

::insert_queue (ready_queue,pcb);

print(pcb);

cout<<(" 变迁1：ready->running\n");

}

else

{//如果不是闲逛进程，则进行如下处理

pcb->State =1;//设置该进程的状态为“运行”

pcb->CPUtime +=4;//累计该进程占用CPU的时间

pcb->priority =pcb->priority - 3;//每运行一个时间片，其优先数减3

if(pcb->priority <1)

pcb->priority =1;

print(pcb);

cout<<(" 变迁1：ready->running\n");

if(rand()%3==1)//PCB不是闲逛进程，满足条件则阻塞此进程

{

if(pcb->CPUtime - 2 < pcb->ALLtime )

block(pcb);

else

{//已经执行完毕，应该销毁进程

cout<

cout<<"\t the process no "<ID

<<" is completed! 销毁：running->Destroy"<

delete pcb;

}

}

else

{//否则看该进程是否执行完毕，如果执行完毕，则释放，否则再次放入就绪队列

if(pcb->CPUtime >= pcb->ALLtime )

{//释放

cout<

cout<<"\t the process no "<ID

<<" is completed! 销毁：running->Destroy"<

delete pcb;

}

else

{//再次放入就绪队列，按照优先级有序

::insert_queue (ready_queue,pcb);

}

}

}

update(ready_queue);//更新就绪队列进程优先数

if(rand()%5==1)

{

insert(3);//创建3个新进程

::sort_queue (ready_queue);

}

if(rand()%7==1)

wakeup_priority(); //唤醒一个进程

//返回当前进程是否被阻塞，1（已阻塞），0（未阻塞）

}

void run_loop(PCB *pcb)

{//如果pcb是闲逛进程，则不作处理，再次放入就绪队列ready_queue

if(pcb->ID ==0)

{

::pushback_queue (ready_queue,pcb);

print(pcb);

cout<<(" 变迁1：ready->running\n");

}

else

{//如果不是闲逛进程，则进行如下处理

pcb->State =1;//设置该进程的状态为“运行”

pcb->CPUtime +=4;//累计该进程占用CPU的时间

print(pcb);

cout<<(" 变迁1：ready->running\n");

if(rand()%3==1)//PCB不是闲逛进程，满足条件则阻塞此进程

{

if(pcb->CPUtime - 2 < pcb->ALLtime )

block(pcb);

else

{//已经执行完毕，应该销毁进程

cout<

cout<<"\t the process no "<ID

<<" is completed! 销毁：running->Destroy"<

delete pcb;

}

}

else

{//否则看该进程是否执行完毕，如果执行完毕，则释放，否则再次放入就绪队列

if(pcb->CPUtime >= pcb->ALLtime )

{//释放//释放

cout<

cout<<"\t the process no "<ID

<<" is completed! 销毁：running->Destroy"<

delete pcb;

}

else

{//再次放入就绪队列

::pushback_queue (ready_queue,pcb);

}

}

}

if(rand()%5==1)

{

insert(3);//创建3个新进程

}

if(rand()%7==1)

wakeup_loop();//唤醒一个进程

//返回当前进程是否被阻塞，1（已阻塞），0（未阻塞）

}

void wakeup_priority()

{//随机唤醒一个阻塞进程

//采用遍历阻塞队列的方法，每访问一个，就产生一个随机数

//如果该随机数对20求余恰好是1，则当前节点被唤醒，就纳入就绪队列if(block_queue->next ==0)//此时没有被阻塞的进程，不需唤醒return;

PCB *p,*q;//下面遍历阻塞队列q永远指向p的前驱

while(true)

{

q=block_queue;

p=q->next ;

while(p && rand()%20!=1)

{

q=p;

p=p->next ;

}

if(p!=0)

{//p就是要唤醒的进程

q->next =p->next ;

break;

}

}

p->State =0;

cout<

::print (p);

cout<<" 变迁3：blocked->ready"<

::insert_queue (ready_queue,p)

}

void wakeup_loop()

{//随机唤醒一个阻塞进程

//采用遍历阻塞队列的方法，每访问一个，就产生一个随机数

//如果该随机数对20求余恰好是1，则当前节点被唤醒，就纳入就绪队列if(block_queue->next ==0)//此时没有被阻塞的进程，不需唤醒return;

PCB *p,*q;//下面遍历阻塞队列q永远指向p的前驱

while(true)

{

q=block_queue;

p=q->next ;

while(p && rand()%20!=1)

{

q=p;

p=p->next ;

}

if(p!=0)

{//p就是要唤醒的进程

q->next =p->next ;

break;

}

}

p->State =0;

cout<

::print (p);

cout<<" 变迁3：blocked->ready"<

::pushback_queue (ready_queue,p);

}

//优先权优先调度算法

void proc_priority()

{

::sort_queue (ready_queue);

PCB *temp=0,*running=0;//running 的PCB指针

int times;

//block_queue=NULL;

//for(times=0;times<300;times++)

for(times=0;times<10;times++)

{//找到优先级最高的进程，并将之从队列中删除

cout<<"本次调度前："<

::print_init (ready_queue);

running=ready_queue->next ;//running 指向就绪队列的队首PCB ready_queue->next =running->next ;

cout<

cout<<"本次调度开始"<

::run_priority (running);

cout<<"\n本次调度结束."<

}

}

//轮转法进程调用算法

void proc_loop()

{

PCB *temp=0,*running=0;//running 的PCB指针

int times;

//block_queue=NULL;

//for(times=0;times<300;times++)

for(times=0;times<10;times++)

{//将running 从队列中删除

cout<<"本次调度前："<

::print_init (ready_queue);

running=ready_queue->next ;//running 指向就绪队列的队首PCB

ready_queue->next =running->next ;

cout<

cout<<"本次调度开始"<

::run_loop (running);

cout<<"\n本次调度结束."<

}

}

c)写出程序并运行，运行界面如下：

选择1，进行优先权调度，得到结果如下：

选择2，进行时间片轮转调度，结果为:

选择0，退出运行界面。

4.实验过程中遇到的问题及解决方案

a)对动态优先调度算法与时间片轮转法调度算法的思想与调度过程不

是十分清楚,通过学习相关操作系统的知识得到解决.

b)对链队列的相关操作不熟悉,通过阅读相关数据结构书籍得到解决.

c)本实验中的动态优先权算法余教材中介绍的算法相比，做了简单化处

理。本算法中不考虑具有相同优先权的进程。

d)动态优先权调度算法设计思想：

(1)先按优先数大小对就绪队列结点进行排序

(2)取出队首元素，让其运行，同时其他进程的优先级增加1，

取出运行的元素优先级减3.

(3)进程若在一个时间片内运行完，则取下一个队首元素运行，

否则停止该元素的运行，插入就绪队列，再按优先级大小排

序。

(4)重复（2），（3）。

e)轮转法进程调度算法设计思想：

(1)将所有就绪进程按照到达时间的先后顺序插入队列中。

(2)取出队首元素运行一个时间片。

(3)时间片到就停止该进程的执行，并将其插入队尾。

(4)重复（2），（3）。

f)动态优先权进程调度算法适用于批处理系统。

轮转法进程调度算法适用于分时系统中，保证系统具有合理的响应时

间。

5.本实验总结

(1)进程调度的基本思想

1)当系统空闲(就绪队列为空)时,系统运行闲逛进程，否则运

行其他进程，发生变迁1（就绪->运行）。

2)在运行进程（包括闲逛进程）的过程中，可能发生变迁2（运

行->阻塞），即将运行进程插入到阻塞队列（闲逛进程不能

被阻塞），可能有其他新的进程创建PCB，还可能唤醒阻塞

队列中的某些进程PCB，发生变迁（阻塞-> 就绪），即从

阻塞队列中移出并插入就绪队列中。

3)时间片运行结束后，若进程式累计占用CPU时间大于等于进

程需要运行的时间，则进程执行结束，释放其PCB。若进程

累计占用CPU 时间小于进程需要运行时间，发生变迁4（运

行->就绪），即将当前运行的进程插入就绪队列中。

(2)通过本模拟实验可以对进程的基本调度过程有了更进一步的了解。

实验二：配置Boch虚拟机完成Minix操作系统的运行

1.实验目的

1)阅读并理解Bochs虚拟机的基本概念,成功安装Bochs虚拟机。

2)阅读Minix操作系统相关技术资料，理解Minix操作系统的安装

过程和Minix 操作系统的模块结构，实现Minix操作系统的运行。2.实验内容

1)在https://www.360docs.net/doc/5318865576.html,网站下载Bochs虚拟机软件和Minix

操作系统镜像。

2)Bochs虚拟机软件解压缩后即完成安装，在Bochs解压缩文件目录

下，bochs.exe是虚拟机可执行文件。

3)在Bochs解压缩目录下新建一个Minix204目录，将Minix操作系

统镜像文件复制到其下。

4)配置Minix操作系统的启动文件，注意设置系统环境变量BXSHARE。

5)配置Minix操作系统硬件配置文件minix.bxrc.

3.实验步骤

1)在https://www.360docs.net/doc/5318865576.html,地址下载Bochs-2.0.2虚拟机软件

Bochs-2.0.2.win32-bin.zip，大小为2.55MB，将其安装在E:\操

作系统\Minix安装\bochs-2.0.2目录下（安装目录可以是任意硬

盘分区，本处为E盘分区）；

2)下载Minix操作系统镜像Minix204.zip，大小为 6.84MB，并用

WINRAR解压缩软件解压缩镜像文件，将镜像文件复制到E:\操作系

统\Minix安装\bochs-2.0.2\minix204目录下；

3)配置Minix操作系统的启动文件E:\操作系统\Minix安装

\bochs-2.0.2\minix204\run.bat，配置内容如下：

SET BXSHARE=E:\操作系统\Minix安装\bochs-2.0.2

cd "E:\操作系统\Minix安装\bochs-2.0.2\minix204"

..\bochs -q -f minix.bxrc

4)在E:\操作系统\Minix安装\bochs-2.0.2\minix204\目录下配置

Minix操作系统硬件配置文件minix.bxrc，配置内容如下：megs: 40

romimage:file=$BXSHARE/BIOS-bochs-latest,

address=0xf0000

vgaromimage: $BXSHARE/VGABIOS-elpin-2.40

ata0-master: type=disk, path=minix.img, cylinders=200,

heads=16, spt=32

log: bochsout.txt

panic: action=ask

error: action=report

info: action=report

debug: action=ignore

ips: 1000000

mouse: enabled=0

user_shortcut: keys=ctrlaltdel