实验三 动态分区存储管理方式的主

合集下载

动态分区存储管理方式的主存分配回收总结

动态分区存储管理方式的主存分配回收总结

动态分区存储管理方式的主存分配回收总结动态分区存储管理是一种常见的主存分配回收技术,它通过动态创建并分配大小不等的存储块来管理主存空间,以满足不同进程的需求。

这种管理方式在操作系统中起着至关重要的作用,因此本文将对动态分区存储管理的主存分配回收进行总结,从原理、特点、优缺点及其在实际应用中的情况进行阐述。

一、原理动态分区存储管理是基于分区的主存管理机制,它将主存空间划分为多个不等大小的分区,每个分区可以被分配给一个进程使用。

当系统收到一个新进程的请求时,它会根据需要的主存大小为进程分配一个合适大小的分区。

当进程执行完毕,系统会回收该进程所占用的分区,使得该空间可以再次被分配给其他进程使用。

在动态分区存储管理中,主要有两种分配方式:首次适应算法和最佳适应算法。

首次适应算法是从第一个满足大小要求的分区开始进行分配;而最佳适应算法是从所有满足大小要求的分区中选择最小的分区进行分配。

这两种分配方式都有自己的优点和局限性,但它们都是基于动态分区存储管理的基本原理。

二、特点1.灵活性动态分区存储管理可以根据进程的需求动态地分配和回收主存空间,提高了主存的利用率和效率。

进程可以根据需要申请和释放主存空间,而无需预先分配固定大小的空间。

2.节省空间动态分区存储管理可以尽可能地利用主存中的碎片空间,减少了外部碎片的浪费。

这种管理方式能够充分利用主存空间,提高了主存的利用率。

3.多样性动态分区存储管理可以适应不同大小的进程需求,能够根据进程的大小灵活地进行分区分配,满足了不同进程的需求。

三、优缺点1.优点(1)提高了主存的利用率和效率。

(2)灵活地分配和回收主存空间,满足不同进程的需求。

(3)节省了主存空间,减少了碎片的浪费。

2.缺点(1)会产生外部碎片,影响了分区空间的利用率。

(2)分配和回收过程中可能产生较大的开销,影响了系统的性能。

四、在实际应用中的情况动态分区存储管理在操作系统中得到了广泛的应用,特别是在多道程序设计和实时系统中。

分区存储管理模拟实验报告

分区存储管理模拟实验报告

分区存储管理模拟实验报告分区存储管理模拟实验报告1.实验目的了解动态分区存储管理方式中的数据结构和分配算法,加深对动态分区存储管理方式及其实现技术的理解。

2. 实验内容▪用C语言或Pascal语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程Allocate()和回收过程Free()。

其中,空闲分区采用空闲分区链来组织,内存分配时,优先使用空闲区低地址部分的空间。

▪假设初始状态,可用内存空间为640KB,作业请求序列如下(也可以编程从键盘输入,R 表示请求,F表示释放):✧作业1请求130 KB。

✧作业2请求60 KB。

✧作业3请求100 KB。

到第一个足以满足要球的空闲块就停止查找,并把它分配出去;如果该空闲空间与所需空间大小一样,则从空闲表中取消该项;如果还有剩余,则余下的部分仍留在空闲表中,但应修改分区大小和分区始址。

最佳适应算法:当要分配内存空间时,就查找空闲表中满足要求的空闲块,并使得剩余块是最小的。

然后把它分配出去,若大小恰好合适,则直按分配;若有剩余块,则仍保留该余下的空闲分区,并修改分区大小的起始地址。

内存回收:将释放作业所在内存块的状态改为空闲状态,删除其作业名,设置为空。

并判断该空闲块是否与其他空闲块相连,若释放的内存空间与空闲块相连时,则合并为同一个空闲块,同时修改分区大小及起始地址。

typedef struct freearea{}ElemType;定义一个空闲区说明表结构,每申请一个作业,改作业便具有此结构体typedef struct DuLNode{}DuLNode,*DuLinkList;定义一个双向链表Status Initblock(){}开创带头结点的内存空间链表,通过双向链表把申请的作业链接起来,作业的插入和删除,和链表中节点的插入和删除类似。

双向链表如图1所示Status First_fit(int ID,int request){}传入作业名及申请量采用首次适应算法实现动态内存分区分配的模拟,初始态640KB,只是一个虚态,每申请成功一个作业,便相应的640KB做相应的减少,同过双向链表模拟主存的分配情况。

存储管理动态分区分配及回收算法

存储管理动态分区分配及回收算法

存储管理动态分区分配及回收算法存储管理是计算机系统中的重要组成部分,它负责管理和分配计算机中的物理内存资源。

在计算机系统中,通过动态分区分配和回收算法来实现对这些资源的有效利用。

本文将介绍动态分区分配和回收算法的原理、主要算法以及优缺点。

动态分区分配是一种灵活、动态的内存分配方式,它根据进程的需求动态地分配内存空间。

动态分区分配算法有多种,其中最常用的有首次适应算法、最佳适应算法和最坏适应算法。

首次适应算法(First Fit)是最常用的分配算法之一、它从低地址开始寻找第一个满足要求的空闲分区来分配进程。

这种算法的优点是简单、高效,但是可能会产生大量的碎片空间,降低内存的利用率。

最佳适应算法(Best Fit)是在所有空闲分区中找到一个大小最适合进程的分区来分配。

它的主要思想是选择一个更接近进程大小的空闲分区,以减少碎片空间的产生。

然而,这种算法的缺点是需要遍历整个空闲分区链表,因此效率相对较低。

最坏适应算法(Worst Fit)与最佳适应算法相反,它选择一个大小最大的空闲分区来分配进程。

这种算法的好处是可以尽可能地保留大块的碎片空间,以便后续分配使用。

但是,它也会导致更多的碎片空间浪费。

动态分区的回收算法是用于回收被释放的内存空间并合并相邻的空闲分区,以尽量减少碎片空间的产生。

常见的回收算法有合并相邻空闲分区算法和快速回收算法。

合并相邻空闲分区算法会在每次有分区被回收时,检查是否有相邻的空闲分区可以合并。

如果有,就将它们合并为一个大的空闲分区。

这样可以最大程度地减少碎片空间,提高内存的利用效率。

快速回收算法是一种将被释放的分区插入到一个空闲分区链表的头部,而不是按照地址顺序进行插入的算法。

这样可以减少对整个空闲分区链表的遍历时间,提高回收的效率。

总结起来,动态分区分配和回收算法在存储管理中起着重要的作用。

首次适应算法、最佳适应算法和最坏适应算法是常用的动态分区分配算法,它们各自有着不同的优缺点。

操作系统-存储管理动态分区分配及回收算法(附源码)

操作系统-存储管理动态分区分配及回收算法(附源码)

存储管理动态分区分配及回收算法课程名称:计算机操作系统班级:信1501-2实验者姓名:李琛实验日期:2018年5月20日评分:教师签名:一、实验目的分区管理是应用较广泛的一种存储管理技术。

本实验要求用一种结构化高级语言构造分区描述器,编制动态分区分配算法和回收算法模拟程序,并讨论不同分配算法的特点.二、实验要求1、编写:First Fit Algorithm2、编写:Best Fit Algorithm3、编写:空闲区回收算法三、实验过程(一)主程序1、定义分区描述器node,包括3 个元素:(1)adr-—分区首地址(2)size——分区大小(3)next——指向下一个分区的指针2、定义3 个指向node 结构的指针变量:(1)head1——空闲区队列首指针(2)back1-—指向释放区node 结构的指针(3)assign——指向申请的内存分区node 结构的指针3、定义1 个整形变量:free——用户申请存储区的大小(由用户键入)(二)过程1、定义check 过程,用于检查指定的释放块(由用户键入)的合法性2、定义assignment1 过程,实现First Fit Algorithm3、定义assignment2 过程,实现Best Fit Algorithm4、定义acceptment1 过程,实现First Fit Algorithm 的回收算法5、定义acceptment2 过程,实现Best Fit Algorithm 的回收算法6、定义print 过程,打印空闲区队列(三)执行程序首先申请一整块空闲区,其首址为0,大小为32767;然后,提示用户使用哪种分配算法,再提示是分配还是回收;分配时要求输入申请区的大小,回收时要求输入释放区的首址和大小。

实验代码Main。

cpp#include〈stdio。

h〉#include<stdlib.h>#include〈string。

动态分区式存储管理

动态分区式存储管理

可变分区存储管理设计思路:整体思路:可变分区管理方式将内存除操作系统占用区域外的空间看做一个大的空闲区。

当作业要求装入内存时,根据作业需要内存空间的大小查询内存中的各个空闲区,当从内存空间中找到一个大于或等于该作业大小的内存空闲区时,选择其中一个空闲区,按作业需求量划出一个分区装人该作业,作业执行完后,其所占的内存分区被收回,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

设计所才用的算法:采用最优适应算法,每次为作业分配内存时,总是把既能满足要求、又是最小的空闲分区分配给作业。

但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行,这时,空闲区分割后剩下的空闲区就很小以致很难再使用,降低了内存的使用率。

为解决此问题,设定一个限值minsize,如果空闲区的大小减去作业需求长度得到的值小于等于minsize,不再将空闲区分成己分分区和空闲区两部分,而是将整个空闲区都分配给作业。

内存分配与回收所使用的结构体:为便于对内存的分配和回收,建立两张表记录内存的使用情况。

一张为记录作业占用分区的“内存分配表”,内容包括分区起始地址、长度、作业名/标志(为0时作为标志位表示空栏目);一张为记录空闲区的“空闲分区表”,内容包括分区起始地址、长度、标志(0表空栏目,1表未分配)。

两张表都采用顺序表形式。

关于分配留下的内存小碎片问题:当要装入一个作业时,从“空闲分区表”中查找标志为“1”(未分配)且满足作业所需内存大小的最小空闲区,若空闲区的大小与作业所需大小的差值小于或等于minsize,把该分区全部分配给作业,并把该空闲区的标志改为“0”(空栏目)。

同时,在已分配区表中找到一个标志为“0”的栏目登记新装人作业所占用分区的起始地址,长度和作业名。

若空闲区的大小与作业所需大小的差值大于minsize。

则把空闲区分成两部分,一部分用来装入作业,另外一部分仍为空闲区。

实验三 动态分区存储管理

实验三 动态分区存储管理

实验三存储管理动态分区存储管理
实验目的
•熟悉并掌握动态分区分配的各种算法。

•熟悉并掌握动态分区中分区回收的各种情
况,并能够实现分区合并。

实验内容及要求
•用高级语言模拟实现动态分区存储管理,要求:
–分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。

熟悉并掌握各种算法的空闲区组织方式。

–分区的初始化——可以由用户输入初始分区的大小。

(初始化后只有一个空闲分区,起始地址为0,大小是用户输入的大小)–分区的动态分配过程:由用户输入作业号和作业的大小,实现分区过程。

–分区的回收:用户输入作业号,实现分区回收,同时,分区的合并要体现出来。

(注意:不存在的作业号要给出错误提示!)–分区的显示:任何时刻,可以查看当前内存的情况(起始地址是什么,大小多大的分区时空闲的,或者占用的,能够显示出来)
实验报告要求
•实验报告应包含但不限于以下内容:–设计图(结构图/流程图)和源代码;
–使用的编程语言和系统环境;
–结果截图;
–对结果截图的解释性说明。

注意事项
•三个动态分区分配算法可以使用一套程序,差别只在空闲分区链(表)的排序策略。

•至少完成一个分配算法。

•需完成回收算法。

动态分区算法实验报告

动态分区算法实验报告

动态分区算法实验报告动态分区算法实验报告一、引言计算机操作系统是现代计算机系统中的核心组成部分,它负责管理计算机硬件资源,并提供各种服务。

内存管理是操作系统的重要功能之一,它负责管理计算机的内存资源,为进程提供运行环境。

在内存管理中,动态分区算法是一种常用的内存分配策略。

本实验旨在通过实践,深入了解动态分区算法的原理和实现。

二、实验目的1. 了解动态分区算法的基本原理和实现方式;2. 掌握动态分区算法的实验环境搭建和使用方法;3. 分析动态分区算法的优缺点,并比较不同算法的性能差异。

三、实验环境本实验使用C语言编程实现,实验环境如下:1. 操作系统:Windows 10;2. 开发工具:Visual Studio 2019;3. 编程语言:C语言。

四、实验过程1. 实验准备在开始实验之前,我们首先需要了解动态分区算法的基本原理。

动态分区算法根据进程的内存需求,将内存划分为若干个不同大小的分区,并按照进程的请求进行分配和释放。

常用的动态分区算法有首次适应算法、最佳适应算法和最坏适应算法等。

2. 实验设计本实验选择实现首次适应算法,并设计以下几个函数:- 初始化内存空间:初始化一块指定大小的内存空间,将其划分为一个个的分区,并设置分区的状态;- 分配内存:根据进程的内存需求,在内存空间中找到合适的分区进行分配,并更新分区的状态;- 释放内存:将已分配的内存空间进行释放,并更新分区的状态;- 显示内存状态:打印当前内存空间的分区状态。

3. 实验实现根据上述设计,我们使用C语言实现了动态分区算法的相关函数。

通过调用这些函数,我们可以模拟动态分区算法的运行过程,并观察分区的分配和释放情况。

4. 实验结果经过实验,我们得到了以下结果:- 动态分区算法可以有效地管理内存资源,根据进程的需求进行灵活的内存分配;- 首次适应算法在内存分配效率和速度方面表现良好,但可能会导致内存碎片的产生;- 释放内存时,及时合并相邻的空闲分区可以减少内存碎片的数量。

操作系统-动态分区分配算法实验报告

操作系统-动态分区分配算法实验报告

实验题目:存储器内存分配设计思路:1.既然是要对内存进行操作,首先对和内存相关的内容进行设置我使用的是用自定义的数据结构struct来存放内存中一个内存块的内容包括:始地址、大小、状态(f:空闲u:使用e:结束)之后采用数组来存放自定义的数据类型,这样前期的准备工作就完成了2.有了要加工的数据,接下来定义并实现了存放自定义数据类型的数组的初始化函数和显示函数,需要显示的是每个内存块的块号、始地址、大小、状态3.接着依此定义三种动态分区分配算法首次适应算法、最佳适应算法和最差适应算法4.对定义的三种算法逐一进行实现①首次适应算法:通过遍历存放自定义数据类型的数组,找到遍历过程中第一个满足分配大小的内存块块号i,找到之后停止对数组的遍历,将i之后的块号逐个向后移动一个,然后将满足分配大小的内存块i分为两块,分别是第i块和第i+1块,将两块的始地址、大小、状态分别更新,这样便实现了首次适应算法②最佳适应算法:和首次适应算法一样,首先遍历存放自定义数据类型的数组,找到满足分配大小的内存块后,对内存块的大小进行缓存,因为最佳适应是要找到最接近要分配内存块大小的块,所以需要遍历整个数组,进而找到满足分配大小要求的而且碎片最小的块i,之后的操作和首次遍历算法相同③最差适应算法:和最佳适应算法一样,区别在于,最佳适应是找到最接近要分配内存块大小的块,而最差适应是要找到在数组中,内存最大的块i,找到之后的操作和最佳适应算法相同,因此不在这里赘述。

5.定义并实现释放内存的函数通过块号找到要释放的内存块,把要释放的内存块状态设置成为空闲,查看要释放的块的左右两侧块的状态是否为空闲,如果有空闲,则将空闲的块和要释放的块进行合并(通过改变块的始地址、大小、状态的方式)6.定义主函数,用switch来区分用户需要的操作,分别是:①首次适应②最佳适应③最差适应④释放内存⑤显示内存⑥退出系统实验源程序加注释:#include<bits/stdc++.h>#define MI_SIZE 100 //内存大小100typedef struct MemoryInfomation//一个内存块{int start; //始地址int Size; //大小char status; //状态 f:空闲 u:使用 e:结束} MI;MI MList[MI_SIZE];void InitMList() //初始化{int i;MI temp = { 0,0,'e' };for (i = 0; i < MI_SIZE; i++){MList[i] = temp;}MList[0].start = 0; //起始为0MList[0].Size = MI_SIZE;//大小起始最大MList[0].status = 'f'; //状态起始空闲}void Display() //显示{int i, used = 0;printf("\n---------------------------------------------------\n");printf("%5s%15s%15s%15s", "块号", "始地址", "大小", "状态");printf("\n---------------------------------------------------\n");for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].status == 'u'){used += MList[i].Size;}printf("%5d%15d%15d%15s\n", i, MList[i].start, MList[i].Size, MList[i].status == 'u' ? "使用" : "空闲");}printf("\n----------------------------------------------\n");}void FirstFit(){int i, j, flag = 0;int request;printf("最先适应算法:请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f') {if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request; MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';flag = 1;}break;}}if (flag != 1 || i == MI_SIZE || MList[i].status == 'e'){printf("没有足够大小的空间分配\n");}Display();}void BadFit(){int i, j = 0, k = 0, flag = 0, request;printf("最坏适应算法:请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0;i < MI_SIZE - 1 && MList[i].status != 'e';i++){if (MList[i].Size >= request && MList[i].status == 'f') {flag = 1;if (MList[i].Size > k){k = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2;j > i;j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}void M_Release() //释放内存{int i, number;printf("\n请问你要释放哪一块内存:\n");scanf("%d", &number);if (MList[number].status == 'u'){MList[number].status = 'f';if (MList[number + 1].status == 'f')//右边空则合并{MList[number].Size += MList[number].Size;for (i = number + 1; i < MI_SIZE - 1 && MList[i].status != 'e'; i++) { //i后面的每一个结点整体后移if (i > 0){MList[i] = MList[i + 1];}}}if (number > 0 && MList[number - 1].status == 'f')//左边空则合并{MList[number - 1].Size += MList[number].Size;for (i = number; i < MI_SIZE - 1 && MList[i].status != 'e'; i++){MList[i] = MList[i + 1];}}}else{printf("该块内存无法正常释放\n");}Display();}void BestFit(){int i, j = 0, t, flag = 0, request;printf("最佳适应算法:请问你要分配多大的内存\n");scanf("%d", &request);t = MI_SIZE;for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f'){flag = 1;if (MList[i].Size < t){t = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else {for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}int main(){int x;InitMList();while (1){printf(" \n"); printf(" 1.首次适应\n");printf(" 2.最佳适应\n");printf(" 3.最差适应\n"); printf(" 4.释放内存\n"); printf(" 5.显示内存\n"); printf(" 6.退出系统\n"); printf("请输入1-6:");scanf("%d", &x);switch (x){case 1:FirstFit();break;case 2:BestFit();break;case 3:BadFit();break;case 4:M_Release();break;case 5:Display();break;case 6:exit(0);}}return 0;}实验测试结果记录:1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存10---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 90 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 65 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存15---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 50 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:1最先适应算法:请问你要分配多大的内存20---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:4请问你要释放哪一块内存:---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:4请问你要释放哪一块内存:2---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 空闲3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:2最佳适应算法:请问你要分配多大的内存5---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:3最坏适应算法:请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 25 使用6 95 5 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6:总结与自评:总结:分区存储管理是操作系统进行内存管理的一种方式。

实验三--动态分区存储管理方式的主

实验三--动态分区存储管理方式的主

实验三动态分区存储管理方式的主存分配回收一、实验目的深入了解动态分区存储管理方式主存分配回收的实现。

二、实验预备知识存储管理中动态分区的管理方式。

、三、实验内容编写程序完成动态分区存储管理方式的主存分配回收的实现。

实验具体包括:首先确定主存空间分配表;然后采用最优适应算法完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。

四、提示与讲解动态分区管理方式预先不将主存划分成几个区域,而把主存除操作系统占用区域外的空间看作一个大的空闲区。

当作业要求装入主存时,根据作业需要主存空间的大小查询主存内各个空闲区,当从主存空间中找到一个大于或等于该作业大小的主存空闲区时,选择其中一个空闲区,按作业需求量划出一个分区装入该作业。

作业执行完后,它所占的主存分区被收回,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

实现动态分区的分配和回收,主要考虑的问题有三个:第一,设计记录主存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计主存分配算法;第三,在设计的数据表格基础上设计主存回收算法。

*首先,考虑第一个问题:设计记录主存使用情况的数据表格,用来记录空闲区和作业占用的区域。

由于动态分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随主存分配和回收变动。

总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。

由于分区长度不同,因此设计的表格应该包括分区在主存中的起始地址和长度。

由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收主存分区时,可能会合并空闲分区,这样如果整个主存采用一张表格记录已分分区和空闲区,就会使表格操作繁琐。

主存分配时查找空闲区进行分配,然后填写已分配区表,主要操作在空闲区;某个作业执行完后,将该分区变成空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。

由此可见,主存的分配和回收主要是对空闲区的操作。

动态分区分配操作系统操作方法实验步骤

动态分区分配操作系统操作方法实验步骤

动态分区分配操作系统操作方法实验步骤1.引言1.1 概述概述部分:在计算机系统中,动态分区分配是一种重要的操作系统操作方法。

它是指在运行时根据进程的内存需求动态地将系统内存分配给进程,以实现内存资源的高效利用。

动态分区分配操作方法在现代操作系统中被广泛应用,例如Windows、Linux等。

通过合理的动态分区分配策略,可以提升系统的性能和资源利用率。

本文将对动态分区分配操作系统操作方法进行详细介绍和实验步骤的说明。

首先,我们将介绍动态分区分配的背景和意义,包括其在操作系统中的作用和应用场景。

其次,我们将详细讨论实验的具体步骤,包括如何进行动态分区分配操作、如何测试相关的性能指标等。

本文的目标是帮助读者了解动态分区分配操作系统操作方法的基本原理和实践技巧。

同时,通过实际操作和实验验证,读者将能够更好地理解动态分区分配的概念和操作过程,提升对操作系统的理解和应用能力。

在接下来的章节中,我们将分别介绍动态分区分配操作系统操作方法的背景和实验步骤,并给出相应的实例和案例分析。

最后,我们将对实验结果进行总结和展望,探讨动态分区分配操作方法的发展前景和可能的研究方向。

通过本文的阅读和实验操作,读者将能够对动态分区分配操作系统操作方法有一个全面的了解,为进一步研究和应用提供基础和指导。

同时,我们也欢迎读者对本文内容进行补充和扩展,以促进相关领域的进一步发展和应用。

1.2 文章结构文章结构部分的内容可以从以下角度进行描述:文章结构是指整篇文章的组织框架和内容安排。

合理的文章结构可以使读者更好地理解文章的主题和内容,帮助读者快速找到所需信息并形成完整的认识。

本文将按照以下结构进行论述:1. 引言:在引言部分,我们将对动态分区分配操作系统操作方法的背景和意义进行介绍,明确文章的目的和重要性。

2. 正文:正文是文章的核心部分,将分为两个要点进行叙述。

2.1 第一个要点:动态分区分配操作系统操作方法。

首先,我们将对动态分区分配的背景进行介绍,解释其在操作系统中的应用和意义。

操作系统实验3-动态分区存储管理

操作系统实验3-动态分区存储管理

实验三动态分区存储管理一:实验目的了解动态分区存储管理方式中的数据结构和分配算法,加深对动态分区存储管理方式及其实现技术的理解。

二:实验内容用C语言或Pascal语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程Allocate()和回收过程Free()。

其中,空闲分区采用空闲分区链来组织,内存分配时,优先使用空闲区低地址部分的空间。

三:实验类别动态分区存储管理四:实验类型模拟实验五:主要仪器计算机六:结果和小结七:程序#include<stdio.h>#include<time.h>#include<stdlib.h>#define SIZE 640 // 内存初始大小#define MINSIZE 5 // 碎片最小值struct memory{struct memory *former;//前向指针int address;//地址int num;//作业号int size;//分配内存大小int state;//状态0表示空闲,1表示已分配struct memory *next;//后向指针}linklist;void intmemory()// 初始化空闲分区链{memory *p=(memory *)malloc(sizeof(memory));// 分配初始分区内存p->address=0;// 给首个分区赋值p->size=SIZE;p->state=0;p->num=-1;p->former=&linklist;p->next=NULL;linklist.former=NULL;// 初始化分区头部信息linklist.next=p;}int firstFit(int num, int size)// 首次适应算法{memory *p = linklist.next;while(p != NULL){if(p->state == 0 && p->size >= size) // 找到要分配的空闲分区{if(p->size - size <= MINSIZE)// 整块分配{p->state = 1;p->num = num;}else // 分配大小为size的区间{memory *node=(memory *)malloc(sizeof(memory));node->address=p->address + size;node->size=p->size-size;node->state=0;node->num=-1;// 修改分区链节点指针node->former=p;node->next=p->next;if(p->next !=NULL){p->next->former=node;}p->next = node;// 分配空闲区间p->size = size;p->state = 1;p->num = num;}printf("内存分配成功!\n");return 1;}p = p->next;}printf("找不到合适的内存分区,分配失败...\n");return 0;}int bestFit(int num, int size)// 最佳适应算法{memory *tar=NULL;int tarSize=SIZE + 1;memory *p=linklist.next;while(p!=NULL){if(p->state==0 && p->size >= size && p->size < tarSize) //寻找最佳空闲区间{tar=p;tarSize=p->size;}p=p->next;}if(tar!=NULL){if(tar->size - size <= MINSIZE) //找到要分配的空闲分区{tar->state = 1;// 整块分配tar->num=num;}else // 分配大小为size的区间{memory *node = (memory *)malloc(sizeof(memory));node->address = tar->address + size;node->size = tar->size - size;node->state = 0;node->num = -1;// 修改分区链节点指针node->former = tar;node->next = tar->next;if(tar->next != NULL){tar->next->former = node;}tar->next = node;// 分配空闲区间tar->size = size;tar->state = 1;tar->num = num;}printf("内存分配成功!\n");return 1;} else{// 找不到合适的空闲分区printf("找不到合适的内存分区,分配失败!!\n");return 0;}}int freememory(int num)// 回收内存{int flag=0;memory *p=linklist.next, *pp;while(p!=NULL){if(p->state==1 && p->num==num){flag = 1;if((p->former!= &linklist && p->former->state == 0) && (p->next != NULL && p->next->state == 0)){// 情况1:合并上下两个分区// 先合并上区间pp=p;p=p->former;p->size+=pp->size;p->next=pp->next;pp->next->former=p;free(pp);// 后合并下区间pp=p->next;p->size+=pp->size;p->next=pp->next;if(pp->next!=NULL){pp->next->former=p;}free(pp);}else if((p->former==&linklist || p->former->state==1)&& (p->next!=NULL&&p->next->state ==0)) {// 情况2:只合并下面的分区pp=p->next;p->size+=pp->size;p->state=0;p->num=-1;p->next=pp->next;if(pp->next!= NULL){pp->next->former=p;}free(pp);}else if((p->former!=&linklist&&p->former->state==0)&& (p->next==NULL || p->next->state==1)) {// 情况3:只合并上面的分区pp=p;p=p->former;p->size+=pp->size;p->next=pp->next;if(pp->next != NULL) {pp->next->former = p;}free(pp);}else{// 情况4:上下分区均不用合并p->state=0;p->num=-1;}}p=p->next;}if(flag==1){// 回收成功printf("内存分区回收成功...\n");return 1;}else{// 找不到目标作业,回收失败printf("找不到目标作业,内存分区回收失败...\n");return 0;}}// 显示空闲分区链情况void showmemory(){printf(" 当前的内存分配情况如下:\n");printf("*********************************************\n");printf(" 起始地址| 空间大小| 工作状态| 作业号\n");memory *p=linklist.next;while(p!=NULL){printf("******************************************\n");printf("**");printf("%5d k |", p->address);printf("%5d k |", p->size);printf(" %5s |", p->state == 0 ? "0" : "1");if(p->num > 0) {printf("%5d ", p->num);} else {printf(" ");}p = p->next;}}int main(){int option, ope, num, size;// 初始化空闲分区链intmemory();// 选择分配算法l1: while(1){printf("***************************************\n");printf("请选择要模拟的分配算法:\n1表示首次适应算法\n2表示最佳适应算法\n");printf("***************************************\n");scanf("%d", &option);system("cls");if(option==1) {printf("你选择了首次适应算法,下面进行算法的模拟\n");break;} else if(option==2) {printf("你选择了最佳适应算法,下面进行算法的模拟\n");break;}else {printf("错误:请输入0/1\n\n");}}// 模拟动态分区分配算法while(1){printf("\n");printf("*********************************************\n");printf("1:分配内存\n 2:回收内存\n 3:返回上一级菜单\n\n");printf("*********************************************\n");scanf("%d", &ope);system("cls");if(ope==0) break;if(ope==1){// 模拟分配内存printf("请输入作业号:");scanf("%d", &num);printf("请输入需要分配的内存大小(KB):");scanf("%d", &size);if(size<=0){printf("错误:分配内存大小必须为正值\n");continue;}// 调用分配算法if(option==0){firstFit(num, size);}else{bestFit(num, size);}// 显示空闲分区链情况showmemory();}else if(ope==2){// 模拟回收内存printf("请输入要回收的作业号:");scanf("%d", &num);freememory(num);// 显示空闲分区链情况showmemory();}else if(ope==3){goto l1;}else{printf("错误:请输入0/1/2\n");}}printf("分配算法模拟结束\n");return 0;}。

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告DOC.doc

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告DOC.doc

计算机操作系统实验报告实验二实验题目:存储器管理系别:计算机科学与技术系班级:姓名:学号:2一、实验目的深入理解动态分区存储管理方式下的内存空间的分配与回收。

二、实验内容编写程序完成动态分区存储管理方式下的内存分配和回收的实现。

具体内容包括:确定用来管理内存当前使用情况的数据结构;采用首次适应算法完成内存空间的分配;分情况对作业进行回收;编写主函数对所做工作进行测试。

三、实验原理分配:动态分区存储管理方式把内存除OS占用区域外的空间看作一个大的空闲区。

当作业要求装入内存时,根据作业需要内存空间的大小查询内存中各个空闲区,当从内存中找到一个大于或等于该作业大小的内存空闲区时,选择其中一个空闲区,按作业要求划出一个分区装入该作业。

回收:作业执行完后,它所占用的内存空间被收回,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

四、实验方法实现动态分区的分配与回收,主要考虑三个问题:第一、设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域(利用结构体类型数组来保存数据);第二、在设计的数据表格基础上设计内存分配算法(采用首次适应算法找合适的分区(对空闲分区表进行排序),分配时要考虑碎片问题);第三、在设计的数据表格基础上设计内存回收算法(分四种情况进行回收(上邻、下邻、上下邻和无相邻分区)。

五、实验步骤第一,设计记录内存使用情况的数据表格●已分配分区表:起始地址、长度、标志(0表示“空表项”,1表示“已分配”)●空闲分区表:起始地址、长度、标志(0表示“空表项”,1表示“未分配”)struct used_table {float address; //已分分区起始地址float length; //已分分区长度,单位为字节int flag; //已分配表区登记栏标志,用0表示空栏目,char zuoyename;}; //已分配区表Struct free_table[ {float address; //空闲分区起始地址float length; //空闲分区长度,单位为字节int flag; //空闲分区表登记栏目用0表示空栏目,1表示未配}; //空闲分区表第二,在设计的表格上进行内存分配●首次适应算法:为作业分配内存,要求每次找到一个起始地址最小的适合作业的分区(按起始地址递增排序)。

动态分区分配算法实验报告

动态分区分配算法实验报告

操作系统实验报告实验二:动态分区分配算法学生:学号:学院:系别:专业:实验时间:报告时间:一、实验内容编写一个内存动态分区分配模拟程序,模拟内存的分配和回收的完整过程。

一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。

当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。

当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。

主存的分配和回收的实现与主存储器的管理方式有关的,通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。

三、实验原理模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。

(1)可变分区方式是按作业需要的主存空间大小来分割分区的。

当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。

随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。

例如:为了说明哪些区是空闲的,可以用来装入新作业,必须要有一X 空闲区说明表,格式如下:第一栏第二栏其中,起址——指出一个空闲区的主存起始地址。

长度——指出从起始地址开始的一个连续空闲的长度。

状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区。

(2) 当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。

有时找到的空闲区可能大于作业需要量,这时应把原来的空闲区变成两部分:一部分分给作业占用;另一部分又成为一个较小的空闲区。

为了尽量减少由于分割造成的空闲区,而尽量保存高地址部分有较大的连续空闲区域,以利于大型作业的装入。

为此,在空闲区说明表中,把每个空闲区按其地址顺序登记,即每个后继的空闲区其起始地址总是比前者大。

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告第一篇:计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告计算机操作系统实验报告实验二实验题目:存储器管理系别:计算机科学与技术系班级:姓名:学号:2一、实验目的深入理解动态分区存储管理方式下的内存空间的分配与回收。

二、实验内容编写程序完成动态分区存储管理方式下的内存分配和回收的实现。

具体内容包括:确定用来管理内存当前使用情况的数据结构;采用首次适应算法完成内存空间的分配;分情况对作业进行回收;编写主函数对所做工作进行测试。

三、实验原理分配:动态分区存储管理方式把内存除OS占用区域外的空间看作一个大的空闲区。

当作业要求装入内存时,根据作业需要内存空间的大小查询内存中各个空闲区,当从内存中找到一个大于或等于该作业大小的内存空闲区时,选择其中一个空闲区,按作业要求划出一个分区装入该作业。

回收:作业执行完后,它所占用的内存空间被收回,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

四、实验方法实现动态分区的分配与回收,主要考虑三个问题:第一、设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域(利用结构体类型数组来保存数据);第二、在设计的数据表格基础上设计内存分配算法(采用首次适应算法找合适的分区(对空闲分区表进行排序),分配时要考虑碎片问题);第三、在设计的数据表格基础上设计内存回收算法(分四种情况进行回收(上邻、下邻、上下邻和无相邻分区)。

五、实验步骤第一,设计记录内存使用情况的数据表格λ已分配分区表:起始地址、长度、标志(0表示“空表项”,1表示“已分配”)λ空闲分区表:起始地址、长度、标志(0表示“空表项”,1表示“未分配”)struct used_table { float address;//已分分区起始地址float length;//已分分区长度,单位为字节int flag;//已分配表区登记栏标志,用0表示空栏目,char zuoyename;};//已分配区表Struct free_table[ { float address;//空闲分区起始地址float length;//空闲分区长度,单位为字节int flag;//空闲分区表登记栏目用0表示空栏目,1表示未配};//空闲分区表第二,在设计的表格上进行内存分配λ首次适应算法:为作业分配内存,要求每次找到一个起始地址最小的适合作业的分区(按起始地址递增排序)。

存储管理动态分区分配及回收算法

存储管理动态分区分配及回收算法

存储管理动态分区分配及回收算法⼀、实验⽬的分区管理是应⽤较⼴泛的⼀种存储管理技术。

本实验要求⽤⼀种结构化⾼级语⾔构造分区描述器,编制动态分区匹配算法和回收算法模拟程序,并讨论不同算法的特点。

⼆、实验内容1.编写:First Fit Algorithm2.编写:Best Fit Algorithm3.编写 :空闲区回收算法三,提⽰和说明(⼀)主程序1、定义分区描述器node,包括 3个元素:(1)adr——分区⾸地址(2)size——分区⼤⼩(3)next——指向下⼀个分区的指针2、定义 3个指向node结构的指针变量:(1)head1——空闲区队列⾸指针(2)back1——指向释放区node结构的指针(3)assign——指向申请的内存分区node结构的指针3、定义 1个整形变量:free——⽤户申请存储区的⼤⼩(由⽤户键⼊)(⼆)过程1、定义check过程,⽤于检查指定的释放块(由⽤户键⼊)的合法性2、定义assignment1过程,实现First Fit Algorithm3、定义assignment2过程,实现Best Fit Algorithm4、定义acceptment1过程,实现First Fit Algorithm的回收算法5、定义acceptment2过程,实现Best Fit Algorithm的回收算法6、定义print过程,打印空闲区队列(三)执⾏程序⾸先申请⼀整块空闲区,其⾸址为0,⼤⼩为32767;然后,提⽰⽤户使⽤哪种分配算法,再提⽰是分配还是回收;分配时要求输⼊申请区的⼤⼩,回收时要求输⼊释放区的⾸址和⼤⼩。

(四)输出要求每执⾏⼀次,输出⼀次空闲区队列情况,内容包括:编号⾸址终址⼤⼩三、实验过程1.准备A.查阅相关资料;B.初步编写程序;C.准备测试数据;2、主要流程和源代码#include<iostream>#include<stdlib.h>using namespace std;#define Free 0 //空闲状态#define Busy 1 //已⽤状态#define OK 1 //完成#define ERROR 0 //出错#define MAX_length 32767 //最⼤内存空间为32767KB typedef int Status;int n = 0;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;DuLinkList block_first; //头结点DuLinkList block_last; //尾结点Status alloc(int);//内存分配Status free(int); //内存回收Status First_fit(int, int);//⾸次适应算法Status Best_fit(int, int); //最佳适应算法void show();//查看分配Status Initblock();//开创空间表Status Initblock()//开创带头结点的内存空间链表{block_first = (DuLinkList)malloc(sizeof(DuLNode)); block_last = (DuLinkList)malloc(sizeof(DuLNode)); block_first->prior = NULL;block_first->next = block_last;block_last->prior = block_first;block_last->next = NULL;block_last->data.address = 0;block_last->data.size = MAX_length;block_last->data.ID = 0;block_last->data.state = Free;return OK;}//分配主存Status alloc(int ch){int ID, request;cout << "请输⼊作业(分区号):";cin >> ID;cout << "请输⼊需要分配的主存⼤⼩(单位:KB):";cin >> request;if (request<0 || request == 0){cout << "分配⼤⼩不合适,请重试!" << endl;return ERROR;}if (ch == 2) //选择最佳适应算法{if (Best_fit(ID, request) == OK) cout << "分配成功!" << endl; else cout << "内存不⾜,分配失败!" << endl;return OK;}else //默认⾸次适应算法{if (First_fit(ID, request) == OK) cout << "分配成功!" << endl; else cout << "内存不⾜,分配失败!" << endl;return OK;}}//⾸次适应算法Status First_fit(int ID, int request)//传⼊作业名及申请量{//为申请作业开辟新空间且初始化DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode)); temp->data.ID = ID;temp->data.size = request;DuLNode *p = block_first->next;while (p){if (p->data.state == Free && p->data.size == request) {//有⼤⼩恰好合适的空闲块p->data.state = Busy;p->data.ID = ID;return OK;break;}if (p->data.state == Free && p->data.size>request){//有空闲块能满⾜需求且有剩余"temp->prior = p->prior;temp->next = p;temp->data.address = p->data.address;p->prior->next = temp;p->prior = temp;p->data.address = temp->data.address + temp->data.size; p->data.size -= request;return OK;break;}p = p->next;}return ERROR;}//最佳适应算法Status Best_fit(int ID, int request){int ch; //记录最⼩剩余空间DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode)); temp->data.ID = ID;temp->data.size = request;temp->data.state = Busy;DuLNode *p = block_first->next;DuLNode *q = NULL; //记录最佳插⼊位置while (p) //初始化最⼩空间和最佳位置{(p->data.size>request || p->data.size == request)){q = p;ch = p->data.size - request;break;}p = p->next;}while (p){if (p->data.state == Free && p->data.size == request) {//空闲块⼤⼩恰好合适p->data.ID = ID;p->data.state = Busy;return OK;break;}if (p->data.state == Free && p->data.size>request) {//空闲块⼤于分配需求if (p->data.size - request<ch)//剩余空间⽐初值还⼩{ch = p->data.size - request;//更新剩余最⼩值q = p;//更新最佳位置指向}}p = p->next;}if (q == NULL) return ERROR;//没有找到空闲块else{//找到了最佳位置并实现分配temp->prior = q->prior;temp->next = q;temp->data.address = q->data.address;q->prior->next = temp;q->prior = temp;q->data.address += request;q->data.size = ch;return OK;}}//主存回收Status free(int ID){DuLNode *p = block_first;while (p){if (p->data.ID == ID){p->data.state = Free;p->data.ID = Free;if (p->prior->data.state == Free)//与前⾯的空闲块相连{p->prior->data.size += p->data.size;p->prior->next = p->next;p->next->prior = p->prior;}if (p->next->data.state == Free)//与后⾯的空闲块相连{p->data.size += p->next->data.size;p->next->next->prior = p;p->next = p->next->next;}break;}p = p->next;}return OK;}// 显⽰主存分配情况void show(){cout << "***********-----------------************" << endl; cout << "**** 主存分配情况 ****" << endl; cout << "***********-----------------************" << endl; DuLNode *p = block_first->next;while (p){cout << "分区号:";if (p->data.ID == Free) cout << "Free" << endl;else cout << p->data.ID << endl;cout << "起始地址:" << p->data.address << endl;cout << "分区⼤⼩:" << p->data.size << " KB" << endl; cout << "状态:";if (p->data.state == Free) cout << "空闲" << endl;else cout << "已分配!" << endl;cout << "-----------------------" << endl;p = p->next;}}//主函数int main(){int ch, d = 0;//算法选择标记cout << "1.⾸次适应算法 2.最佳适应算法 0.退出" << endl; cout << "请选择分配算法:";cin >> ch;if (ch == 0 || ch == 1 || ch == 2) d++;while (d == 0){cout << "请选择正确的数字0 ,1 或2" << endl;cin >> ch;if (ch == 0 || ch == 1 || ch == 2) d++;}if (ch == 0) exit(0);if (n == 0) Initblock(); //开创空间表int choice; //操作选择标记while (1){cout << "********************************************" << endl; cout << "** 1: 分配内存 2: 回收内存 **" << endl; cout << "** 3: 查看分配 0: 返回 **" << endl; cout << "********************************************" << endl; cout << "请输⼊您的操作:";cin >> choice;if (choice == 1)alloc(ch); // 分配内存n++;}else if (choice == 2) // 内存回收{int ID;cout << "请输⼊您要释放的分区号:"; cin >> ID;free(ID);n++;}else if (choice == 3){show();//显⽰主存n++;}else if (choice == 0){main(); //退出n++;}else //输⼊操作有误{cout << "输⼊有误,请重试!" << endl; continue;}}}四、实验结果3、遇到的主要问题和解决⽅法主要问题是在算法的结构的理解。

操作系统实验动态分区存储管理方式的主存分配回收.

操作系统实验动态分区存储管理方式的主存分配回收.

操作系统实验_动态分区存储管理方式的主存分配回收//////////////////////////////////////////////////////////// // 功能:// 《计算机操作系统》实验// 首次适应性算法// 摸拟动态分区存储管理方式的主存分配和回收// 时间:// 2005-11-14////////////////////////////////////////////////////////////#include "iostream.h"#include "iomanip.h"#define ERR_NOFREEAREA 1#define ERR_NOADEQUACYAREA 2#define ERR_ALLOCATED 4#define ERR_NOJOBS 1#define ERR_NOSUCHJOB 2#define ERR_RECLAIMED 4typedef struct tagUsedNode{long address;long length;int flag; //作业名struct tagUsedNode *next;} USED_AREA , *USED_TABLE;typedef struct tagFreeNode{long address;long length;struct tagFreeNode *next;} FREE_AREA , *FREE_TABLE;//空闲区、作业区链表USED_TABLE usedTable = NULL;FREE_TABLE freeTable = NULL;//给作业分配空间//jobname: 作业名//jobsize: 作业所需空间大小int Allocate( int jobname , long jobsize )//如果没有空闲区if( freeTable == NULL )return ERR_NOFREEAREA;FREE_TABLE p = freeTable;FREE_TABLE q = p;//找首次适应空闲区while( p != NULL && p->length < jobsize ){q = p;p = p->next;}//如果找不到有足够空间的分区if( p == NULL )return ERR_NOADEQUACYAREA;USED_TABLE x = new USED_AREA;x->address = p->address;x->length = jobsize;x->flag = jobname;x->next = NULL;//如果该分区大于作业需求,空间大小减去作业大小if( p->length > jobsize ){p->length -= jobsize;p->address += jobsize;}//如果该分区等于作业大小,删除该分区else{if( p == freeTable )freeTable = NULL;elseq->next = p->next;delete p;}//作业加入“作业表”中USED_TABLE r = usedTable;USED_TABLE t = r;while( r != NULL && r->address < x->address ) {t = r;r = r->next;}if( usedTable == NULL )usedTable = x;else{x->next = r;t->next = x;}return ERR_ALLOCATED;}//回收作业空间//jobname: 作业名int Reclaim( int jobname ){if( usedTable == NULL )return ERR_NOJOBS;USED_TABLE p = usedTable;USED_TABLE q = p;while( p != NULL && p->flag != jobname ){q = p;p = p->next;}//如果没有该作业if( p == NULL )return ERR_NOSUCHJOB;//回收后的空间加入到空闲区FREE_TABLE r = freeTable;FREE_TABLE t = r;FREE_TABLE x;while( r != NULL && r->address < p->address ) {t = r;r = r->next;}x = new FREE_AREA;x->address = p->address;x->length = p->length;x->next = NULL;if( r == freeTable ){x->next = r;freeTable = x;t = freeTable;}else{x->next = r;t->next = x;}//合并分区while( t->next != NULL && t->address + t->length == t->next->address ) {t->length += t->next->length;r = t->next;t->next = t->next->next;delete r;}//删除该作业if( p == usedTable ){usedTable = usedTable->next;}elseq->next = p->next;delete p;return ERR_RECLAIMED;}int Init(){freeTable = new FREE_AREA;freeTable->address = 0;freeTable->length = 1024;freeTable->next = NULL;return 1;}void jobrequest(){int jobname;int jobsize;cout<<"...................."<<endl;cout<<"作业名: ";cin >> jobname;cout<<"作业长度: ";cin >> jobsize;if( Allocate( jobname , jobsize ) == ERR_ALLOCATED )cout<<"该作业已成功获得所需空间"<<endl;elsecout<<"该作业没有获得所需空间"<<endl;cout<<"...................."<<endl;}void jobreclaim(){int jobname;cout<<"...................."<<endl;cout<<"作业名: ";cin >>jobname;int result = Reclaim( jobname );if( result == ERR_RECLAIMED )cout<<"该作业已成功回收"<<endl;else if( result == ERR_NOSUCHJOB || result == ERR_NOJOBS )cout<<"系统没有作业或该作业不存在"<<endl;cout<<"...................."<<endl;}void freeTablePrint(){cout<<"........................................"<<endl;cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<en dl<<endl;FREE_TABLE p = freeTable;USED_TABLE q = usedTable;int x , y;while( p || q ){if( p )x = p->address;elsex = 0x7fffffff;if( q )y = q->address;elsey = 0x7fffffff;if( x < y ){cout<<setw(10)<<p->address<<setw(10)<<p->length<<setw(10)<<"空闲"<<endl;p = p->next;}if( x > y ){cout<<setw(10)<<q->address<<setw(10)<<q->length<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->flag<<endl;q = q->next;}}cout<<"........................................"<<endl;}void main(){Init();int choose;bool exitFlag = false;while( !exitFlag ){cout<<"选择功能项( 0 -退出 1 - 分配主存 2 - 回收主存 3 - 显示主存)"<<endl; cout<<"?>";cin>>choose;switch( choose ){case 0:exitFlag = true;break;case 1:jobrequest();break;case 2:jobreclaim();break;case 3:freeTablePrint();break;}}}Trackback: /TrackBack.aspx?PostId=529025。

操作系统原理实验教学大纲(本科) 2021

操作系统原理实验教学大纲(本科) 2021

操作系统原理实验教学大纲(本科) 2021操作系统原理实验教学大纲(本科)-2021《操作系统原理》实验教学大纲一、实验教学内容与基本建议实验一批处理系统的作业调度1目的要求1.增进对作业概念的认知;2.深入了解批处理系统如何组织作业、管理作业和调度作业。

2实验内容编写程序顺利完成批处理系统中的作业调度,建议使用积极响应比高者优先的作业调度算法。

实验具体内容包含:首先确认作业控制块的内容,作业控制块的共同组成方式;然后顺利完成作业调度;最后撰写主函数对所搞工作展开测试。

3所需实验设施设备pc、windows操作系统4教学形式及过程模拟、学生单一制顺利完成实验二进程管理1目的建议1.加深对进程概念的理解,明确进程和程序的区别。

2.深入了解系统如何组织进程、创建进程。

3.进一步认识如何实现处理器调度。

2实验内容编写程序顺利完成单处理机系统中的进程调度,建议使用时间片吕埃县调度算法。

实验具体内容包含:首先确认进程掌控块的内容,进程掌控块的共同组成方式;然后顺利完成进程建立原语和进程调度原语;最后撰写主函数对所搞工作展开测试。

3所需实验设施设备pc、windows操作系统4教学形式及过程模拟、学生单一制顺利完成实验三动态分区存储管理方式的主存分配回收1目的要求深入细致介绍动态分区存储管理方式主存分配废旧的同时实现。

2实验内容编写程序完成动态分区存储管理方式的主存分配回收的实现。

实验具体包括:首先确定主存空间分配表;然后采用最优适应算法完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。

3所需实验设施设备pc、windows操作系统4教学形式及过程演示、学生独立完成实验四页式虚拟存储管理中地址切换和缺页中断1目的建议1.深入了解页式存储管理如何实现地址转换;2.进一步认识页式虚拟存储管理中如何处理缺页中断。

2实验内容编写程序顺利完成页式存储管理中地址切换过程和演示缺页中断的处置。

实验具体内容包含:首先对取值的地址展开地址切换工作,若出现缺页则先展开缺页中断处置,然后再展开地址切换;最后撰写主函数对所搞工作展开测试。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验三动态分区存储管理方式的主存分配回收一、实验目的深入了解动态分区存储管理方式主存分配回收的实现。

二、实验预备知识存储管理中动态分区的管理方式。

三、实验内容编写程序完成动态分区存储管理方式的主存分配回收的实现。

实验具体包括:首先确定主存空间分配表;然后采用最优适应算法完成主存空间的分配和回收;最后编写主函数对所做工作进行测试。

四、提示与讲解动态分区管理方式预先不将主存划分成几个区域,而把主存除操作系统占用区域外的空间看作一个大的空闲区。

当作业要求装入主存时,根据作业需要主存空间的大小查询主存内各个空闲区,当从主存空间中找到一个大于或等于该作业大小的主存空闲区时,选择其中一个空闲区,按作业需求量划出一个分区装入该作业。

作业执行完后,它所占的主存分区被收回,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

实现动态分区的分配和回收,主要考虑的问题有三个:第一,设计记录主存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计主存分配算法;第三,在设计的数据表格基础上设计主存回收算法。

首先,考虑第一个问题:设计记录主存使用情况的数据表格,用来记录空闲区和作业占用的区域。

由于动态分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随主存分配和回收变动。

总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。

由于分区长度不同,因此设计的表格应该包括分区在主存中的起始地址和长度。

由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收主存分区时,可能会合并空闲分区,这样如果整个主存采用一张表格记录已分分区和空闲区,就会使表格操作繁琐。

主存分配时查找空闲区进行分配,然后填写已分配区表,主要操作在空闲区;某个作业执行完后,将该分区变成空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。

由此可见,主存的分配和回收主要是对空闲区的操作。

这样为了便于对主存空间的分配和回收,就建立两张分区表记录主存使用情况,一张表格记录作业占用分区的“已分配区表”;一张是记录空闲区的“空闲区表”。

这两张表的实现方法一般有两种,一种是链表形式,一种是顺序表形式。

在实验中,采用顺序表形式,用数组模拟。

由于顺序表的长度必须提前固定,所以无论是“已分配区表”还是“空闲区表”都必须事先确定长度。

它们的长度必须是系统可能的最大项数,系统运行过程中才不会出错,因而在多数情况下,无论是“已分配区表”还是“空闲区表”都有空闲栏目。

已分配区表中除了分区起始地址、长度外,也至少还要有一项“标志”,如果是空闲栏目,内容为“空”,如果为某个作业占用分区的登记项,内容为该作业的作业名;空闲区表中除了分区起始地址、长度外,也要有一项“标志”,如果是空闲栏目,内容为“空”,如果为某个空闲区的登记项,内容为“未分配”。

在实际系统中,这两表格的内容可能还要多,实验中仅仅使用上述必须的数据。

为此,“已分配区表”和“空闲区表”在实验中有如下的结构定义。

已分配区表的定义:#define n 10//假定系统允许的最大作业数量为nstruct{float address;//已分分区起始地址float length; //已分分区长度,单位为字节int flag;//已分配区表登记栏标志,“0”表示空栏目,实验中只支持一个字符的作业名}used_table[n];//已分配区表空闲区表的定义:#define m 10//假定系统允许的空闲区表最大为mstruct{float address;//空闲区起始地址float length;//空闲区长度,单位为字节int flag;//空闲区表登记栏标志,用“0”表示空栏目,用“1”表示未分配}free_table[m];//空闲区表其中分区起始地址和长度数值太大,超出了整型表达范围,所以采用了float类型。

然后,就要考虑如何在设计的数据表格上进行主存的分配。

当要装入一个作业时,从空闲区表中查找标志为“未分配”的空闲区,从中找出一个能容纳该作业的空闲区。

如果找到的空闲区正好等于该作业的长度,则把该分区全部分配给作业。

这时应该把该空闲区登记栏中的标志改为“空”,同时在已分配区表中找到一个标志为“空”的栏目登记新装入作业所占用分区的起始地址、长度和作业名。

如果找到的空闲区大于作业长度,则把空闲区分成两部分,一部分用来装入作业,另外一部分仍为空闲区。

这时只要修改原空闲区的长度,且把新装入的作业登记到已分配区表中。

实验中主存分配算法采用“最优适应”算法。

最优适应算法是按作业要求挑选一个能满足作业要求的最小空闲区,这样保证可以不去分割一个大的区域,使装入大作业时比较容易得到满足。

但是最优适应算法容易出现找到的一个分区可能只比作业所要求的长度略大一点的情况,这时,空闲区分割后剩下的空闲区就很小,这种很小的空闲区往往无法使用,影响了主存的使用。

为了一定程度上解决这个问题,如果空闲区的大小比作业要求的长度略大一点,不再将空闲区分成已分分区和空闲区两部分,而是将整个空闲区分配给作业。

在实现最优适应算法时,可把空闲区按长度以递增方式登记在空闲区表中。

分配时顺序查找空闲表,查找到的第一个空闲区就是满足作业要求的最小分区。

这样查找速度快,但是为使空闲区按长度以递增顺序登记在空闲表中,就必须在分配回收时进行空闲区表的调整。

空闲区表调整时移动表目的代价要高于查询整张表的代价,所以实验中不采用空闲区有序登记在空闲表中的方法。

动态分区方式的主存分配流程如图4所示。

作业J申请xk大小的主存空间i=0;k=-1;i是空闲区表中一栏(i<=m)?YN第i栏标志为“未分配”且满足作业需求xk?N是否找到满足需求的分区k?N主存分配失败结束YY第k栏xx-作业需求≤minsize?N第i栏空闲区为第一个满足需求的或第i栏空闲区xx小于第k栏空闲区xx?N分配整个分区:第k栏状态为“空”ad=第k栏起始地址;xk=第k栏xx;Yi=0切割空闲区:第k栏xx减去xk;ad=第k栏起始地址-第k栏xx;k=ii=i+1第i栏是已分配区表中一栏且第i栏状态不为空?i=i+1YNY第i栏是为已分分配表中一栏?YN填写已分配区表:第j栏起始地址=ad;第j栏xx=xk;第j栏状态=作业名J空闲区表第k栏状态为空?N空闲区表状态未分配空闲区表第k栏长度加xk已分配区表长度不足,分配失败结束图4动态分区最优分配算法流程图最后是动态分区方式下的主存回收问题。

动态分区方式下回收主存空间时,应该检查是否有与归还区相邻的空闲区。

若有,则应该合并成一个空闲区。

一个归还区可能有上邻空闲区,也可能有下邻空闲区,或者既有上邻空闲区又有下邻空闲区,或者既无上邻空闲区也无下邻空闲区。

在实现回收时,首先将作业归还的区域在已分配表中找到,将该栏目的状态变为“空”,然后检查空闲区表中标志为“未分配”的栏目,查找是否有相邻空闲区;最后,合并空闲区,修改空闲区表。

假定作业归还的分区起始地址为S,长度为L,则:(1)归还区有下邻空闲区如果S+L正好等于空闲区表中某个登记栏目(假定为第j栏)的起始地址,则表明归还区有一个下邻空闲区。

这时只要修改第j栏登记项的内容:起始地址=S;第j栏xx=第j栏xx+L;则第j栏指示的空闲区是归还区和下邻空闲区合并后的大空闲区。

(2)归还区有上邻空闲区如果空闲区表中某个登记栏目(假定为第k栏)的“起始地址+长度”正好等于S,则表明归还区有一个上邻空闲区。

这时要修改第k栏登记项的内容(起始地址不变):第k栏xx=第k栏xx+L;于是第k栏指示的空闲区是归还区和上邻空闲区合并后的大空闲区。

(3)归还区既有上邻空闲区又有下邻空闲区如果S+L正好等于空闲区表中某个登记栏目(假定为第j栏)的起始地址,同时还有某个登记栏目(假定为第k栏)的“起始地址+长度”正好等于S,这表明归还区既有一个上邻空闲区又有一个下邻空闲区。

此时对空闲区表的修改如下:第k栏长度=第k栏长度+第j栏长度+L;(第k栏起始地址不变)第j栏状态=“空”;(将第j栏登记项删除)这样,第k栏指示的空闲区是归还区和上、下邻空闲区合并后的大空闲区;原来的下邻空闲区登记项(第j栏)被删除,置为“空”。

(4)归还区既无上邻空闲区又无下邻空闲区如果在检查空闲区表时,无上述三种情况出现,则表明归还区既无上邻空闲区又无下邻空闲区。

这时,应该在空闲区表中查找一个状态为“空”的栏目(假定查到的是第t栏),则第t栏的内容修改如下:第t栏起始地址=S;第t栏xx=L;第t栏状态=“未分配”这样,第t栏指示的空闲区是归还区。

按上述方法归还主存区域的流程如图5所示。

由于是实验,没有真正的主存要分配,所以在实验中,首先应建立一张空闲区表,初始状态只有一个空闲登记项(假定的主存空闲区)和一张所有状态都为“空”的已分配区表,假定主存空间110KB,操作系统占用10KB,其余为空闲区;然后,可以选择进行主存分配或主存回收,如果是分配,要求输入作业名和所需主存空间大小,如果是回收,输入回收作业的作业名,循环进行主存分配和回收后,如果需要,则显示两张表的内容,以检查主存的分配和回收是否正确。

作业J归还空间s=0s=s+1已分配区表第s栏状态为作业J(s<=n)?NYNs为已分配区表中一栏?YS=已分配区表第Ys栏起始地址L=已分配区表第s栏xx已分配区表第s栏状态为空未找到作业,回收失败结束假设下邻空闲区在第假设上邻空闲区在第i=0j栏j=-1;k栏k=-1;i=i+1第i栏不是空闲区表中一栏或回收分区的上下邻空闲区均找到?YNN第i栏状态为“未分配”?YY回收分区有上邻?N回收分区有下邻?N回收分区有下邻?Nt=0YYY第i栏为回收分区的上邻?NYj=i第Ni栏为回收分区的下邻?NY第t栏是空闲表一栏?N和上邻合并:第k 栏xx=第k栏xx+L和上下邻三项合并:第k栏xx=第k栏长度+第j栏xx+L;第j栏状态=“空”和下邻合并:第j 栏长度=第j栏长度+L第j 栏起始地址=Sj=i t=t+1第t栏是空闲表xx空栏?YN已分配区表第s栏状态为J;空闲区表xx不足,回收失败归还分区填入空闲区表:第t栏起始地址=S;第t栏xx=L;第t栏状态=“未分配”结束图5动态分区回收流程图五、课外题(1)编程实现页式存储管理的主存分配和回收。

(2)用链表方式表示主存空间分配情况,完成动态分区管理方式下的主存空间分配和回收。

六、参考程序#define n 10//假定系统允许的最大作业数量为n#define m 10//假定系统允许的空闲区表最大为m#define minisize 100struct{ float address;//已分分区起始地址float length;//已分分区长度,单位为字节int flag;//已分配区表登记栏标志,用“0”表示空栏目,实验中只支持一个字符的作业名}used_table[n];//已分配区表struct{float address;//空闲区起始地址float length;//空闲区长度,单位为字节int flag;//空闲区表登记栏标志,用“0”表示空栏目,用“1”表示未分配}free_table[m];//空闲区表allocate(J,xk)//采用最优分配算法分配xk大小的空间char J;float xk;{int i,k;float ad;k=-1;for(i=0;i<m;i++)//寻找空间大于xk的最小空闲区登记项kif(free_table[i].length>=xk&&free_table[i].flag==1)if(k==-1||free_table[i].length<free_table[k].length)k=i;if(k==-1)//未找到可用空闲区,返回{printf("无可用空闲区\n");return;}//找到可用空闲区,开始分配:若空闲区大小与要求分配的空间差小于minisize大小,则空闲区全部分配;若空闲区大小与要求分配的空间差大于minisize大小,则从空闲区划出一部分分配if(free_table[k].length-xk<=minisize){free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;} else{free_table[k].length=free_table[k].length-xk;ad=free_table[k].address+free_table[k].length;}//修改已分配区表i=0;while(used_table[i].flag!=0&&i<n)//寻找空表目i++;if(i>=n)//无表目填写已分分区{printf("无表目填写已分分区,错误\n");//xx空闲区表if(free_table[k].flag==0)//前面找到的是整个空闲区free_table[k].flag=1;else //前面找到的是某个空闲区的一部分free_table[k].length=free_table[k].length+xk;return;} else //修改已分配区表{used_table[i].address=ad;}//主存归还函数结束main( ){int i,a;float xk;char J;//空闲区表初始化free_table[0].address=10240;free_table[0].length=102400;free_table[0].flag=1;for(i=1;i<m;i++)free_table[i].flag=0;//已分配区表初始化for(i=0;i<n;i++)used_table[i].flag=0;while(1){printf("选择功能项(0-退出,1-分配主存,2-回收主存,3-显示主存)\n"); printf("选择功项(0~3) :");scanf("%d",&a);switch(a){case 0: exit(0);//a=0程序结束case 1://a=1分配主存空间printf("输入作业名J和作业所需长度xk:");scanf("%*c%c%f",&J,&xk);allocate(J,xk);//分配主存空间break;case 2://a=2回收主存空间printf("输入要回收分区的作业名");scanf("%*c%c",&J);reclaim(J);//回收主存空间break;case 3://a=3显示主存情况,输出空闲区表和已分配区表printf("输出空闲区表:\n起始地址分区xx标志\n");for(i=0;i<m;i++)printf("%5.0f%10.0f%6d\n",free_table[i].address,free_table[i].length,free_table[i].flag);printf("按任意键,输出已分配区表\n");getch();printf("输出已分配区表:\n起始地址分区xx标志\n");for(i=0;i<n;i++)if(used_table[i].flag!=0)printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length,used_table[i].flag);elseprintf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length,used_table[i].flag); break;default:printf("没有该选项\n");}//case}//while}//main( )结束。

相关文档
最新文档