动态分区分配方式的模拟c语言代码_计算机操作系统：动态分区分配方式的模拟...

最新推荐文章于 2025-02-06 21:04:59 发布

weixin_39557583

最新推荐文章于 2025-02-06 21:04:59 发布

阅读量1.7k

点赞数 4

动态分区首次适应算法最佳适应算法内存分配碎片

关键词由CSDN通过智能技术生成

本篇文章原文来自CSDN：https://blog.csdn.net/weixin_37537818/article/details/89486644

并非自己原创！

自己进行了排版上的更改，更适合直接拿来提交。

仅供参考！！！仅供参考！！！仅供参考！！！

实验5：动态分区分配方式的模拟

1 ．实验目的

了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。

2 ．实验内容

（1）用C 语言分别实现采用首次适应算法（地址从小到大）和最佳适应算法（空闲块大小从小到大）的动态分区分配过程myalloc() 和回收过程myfree()(即自己编写一个分区分配和释放的函数) 。其中，空闲分区通过空闲分区链来管理；在进行内存分配时，系统优先使用空闲区低端的空间。

（2）假设初始状态下，可用的内存空间为640 KB（即程序开始运行时，用malloc()函数一次申请640KB的内存空间，程序结束时用free()函数释放空间。然后自己编写程序在这640KB的空间上模拟首次适应算法和最佳适应算法的分配过程。自己编写的分配过程不是真正去向操作系统申请空间，而是在这640KB空间上标记那块占用了；释放过程也不是真正释放空间，只是标记哪块分区空闲），作业请求序列如下：

l 作业l 申请130 KB 。

l 作业2 申请60 KB 。

l 作业3 申请100 KB 。

l 作业2 释放60 KB 。

l 作业4 申请200 KB 。

l 作业3 释放100 KB 。

l 作业l 释放130 KB 。

l 作业5 申请140 KB 。

l 作业6 申请60 KB 。

l 作业7 申请50 KB 。

l 作业6 释放60 KB 。

请分别采用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况。

实验步骤与调试过程：

首次适应算法

我们以空闲分区链为例来说明采用FF算法时的分配情况。FF算法要求空闲分区链以地址递增的次序链接。

1.在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止；

2.然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲分区仍留在空闲链中。

3.若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。

最佳适应算法：

1.将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序，从而形成空闲分区链。

2.每次从链首进行查找合适的空闲分区为作业分配内存，余下的空闲分区仍留在空闲链中。

3.若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。

实验结果：

（在提交的时候图片一定要进行去水印处理啊=-=，不知道怎么去水印→百度）

首次适应算法

最佳适应算法

首次适应算法

最佳适应算法

疑难小结：

通过本次实验，编写并调试了动态分区分配方式的模拟程序，更加熟悉了动态分区分配方式的过程，我采用了动态分区分配，动态分区分配也包含了几个算法，分别是首次适应算法，和最佳适应算法，提高了计算机的分配效率。

各种分配算法的特点：

首次适应算法：

算法思想：将空闲分区链以地址递增的顺序连接；在进行内存分配时，从链首开始顺序查找，直到找到一块分区的大小可以满足需求时，按照该作业的大小，从该分区中分配出内存，将剩下的空闲分区仍然链在空闲分区链中。

优点：高址部分的大的空闲分区得到保留，为大作业的内存分配创造了条件；

缺点：（1）每次都是优先利用低址部分的空闲分区，造成低址部分产生大量的外碎片。（2）每次都是从低址部分查找，使得查找空闲分区的开销增大；

最佳适应算法：

算法思想：将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序，从而形成空闲分区链。每次从链首进行查找合适的空闲分区为作业分配内存，这样每次找到的空闲分区是和作业大小最接近的，所谓“最佳”。

优点：第一次找到的空闲分区是大小最接近待分配内存作业大小的；

缺点:产生大量难以利用的外部碎片。

主要实现方法或程序：

#include<stdio.h>
#include<malloc.h>
#include<string.h>

#define TOTAL_MEMORY 200


typedef struct partition {
	int num;			//分区号 
	int startAdress;    //分区开始地址 
	int leisureAdress;  //空闲地址 
	int size;			//剩余空间 
	int state;         //状态 , 0未分配，1已分配 
	struct partition *next;
}partition, *PART;

void printPartitionQue(PART partHead) {
	PART mPart = partHead;
	printf("分区号      起址       空闲起址       空闲空间       状态n");
	while (mPart != NULL) {
		printf("%3d          ", mPart->num);
		printf("%3d          ", mPart->startAdress);
		printf("%3d          ", mPart->leisureAdress);
		printf("%3d           ", mPart->size);
		printf("%3d           ", mPart->state);
		printf("n");
		mPart = mPart->next;
	}
	printf("n");
}

/**
*	创建分区
*/
PART createPartition() {
	PART partHead = NULL, mPart = NULL;
	int sizes[4] = { 64, 16, 128, 32 };
	//	int sizes[4] = {128, 64, 32, 12};
	int startAdress = 20;
	for (int i = 1; i <= 4; i++) {
		if (i == 1) {
			mPart = partHead = (PART)malloc(sizeof(partition));
			mPart->num = i;
			mPart->startAdress = startAdress;
			mPart->leisureAdress = startAdress;
			mPart->size = sizes[i - 1];
			mPart->state = 0;
			startAdress += mPart->size;
			mPart->next = NULL;
		}
		else {
			mPart->next = (PART)malloc(sizeof(partition));
			mPart = mPart->next;
			mPart->num = i;
			mPart->startAdress = startAdress;
			mPart->leisureAdress = startAdress;
			mPart->size = sizes[i - 1];
			mPart->state = 0;
			startAdress += mPart->size;
			mPart->next = NULL;
		}
	}
	return partHead;
}

/**
*	按可用空间大小按升序 选择排序
*/
PART  sort(PART partHead, int totalPart) {
	PART sortHead = NULL;
	PART nPart = NULL, tPart = NULL;;
	PART temp;
	int min = 0;
	while (totalPart != 0) {
		min = partHead->size;
		nPart = partHead->next;
		//获取最小的大小赋值给min 
		while (nPart != NULL) {
			if (min > nPart->size) {
				min = nPart->size;
			}
			nPart = nPart->next;
		}
		nPart = partHead;
		while (nPart != NULL) {
			if (nPart->size == min) {
				temp = nPart;
				if (sortHead == NULL) {
					tPart = sortHead = (PART)malloc(sizeof(partition));
					tPart->num = nPart->num;
					tPart->startAdress = nPart->startAdress;
					tPart->leisureAdress = nPart->leisureAdress;
					tPart->size = nPart->size;
					tPart->state = nPart->state;
					tPart->next = NULL;
				}
				else {
					tPart->next = (PART)malloc(sizeof(partition));
					tPart = tPart->next;
					tPart->num = nPart->num;
					tPart->startAdress = nPart->startAdress;
					tPart->leisureAdress = nPart->leisureAdress;
					tPart->size = nPart->size;
					tPart->state = nPart->state;
					tPart->next = NULL;
				}
				PART mPart = partHead;
				while (mPart != NULL) {
					if (mPart == temp) {
						partHead = partHead->next;
						totalPart--;
						break;
					}
					else if (mPart->next == temp) {
						mPart->next = temp->next;
						totalPart--;
						break;
					}
					mPart = mPart->next;
				}
			}

			nPart = nPart->next;
		}
	}
	return sortHead;
}

/**
*	首次适应算法分配内存核心代码
*/
void assignOfFirstFit(PART partHead, PART mPart, int size) {
	mPart = partHead;
	while (mPart != NULL) {
		if (mPart->size >= size) {
			mPart->size -= size;
			mPart->leisureAdress += size;
			mPart->state = 1;
			printf("***********************成功分配后的分区列表***********************n");
			printPartitionQue(partHead);
			break;
		}
		mPart = mPart->next;
	}
	if (mPart == NULL) {
		printf("内存不足!n");
	}
}

/**
*	循环首次适应算法分配内存核心代码
*/
PART assignOfNextFit(PART partHead, PART mPart, int size, int totalPart) {
	while (totalPart != 0) {
		if (mPart != NULL) {
			if (mPart->size >= size) {
				mPart->size -= size;
				mPart->leisureAdress += size;
				mPart->state = 1;
				printf("***********************成功分配后的分区列表***********************n");
				printPartitionQue(partHead);
				return mPart->next;
			}
			mPart = mPart->next;
			totalPart--;
		}
		else {
			mPart = partHead;
		}
	}
	if (totalPart == 0) {
		printf("内存不足!n");
		return mPart;
	}
}


//	最佳适应算法

PART assignOfBestFit(PART partHead, PART mPart, int size) {
	mPart = sort(partHead, 4);
	partHead = mPart;
	while (mPart != NULL) {
		if (mPart->size >= size) {
			mPart->size -= size;
			mPart->leisureAdress += size;
			mPart->state = 1;
			printf("***********************成功分配后的分区列表***********************n");
			partHead = sort(partHead, 4);
			printPartitionQue(partHead);
			return partHead;
		}
		mPart = mPart->next;
	}
	if (mPart == NULL) {
		printf("内存不足!n");
		return partHead;
	}
}

/**
*  分配内存
*/
void assignMemory(PART partHead, int assignType) {
	int totalPart = 4;
	PART mPart = partHead;
	char c;
	char name[10] = "";
	int size = 0;
	printf("是否输入作业(Y/N)：");
	scanf("%c", &c);
	while (c == 'Y' || c == 'y') {
		printf("请输入作业名：");
		scanf("%s", &name);
		printf("请输入作业大小：");
		scanf("%d", &size);

		switch (assignType) {
		case 1:
			assignOfFirstFit(partHead, mPart, size);
			break;
		case 2:
			partHead = assignOfBestFit(partHead, mPart, size);
			break;
		}

		printf("是否输入作业(Y/N)：");
		getchar();
		scanf("%c", &c);
	}
}

/**
*	最佳适应算法
*/
void BestFit(PART partHead) {
	printf("***********************排序前的分区列表***********************n");
	printPartitionQue(partHead);
	//分配内存
	assignMemory(partHead, 2);
}


/**
*	首次适应算法
*/
void FirstFit(PART partHead) {
	printf("***********************分配前的分区列表***********************n");
	printPartitionQue(partHead);
	//分配内存 
	assignMemory(partHead, 1);
}

int main() {
	int k;
	PART partHead = createPartition();
	printf("*****************************动态分区分配方式的模拟*************************");
	printf("n                          1、首次适应算法                                 ");
	printf("n                          2、最佳适应算法                                 ");
	printf("n                          3、退出                                         ");
	printf("n请输入对应序号选择相应的算法：");
	scanf("%d", &k);
	getchar();
	switch (k) {
	case 1:
		FirstFit(partHead);
		break;
	case 2:
		BestFit(partHead);
		break;
	case 3:
		break;
	default:
		printf("选择错误，请重新选择。");
	}
	return 0;
}