实验三 存储管理实验012622沈桂江.docx

实验三 存储管理实验012622沈桂江.docx

《实验三 存储管理实验012622沈桂江.docx》由会员分享，可在线阅读，更多相关《实验三 存储管理实验012622沈桂江.docx（37页珍藏版）》请在冰豆网上搜索。

实验三存储管理实验012622沈桂江

实验三存储管理实验2014012622沈桂江

西北农林科技大学信息工程学院实习报告课程计算机操作系统学院信息工程专业年级软件141学号**********姓名沈桂江

周次10交报告时间成绩

实验三存储管理实验

一.目的要求:

1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。

熟悉虚存管理的各种页面淘汰算法。

2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

二（实习内容:

1、设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。

可以假定每个作业都是批处理作业，并且不允许动态申请内存。

为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。

2、设计一个可变式分区分配的存储管理方案。

并模拟实现分区的分配和回收过程。

对分区的管理法可以是下面三种算法之一:

首次适应算法

循环首次适应算法

最佳适应算法

3、编写并调试一个段页式存储管理的地址转换的模拟程序。

首先设计好段表、页表，然后给出若干个有一定代表性的地址，通过查找段表页表后得到转换的地址。

要求打印转换前的地址，相应的段表，页表条款及转换后的地址，以便检查。

三（实习任务及完成情况:

1.设计存储算法流程图:

图1-1

图1-2段表、页表和内存的关系2.第一道题:

设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。

（1）编写程序源代码:

#include

#defineN5

structfreearea/*定义一个空闲区说明表结构,并初始化变量*/{

intstartaddress;/*空闲区地址*/

intsize;/*空闲区大小*/

intstate;/*空闲区状态:

0为空表目,1为可用空闲块*/}freeblock[N]=

{{20,20,1},{80,50,1},{150,100,1},{300,30,0},{600,100,1}};

/*定义为作业分配主存空间的函数alloc（）*/intalloc（intapplyarea）/*applyarea为作业申请量*/{

inti,tag=0;/*tag为检查是否有满足作业若需要的空闲区的标志*/

for（i=0;i

if（freeblock[i].state==1&&freeblock[i].size>applyarea）

{

startaddress=freeblock[i].startaddress+applyarea;freeblock[i].

freeblock[i].size=freeblock[i].size-applyarea;

tag=1;/*有满足条件的空闲区时,tag置1*/

returnfreeblock[i].startaddress-applyarea;

}

elseif（freeblock[i].state==1&&freeblock[i].size==applyarea）

{

freeblock[i].state=0;

tag=1;/*有满足条件的空闲区时,tag置1*/

returnfreeblock[i].startaddress;/*返回为作业分配的主存地

址*/

}

if（tag==0）

return-1;/*没有满足条件的空闲区,分配不成功,返回-1*/

}

/*定义主存回收函数:

setfree（）*/

/*tag1代表释放区的高地址是否邻接一个空闲区,tag2代表释放区的高低地址

是否都邻接一个空闲区,tag3代表释放区的低地址是否邻接一个空闲区*/

voidsetfree（）

{

intstart,length,tag1=0,tag2=0,tag3=0,i,j;

printf（"输入空闲区的起始地址:

\n"）;

scanf（"%d",&start）;/*输入释放区的开始地址*/

printf（"输入空闲区的大小:

\n"）;

scanf（"%d",&length）;/*输入释放区的大小*/

for（i=0;i

{

if（freeblock[i].startaddress==start+1&&freeblock[i].state==1）

{

length=1+freeblock[i].size;

tag1=1;/*有与释放区的高地址邻接的空闲区,tag1置1*/

for（j=0;j

if（freeblock[j].startaddress+freeblock[j].size==start&&freeblock[j].s

tate==1）

{

freeblock[i].state=0;

freeblock[j].size=freeblock[j].size+1;

tag2=1;/*有与释放区上下都邻接的空闲区,tag2置1*/

break;

}

if（tag2==0）/*无与释放区高地址邻接的空闲区*/

{

freeblock[i].startaddress=start;

freeblock[i].size=1;

break;

}

}

}

if（tag1=0）/*无与释放区高地址邻接的空闲区,检查是否低地址有邻接空闲区*/

{

for（i=0;i

if（freeblock[i].startaddress+freeblock[i].size==start&&freeblock[i].s

tate==1）

{

freeblock[i].size=freeblock[i].size+1;

tag3=1;/*有与释放区低地址邻接的空闲区,tag3置1*/

break;

}

if（tag3==0）/*无与释放区高低地址邻接的空闲区*/

for（j=0;j

if（freeblock[j].state==0）/*找一个空白表,将释放区放入表中*/

{

freeblock[j].startaddress=start;

freeblock[j].size=1;

freeblock[j].state=1;

break;

}

}

}

/*定义对空闲区表中的空闲区调整的函数adjust（）,使空闲区按始地址从小到

大排列,空表目放在后面*/

voidadjust（）

{

inti,j;

structfreeareamiddata;

for（i=0;i

for（j=0;j

if（freeblock[j].startaddress>freeblock[j+1].startaddress）

{

middata.startaddress=freeblock[j].startaddress;

middata.size=freeblock[j].size;

middata.state=freeblock[j].state;

freeblock[j].startaddress=freeblock[j+1].startaddress;

freeblock[j].size=freeblock[j+1].size;

freeblock[j].state=freeblock[j+1].state;

freeblock[j+1].startaddress=middata.startaddress;

freeblock[j+1].size=middata.size;

freeblock[j+1].state=middata.state;

}

for（i=0;i

for（j=0;j

if（freeblock[j].state==0&&freeblock[j+1].state==1）

{

middata.startaddress=freeblock[j].startaddress;

middata.size=freeblock[j].size;

middata.state=freeblock[j].state;

freeblock[j].startaddress=freeblock[j+1].startaddress;

freeblock[j].size=freeblock[j+1].size;

freeblock[j].state=freeblock[j+1].state;

freeblock[j+1].startaddress=middata.startaddress;

freeblock[j+1].size=middata.size;

freeblock[j+1].state=middata.state;

}

}

/*定义打印空闲区说明表函数:

print（）*/

voidprint（）

{

inti;

printf（"

|................................................|\n"）;

printf（"|startsizestate|\n"）;

printf（"

|................................................|\n"）;

for（i=0;i

{

printf（"|%3d%3d%5d

|\n",freeblock[i].startaddress,freeblock[i].size,freeblock[i].state）;

printf（"

|................................................|\n"）;

}

}

voidmain（）/*主函数*/

{

intapplyarea,start,j;

charend;

printf（"\n有任何工作请求内存?

yorn:

"）;

while（（end=getchar（））=='y'）

{

printf（"在这第一空闲内存:

\n"）;

adjust（）;/*对空闲区表中的空闲区调整的函数*/

print（）;/*打印空闲区表的初始状态*/

printf（"输入请求内存的大小:

"）;

scanf（"%d",&applyarea）;/*输入作业的申请量*/

start=alloc（applyarea）;/*调用alloc（）函数,为作业分配空

间,start为返回的始地址*/

adjust（）;

printf（"分配后，可用内存是:

\n"）;

print（）;/*打印空闲区表*/

if（start==-1）/*alloc（）分配不成功时,返回-1*/

printf（"没有合适的内存，请稍等\n"）;

else

printf（"工作的内存起始地址:

%d\n",start）;

printf（"工作尺寸:

%d\n",applyarea）;

printf（"工作运行.\n"）;

printf（"任务终止..\n"）;

for（j=1;j<100000;j++）;/*延迟时间*/

setfree（）;/*主存回收函数*/

adjust（）;/*调整空闲区说明表*/

print（）;/*打印空闲区表函数*/

printf（"有任何工作在等待?

y/n:

"）;

end=getchar（）;/*是否有作业等待?

有（Y）无（N）*/

}

}

（2）程序运行结果:

图2-1内存初始化操作

图2-2请求输入大小为90的内存

图2-3从空闲区为0的地址开始搜索符合的内存

图2-4请求输入大小为99的内存

图2-5从起始地址为20开始请求分配大小为8的内存

图2-6请求分配大小为100的内存，空间不足分配失败2.第二道题:

设计一个可变式分区分配的存储管理方案。

并模拟实现分区的分配和回收过程。

（1）编写程序源代码:

#include

#include#defineFree0//空闲状态

#defineBusy1//已用状态

#defineOK1//完成

#defineERROR0//出错

#defineMAX_length32767//最大内存空间为32767KBtypedefintStatus;intn=0;

typedefstructfreearea//定义一个空闲区说明表结构{

intID;//分区号

longsize;//分区大小

longaddress;//分区地址

intstate;//状态

}ElemType;

//----------线性表的双向链表存储结构------------

typedefstructDuLNode//doublelinkedlist

{

ElemTypedata;

structDuLNode*prior;//前趋指针

structDuLNode*next;//后继指针

}DuLNode,*DuLinkList;

DuLinkListblock_first;//头结点

DuLinkListblock_last;//尾结点

Statusalloc（int）;//内存分配

Status_free（int）;//内存回收

StatusFirst_fit（int,int）;//首次适应算法

StatusBest_fit（int,int）;//最佳适应算法

voidshow（）;//查看分配

StatusInitblock（）;//开创空间表

StatusInitblock（）//开创带头结点的内存空间链表

{

block_first=（DuLinkList）malloc（sizeof（DuLNode））;

block_last=（DuLinkList）malloc（sizeof（DuLNode））;

block_first->prior=NULL;

block_first->next=block_last;

block_last->prior=block_first;

block_last->next=NULL;

block_last->data.address=0;

block_last->data.size=MAX_length;

block_last->data.ID=0;

block_last->data.state=Free;

returnOK;

}

//-----------------------分配主存-------------------------

Statusalloc（intch）

{

intID,request;

printf（"请输入作业（分区号）:

\n"）;

scanf（"%d",&ID）;

printf（"请输入需要分配的主存大小（单位:

KB）:

\n"）;

scanf（"%d",&request）;

if（request<0||request==0）

{

printf（"分配大小不合适，请重试!

\n"）;

returnERROR;

}

if（ch==2）//选择最佳适应算法

{

if（Best_fit（ID,request）==OK）

printf（"分配成功!

\n"）;

else

printf（"内存不足，分配失败!

\n"）;

returnOK;

}

else//默认首次适应算法

{

if（First_fit（ID,request）==OK）

printf（"分配成功!

\n"）;

else

printf（"内存不足，分配失败!

\n"）;

returnOK;

}

}

//------------------首次适应算法-----------------------StatusFirst_fit（intID,intrequest）//传入作业名及申请量{

//为申请作业开辟新空间且初始化

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.ID=ID;

temp->data.size=request;

temp->data.state=Busy;

DuLNode*p=block_first->next;

while（p）

{

if（p->data.state==Free&&p->data.size==request）

{

//有大小恰好合适的空闲块

p->data.state=Busy;

p->data.ID=ID;

returnOK;

break;

}

if（p->data.state==Free&&p->data.size>request）

{

//有空闲块能满足需求且有剩余"

temp->prior=p->prior;

temp->next=p;

temp->data.address=p->data.address;

p->prior->next=temp;

p->prior=temp;

p->data.address=temp->data.address+temp->data.size;

p->data.size-=request;

returnOK;

break;

}

p=p->next;

}

returnERROR;

}

//--------------------最佳适应算法------------------------

StatusBest_fit（intID,intrequest）

{

intch;//记录最小剩余空间

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.ID=ID;

temp->data.size=request;

temp->data.state=Busy;

DuLNode*p=block_first->next;

DuLNode*q=NULL;//记录最佳插入位置

while（p）//初始化最小空间和最佳位置

{

if（p->data.state==Free&&

（p->data.size>request||p->data.size==request））

{

q=p;

ch=p->data.size-request;

break;

}

p=p->next;

}

while（p）

{

if（p->data.state==Free&&p->data.size==request）

{

//空闲块大小恰好合适

p->data.ID=ID;

p->data.state=Busy;

returnOK;

break;

}

if（p->data.state==Free&&p->data.size>request）

{

//空闲块大于分配需求

if（p->data.size-request

{

ch=p->data.size-request;//更新剩余最小值

q=p;//更新最佳位置指向

}

}

p=p->next;

}

if（q==NULL）

returnERROR;//没有找到空闲块

else

{

//找到了最佳位置并实现分配

temp->prior=q->prior;

temp->next=q;

temp->data.address=q->data.address;

q->prior->next=temp;

q->prior=temp;

q->data.address+=request;

q->data.size=ch;

returnOK;

}

}

//-----------------------主存回收--------------------

Status_free（intID）

{

DuLNode*p=block_first;

while（p）

{

if（p->data.ID==ID）

{

p->data.state=Free;

p->data.ID=Free;

if（p->prior->data.state==Free）//与前面的空闲块相连

{

p->prior->data.size+=p->data.size;

p->prior->next=p->next;

p->next->prior=p->prior;

}

if（p->next->data.state==Free）//与后面的空闲块相连

{

p->data.size+=p->next->data.size;

p->next->next->prior=p;

p->next=p->next->next;

}

break;

}

p=p->next;

}

returnOK;

}

//---------------显示主存分配情况------------------

voidshow（）

{

printf（"***********-----------------************\n\n"）;

printf（"****主存分配情况****\n\n"）;

printf（"***********-----------------************\n\n"）;

DuLNode*p=block_first->next;

while（p）

{

printf（"分区号:

"）;

if（p->data.ID==Free）

printf（"Free\n"）;

else

printf（"%d\n",p->data.ID）;

printf（"起始地址:

%ld\n",p->data.address）;

printf（"分区大小:

%ldKB\n",p->data.size）;

printf（"状态:

"）;

if（p->data.state==Free）

printf（"空闲\n"）;

else

pri