dynamicdevide.cpp

动态分区存储管理是一种存储器管理方案。它包含四种内存分配方法：首次适应法、循环首次适应法、最佳适应法和最差适应法

//synamicDevide.cpp

#include"dynamicDevide.h"
#include<vector>
#include<cstdlib>

using namespace std;

void create(vector<block>& pMem,vector<PName>& pList)
{//数据初始化内存块空间
	int MaxSize = 1024;
	int initPosition[5] = {0,150,260,350,600};   //已分配分区的首地址
	int initProgramme[5] = {80,20,60,15,120};    //已分配分区的大小
	int cPosition = 0;
	for(int i = 0;i < 5;i ++)
	{
		if(initPosition[i] > cPosition)
		{
			block tempEBlock;
			tempEBlock.position = cPosition;
			tempEBlock.size = initPosition[i] - cPosition;
			tempEBlock.programmeID = -1;
			tempEBlock.isFilled = false;
			pMem.push_back(tempEBlock);
		}
		block tempBlock;
		tempBlock.position = initPosition[i];
		tempBlock.size = initProgramme[i];
		tempBlock.isFilled = true;
		tempBlock.programmeID = i;
		pMem.push_back(tempBlock);
		PName tempProgramme;
		tempProgramme.ID = i;
		tempProgramme.isDevided = true;
		tempProgramme.size = initProgramme[i];
		pList.push_back(tempProgramme);
		cPosition = initPosition[i] + initProgramme[i];
	}
	if(cPosition < MaxSize)
	{
		block tempEBlock;
		tempEBlock.position = cPosition;
		tempEBlock.size = MaxSize - cPosition;
		tempEBlock.programmeID = -1;
		tempEBlock.isFilled = false;
		pMem.push_back(tempEBlock);
	}
}

void visit(const vector<block>& pMem)
{//内存块的遍历
	cout<<"分区大小\t分区首地址\t已分配分区所属的进程名\t是否分配"<<endl;
	for(int i = 0;i < pMem.size();i ++)
	{
		cout<<pMem[i].size<<"\t\t"
			<<pMem[i].position<<"\t\t"
			<<pMem[i].programmeID<<"\t\t\t"
			<<(pMem[i].isFilled == true ? "已分配":"空闲")
			<<endl;
	}
}

bool FFSolve(vector<block>& pMem,PName cProgramme)
{
	for(int i = 0;i < pMem.size(); i ++)
	{
		if(!pMem[i].isFilled)
		{
			if(pMem[i].size >= cProgramme.size)
			{
				devided(pMem,i,cProgramme);
				return true;
			}
		}
	}
	return false;
}

void devided(vector<block>& pMem,int position,PName cProgramme)
{//为具体内存分配空间
	if(pMem[position].size == cProgramme.size)
	{
		pMem[position].programmeID = cProgramme.ID;
		pMem[position].isFilled = true;
		return;
	}
	else
	{
		block tempBlock;
		pMem.push_back(tempBlock);
		for(int i = pMem.size() - 1;i >position + 1;i --)
		{
			pMem[i] = pMem[i - 1];
		}
		int lSize = pMem[position].size - cProgramme.size;
		pMem[position].size = cProgramme.size;
		pMem[position].programmeID = cProgramme.ID;
		pMem[position].isFilled = true;
		pMem[position + 1].position = pMem[position].position + cProgramme.size;
		pMem[position + 1].programmeID = -1;
		pMem[position + 1].size = lSize;
		pMem[position + 1].isFilled = false;
		return;
	}
}

bool worstSolve(vector<block>& pMem,PName cProgramme)
{
	int largestBlock = -1;
	int nPosition = -1;
	for(int i = 0;i < pMem.size();i ++)
	{
		if(!pMem[i].isFilled)
		{
			if(pMem[i].size > largestBlock)
			{
				nPosition = i;
				largestBlock = pMem[i].size;
			}
		}
	}
	
	if(pMem[nPosition].size >= cProgramme.size)
	{
		devided(pMem,nPosition,cProgramme);
		return true;
	}
	else
	{
		return false;
	}
}

void recycleSolve(vector<block>& pMem,PName cProgramme)
{
	for(int i = 0; i < pMem.size();i ++)
	{
		if(pMem[i].programmeID == cProgramme.ID)
		{
			break;
		}
	}
	pMem[i].isFilled = false;
	pMem[i].programmeID = -1;
	int contractNum = 0;
	int preNode = 0;
	if(i > 0)
	{
		if(pMem[i-1].isFilled == false)
		{
			contractNum += 1; 
		}
	}
	if(contractNum)
	{
		preNode = 1;
	}
	if(i < pMem.size() - 1)
	{
		if(pMem[i + 1].isFilled == false)
		{
			contractNum += 1;
		}
	}
	switch(contractNum)
	{
	case 0:break;
	case 1:if(preNode)
		   {
			   pMem[i - 1].size += pMem[i].size;
			   for(int j = i + 1;j < pMem.size();j ++)
			   {
				   pMem[j - 1] = pMem[j];
			   }
			   pMem.pop_back();
		   }
		   else
		   {
			   pMem[i].size += pMem[i + 1].size;
			   for(int j = i + 2;j < pMem.size(); j ++)
			   {
				   pMem[j - 1] = pMem[j];
			   }
			   pMem.pop_back();
		   }
		   break;
	case 2:pMem[i - 1].size += pMem[i].size + pMem[i + 1].size;
		   for(int j = i + 2;j < pMem.size(); j ++)
		   {
			   pMem[j - 2] = pMem[j];
		   }
		   pMem.pop_back();
		   pMem.pop_back();
		   break;
	}
}