基于可重定位分区分配算法的内存管理的设计与实现之欧阳道创编

组号成果
计算机操纵系统
课程设计陈述
题目基于可重定位分区分派算法的内存管理的设计与实现
专业：计算机科学与技术
班级：
学号+姓名：
指导教师：
12月23 日
一．设计目的
掌握内存的连续分派方法的各种分派算法二．设计内容
基于可重定位分区分派算法的内存管理的设计与实现。

本系统模拟操纵系统内存分派算法的实现，实现可重定位分区分派算法，采取PCB界说结构体来暗示一个进程，界说了进程的名称和年夜小，进程内存起始地址和进程状态。

内存分区表采取空闲分区表的形式来模拟实现。

要求界说与算法相关的数据结构，如PCB、空闲分区；在使用可重定位分区分派算法时必须实现紧凑。

三．设计原理
可重定位分区分派算法与静态分区分派算法基本上相同，不同仅在于：在这种分派算法中，增加了紧凑功能。

通常，该算法不克不及找到一个足够年夜的空闲分区以满足用户需求时，如果所有的小的空闲分区的容量总和年夜于用户的要求，这是便须对内存进行“紧凑”，将经过“紧凑”后所获得的年夜空闲分区分派给用户。

如果所有的小空闲分区的容量总和仍小于用户的要求，则前往分派失败信息
四．详细设计及编码
1.模块阐发
（1）分派模块
这里采取首次适应(FF)算法。

设用户请求的分区年夜小为u.size,内存中空闲分区年夜小为m.size,规定的不再切割的剩余空间年夜小为size。

空闲分区按地址递增的顺序排列；在分派内存时，从空闲分区表第一个表目开始顺序查找，如果m.size≥u.size且m.sizeu.size≤size，说明过剩部分太小，不再联系，将整个分区分派给请求者；如果m.size≥u.size且m.sizeu.size>size，就从该空闲分区中按请求的年夜小划分出一块内存空间分派给用户，剩余的部分仍留在空闲分区表中；如果m.size<u.size 则查找下一个空闲分区表项，直到找到一个足够年夜的空闲分区；如果没有找到一个足够年夜的内存空闲分区，但所有的小的空闲分区的容量总和年夜于用户的要求，就进行紧凑，将紧凑后获得的年夜的空闲分区按上述的方法分派给用户；但如果所有的小的空闲分区的容量总和仍不克不及满足用户需要，则分派失败。

（2）内存回收模块
进行内存回收操纵时，先随机产生一个要回收的进程的进程号，把该进程从进程表中中删除，它所释放的空闲内存空间拔出到空闲分区表；如果回收区与拔出点的前一个空闲分区相邻，应将回收区与拔出点的前一分区合并，修改前一个分区的年夜小；如果回收区与拔出点的后一个空闲分区相邻，应将回收区与拔出点的后一分区合并，回收区的首址作为新空闲分区的首址，年夜小为两者之和；如果回收区同时与拔出点的前、后空闲分区相邻，应将三个分区合并，使用前一个分区的首址，取消后一个分区，年夜小为三者之和。

（3）紧凑模块
将内存中所有作业进行移动，使他们全都相邻接，把原来分离的多个空闲小分区拼接成一个年夜分区。

2.流程图
否
否
是是3.代码实现
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<windows.h>
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE 1
#define OVERFLOW 2
#define SIZE 15
////////////////////////////进程表//////////////
int ppNo=1; //用于递增生成进程号
int pLength=0;
struct PCB
{
int pNo; //进程号(名)
int pSize; // 进程年夜小
int pOccupy; // 实际占用的内存 int pStartAddr; // 进程起始地址
int pState; //进程状态
};
struct PCB pList[200];
//////////////////空闲分区表部分/////////////// typedef int Status;
typedef struct emptyNode
{ //空闲分区结构体
int areaSize; //空闲分区年夜小
int aStartAddr; //空闲分区始址
struct emptyNode *next;
}emptyNode,*LinkList;
int ListDelete(struct PCB *pList,int i);//AAA/删除下标为i的进程
void pSort(struct PCB *pList); //AAA/内存中的进程按始址递增排序
void compact(LinkList &L,struct PCB *pList);//AAA/紧凑,内存中进程移动，修改进程数据结构；空闲分区合并，修改空闲分区表数据结构
void amalgamate(LinkList &L); //AAA/回收后进行合并空闲分区
void recycle(LinkList &L,struct PCB *pList); //AAA/回收，从进程表中删除进程，把释放出的空间拔出到空闲分区链表中
Status InitList(LinkList &L); //1AAA/构造一个新的有头节点的空链表L
Status ClearList(LinkList &L); //2AAA/将链表L重置为空表
Status ListInsert(LinkList &L,LinkList s1); //AAA/*****根据始址进行拔出
void DeleteElem(LinkList &L,int aStartAddr);//*****删除线性表中始址值为aStartAddr的结点
void PrintList(LinkList L); //AAA/*****输出各结点的值
void creatP(struct PCB *p); //AAA/初始化进程
int search(LinkList &L,int pSize); //AAA/检索分区表,前往合适分区的首址
int add(LinkList &L); //AAA/前往空闲分区总和
void pListPrint(struct PCB *pList); //AAA/输出内存中空间占用情况
void distribute(LinkList &L,struct PCB *process);
int ListDelete(struct PCB *pList,int i)//AAA/删除下标为i的进程
{
for(;i<pLength1;i++){
pList[i]=pList[i+1];
}
pLength;
}//ListDelete
void pSort(struct PCB *pList){ //AAA/内存中的进程按始址递增排序
int i,j;
struct PCB temp;
for(i=0;i<pLength1;i++){
for(j=0;j<pLengthi1;j++){
if(pList[j].pStartAddr>pList[j+1].pStartAddr){ temp=pList[j];
pList[j]=pList[j+1];
pList[j+1]=temp;
}
}
}
}
//AAA/紧凑,内存中进程移动，修改进程数据结构；空闲分区合并，修改空闲分区表数据结构
void compact(LinkList &L,struct PCB *pList){ printf("进行紧凑\n");
//1、进程移动,修改进程数据结构
int i;
pList[0].pStartAddr=0; //第一个进程移到最上面
for(i=0;i<pLength1;i++){
pList[i+1].pStartAddr=pList[i].pStartAddr+pList[i].pOc cupy;
}
//2、空闲分区合并，修改空闲分区表数据结构
LinkList p=L>next,s;
int sumEmpty=0;
while(p!=NULL)//求空闲区总和
{
sumEmpty+=p>areaSize;
p=p>next;
}
ClearList(L); //清空空闲分区表
s=(LinkList)malloc(sizeof(emptyNode));
s>aStartAddr=pList[pLength1].pStartAddr+pList[pLeng th1].pOccupy;
s>areaSize=sumEmpty;
ListInsert(L,s);
printf("\n紧凑后的>>>>\n");
pListPrint(pList);
PrintList(L);
}
void amalgamate(LinkList &L){//AAA/回收后进行合并空闲分区
LinkList p=L>next,q=p>next;
while(q!=NULL){
if(p>aStartAddr+p>areaSize==q>aStartAddr){ p>areaSize+=q>areaSize;
DeleteElem(L,q>aStartAddr);//删除被合并的结点
q=p>next;
}else{
p=q;
q=q>next;
}
}
}
//AAA/回收，从进程表中删除进程，把释放出的空间拔出到空闲分区链表中
void recycle(LinkList &L,struct PCB *pList){
int
index,delPNo,delPSize,delPOccupy,delPStartAddr;
LinkList s;
srand(time(0));
index=rand()%pLength;
delPNo=pList[index].pNo;
delPSize=pList[index].pSize;
delPOccupy=pList[index].pOccupy;
delPStartAddr=pList[index].pStartAddr;
printf("________________________________________ ________________________________________");
printf("回收内存进程P%d: 始址：%d K 占用：%d KB\n",delPNo,delPStartAddr,delPOccupy);
printf("\n回收后>>>>\n");
ListDelete(pList,index);
//pListPrint(pList);
s=(LinkList)malloc(sizeof(emptyNode));
s>areaSize=delPOccupy;
s>aStartAddr=delPStartAddr;
ListInsert(L,s);
amalgamate(L);
pListPrint(pList);//输出内存中空间占用情况
PrintList(L);
}
///////////////////////////////////////////
Status InitList(LinkList &L) //1AAA/构造一个新的有头节点的空链表L
{
LinkList s;
L=(LinkList)malloc(sizeof(emptyNode)); //生成新节点(头结点)
if(!L) return ERROR; //申请内存失败
s=(LinkList)malloc(sizeof(emptyNode));
s>areaSize=900;
s>aStartAddr=0;
L>next=s; //头节点的指针域指向第一个结点
s>next=NULL;
return OK;
}//InitList
Status ClearList(LinkList &L) //2AAA/将链表L重置为空表
{
LinkList p,r;
p=L>next; r=p>next;
while(p!=NULL)
{
free(p);
if(r==NULL){
p=NULL;
}else{
p=r;
r=p>next;
}
}
L>next=NULL;
return OK;
}//ClearList
//AAA/*****根据始址进行拔出Status ListInsert(LinkList &L,LinkList s1) {
LinkList r=L,p=L>next,s;//指针
s=(LinkList)malloc(sizeof(emptyNode)); s>areaSize=s1>areaSize;
s>aStartAddr=s1>aStartAddr;
if(p==NULL){
L>next=s;
s>next=NULL;
}else{
while(p!=NULL)
{
if(s1>aStartAddr < p>aStartAddr){
s>next=r>next;
r>next=s;
break;
}
r=p;
p=p>next; //后移
}
i f(p==NULL){
r>next=s;
s>next=NULL;
}
}
return OK;
}//ListInsert2
void DeleteElem(LinkList &L,int aStartAddr)//*****删除线性表中始址值为aStartAddr的结点
{
LinkList p=L,q;
while(p>next!=NULL)
{
q=p>next;
if(q>aStartAddr==aStartAddr)
{
p>next=q>next;
free(q);
}
else
p=p>next;
}
}//DeleteElem
////////////////////////////////////////////////
void PrintList(LinkList L)//AAA/*****输出各结点的值{
printf("\n空闲分区情况: 始址\t 年夜小\n");
LinkList p=L>next;
while(p!=NULL)
{
printf(" %d K\t%d
KB\n",p>aStartAddr,p>areaSize);
p=p>next;
}
printf("\n");
}//PrintList
void creatP(struct PCB *p){ //AAA/初始化进程
int size;
srand(time(NULL));
size=rand()%7+1;
size*=10;
p>pNo=ppNo++;
p>pSize=size;
p>pOccupy=0;
p>pStartAddr=0;
p>pState=0;
}
int search(LinkList &L,int pSize){ //检索分区表,前往合适分区的首址
LinkList p=L>next;
while(p!=NULL)
{
if(p>areaSize>=pSize){
return p>aStartAddr;
}
p=p>next;
}
return 1;//没有足够年夜的
}
int add(LinkList &L){ //前往空闲分区总和 LinkList p=L>next;
int sum=0;
while(p!=NULL)
{
sum+=p>areaSize;
p=p>next;
}
return sum;
}
void pListPrint(struct PCB *pList){//AAA/输出内存中空间占用情况
printf("\n进程分派情况: 进程\t 始址\t占用\n"); for(int i=0;i<pLength;i++){
printf(" P%d\t %d K\t%d KB\n",
pList[i].pNo,pList[i].pStartAddr,pList[i].pOccupy); }
}
void distribute(LinkList &L,struct PCB *process){
LinkList p=L>next;
while(p!=NULL)
{
if(p>areaSize>=process>pSize)
break;
p=p>next;
}
printf("%d KB < %d KB",process>pSize,p>areaSize);
if(p>areaSizeprocess>pSize<=SIZE){
//不必联系全部分派（直接删除此空闲分区结点）process>pStartAddr=p>aStartAddr; //进程始址变更
process>pState=1; //进程状态
process>pOccupy=p>areaSize; //进程实际占用内存为改空闲分区的年夜小
pList[pLength++]= *process; //把进程加入进程列
表
printf(" 且%d KB %d KB = %d KB < %d KB 则整区分派\n",
p>areaSize,process>pSize,p>areaSizeprocess>pSize,SIZ E);
pSort(pList);
printf("\n分派后>>>>\n");
pListPrint(pList);//输出内存中空间占用情况
DeleteElem(L,p>aStartAddr);
}else{//联系分派
process>pStartAddr=p>aStartAddr; //进程始址变更process>pState=1; //进程状态
process>pOccupy=process>pSize; //进程实际占用内存为该进程的年夜小
pList[pLength++]= *process; //把进程加入进程列表
printf(" 且%d KB %d KB = %d KB > %d KB 则划分分派\n",
p>areaSize,process>pSize,p>areaSizeprocess>pSize,SIZ E);
pSort(pList); //进程排序
printf("\n分派后>>>>\n");
pListPrint(pList);//输出内存中空间占用情况
//compact(L,pList);
p>aStartAddr+=process>pSize; //空闲分区始址变更p>areaSize=process>pOccupy; //空闲分区年夜小变更
}
}
int main(){
//0、创建一个进程，参数随机数方法产生
struct PCB p;
int i,num,dele,k,stAddr,flag;
LinkList s,L;
printf("********************************可重定位分区分派********************************");
if(!InitList(L)) //初始化空闲分区表
printf("创建表失败\n");
while(1){
srand(time(0));
flag=rand()%100+1;
if(flag%2==0){
creatP(&p);//初始化进程
printf("_______________________________________ _________________________________________");
printf("待装入作业:%d Size = %d
KB\n",p.pNo,p.pSize);
//1、请求分派size
//2、检索空闲分区表(首次适应FF)
PrintList(L);
stAddr=search(L,p.pSize);//获得足够年夜的分区的始址，没有则前往1
if(stAddr==1){//没有足够年夜的分区
if(add(L)>=p.pSize){//空闲区总和足够年夜
printf("没有足够年夜的空闲分区但空闲总和足够年夜\n");
//紧凑
compact(L,pList);
//按静态分区方法分派
distribute(L,&p);
//compact(L,pList); //紧凑
}else{ //空闲区总和缺乏
printf("分派失败\n\n");
}
}else{//有足够年夜的
distribute(L,&p);
PrintList(L);
//compact(L,pList); //紧凑
}
}else{//回收
if(pLength>0){
recycle(L,pList);
//compact(L,pList); //紧凑
}else{
printf("无可回收内存！");
}
}
system("pause");
} //while
return 0;
}
4.结果及其相关阐发
图4.1
阐发：作业1年夜小为20KB。

找到足够年夜空闲分区，进行划分分派。

图4.2
阐发：作业2年夜小为70KB。

找到足够年夜空闲分区，
进行划分分派。

图4.3
阐发：先回收进程1年夜小为20KB，删除进程，并把释放的空闲分区拔出空闲分区表；再回收进程2年夜小为70KB，删除进程，并把释放的空闲分区拔出空闲分区表；
图4.4
阐发：法度运行一段时间后的进程分派情况和空闲分区情况。

图4.5
阐发：法度运行一段时间后的进程分派情况和空闲分区情况。

图4.6
阐发：内存中已没有进程，所以不克不及进行回收。

图4.7
阐发：没有足够年夜的空闲分区且所有分区之和也不满足要求，分派失败。

图4.8
图4.9
阐发：进行紧凑，图4.8状态装换为图4.9状态。

五．课程设计小结
这次课程设计让我受益匪浅。

通过这次课程设计，我不单深刻理解了可重定位分区分派算法；更理解了存储器管理的目的：提高存储器的利用率，提高系统性能。

在作课程设计过程中我还体会到，连续分派存储管理的弊病：连续分派方法会形成许多“碎片”，虽然可通过“紧凑”方法将许多碎片拼接成可用的年夜块空间，但须为之支出很年夜开销。