操作系统原理与实验——实验八连续存储管理方式的模拟与实现(可变分区)

已于 2024-04-23 14:41:40 修改
阅读量777 收藏 13
点赞数 4
文章标签： 算法
于 2024-04-01 21:40:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62806440/article/details/137247385
版权

实验指南

1.本实验是模拟存储管理方式中的可变分区分配与回收算法，系统需要建立两张分区表，分别是未(已)分配分区表，然后根据待装入作业的名称和大小到未分配分区列表中查找(具体包含最先/最优/最坏适配算法)满足要求的空闲分区，再将该分区一分为二，前半部分分配给作业使用并登记到已分配分区表的空栏中，剩余部分仍修改为新的空闲分区，最后通过动态重定位方式完成地址转换；当作业运行结束时，根据该作业名查找已分配分区表，找到与作业名相同的分区，然后将该分配从已分配分区表中删除，最后按照无上邻无下邻、有上邻无下邻、无上邻有下邻和有上邻有下邻四种形式分别修改未分配分区表。

 

测试用例：

样例一：

最先分配算法

256
40
1
1
JOB_A
15
1
1
JOB_B
50
1
1
JOB_C
10
1
1
JOB_D
25
1
1
JOB_E
14
2
JOB_B
2
JOB_D
1
1
JOB_F
32
2
JOB_C
2
JOB_E
2
JOB_A
2
JOB_F

 

样例二：

最优分配算法

256
40
1
2
JOB_A
15
1
2
JOB_B
50
1
2
JOB_C
10
1
2
JOB_D
5
1
2
JOB_E
14
2
JOB_D
1
2
JOB_H
6

关键代码

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>
#include<string.h>
using namespace std;
//内存结构体
typedef struct memory_node
{    
	int size; //内存大小
    int address; //内存始址
} memoryNode;
memoryNode memory;
//分区结构体
typedef struct link_node
{    	
	int size;//分区大小
    int address; //分区始址
    char flag[20]; //分区状态，空闲或者占用作业名
    struct link_node *next;
} node;
//作业结构体
typedef struct job_node
{    
	int id;//作业编号
    char name[20];//作业名
    int size;//作业大小
} job;
void print(node *yfp,node *wfp)
{
		printf("\n*******************主存分配情况**************");
		printf("\n已分配："); 
		
		int count = 1;
		node *dy;
		dy=yfp->next;
		printf("\n分区号   大小（KB）   起始（KB）   状态");
		while(dy!=NULL)
		{
			printf("\n%d\t  %d\t\t %d\t   ",count,dy->size,dy->address);
			if(dy->flag[0] == '\0')
			printf("空闲");
			else
			printf("%s",dy->flag);
			dy = dy->next;
			count++;
		}
	
		printf("\n未分配：");
		dy=wfp->next;
		printf("\n分区号   大小（KB）   起始（KB）   状态");
		while(dy!=NULL)
		{
			printf("\n%d\t  %d\t\t%d\t   ",count,dy->size,dy->address);
			if(dy->flag[0] == '\0')
			printf("空闲");
			else
			printf("%s",dy->flag);
			dy = dy->next;
			count++;
		}
}
void govern(node *yfp,node *wfp)
{
	int option; 
	printf("\n*****************分配算法*****************"); 
	printf("\n        *       1.最先分配算法       *");
	printf("\n        *       2.最优分配算法       *");
	printf("\n        *       3.最坏分配算法       *");
	printf("\n                请输入选项："); 
	scanf("%d",&option);
	if(option == 1)//最先分配算法
	{
		job JOB;
		printf("\n请输入作业名：");
		scanf("%s",&JOB.name);
		printf("\n%s需要分配的主存大小（单位：KB）：",JOB.name);
		scanf("%d",&JOB.size); 
		node*p = wfp->next;
		while(p != NULL)
		{
			if(p->size >= JOB.size)
			{
				break;
			}
			p = p->next; 
		}
		node*NODE = (node*)malloc(sizeof(node));//创建节点插入已分配表中 
		NODE->next = NULL;
		NODE->size = JOB.size;
		NODE->address = p->address;
		int i=0;
		for(i=0;i<strlen(JOB.name);i++)
		{
			NODE->flag[i] = JOB.name[i];
		} 
		NODE->flag[i+1]='\0';
		 
		
		node*h = yfp;//修改已分配表 
		while(h->next != NULL)
		{
			h = h->next; 
		}
		h->next = NODE;
		
		node*hh = wfp->next;
		node*pre = wfp;
		while(hh != p)
		{
			pre=hh;
			hh = hh->next;
		}
		if(p->size == JOB.size)
		{
			pre->next = p->next;
		}
		else
		{
			p->address = p->address + JOB.size;
			p->size = p->size -JOB.size;
		}
		printf("\n分配成功！");
		print(yfp,wfp);
	}
	else if(option == 2)//最优分配算法
	{
		job JOB;
		printf("\n请输入作业名：");
		scanf("%s",&JOB.name);
		printf("\n%s需要分配的主存大小（单位：KB）：",JOB.name);
		scanf("%d",&JOB.size); 
		node*p = wfp->next,*best = NULL;
		while(p != NULL)
		{
			if(p->size >= JOB.size && best == NULL)
			{
				best = p;
			}
			if(p->size >= JOB.size && p->size <best->size)
			{
				best = p;
			}
			p = p->next; 
		}
		node*NODE = (node*)malloc(sizeof(node));//创建节点插入已分配表中 
		NODE->next = NULL;
		NODE->size = JOB.size;
		NODE->address = best->address;
		int i=0;
		for(i=0;i<strlen(JOB.name);i++)
		{
			NODE->flag[i] = JOB.name[i];
		} 
		NODE->flag[i+1]='\0';
		 
		
		node*h = yfp;//修改已分配表 
		while(h->next != NULL)
		{
			h = h->next; 
		}
		h->next = NODE;
		
		node*hh = wfp->next;
		node*pre = wfp;
		while(hh != best)//修改未分配表 
		{
			pre=hh;
			hh = hh->next;
		}
		if(best->size == JOB.size)
		{
			pre->next = best->next;
		}
		else
		{
			best->address = best->address + JOB.size;
			best->size = best->size -JOB.size;
		}
		printf("\n分配成功！");
		print(yfp,wfp);
	}
	else//最坏分配算法
	{
		job JOB;
		printf("\n请输入作业名：");
		scanf("%s",&JOB.name);
		printf("\n%s需要分配的主存大小（单位：KB）：",JOB.name);
		scanf("%d",&JOB.size); 
		node*p = wfp->next,*best = NULL;
		while(p != NULL)
		{
			if(p->size >= JOB.size && best == NULL)
			{
				best = p;
			}
			if(p->size >= JOB.size && p->size >best->size)
			{
				best = p;
			}
			p = p->next; 
		}
		node*NODE = (node*)malloc(sizeof(node));//创建节点插入已分配表中 
		NODE->next = NULL;
		NODE->size = JOB.size;
		NODE->address = best->address;
		int i=0;
		for(i=0;i<strlen(JOB.name);i++)
		{
			NODE->flag[i] = JOB.name[i];
		} 
		NODE->flag[i+1]='\0';
		 
		
		node*h = yfp;//修改已分配表 
		while(h->next != NULL)
		{
			h = h->next; 
		}
		h->next = NODE;
		
		node*hh = wfp->next;
		node*pre = wfp;
		while(hh != best)//修改未分配表 
		{
			pre=hh;
			hh = hh->next;
		}
		if(best->size == JOB.size)
		{
			pre->next = best->next;
		}
		else
		{
			best->address = best->address + JOB.size;
			best->size = best->size -JOB.size;
		}
		printf("\n分配成功！");
		print(yfp,wfp);
	}
} 
void release(node *yfp, node *wfp)
{
		print(yfp,wfp);
		printf("\n请输入要回收的作业名："); 
		char NAME[20];
		scanf("%s",&NAME);
		
		node *h,*hpre;
		hpre = yfp;
		h = yfp->next;
		while(h!=NULL)
		{
			string str1,str2;
			str1 = h->flag;
			str2 = NAME;
			const char* p = str1.data();
			const char* p2 = str2.data();
			if(strcmp(p,p2)==0)
			{ 
				break; 
			} 
			hpre = h;
			h = h->next;
		}
		
		node *seek,*pre;
		seek = wfp->next;
		pre = wfp;
		while(seek!=NULL)
		{
			if(pre == wfp)
			{
				//printf("//更新未分配表的头部\n");
				if(h->address+h->size<=seek->address) 
				{
					if(h->address+h->size<seek->address)
					{
						hpre->next = h->next;
						h->next = seek;
						pre->next = h;
						h->flag[0] = '\0';
						break;
					}
					else
					{
						hpre->next = h->next;
						seek->address = h->address;
						seek->size = seek->size+h->size; 
						break;
					}
				}
			}
			else if(seek->next == NULL)
			{
				//printf("//更新未分配表的尾部\n");
				if(h->address >= seek->address +seek->size)
				{
					if(h->address > seek->address +seek->size)
					{
						hpre->next = h->next;
						h->next = NULL;
						seek->next = h;
						h->flag[0] = '\0';
						break;
					}
					else
					{
						hpre->next = h->next;
						seek->size = seek->size+h->size; 
						break;
					}
				}
				else
				{
					//printf("//更新未分配表的中部\n");
					if(pre->address+pre->size == h->address&&pre->address+pre->size+h->size<seek->address)
					{
						//printf("//有上邻空闲\n");
						pre->size  = pre->size+h->size;
						hpre->next = h->next;
						break;
					} 
					else if(pre->address+pre->size < h->address&&h->address + h->size == seek->address)
					{
						//printf("//有下邻空闲\n");
						seek->address = h->address;
						seek->size = seek->size+h->size;
						hpre->next = h->next;
						break;
					} 
					else if(pre->address+pre->size == h->address&&h->address + h->size == seek->address)
					{
						//printf("//有上、下邻空闲\n");
						pre->size = pre->size  + h->size +seek->size;
						pre->next = seek->next;
						hpre->next = h->next;
						break;
					} 
					else if(pre->address+pre->size < h->address&&h->address + h->size < seek->address)
					{
						//printf("//没有空闲\n");
						hpre->next = h->next;
						h->next = seek;
						pre->next = h;
						h->flag[0]='\0';
						break;
					} 
				}
			}
			else
			{
				//printf("//更新未分配表的中部\n");
				if(pre->address+pre->size == h->address&&pre->address+pre->size+h->size<seek->address)
				{
					//printf("//有上邻空闲\n");
					pre->size  = pre->size+h->size;
					hpre->next = h->next;
					break;
				} 
				else if(pre->address+pre->size < h->address&&h->address + h->size == seek->address)
				{
					//printf("//有下邻空闲\n");
					seek->address = h->address;
					seek->size = seek->size+h->size;
					hpre->next = h->next;
					break;
				} 
				else if(pre->address+pre->size == h->address&&h->address + h->size == seek->address)
				{
					//printf("//有上、下邻空闲\n");
					pre->size = pre->size  + h->size +seek->size;
					pre->next = seek->next;
					hpre->next = h->next;
					break;
				} 
				else if(pre->address+pre->size < h->address&&h->address + h->size < seek->address)
				{
					//printf("//没有空闲\n");
					hpre->next = h->next;
					h->next = seek;
					pre->next = h;
					h->flag[0]='\0';
					break;
				} 
			}
			pre = seek;
			seek = seek->next;
		}
		
		printf("\n回收成功！");
		print(yfp,wfp);
}
int main()
{
	int option=1;
	printf("请输入内存大小为：");
	scanf("%d",&memory.size);
	printf("\n请输入起始地址大小为：");
	scanf("%d",&memory.address);
	
	node*yfp = (node *)malloc(sizeof(node));
	yfp->next =NULL;
	node*wfp = (node *)malloc(sizeof(node));
	
	node*p = (node *)malloc(sizeof(node));
	p->size = memory.size;
	p->address = memory.address;
	p->flag[0]='\0';
	p->next = NULL;
	wfp->next = p;
	
	while(option)
	{
	printf("\n*****************可变分区管理*****************"); 
	printf("\n        *       1.内存管理       *");
	printf("\n        *       2.内存去配       *");
	printf("\n        *       0.退出           *");
	printf("\n                请输入选项："); 
	scanf("%d",&option);
	if(option == 1)
	{
		govern(yfp,wfp);
	}
	else if(option == 2)
	{
		release(yfp,wfp);
	}
	}
}
//new malloc  没有真正接触内存

运行结果

样例一：

fa3dc1bc4f224aad8ecb76a97509a44b.png

样例二：

9e8cf5116dc44b2ca91a4a1aa3fa4517.png

实验总结

①写程序之前的逻辑思路非常重要

②当遇到难理解的地方时一定要多想

③调用函数创建的单链表要注意是否要return，如果是带头节点的可以不用返回值，如果不是带头节点的要返回单链表

④最大的体会是在调用函数中创建的节点和调用函数中定义的变量二者的生存期不同

 

m0_62806440
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统实验之存储器管理
lwcwam的博客
01-19 1206
操作系统实验之存储器管理
操作系统实验三——动态分区分配方式的模拟
08-29
本设计的目的是使学生熟悉存储器管理系统的设计方法；加深对所学各种存储器管理方案的了解；要求采用一些常用的存储器分配算法，设计一个存储器管理模拟系统并调试运行
动态可变分区存储管理模拟系统
07-03
模拟实现动态可变分区存储管理系统，内存资源的分配情况用一个单链表来表示，每一个节点表示一个可变分区，记录有内存首地址、大小、使用情况等，模拟内存分配动态输入构造空闲区表，键盘接收内存申请尺寸大小，根据申请，实施内存分配，并返回分配所得内存首址。分配完后，调整空闲区表，并显示调整后的空闲区表和已占用的区表。如果分配失败，返回分配失败信息。模拟内存回收。根据空闲区表，从键盘接收回收区域的内存作业代号。回收区域，调整空闲区表，并显示调整后的空闲区表。对于内存区间的分配，移出，合并就是相应的对链表节点信息进行修改，删除和创建相应的节点。 在模拟实现动态可变分区存储管理系统中用到的是“最佳适应算法”与“最坏适应算法”。所谓“最佳”是指每次为作业分配内存时，总是把满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。因此保证每次找到的总是空闲分区中最小适应的，但这样会在储存器中留下许多难以利用的小的空闲区。最坏适应分配算法是要扫描整个空闲分区表或链表，总是挑选最大的一个空闲分区割给作业使用。进入系统时我们需要内存首地址和大小这些初始化数据。成功后我们可以自由的使用首次适应算法与最佳适应算法对内存进行分配。内存经过一系列分配与回收后，系统的内存分配情况不再连续。首次适应算法与最佳适应算法的差异也就很容易的体现在分配时。动态可变分区存储管理模拟系统采用最佳适应算法、最坏适应算法内存调度策略，对于采用不同调度算法，作业被分配到不同的内存区间。
可变分区存储管理模拟（基于C）
02-26
西安电子科技大学出版的《计算机操作系统》经典教材，课设选题，可变分区存储管理的模拟实现，代码结构清晰，界面友好
模拟可变分区管理（大学实验）
Max316121的博客
12-05 174
大学实验报告
操作系统存储管理----可变分区管理
青枫阁
04-26 1621
/* 操作系统存储管理----可变分区管理 通过分区存储管理模拟算法，了解可变分区的内存分配和回收过程，熟悉内存分配之最佳适应算法。 1. 所用模拟内存大小10k ； 2. 定义可用分区表和已用分区表 ； 3. 设计最先内存分配算法，分配从小地址开始； 4. 设计内存回收算法。 最佳分配算法参考程序 */ #include #include #define n 10 /*假定系统允
操作系统实验可变分区存储管理模拟C#源码.zip
最新发布
11-03
可变分区存储管理实验 操作系统实验可变分区存储管理模拟C#源码.zip操作系统实验可变分区存储管理模拟C#源码.zip操作系统实验可变分区存储管理模拟C#源码.zip
操作系统实验五---可变分区的分配与回收
08-04
编程分别用首次适应算法，最佳适应算法，最坏适应算法实现可变分区的分配与回收 二、 设备与环境 codeblocks 三、实验内容 分区空闲表要表示出分区号、始址、大小 作业申请和回收能够动态输入 内存不足，必须有...
基于C++实现的操作系统进程调度可视化与模拟源码+实验报告.zip
08-21
基于C++实现的操作系统进程调度可视化与模拟源码+实验报告.zip 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、...
操作系统实验-可变分区存储管理模拟C#源码.zip
11-03
操作系统实验—可变分区存储管理模拟C#源码.zip操作系统实验—可变分区存储管理模拟C#源码.zip操作系统实验—可变分区存储管理模拟C#源码.zip操作系统实验—可变分区存储管理模拟C#源码.zip操作系统实验—可变分区...
实验一 可变分区存储管理1
08-03
1. 加深对可变分区存储管理的理解 2. 考察使用C语言编写代码的能力，特别是C语言编程的难点之一：指针的使用 3. 复习使用指针实现链表以及在链表上的基本操作
操作系统实验实验四 模拟内存管理程序
06-14
实验四 模拟内存管理程序（4学时） 1、 实验目的 了解简单的固定大小内存分配方法，掌握分区存储管理技术，了解在分区管理机制下所需的数据结构。
操作系统第三次实验-动态分区存储管理(python代码实现)
qq_49383677的博客
01-04 3207
在具体的代码实现中，我采用的是Python语言，因为Python中列表这一数据结构可以较为简便地实现分区的增删改，在处理BF和WF内存分配算法时需要注意在分区空间相同时优先向低地址的分区分配作业，这个要求的实现如果不细想的话可能觉得比较复杂，实际在仔细考虑之后只需将排序算法中小于或大于的比较中加上等号就可实现了，因为本身分区是按地址从小到大依次排序的，那么在加上等号之后就可实现在新的排序中即使分区的大小相同，也是地址较小的靠前。分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。
[C]详解C语言动态内存分配
qq_59456417的博客
10-21 824
详解C语言动态内存管理，解析malloc、free、calloc、realloc函数的使用和注意事项。
操作系统实验三  可变分区存储管理
热门推荐
雪之下
05-19 1万+
实验三 可变分区存储管理 一.实验目的和要求 通过这次实验，加深对内存管理的认识，进一步掌握内存的分配、回收算法的思想。 二.实验目的和要求 阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。 编写程序模拟实现内存的动态分区法存储管理。内存空闲区使用自由链管理，采用最坏适应算法从自由链中寻找空闲区进行分配，内存回收时假定不做与相邻空闲区的合并。 假定系统的内存共640K...
C语言模拟实现（二）-----可变分区存储管理方式
奋斗の博客
11-15 1万+
系统特点 系统采用最优适应分配算法为作业分配主存空间，而且具有合并、移动技术。 概念区别 合并：每次将作业回收后，若回收后的地址空间与空闲去相邻，则将其与相邻的空闲区合并为一块空闲区。 移动：如果每块空闲区的内存都不足以满足要装入的作业所需的内存，但空闲区的总和够用，此时采取移动技术。 实现代码 #include &lt;stdio.h&gt; #include &lt;stdlib...
操作系统实验三：内存管理（动态分区分配方式的模拟）
fufuyfu的博客
06-02 7577
操作系统实验三：内存管理（动态分区分配方式的模拟算法）
（存储管理）02.可变分区存储管理
qq_36301157的博客
08-29 1363
系统根据作业所需内存大小来动态分配内存，这也就是可变分区或动态分区。 因为动态分区数量是不固定的，所以用分区说明表来记录分区信息不太合适。所以，就采用了链表形式来组织并记录分区的信息。如下图： 通过链表的形式，将这些空闲且不连续的分区串联起来。因此，在给作业分配分区时，会遍历这条链表上的空闲分区，找出大小合适的分区。 结合不同的场景，有三种分配合适分区的算法。 1、首次适应算法：遍历链表，挑选最开始满足大小要求的分区。 2、最佳适应算法：根据分区的大小升序排序 + 首次适应 3、最差适应算法：根据分区的大
操作系统 实验四可变式分区分配的存储管理
05-24
可变式分区分配是一种存储管理技术，用于为进程分配内存空间。它的主要特点是分区大小不固定，可以根据进程的需要进行动态调整。在这种技术中，物理内存被划分为多个可变大小的分区，每个分区可以分配给一个进程使用。 下面是实验四的步骤： 1. 设计数据结构：设计数据结构来存储可用分区和已分配分区的信息，包括分区的起始地址、大小和状态等。 2. 初始化分区：将整个物理内存划分为一个或多个可用分区，并将其添加到可用分区列表中。 3. 进程申请内存：当进程需要内存时，它向操作系统发出请求。操作系统会在可用分区列表中查找一个大小足够的分区来满足进程的需要。 4. 分配分区：如果找到了一个合适的分区，操作系统会将该分区标记为已分配，并从可用分区列表中删除该分区，然后将该分区的起始地址返回给进程。 5. 释放分区：当进程不再需要某个分区时，它将释放该分区。操作系统将该分区标记为可用，并将其添加到可用分区列表中。 6. 内存回收：当所有进程都结束时，操作系统将所有已分配的分区标记为可用，以便下一批进程使用。 7. 碎片整理：在分配和释放分区的过程中，可能会出现内存碎片。为了最大化可用内存空间，可以实现碎片整理算法，将多个相邻的可用分区合并成一个更大的分区。 这些步骤可以通过编程实现。在实现过程中，需要注意保证数据结构的完整性和正确性，以及在内存分配和释放过程中避免死锁等问题的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值