实验四 动态分区分配算法（二）的模拟

1.实验目的

1）加深操作系统内存管理过程的理解

2）掌握内存分配算法的基本应用

2.实验要求

1）实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。希望同学们实现如下功能：

2）初始化功能：内存状态设置为初始状态。

3）分配功能：要求至少使用两种算法，用户可以选择使用。

4）回收功能：

5）空闲块的合并：即紧凑功能，用以消除碎片。当做碎片整理时，需要跟踪分配的空间，修改其引用以保证引用的正确性。

6）显示当前内存的使用状态，可以使用表格或图形。

2.实验步骤：设计程序模拟内存动态分区分配流程。
1、内存分配表建议使用单链表实现。
2、分区分配算法可以采用首次适应算法、循环首次适应算法、最佳算法之一。
3、假设内存大小为1024K，起始地址为0，都可以被用户程序使用，size数值设为2K。

实验分析：

设计程序模拟内存动态分区分配流程，要求实现三项功能：分配内存、回收内存、显示内存使用情况
内存连续分配动态分区分配流程图如下

#include<bits/stdc++.h>
#include<iterator>
using namespace std;
#define SIZE 2

typedef struct Memory
{
	int zoning_number;//分区号
	char job_name;//作业名
	int start_address;//起始地址
	int zoning_size;//分区大小
	int state;//状态 （0 1）   1：已分配 2：未分配
} memory;

list<memory> me;

bool cmp(memory a,memory b)
{
	return a.start_address<b.start_address;
}

void FF()   //首次适应算法
{
	int flag=0;//分配成功 1  失败 0
	memory node;//申请新节点
	//input
	cout<<"作业名(一个字符):";
	char name;
	cin>>name;
	node.job_name=name;
	cout<<"作业占内存大小：";
	int u;
	cin>>u;
	node.zoning_size=u;
	//ff算法
	me.sort(cmp);//地址递增排序
	list<memory>::iterator it;
	for(it=me.begin(); it!=me.end(); it++)
	{
		if((*it).state==0)   //空闲分区链
		{
			if((*it).zoning_size>u)
			{
				if((*it).zoning_size-u<=2)
				{
					(*it).state=1;//将该分区从空闲链中移除
					(*it).job_name=name;
					flag=1;
					break;
				}
				else     //有空闲块能满足需求且有剩余
				{
					node.zoning_number=(*it).zoning_number;
					node.start_address=(*it).start_address;
					(*it).zoning_number+=1;
					(*it).start_address+=u;
					(*it).zoning_size-=u;
					node.state=1;
					me.insert(it--,node);
					flag=1;
					break;
				}
			}
		}
	}
	if(flag==1)
	{
		cout<<"分配成功！！！"<<endl;
	}
	else
		cout<<"分配失败！！！"<<endl;
}

void recovery()   //回收内存
{
	cout<<"输入要回收分区的作业名(一个字符):";
	char name;
	cin>>name;
	list<memory>::iterator it;
	list<memory>::iterator next_mem;
	list<memory>::iterator pre_mem;
	list<memory>::iterator tail;
	list<memory>::iterator now;
	list<memory>::iterator now1;
	list<memory>::iterator next_mem1;
	for(it=me.begin(); it!=me.end(); it++)
	{
		if((*it).job_name==name&&it==me.begin())//开头
		{
			pre_mem=it;
			next_mem=++it;//后一个分区
			cout<<(*next_mem).zoning_number<<endl;
			if((*next_mem).state==0)   //后一个分区为空闲   合并
			{
				(*pre_mem).zoning_size+=(*next_mem).zoning_size;//合并 回收区与f2
				(*pre_mem).state=0;
				(*pre_mem).job_name=' ';
				pre_mem=it;
				next_mem=++it;
				while(next_mem!=me.end())
				{
					(*pre_mem).job_name=(*next_mem).job_name;
					(*pre_mem).start_address=(*next_mem).start_address;
					(*pre_mem).zoning_size=(*next_mem).zoning_size;
					(*pre_mem).state=(*next_mem).state;
					pre_mem++;
					next_mem++;
				}//删除f2过程
				me.pop_back();
				cout<<"回收成功！！！"<<endl;
				break;
			}
			else
			{
				(*pre_mem).job_name=' ';
				(*pre_mem).state=0;
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
		tail=me.end();
		--tail;
		if((*it).job_name==name&&it==tail)//结尾
		{
			pre_mem=--it;//结尾的上一个元素
			if((*pre_mem).state==0)//合并
			{
				(*pre_mem).zoning_size+=(*tail).zoning_size;
				me.pop_back();
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
		//3种情况
		if((*it).job_name==name)
		{
			pre_mem=--it;
			now=++it;
			next_mem=++it;
			if((*pre_mem).state==0&&(*next_mem).state==0)//3个合并
			{
				(*pre_mem).zoning_size=(*now).zoning_size+(*next_mem).zoning_size+(*pre_mem).zoning_size;//合并大小

				now1=now;
				next_mem1=next_mem;

				while(next_mem1!=me.end())
				{
					(*now1).job_name=(*next_mem1).job_name;
					(*now1).start_address=(*next_mem1).start_address;
					(*now1).zoning_size=(*next_mem1).zoning_size;
					(*now1).state=(*next_mem1).state;
					now1++;
					next_mem1++;
				}//删
				me.pop_back();
				it=now; 
				while(next_mem!=me.end())
				{
					(*now).job_name=(*next_mem).job_name;
					(*now).start_address=(*next_mem).start_address;
					(*now).zoning_size=(*next_mem).zoning_size;
					(*now).state=(*next_mem).state;
					now++;
					next_mem++;
				}//删
				me.pop_back();
				cout<<"333回收成功！！！"<<endl;
				break;
			}
			else if((*pre_mem).state==0)
			{
				(*pre_mem).zoning_size+=(*now).zoning_size;
				while(next_mem!=me.end())
				{
					(*now).job_name=(*next_mem).job_name;
					(*now).start_address=(*next_mem).start_address;
					(*now).zoning_size=(*next_mem).zoning_size;
					(*now).state=(*next_mem).state;
					now++;
					next_mem++;
				}//删
				me.pop_back();
				cout<<"f1回收成功！！！"<<endl;
			}
			else if((*next_mem).state==0)
			{
				(*now).zoning_size+=(*next_mem).zoning_size;
				
				now1=next_mem;
				next_mem1=++next_mem;
				while(next_mem1!=me.end())
				{
					(*now1).job_name=(*next_mem1).job_name;
					(*now1).start_address=(*next_mem1).start_address;
					(*now1).zoning_size=(*next_mem1).zoning_size;
					(*now1).state=(*next_mem1).state;
					now1++;
					next_mem1++;
				}//删
				me.pop_back();
				cout<<"f2回收成功！！！"<<endl;
				break;
			}
			else//都不邻接
			{
				(*now).job_name=' ';
				(*now).state=0;
				cout<<"回收成功！！！"<<endl;
				break;
			}
		}
	}
}

void menu()
{
	cout<<"\n\n";
	cout<<"1. 分配内存"<<endl;
	cout<<"2. 回收内存"<<endl;
	cout<<"3. 显示内存使用情况"<<endl;
	cout<<"4. 退出"<<endl;
	cout<<"\n\n";
	cout<<"请输入选择:";
}

void print()   //显示内存使用情况
{

	cout<<"分区号\t作业名\t起始地址\t分区大小\t状态"<<endl;
	list<memory>::iterator it;
	for(it=me.begin(); it!=me.end(); it++)
	{
		cout<<(*it).zoning_number<<"\t"<<(*it).job_name<<"\t"<<(*it).start_address<<"\t\t"<<(*it).zoning_size<<"\t\t"<<(*it).state<<endl;
	}
}

int main()
{
	//初始化头结点
	memory head;
	head.zoning_number=0;
	head.start_address=0;
	head.zoning_size=1024;
	head.state=0;

	me.push_front(head);

	int sel;
	int flag=1;
	while(1)
	{
		menu();
		cin>>sel;
		switch(sel)
		{
			case 1:
				FF();
				break;
			case 2:
				recovery();
				break;
			case 3:
				print();
				break;
			case 4:
				flag=0;
				break;
		}
		if(flag==0)
			break;
	}
}

代码运行后：