操作系统实验 连续内存分配 首次适应（FF）算法

已于 2022-08-09 22:13:18 修改
阅读量4.5k 收藏 43
点赞数 9
分类专栏： 操作系统 文章标签： 链表 内存管理 算法 c++ 操作系统
于 2020-11-18 22:48:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44256828/article/details/109789760
版权

1.实验要求

操作系统实验——编程实现首次适应算法。已知作业名、作业大小、作业提交时间、内存容量、碎片大小，要求使用分区大小不等的内存分区方法和首次适应分配算法给每次到来的作业分配内存。输出内存分区情况和分配情况。

2.算法描述

分区大小不等的内存分区法：
可把内存区划分成含有多个较小的分区、适量的中等分区及少量的大分区。
首次适应算法(first fit)：
在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止；如果分区大小-作业大小<=碎片，则直接分配，否则，按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲分区仍留在空闲链中。若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。

3.实验源码

#include<stdio.h>
#include<iostream>
#include<iomanip>
using namespace std;

//操作系统实验 基于顺序搜索的连续 动态分区分配算法 按地址递增 首次适应算法 

#define Free 0 		//	空闲状态
//	#define Busy 1 		//	已用状态
//	#define OK 1    	//	完成
#define ERROR 0 	//	出错
#define MAX_length 640 	//	最大内存空间为640KB
#define Begin_address 0 //  初始地址从 0 开始 
#define Size 10         //  不可分割的最小值 

typedef int Status;

typedef struct freearea		//	定义一个空闲区说明表结构
{
	int ID;
	long size;
	long address;
	int state;
}ElemType;

typedef struct DuLNode 	//	double linked list
{
	ElemType data;
	struct DuLNode *prior; 	//	前趋指针
	struct DuLNode *next;  	//	后继指针
}DuLNode, *DuLinkList;

int n;
DuLinkList block_first; 	//	头结点
DuLinkList block_last;  	//	尾结点   
//==============================================//
void alloc();         	    //	内存分配
Status free2(int); 			//	内存回收
Status free1(int); 			//	作业回收
Status First_fit(int, int);	//	首次适应算法
void show();				//	查看分配
Status Initblock();			//	开创空间表
Status Allocation(int, int);	//	传入分区名及大小

//==============创建双向链表=========================//	
Status Initblock()	//	开创带头结点的内存空间链表
{
	block_first = (DuLinkList)malloc(sizeof(DuLNode));
	block_last = (DuLinkList)malloc(sizeof(DuLNode));

	block_first->prior = NULL;
	block_first->next = block_last;
	block_first->data.state = 3;      //  便于 编程 
	block_last->prior = block_first;
	block_last->next = NULL;

	block_last->data.address = Begin_address;
	block_last->data.size = MAX_length;
	block_last->data.ID = 0;
	block_last->data.state = Free;

	return 1;
}


//============ 动态分区 ========================//

Status Allocation(int ID, int request)	//	传入分区名及大小
{
	//	为申请作业开辟新空间且初始化
	DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));

	temp->data.ID = ID;
	temp->data.size = request;
	temp->data.state = 1;

	DuLNode *p = block_first->next;
	while (p)
	{
		if (p->data.ID == ID)
		{
			p->data.size += request;
			DuLNode *r = p->next;
			while (p)
			{
				p->data.address += request;
				p = p->next;

			}
			return 1;
			break;
		}
		if (p->data.state == Free && p->data.size == request)
		{
			//	有大小恰好合适的空闲块
			p->data.state = 1;
			p->data.ID = ID;

			return 1;
			break;
		}

		if (p->data.state == Free && p->data.size > request)
		{
			//	有空闲块能满足需求且有剩余
			temp->prior = p->prior;
			temp->next = p;

			p->prior->next = temp;
			p->prior = temp;

			temp->data.address = p->data.address;  //  地址 

			p->data.address = temp->data.address + temp->data.size;
			p->data.size = p->data.size - request;

			return 1;
			break;
		}
		p = p->next;
	}
	return ERROR;
}

//==================== 首次适应算法 =======//

Status First_fit(int ID, int request)
{
	//   	cout<<ID<<" "<<request;
	DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));

	temp->data.ID = ID;
	temp->data.size = request;
	temp->data.state = 2;

	DuLNode *p = block_first->next;
	while (p)
	{
		if ((p->data.state == 1) && (p->data.size - request >= 0) && (p->data.size - request <= Size))
		{
			//	有大小恰好合适的空闲块 或所剩为碎片
			p->data.state = 2;
			p->data.ID = ID;

			return 1;
			break;
		}

		if ((p->data.state == 1) && (p->data.size - request > Size))
		{
			//	有空闲块能满足需求且有剩余
			temp->prior = p->prior;
			temp->next = p;

			p->prior->next = temp;
			p->prior = temp;

			temp->data.address = p->data.address;  //  地址  

			p->data.address = temp->data.address + temp->data.size;
			p->data.size = p->data.size - temp->data.size;

			return 1;
			break;
		}
		p = p->next;
	}
	return ERROR;
}
//====================分区 =======================//
void alloc()
{
	int ID, request;
	cout << "请输入分区号、需要分配的主存大小(单位:KB)：";
	cin >> ID >> request;
	if (request < 0 || request == 0)
	{
		cout << "分配大小不合适，请重试！" << endl;
	}
	if (Allocation(ID, request) == 1)
		cout << "分配成功！" << endl;
	else
		cout << "内存不足，分配失败！" << endl;
}

//================== 主存回收  ===================//

Status free2(int ID)
{
	DuLNode *p = block_first;
	while (p)
	{
		if (p->data.ID == ID)
		{
			if (p->data.state == 0)
				cout << "\n区间:" << ID << " 已回收！\n";
			else
				cout << "\n分区:" << ID << " 回收成功！" << endl;

			p->data.state = 0;

			//	  与前面的空闲块相连
			if (p->prior->data.state == 0)
			{
				p->prior->data.size += p->data.size;

				p->prior->next = p->next;
				p->next->prior = p->prior;

				p = p->prior;   //  指针 前移 
			}

			//	  与后面的空闲块相连
			if (p->next->data.state == 0)
			{
				p->data.size += p->next->data.size;

				if (p->next->next == NULL) { p->next = NULL; }
				else
				{
					p->next->next->prior = p;
					p->next = p->next->next;
				}
			}
			break;
		}
		p = p->next;
	}
	return 1;
}

//=========== 撤销作业  ===================//

Status free1(int ID)
{
	int i = 1;
	DuLNode *p = block_first;
	while (p)
	{
		if (p->data.ID == ID)
		{
			if (p->data.state == 2)
				cout << "\n作业:" << ID << " 撤销成功！" << endl;
			if (p->data.state == 1)
				cout << "\n作业:" << ID << " 已撤销！" << endl;
			if (p->data.state == 0)
				cout << "\n区间:" << ID << " 未分配！" << endl;

			p->data.state = 1;

			//	  与前面的空闲块相连
			if (p->prior->data.state == 1)
			{
				p->prior->data.size += p->data.size;

				p->prior->next = p->next;
				p->next->prior = p->prior;

				p = p->prior;   //  指针 前移 
			}

			//	  与后面的空闲块相连
			if (p->next->data.state == 1)
			{
				p->data.size += p->next->data.size;

				if (p->next->next == NULL) { p->next = NULL; }
				else
				{
					p->next->next->prior = p;
					p->next = p->next->next;
				}
			}
			break;
		}
		p = p->next;
	}
	return 1;
}

//====================  显示主存分配情况  ====//

void show()
{
	//		cout<<"主存分配情况 :       \n";	

	DuLNode *p = block_first->next;
	printf("\n\n分区(作业)号    起始地址      所占内存大小(KB)          状态\n\n");

	while (p)
	{
		if (p->data.ID == Free)
			cout << "Free";
		else
			printf("%4d", p->data.ID);

		printf("%17d", p->data.address);
		printf("%18d", p->data.size);

		if (p->data.state == Free)
			cout << setw(22) << "空闲\n";
		else if (p->data.state == 1)
			cout << setw(24) << "已分区\n";
		else
			cout << setw(26) << "已分配作业\n";

		p = p->next;
	}
	cout << "\n=====================================================";
}


int main() 
{
	Initblock();
	int choice;
	int i;
	cout << endl;

	cout << "  ++++++++++++++++++++++++++\n";
	cout << "  ++++++++++++++ 动态分区分配方式的模拟+++\n";
	cout << "  +++++++首次适应算法++++++++++++++++++++++++\n";
	for (i = 0; ; i++)
	{
		show();

		cout << "\n\n  1: 分配内存\n";
		cout << "  2: 装入作业\n";
		cout << "  3: 撤销作业\n";
		cout << "  4: 回收内存\n";
		cout << "  0: 退出\n\n";
		cout << "请输入您的操作： ";
		cin >> choice;

		if (choice == 1)	// 分配内存
			alloc();
		else if (choice == 2)
		{
			int a, b;
			cout << "请输入作业号、大小： ";
			cin >> a >> b;

			if (First_fit(a, b) == 0)
			{
				cout << "\n装不下！没有足够大的区间\n";
			}
		}
		else if (choice == 3)	// 撤销作业
		{
			int ID;
			cout << "请输入您要撤销的作业号：";
			cin >> ID;
			free1(ID);
		}
		else if (choice == 4)	// 内存回收
		{
			int ID;
			cout << "请输入您要释放的分区号：";
			cin >> ID;
			free2(ID);
		}
		else if (choice == 0)	//	退出
			break;
		else 	
		{
			cout << "输入有误，请重试！" << endl;
			continue;
		}
	}

	return 0;
}
gestwr
关注
  • 9
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
可变分区存储管理实验报告总结_可变分区存储管理方式的内存分配和回收实验报告(最优算法)...
weixin_39638305的博客
12-19 2142
p=p->next;}cout<void Initial() { // 初始化说明表SP p,q;p=(SP)malloc(sizeof(SNode));q=(SP)malloc(sizeof(SNode));p->start=14; p->length=12; p->end=26;q->start=32; q->length=96; q->end=...
可变分区存储管理实验报告总结_计算机操作系统存储管理实验报告.doc
weixin_39797912的博客
12-19 875
计算机操作系统存储管理实验报告计算机操作系统存储管理实验报告篇一：《操作系统》存储管理实验报告____大学____学院实验报告篇二：操作系统存储管理实验报告北京邮电大学 操作系统实验 实验报告实验日期：2010-12-20实验名称：存储管理一、实验目的 ............................................................................
动态分区分配算法(First Fit，Next Fit，Best Fit，Worst Fit)
热门推荐
木牛的博客
06-15 1万+
1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit）3.最佳适应算法（Best Fit）4.最坏适应算法（Worst Fit）1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit） 3.最佳适应算法（Best Fit） 4.最坏适应算法（Worst Fit） 1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit）3.最佳适应算法（Best Fit）4.最坏适应算法（Worst Fit） (488条消息) 动态分
操作系统首次适应算法
01-07
VC++6.0编译 模拟操作系统首次适应算法
操作系统主存储器空间的分配和回收 最佳适应算法（C++）
weixin_45623750的博客
12-10 7163
一、实验目的 一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实验帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。 二、实验要求 1．在可变分区管理方式下采用
分区存储管理程序模拟_（连续存储管理）2、可变分区存储管理
weixin_39867208的博客
11-20 1115
可变分区存储管理：1、可变分区：为了解决固定分区因作业装入前，分区的数量和大小确定而造成的内部碎片问题，所以引入了可变分区存储管理。目的就是根据作业对存储空间实际的需求量来划分存储分区。也就是每一个分区与进入该分区的作业大小相同，这样能够有效的解决固定分区引起的内部碎片问题。这是比较实用的存储管理方法，因为在系统运行时，无法确定分区的的数目与大小，所以这种可变式分区也称动态分区。2、问题...
操作系统实验四主存空间的分配与回收首次适应算法和循环首次适应算法.docx
12-23
通过这个实验，学生可以深入理解操作系统如何处理内存分配问题，学习如何有效地管理有限的主存资源，以及如何通过不同的策略来优化内存分配的效率。同时，通过实践，也能提高对数据结构和算法应用的理解。
安徽大学操作系统实验（四）主存空间的分配与回收之首次适应算法FF和循环首次适应算法NF，C语言编写，调试过可运行，含实验报告，含具体流程图 ，有注释和变量解释
12-21
在本实验中，我们探讨了两个关键的内存分配策略：首次适应算法（First Fit, FF）和循环首次适应算法（Next Fit, NF）。这两个算法都是为了解决如何有效地在主存中分配和回收块，以满足不同进程对内存的需求。 首次...
操作系统实验：首次适应算法、最佳适应算法、最坏适应算法
最新发布
qq_66403464的博客
12-05 5277
操作系统实验：首次适应算法、最佳适应算法、最坏适应算法
操作系统实验四主存空间的分配及回收-首次适应算法和循环首次适应算法.doc
10-06
【操作系统实验四】主存空间的分配与回收是操作系统中重要的组成部分，主要涉及连续分区的动态存储管理方式。本实验重点研究两种算法：首次适应算法（First Fit, FF）和循环首次适应算法（Next Fit, NF）。 首次...
操作系统内存分配算法模拟实现
12-11
掌握为实现多道程序并发执行，操作系统是如何通过作业调度选择作业进入内存。系统如何为进入内存的作业分配内存空间，实现多道作业同时驻留内存，就绪进程队列中的多个进程是如何以分式方式共享CPU，作业运行完成离开系统时，系统如何进行内存回收，计算进程周转时间。
操作系统内存分配算法
01-07
四种常见的内存分配算法，简要介绍其优缺点以及代码实现
存储管理--可变分区管理 操作系统 实验报告
12-24
设计一个可变式分区分配的存储管理方案。并模拟实现分区的分配和回收过程。 对分区的管理法可以采用下面三种算法之一： 首次适应算法 循环首次适应算法 最佳适应算法 必须建立空闲区表和占用区表，回收算法考虑四种情况。 流程图按选定的算法自己完成。 三．实验源程序文件名:cunchuguanli.c 执行文件名:cunchuguanli.exe 四、实验分析： 1)本实验采用可变分区管理
操作系统实验报告--模拟内存分配程序
12-30
第一题：在可变分区管理方式下采用首次适应算法实现主存空间的分配和回收，采用空闲区说明表数据结构。 1， 按下图从键盘输入并显示内存空间的分配现状，每个分区有四个数据项：起始地址，大小，状态，进程号。起始地址和大小均以K（字节）为单位；状态为“已分”或“空闲”；进程号：若一分区是“已分”，则填上分得此分区的进程号；若一分区是“空闲”，则填“？”； 第二题：采用可变式分区管理，使用最佳适应法实现主存空间的分配和回收，采用空闲区链数据结构。 该题与上题的程序流程基本相同，只是排序的方法不同：最佳适应法是按“空闲区”的大小从小到大排序。不再重复说明。。
可变式分区存储管理 实验报告和源代码
06-24
操作系统原理课程设计：可变式分区存储管理系统 采用空闲区链实现主存的分配与回收 使用首次适应算法、最优适应算法、最坏适应算法、最后适应算法
Java实现内存分配算法 FF(首次适应算法) BF(最佳适应算法)
u012567068的博客
03-17 2662
一、概述 　　因为这次os作业对用户在控制台的输入输出有要求，所以我花了挺多的代码来完善控制台的显示。 　　MemoryAlgorithm类里只是和控制台输入输出有关的操作，而对内存的所有逻辑操作都是用Memory类里对应的方法实现的。 　　因为不同内存分配算法，只有对空闲分区表的排序不同，所以可以将FF和BF等内存分配算法一起实现。 　　 　　如果只关心和算法有关的核心代码的话，只看M...
可变分区存储管理实验报告总结_可变分区存储管理+实验报告+程序+设计思路和感悟概要...
weixin_39708737的博客
12-19 732
实验题目：可变分区存储管理一、实验目的可变分区存储管理方式是操作系统中存储管理的重要方式，其主要思想是用户作业进行连续存储，每次按照用户的请求，如果内存中有能满足用户作业大小的空闲区，就采用不同的算法分配给用户，否则，不分配，可变分区容易产生外零头。分区分配算法包括最佳适应算法、最坏适应算法、首次适应算法等。通过本实验可加深学生对存储器管理方式的把握以及分配算法的理解，并提高程序设计的能力。二、实...
操作系统内存分配算法与实现
weixin_47139576的博客
08-25 240
操作系统采用了多种内存分配算法和机制，以管理系统的物理内存资源。这些算法和机制的目标是提供高效的内存分配和回收，以满足不同应用程序和任务的需求。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值