请求分页式存储管理.docx
《请求分页式存储管理.docx》由会员分享，可在线阅读，更多相关《请求分页式存储管理.docx（29页珍藏版）》请在冰豆网上搜索。
请求分页式存储管理
江南大学物联网工程学院实验报告
课程名称操作系统实践实验名称请求分页式存储管理实验日期2011-5-13
班级_计科0802姓名_刘伟_学号_0304080230仪器编号_________
实验报告要求1实验目的2实验要求3实验步骤4程序清单5运行情况6流程图7实验体会
1．实验目的
理解内存页面调度的机理，掌握几种理论调度算法实现，并通过实验比较各种调度算法的优劣。
2．实验要求
采用请求分页式存储管理方式对作业及内存进行管理
3．编程环境
编程工具：
VC++6.0
平台：
windowsXP
4．实验原理
本程序提供两种分区管理法供用户使用，这两种算法是最佳适应算法和首次适应算法。
最佳适应算法要求将所有的空闲区，按其大小以递增的顺序形成一空闲区链。
这样，第一次找到的满足要求的空闲区，必然是最优的。
但该算法会留下许多这样难以利用的小空闲区。
首次适应算法要求空闲分区链以地址递增的次序链接。
在进行内存分配时，从链首开始顺序查找，直至找到一个能满足其大小要求的空闲分区为止。
然后，再按照作业的大小，从该分区中划出一快内存空间分配该请求者，余下的空闲分区仍留在空闲链中。
不足之处：
该程序可以用文件形式输入作业的信息，但是该文件没有绑定在程序中。
不过，用户用键盘输入的作业的信息会自动保存到该文件中，下次当以文件形式输入作业信息时，文件中的内容是上一次用户用键盘输入的内容。
5．程序清单
#include
#include
#include
intmemoryStartAddress=-1;
intmemorySize=-1;
structjobList
//作业后备队列的链结点
{
intid;//作业的ID号
intsize;//作业的大小
intstatus;//作业状态
structjobList*next;
};
structfreeList//空闲链的链结点
{
intstartAddress;//空闲分区的首地址
intsize;//空闲分区的大小
structfreeList*next;
};
structusedList//已分配内存的作业链
{
intstartAddress;//以分配内存的首地址
intjobID;
structusedList*next;
};
voiderrorMessage（void）//出错信息
{
printf（"\n\t错误!
\a"）;
printf（"\n按任意键继续!
"）;
getch（）;
exit
（1）;
}
voidopenFile（FILE**fp,char*filename,char*mode）//打开文件函数
{
if（（*fp=fopen（filename,mode））==NULL）
{
printf（"\n不能打开%s.",filename）;
errorMessage（）;
}
}
voidmakeFreeNode（structfreeList**empty,intstartAddress,intsize）//申请内存空间
{
if（（*empty=malloc（sizeof（structfreeList）））==NULL）
{
printf（"\n没有足够空间."）;
errorMessage（）;
}
（*empty）->startAddress=startAddress;//当有足够空间时，则分配
（*empty）->size=size;
（*empty）->next=NULL;
}
voidiniMemory（void）//输入要求分配内存的首地址，大小
{
charMSA[10],MS[10];
printf（"\n请输入要分配内存的首地址!
"）;
scanf（"%s",MSA）;
memoryStartAddress=atoi（MSA）;
printf（"\n请输入要分配内存的大小!
"）;
scanf（"%s",MS）;
memorySize=atoi（MS）;
}
charselectFitMethod（void）//选择分区管理算法
{
FILE*fp;
charfitMethod;
do{
printf（"\n\n请选择分区管理的算法!
\
\n1最佳适应算法\
\n2首次适应算法\n"）;
fitMethod=getche（）;
}while（fitMethod<'1'||fitMethod>'3'）;//选择出错时
openFile（&fp,"d:
\\result.cl","a"）;
switch（fitMethod）
{
case'1':
fprintf（fp,"\n\n\n\n\t最佳适应算法"）;
fprintf（fp,"\n**********************************************"）;
break;
case'2':
fprintf（fp,"\n\n\n\n\t首次适应算法"）;
fprintf（fp,"\n**********************************************"）;
break;
}
fclose（fp）;
returnfitMethod;
}
voidinputJob（void）//输入作业的信息
{
int/*id,size,*/status=0,jobnum=0;
FILE*fp;
charid[10],size[10];
openFile（&fp,"d:
\\job.cl","w"）;
fprintf（fp,"作业名\t大小\t状态"）;
printf（"\n\n\n\n请输入作业名和大小!
\n输入00退出，job_ID由数字组成\n\n\njob_ID\tsize\n"）;
do{
/*scanf（"%d%d",&id,&size）;*/
scanf（"%s\t%s",id,size）;//保存作业ID，大小
if（atoi（id）>0&&atoi（size）>0）
{
fprintf（fp,"\n%s\t%s\t%d",id,size,status）;
/*fprintf（fp,"\n%d\t%d\t%d",id,size,status）;*/
jobnum++;
}
elsebreak;
}while
（1）;
if（jobnum）
printf（"\n完成输入!
"）;
else
{
printf（"\n没有请求分配内存."）;
errorMessage（）;
}
fclose（fp）;
}
intmakeJobList（structjobList**jobs）//把作业插入分区
{
charjobID[10],size[10],status[10];
structjobList*rear;
FILE*fp;
openFile（&fp,"d:
\\job.cl","r"）;
fscanf（fp,"%s%s%s",jobID,size,status）;
if（（*jobs=malloc（sizeof（structjobList）））==NULL）//当没有空闲分区时
{
printf（"\n没有足够空间."）;
fclose（fp）;
errorMessage（）;
}
rear=*jobs;
（*jobs）->next=NULL;
while（!
feof（fp））
{
structjobList*p;
fscanf（fp,"%s%s%s",jobID,size,status）;
if（（p=malloc（sizeof（structjobList）））==NULL）
{
printf（"\n没有足够空间."）;
fclose（fp）;
errorMessage（）;
}
p->next=rear->next;//插入已在分区的作业队列中
rear->next=p;
rear=rear->next;
rear->id=atoi（jobID）;
rear->size=atoi（size）;
rear->status=atoi（status）;
}
fclose（fp）;
return0;
}
intupdateJobFile（structjobList*jobs）
{
FILE*fp;
structjobList*p;
openFile（&fp,"d:
\\job.cl","w"）;
fprintf（fp,"job_ID\tsize\tstatus"）;
for（p=jobs->next;p;p=p->next）
fprintf（fp,"\n%d\t%d\t%d",p->id,p->size,p->status）;
fclose（fp）;
return0;
}
intshowFreeList（structfreeList*empty）//在屏幕上显示空闲分区
{
FILE*fp;
structfreeList*p=empty->next;
intcount=0;
openFile（&fp,"d:
\\result.cl","a"）;
fprintf（fp,"\n\n显示空闲内存"）;
printf（"\n\n显示空闲内存"）;
if（p）
{
fprintf（fp,"\nnumber\tsize\tstartAddress"）;
printf（"\n序号\t大小\t开始地址"）;//显示空闲分区的大小和首地址
for（;p;p=p->next）
{
fprintf（fp,"\n%d\t%d\t%d",++count,p->size,p->startAddress）;
printf（"\n%d\t%d\t%d",count,p->size,p->startAddress）;
}
fclose（fp）;
return1;
}
Else//没有空闲分区
{
fprintf（fp,"\n内存已分配完!
"）;
printf（"\n内存已分配完!
"）;
fclose（fp）;
return0;
}
}
voidgetJobInfo（structjobList*jobs,intid,int*size,int*status）//查找作业是否在分区中
{
structjobList*p=jobs->next;
while（p&&p->id!
=id）//删除作业
p=p->next;
if（p==NULL）
{
printf（"\n不能找到作业:
%d.",id）;
errorMessage（）;
}
else
{
*size=p->size;
*status=p->status;
}
}
voidupdateJobStatus（structjobList**jobs,intid,intstatus）//改变作业的状态
{
structjobList*p=（*jobs）->next;
while（p&&p->id!
=id）
p=p->next;
if（p==NULL）
{
printf（"\n不能找到作业:
%d.",id）;
errorMessage（）;
}
else
p->status=status;//作业状态
}
intshowUsedList（structjobList*jobs,structusedList*used）//显示以分配的分区
{
FILE*fp;
structusedList*p=used->next;
intcount=0,size,status;
openFile（&fp,"d:
\\result.cl","a"）;
fprintf（fp,"\n\n显示已分配的内存"）;
printf（"\n\n显示已分配的内存"）;
if（p）
{
fprintf（fp,"\nnumber\t作业名\t大小\t开始地址"）;
printf（"\nnumber\t作业名\t大小\t开始地址"）;//显示分区中的作业信息
for（;p;p=p->next）
{
getJobInfo（jobs,p->jobID,&size,&status）;
fprintf（fp,"\n%d\t%d\t%d\t%d",++count,p->jobID,size,p->startAddress）;
printf（"\n%d\t%d\t%d\t%d",count,p->jobID,size,p->startAddress）;
}
fclose（fp）;
return1;
}
Else//分区中没有作业
{
fprintf（fp,"\n内存中没有作业."）;
printf（"\n内存中没有作业."）;
fclose（fp）;
return0;
}
}
intshowJobList（structjobList*jobs）//分区上的作业
{
structjobList*p;
p=jobs->next;
if（p==NULL）
{
printf（"\n列表上没有作业."）;
return0;
}
printf（"\n\nT列表上的作业如下:
\n作业名\t大小\t状态"）;//显示作业信息
while（p）
{
printf（"\n%d\t%d\t%d",p->id,p->size,p->status）;
p=p->next;
}
return1;
}
voidmoveFragment（structjobList*jobs,structfreeList**empty,structusedList**used）//当回收一部分分区后，进行碎片紧凑
{
intsize,status;
structusedList*p;
intaddress=memoryStartAddress;
if（（*empty）->next==NULL）//当没有空闲分区分配时，可以回收已分配内存
{
printf（"\n内存已用完.\
\n你可以先回收一些内存或者\
\n按任意键再试一次!
"）;
getch（）;
return;
}
for（p=（*used）->next;p;p=p->next）//插入作业
{
p->startAddress=address;
getJobInfo（jobs,p->jobID,&size,&status）;
address+=size;
}
（*empty）->next->startAddress=address;//删除作业，回收内存
（*empty）->next->size=memorySize-（address-memoryStartAddress）;
（*empty）->next->next=NULL;
}
voidorder（structfreeList**empty,intbySize,intinc）//按顺序排列分区的作业
{
structfreeList*p,*q,*temp;
intstartAddress,size;
for（p=（*empty）->next;p;p=p->next）
{
for（temp=q=p;q;q=q->next）
{
switch（bySize）
{
case0:
switch（inc）
{
case0:
if（q->sizesize）//交换作业位置
temp=q;break;
default:
if（q->size>temp->size）//交换作业位置
temp=q;break;
}break;
default:
switch（inc）
{
case0:
if（q->startAddressstartAddress）
temp=q;break;//交换作业位置
default:
if（q->startAddress>temp->startAddress）
temp=q;break;//交换作业位置
}break;
}
}
if（temp!
=p）
{
startAddress=p->startAddress;
size=p->size;
p->startAddress=temp->startAddress;
p->size=temp->size;
temp->startAddress=startAddress;
temp->size=size;
}
}
}
intallocate（structfreeList**empty,intsize）//按要求把分区分该作业
{
structfreeList*p,*prep;
intstartAddress=-1;
p=（*empty）->next;
while（p&&p->size//没有足够分区，删除作业
p=p->next;
if（p!
=NULL）
{
if（p->size>size）//当有足够分区，直接分配
{
startAddress=p->startAddress;
p->startAddress+=size;
p->size-=size;
}
else//将整个分区分给一个作业
{
startAddress=p->startAddress;
prep=*empty;
while（prep->next!
=p）
prep=prep->next;
prep->next=p->next;
free（p）;
}
}
elseprintf（"\n你可以拼接碎片."）;/*Unsuccessful!
*/
returnstartAddress;
}
voidinsertUsedNode（structusedList**used,intid,intstartAddress）
//在分区中插入作业
{
structusedList*q,*r,*prer;
if（（q=malloc（sizeof（structusedList）））==NULL）//没有足够空间时
{
printf（"\nNotenoughtoallocatefortheusednode."）;
errorMessage（）;
}
q->startAddress=startAddress;//插入作业
q->jobID=id;
prer=*used;
r=（*used）->next;
while（r&&r->startAddress{
prer=r;
r=r->next;
}
q->next=prer->next;
prer->next=q;
}
intfinishJob（structusedList**used,intid,int*startAddress）//删除作业，回收分区
{
structusedList*p,*prep;
prep=*used;
p=prep->next;
while（p&&p->jobID!
=id）//删除作业
{
prep=p;
p=p->next;
}
if（p==NULL）
{
printf（"\n作业:
%d不在内存!
",id）;//找不到要删除的作业
return0;
}
else
{
*startAddress=p->startAddress;
prep->next=p->next;
free（p）;
return1;
}
}
voidinsertFreeNode（structfreeList**empty,intstartAddress,intsize）//插入空闲分区
{
structfreeList*p,*q,*r;
for（p=*empty;p->next;p=p->next）;
if（p==*empty||p->startAddress+p->size//对空闲分区进行排列
{
makeFreeNode（&r,startAddress,size）;
r->next=p->next;
p->next=r;
return;
}
if（p->startAddress+p->size==startAddress）//插入空闲分区
{
p->size+=size;
return;
}
q=（*empty）->n
升级会员 