Linux内存管理

2021SC@SDUSC

项目环境：

1. 树莓派4b
2. Ubuntu Desktop 21.04

动态分区分配：

进程在运行的时候需要为其分配内存空间，但考虑到节约内存等因素的影响，我们需要适当的算法来对进程进行内存分配，这就是动态存储分配问题（dynamic storage-allocation problem）。

当按照地址顺序在链表中存放进程和空闲区时，有几种算法可以用来为创建的进程（或从磁盘换入的已存在的进程）分配内存。在代码中，实现了首次适配（first fit）、下次适配（next fit）（临近适配）、最佳适配（best fit）以及最差适配（worst fit）。

对于以上四种算法，《操作系统概念》中说明：

• 首次适应：分配首个足够大的孔。查找可以从头开始，也可以从上次首次适应结束时开始。一旦找到足够大的空闲孔，就可以停止。
• 最优适应：分配最小的足够大的孔。应查找整个列表，除非列表按大小排序。这种方法可以产生最小剩余孔。
• 最差适应：分配最大的孔。同样，应查找整个列表，除非列表按大小排序。这种方法可以产生最大剩余孔，该孔可能比最优适应产生的较小剩余孔更为适用。

在书《现代操作系统》中，有如下说明：

依据上面的描述，我们不难写出算法相应代码实现。下面附上实验代码与截图：

 
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;
 
#define MAXNUMBER 100
static int PartitionNum;
static int ProcessNum; 
static int FreePartition[MAXNUMBER]; 
static int ProcessNeed[MAXNUMBER]; 
static int LeftFreePartition[MAXNUMBER];
static int LeftProcessNeed[MAXNUMBER];
static char ProcessName[MAXNUMBER];
static char NameProcessToPartition[MAXNUMBER][MAXNUMBER];
 
typedef struct
{
	int partitionSize;
	int id;
}sortNeed;
 
void readDataFunction();
void display();
void FirstFit();
void NextFit();
void BestFit();
void WorstFit();
void selectAlgorithm(int chooceAlgorithm);
void display();
 
void readDataFunction()
{
	ifstream readData;
	readData.open("data.txt");
 
	readData>>PartitionNum;
	for (int i=0;i<PartitionNum;i++)
	{
		readData>>FreePartition[i];
	}
 
	readData>>ProcessNum;
	for (int i=0;i<ProcessNum;i++)
	{
		readData>>ProcessName[i];
	}
	for (int i=0;i<ProcessNum;i++)
	{
		readData>>ProcessNeed[i];
	}
}
 
void initial()
{
	readDataFunction();
	for (int i=0;i<ProcessNum;i++)
	{	
		for (int j =0;j<PartitionNum;j++)
		{
			NameProcessToPartition[i][j] =NULL;
			LeftFreePartition[j] = FreePartition[j];
		}
	}
	for (int i = 0;i<ProcessNum;i++)
	{
		LeftProcessNeed[i] = ProcessNeed[i];
	}
}
 
 
void FirstFit()
{
	cout<<"***********首次适应***********"<<endl;
	initial();
 
	int i,j;
	for (i = 0;i<ProcessNum;i++) 
	{
		for (j = 0;j<PartitionNum;j++)   
		{
			if (LeftProcessNeed[i] <= LeftFreePartition[j] && LeftFreePartition!=0) 
			{
				LeftFreePartition[j] -= LeftProcessNeed[i]; 
				LeftProcessNeed[i] = 0; 
				NameProcessToPartition[i][j] = ProcessName[i];
 
				break;   
			}
		}
	}
 
	display();
	
}
 
void NextFit()
{
	cout<<"***********循环首次适应***********"<<endl;
	initial();
	int i,nextPoint = 0;
	bool isWhile;
	for (i = 0;i<ProcessNum;i++)
	{
		isWhile = true;
		while(isWhile)  
		{
			if (LeftFreePartition[nextPoint] >= LeftProcessNeed[i])
			{
				LeftFreePartition[nextPoint] -= LeftProcessNeed[i];
				LeftProcessNeed[i] = 0;
				NameProcessToPartition[i][nextPoint] = ProcessName[i];
				nextPoint++;
				if (nextPoint > PartitionNum - 1)
				{
					nextPoint = 0; 
				}
				isWhile = false;
			}
			else
				nextPoint++;
		}
	}
	display();
}
 
void BestFit()
{
	
	cout<<"***********最佳适应***********"<<endl;
	initial();
	int i,j,temp,tempID;
 
	sortNeed best[MAXNUMBER];
	for (i = 0;i<PartitionNum;i++)
	{
		//初始化结构体
		best[i].partitionSize = FreePartition[i];
		best[i].id = i;
	}
 
	for (i = 0;i<ProcessNum;i++