実験2の動的パーティション割り当てアルゴリズムのシミュレーション
2.1 最初の適応アルゴリズムのシミュレーション
1. 実験の目的と要件
1. 実験の目的
1) オペレーティングシステムのメモリ管理プロセスについての理解を深める
2) メモリ割り当てアルゴリズムの基本的な応用を習得する
2. 実験環境（ツール、設定など）
1. ハードウェア要件: コンピューター。
2. ソフトウェア要件: C、C++、Java などの任意のプログラミング言語を使用する Windows オペレーティング システム。
3. 実験内容
1. アルゴリズムのアイデア: 第 1 適応アルゴリズム: 空きパーティション チェーンをアドレスの昇順に接続し、メモリ割り当てを実行するときは、サイズに応じて要件を満たすサイズのパーティションが見つかるまでチェーンの先頭から順に検索します。ジョブの場合、このパーティションからメモリを割り当て、残りの空きパーティションを空きパーティション チェーンにリンクします。
2. メモリ状態の初期化: ユーザーは空のパーティションの数を動的に入力し、空のパーティションのサイズを設定します。ここでは 5 つの空のパーティションを入力し、そのサイズは 100、200、300、400、500 (単位:メモリの初期状態を設定した結果を次の図に示します。
3. メモリを割り当て、メモリの状態を確認します。ジョブ A は 120KB のメモリに適用され、ジョブ B は 80KB のメモリに適用され、ジョブ C は 320KB のメモリに適用され、ジョブ D は 410KB のメモリに適用され、ジョブ E 100KB のメモリに適用されます。割り当て結果は、予想される結果と一致して、次の図に示されています:
図 2 メモリ割り当て (1)
図 2 メモリ割り当て (2)
図 3 割り当て後の結果
4. 断片化されたスペースをマージします。割り当てられたメモリを断片化されたスペースにマージするには 4 を入力し、メモリのステータスを確認するには 3 を入力します。結果は次の図に示されています。
5. メモリの解放: 2 を入力し、パーティション番号 1 のメモリを解放することを選択します。結果は次の図に示されています。解放後、パーティション番号 1 のメモリはアイドル状態になり、期待どおりの結果になります。
6. 分析: 上記のシミュレーションから、アルゴリズムがメモリの低アドレス部分の空き領域を優先的に利用する傾向があり、それによって高アドレス部分の大きな空き領域が保持され、状況が作成されることが明確にわかります。大規模なジョブのメモリ割り当て用。しかし、毎回低アドレス部の空きパーティションが優先的に使用されるため、低アドレス部のフラグメントが多くなり、同時に毎回低アドレス部から検索が行われるため、これにより、空きパーティションを検索するオーバーヘッドが増加します。
コードは次のようになります。
#include<iostream>
#include<stdlib.h>
#include<windows.h>
using namespace std;
#define Free 0 //空闲状态
#define Busy 1 //已用状态
#define OK 1 //完成
#define ERROR 0 //出错
#define MAX_length 2048 //定义最大主存信息2048KB
#define Min_Size 10 //规定的不可分割的剩余分区的大小
int flag;//标志位
//函数声明
int myMalloc();//内存分配
int free(int); //内存回收
int First_fit(int);//首次适应算法
void printNode();//查看分配
int Init();//空闲分区的设置
int Combination();//合并碎片空间
typedef struct Kongxian //定义一个空闲区说明表结构
{
char name[30] ;
long size; //分区大小
long address; //分区地址
int state; //空闲标志
}Elem;
typedef struct LinkNode// 双向链表存储结构
{
Elem data;
struct LinkNode *prior; //前趋指针
struct LinkNode *next; //后继指针
}LinkNode, *LinkList;
LinkList block_first; //头结点
LinkList block_last; //尾结点
LinkNode *pn ; //循环首次适应算法中的指针
void menu(){
//打印操作界面
printf("\n");
printf("\t\t\t\t ***** 首次适应算法的动态分区分配方式模拟 ***** \n");
printf("\t\t\t\t ┌───────────────────────────────────────────-┐\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 1. 申请内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 2. 释放内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 3. 查看内存情况 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 4. 合并碎片空间 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 5.退出 │\n");
printf("\t\t\t\t └────────────────────────────────────────────┘\n");
printf("\t\t\t\t\t\t 请您选择(1-5):\t"); //打印想要进行的操作
}
int Init()//初始化内存状态设置（空闲分区的设置）
{
int Free_num; //空闲分区的个数
block_first = (LinkList)malloc(sizeof(LinkNode));
block_last = (LinkList)malloc(sizeof(LinkNode));
block_first->prior = NULL;
block_first->next = block_last;
cout << "请输入空闲分区数目：";
cin >> Free_num ;
int Size[Free_num];
printf("\n请分别输入这%d空闲分区大小（单位KB）：\n",Free_num );
for(int i = 0; i < Free_num; i++)
{
cin >> Size[i];
if(Size[i] <= Min_Size) {
i--;
cout << "\n输入错误，请重输！\n";
}
int temp = 0;
temp = temp + Size[i];
if(temp >= MAX_length) {
i--;
cout << "\n输入错误，请重输！\n";
}
}
LinkList p = block_first;
for(int i = 0; i < Free_num; i++)
{
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = Size[i];
temp->data.state = Free;
if(p == block_first)
temp->data.address = 0;
else
temp->data.address = p->data.address + p->data.size;
temp->prior =p;
p->next = temp;
p = p->next;
}
block_last = p;
block_last->next = NULL;
pn = block_first->next;
return OK;
}
int myMalloc()//分配主存
{
int request = 0;
cout << "请输入需要分配的主存大小(单位:KB)："<<endl;
cin >> request;
if (request<0 || request == 0)
{
cout << "分配大小不合适，请重试！" << endl;
return ERROR;
}
if (First_fit(request) == OK) cout << "分配成功！" << endl;
else cout << "内存不足，分配失败！" << endl;
return OK;
}
int First_fit(int request)//首次适应算法
{
//为申请作业开辟新空间且初始化
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = request;
temp->data.state = Busy;
cout << "请输入作业名：";
cin >>temp->data.name ;
cout <<endl;
LinkNode *p = block_first->next;
while (p)
{
if (p->data.state == Free && p->data.size - request <= Min_Size && p->data.size - request >= 0) //有大小恰好合适的空闲块
{
p->data.state = Busy;
for(int i = 0; i < 10; i++){
p->data.name[i] = temp->data.name[i];
}
return OK;
break;
}
if (p->data.state == Free && p->data.size - request > Min_Size) //有空闲块能满足需求且有剩余
{
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;
}
int free(int flag)//主存回收
{
LinkNode *p = block_first;
for (int i = 0; i <= flag; i++)
if (p != NULL)
p = p->next;
else
return ERROR;
p->data.state = Free;
if(p == block_last){
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p = p->prior;
p->next = NULL;
block_last = p;
}
}
else{
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p->prior->next = p->next;//去掉原来被合并的p
p->next->prior = p->prior;
p = p->prior;
}
if (p->next != block_last && p->next->data.state == Free )//与后面的空闲块相连
{
p->data.size += p->next->data.size;//空间扩充,合并为一个
p->next->next->prior = p;
p->next = p->next->next;
}
if (p->next == block_last && p->next->data.state == Free )//与最后的空闲块相连
{
p->data.size += p->next->data.size;
p->next = NULL;
}
}
return OK;
}
int Combination() //实现紧凑，合并碎片
{
LinkNode *p = block_first->next;
int size = 0;
while(p){
if(p->data.state ==Free && p != block_last) //去除空闲分区
{
size =size + p->data.size ;
p->next->prior =p->prior ;
p->prior->next = p->next ;
}
else{
p->data.address = p->data.address - size; //改变地址
}
p = p->next;
}
if(block_last->data.state == Free){
//实现最后合并空闲分区
block_last->data.size += size;
}
else if(size != 0){
//将所有空闲分区合并放在最后一个分区后面
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
block_last->next =temp;
temp->prior = block_last;
temp->next = NULL;
temp->data.size = size;
temp->data.address = block_last->data.address + block_last->data.size ;
block_last = temp;
temp->data.state = Free;
}
pn = block_first->next;
if(size == 0) //判断是否有碎片
{
return ERROR;
}
return OK;
}
void printNode()//显示内存分配情况
{
int num = 0;
printf(" 内存情况 \n");
cout << "======================================================\n\n";
LinkNode *p = block_first->next;
cout << "分区号\t起始地址\t分区大小\t状态\t作业名\n\n";
while (p)
{
cout << " " << num++ << "\t";
cout << " " << p->data.address << "\t\t";
cout << " " << p->data.size << "KB\t\t";
if (p->data.state == Free) {
cout << "空闲\n\n";
}
else {
cout << "已分配\t";
cout <<" "<<p->data.name <<"\n\n";
}
p = p->next;
}
cout << "======================================================\n\n";
}
void Operate(){
int choice; //操作选择标记
while (1)
{
menu();
scanf("%d",&choice);
if (choice == 1) myMalloc(); // 分配内存
else if (choice == 2) // 内存回收
{
int flag;
cout << "请输入您要释放的分区号："<<endl;
cin >> flag;
free(flag);
}
else if (choice == 3) printNode();
else if(choice == 4)
{
if(Combination() == 0){
cout<<"无需合并碎片空间！"<<endl;
}
else{
cout<<"成功合并碎片！"<<endl;
}
}
else if (choice == 5) break; //退出
else //输入操作有误
{
cout << "输入有误，请重试！" << endl;
continue;
}
}
}
int main()//主函数
{
system("color 5E");
Init(); //初始化内存状态
Operate();
return 0;
}
2.2 ベストフィットアルゴリズムのシミュレーション
1. 実験結果と解析
1. アルゴリズムのアイデア: 空きパーティション チェーン内の空きパーティションを、空きパーティションの小さいものから大きいものへの順序に従ってソートし、空きパーティション チェーンを形成します。ジョブにメモリを割り当てるためにチェーンの先頭から毎回適切な空きパーティションが検索され、そのたびに見つかる空きパーティションがジョブのサイズに最も近い、いわゆる「最良」になります。
2. メモリ状態の初期化: ユーザーは空のパーティションの数を動的に入力し、空のパーティションのサイズを設定します。ここでは 5 つの空のパーティションを入力し、そのサイズは 100、200、300、400、500 (単位:メモリの初期状態を設定した結果を次の図に示します。
4. 断片化されたスペースをマージする: 4 を入力して上で割り当てられたメモリをマージして断片化されたスペースをマージし、3 を入力してメモリのステータスを確認します。結果は次の図に示されています。
6. 分析: 上記のシミュレーションから、アルゴリズムではすべての空きパーティションが容量の小さいものから大きいものへの順序で空きパーティションのチェーンを形成する必要があり、これにより検索が高速化されることが明確にわかります。初めて見つけた条件を満たすフリーエリアが最適なはずです。各分割の残りのスペースは常に最小となり、生成される外部フラグメントのサイズが減少します。単独では、それが最良であるように見えますが、必ずしも巨視的にはそうではありません。また、スペース利用の観点から見ると、NF アルゴリズムはすべてを最大限に活用しますが、各分割では使いにくい外部フラグメントが残るため、検索効率が低下します。
コードは次のようになります。
#include<iostream>
#include<stdlib.h>
#include<windows.h>
using namespace std;
#define Free 0 //空闲状态
#define Busy 1 //已用状态
#define OK 1 //完成
#define ERROR 0 //出错
#define MAX_length 2048 //定义最大主存信息2048KB
#define Min_Size 10 //规定的不可分割的剩余分区的大小
int flag;//标志位
//函数声明
int myMalloc();//内存分配
int free(int); //内存回收
int Best_fit(int);//最佳适应算法
void printNode();//查看分配
int Init();//空闲分区的设置
int Combination();//合并碎片空间
typedef struct FreeArea //定义一个空闲区说明表结构
{
char name[30] ;
long size; //分区大小
long address; //分区地址
int state; //空闲标志
}Elem;
typedef struct LinkNode// 双向链表存储结构
{
Elem data;
struct LinkNode *prior; //前趋指针
struct LinkNode *next; //后继指针
}LinkNode, *LinkList;
LinkList block_first; //头结点
LinkList block_last; //尾结点
LinkNode *pn ; //循环首次适应算法中的指针
void menu(){
//打印操作界面
printf("\n");
printf("\t\t\t\t ***** 最佳适应算法的动态分区分配方式模拟 ***** \n");
printf("\t\t\t\t ┌───────────────────────────────────────────-┐\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 1. 申请内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 2. 释放内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 3. 查看内存情况 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 4. 合并碎片空间 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 5.退出 │\n");
printf("\t\t\t\t └────────────────────────────────────────────┘\n");
printf("\t\t\t\t\t\t 请您选择(1-5):\t"); //打印想要进行的操作
}
int Init()//初始化内存状态设置（空闲分区的设置）
{
int Free_num; //空闲分区的个数
block_first = (LinkList)malloc(sizeof(LinkNode));
block_last = (LinkList)malloc(sizeof(LinkNode));
block_first->prior = NULL;
block_first->next = block_last;
cout << "请输入空闲分区数目：";
cin >> Free_num ;
int Size[Free_num];
printf("\n请分别输入这%d空闲分区大小（单位KB）：\n",Free_num );
for(int i = 0; i < Free_num; i++)
{
cin >> Size[i];
if(Size[i] <= Min_Size) {
i--;
cout << "\n输入错误，请重输！\n";
}
int temp = 0;
temp = temp + Size[i];
if(temp >= MAX_length) {
i--;
cout << "\n输入错误，请重输！\n";
}
}
LinkList p = block_first;
for(int i = 0; i < Free_num; i++)
{
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = Size[i];
temp->data.state = Free;
if(p == block_first)
temp->data.address = 0;
else
temp->data.address = p->data.address + p->data.size;
temp->prior =p;
p->next = temp;
p = p->next;
}
block_last = p;
block_last->next = NULL;
pn = block_first->next;
return OK;
}
int myMalloc()//分配主存
{
int request = 0;
cout << "请输入需要分配的主存大小(单位:KB)："<<endl;
cin >> request;
if (request<0 || request == 0)
{
cout << "分配大小不合适，请重试！" << endl;
return ERROR;
}
if (Best_fit(request) == OK) cout << "分配成功！" << endl;
else cout << "内存不足，分配失败！" << endl;
return OK;
}
int Best_fit(int request)//最佳适应算法
{
int ch; //记录最小剩余空间
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = request;
temp->data.state = Busy;
LinkNode *p = block_first->next;
LinkNode *q = NULL; //记录最佳插入位置
cout << "请输入作业名：";
cin >>temp->data.name ;
while (p) //初始化最小空间和最佳位置
{
if (p->data.state == Free && (p->data.size >= request))
{
if (q == NULL)
{
q = p;
ch = p->data.size - request;
}
else if (q->data.size > p->data.size)
{
q = p;
ch = p->data.size - request;
}
}
p = p->next;
}
if (q == NULL) return ERROR;//没有找到空闲块
else if (q->data.size - request <= Min_Size)
{
q->data.state = Busy;
for(int i = 0; i < 10; i++){
q->data.name[i] = temp->data.name[i];
}
return OK;
}
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;
}
return OK;
}
int free(int flag)//主存回收
{
LinkNode *p = block_first;
for (int i = 0; i <= flag; i++)
if (p != NULL)
p = p->next;
else
return ERROR;
p->data.state = Free;
if(p == block_last){
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p = p->prior;
p->next = NULL;
block_last = p;
}
}
else{
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p->prior->next = p->next;//去掉原来被合并的p
p->next->prior = p->prior;
p = p->prior;
}
if (p->next != block_last && p->next->data.state == Free )//与后面的空闲块相连
{
p->data.size += p->next->data.size;//空间扩充,合并为一个
p->next->next->prior = p;
p->next = p->next->next;
}
if (p->next == block_last && p->next->data.state == Free )//与最后的空闲块相连
{
p->data.size += p->next->data.size;
p->next = NULL;
}
}
return OK;
}
int Combination() //实现紧凑，合并碎片
{
LinkNode *p = block_first->next;
int size = 0;
while(p){
if(p->data.state ==Free && p != block_last) //去除空闲分区
{
size =size + p->data.size ;
p->next->prior =p->prior ;
p->prior->next = p->next ;
}
else{
p->data.address = p->data.address - size; //改变地址
}
p = p->next;
}
if(block_last->data.state == Free){
//实现最后合并空闲分区
block_last->data.size += size;
}
else if(size != 0){
//将所有空闲分区合并放在最后一个分区后面
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
block_last->next =temp;
temp->prior = block_last;
temp->next = NULL;
temp->data.size = size;
temp->data.address = block_last->data.address + block_last->data.size ;
block_last = temp;
temp->data.state = Free;
}
pn = block_first->next;
if(size == 0) //判断是否有碎片
{
return ERROR;
}
return OK;
}
void printNode()//显示主存分配情况
{
int num = 0;
printf(" 内存情况 \n");
cout << "======================================================\n\n";
LinkNode *p = block_first->next;
cout << "分区号\t起始地址\t分区大小\t状态\t作业名\n\n";
while (p)
{
cout << " " << num++ << "\t";
cout << " " << p->data.address << "\t\t";
cout << " " << p->data.size << "KB\t\t";
if (p->data.state == Free) {
cout << "空闲\n\n";
}
else {
cout << "已分配\t";
cout <<" "<<p->data.name <<"\n\n";
}
p = p->next;
}
cout << "======================================================\n\n";
}
void Operate(){
int choice; //操作选择标记
while (1)
{
menu();
scanf("%d",&choice);
if (choice == 1) myMalloc(); // 分配内存
else if (choice == 2) // 内存回收
{
int flag;
cout << "请输入您要释放的分区号："<<endl;
cin >> flag;
free(flag);
}
else if (choice == 3) printNode();
else if(choice == 4)
{
if(Combination() == 0){
cout<<"无需合并碎片空间！"<<endl;
}
else{
cout<<"成功合并碎片！"<<endl;
}
}
else if (choice == 5) break; //退出
else //输入操作有误
{
cout << "输入有误，请重试！" << endl;
continue;
}
}
}
int main()//主函数
{
system("color 5E");
Init(); //初始化内存状态
Operate();
return 0;
}
ワーストフィットアルゴリズムのシミュレーション
実験結果と分析
1. アルゴリズムのアイデア: ベスト フィット アルゴリズムとは異なり、空きパーティション チェーンのパーティションは降順に並べ替えられて空きパーティション チェーンが形成され、各検索では最初の空きパーティションが満たされるかどうかを確認するだけで済みます。
2. メモリ状態の初期化: ユーザーは、空のパーティションの数を動的に入力し、空のパーティションのサイズを設定します。ここでは、5 つの空のパーティションを入力するために使用します。そのサイズは、100、200、300、400、500 (単位) : KB)、メモリの初期状態を設定した結果を次の図に示します。
3. 断片化されたスペースをマージします: 割り当てられたメモリを断片化されたスペースにマージするには 4 を入力し、次に 3 を入力してメモリの
ステータスを確認します。結果は次の図に示されています。
4. メモリの解放: 2 を入力し、メモリを解放することを選択します。パーティション番号 1 の結果 以下の図に示すように、解放後、パーティション番号 2 のメモリはアイドル状態になり、予想される結果 6 を満たしています。 分析: 上記のシミュレーションから、最悪の結果が明らかにわかります
。適応アルゴリズムは効率的でパーティションを見つけるのが簡単ですが、小さなジョブが大きな空きパーティションを小さなパーティションに分割すると、大きなジョブは適切な空きパーティションを見つけることができなくなります。
7. フローチャート
#include<iostream>
#include<stdlib.h>
#include<windows.h>
using namespace std;
#define Free 0 //空闲状态
#define Busy 1 //已用状态
#define OK 1 //完成
#define ERROR 0 //出错
#define MAX_length 2048 //定义最大主存信息2048KB
#define Min_Size 10 //规定的不可分割的剩余分区的大小
int flag;//标志位
//函数声明
int myMalloc();//内存分配
int free(int); //内存回收
int Worst_fit(int); //最差适应算法
void printNode();//查看分配
int Init();//空闲分区的设置
int Combination();//合并碎片空间
typedef struct FreeArea //定义一个空闲区说明表结构
{
char name[30] ;
long size; //分区大小
long address; //分区地址
int state; //空闲标志
}Elem;
typedef struct LinkNode// 双向链表存储结构
{
Elem data;
struct LinkNode *prior; //前趋指针
struct LinkNode *next; //后继指针
}LinkNode, *LinkList;
LinkList block_first; //头结点
LinkList block_last; //尾结点
LinkNode *pn ; //循环首次适应算法中的指针
void menu(){
//打印操作界面
printf("\n");
printf("\t\t\t\t ***** 最差适应算法的动态分区分配方式模拟 ***** \n");
printf("\t\t\t\t ┌───────────────────────────────────────────-┐\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 1. 申请内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 2. 释放内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 3. 查看内存情况 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 4. 合并碎片空间 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 5.退出 │\n");
printf("\t\t\t\t └────────────────────────────────────────────┘\n");
printf("\t\t\t\t\t\t 请您选择(1-5):\t"); //打印想要进行的操作
}
int Init()//初始化内存状态设置（空闲分区的设置）
{
int Free_num; //空闲分区的个数
block_first = (LinkList)malloc(sizeof(LinkNode));
block_last = (LinkList)malloc(sizeof(LinkNode));
block_first->prior = NULL;
block_first->next = block_last;
cout << "请输入空闲分区数目：";
cin >> Free_num ;
int Size[Free_num];
printf("\n请分别输入这%d空闲分区大小（单位KB）：\n",Free_num );
for(int i = 0; i < Free_num; i++)
{
cin >> Size[i];
if(Size[i] <= Min_Size) {
i--;
cout << "\n输入错误，请重输！\n";
}
int temp = 0;
temp = temp + Size[i];
if(temp >= MAX_length) {
i--;
cout << "\n输入错误，请重输！\n";
}
}
LinkList p = block_first;
for(int i = 0; i < Free_num; i++)
{
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = Size[i];
temp->data.state = Free;
if(p == block_first)
temp->data.address = 0;
else
temp->data.address = p->data.address + p->data.size;
temp->prior =p;
p->next = temp;
p = p->next;
}
block_last = p;
block_last->next = NULL;
pn = block_first->next;
return OK;
}
int myMalloc()//分配主存
{
int request = 0;
cout << "请输入需要分配的主存大小(单位:KB)："<<endl;
cin >> request;
if (request<0 || request == 0)
{
cout << "分配大小不合适，请重试！" << endl;
return ERROR;
}
if (Worst_fit(request) == OK) cout << "分配成功！" << endl;
else cout << "内存不足，分配失败！" << endl;
return OK;
}
int Worst_fit(int request)//最差适应算法
{
int ch; //记录最大剩余空间
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = request;
temp->data.state = Busy;
LinkNode *p = block_first->next;
LinkNode *q = NULL; //记录最佳插入位置
cout << "请输入作业名：";
cin >>temp->data.name ;
while (p) //初始化最大空间和最佳位置
{
if (p->data.state == Free && (p->data.size >= request))
{
if (q == NULL)
{
q = p;
ch = p->data.size - request;
}
else if (q->data.size < p->data.size)
{
q = p;
ch = p->data.size - request;
}
}
p = p->next;
}
if (q == NULL) return ERROR;//没有找到空闲块
else if (q->data.size - request <= Min_Size)
{
q->data.state = Busy;
for(int i = 0; i < 10; i++){
q->data.name[i] = temp->data.name[i];
}
return OK;
}
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;
}
return OK;
}
int free(int flag)//主存回收
{
LinkNode *p = block_first;
for (int i = 0; i <= flag; i++)
if (p != NULL)
p = p->next;
else
return ERROR;
p->data.state = Free;
if(p == block_last){
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p = p->prior;
p->next = NULL;
block_last = p;
}
}
else{
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p->prior->next = p->next;//去掉原来被合并的p
p->next->prior = p->prior;
p = p->prior;
}
if (p->next != block_last && p->next->data.state == Free )//与后面的空闲块相连
{
p->data.size += p->next->data.size;//空间扩充,合并为一个
p->next->next->prior = p;
p->next = p->next->next;
}
if (p->next == block_last && p->next->data.state == Free )//与最后的空闲块相连
{
p->data.size += p->next->data.size;
p->next = NULL;
}
}
return OK;
}
int Combination() //实现紧凑，合并碎片
{
LinkNode *p = block_first->next;
int size = 0;
while(p){
if(p->data.state ==Free && p != block_last) //去除空闲分区
{
size =size + p->data.size ;
p->next->prior =p->prior ;
p->prior->next = p->next ;
}
else{
p->data.address = p->data.address - size; //改变地址
}
p = p->next;
}
if(block_last->data.state == Free){
//实现最后合并空闲分区
block_last->data.size += size;
}
else if(size != 0){
//将所有空闲分区合并放在最后一个分区后面
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
block_last->next =temp;
temp->prior = block_last;
temp->next = NULL;
temp->data.size = size;
temp->data.address = block_last->data.address + block_last->data.size ;
block_last = temp;
temp->data.state = Free;
}
pn = block_first->next;
if(size == 0) //判断是否有碎片
{
return ERROR;
}
return OK;
}
void printNode()//显示内存分配情况
{
int num = 0;
printf(" 内存情况 \n");
cout << "======================================================\n\n";
LinkNode *p = block_first->next;
cout << "分区号\t起始地址\t分区大小\t状态\t作业名\n\n";
while (p)
{
cout << " " << num++ << "\t";
cout << " " << p->data.address << "\t\t";
cout << " " << p->data.size << "KB\t\t";
if (p->data.state == Free) {
cout << "空闲\n\n";
}
else {
cout << "已分配\t";
cout <<" "<<p->data.name <<"\n\n";
}
p = p->next;
}
cout << "======================================================\n\n";
}
void Operate(){
int choice; //操作选择标记
while (1)
{
menu();
scanf("%d",&choice);
if (choice == 1) myMalloc(); // 分配内存
else if (choice == 2) // 内存回收
{
int flag;
cout << "请输入您要释放的分区号："<<endl;
cin >> flag;
free(flag);
}
else if (choice == 3) printNode();
else if(choice == 4)
{
if(Combination() == 0){
cout<<"无需合并碎片空间！"<<endl;
}
else{
cout<<"成功合并碎片！"<<endl;
}
}
else if (choice == 5) break; //退出
else //输入操作有误
{
cout << "输入有误，请重试！" << endl;
continue;
}
}
}
int main()//主函数
{
system("color 5E");
Init(); //初始化内存状态
Operate();
return 0;
}
サイクルファースト適応アルゴリズムのシミュレーション
1. 実験解析と結果
1. アルゴリズムの考え方：メモリを割り当てる際、チェーンの先頭からメモリを割り当てられる空きパーティションを探すのではなく、前回メモリを割り当てた空きパーティションの次のパーティションから検索を開始し、最後にメモリを割り当てるプロセスに使用できる空きパーティションが見つかり、割り当てられたメモリの空きパーティションが見つかります。
2. メモリ状態の初期化: ユーザーは、空のパーティションの数を動的に入力し、空のパーティションのサイズを設定します。ここでは、5 つの空のパーティションを入力するために使用します。そのサイズは、100、200、300、400、500 (単位) : KB)、ここで、メモリの初期状態の設定結果を次の図に示します。
3. メモリを割り当て、メモリの状態を確認します。ジョブ A は 120KB のメモリに適用され、ジョブ B は 80KB のメモリに適用され、ジョブ C は適用されます。 320KB のメモリの場合、ジョブ D は 410KB のメモリに適用され、ジョブ E は 100KB のメモリに適用されます。結果は次の図に示すとおりであり、予想される結果と一致しています
。割り当てられたメモリを断片化された領域にマージし、「3」を入力してメモリのステータスを確認すると、結果は次の図のようになります。 5. メモリの解放: 2 を入力し、「パーティション番号 1 のメモリを解放する」を選択すると、結果は次のようになります
。下図に示すように、解放後、パーティション番号 1 のメモリはアイドル状態になり、期待どおりの結果になります。
6. 分析: 上記のシミュレーションから、ループファースト適応アルゴリズムにより空きパーティションの分布がより均一になり、空きパーティションの検索オーバーヘッドが小さいことが明確にわかります。ただし、上位アドレス部分の大きな空きパーティションが小さなパーティションに分割されるため、大きなジョブにメモリを割り当てることができません。
7. フローチャート
コードは次のとおりです。
#include<iostream>
#include<stdlib.h>
#include<windows.h>
using namespace std;
#define Free 0 //空闲状态
#define Busy 1 //已用状态
#define OK 1 //完成
#define ERROR 0 //出错
#define MAX_length 2048 //定义最大主存信息2048KB
#define Min_Size 10 //规定的不可分割的剩余分区的大小
int flag;//标志位
//函数声明
int myMalloc();//内存分配
int free(int); //内存回收
int Next_fit(int);//循环首次适应算法
void printNode();//查看分配
int Init();//空闲分区的设置
int Combination();//合并碎片空间
typedef struct FreeArea //定义一个空闲区说明表结构
{
char name[30] ;
long size; //分区大小
long address; //分区地址
int state; //空闲标志
}Elem;
typedef struct LinkNode// 双向链表存储结构
{
Elem data;
struct LinkNode *prior; //前趋指针
struct LinkNode *next; //后继指针
}LinkNode, *LinkList;
LinkList block_first; //头结点
LinkList block_last; //尾结点
LinkNode *pn ; //循环首次适应算法中的指针
void menu(){
//打印操作界面
printf("\n");
printf("\t\t\t\t ***** 循环首次适应算法的动态分区分配方式模拟 ***** \n");
printf("\t\t\t\t ┌───────────────────────────────────────────-┐\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 1. 申请内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 2. 释放内存 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 3. 查看内存情况 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 4. 合并碎片空间 │\n");
printf("\t\t\t\t │ │\n");
printf("\t\t\t\t │ 5.退出 │\n");
printf("\t\t\t\t └────────────────────────────────────────────┘\n");
printf("\t\t\t\t\t\t 请您选择(1-5):\t"); //打印想要进行的操作
}
int Init()//初始化内存状态设置（空闲分区的设置）
{
int Free_num; //空闲分区的个数
block_first = (LinkList)malloc(sizeof(LinkNode));
block_last = (LinkList)malloc(sizeof(LinkNode));
block_first->prior = NULL;
block_first->next = block_last;
cout << "请输入空闲分区数目：";
cin >> Free_num ;
int Size[Free_num];
printf("\n请分别输入这%d空闲分区大小（单位KB）：\n",Free_num );
for(int i = 0; i < Free_num; i++)
{
cin >> Size[i];
if(Size[i] <= Min_Size) {
i--;
cout << "\n输入错误，请重输！\n";
}
int temp = 0;
temp = temp + Size[i];
if(temp >= MAX_length) {
i--;
cout << "\n输入错误，请重输！\n";
}
}
LinkList p = block_first;
for(int i = 0; i < Free_num; i++)
{
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = Size[i];
temp->data.state = Free;
if(p == block_first)
temp->data.address = 0;
else
temp->data.address = p->data.address + p->data.size;
temp->prior =p;
p->next = temp;
p = p->next;
}
block_last = p;
block_last->next = NULL;
pn = block_first->next;
return OK;
}
int myMalloc()//分配主存
{
int request = 0;
cout << "请输入需要分配的主存大小(单位:KB)："<<endl;
cin >> request;
if (request<0 || request == 0)
{
cout << "分配大小不合适，请重试！" << endl;
return ERROR;
}
if (Next_fit(request) == OK) cout << "分配成功！" << endl;
else cout << "内存不足，分配失败！" << endl;
return OK;
}
//循环首次适应算法
int Next_fit(int request){
//为申请作业开辟新空间且初始化
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
temp->data.size = request;
temp->data.state = Busy;
cout << "请输入作业名：";
cin >>temp->data.name ;
while (pn)
{
if (pn->data.state == Free && pn->data.size - request <=Min_Size && pn->data.size - request >= 0)
{
//有大小恰好合适的空闲块
pn->data.state = Busy;
for(int i = 0; i < 10; i++){
pn->data.name[i] = temp->data.name[i];
}
return OK;
break;
}
if (pn->data.state == Free && pn->data.size > request + Min_Size)
{
//有空闲块能满足需求且有剩余
temp->prior = pn->prior;
temp->next = pn;
temp->data.address = pn->data.address;
pn->prior->next = temp;
pn->prior = temp;
pn->data.address = temp->data.address + temp->data.size;
pn->data.size -= request;
return OK;
break;
}
pn = pn->next;
if(pn == NULL)
pn = block_first;
}
return ERROR;
}
int free(int flag)//主存回收
{
LinkNode *p = block_first;
for (int i = 0; i <= flag; i++)
if (p != NULL)
p = p->next;
else
return ERROR;
p->data.state = Free;
if(p == block_last){
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p = p->prior;
p->next = NULL;
block_last = p;
}
}
else{
if (p->prior != block_first && p->prior->data.state == Free )//与前面的空闲块相连
{
p->prior->data.size += p->data.size;//空间扩充,合并为一个
p->prior->next = p->next;//去掉原来被合并的p
p->next->prior = p->prior;
p = p->prior;
}
if (p->next != block_last && p->next->data.state == Free )//与后面的空闲块相连
{
p->data.size += p->next->data.size;//空间扩充,合并为一个
p->next->next->prior = p;
p->next = p->next->next;
}
if (p->next == block_last && p->next->data.state == Free )//与最后的空闲块相连
{
p->data.size += p->next->data.size;
p->next = NULL;
}
}
return OK;
}
int Combination() //实现紧凑，合并碎片
{
LinkNode *p = block_first->next;
int size = 0;
while(p){
if(p->data.state ==Free && p != block_last) //去除空闲分区
{
size =size + p->data.size ;
p->next->prior =p->prior ;
p->prior->next = p->next ;
}
else{
p->data.address = p->data.address - size; //改变地址
}
p = p->next;
}
if(block_last->data.state == Free){
//实现最后合并空闲分区
block_last->data.size += size;
}
else if(size != 0){
//将所有空闲分区合并放在最后一个分区后面
LinkList temp = (LinkList)malloc(sizeof(LinkNode));
block_last->next =temp;
temp->prior = block_last;
temp->next = NULL;
temp->data.size = size;
temp->data.address = block_last->data.address + block_last->data.size ;
block_last = temp;
temp->data.state = Free;
}
pn = block_first->next;
if(size == 0) //判断是否有碎片
{
return ERROR;
}
return OK;
}
void printNode()//显示主存分配情况
{
int num = 0;
printf(" 内存情况 \n");
cout << "======================================================\n\n";
LinkNode *p = block_first->next;
cout << "分区号\t起始地址\t分区大小\t状态\t作业名\n\n";
while (p)
{
cout << " " << num++ << "\t";
cout << " " << p->data.address << "\t\t";
cout << " " << p->data.size << "KB\t\t";
if (p->data.state == Free) {
cout << "空闲\n\n";
}
else {
cout << "已分配\t";
cout <<" "<<p->data.name <<"\n\n";
}
p = p->next;
}
cout << "======================================================\n\n";
}
void Operate(){
int choice; //操作选择标记
while (1)
{
menu();
scanf("%d",&choice);
if (choice == 1) myMalloc(); // 分配内存
else if (choice == 2) // 内存回收
{
int flag;
cout << "请输入您要释放的分区号："<<endl;
cin >> flag;
free(flag);
}
else if (choice == 3) printNode();
else if(choice == 4)
{
if(Combination() == 0){
cout<<"无需合并碎片空间！"<<endl;
}
else{
cout<<"成功合并碎片！"<<endl;
}
}
else if (choice == 5) break; //退出
else //输入操作有误
{
cout << "输入有误，请重试！" << endl;
continue;
}
}
}
int main()//主函数
{
system("color 5E");
Init(); //初始化内存状态
Operate();
return 0;
}
お役に立てれば幸いです。