BX121028俞佳星实验5 分区式存储管理.docx

BX121028俞佳星实验5 分区式存储管理.docx

《BX121028俞佳星实验5 分区式存储管理.docx》由会员分享，可在线阅读，更多相关《BX121028俞佳星实验5 分区式存储管理.docx（12页珍藏版）》请在冰豆网上搜索。

BX121028俞佳星实验5分区式存储管理

电子信息学院

实验报告书

课程名：

《操作系统原理实验》

题目：

实验5分区式存储管理

实验类别：

【设计】

班级：

BX1210

学号：

121003531028

姓名：

俞佳星

一、实验内容

设计程序模拟内存的动态分区法存储管理。

内存空闲区使用自由链管理，采用最坏适应算法从自由链中寻找空闲区进行分配，内存回收时假定不做与相邻空闲区的合并。

假定系统的内存共640K，初始状态为操作系统本身占用64K。

在t1时间之后，有作业A、B、C、D分别请求8K、16K、64K、124K的内存空间；在t2时间之后，作业C完成；在t3时间之后，作业E请求50K的内存空间；在t4时间之后，作业D完成。

要求编程序分别输出t1、t2、t3、t4时刻内存的空闲区的状态。

。

二、实验目的与要求

过本次实验，加深对内存管理的认识，进一步掌握内存的分配、回收算法的思想。

三、实验环境

RedHatLinux9；用户名：

root，密码：

123456

四、实验步骤

1.程序中自由链队列的结点类型可描述如下：

structfreelink{

intlen,address;/*len为分区长度；address为分区起始地址

structfreelink/*next;

}

内存占用区用链表描述，其结点类型描述如下：

structbusylink{

charname;/*作业或进程名name=’S’表示OS占用

intlen,address;

structbusylink*next;

}

并设全程量：

structfreelink*free_head=NULL;//自由链队列（带头结点）队首指针

structbusylink*busy_head=NULL,//占用区队列队（带头结点）首指针

*busy_tail=NULL；//占用区队列队尾指针

2.设计子函数：

voidstart（void）;/*设置系统初始状态*/

{structfreelink*p;

structbusylink*q;

free_head=（structfreelink*）malloc（sizeof（structfreelink））;

free_head->next=NULL;//创建自由链头结点

busy_head=busy_tail=（structbusylink*）malloc（sizeof（structbusylink））;

busy_head->next=NULL;//创建占用链头结点

p=（structfreelink*）malloc（sizeof（structfreelink））;

p->address=64;

p->len=640-64;（OS占用了64K）

p->next=NULL;

free_head->next=p;

q=（structbusylink*）malloc（sizeof（structbusylink））;

q->name=’S’;/*S表示操作系统占用*/

q->len=64;q->address=0;q->next=NULL;

busy_head->next=q;busy_tail=q;

}

voidrequireMemo（charname,intrequire）;/*模拟内存分配*/

voidfreeMemo（charname）;/*模拟内存回收*/

voidpast（inttime）;/*模拟系统过了time时间*/

voidprintlink（）;/*输出内存空闲情况（自由链的结点）*/

3、设计主函数：

main（）

{start（）;

past（t1）;

requireMemo（‘A’,8）;requireMemo（‘B’,16）;

requireMemo（‘C’,64）;requireMemo（‘D’,124）;

printlink（）;

past（t2）;

freeMemo（‘C’）;

printlink（）;

past（t3）;

requireMemo（‘E’,50）;

printlink（）;

freeMemo（‘D’）;

printlink（）;

}

4、主要函数设计及流程图

主要函数：

●初始化worstFit（）即worstFit类的构造函数

●模拟内存分配voidrequireMemo（charname,intrequire）

●模拟内存回收voidfreeMemo（charname）

●空闲分区排序voidorder（）

●模拟系统时间voidpast（inttime）

●输出内存空闲情况voidfreePrint（）

●输出内存占用情况voidbusyPrint（）

模拟内存分配函数流程图：

模拟内存分配函数流程图：

5、源程序

packagecom.johnson;

importjava.util.LinkedList;

publicclasssy5{

publicstaticvoidmain（Stringargs[]）{//主函数

worstFitwf=newworstFit（）;

wf.past（5）;

wf.requireMemo（'A',8）;wf.requireMemo（'B',16）;

wf.requireMemo（'C',64）;wf.requireMemo（'D',124）;

wf.busyPrint（）;wf.freePrint（）;

wf.past（10）;

wf.freeMemo（'C'）;

wf.busyPrint（）;wf.freePrint（）;

wf.past（15）;

wf.requireMemo（'E',50）;

wf.busyPrint（）;wf.freePrint（）;

wf.past（20）;

wf.freeMemo（'D'）;

wf.busyPrint（）;wf.freePrint（）;

}

}

//最坏适应算法

classworstFit{

LinkedListfreelink=null;//空闲分区链表

LinkedListbusylink=null;//内存占用链表

//系统初始化

worstFit（）{

freelink=newLinkedList（）;

busylink=newLinkedList（）;

freeSpacefFirst=newfreeSpace（640-64,64）;

busySpacebFirst=newbusySpace（'S',64,0）;

freelink.add（fFirst）;

busylink.add（bFirst）;

System.out.println（"初始化完成。

"）;

}

//模拟内存分配

voidrequireMemo（charname,intrequire）{

if（freelink.size（）>0）//判断是否有空闲分区

if（freelink.get（0）.getLen（）>=require）{//判断第一个空闲分区是否足够

intoLen=freelink.get（0）.getLen（）;//原空闲分区大小

intoAddress=freelink.get（0）.getAddress（）;//原空闲分区地址

freelink.get（0）.setLen（oLen-require）;//修改原空闲分区大小

freelink.get（0）.setAddress（oAddress+require）;//修改原空闲分区地址

busySpacebx=newbusySpace（name,require,oAddress）;//新建内存占用空间

busylink.add（bx）;//添加到内存占用链表

order（）;//对空闲链表重新排序

}

}

//空闲链表_重新排序（从大到小_冒泡法）

voidorder（）{

for（inti=0;i

for（intj=0;j

if（freelink.get（i）.getLen（）

freeSpacefsx=freelink.get（i）;

freelink.set（i,freelink.get（j））;

freelink.set（j,fsx）;

}

}

//模拟内存回收

voidfreeMemo（charname）{

for（inti=0;i

if（busylink.get（i）.getName（）==name）{//寻找要回收的分区是否存在

intoLen=busylink.get（i）.getLen（）;//要回收内存大小

intoAddress=busylink.get（i）.getAddress（）;//要回收内存的地址

busylink.remove（i）;//移除占用的空闲内存

freeSpacefx=newfreeSpace（oLen,oAddress）;//新建空闲分区

freelink.add（fx）;//添加到空闲链表

order（）;//对空闲链表重新排序

break;

}

}

//模拟系统过了时间time

voidpast（inttime）{

try{

Thread.sleep（500）;

}catch（InterruptedExceptione）{

System.out.println（"线程随眠出错！

"）;

}

System.out.println（"\n\n时间"+time+"后"）;

}

//输出内存空闲情况

voidfreePrint（）{

System.out.println（"-----------------内存空闲情况------------------------"）;

if（freelink.size（）>0）

for（inti=0;i

System.out.println（"首地址:

"+freelink.get（i）.getAddress（）+"\t长度:

"+freelink.get（i）.getLen（））;

else

System.out.println（"无空闲区！

"）;

}

//输出内存占用情况

voidbusyPrint（）{

System.out.println（"-----------------内存占用情况------------------------"）;

if（busylink.size（）>0）

for（inti=0;i

System.out.println（"名称:

"+busylink.get（i）.getName（）+"\t首地址:

"+busylink.get（i）.getAddress（）+"\t长度:

"+busylink.get（i）.getLen（））;

else

System.out.println（"无内存占用区！

"）;

}

}

//空闲分区

classfreeSpace{

intlen;

intaddress;

publicfreeSpace（intlen,intaddress）{

this.len=len;

this.address=address;

}

publicintgetLen（）{

returnlen;

}

publicvoidsetLen（intlen）{

this.len=len;

}

publicintgetAddress（）{

returnaddress;

}

publicvoidsetAddress（intaddress）{

this.address=address;

}

}

//使用中的分区

classbusySpace{

charname;//作业或进程名name='S'表示OS占用

intlen,address;

publicbusySpace（charname,intlen,intaddress）{

this.name=name;

this.len=len;

this.address=address;

}

publicchargetName（）{

returnname;

}

publicvoidsetName（charname）{

this.name=name;

}

publicintgetLen（）{

returnlen;

}

publicvoidsetLen（intlen）{

this.len=len;

}

publicintgetAddress（）{

returnaddress;

}

publicvoidsetAddress（intaddress）{

this.address=address;

}

}

五、结果分析与实验体会

在本次实验中我们自己设计程序来模拟内存的动态分区法存储管理。

内存空闲区使用自由链管理，我们采用最坏适应算法从自由链中寻找空闲区进行分配。

通过本次实验的实际操作，我们对内存的管理，以及最坏适应算法有了更深的了解。