实验三存储管理实验.docx
《实验三存储管理实验.docx》由会员分享，可在线阅读，更多相关《实验三存储管理实验.docx（16页珍藏版）》请在冰豆网上搜索。
实验三存储管理实验
文件排版存档编号：
[UYTR-OUPT28-KBNTL98-UYNN208]
实验三存储管理实验
实验三存储管理实验
一.目的要求：
1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法。
2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
二．实验内容：
1、设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
可以假定每个作业都是批处理作业，并且不允许动态申请内存。
为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。
算法描述：
本算法将内存的用户区分成大小相等的四个的分区，设一张分区说明表用来记录分区，其中分区的表项有分区的大小、起始地址和分区的状态，当系统为某个作业分配主存空间时，根据所需要的内存容量，在分区表中找到一个足够大的空闲分区分配给它，然后将此作业装入内存。
如果找不到足够大的空闲分区，则这个作业暂时无法分配内存空间，系统将调度另一个作业。
当一个作业运行结束时，系统将回收改作业所占据的分区并将该分区改为空闲。
算法原程序
#include""
#include""
#include<>
#include<>
#definePCB_NUM5行程序."）;
printf（"\n\t\t\t0.退出程序."）;
scanf（"%d",&m）;
switch（m）
{
case1:
break;
case0:
system（"cls"）;
menu（）;
break;
default:
system（"cls"）;
break;
}
}
voidpaixu（structMemInf*ComMem,intn）
{
inti,j,t;
for（j=0;jfor（i=0;iif（ComMem[i].size>ComMem[i+1].size）
{
t=ComMem[i].size;
ComMem[i].size=ComMem[i+1].size;
ComMem[i+1].size=t;
}
}
voidpaixu2（）
{
inti,j,t;
for（j=0;j<4;j++）
for（i=0;i<4-j;i++）
if（pcbList[i].size>pcbList[i+1].size）
{
t=pcbList[i].size;
pcbList[i].size=pcbList[i+1].size;
pcbList[i+1].size=t;
}
}
voidmain（）
{
DD:
menu（）;
charch;
inti,j,n,a=0;
structMemInf*ComMem;
system（"cls"）;
printf（"你要分多少个分区呢，请输入数值吧:
"）;
scanf（"%d",&n）;
ComMem=（structMemInf*）malloc（n*sizeof（structMemInf））;
printf（"请划分内存固定大小分区:
\n"）;ize）;
if（i==0）ComMem[i].addr=40;ddr=ComMem[i-1].addr+ComMem[i-1].size;tate=0;ize+a;
if（a>=INT）
{
printf（"超出规定内存范围"）;
ch=getchar（）;
ch=getchar（）;
gotoDD;
}
}
paixu（ComMem,n）;
cbID=1;
pcbList[0].RunState=0;ize=30;
pcbList[0].RunTime=0;
pcbList[0].TolTime=5;
pcbList[1].pcbID=2;
pcbList[1].RunState=0;
pcbList[1].size=15;
pcbList[1].RunTime=0;
pcbList[1].TolTime=6;
pcbList[2].pcbID=3;
pcbList[2].RunState=0;
pcbList[2].size=50;
pcbList[2].RunTime=0;
pcbList[2].TolTime=3;
pcbList[3].pcbID=4;
pcbList[3].RunState=0;
pcbList[3].size=120;
pcbList[3].RunTime=0;
pcbList[3].TolTime=4;
pcbList[4].pcbID=5;
pcbList[4].RunState=0;
pcbList[4].size=125;
pcbList[4].RunTime=0;
pcbList[4].TolTime=9;
ch=getchar（）;
ch=getchar（）;
while（pcbList[PCB_NUM-1].RunTime{
{
for（j=0;j{tate==0&&pcbList[j].RunState==0）ize>=pcbList[j].size）tate=pcbList[j].pcbID;
pcbList[j].RunState=1;
}
}unTime>=pcbList[j].TolTime）tate==pcbList[j].pcbID）
{
ComMem[i].state=0;unState=2;unState==1&&pcbList[i].RunTimecbID,pcbList[i].size,pcbList[i].RunState,pcbList[i].TolTime,pcbList[i].RunTime）;
printf（"分区ID\t分区大小\t状态\n"）;
for（i=0;iprintf（"%d\t%d\t\t%d\n",i,ComMem[i].size,ComMem[i].state）;
printf（"按回车键继续...\n"）;
getchar（）;tart=-1;
frees[i].length=0;
strcpy（frees[i].tag,"free"）;
occupys[i].start=-1;
occupys[i].length=0;
strcpy（occupys[i].tag,""）;
}
free_quantity=0;
occupy_quantity=0;
}
voidwritedata（）tart）;
printf（"输入第%d个分区的长度：
\n",j）;
scanf（"%d",&frees[i].length）;
}
if（（fp=fopen（fname,"wb"））==NULL）
printf（"错误,文件打不开,请检查文件名\n"）;
for（i=0;iif（fwrite（&frees[i],sizeof（structnode）,1,fp）!
=1）
printf（"文件写入错误!
\n"）;
fclose（fp）;
}
voidreaddata（）tart<=frees[t].start）
t=j;
}
frees[free_quantity].start=frees[i].start;
frees[free_quantity].length=frees[i].length;
frees[i].start=frees[t].start;
frees[i].length=frees[t].length;
frees[t].start=frees[free_quantity].start;
frees[t].length=frees[free_quantity].length;
}
}
voidview（）tart,frees[i].length,frees[i].tag）;
printf（"\n\n已分配分区表显示如下：
\n"）;
printf（"起始地址\t长度\t占用作业名\n"）;
for（j=0;jprintf（"%6dk\t%10dk\t%s\t\n",occupys[j].start,occupys[j].length,occupys[j].tag）;
getchar（）;
getchar（）;
}
voidearliest（）ength>=joblength）
f=1;
}
if（f==0）
{
printf（"\n当前没有能满足你申请长度的空闲内存,请稍候再试\n"）;
getchar（）;
}
else
{ength>=joblength）
{
t=1;
}
j++;
}
j--;
occupys[occupy_quantity].start=frees[j].start;ag,jobname）;
occupys[occupy_quantity].length=joblength;
occupy_quantity++;
if（frees[j].length>joblength）
{
frees[j].start+=joblength;
frees[j].length-=joblength;
}
else
{
for（i=j;i{
frees[i].start=frees[i+1].start;
frees[i].length=frees[i+1].length;
}
free_quantity--;
}
printf（"作业申请内存空间成功!
\n"）;
getchar（）;
getchar（）;
}
}
voidexcellent（）ength>=joblength）
f=1;
}
if（f==0）
{
printf（"\n当前没有能满足你申请长度的空闲内存,请稍候再试\n"）;
getchar（）;
}
elseength>=joblength）
{
t=1;
}
j++;
}
j--;
for（i=0;i{
if（frees[i].length>=joblength&&frees[i].lengthj=i;
}
occupys[occupy_quantity].start=frees[j].start;ag,jobname）;
occupys[occupy_quantity].length=joblength;
occupy_quantity++;
if（frees[j].length>joblength）
{
frees[j].start+=joblength;
frees[j].length-=joblength;
}
else
{
for（i=j;i{
frees[i].start=frees[i+1].start;
frees[i].length=frees[i+1].length;
}
free_quantity--;
}
printf（"作业申请内存空间成功!
\n"）;
getchar（）;
getchar（）;
}
}
voidworst（）
{
charjobname[20];
intjoblength,f=0;inti,j;
printf（"请输入作业名：
\n"）;
scanf（"%s",&jobname）;
printf（"输入作业的长度：
\n"）;
scanf（"%d",&joblength）;
for（i=0;i{
if（frees[i].length>=joblength）
f=1;
}
if（f==0）
{
printf（"\n当前没有能满足你申请长度的空闲内存,请稍候再试\n"）;
getchar（）;
getchar（）;
}
elseength>=joblength）
{
t=1;
}
j++;
}
j--;
for（i=0;i{
if（frees[i].length>=joblength&&frees[i].length>frees[j].length）
j=i;
}
occupys[occupy_quantity].start=frees[j].start;ag,jobname）;
occupys[occupy_quantity].length=joblength;
occupy_quantity++;
if（frees[j].length>joblength）
{
frees[j].start+=joblength;
frees[j].length-=joblength;
}
else
{
for（i=j;i{
frees[i].start=frees[i+1].start;
frees[i].length=frees[i+1].length;
}
free_quantity--;
}
printf（"作业申请内存空间成功!
\n"）;
getchar（）;
getchar（）;
}
}
voidmain（）
{
initial（）;
intn;
writedata（）;
system（"cls"）;
readdata（）;
for（;;）
{
sort（）;
printf（"************************************\n"）;
printf（"************************************\n"）;
printf（"**欢迎使用可变分区存储管理系统**\n"）;
printf（"************************************\n"）;
printf（"**1.显示空闲表和分配表**\n"）;
printf（"**2.首次适应算法**\n"）;
printf（"**3.最佳适应算法**\n"）;
printf（"**4.最坏适应算法**\n"）;
printf（"**0.退出系统**\n"）;
printf（"************************************\n"）;
printf（"************************************\n"）;
printf（"请输入您要选择的项目：
\n"）;
scanf（"%d",&n）;
for（;;）
{
if（n<0||n>4）
{
printf（"没有这个选项，请重新输入!
"）;
scanf（"%d",&n）;
}
else
break;
}
switch（n）
{
case0:
printf（"感谢您的使用!
再见!
\n"）;exit（0）;
case1:
view（）;break;
case2:
earliest（）;break;
case3:
excellent（）;break;
case4:
worst（）;break;
}
system（"cls"）;
}
}
测试结果：
使用首次适应算法的结果：
使用最佳适应算法：
使用最坏适应算法：
内存过满：
3、编写并调试一个段页式存储管理的地址转换的模拟程序。
首先设计好段表、页表，然后给出若干个有一定代表性的地址，通过查找段表页表后得到转换的地址。
要求打印转换前的地址，相应的段表，页表条款及转换后的地址，以便检查。
代码实现
#include
#include
usingnamespacestd;
typedefstructQuick
{
intqs;um>>ss[ss1].flag>>ss[ss1].plen>>ss[ss1].psta;
cout<<"请初始化第"<for（intsss1=0;sss1{
page[ss1][sss1].num=sss1;
cout<<"请输入该段第"<cin>>page[ss1][sss1].flag>>page[ss1][sss1].block;
}
}
um=bn;
cout<<"请输入第"<cin>>work[bn].str;
}
lag!
=1||page[][].flag!
=1）
{
cout<<"该页不在内存请输入一页在内存中的作为快表,请输入要作为快表的段号和页号"<cin>>>>;
}
=page[][].block;
menu（）;
}
voidchange（）
{
cout<<"请输入要转化的逻辑地址，段号s，段内页号p，页内偏移地址d（B）"<intsnum,pnum,dnum;
cin>>snum>>pnum>>dnum;
lock].str<cout<<"物理地址是"<<*bbs*1024+dnum<menu（）;
}
lag==0）
{
cout<<"缺段中断"<menu（）;
}
else
{
len-1）
{
cout<<"缺页中断"<menu（）;
}
else
{
if（pnum>=0&&pnum<=ss[ssnum].plen-1）
{
if（page[ssnum][pnum].flag==0）
{
cout<<"缺页中断"<menu（）;
}
else
{
cout<<"找到该页"<<"查询页表后对应块号"<cout<<"该块内存的数据是"<cout<<"转化得到的物理地址是：
"<menu（）;
}
}
}
}
}
}
}
}
实验结果：
四、实验总结
本次实习内容存储管理，通过编写和调试存储管理的模拟程序加深了对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法。
对算法有了更深刻的理解，就是动手能力太差。
升级会员 