存储管理实验报告18386.docx

存储管理实验报告18386.docx

《存储管理实验报告18386.docx》由会员分享，可在线阅读，更多相关《存储管理实验报告18386.docx（31页珍藏版）》请在冰点文库上搜索。

存储管理实验报告18386

存储管理实验报告

题目：

1。

存储管理

描述请求分页存储管理。

一.产生一个作业及作业页面序列P（pi），例如：

P（0,2,3,4,1,5,2,3,0,4,1,5）。

二.分配物理内存块数M。

三.采用FIFO，LRU置换算法。

四.设计原理：

本程序提供两种分区管理法供用户使用，这两种算法是最佳适应算法和首次适应算法。

最佳适应算法要求将所有的空闲区，按其大小以递增的顺序形成一空闲区链。

这样，第一次找到的满足要求的空闲区，必然是最优的。

但该算法会留下许多这样难以利用的小空闲区。

首次适应算法要求空闲分区链以地址递增的次序链接。

在进行内存分配时，从链首开始顺序查找，直至找到一个能满足其大小要求的空闲分区为止。

然后，再按照作业的大小，从该分区中划出一快内存空间分配该请求者，余下的空闲分区仍留在空闲链中。

三．不足之处：

该程序可以用文件形式输入作业的信息，但是该文件没有绑定在程序中。

不过，用户用键盘输入的作业的信息会自动保存到该文件中，下次当以文件形式输入作业信息时，文件中的内容是上一次用户用键盘输入的内容。

四．源程序以及解释：

#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）->next;

if（startAddress+size==q->startAddress）//插入空闲分区

{

q->startAddress=startAddress;

q->size+=size;

}

elseif（startAddress+s