研发设计1进程调度算法模拟.docx

研发设计1进程调度算法模拟.docx

《研发设计1进程调度算法模拟.docx》由会员分享，可在线阅读，更多相关《研发设计1进程调度算法模拟.docx（50页珍藏版）》请在冰豆网上搜索。

研发设计1进程调度算法模拟

设计1进程调度算法的模拟

一、设计目的

1、通过编程实现进程调度算法的模拟，了解进程调度的过程，理解进程调度各方法的特点。

二、设计要求

1．用语言来实现对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链接成就绪队列。

聞創沟燴鐺險爱氇谴净。

三、设计说明

1FCFS模块

1.1功能

对于先到达的进程优先分配CPU，按照先来先服务的原则依次执行各进程。

1.2数据结构

typedefstructPCB

{

intID;//进程优先数,用于标示不同的进程

intPriority;//进程优先级

intCPUTime;//进程占用的CPU时间CPUtime，进程每运行一次，累计值等于4

intALLTime;//进程总共需要运行时间Alltime

intStatus;//用于表示进程状态，0：

就绪态；1：

运行态；2：

阻塞态

}PCB;

1.3算法

voidFCFS（）

{

Node*p=head->next;

while（p!

=NULL）

{

cout<<"执行进程"<data.ID;

p=p->next;

}

cout<

cout<<"所有进程都执行完成"<

}

2.SJF模块

2.1功能

先找到运行时间最短的程序，然后执行，再从剩余的程序中找到运行时间最短的在执行，依次每次都执行运行时间最短的，直到程序执行完毕。

残骛楼諍锩瀨濟溆塹籟。

2..2数据结构

typedefstructPCB

{

intID;//进程优先数,用于标示不同的进程

intPriority;//进程优先级

intCPUTime;//进程占用的CPU时间CPUtime，进程每运行一次，累计值等于4

intALLTime;//进程总共需要运行时间Alltime

intStatus;//用于表示进程状态，0：

就绪态；1：

运行态；2：

阻塞态

}PCB;

2.3算法

voidSJF（）

{

Node*p;

Node*pmin;

while（head2->next!

=NULL）

{

pmin=head2->next;

for（p=head2->next;p!

=NULL;p=p->next）

{

if（pmin->data.ALLTime>p->data.ALLTime）

pmin=p;

}

cout<<"执行剩余区间长度最短的进程"<data.ID;

for（p=head2;p!

=NULL;p=p->next）

{

if（p->next==pmin）

{

p->next=p->next->next;

free（pmin）;

}

}

}

printf（"\n"）;

printf（"所有进程都执行完成。

\n\n"）;

}

3SearchMaxPRI模块

3.1功能

按照优先级从高到低依次执行程序

3.2数据结构

q0指向q的前一个进程，便于删除进程；p返回优先级最大进程；q用于遍历链表

3.3算法

voidSearchMaxPRI（intm）

{

Node*p=head->next;

Node*q=head->next;

Node*q0=head;

while（q!

=NULL）

{

if（q->data.ALLTime==0）

{

cout<<"进程已执行完成"<data.ID;

n--;

q0->next=q0->next->next;

free（q）;

q=q0->next;

}

else

{

if（q->data.Priority>p->data.Priority）

p=q;

q0=q0->next;

q=q->next;

}

}

if（n>0）

action（p）;

}

©

按照轮转的次序分配给每个程序一定的时间执行，执行完成后执行后面的进程，依次循环执行直到所有进程执行完成。

酽锕极額閉镇桧猪訣锥。

4.2数据结构

4.3算法

voidRR（intm）

{

Node*p;

while（head1->next!

=NULL）

{

p=head1->next;

Node*prep=head1;

Node*q;

while（p!

=NULL）

{

cout<<"执行进程一个时间片"<data.ID;

for（q=head1;q->next!

=NULL;q=q->next）

{

if（q->next==p）

{

p->data.ALLTime-=4;

p->data.CPUTime+=4;

}

}

if（p->data.ALLTime<=0）

{

cout<<"进程已执行完成"<data.ID;

prep->next=prep->next->next;

free（p）;

p=prep->next;

}

else

{

prep=prep->next;

p=p->next;

}

}

cout<

cout<<"进入下一次轮转"<

}

cout<<"所有进程都执行完成"<

}

四、运行结果及分析

该程序实现了进程调度的四种不同调度算法下的调度顺序的输出情况。

五、总结

通过该程序的实现，对进程的调度有了更多的了解，对于不同的系统和系统目标，通常采用不同的调度算法。

有的算法适用于为数众多的短作业调度，有的算法为系统合理的响应时间提供了保证。

调度算法的选择的合适与否很重要。

彈贸摄尔霁毙攬砖卤庑。

源代码：

#include

#include

#include

#include

#include

#defineTRUE1

#defineFALSE0

#defineOK1

typedefstructPCB

{

intID;

intPriority;

intCPUTime;

intALLTime;

intStatus;

}PCB;

typedefPCBDt;

typedefstructNode

{

Dtdata;

structNode*next;

}Node;

Node*head=（Node*）malloc（sizeof（Node））;

Node*head1=（Node*）malloc（sizeof（Node））;

Node*head2=（Node*）malloc（sizeof（Node））;

intn;

voidcreate（intn）

{

inti=1;

srand（（int）time（0））;

head->next=NULL;

Node*q=head;

cout<<"优先数优先级CPUTimeAllTimeStatus"<

while（i<=n）

{

Node*p=（Node*）malloc（sizeof（Node））;

p->data.ID=i;

p->data.CPUTime=0;

p->data.Status=0;

p->data.Priority=rand（）%10+1;

p->data.ALLTime=rand（）%8+1;

cout<<""<data.ID<<""<data.Priority<<""<<厦礴恳蹒骈時盡继價骚。

p->data.CPUTime<<""<data.ALLTime<<""<data.Status<

p->next=NULL;

q->next=p;

q=q->next;

i++;

}

Node*p0=head1;

head1->next=NULL;

for（q=head->next;q!

=NULL;q=q->next）

{

Node*r=（Node*）malloc（sizeof（Node））;

r->data.ID=q->data.ID;

r->data.CPUTime=q->data.CPUTime;

r->data.Status=q->data.Status;

r->data.Priority=q->data.Priority;

r->data.ALLTime=q->data.ALLTime;

p0->next=r;

r->next=NULL;

p0=p0->next;

}

Node*p1=head2;

head2->next=NULL;

for（q=head->next;q!

=NULL;q=q->next）

{

Node*k=（Node*）malloc（sizeof（Node））;

k->data.ID=q->data.ID;

k->data.CPUTime=q->data.CPUTime;

k->data.Status=q->data.Status;

k->data.Priority=q->data.Priority;

k->data.ALLTime=q->data.ALLTime;

p1->next=k;

k->next=NULL;

p1=p1->next;

}

}

voidFCFS（）

{

Node*p=head->next;

while（p!

=NULL）

{

cout<<"执行进程"<data.ID;

p=p->next;

}

cout<

cout<<"所有进程都执行完成"<

}

voidSJF（）

{

Node*p;

Node*pmin;

while（head2->next!

=NULL）

{

pmin=head2->next;

for（p=head2->next;p!

=NULL;p=p->next）

{

if（pmin->data.ALLTime>p->data.ALLTime）

pmin=p;

}

cout<<"执行剩余区间长度最短的进程"<data.ID;

for（p=head2;p!

=NULL;p=p->next）

{

if（p->next==pmin）

{

p->next=p->next->next;

free（pmin）;

}

}

}

cout<

cout<<"所有进程都执行完成"<

}

voidaction（Node*p）

{

Node*q=head->next;

while（q!

=NULL）

{

cout<data.ID<<"执行一个时间片的进程"<

if（q!

=p）

q->data.Priority=q->data.Priority+1;

else

{

q->data.Priority=q->data.Priority-3;

if（q->data.ALLTime>4）

q->data.ALLTime-=4;

else

q->data.ALLTime=0;

q->data.Status=1;

}

q=q->next;

}

}

voidSearchMaxPRI（intm）

{

Node*p=head->next;

Node*q=head->next;

Node*q0=head;

while（q!

=NULL）

{

if（q->data.ALLTime==0）

{

cout<data.ID<<"进程已执行完成"<

n--;

q0->next=q0->next->next;

free（q）;

q=q0->next;

}

else

{

if（q->data.Priority>p->data.Priority）

p=q;

q0=q0->next;

q=q->next;

}

}

if（n>0）

action（p）;

}

voidRR（intm）

{

Node*p;

while（head1->next!

=NULL）

{

p=head1->next;

Node*prep=head1;

Node*q;

while（p!

=NULL）

{

cout<data.ID<<"执行进程一个时间片"<

for（q=head1;q->next!

=NULL;q=q->next）

{

if（q->next==p）

{

p->data.ALLTime-=4;

p->data.CPUTime+=4;

}

}

if（p->data.ALLTime<=0）

{

cout<data.ID<<"进程已执行完成"<

prep->next=prep->next->next;

free（p）;

p=prep->next;

}

else

{

prep=prep->next;

p=p->next;

}

}

cout<

cout<<"进入下一次轮转"<

}

cout<<"所有进程都执行完成"<

}

intmain（）

{

cout<<"请输入系统进程数：

"<

cin>>n;

intm=n;

if（n==0）

cout<<"此时没有就绪进程"<

else

{

create（n）;

cout<

cout<<"先来先服务调度"<

FCFS（）;

cout<

cout<<"最短作业优先调度"<

SJF（）;

cout<

cout<<"优先权的分时调度"<

while（head->next!

=NULL）

{

SearchMaxPRI（m）;

}

cout<<"所有进程都执行完成"<

cout<

cout<<"轮转法调度"<

RR（m）;

}

}

设计2模拟银行家算法

一、设计目的

1、通过对银行家算法的模拟，理解银行家算法的实现过程，了解系统解决死锁的方法

二、设计要求

1、编程序模拟银行家算法

2、能体现算法的全过程

三、设计说明

1.bank模块

1.1功能

利用银行家算法，给系统分配资源，避免死锁。

1.2数据结构

TypedefstructRESOURCE

{

intavailable[R];//系统可用资源数

intallocation[W][R];//M个进程已经得到N类资源的资源量

intneed[W][R];//M个进程还需要N类资源的资源量

intrequest[R];//请求资源个数

}RESOURCE

1.3算法

{

inti=0,j=0;

charchoice='Y';

while（choice=='Y'||choice=='y'）

{

i=-1;

while（i<0||i>=M）

{

cout<

";

cin>>i;

if（i<0||i>=M）cout<<"进程号不存在，重新输入!

"<

}

cout<<"请输入进程"<

"<

for（j=0;j

{

cout<<"资源"<

";

cin>>request[j];

if（request[j]>need[i][j]）

{

cout<

";鹅娅尽損鹌惨歷茏鴛賴。

cout<<"若继续执行系统将处于不安全状态!

"<

choice='N';

break;

}

else

{

if（request[j]>available[j]）

{

cout<

";籟丛妈羥为贍偾蛏练淨。

cout<<"继续执行系统将处于不安全状态!

"<

choice='N';

break;

}

}

}

if（choice=='Y'||choice=='y'）

{

distribute（i）;

if（check（））

{

restore（i）;

print（）;

}

else

print（）;

}

else

cout<

cout<<"是否继续银行家算法演示？

Y/N";

cin>>choice;

}

}

2.check模块

2.1功能

检查资源分配后系统是否处于安全状态。

2.2数据结构

TypedefstructRESOURCE

{

intavailable[R];//系统可用资源数

intallocation[W][R];//M个进程已经得到N类资源的资源量

intneed[W][R];//M个进程还需要N类资源的资源量

intrequest[R];//请求资源个数

}RESOURCE

2.3算法

{

intwork[R],finish[W];

inti,j;

for（j=0;j

for（i=0;i

for（i=0;i

{

for（j=0;j

{

if（finish[i]==FALSE&&need[i][j]<=work[j]）

{

work[j]=work[i]+allocation[i][j];

}

}

finish[i]=TRUE;

}

for（i=0;i

{

if（finish[i]==FALSE）

{

cout<

cout<<"系统不安全!

资源申请失败!

"<

cout<

return1;

}

else

{

cout<<"系统安全，分配成功!

"<

return0;

}

}

}

四、运行结果及分析

通过实验结果可知银行家算法中，当进程申请的资源大于声明所需的最大资源或者大于系统当前可用的资源时，系统将处于不安全状态，资源分配失败，从而防止了死锁的产生。

預頌圣鉉儐歲龈讶骅籴。

五、总结

通过该算法的模拟可知银行家算法是一种最有代表性的避免死锁的算法。

在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。

为实现银行家算法，系统必须设置若干数据结构。

渗釤呛俨匀谔鱉调硯錦。

源代码：

#include

#include

#include

#defineFALSE0

#defineTRUE1

#defineW10

#defineR10

intallresource[W];

intmax[W][R];

intavailable[R];

intallocation[W][R];

intneed[W][R];

intrequest[R];

intM;

intN;

voidprint（）

{

inti,j;

cout<<"各种资源总量:

"<

for（j=0;j

cout<<"资源"<

"<

cout<<"目前各种资源可利用数量:

"<

for（j=0;j

cout<<"资源"<

"<

cout<<"各进程还需要的资源数量:

"<

cout<<"resourceA"<<"resourceB"<<"resourceC"<

for（i=0;i

{

cout<<"进程"<

";

for（j=0;j

cout<

cout<

}

cout<<"各进程已经得到的资源量:

"<

cout<<"resourc