内存的分配与回收实验报告(最先适应法)
实验报告二主存空间的分配和回收
![实验报告二主存空间的分配和回收](https://img.taocdn.com/s3/m/f4c3faefaeaad1f346933f14.png)
if(strcmp(PName,"OS")==0)
{ printf("ERROR!");
return;
}
while((strcmp(temp->proID,PName)!=0||temp->flag==1)&&temp)
temp=temp->next;
四、程序中使用的数据结构及符号说明
结构1:
typedef struct freeTable
{
char proID[6];
int startAddr; /*空闲区起始地址*/
int length; /*空闲区长度,单位为字节*/
int flag; /*空闲区表登记栏标志,用"0"表示空表项,用"1"表示未分配*/
freeNode=freeNode->next;
}
getchar();
break;
default:printf("没有该选项\n");
}/*case*/
}/*while*/
}/*main()*/
六、运行调试结果
初始界面:
分配主存,五个作业名:P1、P2、P3、P4、P5
显示主存使用情况:
回收主存P2:
if(front->flag==1&&rear->flag==1)
/* 上邻空闲区,下邻空闲区,三项合并*/
{
front->length=front->length+rear->length+temp->length;
用首次适应算法实现内存分配与回收
![用首次适应算法实现内存分配与回收](https://img.taocdn.com/s3/m/f67a8706c950ad02de80d4d8d15abe23492f0379.png)
用首次适应算法实现内存分配与回收首次适应算法(First Fit)是一种常用的内存分配算法,它将内存分为若干个大小相等的块,并按顺序进行分配。
当有一个进程请求内存时,首次适应算法从头开始,找到第一个大小能够满足这个进程需要的空闲块,将其分配给该进程。
以下是使用首次适应算法实现内存分配与回收的一种简单示例:1.假设整个内存大小为M字节,每个块的大小为N字节,内存被分为M/N个块。
2. 定义一个长度为(M/N)的布尔数组block,表示每个块的分配状态,初始时所有元素都为false,表示空闲状态。
3. 当一个进程请求分配S字节的内存时,首次适应算法从第一个块开始遍历数组block,直到找到一个大小大于等于S的空闲块。
4. 如果找到了合适的空闲块,将该块标记为已分配(设置为true),并返回该块的起始地址;否则,返回分配失败的标识。
5. 当一个进程释放已分配的内存时,可以根据该内存的起始地址计算出对应的块索引,将对应的block元素设置为false,表示该块变为空闲状态。
以下是一个简单的C++代码示例,演示了使用首次适应算法进行内存分配与回收的实现:```cpp#include <iostream>using namespace std;const int M = 1000; // 总内存大小const int N = 100; // 块大小bool block[M/N] = { false }; // 内存块分配状态//首次适应内存分配算法int allocateMemory(int size)int numBlocks = M / N; // 块数量int numNeeded = size / N;if (size % N != 0)numNeeded++;}for (int i = 0; i < numBlocks; i++)bool found = true;for (int j = i; j < i + numNeeded; j++)if (j >= numBlocks , block[j] == true)found = false;break;}}if (found)for (int j = i; j < i + numNeeded; j++)block[j] = true;}return i * N;}}return -1; // 分配失败//内存回收void deallocateMemory(int startAddr, int size)int startIndex = startAddr / N;int numBlocks = size / N;if (size % N != 0)numBlocks++;}for (int i = startIndex; i < startIndex + numBlocks; i++) block[i] = false;}int maiint size1 = 200; // 请求200字节内存int size2 = 300; // 请求300字节内存int addr1 = allocateMemory(size1);int addr2 = allocateMemory(size2);if (addr1 != -1)cout << "分配内存成功,起始地址:" << addr1 << endl; } elsecout << "分配内存失败" << endl;}if (addr2 != -1)cout << "分配内存成功,起始地址:" << addr2 << endl; } elsecout << "分配内存失败" << endl;}deallocateMemory(addr1, size1);deallocateMemory(addr2, size2);return 0;```这段代码实现了一个简单的内存分配与回收示例。
用首次适应算法模拟内存的分配和回收
![用首次适应算法模拟内存的分配和回收](https://img.taocdn.com/s3/m/a24e31d3b9f3f90f76c61b51.png)
操作系统实验报告完成日期:2011-12-5用首次适应算法模拟内存的分配和回收一、实验目的在计算机系统中,为了提高内存区的利用率,必须给电脑内存区进行合理的分配。
本实验通过对内存区分配方法首次适应算法的使用,来了解内存分配的模式。
在熟练掌握计算机分区存储管理方式的原理的基础上,编程模拟实现操作系统的可变分区存储管理的功能,一方面加深对原理的理解,另一方面提高根据已有原理通过编程解决实际问题的能力,为进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。
二、实验内容与数据结构:(1)可变式分区管理是指在处理作业过程中建立分区,使分区大小正好适合作业的需要,并且分区的个数是可以调整的。
当需要装入一个作业时,根据作业需要的贮存量,查看是否有足够的空闲空间,若有,则按需求量分割一部分给作业;若无,则作业等待。
随着作业的装入、完成,主存空间被分割成许多大大小小的分区。
有的分区被分配作业占用,有的分区空闲,例如,某时刻主存空间占用情况如图所示:为了说明哪些分区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,如下图所示。
(2)当有一个新作业要求装入贮存时,必须查空闲区说明表,从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业的需求量,这时应将空闲区一分为二。
一个分给作业,另一个仍作为空闲区留在空闲区表中。
为了尽量减少由于分割造成的碎片,尽可能分配地地址部分的空闲区,将较大的空闲区留在高地址端,以利于大作业的装入。
为此在空闲区表中,按空闲区首地址从低到高进行登记。
(3)当一个作业执行完成时,作业所占用的分区应归还给系统。
在归还时,要考虑相邻空间区合并问题。
作业的释放区与空闲区的邻接分以下4种情况考虑:A、释放区下邻空闲区;B、释放区上邻空闲区;C、释放区上下都与空闲区邻接;D、释放区上邻空闲区不邻接;二、实验要求1.内存大小初始化2.可以对内存区进行动态分配,采用首次适应算法来实现3.可以对已分配的内存块进行回收,并合并相邻的空闲内存块。
实现内存分配实验报告(3篇)
![实现内存分配实验报告(3篇)](https://img.taocdn.com/s3/m/a0d1c962eef9aef8941ea76e58fafab068dc441b.png)
第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。
2. 掌握动态分区分配方式中的数据结构和分配算法。
3. 通过编写程序,实现内存分配和回收功能。
二、实验环境1. 操作系统:Linux2. 编程语言:C语言3. 开发工具:GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要,将物理内存分配给程序使用的过程。
内存分配算法主要包括以下几种:(1)首次适应算法(First Fit):从内存空间首部开始查找,找到第一个满足条件的空闲区域进行分配。
(2)最佳适应算法(Best Fit):在所有满足条件的空闲区域中,选择最小的空闲区域进行分配。
(3)最坏适应算法(Worst Fit):在所有满足条件的空闲区域中,选择最大的空闲区域进行分配。
2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中,根据需要动态地分配和回收内存空间。
动态分区分配方式包括以下几种:(1)固定分区分配:将内存划分为若干个固定大小的分区,程序运行时按需分配分区。
(2)可变分区分配:根据程序大小动态分配分区,分区大小可变。
(3)分页分配:将内存划分为若干个固定大小的页,程序运行时按需分配页。
四、实验内容1. 实现首次适应算法(1)创建空闲分区链表,记录空闲分区信息,包括分区起始地址、分区大小等。
(2)编写分配函数,实现首次适应算法,根据程序大小查找空闲分区,分配内存。
(3)编写回收函数,回收程序所占用的内存空间,更新空闲分区链表。
2. 实现最佳适应算法(1)创建空闲分区链表,记录空闲分区信息。
(2)编写分配函数,实现最佳适应算法,根据程序大小查找最佳空闲分区,分配内存。
(3)编写回收函数,回收程序所占用的内存空间,更新空闲分区链表。
3. 实验结果分析(1)通过实验,验证首次适应算法和最佳适应算法的正确性。
(2)对比两种算法在内存分配效率、外部碎片等方面的差异。
五、实验步骤1. 创建一个动态内存分配模拟程序,包括空闲分区链表、分配函数和回收函数。
在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。
![在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。](https://img.taocdn.com/s3/m/a133fa2e0066f5335a8121e9.png)
System.out.println("...............删除作业2后的内存情况....................");
l.delete(jobArray,2);
System.out.println("...............此后再添加作业4后的内存情况....................");
Link l = new Link();
System.out.println("...................起始的内存..................................");
jobArray[0].print();
System.out.println(".....................增加第一个作业后的内存情况.....................");
实验
一、实验目的
帮助学生理解在不同的存储管理方式下应如何实现主存空间的分配和回收。理解好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能够合理地分配和使用这些存储空间。
二、实验环境
1、Java环境
三、实验时数:
四
1.在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。
}
else{ //当下一块内存已被使用,那么继续寻找一块还没被使用的内存
for(int j=i+1;j<a.length-1;j++){
if(a[j]==null){
a[j]=new Node(size+a[j-1].start,size,true,jobNo);
主存空间的分配与回收 首次适应法
![主存空间的分配与回收 首次适应法](https://img.taocdn.com/s3/m/f884b3dc6bec0975f565e215.png)
南通大学操作系统实验课实验报告学生姓名所在院系专业学号指导教师南通大学2014年 5 月 16 日主存空间的分配与回收——首次适应法一、实验目的主存是中央处理机能直接存取指令和数据的存储器,能否合理而有效地使用它,在很大程度上将影响整个计算机系统的性能。
本实验主要熟悉主存的管理方法以及相应的分配与回收算法。
所谓分配,就是解决多道程序或多进程如何共享主存空间的问题,以便各个进程能获得所希望的主存空间,正确运行。
所谓回收,就是当进程运行完成时,将其所占用的主存空间归还给系统。
二、实验要求采用空闲区链法管理空闲区,并增加已分配区表。
分配算法采用首次适应法。
三、设计思路:(1)采用空闲区链法管理空闲区,并增加已分配区表。
分配算法采用首次适应法(内存空闲区的地址按照从小到大的自然顺序排列),实现内存的分配与回收。
(2)设计一个进程申请序列以及进程完成后的释放顺序,实现主存的分配与回收。
(3)进行分配时应该考虑这样3种情况:进程申请的空间小于、等于或大于系统空闲区的大小。
回收时应该考虑这样4种情况:释放区上邻、下邻、上下都邻和都不邻接空闲区。
(4)每次的分配与回收都要求把记录内存使用情况的各种数据结构的变化情况以及各进程的申请、释放情况显示出来。
四、主要思想(1)输入主存空间的最大长度n创建最大长度总和为n的若干空闲区的主存空闲区链;(2)输入待存作业的长度x,从链头开始找第一个合适作业的空闲区:分区长度小于x时,指针后移,继续寻找;分区长度等于x时,分配空间,修改作业分区;分区长度大于x 时,分配空间,修改分区数据。
五、流程图1.空闲区链的首次适应算法分配流程图2.空闲区链的首次适应算法回收流程图六、调试结果1.内存的分配2.内存的回收3.内存清空七、总结与感悟说实话我操作系统学得不是很好,一开始看到题目觉得自己要完成这个实验有些难度。
好在老师提醒书上有另一道类似题目的程序代码,另外书上也有首次适应法的流程图,可以给我们一些提示。
实验四操作系统存储管理实验报告
![实验四操作系统存储管理实验报告](https://img.taocdn.com/s3/m/930af803302b3169a45177232f60ddccdb38e668.png)
实验四操作系统存储管理实验报告一、实验目的本次实验的主要目的是深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握内存分配与回收、页面置换算法等关键概念,并能够分析和解决存储管理中可能出现的问题。
二、实验环境本次实验在装有 Windows 操作系统的计算机上进行,使用了 Visual Studio 等编程工具和相关的调试环境。
三、实验内容(一)内存分配与回收算法实现1、首次适应算法首次适应算法从内存的起始位置开始查找,找到第一个能够满足需求的空闲分区进行分配。
在实现过程中,我们通过建立一个空闲分区链表来管理内存空间,每次分配时从表头开始查找。
2、最佳适应算法最佳适应算法会选择能够满足需求且大小最小的空闲分区进行分配。
为了实现该算法,在空闲分区链表中,分区按照大小从小到大的顺序排列,这样在查找时能够快速找到最合适的分区。
3、最坏适应算法最坏适应算法则选择最大的空闲分区进行分配。
同样通过对空闲分区链表的排序和查找来实现。
(二)页面置换算法模拟1、先进先出(FIFO)页面置换算法FIFO 算法按照页面进入内存的先后顺序进行置换,即先进入内存的页面先被置换出去。
在模拟过程中,使用一个队列来记录页面的进入顺序。
2、最近最久未使用(LRU)页面置换算法LRU 算法根据页面最近被使用的时间来决定置换顺序,最近最久未使用的页面将被置换。
通过为每个页面设置一个时间戳来记录其最近使用的时间,从而实现置换策略。
3、时钟(Clock)页面置换算法Clock 算法使用一个环形链表来模拟内存中的页面,通过指针的移动和页面的访问标志来决定置换页面。
四、实验步骤(一)内存分配与回收算法的实现步骤1、初始化内存空间,创建空闲分区链表,并为每个分区设置起始地址、大小和状态等信息。
2、对于首次适应算法,从链表表头开始遍历,找到第一个大小满足需求的空闲分区,进行分配,并修改分区的状态和大小。
3、对于最佳适应算法,在遍历链表时,选择大小最接近需求的空闲分区进行分配,并对链表进行相应的调整。
操作系统实验四 主存空间的分配与回收-首次适应算法和循环首次适应算法
![操作系统实验四 主存空间的分配与回收-首次适应算法和循环首次适应算法](https://img.taocdn.com/s3/m/a3adbb5501f69e31433294cb.png)
实验报告【实验名称】首次适应算法和循环首次适应算法【实验目的】理解在连续分区动态的存储管理方式下,如何实现主存空间的分配与回收。
【实验原理】首次适应(first fit,FF)算法FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时,从链首开始顺序查找,直至找到一个大小能满足要求的空闲分区即可。
然后再按照作业的大小,从该分区中划出一块内存空间,分配给请求者,余下的空闲分区仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区,则表明系统中已经没有足够大的内存分配给该进程,内存分配失败,返回。
循环首次适应(next fit,NF)算法为避免低址部分留下许多很小的空闲分区,以及减少查找可用空闲分区的开销,循环首次适应算法在为进程分配内存空间时,不再是每次都从链首开始查找,而是从上次找到的空闲分区的下一个空闲分区开始查找,直至找到一个能满足要求的空闲分区,从中划出一块玉请求大小相等的内存空间分配给作业。
【实验内容】实现主存空间的分配与回收:1.采用可变式分区管理,使用首次适应算法实现主存空间的分配与回收;2.采用可变式分区管理,使用循环首次适应算法实现主存空间的分配与回收。
数据结构和符号说明:typedef struct PCB//进程控制块{char ProgressName[10]; //进程名称int Startaddress; //进程开始地址int ProgressSize; //进程大小int ProgressState = 0; //进程状态};typedef struct FREE //空闲区结构体{int Free_num; //空闲区名称int Startaddress; //空闲区开始地址int Endaddress; //空闲区结束地址int Free_Space; //空闲区大小};算法流程图:首次适应算法循环首次适应算法程序代码及截图:主界面:首次适应算法,初始空闲区:插入进程:插入3个进程:空闲区信息:删除进程2:删除后空闲区状况:再插入一个进程,可以看到其其初始地址为100:循环首次适应算法,插入3个进程删除进程2后:再插入进程A,发现其从上次找到的空闲分区的下一个空闲分区开始查找,其初始地址为750而不是200:。
内存分配回收实验报告
![内存分配回收实验报告](https://img.taocdn.com/s3/m/cb6c666c30126edb6f1aff00bed5b9f3f90f7293.png)
一、实验目的通过本次实验,加深对内存分配与回收机制的理解,掌握内存分配算法和回收策略,并能够运用所学知识解决实际内存管理问题。
二、实验内容1. 确定内存空间分配表;2. 采用首次适应算法实现内存分配;3. 采用最佳适应算法实现内存分配;4. 采用最坏适应算法实现内存分配;5. 实现内存回收功能;6. 对比分析不同内存分配算法的优缺点。
三、实验步骤1. 创建一个内存空间模拟程序,用于演示内存分配与回收过程;2. 定义内存空间分配表,记录内存块的起始地址、大小和状态(空闲或占用);3. 实现首次适应算法,在内存空间分配表中查找第一个满足条件的空闲内存块,分配给请求者;4. 实现最佳适应算法,在内存空间分配表中查找最接近请求大小的空闲内存块,分配给请求者;5. 实现最坏适应算法,在内存空间分配表中查找最大的空闲内存块,分配给请求者;6. 实现内存回收功能,当内存块释放时,将其状态更新为空闲,并合并相邻的空闲内存块;7. 对比分析不同内存分配算法的优缺点,包括分配时间、内存碎片和内存利用率等方面。
四、实验结果与分析1. 首次适应算法:该算法按照内存空间分配表的顺序查找空闲内存块,优点是分配速度快,缺点是容易产生内存碎片,且内存利用率较低;2. 最佳适应算法:该算法查找最接近请求大小的空闲内存块,优点是内存利用率较高,缺点是分配速度较慢,且内存碎片较多;3. 最坏适应算法:该算法查找最大的空闲内存块,优点是内存利用率较高,缺点是分配速度较慢,且内存碎片较多。
五、实验结论通过本次实验,我们掌握了内存分配与回收的基本原理和算法,了解了不同内存分配算法的优缺点。
在实际应用中,我们需要根据具体需求选择合适的内存分配算法,以优化内存管理,提高系统性能。
六、实验心得1. 内存分配与回收是计算机系统中重要的组成部分,对系统性能有着重要影响;2. 熟练掌握内存分配算法和回收策略,有助于解决实际内存管理问题;3. 在实际应用中,应根据具体需求选择合适的内存分配算法,以优化内存管理,提高系统性能。
操作系统实验报告三存储器管理实验
![操作系统实验报告三存储器管理实验](https://img.taocdn.com/s3/m/6813f24b53d380eb6294dd88d0d233d4b14e3f82.png)
操作系统实验报告三存储器管理实验操作系统实验报告三:存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法,通过实际操作和观察,掌握内存分配与回收的算法,以及页面置换算法的工作过程和性能特点,从而提高对操作系统资源管理的认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。
三、实验内容1、内存分配与回收算法实现首次适应算法(First Fit)最佳适应算法(Best Fit)最坏适应算法(Worst Fit)2、页面置换算法模拟先进先出页面置换算法(FIFO)最近最久未使用页面置换算法(LRU)时钟页面置换算法(Clock)四、实验原理1、内存分配与回收算法首次适应算法:从内存的起始位置开始,依次查找空闲分区,将第一个能够满足需求的空闲分区分配给进程。
最佳适应算法:在所有空闲分区中,选择能够满足需求且大小最小的空闲分区进行分配。
最坏适应算法:选择空闲分区中最大的分区进行分配。
2、页面置换算法先进先出页面置换算法:选择最早进入内存的页面进行置换。
最近最久未使用页面置换算法:选择最近最长时间未被访问的页面进行置换。
时钟页面置换算法:给每个页面设置一个访问位,在页面置换时,从指针指向的页面开始扫描,选择第一个访问位为0 的页面进行置换。
五、实验步骤1、内存分配与回收算法实现定义内存分区结构体,包括分区起始地址、大小、是否已分配等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
编写测试程序,创建多个进程,并使用不同的算法为其分配内存,观察内存分配情况和空闲分区的变化。
2、页面置换算法模拟定义页面结构体,包括页面号、访问位等信息。
实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。
编写测试程序,模拟页面的调入和调出过程,计算不同算法下的缺页率,比较算法的性能。
首次适应算法 实验报告
![首次适应算法 实验报告](https://img.taocdn.com/s3/m/8ec4a2c8b8d528ea81c758f5f61fb7360b4c2b8a.png)
首次适应算法实验报告引言首次适应算法(First Fit)是一种内存分配算法,用于解决操作系统中的内存管理问题。
在该算法中,操作系统将可用的内存空间分为若干个大小不等的分区,当一个新的作业需要分配内存时,算法通过在空闲分区列表中查找第一个能够满足作业大小的分区,找到第一个合适的位置将作业分配到该分区。
本次实验旨在通过调试和运行一个模拟的内存管理系统,了解首次适应算法的实现原理,并比较它与其他内存分配算法的性能差异。
实验环境- 操作系统:Windows 10- 开发语言:C++实验步骤和结果分析1. 设计数据结构我们首先设计了一个表示内存分区的数据结构`Partition`,包括以下成员变量:- `start`:表示分区的起始地址- `size`:表示分区的大小- `allocated`:表示分区是否已经分配给作业然后,我们设计了一个表示内存管理系统的数据结构`Memory`,包括以下成员变量:- `partitions`:表示分区列表,使用一个动态数组存储所有分区- `size`:表示内存总大小2. 实现首次适应算法在内存管理系统的实现中,我们通过设计一个`allocate`方法来实现首次适应算法的分配过程。
该方法接受一个作业的大小作为参数,返回一个指向分配的分区的指针。
如果找不到合适的分区,则返回`nullptr`。
首次适应算法的实现原理如下:- 遍历所有的分区,查找第一个未分配且大小大于作业大小的分区。
- 如果找到合适的分区,则将分区的`allocated`属性设置为`true`,表示已分配,并返回该分区的指针。
- 如果没有找到合适的分区,则返回`nullptr`。
3. 测试并分析结果在测试阶段,我们通过运行一系列的分配和释放操作来模拟作业的动态运行过程。
为了更好地观察内存的分配情况,我们将内存分为等大小的分区,并以图表的方式显示。
通过对不同大小的作业进行分配和释放测试,我们得到了如下结果:![内存分配示意图](memory_allocation.png)从上图可以看出,首次适应算法根据作业的大小选择不同的分区进行分配,确保了尽可能多地利用内存空间。
内存的分配与回收实验报告(最先适应法)
![内存的分配与回收实验报告(最先适应法)](https://img.taocdn.com/s3/m/d2cc6455be23482fb4da4c26.png)
代码实现如下:#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define n 64 //定义内存的大小int a[n],count=0;//数组a用来保存内存使用状况1为已分配0为未分配,count用来记name数组中元素个数char name[n];//已分配内存的名称(字符类型)typedef struct linknode{char pid;int start;int length;struct linknode *left,*right;}de_node; //进程节点结构体定义//head1表示未分配内存队列头指针,head2便是已分配进程队列头指针de_node *head1,*head2=NULL;struct linknode* creat()//创建一个进程节点{int len,flag1=1;//用于表示进程是否可以创建char id;struct linknode* p;p = (de_node *)malloc(sizeof(de_node));//试图在系统内存中开辟空间创建一个进程if (p==NULL) //p为空,说明系统没有可用内存用于创建此模拟进程{ printf("系统没有足够的内存可供使用!\n");//输出return(NULL);//返回空指针}printf("请输入进程id(字符类型)和长度:");//为进程输入id和分配的长度scanf("%c %d",&id,&len);fflush(stdin);//清除输入缓存if((id>='a'&&id<='z'||id>='A'&&id<='Z')&&(len>0)){for(int i=0;i<count;i++)//判断输入的进程名,如果已使用,返回空指针,并释放p指针if(name[i]==id){printf("此名称进程已存在!!");flag1=0;//标志位为0,表示下面对p指向内容不做修改free(p);return NULL;}if(len==0) {//如果输入要分配的进程长度为0,释放p,返回空指针printf("输入长度为0!\n");free(p);return(NULL);}if(flag1){//标志位1,可以对p指向内容进行修改p->pid=id; //idp->start=0; //初始开始内存位置,在以后会修改p->length=len;//长度p->left=NULL;//左指针p->right=NULL;//右指针name[count++]=id;//将id存入数组,count自加return(p);}//返回创建的进程的地址}else {printf("输入进程格式有误\n");free(p);return (NULL);}}//分配内存空间void distribute(de_node *p){ de_node *q=head1,*temp;int flag=0;do{//do_while循法//判断当前指向的内存空间的长度是否满足p所申请的长度,大于就分配if(q->length>=p->length) {p->start=q->start;//把进程的内存开始地址指向内存的可用开始地址处q->start+=p->length;//可用地址起始改变q->length-=p->length;//可用内存长度修改for(int i=p->start;i<p->start+p->length;i++)//将已分配的内存空间全部置1 a[i]=1;flag=1;//表示内存可分配//队列不止一个进程,第一个满足条件,并且刚好分配完,修改指针指向if(q->length==0&&q->right!=q) { if(q==head1)//如果第一个满足,修改头指针指向head1=q->right;q->left->right=q->right;q->right->left=q->left;free(q);//把这个已分配完的空间指针释放}}if(flag==1)//已做完处理直接跳出循环break;if(flag==0)//当前指向的内存不满足,指向下一个,继续判断是否满足q=q->right;}while(q!=head1);//搜索一遍可用内存序列if(flag==0){//没有可用的内存printf("没有满足的内存!\n");count--;//由于创建时加1,但在分配内存时失败,把1又减掉free(p);//把这个未分配到内存的进程释放}if(flag==1){//表示上面已分配好内存,并已修改内存链表,下面修改已分配内存的进程队列temp=head2;//把已分配内存的进程队列赋值给临时指针if(temp==NULL)//如果还还没有存在的任何的进程,说明当前是第一个{ head2=p;//让头指针指向第一个进程p->left=p;//双向队列第一个左右指针都指向自己p->right=p;//双向队列第一个左右指针都指向自己}else if(temp!=NULL){//已存在队列,把当前直接链到第一个,与上面的区别是指针指向head2=p;//让头指针指向p指向的进程p->left=temp->left;//p进程左边为原来第一个的左边p->right=temp;//p进程右边指向第一个temp->left->right=p;//原来第一个的左边为ptemp->left=p;//原来第一个的左边的进程为p}}}//对进程的回收void reclaim(){ char id;int flag=0;de_node *q=head2,*p=head1;if(head2==NULL)//表示当前没有进程{ printf("已没有进程!\n");}else {//已分配内存队列如果不为空printf("输入要回收的进程id:");//输入要回收进程的idscanf("%c",&id);fflush(stdin);for(int i=0;i<count;i++)//双重循环把要回收的进程找出来,并把记录的id去掉if(name[i]==id){//判断当前的进程是否满足要求for(int j=i;j<count;j++)name[j]=name[j+1];//向前覆盖name[j+1]=NULL;//置空count--;//减一}//判断是否总共只有一个进程且是够刚好也满足条件if(q->pid==id&&q->right==q&&head2==q){ head2=NULL;//把已分配队列直接置空flag=1;//表示找到满足条件的进程}if(flag==0){//上面的都没找到do{if(q->pid==id){//如果找到if(q==head2)head2=q->right;q->left->right=q->right;//修改指针指向q->right->left=q->left;flag=1;break;}else q=q->right;}while(q!=head2);}//如果找到或是遍历一遍结束if(flag==0) printf("没有此进程号!!!\n");//没有找到满足的进程if(flag==1){//表示找到了for(int i=q->start;i<q->start+q->length;i++)//释放占有的内存a[i]=0;//接下来修改可用内存的队列,while(q->start>p->start&&p->right!=head1){//从第一个开始找到回收回来的内存开始地址大的那个队列p=p->right;}if(p==head1)//表示比第一个的开始还小,那么就要修改头地址head1=q;//其他情况不用修改头地址,只需找到应该的位置,把此进程插进去q->left=p->left;//修改指针的指向q->right=p;p->left->right=q;p->left=q;if(q->start+q->length==p->start)//可以与后面合并的情况{ q->length+=p->length;//修改指针的指向p->right->left=q;q->right=p->right;free(p);}if(q->left->start+q->left->length==q->start)//可以与前面合并的情况{ q->left->length+=q->length;//修改指针的指向q->left->right=q->right;q->right->left=q->left;free(q);}}}}//打印输出void print(){ de_node *q=head2,*p=head1;if(count==0)printf("没有进程占有内存。
实验报告 可变分区 主存分配回收
![实验报告 可变分区 主存分配回收](https://img.taocdn.com/s3/m/d58e7bdad15abe23482f4d15.png)
printf("========================================\n");
printf("输入你的选择:\n");
scanf("%d",&j);
switch(j)
{
case 1:insertu(i);//为作业分配空间
//合并完之后的空闲分区的结束地址和相邻的空闲分区的起始地址也相连,则继续合并
{
fr[i].len=fr[i].len+fr[i+1].len;
for(k=i+1;k<m-1;k++)
{
fr[k].ad=fr[k+1].ad;
fr[k].len=fr[k+1].len;
fr[k].state=fr[k+1].state;
操作系统实验报告
设计题目
在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收
一、设计内容
主存储器空间的分配和回收。
二、设计目的
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的,通过本实习帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
{
while(fr[i].state!='M')
内存的分配与回收实验报告
![内存的分配与回收实验报告](https://img.taocdn.com/s3/m/355aeb5eb6360b4c2e3f5727a5e9856a561226a1.png)
内存的分配与回收实验报告实验目的:了解计算机内存分配与回收的原理及实现方式,掌握最先适应算法的具体实现,加深对内存管理的理解。
实验原理:内存是计算机系统中的关键组成部分之一,它负责存储程序运行所需的数据和指令。
为了有效管理内存,将其划分为若干个固定大小的单元,称为分配单元。
内存分配与回收的基本原则是尽量高效地利用内存空间。
最先适应算法是一种常用的内存分配算法,它的基本思想是按照内存地址从小到大的顺序,依次寻找满足分配要求的第一个空闲分区。
因为每次分配都是从低地址开始,所以能够尽量填满被回收后的可用内存空间。
实验步骤:1.定义内存块的数据结构,包括起始地址、大小、状态等信息。
2.初始化内存,划分出若干个固定大小的内存块。
3.从给定的进程请求中获取进程需要的内存大小。
4.遍历内存块列表,寻找第一个满足分配要求的空闲分区,即大小大于等于进程需求的分区。
5.如果找到了满足要求的分区,则将其划分为两个分区,一个用于分配给进程,一个作为剩余的空闲分区。
6.更新内存块列表,记录分配给进程的内存块。
7.如果没有找到满足要求的分区,则返回分配失败的信息。
8.进程完成运行后,将其占用的内存块标记为空闲,并进行合并操作,合并相邻的空闲分区。
9.更新内存块列表,记录回收的内存块。
10.重复步骤3至步骤9,直到完成所有的进程请求。
实验结果:经过多次实验,使用最先适应算法进行内存分配与回收,可以有效地利用内存空间,提高内存利用率。
实验总结:通过本次实验,我深入理解了最先适应算法的实现原理和逻辑流程。
在实际的内存管理中,我们需要根据实际情况选择合适的内存分配策略,以避免出现内存碎片和浪费现象。
同时,回收后的内存块需要及时进行合并操作,以提高内存的利用率。
实验过程中还发现,在有大量并发的情况下,最先适应算法可能会产生较多的内存碎片,影响内存的使用效率,因此需要根据实际情况选择其他适合的内存分配算法。
总之,通过这次实验,我对内存分配与回收有了更深入的理解,对内存管理算法的选择和优化也更加清晰,为以后的实际应用打下了基础。
(实验3)在可变分区管理方式下采用最先适应算法实现主存分配与回收
![(实验3)在可变分区管理方式下采用最先适应算法实现主存分配与回收](https://img.taocdn.com/s3/m/b7d494d0102de2bd9705881b.png)
实验3 内存管理一、实验内容选择一种算法在可变分区管理方式下对内存进行管理 二、实验目的掌握可变分区内存管理方式,能熟练运用内存管理的各种算法对内存进行分配和回收。
三、实验题目在可变分区管理方式下采用最先适应算法实现主存分配与回收 [提示]:可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。
随着作业的装入、撤离,主为了说明哪些区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,格式如下:第一栏 第二栏其中,起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区;另一种是“空表目”状态,表示表中对应的登记项目是空白(无效),可用来登记新的空闲区(例如,作业撤离后,它所占的区域就成了空闲区,应找一个“空表目”栏登记归还区的起址和长度且修改状态)。
由于分区的个数不定,所以空闲区说明表中应有适量的状态为“空表目”的登记栏目,否则造成表格“溢出”无法登记。
上述的这张说明表的登记情况是按提示(1)中的例所装入的三个作业占用的主存区域后填写的。
(2) 当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业需要量,这时应把原来的空闲区变成两部分:一部分分给作业占用;另一部分又成为一个较小的空闲区。
为了尽量减少由于分割造成的空闲区,而尽量保存高地址部分有较大的连续空闲区域,以利于大型作业的装入。
为此,在空闲区说明表中,把每个空闲区按其地址顺序登记,即每个后继的空闲区其起始地址总是比前者大。
为了方便查找还可使表格“紧缩”,总是让“空表目”栏集中在表格的后部。
(3) 采用最先适应算法(顺序分配算法)分配主存空间。
内存分配实验报告总结(3篇)
![内存分配实验报告总结(3篇)](https://img.taocdn.com/s3/m/c24a8c7b11a6f524ccbff121dd36a32d7275c755.png)
第1篇一、实验目的本次实验旨在让学生深入理解内存分配的基本原理和不同分配算法,通过实际操作,提高学生对内存管理技术的掌握程度。
通过本次实验,我们希望达到以下目标:1. 熟悉内存分配的基本概念和过程;2. 掌握常见的内存分配算法,如首次适应算法、最佳适应算法和最坏适应算法;3. 理解内存分配中的碎片问题,并尝试解决;4. 培养学生的动手实践能力和问题解决能力。
二、实验内容1. 实验环境:使用C语言编写程序,运行在Linux操作系统上。
2. 实验步骤:(1)首次适应算法:从内存空间的起始位置开始查找,找到第一个满足申请大小的空闲分区,将其分配给请求者。
(2)最佳适应算法:从所有空闲分区中查找一个最小的满足申请大小的分区,将其分配给请求者。
(3)最坏适应算法:从所有空闲分区中查找一个最大的满足申请大小的分区,将其分配给请求者。
(4)解决内存碎片问题:采用紧凑算法,将所有空闲分区合并成一个连续的大空间,从而减少内存碎片。
三、实验过程1. 编写程序实现内存分配算法,包括内存初始化、申请内存、释放内存等功能。
2. 对不同分配算法进行测试,观察分配效果,分析不同算法的优缺点。
3. 分析内存碎片问题,尝试解决方法,如紧凑算法。
四、实验结果与分析1. 首次适应算法:该算法简单易实现,但可能导致内存利用率较低,且可能产生较大的内存碎片。
2. 最佳适应算法:该算法分配效果较好,内存利用率较高,但分配速度较慢。
3. 最坏适应算法:该算法分配效果较差,内存利用率较低,但分配速度较快。
4. 紧凑算法:通过合并空闲分区,减少了内存碎片,提高了内存利用率。
五、实验体会1. 通过本次实验,我们深入了解了内存分配的基本原理和不同分配算法,掌握了常见内存分配算法的优缺点。
2. 实验过程中,我们遇到了各种问题,如内存碎片问题、算法实现问题等,通过查阅资料、讨论和尝试,最终解决了这些问题,提高了我们的问题解决能力。
3. 实验使我们认识到,内存管理是操作系统中的一个重要组成部分,对计算机性能和稳定性有着重要影响。
主存储器空间的分配和回收实验报告
![主存储器空间的分配和回收实验报告](https://img.taocdn.com/s3/m/5a70967d0812a21614791711cc7931b765ce7b09.png)
主存储器空间的分配和回收实验报告主存储器是计算机中一种重要的存储设备,它用于存储程序的指令和数据。
在计算机系统中,主存储器的空间分配和回收是一个关键的问题。
为了研究主存储器空间的分配和回收,我们进行了一系列实验。
实验目的:1.了解主存储器的空间分配和回收原理;2.掌握主存储器空间分配和回收的算法和方法;3.借助实验了解主存储器空间分配和回收对系统性能的影响。
实验步骤:1.设计一个模拟的主存储器,包括地址空间和物理存储空间。
我们将地址空间划分为多个固定大小的块,每个块对应一个页面。
2.实现主存储器的空间分配算法。
我们选择了最先适应算法,即从低地址开始寻找第一个可以容纳所需页面的空闲块。
3.实现主存储器的空间回收算法。
我们选择了简单的空闲块链表算法,即将回收的空间加入到一个空闲块链表中。
4.编写测试程序,模拟实际系统中的内存分配和回收操作。
测试程序包括创建新进程,分配内存空间,释放内存空间等操作。
5.对测试程序进行性能评测,比较不同算法和策略下的主存储器使用效率和系统性能。
实验结果:通过对实验数据的分析和对比,我们得出了以下结论:1.最先适应算法在空间分配方面具有较好的效果,能够快速找到合适的空闲块。
2.简单的空闲块链表算法能够有效地回收空间,减少内存碎片的产生。
3.不同的内存分配策略会对系统性能产生影响,合理选择内存管理算法是提高系统性能的关键。
结论:本次实验通过对主存储器空间的分配和回收进行实验研究,掌握了主存储器空间分配和回收的算法和方法,并通过实验结果对主存储器的性能进行了评估和分析。
实验结果表明最先适应算法和简单的空闲块链表算法是有效的方法,能够提高主存储器的使用效率和系统性能。
在实际系统中,我们需要根据具体情况选择合适的算法和策略,以满足系统的需求。
操作系统实验报告可变分区存储管理方式的内存分配回收
![操作系统实验报告可变分区存储管理方式的内存分配回收](https://img.taocdn.com/s3/m/8b2f9ceef424ccbff121dd36a32d7375a417c6d1.png)
操作系统实验报告可变分区存储管理方式的内存分配回收可变分区存储管理方式是一种常见的内存分配和回收策略,通过将内存分成若干大小不等的分区,分配给不同大小的进程使用。
本文将对可变分区存储管理方式的内存分配和回收进行详细介绍。
首先,可变分区存储管理方式需要对内存进行划分,将内存分成若干个大小不等的分区。
这些分区可以是固定大小的,也可以是可变大小的。
当进程申请内存时,系统会根据申请内存的大小来选择一个合适大小的分区进行分配。
分配时分为两种情况:首次适应和最佳适应。
首次适应算法是指从内存的起始位置开始遍历分区,找到第一个能满足进程要求的分区进行分配。
这种算法的优点是找到满足条件的分区速度较快,缺点是容易造成较大的内存碎片。
最佳适应算法是指通过遍历整个内存,找到一个大小最接近进程要求的分区进行分配。
这种算法的优点是能够减小内存碎片的产生,但是分配速度较慢。
当进程结束时,需要回收其占用的内存。
对于可变分区存储管理方式,在回收内存时出现了两种情况:内部碎片和外部碎片。
内部碎片是指分配给进程的分区中,有一部分空闲内存无法被其他进程利用。
这是因为当一些进程需要分配内存时,分配的大小可能大于其实际需要的大小,导致分区中留下了空余空间。
解决内部碎片的方法是动态地调整分区的大小,使其能够更好地适应进程的大小需求。
外部碎片是指存储空闲的分区之间的一些不可利用的内存。
当进程需要分配内存时,可能没有一个分区能满足其大小需求,导致无法分配内存。
解决外部碎片的方法是内存紧缩和分区合并。
内存紧缩是指将内存中的进程向一端移动,使剩余的空闲内存空间连在一起。
这样可以使得所有的空闲内存空间都可以被利用,减少外部碎片的产生。
分区合并是指将不连续的空闲分区进行合并,形成更大的连续空闲分区。
这样可以提供给大型进程使用,减少外部碎片的产生。
综上所述,可变分区存储管理方式的内存分配和回收是一个动态的过程,需要根据进程的需求进行灵活地管理。
它可以通过首次适应或最佳适应算法选择合适的分区进行内存分配,通过动态调整分区大小解决内部碎片问题,并通过内存紧缩和分区合并减少外部碎片的产生。
操作系统之内存分配与回收
![操作系统之内存分配与回收](https://img.taocdn.com/s3/m/fa679a216137ee06eef9184a.png)
操作系统实验内存的分配与回收实验报告一、实验题目:内存的分配与回收二、实验内容:利用可变分区的首次适应算法,模拟内存的分配与回收。
三、实验目的:掌握可变分区首次适应算法的原理以及其编程实现。
四、实验过程:1、基本思想:可变分区分配是根据进程的实际需求,动态地为之分配内存空间。
首次适应算法要求空闲空间链以地址递增的次序链接。
进行内存分配时,从链表头部开始依次检索,找到第一个不小于请求空间大小的空闲空间进行分配。
分配时需考虑碎片问题,若分配会导致碎片产生则将整块分区分配。
内存的回收需要考虑四种情况:⑴回收分区前后两个分区都空闲,则需要和前后两个分区合并;(2)回收分区只有前一分区空闲,则与前一分区合并;(3)回收分区只有后一分区空闲,则和后一分区合并;(4)回收分区独立,不考虑合并。
2、主要数据结构:struct FreeArea{ 链结点包含的数据:分区号、大小、起址、标记int ID;int size;long address;int sign;};struct Node { 双链表结点结构体:数据区、前向指针、后继指针FreeArea data;struct Node *prior;struct Node *next;}*DLinkList;3、输入、输出:输入: I.内存分配时由键盘输入分区ID和大小;II.内存回收时由键盘输入需要回收的分区ID;输出:输出内存的分配情况(按照地址从低到高)4、程序流程图:5、实验结果截屏:6、源程序代码:#include<iostream>using namespace std;#define Free 0 //空闲状态#define Busy 1 //已用状态#define PBusy 2 //碎片已用状态#define FINISH 1 //完成#define FINISH2 1 //完成#define ERROR 0 //出错#define memory 512 //最大内存空间为(单位:KB)#define min 10 //碎片最小值(单位:KB)typedef struct FreeArea//空闲链数据{int ID;int size;long address;int sign;};typedef struct Node//空闲连结构{FreeArea data;struct Node *prior;struct Node *next;}*DLinkList;DLinkList head; //头结点DLinkList tail; //尾结点int Create()//初始化{head=(DLinkList)malloc(sizeof(Node));//分配内存tail=(DLinkList)malloc(sizeof(Node));head->prior=NULL;head->next=tail;tail->prior=head;tail->next=NULL;tail->data.address=0;tail->data.size=memory;tail->data.ID=0;tail->data.sign=Free;return FINISH;}int FirstFit(int ID,int request)//首次适应算法{DLinkList temp=(DLinkList)malloc(sizeof(Node));//新建作业的结点temp->data.ID=ID;temp->data.size=request;temp->data.sign=Busy;Node *p=head;//插入指针Pwhile(p){if(p->data.sign==Free && p->data.size==request)//剩余大小恰好满足{p->data.sign=Busy;p->data.ID=ID;return FINISH;break;}else if(p->data.sign==Free&& p->data.size>request&& (p->data.size-request>min))//满足需求且有剩余且不产生碎片{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=p->data.size-request;return FINISH;break;}else if(p->data.sign==Free&& p->data.size>request&& p->data.size-request<=min)//产生碎片时{p->data.sign=PBusy;p->data.ID=ID;return FINISH;break;}p=p->next;//若前面的分区都已分配,P指针后移}return ERROR;}int Allocate()//主存分配{int ID,request;cout<<"请输入作业所在分区号:";cin>>ID;cout<<"请输入分配的主存(单位:KB):";cin>>request;if(request<0 ||request==0){cout<<"分配的主存必须是正整数!"<<endl;return ERROR;}if(FirstFit(ID,request)==FINISH)cout<<"分配成功!"<<endl;elsecout<<"内存不足,分配失败!"<<endl;}int Recycle(int ID)//回收{Node *p=head;while(p){if(p->data.ID==ID){p->data.sign=Free;//p->data.ID=Free;if((p->prior->data.sign==Free)&&(p->next->data.sign==Free))//与前后的空闲块相连{p->prior->data.size=p->prior->data.size+p->data.size+p->next->data.size;p->prior->next=p->next->next;if(p->next->next==NULL)//若p->next是最后一个结点{p->prior->data.ID=Free;p->next=NULL;}else{p->next->next->prior=p->prior;}break;}if(p->prior->data.sign==Free)//与前面的空闲块相连{p->prior->data.size+=p->data.size;p->prior->next=p->next;p->next->prior=p->prior;break;}if(p->next->data.sign==Free)//与后面的空闲块相连{p->data.size+=p->next->data.size;if(p->next->next==NULL)//若p->next是最后一个结点p->next=NULL;else{p->next->next->prior=p;p->next=p->next->next;}break;}break;}p=p->next;}cout<<"分区:"<<ID<<"回收成功"<<endl;return FINISH;}void show()//显示{cout<<" 主存分配情况\n";Node *p=head->next;while(p){cout<<"分区号:";if(p->data.ID==Free)cout<<"Free"<<endl;elsecout<<p->data.ID<<endl;cout<<"起始地址:"<<p->data.address;cout<<" 分区大小:"<<p->data.size<<" KB";cout<<" 状态:";if(p->data.sign==Free)cout<<"空闲"<<endl;else if(p->data.sign==PBusy)cout<<"碎片已分配"<<endl;elsecout<<"已分配"<<endl;p=p->next;}cout<<endl;}void main(){Create();int choice;int i;for(i=0;;i++){cout<<"请输入操作:";cout<<"1.分配内存 2.回收内存 3.显示主存0.退出";cout<<endl;cin>>choice;if(choice==1)// 分配内存Allocate();else if(choice==2)// 内存回收{ i nt ID;cout<<"请输入要释放的分区号:";cin>>ID;Recycle(ID);}else if(choice==3)//显示主存show();else if(choice==0)//退出break;else//非法输入{cout<<"输入有误!"<<endl;continue;}}}。
内存分配,首次适应算法
![内存分配,首次适应算法](https://img.taocdn.com/s3/m/e7c704a55a8102d277a22f3d.png)
一、实验名称:内存分配与回收二、实验内容:用首次适应算法实现存储空间的分配,回收作业所占用的存储空间。
三、实验目的:一个好的计算机系统不仅要有足够的存储容量,较高的存取速度和稳定可靠的存储器,而且能够合理的分配和使用这些主存空间。
当用户提出申请主存空间的要求时,存储管理能够按照一定的策略分析主存的使用情况,找出足够的空间分配给申请者;当作业运行完毕,存储管理要回收作业占用的主存空间。
本实验实现在可变分区存储管理方式下,采用最先适应算法对主存空间进行分配和回收,以加深了解操作系统的存储管理功能。
四、实验过程:a)基本思想空闲分区链以地址递增的次序连接。
在分配内存时,从链首开始顺序查找,直至找到一个大小能够满足要求的空闲分区为止;然后再按照作业大小,从该分区中划出一块内存空间分配给请求者,余下的空闲分区仍然留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区,则此次内存分配失败。
b)主要数据结构typedef struct FreeLink{#include <>#include <>using namespace std;typedef struct FreeLink{配内存"<<endl;cout<<"2.回收内存"<<endl;cout<<"3.结束操作"<<endl;cout<<"请输入你的选择:";cin>>choice;}while(choice!='1'&&choice!='2'&&choice!='3');switch(choice){case '1':allocate(p);print();break;case '2':huishou(p);print();break;case '3':clear();return 0;break;}}}int main(){//主函数ptr free=(FreeLink *)malloc(sizeof(FreeLink));top=free;top->name='*';top->start=0;top->size=256;top->flag=false;top->prior=NULL;top->next=NULL;cout<<endl;cout<<"************************ 首次适应算法************************"<<endl;cout<<endl;firstfit();}六、实验小结通过本实验,深刻地理解到了利用可变分区,采用首次适应算法为作业分配内存的过程。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
代码实现如下:#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define n 64 //定义内存的大小int a[n],count=0;//数组a用来保存内存使用状况1为已分配0为未分配,count用来记name数组中元素个数char name[n];//已分配内存的名称(字符类型)typedef struct linknode{char pid;int start;int length;struct linknode *left,*right;}de_node; //进程节点结构体定义//head1表示未分配内存队列头指针,head2便是已分配进程队列头指针de_node *head1,*head2=NULL;struct linknode* creat()//创建一个进程节点{int len,flag1=1;//用于表示进程是否可以创建char id;struct linknode* p;p = (de_node *)malloc(sizeof(de_node));//试图在系统内存中开辟空间创建一个进程if (p==NULL) //p为空,说明系统没有可用内存用于创建此模拟进程{ printf("系统没有足够的内存可供使用!\n");//输出return(NULL);//返回空指针}printf("请输入进程id(字符类型)和长度:");//为进程输入id和分配的长度scanf("%c %d",&id,&len);fflush(stdin);//清除输入缓存if((id>='a'&&id<='z'||id>='A'&&id<='Z')&&(len>0)){for(int i=0;i<count;i++)//判断输入的进程名,如果已使用,返回空指针,并释放p指针if(name[i]==id){printf("此名称进程已存在!!");flag1=0;//标志位为0,表示下面对p指向内容不做修改free(p);return NULL;}if(len==0) {//如果输入要分配的进程长度为0,释放p,返回空指针printf("输入长度为0!\n");free(p);return(NULL);}if(flag1){//标志位1,可以对p指向内容进行修改p->pid=id; //idp->start=0; //初始开始内存位置,在以后会修改p->length=len;//长度p->left=NULL;//左指针p->right=NULL;//右指针name[count++]=id;//将id存入数组,count自加return(p);}//返回创建的进程的地址}else {printf("输入进程格式有误\n");free(p);return (NULL);}}//分配内存空间void distribute(de_node *p){ de_node *q=head1,*temp;int flag=0;do{//do_while循法//判断当前指向的内存空间的长度是否满足p所申请的长度,大于就分配if(q->length>=p->length) {p->start=q->start;//把进程的内存开始地址指向内存的可用开始地址处q->start+=p->length;//可用地址起始改变q->length-=p->length;//可用内存长度修改for(int i=p->start;i<p->start+p->length;i++)//将已分配的内存空间全部置1 a[i]=1;flag=1;//表示内存可分配//队列不止一个进程,第一个满足条件,并且刚好分配完,修改指针指向if(q->length==0&&q->right!=q) { if(q==head1)//如果第一个满足,修改头指针指向head1=q->right;q->left->right=q->right;q->right->left=q->left;free(q);//把这个已分配完的空间指针释放}}if(flag==1)//已做完处理直接跳出循环break;if(flag==0)//当前指向的内存不满足,指向下一个,继续判断是否满足q=q->right;}while(q!=head1);//搜索一遍可用内存序列if(flag==0){//没有可用的内存printf("没有满足的内存!\n");count--;//由于创建时加1,但在分配内存时失败,把1又减掉free(p);//把这个未分配到内存的进程释放}if(flag==1){//表示上面已分配好内存,并已修改内存链表,下面修改已分配内存的进程队列temp=head2;//把已分配内存的进程队列赋值给临时指针if(temp==NULL)//如果还还没有存在的任何的进程,说明当前是第一个{ head2=p;//让头指针指向第一个进程p->left=p;//双向队列第一个左右指针都指向自己p->right=p;//双向队列第一个左右指针都指向自己}else if(temp!=NULL){//已存在队列,把当前直接链到第一个,与上面的区别是指针指向head2=p;//让头指针指向p指向的进程p->left=temp->left;//p进程左边为原来第一个的左边p->right=temp;//p进程右边指向第一个temp->left->right=p;//原来第一个的左边为ptemp->left=p;//原来第一个的左边的进程为p}}}//对进程的回收void reclaim(){ char id;int flag=0;de_node *q=head2,*p=head1;if(head2==NULL)//表示当前没有进程{ printf("已没有进程!\n");}else {//已分配内存队列如果不为空printf("输入要回收的进程id:");//输入要回收进程的idscanf("%c",&id);fflush(stdin);for(int i=0;i<count;i++)//双重循环把要回收的进程找出来,并把记录的id去掉if(name[i]==id){//判断当前的进程是否满足要求for(int j=i;j<count;j++)name[j]=name[j+1];//向前覆盖name[j+1]=NULL;//置空count--;//减一}//判断是否总共只有一个进程且是够刚好也满足条件if(q->pid==id&&q->right==q&&head2==q){ head2=NULL;//把已分配队列直接置空flag=1;//表示找到满足条件的进程}if(flag==0){//上面的都没找到do{if(q->pid==id){//如果找到if(q==head2)head2=q->right;q->left->right=q->right;//修改指针指向q->right->left=q->left;flag=1;break;}else q=q->right;}while(q!=head2);}//如果找到或是遍历一遍结束if(flag==0) printf("没有此进程号!!!\n");//没有找到满足的进程if(flag==1){//表示找到了for(int i=q->start;i<q->start+q->length;i++)//释放占有的内存a[i]=0;//接下来修改可用内存的队列,while(q->start>p->start&&p->right!=head1){//从第一个开始找到回收回来的内存开始地址大的那个队列p=p->right;}if(p==head1)//表示比第一个的开始还小,那么就要修改头地址head1=q;//其他情况不用修改头地址,只需找到应该的位置,把此进程插进去q->left=p->left;//修改指针的指向q->right=p;p->left->right=q;p->left=q;if(q->start+q->length==p->start)//可以与后面合并的情况{ q->length+=p->length;//修改指针的指向p->right->left=q;q->right=p->right;free(p);}if(q->left->start+q->left->length==q->start)//可以与前面合并的情况{ q->left->length+=q->length;//修改指针的指向q->left->right=q->right;q->right->left=q->left;free(q);}}}}//打印输出void print(){ de_node *q=head2,*p=head1;if(count==0)printf("没有进程占有内存。
\n");else{ printf("输出进程id号:\n");for(int i=0;i<count;i++)printf("%c\t",name[i]);}printf("\n");printf("输出内存当前使用情况:\n");for(int j=0;j<n;j++)printf("%d %d\t",j,a[j]);printf("\n");printf("内存初始名称为i,回收后可能会变,可以查看回收来自那个进程\n");do //输出可用内存序列{ if(p!=NULL){ printf("进程id:%c 开始地址:%d 长度%d\n",p->pid,p->start,p->length);p=p->right;}}while(p!=head1);printf("\n");printf("已分配进程队列:\n");do //已分配进程队列{if(q!=NULL){printf("进程id:%c 开始地址:%d 长度%d\n",q->pid,q->start,q->length);q=q->right;}}while(q!=head2);}//主函数void main(){ int x;de_node *point,*p1;//创建内存的初始状态point=(struct linknode*)malloc(sizeof(struct linknode)); head1=point;point->pid='i';point->start=0;point->length=n;head1->left=point;head1->right=point;print();while(1){printf(" ------MENU-------\n");printf("1----distribute(分配)\n");printf("2----reclaim(回收)\n");printf("3----view (浏览)\n");printf("4----exit(退出)\n");printf("请输入上面的选项(1--4):\n");scanf("%d",&x);fflush(stdin);switch(x){case 1:{ p1=creat();if(p1==NULL) printf("创建进程失败。