精华内容
下载资源
问答
  • 操作系统实验报告-可变分区存储管理方式的内存分配回收
    2020-12-29 05:32:45

    实验三可变分区存储管理方式的内存分配回收

    一.实验目的

    (1)深入了解可变分区存储管理方式的内存分配回收的实现。

    二.实验内容

    编写程序完成可变分区存储管理方式的内存分配回收,要求有内存空间分配表,并采用最优适应算法完成内存的分配与回收。

    三.实验原理

    在可变分区模式下,在系统初启且用户作业尚未装入主存储器之前,整个用户区是一个大空闲分区,随着作业的装入和撤离,主存空间被分成许多分区,有的分区被占用,而有的分区时空闲的。为了方便主存空间的分配和去配,用于管理的数据结构可由两张表组成:“已分配区表”和“未分配区表”。在“未分配表中”将空闲区按长度递增顺序排列,当装入新作业时,从未分配区表中挑选一个能满足用户进程要求的最小分区进行分配。这时从已分配表中找出一个空栏目登记新作业的起始地址和占用长度,同时修改未分配区表中空闲区的长度和起始地址。当作业撤离时已分配区表中的相应状态变为“空”,而将收回的分区登记到未分配区表中,若有相邻空闲区再将其连接后登记。可变分区的回收算法较为复杂,当一个作业撤离时,可分为4种情况:其临近都有作业(A和B),其一边有作业(A或B),其两边均为空闲区。尤其重要的是,在程序中利用“new类型T(初值列表)”申请分配用于存放T类型数据的内存空间,利用“delete指针名”释放指针所指向的内存空间。

    四.实验部分源程序

    #include

    using namespace std;

    typedef struct SNode { // Space Node

    int start,end; // 起始,结束

    int length; // 长度大小

    struct SNode *next; // 指向下一结点的指针

    }* SP;

    SP Head=(SP)malloc(sizeof(SNode)); // 全局变量,内存空间头结

    void DispSpace() { // 显示内存空间分配情况

    SP p=Head->next;

    cout<

    <

    while (p)

    {

    cout

    next;

    }

    cout<

    }

    void Initial() { // 初始化说明表

    更多相关内容
  • 一实验目的 通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解熟悉可变分区存 储管理的内存分配和回收 二实验内容 确定内存空间分配表 采用最优适应算法完成内存空间的分配和回收 编写主函数对所做工作...
  • NULL 博文链接:https://touch-2011.iteye.com/blog/1068974
  • 可变分区存储管理

    2013-12-23 21:12:44
    可变分区存储管理 源代码,C,推荐给初学者参考使用
  • NULL 博文链接:https://touch-2011.iteye.com/blog/1068968
  • 内容索引:VB源码,系统相关,分区存储 来自浙江大学的一个计算机操作系统可变分区存储管理模拟实验,基于VB程序编写,附有源代码和实验报告。通过这个实验帮助学习者理解操作系统中可变分区管理的算法,掌握分配和...
  • 可变分区存储管理模拟
  • 可变分区存储管理: 通过文件操作读取空闲区表(包含空闲区的起始地址和长度),通过用户选择分配/回收内存,回收的内存如果和空闲区表的内存块相邻,则进行合并 注:解决方案中带有data.txt文件,并在代码中指定...
  • C++编写的可变分区存储管理实验报告,包括首次适应算法,最佳适应算法和最差适应算法。我也是学生,所以希望这份报告对大家有用哦~
  • 精品文档 实验三 可变分区存储管理方式的内存分配回收 一实验目的 1深入了解可变分区存储管理方式的内存分配回收的实现 二实验内容 编写程序完成可变分区存储管理方式的内存分配回收 要求有内存空间分配表 并采用 ...
  • 操作系统可变分区存储管理方式的内存分配和回收,可变分区调度算法有:最先适应分配算法,最优适应分配算法,最坏适应算法 用户提出内存空间的申请;系统根据申请者的要求,按照一定的分配策略分析内存空间的使用情况,...
  • 使用双向链表的数据结构,用C语言成功实现了可变分区存储管理中的循环首次适应法,实现了对内存区的分配和释放管理。并且考虑了很多分配和释放内存区时的错误,如分配时内存不足,释放越界,重复释放等问题,并给出...
  • 动态可变分区存储管理模拟系统

    热门讨论 2011-07-03 15:54:39
    模拟实现动态可变分区存储管理系统,内存资源的分配情况用一个单链表来表示,每一个节点表示一个可变分区,记录有内存首地址、大小、使用情况等,模拟内存分配动态输入构造空闲区表,键盘接收内存申请尺寸大小,根据...
  • 其中最复杂的是可变分区存储管理,内存管理效果最好,但是实际应用最多的是段页式存储管理。段页式存储管理实现考虑情况较少,实现起来相对简单,但是效率也很高。但是如果明白了可变分区存储管理,应该其他内存管理...

    在学习操作系统时,讲到CPU对内存的寻址,会涉及到内存的管理方式,内存管理方式有如下四种:
    1.单连续分区存储管理
    2.页式存储管理
    3.段式存储管理
    4.段页式存储管理

    其中,单连续分区存储管理可以分为1.固定分区存储管理2.可变分区存储管理
    其中最复杂的是可变分区存储管理,内存管理效果最好,但是实际应用最多的是段页式存储管理。段页式存储管理实现考虑情况较少,实现起来相对简单,但是效率也很高。但是如果明白了可变分区存储管理,应该其他内存管理方式也明白了。

    单连续分区存储管理

    思想

    维护两个数据结构
    1.用于存放空闲分区的双向链表
    2.是用于存放内存中作业信息的线性表
    将内存看成是一个大的块,当有作业申请内存时,就找第一个足够大小的空闲分区,将作业放入该分区,同时更新线性表和链表。如果没有足够大小的空间,就启动主存紧凑(将所有的主存外零头汇聚到高地址处),得到一个大的空闲分区块,然后判断是否满足分配条件。
    在这里插入图片描述

    算法实现

    分配内存

    在这里插入图片描述

    只考虑三种情况
    |1.作业C不能放入空闲分区。
    |2.作业C可以放入空闲分区
    ___|2.1剩下的内存大小不足以形成内存碎片,直接分配给该作业。
    ___|2.2.作业C可以放入空闲分区,剩下的内存大小也足以形成内存碎片

    void addTable(int name, int size,int addr) {
    	//往任务分配表中添加新任务
    	for (int i = 0; i < 100; i++) {
    		if (tab[i].flag == false) {
    			tab[i].name = name;
    			tab[i].addr = addr;
    			tab[i].length = size;
    			tab[i].flag = true;								//该内存块被占用
    			return;
    		}
    	}
    }
    
    void alterTable() {
    	//修改任务分配表
    	std::sort(tab, tab + 100, cmp);									//将任务分配表按从大到小的顺序排序
    	tab[0].addr = 0;
    	for (int i = 1; i < 100; i++) {
    		if (!tab[i].flag) break;
    		tab[i].addr = tab[i - 1].addr + tab[i - 1].length;		//更改任务起始地址
    	}
    }
    
    void compactMem(pFreePartition p) {
    	//递归将p空闲分区合并到p.next中
    	if (p == NULL) {
    		return;
    	}
    	if (p->next == NULL) {
    		head = p;
    		p->back = NULL;
    		return;
    	}
    	p->next->size += p->size;										//更改空闲分区的大小
    	p->next->address -= p->size;									//更改空闲分区的地址
    	compactMem(p->next);
    	free(p);
    }
    
    void ffcolection() {
    	//模拟分配内存模块
    	int size;
    	int name;
    	bool flag = false;												//用于标识分配了一个完整的分区
    	printf("\n----------模拟分配作业内存模块----------\n\n");
    	printf("\n请输入需要分配的作业名:\n");
    	scanf("%d", &name);
    	printf("\n请输入需要分配的内存大小(单位 B):\n");
    	scanf("%d", &size);
    
    	pFreePartition p = head;										//设置指针遍历空闲分区链表
    
    	while (p != NULL) {
    		if (p->size > size) {
    			//当前内存区满足分配条件
    			if (p->size - size > MIN) {
    				//分配内存以后的空间满足内存碎片
    				addTable(name, size, p->address);					//修改作业分配表
    				p->size = p->size - size;							//修改空闲区链表
    				p->address += size;
    			}
    			else {
    				//分配内存以后的空间不满足内存碎片的条件,直接分配给原进程
    				addTable(name, p->size, p->address);
    				flag = true;
    				if (p == head) {
    					//头结点为分区
    					head = p->next;									//空闲区链表为空
    					free(p);
    					p = NULL;
    				}
    				else {
    					//非头结点为分区
    					p->back->next = p->next;
    					free(p);
    					p = NULL;
    				}
    			}
    			break;
    		}
    		//当前内存区不满足内存分配条件
    		p = p->next;
    	}
    
    	if (p == NULL && flag == false) {
    		//p==NULL有可能分配了一个完整的分区,有可能没有找到一个分区,flag==fasle标识没有找到一个完整的分区
    		//尝试主存紧凑
    		//printf("test1:%d\n", head->address);
    		compactMem(head);
    		//printf("test2:%d\n", head->address);
    		//更改任务分配表
    		alterTable();
    		if (head==NULL||head->size < size) {
    			printf("无法为任务提供足够内存!!\n");
    		}
    		else {
    			addTable(name, size, head->address);
    			head->size -= size;
    			head->address += size;
    			if (head->size == 0) {
    				free(head);
    				head = NULL;
    			}
    		}
    	}
    }
    

    释放内存

    四种情况:
    情况一:
    在这里插入图片描述情况2:
    在这里插入图片描述
    情况3:
    在这里插入图片描述情况4:
    在这里插入图片描述
    实际上四种情况可以当成两种情况处理,先将空闲内存块插入,最后再进行空闲块整合。

    void recolection() {
    	//模拟释放内存模块
    	int name;														//记录删除的进程名
    	int address = -1;													//记录删除的进程地址
    	int length;														//记录删除的进程长度
    	printf("\n----------模拟释放内存模块----------\n\n");
    	printf("\n请输入要释放的作业名:\n\n");
    	scanf("%d", &name);
    
    	for (int i = 0; i < 100; i++) {									//任务分配表中删除任务name
    		if (name == tab[i].name) {
    			address = tab[i].addr;
    			length = tab[i].length;
    			tab[i].flag = false;
    			tab[i].addr = INF;
    		}
    	}
    	if (address == -1) {
    		printf("任务名不存在!!\n");
    		return;
    	}
    
    	pFreePartition p = head;
    	pFreePartition pre = head;
    
    	while (p != NULL) {
    		if (p->address > address) {
    			//p空闲分区在address之后
    			break;
    		}
    		pre = p;
    		p = p->next;
    	}
    
    	if (p == NULL) {
    		//释放的任务后无空闲区
    		p = (pFreePartition)malloc(sizeof(freePartition));
    		p->address = address;
    		p->next = NULL;
    		p->back = pre;
    		p->size = length;
    		if (p->back != NULL) {
    			//p不是头结点
    			p->back->next = p;
    		}
    		else {
    			//p是头结点
    			head = p;
    		}
    	}
    	else {
    		//释放的任务后有空闲区
    		pFreePartition temp = (pFreePartition)malloc(sizeof(freePartition));
    		//检测一下p->back是否是空
    		temp->next = p;
    		temp->back = p->back;
    		p->back = temp;
    		if (temp->back != NULL) {
    			//p不是头结点
    			temp->back->next = temp;
    		}
    		else {
    			//p是头结点
    			head = temp;
    		}
    		
    		temp->address = address;
    		temp->size = length;
    	}
    
    /*任务内存恢复测试
    	p = head;
    	while (p != NULL) {
    		printf("test:   address:%d   size:%d\n", p->address, p->size);
    		p = p->next;
    	}
    */
    	p = head->next;
    	while (p!=NULL&&p->back!=NULL) {
    		//将多个连续的分区合并为一个分区
    		if (p->back->address + p->back->size == p->address) {
    			//printf("p->address:%d p->size:%d p->next->addreee:%d\n", p->address, p->size, p->next->address);
    			pFreePartition temp = p->back;
    			p->size += p->back->size;
    			p->address = p->back->address;
    			head = p;
    			free(temp);
    		}
    		p = p->next;
    	}
    	printf("内存释放完成\n");
    }
    

    查看内存使用情况和作业管理表使用情况

    void seeSimulateMemory() {
    	//查看当前模拟内存使用情况
    	printf("\n空闲分区使用情况:\n\n");
    	pFreePartition p = head;
    	while (p != NULL) {
    		printf("address:%d   size:%d\n", p->address,p->size);
    		p = p->next;
    	}
    	printf("\n-----------任务分配情况----------\n\n");
    	for (int i = 0; i < 100; i++) {
    		if (tab[i].flag==true) {
    			printf("name:%d   address:%d   length:%d\n", tab[i].name, tab[i].addr, tab[i].length);
    		}
    	}
    	printf("空闲分区查看完成");
    }
    

    完整代码

    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    #include<algorithm>
    
    #define debug(x) printf("debug:%s",x);
    #define freep NULL;
    
    const int INF = 0x3f3f3f3f;
    const int MIN = 5;						//定义碎片最小容量
    
    typedef unsigned int Uint;
    
    //空闲区链表
    typedef struct node {
    	Uint size;							//空区大小(以字节计),包括区头所占空间
    	struct node* next;					//后一分区地址
    	struct node* back;					//前一分区地址
    	Uint address;						//本分区首地址
    }freePartition,*pFreePartition;
    
    //作业分配表
    typedef struct table {
    	int name;							//用户作业名
    	Uint length;						//作业区大小
    	int addr;							//作业区首地址
    	bool flag;							//标记内存的状态,flag=true为占用
    }memTable;
    
    pFreePartition head;					//空闲区表头
    memTable tab[100];						//作业分配表,最多支持100个作业
    
    void init() {
    	//初始化空闲分区表
    	int size;
    	head = (pFreePartition)malloc(sizeof(freePartition));
    	printf("请输入总分区大小:");
    	scanf("%d", &size);
    
    	assert(size > 5);											//判断总分区的合理性
    
    	head->next = freep;											
    	head->address = 0;
    	head->back = freep;
    	head->size = size;
    
    	for (int i = 0; i < 100; i++) {
    		tab[i].addr = INF;
    		tab[i].flag = false;
    	}
    	return ;
    }
    
    void addTable(int name, int size,int addr) {
    	//往任务分配表中添加新任务
    	for (int i = 0; i < 100; i++) {
    		if (tab[i].flag == false) {
    			tab[i].name = name;
    			tab[i].addr = addr;
    			tab[i].length = size;
    			tab[i].flag = true;								//该内存块被占用
    			return;
    		}
    	}
    }
    
    bool cmp(memTable a, memTable b) {
    	return a.addr < b.addr;
    }
    
    void alterTable() {
    	//修改任务分配表
    	std::sort(tab, tab + 100, cmp);									//将任务分配表按从大到小的顺序排序
    	tab[0].addr = 0;
    	for (int i = 1; i < 100; i++) {
    		if (!tab[i].flag) break;
    		tab[i].addr = tab[i - 1].addr + tab[i - 1].length;		//更改任务起始地址
    	}
    }
    
    void compactMem(pFreePartition p) {
    	//递归将p空闲分区合并到p.next中
    	if (p == NULL) {
    		return;
    	}
    	if (p->next == NULL) {
    		head = p;
    		p->back = NULL;
    		return;
    	}
    	p->next->size += p->size;										//更改空闲分区的大小
    	p->next->address -= p->size;									//更改空闲分区的地址
    	compactMem(p->next);
    	free(p);
    }
    
    void ffcolection() {
    	//模拟分配内存模块
    	int size;
    	int name;
    	bool flag = false;												//用于标识分配了一个完整的分区
    	printf("\n----------模拟分配作业内存模块----------\n\n");
    	printf("\n请输入需要分配的作业名:\n");
    	scanf("%d", &name);
    	printf("\n请输入需要分配的内存大小(单位 B):\n");
    	scanf("%d", &size);
    
    	pFreePartition p = head;										//设置指针遍历空闲分区链表
    
    	while (p != NULL) {
    		if (p->size > size) {
    			//当前内存区满足分配条件
    			if (p->size - size > MIN) {
    				//分配内存以后的空间满足内存碎片
    				addTable(name, size, p->address);					//修改作业分配表
    				p->size = p->size - size;							//修改空闲区链表
    				p->address += size;
    			}
    			else {
    				//分配内存以后的空间不满足内存碎片的条件,直接分配给原进程
    				addTable(name, p->size, p->address);
    				flag = true;
    				if (p == head) {
    					//头结点为分区
    					head = p->next;									//空闲区链表为空
    					free(p);
    					p = NULL;
    				}
    				else {
    					//非头结点为分区
    					p->back->next = p->next;
    					free(p);
    					p = NULL;
    				}
    			}
    			break;
    		}
    		//当前内存区不满足内存分配条件
    		p = p->next;
    	}
    
    	if (p == NULL && flag == false) {
    		//p==NULL有可能分配了一个完整的分区,有可能没有找到一个分区,flag==fasle标识没有找到一个完整的分区
    		//尝试主存紧凑
    		//printf("test1:%d\n", head->address);
    		compactMem(head);
    		//printf("test2:%d\n", head->address);
    		//更改任务分配表
    		alterTable();
    		if (head==NULL||head->size < size) {
    			printf("无法为任务提供足够内存!!\n");
    		}
    		else {
    			addTable(name, size, head->address);
    			head->size -= size;
    			head->address += size;
    			if (head->size == 0) {
    				free(head);
    				head = NULL;
    			}
    		}
    	}
    }
    
    void recolection() {
    	//模拟释放内存模块
    	int name;														//记录删除的进程名
    	int address = -1;													//记录删除的进程地址
    	int length;														//记录删除的进程长度
    	printf("\n----------模拟释放内存模块----------\n\n");
    	printf("\n请输入要释放的作业名:\n\n");
    	scanf("%d", &name);
    
    	for (int i = 0; i < 100; i++) {									//任务分配表中删除任务name
    		if (name == tab[i].name) {
    			address = tab[i].addr;
    			length = tab[i].length;
    			tab[i].flag = false;
    			tab[i].addr = INF;
    		}
    	}
    	if (address == -1) {
    		printf("任务名不存在!!\n");
    		return;
    	}
    
    	pFreePartition p = head;
    	pFreePartition pre = head;
    
    	while (p != NULL) {
    		if (p->address > address) {
    			//p空闲分区在address之后
    			break;
    		}
    		pre = p;
    		p = p->next;
    	}
    
    	if (p == NULL) {
    		//释放的任务后无空闲区
    		p = (pFreePartition)malloc(sizeof(freePartition));
    		p->address = address;
    		p->next = NULL;
    		p->back = pre;
    		p->size = length;
    		if (p->back != NULL) {
    			//p不是头结点
    			p->back->next = p;
    		}
    		else {
    			//p是头结点
    			head = p;
    		}
    	}
    	else {
    		//释放的任务后有空闲区
    		pFreePartition temp = (pFreePartition)malloc(sizeof(freePartition));
    		//检测一下p->back是否是空
    		temp->next = p;
    		temp->back = p->back;
    		p->back = temp;
    		if (temp->back != NULL) {
    			//p不是头结点
    			temp->back->next = temp;
    		}
    		else {
    			//p是头结点
    			head = temp;
    		}
    		
    		temp->address = address;
    		temp->size = length;
    	}
    
    /*任务内存恢复测试
    	p = head;
    	while (p != NULL) {
    		printf("test:   address:%d   size:%d\n", p->address, p->size);
    		p = p->next;
    	}
    */
    	p = head->next;
    	while (p!=NULL&&p->back!=NULL) {
    		//将多个连续的分区合并为一个分区
    		if (p->back->address + p->back->size == p->address) {
    			//printf("p->address:%d p->size:%d p->next->addreee:%d\n", p->address, p->size, p->next->address);
    			pFreePartition temp = p->back;
    			p->size += p->back->size;
    			p->address = p->back->address;
    			head = p;
    			free(temp);
    		}
    		p = p->next;
    	}
    	printf("内存释放完成\n");
    }
    
    void recolectionALL() {
    	//释放链表的的所有进程
    	int size = 0;
    	printf("\n释放链表的的所有内存\n\n");
    	pFreePartition p = head;
    	while (p != NULL) {
    		//收集空闲分区内存
    		pFreePartition temp = p;
    		p = p->next;
    		size += p->size;
    		free(temp);
    	}
    	for (int i = 0; i < 100; i++) {
    		//收集所有任务表的内存
    		if (tab[i].flag) {
    			size += tab[i].length;
    		}
    	}
    
    	p = (pFreePartition)malloc(sizeof(freePartition));
    	p->back = NULL;
    	p->next = NULL;
    	p->address = 0;
    	p->size = size;
    	printf("内存释放完成");
    }
    
    void seeSimulateMemory() {
    	//查看当前模拟内存使用情况
    	printf("\n空闲分区使用情况:\n\n");
    	pFreePartition p = head;
    	while (p != NULL) {
    		printf("address:%d   size:%d\n", p->address,p->size);
    		p = p->next;
    	}
    	printf("\n-----------任务分配情况----------\n\n");
    	for (int i = 0; i < 100; i++) {
    		if (tab[i].flag==true) {
    			printf("name:%d   address:%d   length:%d\n", tab[i].name, tab[i].addr, tab[i].length);
    		}
    	}
    	printf("空闲分区查看完成");
    }
    
    void menu() {
    	int key;																//接受命令信息
    	init();
    	while (1) {
    		printf("------------------模拟命令菜单------------------\n\n");
    		printf("---------------模拟分配内存  键入1--------------\n\n");
    		printf("---------------模拟释放内存  键入2--------------\n\n");
    		printf("-------------模拟释放所有内存  键入3--------------\n\n");
    		printf("----------------退出系统   键入0----------------\n\n");
    
    		printf("目前内存使用情况如下:\n");
    		seeSimulateMemory();
    
    		printf("请输入命令:");
    		scanf("%d", &key);
    		switch (key) {
    		case 1:
    			ffcolection();
    			break;
    		case 2:
    			recolection();
    			break;
    		case 3:
    			recolectionALL();
    			break;
    		case 0:
    			recolectionALL();
    			exit(0);
    		default:
    			printf("\n命令不存在,请重新输入\n\n");
    		}
    	}
    }
    
    
    展开全文
  • 可变分区存储管理方式的内存分配回收,使用最有算法
  • 实验四 存储管理-可变分区存储管理的空间分配与去配 一、实验目的 要求掌握存储管理中的典型算法,理解各种存储管理的工作原理,特别是可变分区存储管理中最先适应分配算法、最优适应分配算法、最坏适应分配算法以及...

    实验四 存储管理-可变分区存储管理的空间分配与去配

    一、实验目的
    要求掌握存储管理中的典型算法,理解各种存储管理的工作原理,特别是可变分区存储管理中最先适应分配算法、最优适应分配算法、最坏适应分配算法以及空间回收算法的工作原理,试采用C语言编程,模拟实现算法功能。

    二、实验要求
    设计一个可变式分区分配的存储管理方案,并模拟实现分区的分配和回收过程。
    假定主存空间为静态分配。为实现分区的分配和回收,需要已分配分区表和系统空闲分区表描述当前系统状态。已分配分区表包括分区编号、已分配分区长度、分区的起始地址等信息。系统空闲分区表包括分区编号、分区长度、分区的起始地址等信息。用户根据需要提出对主存空间大小的申请,系统按照一定的分配策略,找出能满足请求的空闲区进行分配。如果满足要求,输出分配完成后已分配分区表和空闲区表的信息,否则输出“无空闲区分配”。
    用户根据需要释放主存空间,实现空间的回收,并输出空间回收后已分配分区表和空闲区表的信息。

    反正代码是写吐了
    如果要加很多功能的话还可以加
    开源图一乐

    /* 
        时间:4月27日~4月28日
       	仅供参考,还请不要复制粘贴
     */
    
    #include <iostream>
    #include <string>
    #include <queue>
    using namespace std;
    // 分配表最多容纳100个
    #define MAX 100
    
    // 创建进程信息
    struct process
    {
        int seq;
        // 分区表的单行序号
        int length;
        // 分区表的单行长度
        int begin_address;
        // 分区表的起始地址
        int number;
        // 最后哪个进程被分配的进程编号
    };
    
    // 创建可变分区表的结构体,表长和进程信息
    struct system_list
    {
    
        process informationArray[MAX];
        int size;
    };
    
    // 菜单展示
    void display()
    {
        cout << "__________________________________" << endl;
        cout << "__________1.设计空闲区信息__________" << endl;
        cout << "__________2.显示空闲区信息______________" << endl;
        cout << "__________3.添加作业队列信息______________" << endl;
        cout << "__________4.显示作业队列信息______________" << endl;
        cout << "__________5.最先分配适应算法________________" << endl;
        cout << "__________6.最优分配适应算法______________" << endl;
        cout << "__________7.最坏分配适应算法_______________" << endl;
        cout << "__________8.主存回收_______________" << endl;
        cout << "__________0.退出系统______________" << endl;
        cout << "__________________________________" << endl;
    }
    
    void addInfo(system_list *l)
    {
        cout << "下面开始建立空闲分区表" << endl;
    
        int seq;
        cout << "输入空闲分区的分区编号" << endl;
        cin >> seq;
        l->informationArray[l->size].seq = seq;
    
        int length;
        cout << "输入空闲分区的可分配区域长度" << endl;
        cin >> length;
        l->informationArray[l->size].length = length;
    
        int begin_address;
        cout << "输入空闲分区的起始地址(十进制)" << endl;
        cin >> begin_address;
        l->informationArray[l->size].begin_address = begin_address;
    
        l->informationArray[l->size].number = -1;
    
        l->size++;
    }
    void displayInformation(system_list *l)
    {
        if (l->size == 0)
        {
            cout << "当前空闲区不空闲" << endl;
            return;
        }
        else
        {
            for (int i = 0; i < l->size; i++)
            {
                cout << "----------------------------------------------------------------------------------" << endl;
                cout << "空闲区序号: " << l->informationArray[i].seq << "\t";
                cout << "空闲区长度: " << l->informationArray[i].length << "\t";
                cout << "空闲区起始地址: " << l->informationArray[i].begin_address << "\t";
                cout << "分配的进程编号: " << l->informationArray[i].number << endl;
                cout << "----------------------------------------------------------------------------------" << endl;
            }
        }
    }
    
    // 创建作业队列,运用queue标准库
    void pushlist(queue<int> *list)
    {
        cout << "请输入你要设计的作业队列需要的内存:" << endl;
        int num;
        cin >> num;
        list->push(num);
    }
    void displaylist(queue<int> *list)
    {
        cout << "----------------队列内容:------------------" << endl;
        int n = 0;
        int pop;
        while (n < list->size())
        {
            cout << "序号为:" << n << "  需求内存为: " << list->front() << endl;
            list->push(list->front());
            list->pop();
            // 没有遍历器,就在出队的同时入队
            n++;
        }
    }
    
    // 冒泡排序:让地址从低到高排序
    void bubble_address(system_list *l)
    {
        process temp;
        for (int i = 0; i < l->size - 1; i++)
        {
            for (int j = 0; j < l->size - i - 1; j++)
            {
                if (l->informationArray[j].begin_address > l->informationArray[j + 1].begin_address)
                {
                    temp = l->informationArray[j];
                    l->informationArray[j] = l->informationArray[j + 1];
                    l->informationArray[j + 1] = temp;
                }
            }
        }
    }
    // 最先适应分配算法
    void frist_fit_allocated(system_list *l, queue<int> *list)
    {
        // 先将地址进行冒泡排序
        bubble_address(l);
        cout << "++++++++++++++++++++++++++++++分配前的空闲区信息++++++++++++++++++++++++" << endl;
        displayInformation(l);
        int n = 0;
    
        while (n < list->size())
        {
            for (int i = 0; i < l->size; i++)
            {
                if (list->front() <= l->informationArray[i].length && l->informationArray[i].number == -1)
                {
                    l->informationArray[i].length = l->informationArray[i].length - list->front();
                    // 将所剩余的空间显示出来。
                    l->informationArray[i].number = n;
                    // 并且将进程编号放入
                    list->pop();
                    // 删除队首
                    break;
                }
            }
            n++;
        }
        cout << "++++++++++++++++++++++分配后的进程信息++++++++++++++++++===+++" << endl;
        displayInformation(l);
        if ((list->size()) != 0)
        {
            cout << "仍然有作业没有分配到空间,请开始主存回收功能重试" << endl;
            displaylist(list);
        }
    }
    
    // 选择排序,将空闲区容量从低到高排序
    void select_length(system_list *l)
    {
        for (int i = 0; i < l->size; i++)
        {
            for (int j = i + 1; j < l->size; j++)
            {
                if (l->informationArray[i].length > l->informationArray[j].length)
                {
                    swap(l->informationArray[i], l->informationArray[j]);
                }
            }
        }
    }
    // 最优适应分配算法
    void frist_best_allocated(system_list *l, queue<int> *list)
    {
        // address sort the select
        select_length(l);
        cout << "++++++++++++++++++++++++++++++分配前的空闲区信息++++++++++++++++++++++++" << endl;
        displayInformation(l);
        int n = 0;
    
        while (n < list->size())
        {
            for (int i = 0; i < l->size; i++)
            {
                if (list->front() <= l->informationArray[i].length && l->informationArray[i].number == -1)
                {
                    l->informationArray[i].length = l->informationArray[i].length - list->front();
                    // 将所剩余的空间显示出来。
                    l->informationArray[i].number = n;
                    // 并且将进程编号放入
                    list->pop();
                    // 删除队首
                    break;
                }
            }
            n++;
        }
        cout << "++++++++++++++++++++++分配后的进程信息++++++++++++++++++===+++" << endl;
        displayInformation(l);
        if ((list->size()) != 0)
        {
            cout << "仍然有作业没有分配到空间,请开始主存回收功能重试" << endl;
            displaylist(list);
        }
    }
    
    // 冒泡排序,让空闲区容量从高到低
    void fast_length(system_list *l)
    {
        for (int i = 0; i < l->size - 1; i++)
        {
            for (int j = 0; j < l->size - 1 - i; j++)
            {
                if (l->informationArray[j].length < l->informationArray[j + 1].length)
                {
                    swap(l->informationArray[j], l->informationArray[j + 1]);
                }
            }
        }
    }
    void frist_terrible_allocated(system_list *l, queue<int> *list)
    {
        fast_length(l);
        cout << "++++++++++++++++++++++++++++++分配前的空闲区信息++++++++++++++++++++++++" << endl;
        displayInformation(l);
        int n = 0;
    
        while (n < list->size())
        {
            for (int i = 0; i < l->size; i++)
            {
                if (list->front() <= l->informationArray[i].length && l->informationArray[i].number == -1)
                {
                    l->informationArray[i].length = l->informationArray[i].length - list->front();
                    // 将所剩余的空间显示出来。
                    l->informationArray[i].number = n;
                    // 并且将进程编号放入
                    list->pop();
                    // 删除队首
                    break;
                }
            }
            n++;
        }
        cout << "++++++++++++++++++++++分配后的进程信息++++++++++++++++++===+++" << endl;
        displayInformation(l);
        if ((list->size()) != 0)
        {
            cout << "仍然有作业没有分配到空间,请开始主存回收功能重试" << endl;
            displaylist(list);
        }
    }
    
    // 重点来了:主存回收-----------------------------------------------------------
    void retrieve(system_list *l)
    {
        bubble_address(l);
        cout << "地址排序结果" << endl;
        displayInformation(l);
        l->informationArray[l->size].begin_address = -100;
        l->informationArray[l->size + 1].begin_address = -100;
        l->informationArray[l->size + 2].begin_address = -100;
        int i = 1;
        while (l->informationArray[i].begin_address != -100)
        {
            // 上面有空间,下面有空间
            if (l->informationArray[i].begin_address - 1 == l->informationArray[i - 1].begin_address && l->informationArray[i].begin_address + 1 == l->informationArray[i + 1].begin_address && l->informationArray[i].length > 0 && l->informationArray[i + 1].length > 0 && l->informationArray[i - 1].length > 0)
            {
                l->informationArray[i - 1].length += l->informationArray[i].length + l->informationArray[i + 1].length;
                while (2)
                {
                    for (int j = i; j < l->size; j++)
                    {
                        l->informationArray[j] = l->informationArray[j + 1];
                    }
                    l->size--;
                }
            }
    
            // 上面有空间
            else if (l->informationArray[i].begin_address - 1 == l->informationArray[i - 1].begin_address && l->informationArray[i].length > 0 && l->informationArray[i - 1].length > 0)
            {
                l->informationArray[i - 1].length += l->informationArray[i].length;
                for (int j = i; j < l->size; j++)
                {
                    l->informationArray[j] = l->informationArray[j+1];
                }
                l->size--;
            }
            // 下面有空间
            else if (l->informationArray[i].begin_address + 1 == l->informationArray[i + 1].begin_address && l->informationArray[i].length > 0 && l->informationArray[i + 1].length > 0)
            {
                l->informationArray[i - 1].length += l->informationArray[i].length;
                for (int j = i + 1; j < l->size; j++)
                {
                    l->informationArray[j] = l->informationArray[j + 1];
                }
                l->size--;
            }
            i++;
        }
        cout<<"+++++++++++++++++++++++++回收结果++++++++++++++++++++++++++++++++++"<<endl;
        displayInformation(l);
        cout << "没有可以回收的空间啦" << endl;
    }
    
    int main()
    {
        int select = 0;
        system_list l;
        queue<int> list;
        l.size = 0;
        cout << "请输入你的选择" << endl;
        while (true)
        {
    
            display();
            cin >> select;
            switch (select)
            {
                // 1~2输入空闲区信息
            case 1:
            {
                cout << "请按照提示输入信息" << endl;
                int num;
                cout << "请输入你要设定空闲区的个数" << endl;
                cin >> num;
                while (num)
                {
                    addInfo(&l);
                    num--;
                }
                cout << "添加完毕,请开始你的表演吧!" << endl;
            }
            break;
    
            case 2:
            {
                displayInformation(&l);
            }
            break;
    
            // 3~4输入作业队列信息
            case 3:
            {
                cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~开始作业队列的输入~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
                cout << "请按照提示输入信息" << endl;
                int num1;
                cout << "请输入你要设定进入空闲区进程的的个数" << endl;
                cin >> num1;
                while (num1)
                {
                    pushlist(&list);
                    num1--;
                }
                cout << "添加完毕" << endl;
            }
            break;
            case 4:
            {
                displaylist(&list);
            }
            break;
            // 最先适应分配算法。
            case 5:
                frist_fit_allocated(&l, &list);
                break;
            // 最优适应分配算法
            case 6:
                frist_best_allocated(&l, &list);
                break;
            // 最坏适应分配算法
            case 7:
                frist_terrible_allocated(&l, &list);
                break;
            case 8:
                retrieve(&l);
                break;
    
            case 0:
                cout << "不欢迎下次的使用" << endl;
                return 0;
            default:
                break;
            }
        }
    }
    
    
    展开全文
  • 带有流程图及注释源代码编写程序完成可变分区存储管理方式的内存分配回收。 具体包括:确定内存空间分配表; 采用最优适应算法完成内存空间的分配和回收; 编写主函数对所做工作进行测试。
  • 西安电子科技大学出版的《计算机操作系统》经典教材,课设选题,可变分区存储管理的模拟实现,代码结构清晰,界面友好
  • 2013 --2014 学年 第 3 学期 实验项目 名称 分区存储管理算法模拟 实验 日期 2014/12/2 5 实验 成绩 实验类型 验证型 实 验 目 的 与 要 求 一个好的计算机系统不仅要有一个足够容量的存取速度高的 稳定可靠的主...
  • 实验四可变分区存储管理 学时4学时 实验内容 主存储器空间分配实验 实验目的 通过首次适应算法最佳适应算法和最坏适应算法实现主存空间的分配可以使读者可好地理解存储分配算法 实验题目 编写一段程序来模拟可变分区...
  • 操作系统实验一 可变分区存储管理 编写一个C程序,用char *malloc(unsigned size)函数向系统申请一次内存空间(如size=1000,单位为字节),用首次适应法 addr = (char *)fmalloc(unsigned size) 和 ffree...
  • 课程设计 2 可变分区存储管理方式的内存分配回收 一课程设计目的 深入了解采用可变分区存储管理方式的内存分配回收的实现 二预备知识 存储管理中可变分区的管理方式 三小组成员 四课程设计内容 编写程序完成可变分区...
  • 操作系统实验可变分区存储管理.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,248
精华内容 40,099
关键字:

可变分区存储管理