操作系统实验报告.docx

操作系统实验报告.docx

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

操作系统实验报告

操作系统实验报告

学院：

　信息科学与工程学院

指导老师：

　　　胡小龙

1、实验目的

1、增强学生对计算机操作系统基本原理、基本理论、基本算法的理解

2、提高和培养学生的动手能力

2、实验题目

银行家算法模拟

3、题目分析

1.银行家算法中的数据结构

（1）可利用资源向量Available，其中每个元素代表一类可利用资源数目，其初始值是系统中所配置的该类的全部可利用资源的数目

（2）最大需求矩阵Max，它定义系统中n个进程中的每一个进程对m类资源的最大需求

（3）分配矩阵Allocation，它定义系统中每一类资源当前已分配给每一进程的资源数

（4）需求矩阵Need，表示每一进程尚需的各类资源数

上述算法结构存在下述关系

Need[i,j]=Max[i,j]-Alocation[i,j]

2.银行家算法

设Requesti是进程Pi的请求向量，当pi发出资源请求后，系统按照下述步骤进行检查：

（1）如果Requesti[j]<=Need[i,j],便转向步骤

（2）；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值；

（2）如果Requesti[j]<=Available[j],便转向步骤（3）；否则表示尚无足够资源，pi须等待

（3）系统试探着把资源分配给进程pi，并修改下面的数据结构中的数值：

Available.i-=res->i;

Allocation[process].i+=res->i;

Need[process].i-=res->i;

（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。

若安全，才正式将资源分配给进程pi，已完成此次分配；否则，将本次的试探分配作废，分配回滚。

Available.i+=res->i;

Allocation[process].i-=res->i;

Need[process].i+=res->i;

//资源分配请求

boolrequest（intprocess,RESOURCE*res）

{

//request向量需小于Need矩阵中对应的向量

if（res->A<=Need[process].A&&res->B<=Need[process].B&&res->C<=Need[process].C）

{

//request向量需小于Available向量

if（res->A<=Available.A&&res->B<=Available.B&&res->C<=Available.C）

{

//试探分配

ProbeAlloc（process,res）;

//如果安全检查成立，则请求成功，否则将分配回滚并返回失败

if（SafeCheck（））

{

returntrue;

}

else

{

printf（"安全性检查失败。

原因：

系统将进入不安全状态，有可能引起死锁。

\n"）;

printf（"正在回滚...\n"）;

RollBack（process,res）;

}

}

else

{

printf（"安全性检查失败。

原因：

请求向量大于可利用资源向量。

\n"）;

}

}

else

{

printf（"安全性检查失败。

原因：

请求向量大于需求向量。

\n"）;

}

returnfalse;

}

3.安全性算法

（1）设置两个向量：

i工作向量Work,表示系统可提供给进程继续运行所需的各类资源数目，在执行安全算法开始时：

Work=Available

iiFinish,表示系统是否有足够的资源分配给进程，是指运行完成。

开始时：

Finish[i]=false;当有足够资源分配给进程时，再令Finish[i]=true

（2）从进程集合中找到一个满足下述条件的进程：

iFinish[i]=false;

iiNeed[i,j]<=Work[j];若找到，执行步骤（3），否则，执行步骤（4）

（3）当进程pi获得资源后，可顺利执行，直至完成，并释放出分配给他的资源

Work[j]=Work[j]+Allocation[i,j];

Finish[i]=true;

Gotostep2;

（4）如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

//安全性检查

boolSafeCheck（）

{

RESOURCEWork=Available;

boolFinish[PROCESSES_NUMBER]={false,false,false,false,false};

inti;

intj=0;

for（i=0;i

{

//是否已检查过

if（Finish[i]==false）

{

//是否有足够的资源分配给该进程

if（Need[i].A<=Work.A&&Need[i].B<=Work.B&&Need[i].C<=Work.C）

{

//有则使其执行完成，并将已分配给该进程的资源全部回收

Work.A+=Allocation[i].A;

Work.B+=Allocation[i].B;

Work.C+=Allocation[i].C;

Finish[i]=true;

safe[j++]=i;

i=-1;//重新进行遍历

}

}

}

//如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态

for（i=0;i

{

if（Finish[i]==false）

{

returnfalse;

}

}

returntrue;

}

4、源代码

banker.h

#pragmawarning（disable:

4996）

typedefintbool;

#definefalse0

#definetrue!

false

//系统中所有进程数量

#definePROCESSES_NUMBER5

typedefstruct{

intA;

intB;

intC;

}RESOURCE;

//最大需求矩阵

RESOURCEMax[PROCESSES_NUMBER]=

{

{7,5,3},

{3,2,2},

{9,0,2},

{2,2,2},

{4,3,3}

};

//已分配资源数矩阵

RESOURCEAllocation[PROCESSES_NUMBER]=

{

{0,1,0},

{2,0,0},

{3,0,2},

{2,1,1},

{0,0,2}

};

//需求矩阵

RESOURCENeed[PROCESSES_NUMBER]=

{

{7,4,3},

{1,2,2},

{6,0,0},

{0,1,1},

{4,3,1}

};

//可用资源向量

RESOURCEAvailable={3,3,2};

intsafe[PROCESSES_NUMBER];

main.c

#include

#include

#include"banker.h"

//试探分配

voidProbeAlloc（intprocess,RESOURCE*res）

{

Available.A-=res->A;

Available.B-=res->B;

Available.C-=res->C;

Allocation[process].A+=res->A;

Allocation[process].B+=res->B;

Allocation[process].C+=res->C;

Need[process].A-=res->A;

Need[process].B-=res->B;

Need[process].C-=res->C;

}

//若试探分配后进入不安全状态，将分配回滚

voidRollBack（intprocess,RESOURCE*res）

{

Available.A+=res->A;

Available.B+=res->B;

Available.C+=res->C;

Allocation[process].A-=res->A;

Allocation[process].B-=res->B;

Allocation[process].C-=res->C;

Need[process].A+=res->A;

Need[process].B+=res->B;

Need[process].C+=res->C;

}

//安全性检查

boolSafeCheck（）

{

RESOURCEWork=Available;

boolFinish[PROCESSES_NUMBER]={false,false,false,false,false};

inti;

intj=0;

for（i=0;i

{

//是否已检查过

if（Finish[i]==false）

{

//是否有足够的资源分配给该进程

if（Need[i].A<=Work.A&&Need[i].B<=Work.B&&Need[i].C<=Work.C）

{

//有则使其执行完成，并将已分配给该进程的资源全部回收

Work.A+=Allocation[i].A;

Work.B+=Allocation[i].B;

Work.C+=Allocation[i].C;

Finish[i]=true;

safe[j++]=i;

i=-1;//重新进行遍历

}

}

}

//如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态

for（i=0;i

{

if（Finish[i]==false）

{

returnfalse;

}

}

returntrue;

}

//资源分配请求

boolrequest（intprocess,RESOURCE*res）

{

//request向量需小于Need矩阵中对应的向量

if（res->A<=Need[process].A&&res->B<=Need[process].B&&res->C<=Need[process].C）

{

//request向量需小于Available向量

if（res->A<=Available.A&&res->B<=Available.B&&res->C<=Available.C）

{

//试探分配

ProbeAlloc（process,res）;

//如果安全检查成立，则请求成功，否则将分配回滚并返回失败

if（SafeCheck（））

{

returntrue;

}

else

{

printf（"安全性检查失败。

原因：

系统将进入不安全状态，有可能引起死锁。

\n"）;

printf（"正在回滚...\n"）;

RollBack（process,res）;

}

}

else

{

printf（"安全性检查失败。

原因：

请求向量大于可利用资源向量。

\n"）;

}

}

else

{

printf（"安全性检查失败。

原因：

请求向量大于需求向量。

\n"）;

}

returnfalse;

}

//输出资源分配表

voidPrintTable（）

{

printf（"\t\t\t*********资源分配表*********\n"）;

printf（"ProcessMaxAllocationNeedAvailable\n"）;

printf（"ABCABCABCABC\n"）;

printf（"P0%d%d%d%d%d%d%d%d%d%d%d%d\n",Max[0].A,Max[0].B,Max[0].C,Allocation[0].A,Allocation[0].B,Allocation[0].C,Need[0].A,Need[0].B,Need[0].C,Available.A,Available.B,Available.C）;

printf（"P1%d%d%d%d%d%d%d%d%d\n",Max[1].A,Max[1].B,Max[1].C,Allocation[1].A,Allocation[1].B,Allocation[1].C,Need[1].A,Need[1].B,Need[1].C）;

printf（"P2%d%d%d%d%d%d%d%d%d\n",Max[2].A,Max[2].B,Max[2].C,Allocation[2].A,Allocation[2].B,Allocation[2].C,Need[2].A,Need[2].B,Need[2].C）;

printf（"P3%d%d%d%d%d%d%d%d%d\n",Max[3].A,Max[3].B,Max[3].C,Allocation[3].A,Allocation[3].B,Allocation[3].C,Need[3].A,Need[3].B,Need[3].C）;

printf（"P4%d%d%d%d%d%d%d%d%d\n",Max[4].A,Max[4].B,Max[4].C,Allocation[4].A,Allocation[4].B,Allocation[4].C,Need[4].A,Need[4].B,Need[4].C）;

printf（"\n"）;

}

intmain（）

{

intch;

printf（"先检查初始状态是否安全。

\n"）;

if（SafeCheck（））

{

printf（"系统处于安全状态。

\n"）;

printf（"安全序列是{P%d,P%d,P%d,P%d,P%d}。

\n",safe[0],safe[1],safe[2],safe[3],safe[4]）;

}

else

{

printf（"系统处于不安全状态。

程序将退出...\n"）;

gotoover;

}

do

{

intprocess;

RESOURCEres;

PrintTable（）;

printf（"请依次输入请求分配的进程和对三类资源的请求数量：

"）;

scanf（"%d%d%d%d",&process,&res.A,&res.B,&res.C）;

if（request（process,&res））

{

printf（"分配成功。

\n"）;

printf（"安全序列是{P%d,P%d,P%d,P%d,P%d}。

\n",safe[0],safe[1],safe[2],safe[3],safe[4]）;

}

else

{

printf（"分配失败。

\n"）;

}

printf（"是否继续分配？

（Y/N）:

"）;

fflush（stdin）;//虽然C标准不支持这种用法，但是VC++支持

ch=getchar（）;

}while（ch=='Y'||ch=='y'）;

over:

printf（"执行完毕。

"）;

return0;

}

五、程序运行截图

6、实验心得