實驗4 內存管理
一、實驗目的
1、對內存管理的相關內容做進一步的理解。
2、瞭解內存管理的主要任務。
3、瞭解內存管理任務的主要實現方法。
4、通過編程加深理解內存的分配、回收等主要算法的原理。
二、實驗內容及要求
1、在該實驗中，採用可變分區方式完成對存儲空間的管理（即存儲空間的分配與回收工作）。
2、設計用來記錄主存使用情況的數據結構：已分區表和空閒分區表。
3、在設計好的數據結構上設計一個主存分配算法，要求實現的基本功能操作有：尋找空閒分區，空閒分區表的修改，已分區表的修改。
4、在設計好的數據結構上設計一個主存回收算法。其中，若回收的分區有上鄰空閒分區和（或）下鄰空閒分區，要求合併爲一個空閒分區登記在空閒分區表的一個表項裏。
三、實驗報告
1、程序中使用的數據結構及符號說明。
2、給出主要算法的流程圖。
3、給出測試數據和運行結果，要求系統每進行一次分配或回收，都要給出內存映像圖或已分配表及未分配表以觀察內存的變化。
代碼：
// OS4.1.cpp : 此文件包含 "main" 函數。程序執行將在此處開始並結束。
//
#include<stdio.h>
#include<stdlib.h>
#define OK 1 //完成
#define ERROR 0 //出錯
typedef int Status;
typedef struct free_table//定義一個空閒區說明表結構
{
int num; //分區序號
long address; //起始地址
long length;//分區大小
int state; //分區狀態
}ElemType;
typedef struct Node//線性表的雙向鏈表存儲結構
{
ElemType data;
struct Node*prior;//前趨指針
struct Node *next;//後繼指針
}Node, *LinkList;
LinkList first;//頭結點
LinkList end;//尾結點
int flag;//記錄要刪除的分區序號
Status Initblock()//開創帶頭結點的內存空間鏈表
{
first = (LinkList)malloc(sizeof(Node));
end = (LinkList)malloc(sizeof(Node));
first->prior = NULL;
first->next = end;
end->prior = first;
end->next = NULL;
end->data.num = 1;
end->data.address = 40;
end->data.length = 600;
end->data.state = 0;
return OK;
}
void sort()//分區序號重新排序
{
Node *p = first->next, *q;
q = p->next;
for (; p != NULL; p = p->next)
{
for (q = p->next; q; q = q->next)
{
if (p->data.num >= q->data.num)
{
q->data.num += 1;
}
}
}
}//顯示主存分配情況
void show()
{
int flag = 0;//用來記錄分區序號
Node *p = first;
p->data.num = 0;
p->data.address = 0;
p->data.length = 40;
p->data.state = 1;
sort();
printf("\n\t\t》主存空間分配情況《\n");
printf("**********************************************************\n\n");
printf("分區序號\t起始地址\t分區大小\t分區狀態\n\n");
while (p)
{
printf("%d\t\t%d\t\t%d", p->data.num, p->data.address, p->data.length);
if (p->data.state == 0)
printf("\t\t空閒\n\n");
else
printf("\t\t已分配\n\n");
p = p->next;
}
printf("**********************************************************\n\n");
}//首次適應算法
Status First_fit(int request) {//爲申請作業開闢新空間且初始化
Node *p = first->next;
LinkList temp = (LinkList)malloc(sizeof(Node));
temp->data.length = request;
temp->data.state = 1;
p->data.num = 1;
while (p)
{
if ((p->data.state == 0) && (p->data.length == request))
{//有大小恰好合適的空閒塊
p->data.state = 1;
return OK;
break;
}
else if ((p->data.state == 0) && (p->data.length > request))
{//有空閒塊能滿足需求且有剩餘
temp->prior = p->prior;
temp->next = p;
temp->data.address = p->data.address;
temp->data.num = p->data.num;
p->prior->next = temp;
p->prior = temp;
p->data.address = temp->data.address + temp->data.length;
p->data.length -= request;
p->data.num += 1;
return OK;
break;
}
p = p->next;
}
return ERROR;
}//最佳適應算法
Status Best_fit(int request)
{
int ch;//記錄最小剩餘空間
Node *p = first;
Node *q = NULL;//記錄最佳插入位置
LinkList temp = (LinkList)malloc(sizeof(Node));
temp->data.length = request;
temp->data.state = 1;
p->data.num = 1;
while (p)//初始化最小空間和最佳位置
{
if ((p->data.state == 0) && (p->data.length >= request))
{
if (q == NULL)
{
q = p;
ch = p->data.length - request;
}
else if (q->data.length > p->data.length)
{
q = p;
ch = p->data.length - request;
}
}
p = p->next;
}
if (q == NULL) return ERROR;
//沒有找到空閒塊
else if (q->data.length == request)
{
q->data.state = 1;
return OK;
}
else
{
temp->prior = q->prior;
temp->next = q;
temp->data.address = q->data.address;
temp->data.num = q->data.num;
q->prior->next = temp;
q->prior = temp;
q->data.address += request;
q->data.length = ch;
q->data.num += 1;
return OK;
}
return OK;
}//最差適應算法
Status Worst_fit(int request)
{
int ch;//記錄最大剩餘空間
Node *p = first->next;
Node *q = NULL;//記錄最佳插入位置
LinkList temp = (LinkList)malloc(sizeof(Node));
temp->data.length = request;
temp->data.state = 1;
p->data.num = 1;
while (p)//初始化最大空間和最佳位置
{
if (p->data.state == 0 && (p->data.length >= request))
{
if (q == NULL)
{
q = p;
ch = p->data.length - request;
}
else if (q->data.length < p->data.length)
{
q = p;
ch = p->data.length - request;
}
}
p = p->next;
}
if (q == NULL) return ERROR;//沒有找到空閒塊
else if (q->data.length == request)
{
q->data.length = 1;
return OK;
}
else
{
temp->prior = q->prior;
temp->next = q;
temp->data.address = q->data.address;
temp->data.num = q->data.num;
q->prior->next = temp;
q->prior = temp;
q->data.address += request;
q->data.length = ch;
q->data.num += 1;
return OK;
} return OK;
}//分配主存
Status allocation(int a)
{
int request;//申請內存大小
printf("請輸入申請分配的主存大小(單位:KB):");
scanf_s("%d", &request);
if (request < 0 || request == 0)
{
printf("分配大小不合適，請重試！");
return ERROR;
}
switch (a)
{
case 1://默認首次適應算法
if (First_fit(request) == OK)
printf("\t****分配成功！****");
else printf("\t****內存不足，分配失敗！****");
return OK;
break;
case 2://選擇最佳適應算法
if (Best_fit(request) == OK)
printf("\t****分配成功！****");
else printf("\t****內存不足，分配失敗！****");
return OK;
break;
case 3://選擇最差適應算法
if (Worst_fit(request) == OK)
printf("\t****分配成功！****");
else printf("\t****內存不足，分配失敗！****");
return OK;
break;
}
}
Status deal1(Node *p)//處理回收空間
{
Node *q = first;
for (; q != NULL; q = q->next)
{
if (q == p)
{
if (q->prior->data.state == 0 && q->next->data.state != 0)
{
q->prior->data.length += q->data.length;
q->prior->next = q->next;
q->next->prior = q->prior;
q = q->prior;
q->data.state = 0;
q->data.num = flag - 1;
}
if (q->prior->data.state != 0 && q->next->data.state == 0)
{
q->data.length += q->next->data.length;
q->next = q->next->next;
q->next->next->prior = q;
q->data.state = 0;
q->data.num = flag;
}
if (q->prior->data.state == 0 && q->next->data.state == 0)
{
q->prior->data.length += q->data.length;
q->prior->next = q->next;
q->next->prior = q->prior;
q = q->prior;
q->data.state = 0;
q->data.num = flag - 1;
}
if (q->prior->data.state != 0 && q->next->data.state != 0)
{
q->data.state = 0;
}
}
}
return OK;
}
Status deal2(Node *p)//處理回收空間
{
Node *q = first;
for (; q != NULL; q = q->next)
{
if (q == p)
{
if (q->prior->data.state == 0 && q->next->data.state != 0)
{
q->prior->data.length += q->data.length;
q->prior->next = q->next;
q->next->prior = q->prior;
q = p->prior;
q->data.state = 0;
q->data.num = flag - 1;
}
if (q->prior->data.state != 0 && q->next->data.state == 0)
{
q->data.state = 0;
}
if (q->prior->data.state == 0 && q->next->data.state == 0)
{
q->prior->data.length += q->data.length;
q->prior->next = q->next;
q->next->prior = q->prior;
q = q->prior;
q->data.state = 0;
q->data.num = flag - 1;
}
if (q->prior->data.state != 0 && q->next->data.state != 0)
{
q->data.state = 0;
}
}
}
return OK;
}//主存回收
Status recovery(int flag)
{
Node *p = first;
for (; p != NULL; p = p->next)
{
if (p->data.num == flag)
{
if (p->prior == first)
{
if (p->next != end)//當前P指向的下一個不是最後一個時
{
if (p->next->data.state == 0)//與後面的空閒塊相連
{
p->data.length += p->next->data.length;
p->next->next->prior = p;
p->next = p->next->next;
p->data.state = 0;
p->data.num = flag;
}
else p->data.state = 0;
}
if (p->next == end)//當前P指向的下一個是最後一個時
{
p->data.state = 0;
}
}//結束if(p->prior==block_first)的情況
else if (p->prior != first)
{
if (p->next != end)
{
deal1(p);
}
else
{
deal2(p);
}
}//結束if(p->prior!=block_first)的情況
}//結束if(p->data.num==flag)的情況
}
printf("\t****回收成功****");
return OK;
}//主函數
void main()
{
int i;//操作選擇標記
int a;//算法選擇標記
printf("**********************************************************\n");
printf("\t\t用以下三種方法實現主存空間的分配\n");
printf("\t(1)首次適應算法\t(2)最佳適應算法\t(3)最差適應算法\n");
printf("**********************************************************\n");
printf("\n");
printf("請輸入所使用的內存分配算法:");
scanf_s("%d", &a);
while (a < 1 || a>3)
{
printf("輸入錯誤，請重新輸入所使用的內存分配算法:\n");
scanf_s("%d", &a);
}
switch (a)
{
case 1:printf("\n\t****使用首次適應算法：****\n"); break;
case 2:printf("\n\t****使用最佳適應算法：****\n"); break;
case 3:printf("\n\t****使用最壞適應算法：****\n"); break;
}
Initblock();//開創空間表
while (1)
{
show();
printf("\t1: 分配內存\t2: 回收內存\t0: 退出\n");
printf("請輸入您的操作：");
scanf_s("%d", &i);
if (i == 1)
allocation(a);//分配內存
else if (i == 2)//內存回收
{
printf("請輸入您要釋放的分區號：");
scanf_s("%d", &flag);
recovery(flag);
}
else if (i == 0)
{
printf("\n退出程序\n");
break;//退出
}
else//輸入操作有誤
{
printf("輸入有誤，請重試！");
continue;
}
}
}
運行結果：
分配和回收測試的情況很多，自己試自己體會吧。