F操作系统实验报告.docx

F操作系统实验报告.docx

《F操作系统实验报告.docx》由会员分享，可在线阅读，更多相关《F操作系统实验报告.docx（59页珍藏版）》请在冰豆网上搜索。

F操作系统实验报告

操作系统实验报告

专业：

网络工程

班级：

1020552

学号：

102055211

姓名：

赫前进

日期：

2012/12/27

实验一进程控制和调度

一、实验目的

用高级语言编写和调试进程调度的模拟程序，以加深对进程调度算法的理解。

二、实验内容

1.自定义进程相关的数据结构；

2.利用MFC类库中的栈（queue），链表（list），向量（vector）等模板模拟进程控制块队列、进程控制块优先级队列、统计信息链表及其指令集合；

3.利用MSDN和MFCAPI编程实现常见的进程控制和调度策略（先来先服务算法、时间片轮转算法、最高优先权优先调度算法、最短进程优先调度算法）；

4.测试以上进程调度策略的周转时间、带权周转时间、平均周转时间和平均带权周转时间，并定性评价它们的性能。

三、实验步骤

#include

#include

#include

#include

#include

#include

intproc;

intpiece;//完成状态

#defineFINISH0//运行状态

#defineRUNNING1//就绪状态

#defineREADY2//io状态

#defineIO3//等待IO

#defineWAIT4//定义PCB结构

typedefstructtagPCBS{//编号

longpid;//进程名

charpname[10];//状态

intpstate;//总时间

intpneedtime;//开始时间

intpiostarttime;//需要时间

intpioneedtime;//当前时间

intptime;//优先级

intpriority;

}pcbs,*ppcbs;

classpcbnode;//队列结点

classpcbnode

{

public:

pcbs*pcb;

pcbnode*link;

pcbnode（）;

~pcbnode（）;

intrun（）;//运行操作

intrunend（）;//运行结束

voidrunio（）;//IO操作

intioend（）;//io结束

intinsertnode（pcbnode*p,pcbnode*q）;//在q后插入结点p

intdeletenode（pcbnode*p,pcbnode*q）;//删除p结点，q为p的前驱

intaddnode（pcbnode*p）;//增加结点

intpcbnode:

:

isio（）;//是否开始IO

};

pcbnode:

:

pcbnode（）{

pcb=0;

link=0;}

pcbnode:

:

~pcbnode（）

{

if（link）

deletelink;

if（pcb）

pcb->pstate=FINISH;

}

intpcbnode:

:

run（）

{

pcb->pstate=RUNNING;

++pcb->ptime;//优先级降低

pcb->priority--;

return0;

}

intpcbnode:

:

runend（）

{

return（pcb->pneedtime<=pcb->ptime）;

}

intpcbnode:

:

isio（）

{

return（（pcb->piostarttime==pcb->ptime）&&（pcb->pioneedtime>0））;

}

intpcbnode:

:

ioend（）

{

return（（pcb->pioneedtime）<=0）;

}

voidpcbnode:

:

runio（）

{

pcb->pstate=IO;

--（pcb->pioneedtime）;

}

intpcbnode:

:

addnode（pcbnode*p）

{

pcbnode*q;

q=this;

p->pcb->pstate=READY;

while（q->link）

q=q->link;

q->link=p;

return0;

}

intpcbnode:

:

insertnode（pcbnode*p,pcbnode*q）

{

p->link=q->link;

q->link=p;

return0;

}

intpcbnode:

:

deletenode（pcbnode*p,pcbnode*q）

{

q->link=p->link;

p->link=0;

return0;

}

intrandInt（intseed）

{

intr;

r=rand（）;

while（（r>seed）||（r<0））

r=rand（）;

returnr;

}

voidnewpcb（pcbs*pcb,intorder）//随机生成进程

{

charbuf[10];

pcb->pid=order;

strcpy（pcb->pname,"proc"）;

itoa（order,buf,10）;

strcat（pcb->pname,buf）;

pcb->pneedtime=randInt（10）;

pcb->piostarttime=randInt（pcb->pneedtime）;

pcb->pioneedtime=randInt（10）;

pcb->ptime=0;

pcb->priority=randInt（10）;

}

voidpprint（pcbs*pcb,intcount）

{

inti;//打印进程状态

cout<<"进程号|进程名|状态|需求量|系统分配|需要分配|运行时间|优先级"<

for（i=0;i

{

cout<

switch（pcb[i].pstate）

{

caseIO:

cout<<"IO";

break;

caseRUNNING:

cout<<"运行中";

break;

caseREADY:

cout<<"就绪";

break;

caseFINISH:

cout<<"完成";

break;

caseWAIT:

cout<<"等待";

break;

}

cout<<'\t'<

cout<<'\t'<

cout<<'\t'<

cout<

}

cout<<"---------------------------------------------"<

}

//时间片轮循法

voidpoll（pcbs*pcb,intpcbsnum）

{

pcbnoderunning,ready,blocked;

pcbnode*p;

pcbnode*q;

cout<<"输入时间片长度：

"<

cin>>piece;

inti;

for（i=0;i

{

p=newpcbnode;

p->pcb=pcb+i;

ready.addnode（p）;

}

//开始调度

while（ready.link||running.link||blocked.link）

{

if（running.link）

{//需要IO?

if（running.link->isio（））

{

blocked.addnode（running.link）;

running.link->pcb->pstate=WAIT;

}

//运行结束?

elseif（running.link->runend（））

{

p=running.link;

running.link=0;

deletep;

}

//调度

else

{

ready.addnode（running.link）;

running.link->pcb->pstate=READY;

}

running.link=0;

}

q=&ready;

p=ready.link;

if（ready.link）

{

ready.deletenode（p,q）;

running.addnode（p）;

p->pcb->pstate=RUNNING;

}

p=blocked.link;

q=&blocked;

if（p）

{

intr;

r=p->ioend（）;

if（r）

{

blocked.deletenode（p,q）;

ready.addnode（p）;

p=q->link;

}

}

intj=piece;

while（j--）

{

p=running.link;

q=&running;

if（p）

{

//isIOstart?

if（!

（p->isio（）））

p->run（）;//RUN

}

p=blocked.link;

q=&blocked;

if（p）

p->runio（）;

//printprocstate

pprint（pcb,pcbsnum）;

}

}

}

//可抢占的优先调度

voidpriority（pcbs*pcb,intpcbsnum）

{

pcbnoderunning,ready,blocked;

pcbnode*p,*f,*front;

pcbnode*q;

inti;

/*将进程表中的进程加到就绪队列中*/

for（i=0;i

{

p=newpcbnode;

p->pcb=pcb+i;

ready.addnode（p）;

}

while（ready.link||running.link||blocked.link）

{

//判断将运行队列中的进程是否要io或结束

if（running.link）

{

//需要IO?

if（running.link->isio（））

{

blocked.addnode（running.link）;

running.link->pcb->pstate=WAIT;

running.link=0;

}

//运行结束?

elseif（running.link->runend（））

{

p=running.link;

running.link=0;

deletep;

}

}

//寻找最大的一个优先级

p=ready.link;

q=p;

f=&ready;

front=f;

if（p）

{

intmaxpri=p->pcb->priority;

while（p）

{

if（p->pcb->priority>maxpri）

{

maxpri=p->pcb->priority;

front=f;

q=p;

}

f=p;

p=p->link;

}

}

//如果最大优先级大于正在运行的优先级则强占cpu

p=running.link;

if（q）

{

if（p）

{

if（p->pcb->prioritypcb->priority）

{

ready.addnode（p）;

running.deletenode（p,&running）;

p->pcb->pstate=READY;

running.addnode（q）;

ready.deletenode（q,front）;

q->pcb->pstate=RUNNING;

}

}

else

{

running.addnode（q）;

ready.deletenode（q,front）;

q->pcb->pstate=RUNNING;

}

}

p=blocked.link;

q=&blocked;

if（p）

{

intr;

r=p->ioend（）;

if（r）

{

blocked.deletenode（p,q）;

ready.addnode（p）;

p=q->link;

}

}

//运行进程

p=running.link;

q=&running;

if（p）

{

//isIOstart?

if（!

（p->isio（）））

p->run（）;//RUN

}

//进行IO

p=blocked.link;

q=&blocked;

if（p）

p->runio（）;

//动态计算就绪队列优先级

p=ready.link;

while（p）

{

（p->pcb->priority）++;

p=p->link;

}

//printprocstate

pprint（pcb,pcbsnum）;

}

}

voidgeneralpriority（pcbs*pcb,intpcbsnum）

{

pcbnoderunning,ready,blocked;

pcbnode*p,*f,*front;

pcbnode*q;

inti;

//将进程表中的进程加到就绪队列中

for（i=0;i

{

p=newpcbnode;

p->pcb=pcb+i;

ready.addnode（p）;

}

while（ready.link||running.link||blocked.link）

{

//判断将运行队列中的进程是否要io或结束

if（running.link）

{//需要IO?

if（running.link->isio（））

{

blocked.addnode（running.link）;

running.link->pcb->pstate=WAIT;

running.link=0;

}

//运行结束?

elseif（running.link->runend（））

{

p=running.link;

running.link=0;

deletep;

}

}

if（!

running.link）

{

//当运行队列为空

//寻找最大的一个优先级

p=ready.link;

q=p;

f=&ready;

front=f;

if（p）

{

intmaxpri=p->pcb->priority;

while（p）

{

if（p->pcb->priority>maxpri）

{

maxpri=p->pcb->priority;

front=f;

q=p;

}

f=p;

p=p->link;

}

}

p=running.link;

if（q）

{

running.addnode（q）;

ready.deletenode（q,front）;

q->pcb->pstate=RUNNING;

}

}

//将处理完IO的进程送到就绪队列

p=blocked.link;

q=&blocked;

if（p）

{

intr;

r=p->ioend（）;

if（r）

{

blocked.deletenode（p,q）;

ready.addnode（p）;

p=q->link;

}

}

//运行进程

p=running.link;

q=&running;

if（p）

{

if（!

（p->isio（）））

p->run（）;//RUN

}

//进行IO

p=blocked.link;

q=&blocked;

if（p）

p->runio（）;

pprint（pcb,pcbsnum）;

}

}

voidmain（）

{

pcbs*pcblist;//进程表

cout<<"请输入数据个数：

"<

cin>>proc;

inti;

remove（"result.txt"）;

pcblist=newpcbs[proc];//为进程表分配空间

for（i=0;i

newpcb（pcblist+i,i）;//产生进程

pprint（pcblist,proc）;

cout<<"************时间片轮转法调度************"<

poll（pcblist,proc）;//轮循法调度

cout<

cout<<"************非抢占调度************"<

generalpriority（pcblist,proc）;//非抢占

cout<

cout<<"************可抢占优先法调度************"<

priority（pcblist,proc）;//可抢占优先法

deletepcblist;//释放进程空间

}

四、实验结果

1、时间片轮转法

2、可抢占优先法

3、非抢占优先法

实验二银行家算法

一、实验目的

了解掌握银行家算法，学会模拟实现资源分配，同时有要求编写和调试一个系统分配资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生

二、实验内容

在多道程序系统中，虽可借助与多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险---死琐。

产生死锁的原因可归结为两点：

1：

竞争资源。

当系统中供多个进程共享的资源如打印机、公用队列等，其数目不足以满足诸进程的需要时，会引起诸进程对资源的竞争而产生死锁。

2：

进程间推进顺序非法。

进程在运行过程中，请求和释放资源的顺序不当，也同样会导致产生进程死锁。

三、实验过程

#include

#include

#include

#definem50

intno1;//进程数

intno2;//资源数

intr;

intallocation[m][m],need[m][m],available[m],max[m][m];

charname1[m],name2[m];//定义全局变量

voidmain（）

{

voidcheck（）;

voidprint（）;

inti,j,p=0,q=0;

charc;

intrequest[m],allocation1[m][m],need1[m][m],available1[m];

printf（"**********************************************\n"）;

printf（"*银行家算法的设计与实现*\n"）;

printf（"**********************************************\n"）;

printf（"请输入进程总数:

\n"）;

scanf（"%d",&no1）;

printf（"请输入资源种类数:

\n"）;

scanf（"%d",&no2）;

printf（"请输入Max矩阵:

\n"）;

for（i=0;i

for（j=0;j

scanf（"%d",&max[i][j]）;//输入已知进程最大资源需求量

printf（"请输入Allocation矩阵:

\n"）;

for（i=0;i

for（j=0;j

scanf（"%d",&allocation[i][j]）;//输入已知的进程已分配的资源数

for（i=0;i

for（j=0;j

need[i][j]=max[i][j]-allocation[i][j];//根据输入的两个数组计算出need矩阵的值

printf（"请输入Available矩阵\n"）;

for（i=0;i

scanf（"%d",&available[i]）;//输入已知的可用资源数

print（）;//输出已知条件

check（）;//检测T0时刻已知条件的安全状态

if（r==1）//如果安全则执行以下代码

{

do{

q=0;

p=0;

printf（"\n请输入请求资源的进程号（0~4）：

\n"）;

for（j=0;j<=10;j++）

{

scanf（"%d",&i）;

if（i>=no1）

{

printf（"输入错误，请重新输入：

\n"）;