标签：
实验三 内存的分配与回收
物联网工程 赖燕菲 201306104147
一、实验目的
为了合理地分配和使用这些存储空间，当用户提出申请主存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间和使用情况，找出足够的空闲区域给申请者。当作业撤离归还主存资源时，则存储管理要收回占用的主存空间。主存的分配和回收的实现是与主存储器的管理方式有关的，通过本实验帮助我们理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
用高级语言完成一个主存空间的分配和回收模拟程序，以加深对内存分配方式及其算法的理解。
二、实验内容和要求
要求：
1）实现特定的内存分配算法
2）实现内存回收模拟
3）每种内存分配策略对应的碎片数统计
a.固定分区存储管理；
b.动态分区分配存储管理
内容：
1) 固定分区存储管理
假设内存容量为120KB，并且分别划分成8,16,32,64KB大小的块各一块。一个进程所需要的内存为0到100个KB。同时假设一个进程在运行过程中所需内存的大小不变。
模拟五个进程到达请求分配与运行完回收情况,输出主存分配表.
2）动态分区分配存储管理
采用连续分配方式之动态分区分配存储管理，使用首次适应算法、下次适应算法、最佳适应算法和最坏适应算法4种算法完成设计(任选两种算法)。
（1）在程序运行过程，由用户指定申请与释放。
（2）设计一个已占用分区表，以保存某时刻主存空间占用情况。
（3）设计一个空闲分区表，以保存某时刻主存空间剩余情况。
（4）用两个表的变化情况,反应各进程所需内存的申请与释放情况。
三、实验方法、步骤及结果测试
1. 源程序名：gu（rar或zip）中源程序名1.c,2.c
原理分析及流程图
1.固定分区内存管理
主要设计思路：
1.固定分区内存管理
该程序定义一个数组home,由于固定分配好5个固定大小的内存空间，先将5个固定大小的内存空间的各个属性先初始化，然提醒用户，输入要执行进程的名字和大小，当内存的大小大于且最接近进程的大小，还有没有被占用，则将内存的state改为进程的名字，当下次用户再输入进程时，就不会去占用已经被其他进程占用的内存块。
2.动态分区分配存储管理
该程序定义两个数组分别存放空闲区和作业区的起始地址，长度，结束地址。先将空闲区的个数初始化为1，然后提醒用户输入进程的大小，相应的在作业新增一条数据，在空闲区则少一条数据。
主要程序段及其解释：
1.固定分区内存管理
typedef struct save{
int sort;
int size;
int start;
char state;
}node;
node home[10];
//初始化内存块的各个属性
void inflate()
{
home[1].sort=1;
home[1].size=8;
home[1].start=30;
home[1].state=‘0‘;
home[2].sort=2;
home[2].size=16;
home[2].start=38;
home[2].state=‘0‘;
home[3].sort=3;
home[3].size=32;
home[3].start=54;
home[3].state=‘0‘;
home[4].sort=4;
home[4].size=64;
home[4].start=118;
home[4].state=‘0‘;
}
//显示各个内存块的信息
void show()
{
int i;
printf("show the message\n");
for(i=1;i<5;i++){
printf("%5d%5d%5d%5c",home[i].sort,home[i].size,home[i].start,home[i].state);
printf("\n");
}
}
main()
{
char name;
int m;
int j,flag=1;
inflate();//初始化内存块
show();
//定义一个标志位flag,如果flag为1则一直提醒用户输入进程，否则，内存块已经被全部占用了，无法为其他进程分配内存空间。
while(flag)
{
printf("please input the process of name and size\n");
scanf("%c%d",&name,&m);
flag=0;
for(j=1;j<5;j++){
if(home[j].state==‘0‘ && home[j].size>m){
home[j].state=name;
flag=1;
break;
}
}
if(flag==0){
printf("无法分配\n");
}
for(j=1;j<5;j++)
{
printf("%5d%5d%5d%5c",home[j].sort,home[j].size,home[j].start,home[j].state);
printf("\n");
if(home[j].state==‘0‘)
{
flag=1;
}
}
getchar();
}
#define N 10000
int xian;//空闲分区的个数
int zuo;//作业区的个数
struct kongxian
{
int start; //起址
int end; //结束
int length; //长度
}kongxian[N];
struct zuoye
{
int start; //起址
int end; //结束
int length; //长度
}zuoye[N];
int cmp1(const void *a,const void *b)
{
return (*(struct kongxian *)a).start-(*(struct kongxian *)b).start;
}
int cmp2(const void *a,const void *b)
{
return (*(struct zuoye *)a).start-(*(struct zuoye *)b).start;
}
void init()
{
xian=1; //初始时只有一个空闲区
zuo=0; //初始没有作业
kongxian[0].start=0;
kongxian[0].end=1023;
kongxian[0].length=1024;
}
void print1() //打印空闲分区
{
int i;
for(i=0;i<xian;i++)
printf("空闲分区ID:%d 起止:%d 结束:%d 长度:%d\n",i,kongxian[i].start,kongxian[i].end,kongxian[i].length);
}
void print2() //打印作业分区
{
int i;
for(i=0;i<zuo;i++)
printf("作业分区ID：%d 起止:%d 结束:%d 长度:%d\n",i,zuoye[i].start,zuoye[i].end,zuoye[i].length);
}
int main()
{
int i,j,k,t,len,flag,id;
int front,middle, behind;
int t1,t2;
init();
print1();
printf("输入1装入新作业，输入0回收作业，输入-1结束\n");
while(scanf("%d",&t)!=EOF)
{
if(t==1) //装入新作业
{
printf("请输入作业的占用空间的长度 ");
scanf("%d",&len);
flag=0;
for(i=0;i<xian;i++)
{
if(kongxian[i].length>=len) //首次适应算法
{
flag=1;
break;
}
}
if(!flag)
{
printf("内存分配失败\n");
}
else
{
//将该作业加入作业区里
zuoye[zuo].start=kongxian[i].start;
zuoye[zuo].end=zuoye[zuo].start+len;
zuoye[zuo].length=len;
zuo++; //作业数加1
if(kongxian[i].length==len) //该分区全部用于分配，删除该空闲分区
{
for(j=i;j<xian-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
xian--;
}
else //该空闲分区部分用于分配，剩余的留在空闲分区中
{
kongxian[i].start+=len;
kongxian[i].length-=len;
}
}
}
else if(t==0)
{
printf("输入要回收的作业ID ");
scanf("%d",&id);
front=middle=behind=0;
for(i=0;i<xian;i++)
{
if(kongxian[i].start>zuoye[id].end)
break;
if(kongxian[i].end==zuoye[id].start) //待回收的作业上面有空闲分区
{
front=1;
t1=i;
}
if(kongxian[i].start==zuoye[id].end) //待回收的作业下面有空闲分区
{
behind=1;
t2=i;
}
}
if(!front&&!behind) //待回收的作业上下均没有空闲分区
{
kongxian[xian].start=zuoye[id].start;
kongxian[xian].end=zuoye[id].end;
kongxian[xian].length=zuoye[id].length;
xian++; //空闲分区增加一个
qsort(kongxian,xian,sizeof(struct kongxian),cmp1); //插入空闲分区后排序
for(j=id;j<zuo-1;j++) //在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
zuo--;
}
if(front &&behind) //待回收的作业上下均有空闲分区
middle=1;
if(front&&!middle) //合并待回收的作业和上面的空闲分区
{
kongxian[t1].end+=zuoye[id].length;
kongxian[t1].length+=zuoye[id].length;
for(j=id;j<zuo-1;j++) //在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
zuo--;
}
if(middle) //合并待回收的作业和上下的空闲分区
{
kongxian[t1].end=kongxian[t2].end;
kongxian[t1].length+=(zuoye[id].length+kongxian[t2].length);
//删除空闲分区t2
for(j=t2;j<xian-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
xian--;
for(j=id;j<zuo-1;j++) //在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
zuo--;
}
if(behind &&!middle) //合并待回收的作业和下面的分区
{
kongxian[t2].start-=zuoye[id].length;
kongxian[t2].length+=zuoye[id].length;
for(j=id;j<zuo-1;j++) //在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
zuo--;
}
}
else
{
printf("操作结束\n");
break;
}
print1();
print2();
}
return 0;
}
1.固定分区内存管理
2. 动态分区分配存储管理
四、实验总结
通过这次实验，从最开始不明白如何实现内存分配管理，到现在大概了解了进程内存分配管理的算法。在编程过程中，通过与同学交流思考，以及自己在课后的思考和上网查阅相关程序片段，摘网上的程序，并理解了网上程序的算法实现过程。本次实验是我在网上摘的程序，再加上自己的理解，实现了简单的算法。本次实验感触最深的是自己C语言基础薄，当然也有很大的收获就是锻炼了自己调试程序的能力以及编程思维得到锻炼。还有一个重要的体会是要善于运用网络上的一些有用的资源，它可以成为你学习的一种很有用的工具。
标签：
原文地址：http://www.cnblogs.com/lyfzero/p/5089964.html
