实验4 内存管理
内存管理实验报告
图 2 MEM_COMMIT
图 3 MEM_RELEASE
操作系统实验——内存管理
计算机 B 班 吴为丹 033511081
图 4 LOCK
图 5 UNLOCK
图 6 MEM_RESET
图 7 MEM_TOP_DOWN 操作失败
d) 有以下几种情况时,操作没有进行,要求释放内存而没有已经分配的内存;要求回 收内存而没有已经保留或分配的内存;要求加锁而没有已经分配的内存;要求解锁而没 有已经加锁的内存。如图 3、图 4 和图 5 所示。
z 实验改进
增加内存分配的类型,如 MEM_TOP_DOWN、MEM_RESET,增加保护级别的类型,如 PAGE_GUARD、PAGE_NOACCESS、PAGE_NOCACHE,运行结果正常,如上图所示。
8) WaitForMultipleObjects 函数功能:当满足下列条件之一时返回:(1)任意一个或全部指定对象处于信号态;(2)超 时。 在本实验中用于结束主程序。 函数原型:DWORD WaitForMultipleObject(DWORD ncount, CONST HANDLE *lpHandles, BOOL fWaitAll, DWORD dwMilliseconds);
// 2:释放(释放已分配内存,但仍然保留); // 3:回收(回收已分配或已保留内存);4:加锁;5:解锁 // 具体数值见数组 TYPE(main.cpp) int Protect; // 0:PAGE_READONLY;1:PAGE_READWRITE;2:PAGE_EXECUTE;
// 3:PAGE_EXECUTE_READ;4:PAGE_EXECUTE_READWRITE // 具体数值见数组 PRO(main.cpp) }; 2) 内存块 struct RESER{ //记录已保留内存 LPVOID lpvoid; DWORD size; }; struct COMMIT{ //记录已分配内存 LPVOID lpvoid; DWORD size; }; struct LOCK{ //记录已加锁内存 LPVOID lpvoid; DWORD size; }; 3. 相关 windows API 函数 1) GlobalMemoryStatus 函数功能:获得计算机系统中当前使用的物理内存和虚拟内存的信息 函数原型:VOID GlobalMemoryStatus (LPMEMORYSTATUS lpBuffer); 函数参数:lpBuffer 是指向 MEMORYSTATUS 结构的指针,_MEMORYSTATUS 结构用来存 储系统内存信息,具体内容见下文“相关数据结构”。 返回值:无(在结构变量中)
内存管理实验报告总结(3篇)
第1篇一、实验背景随着计算机技术的发展,内存管理在操作系统中的地位日益重要。
为了加深对内存管理方案的理解,熟悉虚存管理的各种页面淘汰算法,以及加强对地址转换过程的了解,我们进行了内存管理实验。
二、实验目的1. 通过编写和调试存储管理的模拟程序,加深对存储管理方案的理解;2. 熟悉虚存管理的各种页面淘汰算法;3. 通过编写和调试地址转换过程的模拟程序,加强对地址转换过程的了解。
三、实验内容1. 设计一个请求页式存储管理方案,并编写模拟程序实现;2. 产生一个需要访问的指令地址流,其中50%的指令是顺序执行的,25%的指令均匀地散布在前地址部分,25%的地址是均匀地散布在后地址部分;3. 采用FIFO页面淘汰算法,并在淘汰一页时,只将该页在页表中抹去,不再判断它是否被改写过,也不将它写回到辅存;4. 通过模拟程序,计算不同页面淘汰算法的命中率,并分析用户内存容量对命中率的影响。
四、实验过程1. 设计请求页式存储管理方案,包括页面大小、内存页表的最大长度等参数;2. 编写模拟程序,实现请求页式存储管理方案;3. 生成指令地址流,包括顺序执行、均匀分布在前地址部分和均匀分布在后地址部分的指令;4. 模拟程序运行,观察页面淘汰算法的执行过程,并记录页面失效次数;5. 计算不同页面淘汰算法的命中率,并分析用户内存容量对命中率的影响。
五、实验结果与分析1. 通过实验,我们成功实现了请求页式存储管理方案,并生成了指令地址流;2. 在实验过程中,我们使用了FIFO页面淘汰算法,发现该算法在页面访问局部性较好时,命中率较高;3. 当用户内存容量较小时,页面失效次数较多,导致命中率降低;4. 随着用户内存容量的增加,页面失效次数逐渐减少,命中率逐渐提高。
六、实验结论1. 通过本次实验,我们对内存管理方案有了更深入的理解,熟悉了虚存管理的各种页面淘汰算法;2. 实验结果表明,FIFO页面淘汰算法在页面访问局部性较好时,具有较高的命中率;3. 用户内存容量对页面淘汰算法的命中率有较大影响,随着内存容量的增加,命中率逐渐提高。
操作系统“内存管理”实验报告
initpart();
printf("\t****************Hale Waihona Puke ***********MENU**
**************************\n");
printf("\t************** Enter: r 请求分配内存**************\n");
%d\n",pcbl->PCBelem[i].name,pcbl->
PCBelem[i].address,pcbl->PCBelem[i].len);
}
printf("当前的空闲分区有:\n");
printf("address length\n");
for(i=0;i<maxPart;i++)
{
if(partl->Partelem[i].valid==1)
for(i=1;i<maxPart;i++)
{
partl->Partelem[i].address=0;
partl->Partelem[i].len=0;
partl->Partelem[i].valid=0;
}
partl->sum=1;
}
voidrequest(charname,intlen)//进程name请求len大小的内存
printf("\t************** Enter: s 结束进程 **************\n");
printf("\t************** Enter: p 打印分配情况**************\n");
内存管理实验报告
内存管理实验报告内存管理实验报告引言内存管理是计算机系统中非常重要的一部分,它负责管理计算机系统的内存资源,为程序的运行提供必要的支持。
本次实验旨在探究不同的内存管理策略对计算机系统性能的影响,以及如何优化内存管理以提高系统效率。
一、实验背景计算机系统中的内存是用于存储程序和数据的关键资源。
在多道程序设计环境下,多个程序需要共享有限的内存资源,因此需要一种有效的内存管理策略来分配和回收内存空间。
本次实验中,我们将研究并比较两种常见的内存管理策略:固定分区和动态分区。
二、实验过程1. 固定分区固定分区是将内存划分为固定大小的若干区域,每个区域可以容纳一个程序。
在实验中,我们将内存划分为三个固定大小的区域,并将三个不同大小的程序加载到内存中进行测试。
通过观察程序的运行情况和内存利用率,我们可以评估固定分区策略的优缺点。
2. 动态分区动态分区是根据程序的大小动态地分配内存空间。
在实验中,我们将使用首次适应算法来实现动态分区。
首次适应算法将按照程序的大小从低地址开始查找可以容纳该程序的空闲分区,并分配给程序使用。
通过观察动态分区策略下的内存利用率和碎片情况,我们可以评估该策略的优劣。
三、实验结果1. 固定分区在固定分区策略下,我们观察到每个程序都能够顺利运行,但是内存利用率较低。
由于每个程序都需要占用一个固定大小的分区,当程序大小与分区大小不匹配时,会出现内存浪费的情况。
此外,固定分区策略也存在无法分配较大程序的问题。
2. 动态分区在动态分区策略下,我们观察到内存利用率较高,碎片情况也较少。
由于动态分区可以根据程序的大小动态分配内存空间,因此可以更加高效地利用内存资源。
然而,动态分区策略也存在着内存分配和回收的开销较大的问题。
四、实验总结通过本次实验,我们对固定分区和动态分区两种内存管理策略进行了比较和评估。
固定分区策略适用于程序大小已知且固定的情况,但会导致内存浪费;而动态分区策略可以更加灵活地分配内存空间,但会增加内存分配和回收的开销。
内存管理实验报告
内存管理实验报告实验名称:内存管理实验目的:掌握内存管理的相关概念和算法加深对内存管理的理解实验原理:内存管理是操作系统中的一个重要模块,负责分配和回收系统的内存资源。
内存管理的目的是高效地利用系统内存,提高系统的性能和稳定性。
实验过程:1.实验环境准备本实验使用C语言编程,要求安装GCC编译器和Linux操作系统。
2.实验内容实验主要包括以下几个部分:a.基本内存管理创建一个进程结构体,并为其分配一定大小的内存空间。
可以通过C语言中的指针操作来模拟内存管理的过程。
b.连续分配内存算法实现两种连续分配内存的算法:首次适应算法和最佳适应算法。
首次适应算法是从低地址开始寻找满足要求的空闲块,最佳适应算法是从所有空闲块中选择最小的满足要求的块。
c.非连续分配内存算法实现分页和分段两种非连续分配内存的算法。
分页是将进程的虚拟地址空间划分为固定大小的页面,然后将页面映射到物理内存中。
分段是将进程的地址空间划分为若干个段,每个段可以是可变大小的。
3.实验结果分析使用实验中的算法和方法,可以实现对系统内存的高效管理。
通过比较不同算法的性能指标,我们可以选择合适的算法来满足系统的需求。
具体而言,连续分配内存算法中,首次适应算法适用于内存中有大量小碎片的情况,可以快速找到满足要求的空闲块。
最佳适应算法适用于内存中碎片较少的情况,可以保证最小的内存浪费。
非连续分配内存算法中,分页算法适用于对内存空间的快速分配和回收,但会带来一定的页表管理开销。
分段算法适用于对进程的地址空间进行分段管理,可以灵活地控制不同段的权限和大小。
实验中还可以通过性能测试和实际应用场景的模拟来评估算法的性能和适用性。
实验总结:本实验主要介绍了内存管理的相关概念和算法,通过编写相应的代码实现了基本内存管理和连续分配、非连续分配内存的算法。
通过实际的实验操作,加深了对内存管理的理解。
在实验过程中,我们发现不同算法适用于不同情况下的内存管理。
连续分配算法可以根据实际情况选择首次适应算法或最佳适应算法。
操作系统存储管理实验报告
操作系统存储管理实验报告一、实验目的本次实验的目的是通过编写一段程序,实现对内存的分配和回收操作,并验证算法的正确性和性能。
二、实验内容1.实现首次适应算法首次适应算法是一种动态分配的内存管理算法,通过从低地址往高地址内存块,找到第一个满足需求的空闲块进行分配。
具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,根据需求大小找到第一个合适的空闲块,并在其前后设置相应的标志位;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。
2.实现最佳适应算法最佳适应算法是一种动态分配的内存管理算法,通过整个内存空间,找到最小的满足需求的空闲块进行分配。
具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,遍历整个内存空间,找到满足需求且大小最小的空闲块进行分配;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。
三、实验结果1.首次适应算法经过测试,首次适应算法能够正确地进行内存的分配和回收操作,并且算法的性能良好。
尽管首次适应算法在分配过程中可能会产生碎片,但是由于它从低地址开始,可以在较短的时间内找到满足需求的空闲块。
在实际应用中,首次适应算法被广泛采用。
2.最佳适应算法经过测试,最佳适应算法能够正确地进行内存的分配和回收操作,并且算法的性能较好。
最佳适应算法会整个内存空间,找到大小最小的满足需求的空闲块。
因此,在分配过程中不会产生很多的碎片,但是算法的执行时间较长。
四、实验总结通过本次实验,我们成功地实现了首次适应算法和最佳适应算法,并对算法的正确性和性能进行了验证。
两种算法在内存的分配和回收过程中都表现出良好的性能,可广泛应用于实际场景中。
实验四 操作系统存储管理实验报告
实验四操作系统存储管理实验报告一、实验目的本次操作系统存储管理实验的主要目的是深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握内存分配、回收、地址转换等关键技术,提高对操作系统存储管理机制的认识和应用能力。
二、实验环境操作系统:Windows 10开发工具:Visual Studio 2019三、实验原理1、内存分配方式连续分配:分为单一连续分配和分区式分配(固定分区和动态分区)。
离散分配:分页存储管理、分段存储管理、段页式存储管理。
2、内存回收算法首次适应算法:从内存低地址开始查找,找到第一个满足要求的空闲分区进行分配。
最佳适应算法:选择大小最接近作业需求的空闲分区进行分配。
最坏适应算法:选择最大的空闲分区进行分配。
3、地址转换逻辑地址到物理地址的转换:在分页存储管理中,通过页表实现;在分段存储管理中,通过段表实现。
四、实验内容及步骤1、连续内存分配实验设计一个简单的内存分配程序,模拟固定分区和动态分区两种分配方式。
输入作业的大小和请求分配的分区类型,程序输出分配的结果(成功或失败)以及分配后的内存状态。
2、内存回收实验在上述连续内存分配实验的基础上,添加内存回收功能。
输入要回收的作业号,程序执行回收操作,并输出回收后的内存状态。
3、离散内存分配实验实现分页存储管理的地址转换功能。
输入逻辑地址,程序计算并输出对应的物理地址。
4、存储管理算法比较实验分别使用首次适应算法、最佳适应算法和最坏适应算法进行内存分配和回收操作。
记录不同算法在不同作业序列下的内存利用率和分配时间,比较它们的性能。
五、实验结果与分析1、连续内存分配实验结果固定分区分配方式:在固定分区大小的情况下,对于作业大小小于或等于分区大小的请求能够成功分配,否则分配失败。
内存状态显示清晰,分区的使用和空闲情况一目了然。
动态分区分配方式:能够根据作业的大小动态地分配内存,但容易产生内存碎片。
2、内存回收实验结果成功回收指定作业占用的内存空间,内存状态得到及时更新,空闲分区得到合并,提高了内存的利用率。
存储管理实验报告
存储管理实验报告一、实验目的1.了解存储管理的概念及作用;2.掌握存储管理的基本操作和技术;3.熟悉常见的存储管理工具和方法;4.分析存储管理对系统性能的影响。
二、实验内容1.了解存储管理的基本概念:存储管理是指对计算机中的存储器进行有效管理和利用的一种技术手段。
主要包括内存管理和外存管理两个方面。
2.学习常见的存储管理工具和方法:(1)内存管理方案:连续内存管理、非连续内存管理和虚存管理;(2)外存管理方案:磁盘存储管理、文件系统管理和缓存管理等。
3.实际操作存储管理工具:(1)使用操作系统的内存管理工具,如Windows的任务管理器和Linux的top命令等,查看内存使用情况和进程占用的内存大小;(2)使用磁盘管理工具,如Windows的磁盘管理器和Linux的fdisk命令等,查看磁盘的分区情况和使用状况;(3)使用文件系统管理工具,如Windows的资源管理器和Linux的ls命令等,查看文件和目录的存储和管理状态。
4.分析存储管理对系统性能的影响:(1)使用性能监控工具,如Windows的性能监视器和Linux的sar 命令等,实时监测系统的内存、磁盘和文件系统等性能指标;(2)对比不同存储管理方案的优缺点,分析其对系统性能的影响;(3)根据实验结果提出优化存储管理的建议。
三、实验步骤1.阅读相关文献和资料,了解存储管理的基本概念和原理;2.使用操作系统的内存管理工具,查看当前系统内存的使用情况;3.使用操作系统的磁盘管理工具,查看当前系统磁盘的分区情况;4.使用操作系统的文件系统管理工具,查看当前系统文件和目录的存储和管理状态;5.使用性能监控工具,实时监测系统的内存、磁盘和文件系统等性能指标;6.根据实验结果,分析存储管理对系统性能的影响;7.结合实验结果,提出优化存储管理的建议。
四、实验结果1.使用内存管理工具查看系统内存使用情况,发现部分进程占用内存过高,导致系统运行缓慢;2.使用磁盘管理工具查看系统磁盘分区情况,发现磁盘分区不合理,造成磁盘空间利用率较低;3.使用文件系统管理工具查看文件和目录的存储和管理状态,发现有大量重复和冗余的文件,需要进行清理和整理;4.使用性能监控工具实时监测系统的性能指标,发现内存和磁盘的利用率较高,需要优化存储管理。
操作系统存储管理实验报告
操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分,它直接影响着系统的性能和资源利用率。
本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握存储分配、回收、地址转换等关键技术,并对不同存储管理策略的性能进行分析和比较。
二、实验环境本次实验在 Windows 10 操作系统下进行,使用 Visual Studio 2019 作为编程环境,编程语言为 C++。
三、实验内容(一)固定分区存储管理1、原理固定分区存储管理将内存空间划分为若干个固定大小的分区,每个分区只能装入一道作业。
分区的大小可以相等,也可以不等。
2、实现创建一个固定大小的内存空间数组,模拟内存分区。
为每个分区设置状态标志(已分配或空闲),并实现作业的分配和回收算法。
3、实验结果与分析通过输入不同大小的作业请求,观察内存的分配和回收情况。
分析固定分区存储管理的优缺点,如内存利用率低、存在内部碎片等。
(二)可变分区存储管理1、原理可变分区存储管理根据作业的实际需求动态地划分内存空间,分区的大小和数量是可变的。
2、实现使用链表或数组来管理内存空间,记录每个分区的起始地址、大小和状态。
实现首次适应、最佳适应和最坏适应等分配算法,以及分区的合并和回收算法。
3、实验结果与分析比较不同分配算法的性能,如分配时间、内存利用率等。
观察内存碎片的产生和处理情况,分析可变分区存储管理的优缺点。
(三)页式存储管理1、原理页式存储管理将内存空间和作业都划分为固定大小的页,通过页表将逻辑地址转换为物理地址。
2、实现设计页表结构,实现逻辑地址到物理地址的转换算法。
模拟页面的调入和调出过程,处理缺页中断。
3、实验结果与分析测量页式存储管理的页面置换算法(如先进先出、最近最少使用等)的命中率,分析其对系统性能的影响。
探讨页大小的选择对存储管理的影响。
(四)段式存储管理1、原理段式存储管理将作业按照逻辑结构划分为若干个段,每个段有自己的名字和长度。
实验四操作系统存储管理实验报告
实验四操作系统存储管理实验报告一、实验目的本次实验的主要目的是深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握内存分配与回收、页面置换算法等关键概念,并能够分析和解决存储管理中可能出现的问题。
二、实验环境本次实验在装有 Windows 操作系统的计算机上进行,使用了 Visual Studio 等编程工具和相关的调试环境。
三、实验内容(一)内存分配与回收算法实现1、首次适应算法首次适应算法从内存的起始位置开始查找,找到第一个能够满足需求的空闲分区进行分配。
在实现过程中,我们通过建立一个空闲分区链表来管理内存空间,每次分配时从表头开始查找。
2、最佳适应算法最佳适应算法会选择能够满足需求且大小最小的空闲分区进行分配。
为了实现该算法,在空闲分区链表中,分区按照大小从小到大的顺序排列,这样在查找时能够快速找到最合适的分区。
3、最坏适应算法最坏适应算法则选择最大的空闲分区进行分配。
同样通过对空闲分区链表的排序和查找来实现。
(二)页面置换算法模拟1、先进先出(FIFO)页面置换算法FIFO 算法按照页面进入内存的先后顺序进行置换,即先进入内存的页面先被置换出去。
在模拟过程中,使用一个队列来记录页面的进入顺序。
2、最近最久未使用(LRU)页面置换算法LRU 算法根据页面最近被使用的时间来决定置换顺序,最近最久未使用的页面将被置换。
通过为每个页面设置一个时间戳来记录其最近使用的时间,从而实现置换策略。
3、时钟(Clock)页面置换算法Clock 算法使用一个环形链表来模拟内存中的页面,通过指针的移动和页面的访问标志来决定置换页面。
四、实验步骤(一)内存分配与回收算法的实现步骤1、初始化内存空间,创建空闲分区链表,并为每个分区设置起始地址、大小和状态等信息。
2、对于首次适应算法,从链表表头开始遍历,找到第一个大小满足需求的空闲分区,进行分配,并修改分区的状态和大小。
3、对于最佳适应算法,在遍历链表时,选择大小最接近需求的空闲分区进行分配,并对链表进行相应的调整。
内存管理实验
内存管理实验一.实验目的1.通过本次实验体会操作系统中内存的分配模式;2.掌握内存分配的方法;3.学会进程的建立,当一个进程被终止时内存是如何处理被释放块,并当内存不满足进程申请时是如何使用内存紧凑;4.掌握内存回收过程及实现方法;5.学会进行内存的申请释放和管理;6.掌握内存分配FF,BF,WF策略及实现的思路;二. 实验内容1.编写程序实现采用可变分区方法管理内存。
2.在该实验中,采用可变分区方式完成对存储空间的管理。
3.设计用来记录主存使用情况的数据结构:已分区表和空闲分区表或链表。
4.在设计好的数据结构上设计一个主存分配算法。
5.在设计好的数据结构上设计一个主存回收算法。
其中,若回收的分区有上邻空闲分区和(或)下邻空闲分区,要求合并为一个空闲分区登记在空闲分区表的一个表项里。
三.概要设计1.功能模块图2.各个模块详细的功能描述主要数据结构:struct free_block_type //空闲块{int size;int start_addr;struct free_block_type *next;};struct allocated_block //已分配的内存块{int pid;int size;int start_addr;char process_name[PROCESS_NAME_LEN];struct allocated_block *next;};(1)Set memory size (default=1024):这个模块是用来设置内存大小的,从键盘获取一个数字,并将它赋值给内存大小;若没有设置,则默认内存的大小为1024。
(2)Set_algorithm:这个模块是用来设置分配算法的,共有三种算法:首次循环适配算法、最好适配算法、最差适配算法。
从键盘输入一种算法前的序号,根据算法点用不同的函数对内存进行分配;(3)New_process:此模块是用来创建进程的。
从键盘输入进程号,调用fork()创建进程并为其分配一定大小的内存,若分配成功,则将其连接到已分配链表中,否则分配失败;(4)Kill_process:此模块是用来杀死进程的。
操作系统内存管理实验报告
#include <stdio.h>
#include <malloc.h>
t;
int main(void)
{
char *str; /*为字符串申请分配一块内存*/
if ((str = (char *) malloc(10)) == NULL)
根据练习二改编程序如下:
#include <stdio.h>
#include <malloc.h>
#include <string.h>
int main(void)
{
char *str;
/*为字符串申请分配一块内存*/
if ((str = (char *) malloc(20)) == NULL)
{
同组同学学号:
同组同学姓名:
实验日期:交报告日期:
实验(No. 4)题目:编程与调试:内存管理
实验目的及要求:
实验目的:
操作系统的发展使得系统完成了大部分的内存管理工作,对于程序员而言,这些内存管
理的过程是完全透明不可见的。因此,程序员开发时从不关心系统如何为自己分配内存,
而且永远认为系统可以分配给程序所需的内存。在程序开发时,程序员真正需要做的就
printf("String is %s\n Address is %p\n", str, str);
/*重分配刚才申请到的内存空间,申请增大一倍*/
int main(void)
{
char *str;
/*为字符串申请分配一块内存*/
if ((str = (char *) malloc(10)) == NULL)
操作系统实验-内存管理
操作系统实验-内存管理操作系统实验内存管理在计算机系统中,内存管理是操作系统的核心任务之一。
它负责有效地分配和管理计算机内存资源,以满足各种程序和进程的需求。
通过本次操作系统实验,我们对内存管理有了更深入的理解和认识。
内存是计算机用于存储正在运行的程序和数据的地方。
如果没有有效的内存管理机制,计算机系统将无法高效地运行多个程序,甚至可能会出现内存泄漏、内存不足等严重问题。
在实验中,我们首先接触到的是内存分配策略。
常见的内存分配策略包括连续分配和离散分配。
连续分配是将内存空间视为一个连续的地址空间,程序和数据被依次分配到连续的内存区域。
这种方式简单直观,但容易产生内存碎片,降低内存利用率。
离散分配则将内存分成大小相等或不等的块,根据需求进行分配。
其中分页存储管理和分段存储管理是两种常见的离散分配方式。
分页存储管理将内存空间划分为固定大小的页,程序也被分成相同大小的页,通过页表进行映射。
分段存储管理则根据程序的逻辑结构将其分成不同的段,如代码段、数据段等,每个段有不同的访问权限和长度。
接下来,我们研究了内存回收算法。
当程序不再使用分配的内存时,操作系统需要回收这些内存以便再次分配。
常见的内存回收算法有首次适应算法、最佳适应算法和最坏适应算法。
首次适应算法从内存的起始位置开始查找,找到第一个满足需求的空闲区域进行分配;最佳适应算法则选择大小最接近需求的空闲区域进行分配;最坏适应算法选择最大的空闲区域进行分配。
为了更直观地理解内存管理的过程,我们通过编程实现了一些简单的内存管理算法。
在编程过程中,我们深刻体会到了数据结构和算法的重要性。
例如,使用链表或二叉树等数据结构来表示空闲内存区域,可以提高内存分配和回收的效率。
在实验中,我们还遇到了一些实际的问题和挑战。
比如,如何处理内存碎片的问题。
内存碎片是指内存中存在一些无法被有效利用的小空闲区域。
为了解决这个问题,我们采用了内存紧缩技术,将分散的空闲区域合并成较大的连续区域。
操作系统内存管理实验报告
操作系统内存管理实验报告操作系统内存管理实验报告引言:操作系统是计算机系统中的核心软件,负责管理计算机系统的各种资源,其中内存管理是操作系统的重要功能之一。
内存管理的目标是有效地管理计算机的内存资源,提高计算机系统的性能和可靠性。
本实验旨在通过设计和实现一个简单的内存管理系统,加深对操作系统内存管理原理的理解,并通过实践来加深对操作系统的认识。
一、实验背景计算机内存是计算机系统中的重要组成部分,它用于存储程序和数据。
在操作系统中,内存被划分为多个不同的区域,每个区域有不同的用途和访问权限。
内存管理的主要任务是为进程分配内存空间,并进行合理的管理和调度,以提高系统的性能和资源利用率。
二、实验目的本实验旨在通过设计和实现一个简单的内存管理系统,加深对操作系统内存管理原理的理解,并通过实践来加深对操作系统的认识。
具体目标包括:1. 设计和实现一个简单的内存分配算法,实现内存的动态分配和回收;2. 实现内存的地址映射机制,实现虚拟地址到物理地址的转换;3. 实现内存保护机制,确保进程之间的内存隔离和安全性;4. 实现内存的页面置换算法,提高内存的利用率和性能。
三、实验设计与实现1. 内存分配算法为了实现内存的动态分配和回收,我们设计了一个简单的内存分配算法。
该算法根据进程的内存需求和剩余内存空间的大小,选择合适的内存块进行分配。
当进程结束或释放内存时,将已使用的内存块标记为空闲状态,以便下次分配。
2. 地址映射机制为了实现虚拟地址到物理地址的转换,我们设计了一个地址映射机制。
该机制使用页表来记录虚拟地址与物理地址的映射关系。
当进程访问内存时,操作系统根据页表将虚拟地址转换为物理地址,并进行内存访问。
3. 内存保护机制为了确保进程之间的内存隔离和安全性,我们实现了一个简单的内存保护机制。
该机制通过设置每个进程的访问权限,限制进程对内存的读写操作。
只有获得相应权限的进程才能访问内存,确保进程之间的数据安全和隔离。
操作系统实验之内存管理实验报告
操作系统实验之内存管理实验报告一、实验目的内存管理是操作系统的核心功能之一,本次实验的主要目的是深入理解操作系统中内存管理的基本原理和机制,通过实际编程和模拟操作,掌握内存分配、回收、地址转换等关键技术,提高对操作系统内存管理的认识和实践能力。
二、实验环境本次实验在 Windows 操作系统下进行,使用 Visual Studio 作为编程环境,编程语言为 C++。
三、实验原理1、内存分配算法常见的内存分配算法有首次适应算法、最佳适应算法和最坏适应算法等。
首次适应算法从内存的起始位置开始查找,找到第一个满足需求的空闲分区进行分配;最佳适应算法则选择大小最接近需求的空闲分区;最坏适应算法选择最大的空闲分区进行分配。
2、内存回收算法当进程结束释放内存时,需要将其占用的内存区域回收至空闲分区链表。
回收过程中需要考虑相邻空闲分区的合并,以减少内存碎片。
3、地址转换在虚拟内存环境下,需要通过页表将逻辑地址转换为物理地址,以实现进程对内存的正确访问。
四、实验内容1、实现简单的内存分配和回收功能设计一个内存管理模块,能够根据指定的分配算法为进程分配内存,并在进程结束时回收内存。
通过模拟多个进程的内存请求和释放,观察内存的使用情况和变化。
2、实现地址转换功能构建一个简单的页式存储管理模型,模拟页表的建立和地址转换过程。
给定逻辑地址,能够正确计算出对应的物理地址。
五、实验步骤1、内存分配和回收功能实现定义内存分区的数据结构,包括起始地址、大小、使用状态等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
创建空闲分区链表,初始化为整个内存空间。
模拟进程的内存请求,调用相应的分配算法进行内存分配,并更新空闲分区链表。
模拟进程结束,回收内存,处理相邻空闲分区的合并。
2、地址转换功能实现定义页表的数据结构,包括页号、页框号等信息。
给定页面大小和逻辑地址,计算页号和页内偏移。
通过页表查找页框号,结合页内偏移计算出物理地址。
操作系统实验四存储管理
宁德师范学院计算机系
实验报告
(2014—2015学年第二学期)
课程名称操作系统
实验名称实验四存储管理
专业计算机科学与技术(非师)年级2012级
学号B2012102147 姓名王秋指导教师王远帆
实验日期2015-05-20
图1 word运行情况
“内存使用”列显示了该应用程序的一个实例正在使用的内存数量。
启动应用程序的另一个实例并观察它的内存需求。
请描述使用第二个实例占用的内存与使用第一个实例时的内存对比情况:第二个实例占用内存22772K,比第一个实例占用的内存大很多
2、教师批改学生实验报告应在学生提交实验报告10日内。
内存模拟管理实验报告
内存模拟管理实验报告引言内存管理是操作系统中重要的一部分,它负责管理计算机的内存资源,合理地分配和回收内存空间。
本实验旨在模拟内存管理过程,通过对内存分配、回收和置换算法的模拟实验,加深对内存管理的理解。
实验目的通过本实验,我们的目标是:1. 掌握内存分配、回收和置换算法的基本原理;2. 理解不同的内存管理算法的特点和适用场景;3. 学会使用模拟软件进行内存管理实验。
系统设计本实验采用基于模拟软件的方式进行,我们使用了一款常用的内存管理模拟软件——MemSim。
该软件可以模拟内存的分配、回收和置换算法,并根据实验结果生成相应的性能报告。
首先,我们在MemSim中设计了一个包含若干作业和内存分区的实验环境。
我们可以设置不同的作业大小和内存分区大小,以及各种不同的内存分配、回收和置换算法。
实验过程首先,我们设计了三种内存分配算法:首次适应算法(First Fit)、最佳适应算法(Best Fit)和最坏适应算法(Worst Fit)。
我们分别选择了一组作业和一组内存分区,并使用这三种算法进行内存分配测试。
我们观察到:- 首次适应算法往往会使碎片数量较少,但存在大量分散的小碎片;- 最佳适应算法分配的内存分区较为紧凑,但会导致外部碎片的增加;- 最坏适应算法可以很好地避免外部碎片的产生,但会导致更多的内部碎片。
接下来,我们针对内存回收算法进行了实验。
我们测试了随时间回收算法(FIFO)和优先级回收算法(Priority)两种算法,并选择了不同的作业和内存分区进行了测试。
我们观察到:- 随时间回收算法在作业的运行时间较长的情况下,表现较好;- 优先级回收算法可以根据作业的优先级来选择回收内存,适合于具有不同优先级的作业。
最后,我们还对内存置换算法进行了实验。
我们测试了最先进入先出算法(FIFO)和最不常使用算法(LFU)。
我们选择了一组较大的内存分区,并模拟了一组较大的作业。
通过实验,我们了解到:- 最先进入先出算法可以很好地保证作业的执行顺序,但会导致较高的缺页率;- 最不常使用算法可以合理地选择置换页面,但会增加算法的复杂度。
实验四-存储器管理
实验四存储器管理1、目的与要求本实验的目的是让学生熟悉存储器管理的方法,加深对所学各种存储器管理方案的了解;要求采用一些常用的存储器分配算法,设计一个存储器管理模拟系统,模拟内存空间的分配和释放。
2、实验内容①设计一个存放空闲块的自由链和一个内存作业分配表,存放内存中已经存在的作业。
②编制一个按照首次适应法分配内存的算法,进行内存分配。
③同时设计内存的回收以及内存清理(如果要分配的作业块大于任何一个空闲块,但小于总的空闲分区,则需要进行内存的清理,空出大块的空闲分区)的算法。
3.实验环境①PC兼容机②Windows、DOS系统、Turbo c 2。
0③C语言4.实验提示一、数据结构1、自由链内存空区采用自由链结构,链首由指针freep指向,链中各空区按地址递增次序排列.初启动时整个用户内存区为一个大空区,每个空区首部设置一个区头(freearea)结构,区头信息包括:Size 空区大小Next 前向指针,指向下一个空区Back 反向指针,指向上一个空区Adderss 本空区首地址2、内存分配表JOBMA T系统设置一个MA T,每个运行的作业都在MAT中占有一个表目,回收分区时清除相应表目,表目信息包括:Name 用户作业名Length 作业区大小Addr 作业区首地址二、算法存储分配算法采用首次适应法,根据指针freep查找自由链,当找到第一块可满足分配请求的空区便分配,当某空区被分配后的剩余空闲空间大于所规定的碎片最小量mini时,则形成一个较小的空区留在自由链中。
回收时,根据MAT将制定分区链入自由链,若该分区有前邻或后邻分区,则将他们拼成一个较大的空区。
当某个分配请求不能被满足,但此时系统中所有碎片总容量满足分配请求的容量时,系统立即进行内存搬家,消除碎片.即将各作业占用区集中下移到用户内存区的下部(高地址部分),形成一片连续的作业区,而在用户内存区的上部形成一块较大的空闲,然后再进行分配。
操作系统实验内存分配
实验四存储器管理一、实验名称:存储器管理二、实验目的在TC、VB、Delphi、C++Builder等语言与开发环境中,模拟操作系统的内存管理;通过程序运行所显示的内存使用的各项指标,加深对内存管理的理解。
三、实验内容实现主存储器空间的分配和回收。
本实验有两个题,学生可选择其中的一题做实验。
第一题:在固定分区管理方式下实现主存分配和回收。
第二题:在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收。
[提示]:可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。
随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。
为了说明哪些区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,格式如下:起址长度状态第一栏14 K 12 K 未分配第二栏32 K 96 K 未分配空表目空表目其中,起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区;另一种是“空表目”状态,表示表中对应的登记项目是空白(无效),可用来登记新的空闲区(例如,作业撤离后,它所占的区域就成了空闲区,应找一个“空表目”栏登记归还区的起址和长度且修改状态)。
由于分区的个数不定,所以空闲区说明表中应有适量的状态为“空表目”的登记栏目,否则造成表格“溢出”无法登记。
空闲区表的定义为:#define m 10 /*假定系统允许的空闲区表最大为m*/struct{ float address; /*起始地址*/float length; /*长度*/int flag; /*标志,用“0”表示空栏目,用“1”表示未分配*/ }free_table[m]; /*空闲区表*/上述的这张说明表的登记情况是按提示(1)中的例所装入的三个作业占用的主存区域后填写的。
操作系统实验 内存管理
操作系统实验报告计算机学院(院、系)网络工程专业082 班组课学号20 姓名区德智实验日期教师评定实验四内存管理一、实验目的通过实验使学生了解可变式分区管理使用的主要数据结构,分配、回收的主要技术,了解最优分配、最坏分配、最先分配等分配算法。
基本能达到下列具体的目标:1、掌握初步进程在内存中的映像所需要的内存需求。
2、内存的最先分配算法首先实现,再逐步完成最优和最坏的分配算法。
二、实验内容1、在进程管理的基础上实现内存分配。
2、运用java实现整体的布局与分配内存时的动态图画显示。
三、实验步骤1.构建一个Process的对象类,每分配一次内存就实例化一个对象。
这对象包含分配内存的名字,内存大小(byte),绘画的起点像素,绘画的终点像素。
主要代码:public class Process {private String name;private int size;private int beginPx;private int endPx;public int getBeginPx() {return beginPx;}public void setBeginPx(int beginPx) {this.beginPx = beginPx;}public int getEndPx() {return endPx;}public void setEndPx(int endPx) {this.endPx = endPx;}public String getName() {return name;}public void setName(String name) { = name;}public int getSize() {return size;}public void setSize(int size) {this.size = size;}}2.根据用户输入而分配内存的大小,若输入的大小大于目前可分配内存的大小则拒绝分配操作,否则增加一个新进程入链表中,并在已分配表中增加进程的名字,更新剩余内存大小。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验4 内存管理学校:FJUT 学号:3131903229 班级:计算机1302 姓名:姜峰注:其中LFU和NRU算法运行结果可能与其他人不同,只是实现方式不同,基本思路符合就可以。
一. 实验学时与类型学时:2,课外学时:自定实验类型:设计性实验二. 实验目的模拟实现请求页式存储管理中常用页面置换算法,理会操作系统对内存的调度管理。
三. 实验内容要求:各算法要给出详细流程图以及执行结果截图。
假设有一程序某次运行访问的页面依次是:0,1,2,4,3,4,5,1,2,5,1,2,3,4,5,6,请给出采用下列各页面置换算法时页面的换进换出情况,并计算各调度算法的命中率(命中率=非缺页次数/总访问次数),初始物理内存为空,物理内存可在4~20页中选择。
(1) FIFO:最先进入的页被淘汰;(2) LRU:最近最少使用的页被淘汰;(3) OPT:最不常用的页被淘汰;(选做)(4) LFU:访问次数最少的页被淘汰(LFU)。
(选做)源代码:#include <stdio.h>#include <string.h>#include <limits.h>#include <malloc.h>#define MAXNUM 100struct Phy_Memory{ //定义一个物理内存结构体char Page;int time;};char *OutPut;struct Phy_Memory *Phy_Page;void Print(char *PageStr,int Phy_PageNum,int absence){ //打印图解函数int i,j;for(i=0;i<strlen(PageStr);i++)printf("%c ",*(PageStr+i));printf("\n");for(i=0;i<strlen(PageStr);i++)printf("--");printf("\n");for(i=0;i<Phy_PageNum;i++){for(j=0;j<strlen(PageStr);j++){printf("%c ",*(OutPut+i*strlen(PageStr)+j));}printf("\n");}printf("缺页数为:%d\n",absence);printf("总访问次数为:%d\n",strlen(PageStr));printf("缺页率为%.2f\n",(double)absence/strlen(PageStr));}int IsExist(char *Temp,int Phy_PageNum){ //判断某页面是否存在于物理内存中int i;for(i=0;i<Phy_PageNum&&(Phy_Page+i)->Page!=*Temp;i++);if(i<Phy_PageNum) return i+1; //找到返回此页面位置加1 return 0;}void FIFO(char *PageStr,int Phy_PageNum){ //利用时间计数器方式,还可以用栈来实现char *Temp=PageStr; //定义Temp指针指向PageStr首地址int i,num,location,absence=0;int Flag=0; //定义一个标记变量,标记插入位置while(*Temp!='\0'){ //页面未访问完num=0;if(Flag<Phy_PageNum){ //若物理内存未满if(!IsExist(Temp,Flag)){ //若此页面未被访问(Phy_Page+Flag)->Page=*Temp;Flag++;absence++;}}else{ //若物理内存已满if(!IsExist(Temp,Phy_PageNum)){ //若此页面未被访问for(i=0;i<Flag;i++){ //找到驻留时间最长的页if(num<(Phy_Page+i)->time){location=i;num=(Phy_Page+i)->time;}}(Phy_Page+location)->Page=*Temp;(Phy_Page+location)->time=0;absence++;}}for(i=0;i<Flag;i++){ //将当前物理内存数组列放入二维数组中(Phy_Page+i)->time++;*(OutPut+i*strlen(PageStr)+(Temp-PageStr))=(Phy_Page+i)->Page;}Temp++;}Print(PageStr,Phy_PageNum,absence);}void LRU(char *PageStr,int Phy_PageNum){ //依旧利用计数器方式,也可用栈来实现char *Temp=PageStr; //定义Temp指针指向PageStr首地址int i,num,location,absence=0;int Flag=0; //定义一个标记变量,标记插入位置while(*Temp!='\0'){ //页面未访问完num=0;if(Flag<Phy_PageNum){ //若物理内存未满if(location=IsExist(Temp,Phy_PageNum)){ //若此页面已被访问(Phy_Page+location-1)->time=0;}else{ //若此页面未被访问(Phy_Page+Flag)->Page=*Temp;Flag++;absence++;}}else{ //若物理内存已满if(location=IsExist(Temp,Phy_PageNum)){ //若此页面已被访问(Phy_Page+location-1)->time=0;}else{ //若此页面未被访问for(i=0;i<Flag;i++){ //找到最近最久未使用的页if(num<(Phy_Page+i)->time){location=i;num=(Phy_Page+i)->time;}}(Phy_Page+location)->Page=*Temp;(Phy_Page+location)->time=0;absence++;}}for(i=0;i<Flag;i++){ //将当前物理内存数组列放入二维数组中(Phy_Page+i)->time++;*(OutPut+i*strlen(PageStr)+(Temp-PageStr))=(Phy_Page+i)->Page;}Temp++;}Print(PageStr,Phy_PageNum,absence );}int Distance(char *PageStr,char *Temp,char Now){ //计算距离函数(OPT算法中使用)int i;for(i=1;*(Temp+i)!='\0'&&*(Temp+i)!=Now;i++);if(*(Temp+i)!='\0')return i;return INT_MAX;}void OPT(char *PageStr,int Phy_PageNum){ //实际中无法实现,知道访问串后顺序遍历char *Temp=PageStr; //定义Temp指针指向PageStr首地址int i,num,Size,location,absence=0;int Flag=0; //定义一个标记变量,标记插入位置while(*Temp!='\0'){ //页面未访问完num=0;if(Flag<Phy_PageNum){ //若物理内存未满if(!IsExist(Temp,Flag)){ //若此页面未被访问(Phy_Page+Flag)->Page=*Temp;Flag++;absence++;}}else{ //若物理内存已满if(!IsExist(Temp,Phy_PageNum)){ //若此页面未被访问for(i=0;i<Flag;i++){ //淘汰在访问串中将来再也不会出现的或离当前最远的位置上出现的页Size=Distance(PageStr,Temp,(Phy_Page+i)->Page); //调用distance 函数返回值为与当前位置物理页面相同页号的距离if(num<Size){location=i;num=Size;}}(Phy_Page+location)->Page=*Temp;absence++;}}for(i=0;i<Flag;i++) //将当前物理内存数组列放入二维数组中*(OutPut+i*strlen(PageStr)+(Temp-PageStr))=(Phy_Page+i)->Page;Temp++;}Print(PageStr,Phy_PageNum,absence);}char *Create(char *PageStr){ //根据访问串建立计数字符数组(LFU算法使用)int i,j,Size,Num=0;char *Temp1,*Temp2;int length=strlen(PageStr);char *NowPage=(char *)malloc(length);for(i=0;i<length;i++) *( NowPage + i ) = *( PageStr + i );Temp1 = Temp2 = NowPage;while((Temp1-NowPage)<=length+1){ //去除访问串中重复串if(*Temp1!='\0'){for(Temp2=Temp1+1;(Temp2-NowPage)<=length+1;Temp2++){if(*Temp1==*Temp2){*Temp2='\0';Num++;}}}Temp1++;}Size=length-Num;char *Count=(char *)malloc(Size*2);for(i=0;i<length;i++){ //将不重复的访问页置于计数器中if(*(NowPage+i)!='\0'){*(Count+Size-1)=*(NowPage+i);Size--;}}Size=length-Num;for(i=Size;i<2*Size;i++){ //计数位置零*(Count+i)='0';}return Count;}void Add(char *Ptr,char Str,int Size){ //相应计数器加一(LFU算法使用)int i;for(i=0;*(Ptr+i)!=Str;i++);*(Ptr+i+Size)+=1;}int Find(char *Ptr,char Str,int Size){ //在计数器中找到相应页面并返回其计数值(LFU算法使用)int i;for(i=0;*(Ptr+i)!=Str;i++);return (*(Ptr+i+Size)-'0');}void Zero( char *Ptr, int Size ){ //将所有计数器清零(LFU算法使用)int i;for(i=Size;i<2*Size;i++) *(Ptr+i)='0';}void LFU(char *PageStr,int Phy_PageNum){ //对每一页面设置一个计数器,每次选出最小的淘汰char *Temp=PageStr; //定义Temp指针指向PageStr首地址char *Count=Create(PageStr);int i,Size,time,num,location,absence=0;int Flag=0; //定义一个标记变量,标记插入位置Size=strlen(Count)/2;while(*Temp!='\0'){ //页面未访问完num=INT_MAX;if(Flag<Phy_PageNum){ //若物理内存未满if(location=IsExist(Temp,Phy_PageNum)){ //若此页面已被访问Add(Count,(Phy_Page+location-1)->Page,Size);}else{ //若此页面未被访问(Phy_Page+Flag)->Page=*Temp;Flag++;absence++;}}else{ //若物理内存已满if(location=IsExist(Temp,Phy_PageNum)){ //若此页面已被访问Add(Count,(Phy_Page+location-1)->Page,Size);}else{ //若此页面未被访问for(i=0;i<Flag;i++){ //找到被访问次数最少的一页time=Find(Count,(Phy_Page+i)->Page,Size);if(num>time){location=i;num=time;}}(Phy_Page+location)->Page=*Temp;Zero(Count,Size);absence++;}}for(i=0;i<Flag;i++) //将当前物理内存数组列放入二维数组中*(OutPut+i*strlen(PageStr)+(Temp-PageStr))=(Phy_Page+i)->Page;Temp++;int j; //打印每次访问后的计数器值for(i=0;i<2;i++){for(j=0;j<Size;j++)printf("%c ",*(Count+i*Size+j));printf("\n");}printf("\n");}Print(PageStr,Phy_PageNum,absence);}void NRU(char *PageStr,int Phy_PageNum){ //对每个物理页设置一个标识(0/1),用指针循环访问淘汰标识为零的页面char *Temp=PageStr; //定义Temp指针指向PageStr首地址int i,location,absence=0;int Flag=0; //定义一个标记变量,标记插入位置struct Phy_Memory *Clock = Phy_Page; //定义一个结构体指针指向物理内存首地址while(*Temp!='\0'){ //页面未访问完if(Flag<Phy_PageNum){ //若物理内存未满if(location=IsExist(Temp,Phy_PageNum)){ //若此页面已被访问(Phy_Page+location-1)->time=1;}else{ //若此页面未被访问(Phy_Page+Flag)->Page=*Temp;(Phy_Page+Flag)->time=1;Flag++;absence++;Clock++;if((Clock-Phy_Page)>=Phy_PageNum) Clock=Phy_Page;}}else{ //若物理内存已满if(location=IsExist(Temp,Phy_PageNum)){ //若此页面已被访问(Phy_Page+location-1)->time=1;}else{ //若此页面未被访问while(Clock->time){Clock->time=0;Clock++;if((Clock-Phy_Page)>=Phy_PageNum) Clock=Phy_Page;}Clock->Page=*Temp;Clock->time=1;Clock++;if((Clock-Phy_Page)>=Phy_PageNum) Clock=Phy_Page;absence++;}}for(i=0;i<Flag;i++){ //将当前物理内存数组列放入二维数组中*(OutPut+i*strlen(PageStr)+(Temp-PageStr))=(Phy_Page+i)->Page;}Temp++;}Print(PageStr,Phy_PageNum,absence );}int main(){char *Str;int i,n,Num;Str=(char*)malloc(MAXNUM);printf("输入程序运行时访问的页面次序以及物理内存的分页数:\n");scanf("%s%d",Str,&Num);Phy_Page=(struct Phy_Memory*)malloc(Num*sizeof(struct Phy_Memory)); //初始化物理内存结构体OutPut=(char*)malloc(Num*strlen(Str));for(i=0;i<Num;i++)(Phy_Page+i )->time=0;printf("选择置换算法:\n1.FIFO 2.LRU 3.OPT 4.LFU 5.NRU\n");scanf("%d",&n);switch (n){case 1:printf("\n以下为FIFO算法图解:\n");FIFO(Str,Num);break;case 2:printf("\n以下为LRU算法图解:\n");LRU(Str,Num);break;case 3:printf("\n以下为OPT算法图解:\n");OPT(Str,Num);break;case 4:printf("\n以下为LFU算法图解:\n各时期计数器如下:\n");LFU(Str,Num);break;case 5:printf("\n以下为NRU算法图解:\n");NRU(Str,Num);break;}free(Phy_Page);free(OutPut);return 0;}注:这里只对分页数为4进行运行截图实验截图:FIFO算法流程图:LRU算法流程图:OPT算法流程图:LFU算法流程图:NRU算法流程图:四. 思考与总结(1)针对上述页面访问顺序,请比较上述各页面置换算法的性能。