进程调度+存储管理+磁盘调度++银行家算法+文件系统1Word文档格式.docx
《进程调度+存储管理+磁盘调度++银行家算法+文件系统1Word文档格式.docx》由会员分享，可在线阅读，更多相关《进程调度+存储管理+磁盘调度++银行家算法+文件系统1Word文档格式.docx（35页珍藏版）》请在冰豆网上搜索。
//定义最大进程数
//定义进程结构体
typedefstructnode
{
intid;
intstatus;
intalltime;
intpriority;
intfinished;
intwait_time;
node*next;
}pcb;
pcbpcbs[MAXPCB];
intcount;
inti;
//初始化函数
voidinitial（）
{
cout<
<
"
请输入进程数：
"
；
cin>
>
i;
count=i;
for（i=0;
i<
MAXPCB;
i++）
{
pcbs[i].id=i+1;
pcbs[i].status=1;
pcbs[i].time=random（20）;
pcbs[i].priority=random
（2）;
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
}
//优先数调度算法
voidorder（）
voidpri（）
if（count!
=0）{}
intpassed_time=0;
inttotal;
intqueue[MAXPCB];
intcurrent_privilege=1000;
quantity;
current_privilege=1000;
for（j=0;
j<
j++）
{
if（（pcbs[j].finished==0）&
&
（pcbs[j].privilege<
current_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<
endl<
***********************************************************"
endl;
优先数调度执行流:
进程名等待时间"
cout<
pcbs[queue[i]].name<
pcbs[queue[i]].wait_time<
total=0;
{total+=pcbs[i].wait_time;
}
总等待时间:
total<
平均等待时间:
total/quantity<
//主函数
voidmain（）
intflag;
version（）;
initial（）;
flag=readData（）;
if（flag==1）
{FIFO（）;
init（）;
privilege（）;
timer（）;
（3）运行结果：
输入进程流文件名1.txt即可得出以下输出结果：
实验二银行家算法
一、实验目的
死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验要求
设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；
三、数据结构
1．可利用资源向量Available，它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available（j）=k，标是系统中现有Rj类资源k个。
2．最大需求矩阵Max，这是一个n×
m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max（i，j）=k，表示进程i需要Rj类资源的最大数目为k。
3．分配矩阵Allocation，这是一个n×
m的矩阵，它定义了系统中的每类资源当前一分配到每一个进程的资源数。
如果Allocation（i，j）=k，表示进程i当前已经分到Rj类资源的数目为k。
Allocationi表示进程i的分配向量，有矩阵Allocation的第i行构成。
4．需求矩阵Need，这是一个n×
m的矩阵，用以表示每个进程还需要的各类资源的数目。
如果Need（i，j）=k，表示进程i还需要Rj类资源k个，才能完成其任务。
Needi表示进程i的需求向量，由矩阵Need的第i行构成。
上述三个矩阵间存在关系：
Need（i，j）=Max（i，j）-Allocation（i，j）；
四、银行家算法
Requesti是进程Pi的请求向量。
Requesti（j）=k表示进程Pi请求分配Rj类资源k个。
当Pi发出资源请求后，系统按下述步骤进行检查：
1．如果Requesti≤Need，则转向步骤2；
否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。
2．如果Requesti≤Available，则转向步骤3；
否则，表示系统中尚无足够的资源满足Pi的申请，Pi必须等待。
3．系统试探性地把资源分配给进程Pi，并修改下面数据结构中的数值：
Available=Available-Requesti
Allocationi=Allocationi+Requesti
Needi=Needi-Requesti
4．系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
如果安全才正式将资源分配给进程Pi，以完成本次分配；
否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
假定系统有5个进程（p0,p1,p2,p3,p4）和三类资源（A，B，C），各种资源的数量分别为10，5，7，在T0时刻的资源分配情况如下图：
MaxAllocationNeedAvailable
ABCABCABCABC
P0753010743332
（230）
P1322200122
（302）（020）
P2902302600
P3222211011
P4433002431
五、安全性算法
1．设置两个向量。
Work：
它表示系统可提供给进程继续运行的各类资源数目，它包含m个元素，开始执行安全性算法时，Work=Available。
Finish：
它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish（I）=false；
当有足够资源分配给进程Pi时，令Finish（i）=true；
2．从进程集合中找到一个能满足下述条件的进程。
Finish（i）==false；
Needi≤work；
如找到则执行步骤3；
否则，执行步骤4；
3．当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行
Work=work+Allocationi
Finish（i）=true；
转向步骤2；
4．若所有进程的Finish（i）都为true，则表示系统处于安全状态；
否则，系统处于不安全状态。
六、系统流程图
七．银行家算法程序代码
conio.h>
iostream>
usingnamespacestd;
typedefstructMax1//资源的最大需求量
intm_a;
intm_b;
intm_c;
}Max;
typedefstructAllocation1//已分配的资源数
inta_a;
inta_b;
inta_c;
}Allocation;
typedefstructNeed1//还需要的资源数
intn_a;
intn_b;
intn_c;
}Need;
structAvailable1//可利用的资源量
intav_a;
intav_b;
intav_c;
}q;
structpr//定义一个结构
charname;
Maxmax;
Allocationallocation;
Needneed;
intfinishflag;
}p[5];
charna[5];
//********************************************
voidinit（）//读入文件"
1.txt"
各进程还需要的资源数NEED：
FILE*fp;
fp=fopen（"
"
r+"
）;
//打开文件"
for（inti=0;
5;
{
fscanf（fp,"
%c,%d,%d,%d,%d,%d,%d\n"
&
p[i].name,&
p[i].max.m_a,&
p[i].max.m_b,
&
p[i].max.m_c,&
p[i].allocation.a_a,&
p[i].allocation.a_b,&
p[i].allocation.a_c）;
p[i].need.n_a=p[i].max.m_a-p[i].allocation.a_a;
p[i].need.n_b=p[i].max.m_b-p[i].allocation.a_b;
p[i].need.n_c=p[i].max.m_c-p[i].allocation.a_c;
p[i].name<
:
p[i].need.n_a<
p[i].need.n_b<
p[i].need.n_c<
fclose（fp）;
//关闭文件
//***********************************************
intfenpei（）//分配资源
Available:
;
q.av_a<
q.av_b<
q.av_c<
intfinishcnt=0,k=0,count=0;
for（intj=0;
p[j].finishflag=0;
while（finishcnt<
5）
for（inti=0;
{
if（p[i].finishflag==0&
q.av_a>
=p[i].need.n_a&
q.av_b>
=p[i].need.n_b&
q.av_c>
=p[i].need.n_c）
{
q.av_a+=p[i].allocation.a_a;
q.av_b+=p[i].allocation.a_b;
q.av_c+=p[i].allocation.a_c;
p[i].finishflag=1;
finishcnt++;
na[k++]=p[i].name;
break;
}
}
count++;
//禁止循环过多
if（count>
5）return0;
return1;
//****************************************************
intshq（）//申请资源
intm=0,i=0,j=0,k=0;
//m为进程号;
i,j,k为申请的三类资源数
请输入进程号和请求资源的数目!
如：
进程号资源ABC"
0202"
cin>
m>
i>
j>
k;
if（i<
=p[m].need.n_a&
=p[m].need.n_b&
k<
=p[m].need.n_c）
if（i<
=q.av_a&
=q.av_b&
=q.av_c）
p[m].allocation.a_a+=i;
p[m].allocation.a_b+=j;
p[m].allocation.a_c+=k;
p[m].need.n_a=p[m].max.m_a-p[m].allocation.a_a;
p[m].need.n_b=p[m].max.m_b-p[m].allocation.a_b;
p[m].need.n_c=p[m].max.m_c-p[m].allocation.a_c;
cout<
各进程还需要的资源数NEED:
'
\n'
for（intw=0;
w<
w++）
p[w].name<
p[w].need.n_a<
p[w].need.n_b
<
p[w].need.n_c<
return1;
else
Request>
Available让进程"
m<
等待......"
else
Need,让进程"
return0;
voidmain（）
charc;
/********银行家算法********/"
确认已经在\"
1.txt\"
文档中正确输入各进程的有关信息后按回车键"
getch（）;
init（）;
q.av_a=10;
//各种资源的数量
q.av_b=5;
q.av_c=7;
while（flag）
q.av_a-=p[i].allocation.a_a;
q.av_b-=p[i].allocation.a_b;
q.av_c-=p[i].allocation.a_c;
if（fenpei（））
这样配置资源是安全的!
其安全序列是：
for（intk=0;
k++）
-->
na[k];
有进程发出Request请求向量吗?
（EnteryorY）"
c=getch（）;
if（c=='
y'
||c=='
Y'
）
if（shq（））continue;
elsebreak;
}
elseflag=0;
else
{flag=0;
不安全!
!
八．运行结果
实验三存储管理
一．实验目的
存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二．实验内容
（1）通过计算不同算法的命中率比较算法的优劣。
同时也考虑了用户内存容量对命中率的影响。
页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。
在本实验中，假定页面大小为1k，用户虚存容量为32k，用户内存容量为4页到32页。
（2）produce_addstream通过随机数产生一个指令序列，共320条指令。
A、指令的地址按下述原则生成：
1）50%的指令是顺序执行的
2）25%的指令是均匀分布在前地址部分
3）25%的指令是均匀分布在后地址部分
B、具体的实施方法是：
1）在[0，319]的指令地址之间随机选取一起点m；
2）顺序执行一条指令，即执行地址为m+1的指令；
3）在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m’；
4）顺序执行一条指令，地址为m’+1的指令
5）在后地址[m’+2，319]中随机选取一条指令并执行；
6）重复上述步骤1）~5），直到执行320次指令
C、将指令序列变换称为页地址流
在用户虚存中，按每k存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：
第0条~第9条指令为第0页（对应虚存地址为[0，9]）；
第10条~第19条指令为第1页（对应虚存地址为[10，19]）；
。
第310条~第319条指令为第31页（对应虚存地址为[310，319]）；
按以上方式，用户指令可组成32页。
（3）计算并输出下属算法在不同内存容量下的命中率。
1）先进先出的算法（FIFO）；
2）最近最少使用算法（LRU）；
3）最佳淘汰算法（OPT）；
4）最少访问页面算法（LFR）；
其中3）和4）为选择内容
三．
系统框图
四．页面置换算法程序代码：
constintMAXSIZE=1000;
//定义最大页面数
constintMAXQUEUE=3;
//定义页框数
{intloaded;
inthit;
}page;
pagepages[MAXQUEUE];
//定义页框表
intqueue[MAXSIZE];
intquantity;
//初始化结构函数
voidinitial（）
MAXQUEUE;
pages[i].loaded=-1;
pages[i].hit=0;
MAXSIZE;
queue[i]=-1;
quantity=0;
}//初始化页框函数
voidinit（）
pages[i].loaded=-1;
pages[i].hit=0;
}//读入页面流
voidreadData（）
charfname[20];
请输入页面流文件名:
fname;
if（（fp=fopen（fname,"
r"
））==NULL）
错误,文件打不开,请检查文件名"
else
while（!
feof（fp））
fscanf（fp,"
%d"
queue[quantity]）;
quantity++;
读入的页面流:
queue[i]<
}//FIFO调度算法
voidFIFO（）
inti,j,p,flag;
intabsence=0;
p=0;
----------------------------"
先进先出调度算法（FIFO）页面调出流:
{flag=0;
for（j=0;
升级会员 