操作系统--可变分区分配

一、实验目的

动态分区分配是根据进程的实际需要，动态地为之分配内存空间，而在分配时，须按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业。

二、实验环境

VS2017+PC

三、实验内容

在本实验中运用了四种分配算法，分别是1.首次适应算法，⒉循环首次适应算法，3.最坏适应算法4.最佳适应算法。

四、实验步骤

1.首次适应算法：在该算法中.把主存中所有空闲区按其起始地址递增的次序排列。在为作业分配存储空间时.从上次找到的空闲分区的下一个空闲分区开始查找.直到找到第一个能满足要求的空闲区.从中划出与请求的大小相等的存储空间分配给作业.余下的空闲区仍留在空闲区链中。

2.循环首次适应算法：该算法是由首次适应算法演变而成，在为进程分配内存空间时，不再是每次都从第一个空间开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，从中划出一块与请求大小相等的内存空间分配给作业，为实现本算法，设置一个全局变量f，来控制循环查找，当f%N==O时，f=0;若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。

3.最佳适应算法：在该算法中.把主存中所有空闲区按其起始地址递增的次序排列。在为作业分配存储空间时.从上次找到的空闲分区的下一个空闲分区开始查找.直到找到一个能满足要求的空闲区且该空闲区的大小比其他满足要求的空闲区都小.从中划出与请求的大小相等的存储空间分配给作业.余下的空闲区仍留在空闲区链中

4.最坏适应算法：在该算法中.把主存中所有空闲区按其起始地址递增的次序排列。在为作业分配存储空间时.从上次找到的空闲分区的下一个空闲分区开始查找.直到找到一个能满足要求的空闲区且该空闲区的大小比其他满足要求的空闲区都大.从中划出与请求的大小相等的存储空间分配给作业.余下的空闲区仍留在空闲区链中。

五、总结

在这次实验中更加清晰的知道：分区的个数和大小不是固定不变的，而是可变的，随装入的作业动态划分，主存的分配和回收的实现与主存储器的管理方式有关，通过做这次实验帮助我理解了可变分区管理方式下应怎样实现贮存空间的分配与回收。由于本次实验是模拟主存的分配，所以主存分配区给作业后并不实际启动装入程序装入作业，采用输入的方式。

六、代码

// Test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;
const int MaxNumber = 100;
int FreePartition[MaxNumber];//空闲可用分区
int Partition[MaxNumber];//进程所需分区
int  PartitionNum, ProcessNum;
int n; //空闲分区个数
int m;//需要分配的进程个数

void FF() //首次适应算法
{
	//寻找大小能满足进程要求的分区
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			if (Partition[i] <= FreePartition[j]) {
				FreePartition[j] = 0;
				cout << "第 " << i + 1 << "个进程被分配给了分区 " << j << endl; break;
			}
			if (j == n - 1) {
				cout << "系统没有足够大的内存分配给进程 " << i << " ，内存分配失败！" << endl;
			}
		}
	}
}

void NF() //循环首次适应算法
{
	int lastUsed = 0;
	int count = 0;
	bool check[100];
	while (count < m) {
		if (lastUsed == n) {
			lastUsed -= n;
		}
		for (int i = lastUsed; i < (n + lastUsed); i++) {
			if (i < n) {
				if (FreePartition[i] >= Partition[count]) {
					FreePartition[i] = 0;
					cout << "空闲分区" << i << "分配了" << Partition[count] << "给进程" << count << endl;
					lastUsed = i + 1;
					break;
				}
			}
			else {
				if (FreePartition[i - n] >= Partition[count]) {
					FreePartition[i - n] = 0;
					cout << "空闲分区" << i - n << "分配了" << Partition[count] << "给进程" << count << endl;
					lastUsed = i + 1; break;
				}
			}
			//没有足够大的进程
			if (i == n + lastUsed - 1) {
				cout << "系统没有足够大的内存分配给进程" << count << "，内存分配失败！" << endl;
			}
		}
		count++;
	}
}

void BF() //最佳适应算法
{
	int count = 0;
	int *Number = new int[n];//记录每个分区内存和进程的内存差
	//让内存最小的进程先判断
	int *Temp = new int[m];
	for (int i = 0; i < m; i++)
	{
		Temp[i] = Partition[i];
	}
	int *number = new int[m];
	for (int i = 0; i < m; i++)
	{
		number[i] = i;
	}
	for (int i = 0; i < m; i++)
	{
		for (int j = i + 1; j < m; j++)
		{
			if (Temp[i] > Temp[j]) {
				int num = 0;
				num = Temp[i];
				Temp[i] = Temp[j];
				Temp[j] = num;

				num = number[i];
				number[i] = number[j];
				number[j] = num;
			}
		}
	}

	while (count < m) {
		//为进程分配内存
		for (int i = 0; i < n; i++) {
			Number[i] = (FreePartition[i] - Partition[number[count]]) >= 0 ? (FreePartition[i] - Partition[number[count]]) : 10000;//如果分区内存大于进程所需，设为10000表示无效分区
		}
		int a = 0;//记录最合适分区的位置
		for (int i = 1; i < n; i++)
		{
			//只需要求数组第一个，即相差最小的
			if (Number[i] < Number[0]) {
				int num = 0;
				a = i;
				num = Number[i];
				Number[i] = Number[0];
				Number[0] = num;
			}

		}
		if (FreePartition[a] >= Partition[number[count]]) {
			FreePartition[a] = 0;
			cout << "分区" << a << "分配给了进程" << number[count] << endl;
		}
		else {
			cout << "系统没有足够大的内存分配给进程 " << number[count] << " ，内存分配失败！" << endl;
		}
		count++;
	}
}

void WF() //最坏适应算法
{
	int count = 0;
	int *Number = new int[n];//记录每个分区内存和进程的内存差
	//让内存最大的进程先判断
	int *Temp = new int[m];
	for (int i = 0; i < m; i++)
	{
		Temp[i] = Partition[i];
	}
	int *number = new int[m];
	for (int i = 0; i < m; i++)
	{
		number[i] = i;
	}
	for (int i = 0; i < m; i++)
	{
		for (int j = i + 1; j < m; j++)
		{
			if (Temp[i] < Temp[j]) {
				int num = 0;
				num = Temp[i];
				Temp[i] = Temp[j];
				Temp[j] = num;

				num = number[i];
				number[i] = number[j];
				number[j] = num;
			}
		}
	}

	while (count < m) {
		//为进程分配内存
		for (int i = 0; i < n; i++) {
			Number[i] = (FreePartition[i] - Partition[number[count]]) >= 0 ? (FreePartition[i] - Partition[number[count]]) : -1;//如果分区内存小于进程所需，设为-1表示无效分区
		}
		int a = 0;//记录最合适分区的位置
		for (int i = 1; i < n; i++)
		{
			//只需要求数组第一个，即相差最大的
			if (Number[i] > Number[0]) {
				int num = 0;
				a = i;
				num = Number[i];
				Number[i] = Number[0];
				Number[0] = num;
			}

		}

		if (FreePartition[a] >= Partition[number[count]]) {
			FreePartition[a] = 0;
			cout << "分区" << a << "分配给了进程" << number[count] << endl;
		}
		else {
			cout << "系统没有足够大的内存分配给进程 " << number[count] << " ，内存分配失败！" << endl;
		}
		count++;
	}
}

int main()
{
	cout << "请输入空闲分区个数：" << endl;
	cin >> n;
	cout << "请输入空闲分区大小：" << endl;
	for (int i = 0; i < n; i++) {
		cin >> FreePartition[i];
	}
	cout << "请输入进程个数：" << endl;
	cin >> m;
	cout << "请输入进程所需分区大小：" << endl;
	for (int i = 0; i < m; i++) {
		cin >> Partition[i];
	}
	int choice;
	while (1)
	{
		cout << "-----------请输入实现的分配方式-----------" << endl;
		cout << "-----------1.首次适应算法-----------------" << endl;
		cout << "-----------2.循环首次适应算法-------------" << endl;
		cout << "-----------3.最佳适应算法-----------------" << endl;
		cout << "-----------4.最坏适应算法-----------------" << endl;
		cout << "-----------5.退出-------------------------" << endl;
		cin >> choice;
		if (choice > 5)
			break;
		switch (choice)
		{
		case 1:
			FF();
			break;
		case 2:
			NF();
			break;
		case 3:
			BF();
			break;
		case 4:
			WF();
			break;
		case 5:
			exit(0);
		}

	}
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件