南昌大学操作系统实验报告.docx
《南昌大学操作系统实验报告.docx》由会员分享，可在线阅读，更多相关《南昌大学操作系统实验报告.docx（20页珍藏版）》请在冰豆网上搜索。
南昌大学操作系统实验报告
实验报告
实验课程：
计算机操作系统
学生姓名：
陈帅
学号：
8000111078
专业班级：
东软实验班111班
2013年6月15日
目录
一、实验一编程实现银行家安全算法………………页码
二、实验二存储管理的模拟实现………………………页码
南昌大学实验报告
---
（1）编程实现银行家安全算法
学生姓名：
陈帅学号：
8000111078专业班级：
东软实验班111班
实验类型：
□验证□综合■设计□创新实验日期：
2013/5/20实验成绩：
一、实验目的
通过实验加强对银行家安全算法的理解和掌握。
二、实验内容
熟悉避免死锁发生的方法，死锁与安全序列的关系，编程实现银行家算法，要求输出进程的安全序列。
三、实验要求
1、需写出设计说明；
2、设计实现代码及说明
3、运行结果；
四、主要实验步骤
五、实验数据及处理结果
#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（"*姓名：
陈帅学号：
8000111078*\n"）;
printf（"**********************************************\n"）;
printf（"请输入进程总数:
\n"）;
scanf（"%d",&no1）;
printf（"请输入资源种类数:
\n"）;
scanf（"%d",&no2）;
printf（"请输入Max矩阵:
\n"）;
for（i=0;ifor（j=0;jscanf（"%d",&max[i][j]）;//输入已知进程最大资源需求量
printf（"请输入Allocation矩阵:
\n"）;
for（i=0;ifor（j=0;jscanf（"%d",&allocation[i][j]）;//输入已知的进程已分配的资源数
for（i=0;ifor（j=0;jneed[i][j]=max[i][j]-allocation[i][j];//根据输入的两个数组计算出need矩阵的值
printf（"请输入Available矩阵\n"）;
for（i=0;iscanf（"%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"）;
continue;
}
elsebreak;
}
printf（"\n请输入该进程所请求的资源数request[j]:
\n"）;
for（j=0;jscanf（"%d",&request[j]）;
for（j=0;jif（request[j]>need[i][j]）p=1;
//判断请求是否超过该进程所需要的资源数
if（p）
printf（"请求资源超过该进程资源需求量，请求失败！
\n"）;
else
{
for（j=0;jif（request[j]>available[j]）q=1;
//判断请求是否超过可用资源数
if（q）
printf（"没有做够的资源分配，请求失败！
\n"）;
else//请求满足条件
{
for（j=0;j{
available1[j]=available[j];
allocation1[i][j]=allocation[i][j];
need1[i][j]=need[i][j];
//保存原已分配的资源数，仍需要的资源数和可用的资源数
available[j]=available[j]-request[j];
allocation[i][j]+=request[j];
need[i][j]=need[i][j]-request[j];
//系统尝试把资源分配给请求的进程
}
print（）;
check（）;//检测分配后的安全性
if（r==0）//如果分配后系统不安全
{
for（j=0;j{
available[j]=available1[j];
allocation[i][j]=allocation1[i][j];
need[i][j]=need1[i][j];
//还原已分配的资源数，仍需要的资源数和可用的资源数
}
printf（"返回分配前资源数\n"）;
print（）;
}
}
}printf（"\n你还要继续分配吗？
YorN?
\n"）;
//判断是否继续进行资源分配
c=getche（）;
}while（c=='y'||c=='Y'）;
}
}
voidcheck（）//安全算法函数
{
intk,f,v=0,i,j;
intwork[m],a[m];
boolfinish[m];
r=1;
for（i=0;ifinish[i]=false;//初始化进程均没得到足够资源数并完成
for（i=0;iwork[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数
k=no1;
do{
for（i=0;i{
if（finish[i]==false）
{
f=1;
for（j=0;jif（need[i][j]>work[j]）
f=0;
if（f==1）//找到还没有完成且需求数小于可提供进程继续运行的资源数的进程
{
finish[i]=true;
a[v++]=i;//记录安全序列号
for（j=0;jwork[j]+=allocation[i][j];//释放该进程已分配的资源
}
}
}
k--;//每完成一个进程分配，未完成的进程数就减1
}while（k>0）;
f=1;
for（i=0;i{
if（finish[i]==false）
{
f=0;
break;
}
}
if（f==0）//若有进程没完成，则为不安全状态
{
printf（"系统处在不安全状态！
"）;
r=0;
}
else
{
printf（"\n系统当前为安全状态，安全序列为：
\n"）;
for（i=0;iprintf（"p%d",a[i]）;//输出安全序列
}
}
voidprint（）//输出函数
{
inti,j;
printf（"\n"）;
printf（"*************此时刻资源分配情况*********************\n"）;
printf（"进程名/号|Max|Allocation|Need|\n"）;
for（i=0;i{
printf（"p%d/%d",i,i）;
for（j=0;j{printf（"%d",max[i][j]）;}
for（j=0;j{printf（"%d",allocation[i][j]）;}
for（j=0;j{printf（"%d",need[i][j]）;}
printf（"\n"）;
}
printf（"\n"）;
printf（"各类资源可利用的资源数为:
"）;
for（j=0;j{printf（"%d",available[j]）;}
printf（"\n"）;
}
实验结果：
1、程序初始化
输入进程号
输入进程号
不在测试
六、实验体会或对改进实验的建议
七、参考资料
南昌大学实验报告
---
（2）存储管理的模拟实现
学生姓名：
陈帅学号：
8000111078专业班级：
东软实验班111班
实验类型：
□验证□综合■设计□创新实验日期：
2013/5/20实验成绩：
一、实验目的
存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。
二、实验内容
编程实现页面置换算法，要求输出页面的置换过程，具体可以编程实现OPT、FIFO和LRU算法。
三、实验要求
1、需写出设计说明；
2、设计实现代码及说明
3、运行结果；
四、主要实验步骤
五、实验数据及处理结果
#include
#include
#include
ints,i;//s表示产生的随机数，i表示物理块数
intm,n,h;//循环专用
intk,g,f;//临时数据
intsum;//缺页次数
floatr;//rate命中率
intp[320];//page页数
inta[320];//执行的指令
intpb[32];//physicalblock用户内存容量（物理块）
voidinitialization（）;
voidFIFO（）;
voidLRU（）;
voidLFU（）;
voidline（）;
voidstart（）;
voidend（）;
voidmain（）
{
start（）;
srand（（int）time（NULL））;//以计算机当前时间作为随机数种子
for（n=0;n<320;n+=3）
{
s=rand（）%320+0;//随机产生一条指令
a[n]=s+1;//顺序执行一条指令
s=rand（）%（a[n]+1）;//执行前地址指令M`
a[n+1]=s+1;
s=rand（）%（319-a[n+1]）+（a[n+1]+1）;
a[n+2]=s;
}
for（n=0;n<320;n++）
p[n]=a[n]/10;//得到指令相对的页数
printf（"物理块数\tFIFO\t\tLRU\t\tLFU\n"）;
line（）;
for（i=4;i<=32;i++）
{
printf（"\n%2d：
",i）;
FIFO（）;
LRU（）;
LFU（）;
}
end（）;
}
voidinitialization（）//用户内存及相关数据初始化
{
for（n=0;n<32;n++）
pb[n]=-1;
sum=0;
r=0;
k=0;
g=-1;
f=-1;
}
voidFIFO（）//先进先出置换算法
{
inttime[32];//定义进入内存时间长度数组
intmax;//max表示进入内存时间最久的，即最先进去的
initialization（）;
for（m=0;mtime[m]=m+1;
for（n=0;n<320;n++）
{
k=0;
for（m=0;mif（pb[m]==p[n]）//表示内存中已有当前要调入的页面
{
g=m;
break;
}
for（m=0;mif（pb[m]==-1）//用户内存中存在空的物理块
{
f=m;
break;
}
if（g!
=-1）
g=-1;
else
{
if（f==-1）//找到最先进入内存的页面
{
max=time[0];
for（m=0;mif（time[m]>max）
{
max=time[m];
k=m;
}
pb[k]=p[n];
time[k]=0;//该物理块中页面停留时间置零
sum++;//缺页数+1
}
else
{
pb[f]=p[n];
time[f]=0;
sum++;
f=-1;
}
}
for（m=0;m=-1;m++）
time[m]++;//物理块中现有页面停留时间+1
}
r=1-（float）sum/320;
printf（"\t\t%6.4f",r）;
}
voidLRU（）//最近最少使用算法
{
inttime[32];
intmax;
initialization（）;
for（m=0;mtime[m]=m+1;
for（n=0;n<320;n++）
{
k=0;
for（m=0;mif（pb[m]==p[n]）
{
g=m;
break;
}
for（m=0;mif（pb[m]==-1）
{
f=m;
break;
}
if（g!
=-1）
{
time[g]=0;
g=-1;
}
else
{
if（f==-1）
{
max=time[0];
for（m=0;mif（time[m]>max）
{
k=m;
max=time[m];
}
pb[k]=p[n];
time[k]=0;
sum++;
}
else
{
pb[f]=p[n];
time[f]=0;
sum++;
f=-1;
}
}
for（m=0;m=-1;m++）
time[m]++;
}
r=1-（float）sum/320;
printf（"\t\t%6.4f",r）;
}
voidLFU（）//最少访问页面算法
{
inttime_lru[32],time[32],min,max_lru,t;
initialization（）;
for（m=0;m{
time[m]=0;
time_lru[m]=m+1;
}
for（n=0;n<320;n++）
{
k=0;
t=1;
for（m=0;mif（pb[m]==p[n]）
{
g=m;
break;
}
for（m=0;mif（pb[m]==-1）
{
f=m;
break;
}
if（g!
=-1）
{
time_lru[g]=0;
g=-1;
}
else
{
if（f==-1）
{
if（n<=20）//将最少使用的间隔时间定位个单位
{
max_lru=time_lru[0];//在未达到"一定时间"的要求时，先采用LRU进行页面置换
for（m=0;mif（time_lru[m]>max_lru）
{
k=m;
max_lru=time_lru[m];
}
pb[k]=p[n];
time_lru[k]=0;
sum++;
}
else
{
for（m=0;mfor（h=n-1;h>=n-51;h--）
if（pb[m]==p[h]）
time[m]++;
min=time[0];
for（m=0;mif（time[m]{
min=time[m];
k=m;
}
for（m=0;mif（time[m]==min）
t++;
if（t>1）//若使用次数同样少，将次数相同的页面按照LRU进行页面置换
{
max_lru=time_lru[k];
for（m=0;mif（time_lru[m]>max_lru）
{
k=m;
max_lru=time_lru[m];
}
}
pb[k]=p[n];
time_lru[k]=0;
sum++;
}
}
else
{
pb[f]=p[n];
time_lru[f]=0;
sum++;
f=-1;
}
}
for（m=0;m=-1;m++）
time_lru[m]++;
}
r=1-（float）sum/320;
printf（"\t\t%6.4f",r）;
}
voidline（）//美化程序，使程序运行时更加明朗美观
{
printf（"********************************************************"）;
}
voidstart（）//表示算法开始
{
line（）;
printf（"\n"）;
printf（"*页面置换算法开始*\n"）;
printf（"*姓名：
陈帅学号：
8000111078*\n"）;
line（）;
printf（"\n\n"）;
}
voidend（）//表示算法结束
{
printf（"\n"）;
line（）;
printf（"\n页面置换算法结束,谢谢使用\n"）;
line（）;
}
运行结果：
六、实验体会或对改进实验的建议
七、参考资料
升级会员 