【實驗目的】
1、 熟悉內存自由空閒隊列的分配策略 2、 熟悉內存分區的回收原則及實現過程 3、 通過實驗深刻理解主存管理的內容
【實驗內容】
模擬內存的動態分配和回收，並編程實現。
【實驗報告】
1、 列出調試通過程序的清單，並附上文檔說明。 2、 總結上機調試過程中所遇到的問題和解決方法及感想。
【實驗說明】
實驗原理
內存的分配可採用操作系統中的首次適應算法、最佳適應算法或最壞適應算法。 內存的回收回收區與空閒區相鄰的各種情況分別處理。
(1) 用C語言分別實現採用首次適應算法和最佳適應算法的動態分區分配過程alloc( )和回收過程free( )。其中，空閒分區通過空閒分區鏈來管理：在進行內存分配時，系統優先使用空閒區低端的空間。
(2) 假設初始狀態下，可用的內存空間爲640KB，並有下列的請求序列：
•作業1申請130KB。
•作業2申請60KB。
•作業3申請100KB。
•作業2釋放60KB。
•作業4申請200KB。
•作業3釋放100KB。
•作業1釋放130KB。
•作業5申請140KB。
•作業6申請60KB。
•作業7申請50KB。
•作業6釋放60KB。
請分別採用首次適應算法和最佳適應算法，對內存塊進行分配和回收，要求每次分配和回收後顯示出空閒分區鏈的情況。
程序代碼——C語言實現
#include<stdio.h>
#include<stdlib.h>
struct node //空閒分區鏈結點的定義
{
node *before;
node *after;
int size;
int address;
int state;
};
node L;
struct usenode
{
usenode *next;
int num;
int add;
int size;
}U,*n;
void Init() //空閒分區鏈的初始化
{
node *p;
p=(node *)malloc(sizeof(node));
p->before=&L;
p->after=NULL;
p->size=640;
p->address=0;
p->state=0;
L.after=p;
L.before=NULL;
L.size=0;
U.next=NULL;
n=&U;
}
node *search(int a)
{
node *p=L.after;
if(p==NULL)
{
printf("沒有空閒的區域!");
p=NULL;
return p;
}
else
{
while(p!=NULL && a>p->size)
p=p->after;
if(p==NULL)
{
printf("沒有找到合適的空閒空間!");
p=NULL;
return p;
}
else
return p;
}
}
void recovery(int a,int b) //內存回收算法
{
node *c,*s,*r=L.after;
node *d=L.after,*e;
usenode *k=U.next,*h=&U;
while(k!=NULL && a!=k->num)
{
h=k;
k=k->next;
}
if(k==NULL)
printf("沒有找到這樣的作業!");
else
{
h->next=k->next;
if(h->next==NULL)
n=h;
}
while(r!=NULL) //若回收得到的空閒塊的前方有空閒塊合併此空閒塊
{
if(k->add==r->address+r->size)
{
r->size=r->size+k->size;
break;
}
else
r=r->after;
}
if(r==NULL) //若回收得到的空閒塊的後面有空閒塊合併此空閒塊
{
r=L.after;
while(r!=NULL)
{
if(k->add+k->size==r->address)
{
r->address=k->add;
r->size=r->size+k->size;
break;
}
else
r=r->after;
}
}
while(d!=NULL) //保證空閒鏈表中沒有相鄰的空閒空間
{
if(d->after!=NULL)
e=d->after;
else
break;
if(d->address+d->size==e->address)
{
d->after=e->after;
while(e->after!=NULL)
e->after->before=d;
d->size=d->size+e->size;
free(e);
break;
}
else
d=d->after;
}
if(r==NULL)
{
r=L.after;
c=(node *)malloc(sizeof(node));
c->size=b;
c->address=k->add;
if(L.after==NULL)
{
c->after=L.after;
c->before=&L;
L.after=c;
}
else
{
r=L.after;
while(r!=NULL)
{
if(r->address>c->address)
{
c->after=r;
c->before=r->before;
r->before->after=c;
r->before=c;
free(k);
return;
}
else
r=r->after;
}
}
}
free(k);
}
void alloc(int a ,int b) //分配內存算法
{
node *p,*q=L.after;
usenode *m;
p=search(b);
if(p==NULL)
return;
m=(usenode *)malloc(sizeof(usenode));//生成一個被佔用鏈表的結點,並插入到該鏈表的尾部
m->add=p->address;
m->size=b;
m->num=a;
m->next=n->next;
n->next=m;
n=m; //保證n始終指向被佔用鏈表的尾部，方便以後新生成結點的插入
if(p->size>b) //如果申請空間的大小小於找到空閒空間的大小的處理
{
p->size=p->size-b;
p->address=p->address+b;
}
else //如果申請空間的大小等於找到空閒空間的大小的處理
{
p->before->after=p->after;
if(p->after!=NULL)
p->after->before=p->before;
free(p);
}
}
void sort() //對空閒鏈表進行排序
{
int max;
node *p,*q,*r,*s;
node a;
p=L.after;
while(p!=NULL) //讓指針q指向鏈表的最後一個結點
{
q=p;
p=p->after;
}
if(L.after->after==NULL)
return;
else
{
while(p!=q)
{
s=r=p=L.after;
max=r->size;
while(s!=q->after)
{
if(s->size>max)
{
max=s->size;
r=s;
s=s->after;
}
else
s=s->after;
}
a.size=q->size;
a.address=q->address;
q->size=r->size;
q->address=r->address;
r->size=a.size;
r->address=a.address;
if(q->before->before==&L)
return;
else
q=q->before;
}
}
}
void Print()
{
node *p=L.after;
usenode *q=U.next;
int i=1;
printf("\n空閒區域列表:\n");
printf("FREEID address size\n");
while(p!=NULL)
{
printf("%-10d",i);
printf("%-10d",p->address);
printf("%d\n",p->size);
p=p->after;
i++;
}
if(q==NULL)
return;
else
{
printf("\n已分配區域列表:\n");
printf("WORKID address size\n");
while(q!=NULL)
{
printf("%-10d",q->num);
printf("%-10d",q->add);
printf("%d\n",q->size);
q=q->next;
}
}
}
void firstfit() //首次適應算法
{
int a,b,i;
Init();
Print();
while(1)
{printf("\n1、申請空間\n");
printf("2、釋放空間\n");
printf("3、退出首次適應算法\n");
printf("請輸入你的選擇:");
scanf("%d",&i);
switch(i)
{
case 1:
{
printf("請輸入申請空間的作業號:");
scanf("%d",&a);
printf("請輸入申請空間的大小:");
scanf("%d",&b);
alloc(a,b);
Print();
break;
}
case 2:
{
printf("請輸入釋放空間的作業號:");
scanf("%d",&a);
printf("請輸入釋放空間的大小:");
scanf("%d",&b);
recovery(a,b);
Print();
break;
}
case 3:printf("\n");return;
}
}
}
void bestfit()
{
int a,b,i;
Init();
Print();
while(1)
{printf("\n1、申請空間\n");
printf("2、釋放空間\n");
printf("3、退出最佳適應算法\n");
printf("請輸入你的選擇:");
scanf("%d",&i);
switch(i)
{
case 1:
{
printf("請輸入申請空間的作業號:");
scanf("%d",&a);
printf("請輸入申請空間的大小:");
scanf("%d",&b);
alloc(a,b);
sort();
Print();
break;
}
case 2:
{
printf("請輸入釋放空間的作業號:");
scanf("%d",&a);
printf("請輸入釋放空間的大小:");
scanf("%d",&b);
recovery(a,b);
sort();
Print();
break;
}
case 3:printf("\n");return;
}
}
}
void main()
{
int i;
while(1)
{
printf("1、首次適應算法\n");
printf("2、最佳適應算法\n");
printf("3、退出\n");
printf("請輸入你的選擇:");
scanf("%d",&i);
switch(i)
{
case 1:firstfit();break;
case 2:bestfit();break;
case 3:return;
}
}
}
運行結果
① 開始界面
② 首次適應算法
③ 最佳適應算法
程序代碼——C++語言實現
//***************************************************************
//******** 動態分區分配方式的模擬 *********
//***************************************************************
#include<iostream.h>
#include<stdlib.h>
#define Free 0 //空閒狀態
#define Busy 1 //已用狀態
#define OK 1 //完成
#define ERROR 0 //出錯
#define MAX_length 640 //最大內存空間爲640KB
typedef int Status;
typedef struct freearea//定義一個空閒區說明表結構
{
int ID; //分區號
long size; //分區大小
long address; //分區地址
int state; //狀態
}ElemType;
//---------- 線性表的雙向鏈表存儲結構 ------------
typedef struct DuLNode //double linked list
{
ElemType data;
struct DuLNode *prior; //前趨指針
struct DuLNode *next; //後繼指針
}DuLNode,*DuLinkList;
DuLinkList block_first; //頭結點
DuLinkList block_last; //尾結點
Status alloc(int);//內存分配
Status free(int); //內存回收
Status First_fit(int,int);//首次適應算法
Status Best_fit(int,int); //最佳適應算法
void show();//查看分配
Status Initblock();//開創空間表
Status Initblock()//開創帶頭結點的內存空間鏈表
{
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;
return OK;
}
//----------------------- 分 配 主 存 -------------------------
Status alloc(int ch)
{
int ID,request;
cout<<"請輸入作業(分區號)：";
cin>>ID;
cout<<"請輸入需要分配的主存大小(單位:KB)：";
cin>>request;
if(request<0 ||request==0)
{
cout<<"分配大小不合適，請重試！"<<endl;
return ERROR;
}
if(ch==2) //選擇最佳適應算法
{
if(Best_fit(ID,request)==OK) cout<<"分配成功！"<<endl;
else cout<<"內存不足，分配失敗！"<<endl;
return OK;
}
else //默認首次適應算法
{
if(First_fit(ID,request)==OK) cout<<"分配成功！"<<endl;
else cout<<"內存不足，分配失敗！"<<endl;
return OK;
}
}
//------------------ 首次適應算法 -----------------------
Status First_fit(int ID,int request)//傳入作業名及申請量
{
//爲申請作業開闢新空間且初始化
DuLinkList temp=(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;
return OK;
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;
return OK;
break;
}
p=p->next;
}
return ERROR;
}
//-------------------- 最佳適應算法 ------------------------
Status Best_fit(int ID,int request)
{
int ch; //記錄最小剩餘空間
DuLinkList temp=(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;
return OK;
break;
}
if(p->data.state==Free && p->data.size>request)
{//空閒塊大於分配需求
if(p->data.size-request<ch)//剩餘空間比初值還小
{
ch=p->data.size-request;//更新剩餘最小值
q=p;//更新最佳位置指向
}
}
p=p->next;
}
if(q==NULL) return ERROR;//沒有找到空閒塊
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;
return OK;
}
}
//----------------------- 主 存 回 收 --------------------
Status free(int ID)
{
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;
}
return OK;
}
//--------------- 顯示主存分配情況 ------------------
void show()
{
cout<<"+++++++++++++++++++++++++++++++++++++++\n";
cout<<"+++ 主 存 分 配 情 況 +++\n";
cout<<"+++++++++++++++++++++++++++++++++++++++\n";
DuLNode *p=block_first->next;
while(p)
{
cout<<"分 區 號：";
if(p->data.ID==Free) cout<<"Free"<<endl;
else cout<<p->data.ID<<endl;
cout<<"起始地址："<<p->data.address<<endl;
cout<<"分區大小："<<p->data.size<<" KB"<<endl;
cout<<"狀 態：";
if(p->data.state==Free) cout<<"空 閒"<<endl;
else cout<<"已分配"<<endl;
cout<<"——————————————"<<endl;
p=p->next;
}
}
//----------------------- 主 函 數---------------------------
void main()
{
int ch;//算法選擇標記
cout<<" 動態分區分配方式的模擬 \n";
cout<<"************************************\n";
cout<<"** 1)首次適應算法 2)最佳適應算法 **\n";
cout<<"************************************\n";
cout<<"請選擇分配算法：";
cin>>ch;
Initblock(); //開創空間表
int choice; //操作選擇標記
while(1)
{
cout<<"********************************************\n";
cout<<"** 1: 分配內存 2: 回收內存 **\n";
cout<<"** 3: 查看分配 0: 退 出 **\n";
cout<<"********************************************\n";
cout<<"請輸入您的操作 ：";
cin>>choice;
if(choice==1) alloc(ch); // 分配內存
else if(choice==2) // 內存回收
{
int ID;
cout<<"請輸入您要釋放的分區號：";
cin>>ID;
free(ID);
}
else if(choice==3) show();//顯示主存
else if(choice==0) break; //退出
else //輸入操作有誤
{
cout<<"輸入有誤，請重試！"<<endl;
continue;
}
}
}