分页式管理实验报告.docx
《分页式管理实验报告.docx》由会员分享，可在线阅读，更多相关《分页式管理实验报告.docx（25页珍藏版）》请在冰豆网上搜索。
分页式管理实验报告
题目连续式与分页式主存管理模式的模拟实现
学生姓名
学号
学院
专业计算机科学与技术专业
指导教师赵晓平
二Ｏ一二年六月十一日
一、实验目的
模拟在连续分配与分页管理两种方式下，主存空间的分配与回收，帮助学生加深了解存储器管理的工作过程。
注意，该实验为模拟实验，并不要求进行真正的内存分配与回收，主要是编写程序模拟其中过程即可。
二、实验内容
1连续式分配
1、在连续分配方式下，设计一个动态分区分配与回收的内存管理程序。
2、动态分区分配按作业需要的主存大小来分割分区。
当要装入一个作业时，根据作业需要、、的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
3、设置一张全局分区状态表说明当前内存分配状态，例如下所示：
0
5k
10k
14k
26k
32k
640k
操作系统区
作业1
作业3
空闲区
作业2
空闲区
4、设置一张空闲分区表描述当前空闲分区分布状况，可采用数组或链表来实现，数组可参考以下格式：
起址
长度
状态
第一栏
14K
12K
未分配
第二栏
32K
96K
未分配
空表目
空表目
说明：
起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区。
5、在作业撤销后，系统需要回收分区。
在空闲分区表中找到一个空表目登记回收分区的起址和长度，并且修改表目状态为未分配。
注意：
由于分区的个数不定，所以空闲分区表中应有适量的状态为“空表目”的登记栏目，否则造成表格“溢出”无法登记。
6、在回收分区时，应考虑相邻空闲分区合并。
7、在完成一次作业装入后，都需要输出：
本次分配的分区起址与长度，全局分区状态表，空闲分区表的内容。
若在分配中发生分割，需要说明分割后新空白分区的起址与长度。
8、在完成一次作业撤销后，都需要输出：
本次回收的分区起址与长度，全局分区状态表，空闲分区表的内容。
若发生相邻空闲分区合并，需要说明哪几个分区合并在一起，合并后的起址与长度
2、分页式管理
1、设计一个基本分页存储管理程序
2、分页式存储器把主存分成大小相等的若干块，作业的信息也按块的大小分页，作业装入主存时按页分散存放在主存的空闲块中。
3、系统用一张块表记录物理块分配的情况，如下图所示，其中状态0表示未分配，1表示已分配。
另外增加一个空闲块数，记录当前可用的物理块总数。
状态
第0块
1
第1块
1
第2块
0
第3块
1
第4块
0
4、需要为每个作业设置一张页表，记录页号与块号的对应关系。
页号
块号
0
168
1
72
2
56
5、作业装入内存时，分配过程如下：
a）将空闲块数乘上每块空间，计算出可用空间总数，然后与作业需要空间比较，若不能满足需要，提示不能装入。
b）若能满足需要，为作业创建页表，在块表中寻找足够的空白块，将页号与块号一一对应，并填入页表。
同时修改块表中各个块的状态
c）修改空闲块数，记录剩下空白块总数。
6、作业撤销后，需要回收物理块，回收过程如下：
a）根据页表，修改块表中对应各个物理块的状态
b）修改空闲块数，记录回收后空白块总数。
c）撤销页表
7、每次作业装入或回收，都需要输出块表、页表的内容，发生变化的块号，以及空闲块数。
若块表太大，可以用二维表格的方式输出，或只输出发生变化的块号。
三、实验要求
1、根据例程，尝试采用首次适应算法、循环首次适应算法、最佳适应算法其中的一种或多种算法实现3.2.1的动态分区分配。
算法思想请参考课本的分区分配算法。
2、根据例程，尝试实现3.2.1的分区回收功能。
3、根据例程，尝试实现3.2.2的分页系统功能
4、至少完成上述三项实验内容中的一个。
5、自行设定内存总空间，大小单位为KB，分页管理需要设定每个页的大小。
6、随机设置当前内存分配状态。
7、自行设计作业队列，队列中至少要有5个作业，设定各个作业空间大小，大小要适中。
8、输出结果要尽量详细清晰，如果输出内容比较多，可以考虑把输出结果保存到文件中，通过文件来查看。
9、程序代码要尽量加入注释，提高程序的清晰度与可读性。
10.在实验报告中，一方面可以对实验结果进行分析，一方面可以对两种分配方式进行比较，分析它们的优劣。
四、实验过程
1.分页式：
//分页存储管理程序
#include
#include
#include
#include
#include
#definen11//模拟实验中允许的最大进程数为n
#definem11//模拟实验中允许的最大分区个数为m
#defineM_SIZE2000
struct
{
floataddress;//分配给进程的起始地址
floatlength;//分配给进程的空闲区长度，单位为字节
intflag;//分配区表标志，用"0"已分配，用"1"表示未分配
}Used_Table[m];//分配分区表
struct
{
floataddress;
floatlength;
intflag;
}Free_table[m];
floatstand_length（intk）//随机产生一个分区大小的函数
{
floatst_length[20];
srand（（unsigned）time（NULL））;//srand（）函数产生一个当前时间开始的随机种子
for（inti=0;i<20;i++）
st_length[i]=float（rand（）%1000）;
returnst_length[k];
}
floatprocess_length（intk）//随机产生一个进程大小的函数
{
floatpt_length[20];
srand（（unsigned）time（NULL））;//srand（）函数产生一个当前时间开始的随机种子
for（inti=0;i<20;i++）
pt_length[i]=float（rand（）%500）;
returnpt_length[k];
}
intprocess_num（）//随机产生一个进程个数的函数
{
intnum;
intA[10]={1,2,3,4,5,6,7,8,9,10};
srand（（unsigned）time（NULL））;
num=rand（）%10;
returnA[num];
}
charsrand_name（intk）//随机产生一个进程的名字
{
charA[26]={'A','B','C','D','E','F','G','H','I',
'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
returnA[k];
}
voidallocate（charPRS_NAME,floatX_K）//采用最优分配算法为进程PRS_NAME分配X_K大小的空间
{
inti,k;
floatad;
k=-1;
for（i=0;iif（Free_table[i].length>=X_K&&Free_table[i].flag==1）
if（k==-1||Free_table[i].lengthk=i;
if（k==-1）//未找到可用空闲分区，返回
{
printf（"无可用空闲区\n"）;
return;
}
//找到可用空闲区，开始分配：
if（Free_table[k].length-X_K<=M_SIZE）
{
Free_table[k].flag=0;
ad=Free_table[k].address;
X_K=Free_table[k].length;
}
else
{
Free_table[k].length=Free_table[k].length-X_K;
ad=Free_table[k].address+Free_table[k].length;
}
//修改已分配区表
i=0;
while（Used_Table[i].flag!
=0&&ii++;
if（i>=n）//无表目填写已分分区
{
printf（"无表目填写已分分区，错误\n"）;
//修正空闲区表
if（Free_table[k].flag==0）
//前面找到的是整个空闲分区
Free_table[k].flag=1;
else
{//前面找到的是某个空闲分区的一部分
Free_table[k].length=Free_table[k].length+X_K;
return;
}
}
else
{//修改已分配表
Used_Table[i].address=ad;
Used_Table[i].length=X_K;
Used_Table[i].flag=PRS_NAME;
}
return;
}//内存分配函数结束
voidreclaim（charPRS_NAME）//回收进程名为PRS_NAME的进程所占内存空间
{
inti,k,j,s,t;
floatS,L;
//寻找已分配表中对应登记项
s=0;
while（（Used_Table[s].flag!
=PRS_NAME||Used_Table[s].flag==0）&&ss++;
if（s>=n）//在已分配表中找不到名字为PRS_NAME的进程
{
cout<<"找不到该进程"<return;
}
//修改已分配表
Used_Table[s].flag=0;//取得归还分区的起始地址S和长度L
S=Used_Table[s].address;
L=Used_Table[s].length;
j=-1;k=-1;i=0;
//寻找回收分区的空闲上下邻，上邻表目k，下邻表目j
while（i{
if（Free_table[i].flag==1）
{
if（Free_table[i].address+Free_table[i].length==S）k=i;//找到上邻
if（Free_table[i].address==S+L）j=i;//找到下邻
}
i++;
}
if（k!
=-1）
if（j!
=-1）
//上邻空闲区，下邻空闲区，三项合并
{
Free_table[k].length=Free_table[j].length+Free_table[k].length+L;
Free_table[j].flag=1;
}
else
//上邻空闲区，下邻非空闲区，与上邻合并
Free_table[k].length=Free_table[k].length+L;
else
if（j!
=-1）
//上邻非空闲区，下邻为空闲区，与下邻合并
{
Free_table[j].address=S;
Free_table[j].length=Free_table[j].length+L;
}
else//上下邻均为非空闲区，回收区域直接填入
{
//在空闲区表中寻找空栏目
t=0;
while（Free_table[t].flag==1&&tt++;
if（t>=m）//空闲区表满,回收空间失败,将已分配表复原
{
cout<<"内存空闲表没有空间,回收空间失败"<Used_Table[s].flag=j;
return;
}
Free_table[t].address=S;
Free_table[t].length=L;
Free_table[t].flag=1;
}
return;
}
voidmain（）
{
inti,a;
floatp_length;
charp_name;
//空闲分区表初始化：
intt_P;
Free_table[0].address=1000;
for（t_P=0;t_P{
Free_table[t_P].length=stand_length（t_P）;
Free_table[t_P].flag=1;
}
for（t_P=1;t_P{
Free_table[t_P].address=Free_table[t_P-1].address+Free_table[t_P-1].length;
}//空闲分区表初始化结束
//已分配表初始化：
for（i=0;iUsed_Table[i].flag=0;
cout<<"*********************分页式主存管理的模拟实现***************"<cout<<"*********************选择以下标号实现其功能*****************************"<cout<<"*0:
退出2:
回收进程和内存*"<cout<<"*1:
随机产生进程并分配内存3:
显示内存分配记录*"<cout<<"**********************************************************"<while
（1）
{
cout<<"请输入一个功能项（0--3）:
"<cin>>a;
switch（a）
{
case0:
return;//a=0选择退出程序结束
case1:
//a=1开始随机的产生进程并分配空间
{
intp_num=process_num（）;
cout<<"随机产生"<intp_p;
cout<<"进程名进程大小"<for（p_p=0;p_p{
p_name=srand_name（p_p）;
p_length=process_length（p_p）;
cout<allocate（p_name,p_length）;//分配内存空间
}
cout<<"要查看内存分配请在提示命令出现后输入'3'回车"<}
break;
case2:
//a=2回收内存空间
cout<<"输入要回收分区的进程名";
cin>>p_name;
reclaim（p_name）;//回收内存空间
break;
case3:
//a=3显示内存情况
cout<<"输出空闲区表：
"<cout<<"------------------------------------------------------"<cout<<"起始地址分区大小标志（0-已分配，1-未分配）"<for（i=0;iprintf（"%6.0f%9.0f%6d\n",Free_table[i].address,Free_table[i].length,Free_table[i].flag）;
cout<<"已分配分区表：
"<cout<<"------------------------------------------------------"<cout<<"起始地址分区大小进程名"<for（i=0;iif（Used_Table[i].flag!
=0）
printf（"%6.0f%9.0f%6c\n",Used_Table[i].address,Used_Table[i].length,Used_Table[i].flag）;
break;
default:
cout<<"请输入正确的选项！
"<}
}
}
截图：
2.首次适应算法实现动态分区分配
代码：
#include
#include
#include
#include
#definegetpch（type）（type*）malloc（sizeof（type））
/*/#defineNULL0*/
structtable{
charname[10];
charstate;/*D（分配）orN（空闲）*/
intsize;/*分区大小*/
intaddr;/*起始地址*/
structtable*next;
structtable*prev;
}*tab=NULL,*p;
typedefstructtableTABLE;
UI（）{
printf（"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"）;
printf（"首次适应算法\n"）;
printf（"\n"）;
printf（"计科3班顾志祥20101308103\n"）;
printf（"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"）;
}
recycle（charn[10]）{
TABLE*pr=NULL;
for（pr=tab;pr!
=NULL;pr=pr->next）{
if（!
strcmp（pr->name,n）&&pr->state=='D'）{
if（pr->prev!
=NULL&&pr->prev->state=='N'）{/*回收区的前一分区空闲*/
if（pr->next->state=='N'）{/*回收区的前后分区都空闲*/
pr->state='N';
pr->prev->size+=（pr->size+pr->next->size）;/*合并分区大小*/
pr->prev->next=pr->next->next;/*删除回收分区及其后一空闲分区表项*/
pr->next->next->prev=pr->prev;
return0;
}
else{
pr->state='N';
pr->prev->size+=pr->size;
pr->next->prev=pr->prev;
pr->prev->next=pr->next;
return0;
}
}
elseif（pr->next!
=NULL&&pr->next->state=='N'）{
pr->state='N';
pr->size+=pr->next->size;
if（pr->next->next!
=NULL）{
pr->next->next->prev=pr;
pr->next=pr->next->next;
}
elsepr->next=NULL;
return0;
}
}
}
if（pr==NULL）printf（"错误!
此分区不存在或未分配作业或前后分区都不空闲!
\n"）;
elseprintf（"分区%s回收完毕!
\n",pr->name）;
return0;
}
allocate（ints）{
TABLE*pt=NULL,*q;
for（pt=tab;pt!
=NULL;pt=pt->next）{
if（pt->size>=s&&pt->state=='N'）{
pt->state='D';
if（pt->size>s）{
q=getpch（TABLE）;
printf（"请输入分割出的分区ID:
\n"）;
scanf（"%s",q->name）;
q->size=pt->size-s;/*分割分区*/
pt->size-=q->size;
q->state='N';
q->addr=pt->addr+pt->size;
if（pt->next!
=NULL）{
pt->next->prev=q;/*在空闲链中插入新的分区*/
q->next=pt->next;
pt->next=q;
q->prev=pt;
return0;
}
pt->next=q;
q->prev=pt;
q->next=NULL;
}
return0;
}
}/*for*/
printf（"没有合适的分区,此次分配失败!
\n"）;
return0;
}
display（）{
TABLE*pt=tab;
if（pt==NULL）return0;
printf（"---------空闲分区情况---------\n"）;
printf（"ID\t状态\t大小\t起始地址\n"）;
while（pt!
=NULL）{
printf（"%2s\t%3c\t%3d\t%5d\n",pt->name,pt->state,pt->size,pt->addr）;
pt=pt->next;
}
return0;
}
sorttable（）{/*分区按升序排列*/
TABLE*first,*second;
if（tab==NULL）{
p->next=tab;
tab=p;
}
else{
first=tab;
second=first->next;
while（second!
=NUL
升级会员 