实验项目五 存储管理

操作系统存储管理实验报告实验5存储管理第一，实验的目的1，加深对操作系统存储管理的理解2，可以过度模拟页面调试算法，加深对操作系统内存管理的理解二、一般设计思想、环境语言、工具等一般设计思想:1.编写一个函数来计算和输出以下算法的命中率:(1) OPT页面替换算法OPT选定的过时页面是已经转移到内存中并且将来不会被使用或者在最长时间内不会被访问的页面。

因此，如何找到这样的页面是算法的关键。

每页可以设置一个步长变量。

它的初始值是一个足够大的数字。

对于不在内存中的页面，其值将重置为零。

对于内存中的页面，其值被重置为当前访问的页面与页面首次出现时的距离。

因此，该值越大，在最长时间内不会被访问的页面就越多，并且可以选择它作为交换页面。

(2)先进先出页面替换算法先进先出总是选择首先进入内存的页面进行清除，因此可以设置先进先出的繁忙页面帧队列，新转移到内存的页面挂在队列的尾部，当没有空闲页面帧时，可以从队列的头部取出下一个页面帧作为空闲页面帧，然后再转移到需要的页面。

(3) LRU页面替换算法LRU 根据转移到存储器中的页面的使用做出决定。

它使用“最近的过去”作为“最近的未来”的近似，并选择最长时间没有使用的页面进行删除。

该算法主要通过页面结构中的访问时间来实现。

时间记录页面的最后访问时间。

因此，当需要删除一个页面时，选择时间值最小的页面，即最近最长时间没有使用的页面进行删除。

(4) LFU页面替换算法LFU要求每个页面配置一个计数器(即页面结构中的计数器)。

一旦页面被访问，计数器的值将增加1。

当需要替换一个页面时，将选择计数器值最小的页面，即存储器中访问次数最少的页面进行清除。

⑤NUR页面替换算法NUR要求为每个页面设置一个访问位(访问位仍然可以由页面结构中的计数器表示)。

当页面被访问时，其访问位计数器被设置为1。

当需要页面替换时，替换算法从替换指针(最初指向第一页)开始顺序检查内存中的每一页。

如果其访问位为0，则选择页面进行替换，否则，替换指针向下移动以继续向下搜索。

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

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

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

主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实验理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。

在计算机系统中，为了提高主存利用率，往往把辅助存储器（如磁盘）作为主存储器的扩充，使多道运行的作业的全部逻辑地址空间总和可以超出主存的绝对地址空间。

用这种办法扩充的主存储器称为虚拟存储器。

通过本实验理解在分页式存储管理中怎样实现虚拟存储器。

在本实验中，通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。

熟悉虚存管理的各种页面淘汰算法通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

二、实验题目：设计一个可变式分区分配的存储管理方案。

并模拟实现分区的分配和回收过程。

对分区的管理法可以是下面三种算法之一：（任选一种算法实现）首次适应算法循环首次适应算法最佳适应算法三．实验源程序文件名:cunchuguanli.c执行文件名:cunchuguanli.exe四、实验分析：1)本实验采用可变分区管理，使用首次适应算法实现主存的分配和回收1、可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。

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

随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。

为了说明那些分区是空闲的，可以用来装入新作业，必须有一张空闲说明表? 空闲区说明表格式如下：?第一栏第二栏其中，起址——指出一个空闲区的主存起始地址，长度指出空闲区的大小。

存储器管理实验实验报告一、实验目的存储器管理是操作系统的重要组成部分，本次实验的目的在于深入理解存储器管理的基本原理和方法，通过实际操作和观察，掌握存储器分配与回收的算法，以及页面置换算法的实现和性能评估。

二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。

三、实验内容与步骤（一）存储器分配与回收算法实现1、首次适应算法（1）原理：从空闲分区链的首地址开始查找，找到第一个满足需求的空闲分区进行分配。

（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态（已分配或空闲）。

当有分配请求时，从链表头部开始遍历，找到第一个大小满足需求的空闲分区。

将该分区进行分割，一部分分配给请求，剩余部分仍作为空闲分区留在链表中。

若找不到满足需求的空闲分区，则返回分配失败。

2、最佳适应算法（1）原理：从空闲分区链中选择与需求大小最接近的空闲分区进行分配。

（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。

当有分配请求时，遍历整个链表，计算每个空闲分区与需求大小的差值。

选择差值最小的空闲分区进行分配，若有多个差值相同且最小的分区，选择其中起始地址最小的分区。

对选中的分区进行分割和处理，与首次适应算法类似。

3、最坏适应算法（1）原理：选择空闲分区链中最大的空闲分区进行分配。

（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。

当有分配请求时，遍历链表，找到最大的空闲分区。

对该分区进行分配和处理。

（二）页面置换算法实现1、先进先出（FIFO）页面置换算法（1）原理：选择在内存中驻留时间最久的页面进行置换。

（2）实现步骤：建立页面访问序列。

为每个页面设置一个进入内存的时间戳。

当发生缺页中断时，选择时间戳最早的页面进行置换。

2、最近最久未使用（LRU）页面置换算法（1）原理：选择最近一段时间内最长时间未被访问的页面进行置换。

存储管理实验报告存储管理实验报告引言：存储管理是计算机系统中非常重要的一部分，它负责管理计算机系统中的存储资源，包括内存和外存。

合理的存储管理能够提高计算机系统的性能和效率，保证系统的稳定运行。

本次实验旨在通过实践操作，深入了解存储管理的原理和方法，并通过实验结果分析，探讨存储管理的优化策略。

一、实验目的本次实验的主要目的是通过实践操作，深入了解存储管理的原理和方法，并通过实验结果分析，探讨存储管理的优化策略。

具体目标如下：1. 了解存储管理的基本概念和原理；2. 掌握存储管理的常用方法和技术；3. 分析实验结果，探讨存储管理的优化策略。

二、实验环境本次实验使用了一台配置较高的计算机，具备较大的内存和高速的硬盘。

实验环境如下：1. 操作系统：Windows 10；2. 内存：16GB；3. 硬盘：1TB。

三、实验过程1. 内存管理实验在内存管理实验中，我们使用了一段较大的程序代码进行测试。

首先，我们通过编程语言将程序代码写入内存中，然后通过内存管理技术将程序代码加载到内存的合适位置。

在加载过程中，我们使用了分页和分段两种常用的内存管理技术，并比较了它们的性能差异。

实验结果显示，分页技术相对来说更加高效，能够更好地利用内存资源，提高系统的运行速度。

2. 外存管理实验在外存管理实验中，我们模拟了大文件的读写操作。

首先，我们将一个较大的文件写入硬盘中，然后通过外存管理技术将文件加载到内存中进行读取。

在加载过程中，我们使用了磁盘调度算法和文件系统管理技术，并比较了它们的性能差异。

实验结果显示，磁盘调度算法的选择对系统的读写速度有较大的影响，而文件系统的合理管理能够提高文件的存取效率。

四、实验结果分析通过对实验结果的分析，我们可以得出以下结论：1. 内存管理中，分页技术相对于分段技术更加高效，能够更好地利用内存资源，提高系统的运行速度；2. 外存管理中，磁盘调度算法的选择对系统的读写速度有较大的影响，合理选择磁盘调度算法能够提高系统的性能；3. 文件系统的合理管理能够提高文件的存取效率，减少文件的碎片化，提高系统的整体性能。

存储管理实验报告存储管理实验报告一、引言存储管理是计算机系统中一个非常重要的组成部分，它负责管理计算机内存的分配、回收和保护。

本次实验旨在通过实际操作，深入理解存储管理的原理和技术，并探索不同的存储管理策略对系统性能的影响。

二、实验目的1. 理解存储管理的基本概念和原理；2. 掌握常见的存储管理算法和策略；3. 分析不同存储管理策略对系统性能的影响。

三、实验环境本次实验使用了一台配置较低的个人电脑，操作系统为Windows 10，内存容量为4GB。

四、实验内容1. 静态分区分配算法静态分区分配算法是最简单的存储管理算法之一。

在实验中，我们使用了最先适应算法（First Fit）和最佳适应算法（Best Fit）进行静态分区分配。

通过对比两种算法的分配效果，我们发现最佳适应算法在减少内存碎片方面表现更好。

2. 动态分区分配算法动态分区分配算法是一种更加灵活的存储管理策略。

在实验中，我们实现了首次适应算法（First Fit）和最佳适应算法（Best Fit）两种动态分区分配算法。

通过观察不同算法的分配效果，我们发现首次适应算法在处理大量小内存块时效率较高，而最佳适应算法在处理大内存块时表现更好。

3. 页面置换算法页面置换算法是虚拟内存管理中的重要组成部分。

在实验中，我们实现了最近最少使用（LRU）算法和先进先出（FIFO）算法两种页面置换算法。

通过模拟内存不足的情况，我们观察了不同算法对系统性能的影响。

结果显示，LRU算法在减少页面置换次数方面比FIFO算法更为优秀。

五、实验结果与分析通过本次实验，我们对不同的存储管理算法和策略进行了实际操作，并观察了它们对系统性能的影响。

实验结果显示，最佳适应算法在静态分区分配中表现更好，而首次适应算法在动态分区分配中效率更高。

在页面置换算法中，LRU 算法在减少页面置换次数方面更为出色。

六、实验总结本次实验通过实际操作，深入理解了存储管理的原理和技术，并探索了不同的存储管理策略对系统性能的影响。

实验报告课程名称：操作系统实验项目名称：存储管理实验时间： 20120504 班级：姓名：学号：实验目的:理解可变分区管理方式下采用最佳适应分配算法实现主存分配和回收。

对理论课中学习的内存管理中的概念作进一步的理解。

实验环境:winTC实验内容及过程:1、分配主存采用最佳适应分配算法（Best fit），将空闲区表中的空闲区按其容量递增的次序排列。

当一个作业要求装入主存时，按由小到大的顺序查找空闲区说明表，找到第一个满足申请长度的空闲区（满足条件的最小空闲区）。

有时候空闲区大于作业需要量，需要将空闲区分成两部分，一部分作业占用，另一部分作为一个空闲区将其插入适当的位置。

为了方便查找，总是让“空表目”集中在表格的后面。

2、回收主存当一个作业执行结束撤离时，作业所占的区域应该归还，系统根据回收区的首址从空闲区表中找到相应的插入点，归还的区域如果与其他空闲区相邻（有如下三种情况），则应合成一个大的空闲区，病登记在空闲区说明表中。

否则作为一个新的空闲区登记在空闲区说明表中。

实验过程：1. 编写程序，由必要的数据结构、主函数、内存分配函数及主存回收函数构成。

实现可变分区管理方式下采用最优/佳适应分配算法实现主存的分配和回收。

2. 在上机环境中输入程序，调试，编译。

3. 设计输入数据，写出程序的执行结果。

实验结果及分析：程序a请求长度为10内存：作业b请求长度为20的内存：回收作业a主存回收b 的主存：实验心得：陈少琼：可变分区管理方式下采用最佳适应分配算法实现主存分配和回收是一个较好理解的算法，用C语言编写的参考程序要自己去补充定义，分析程序，理解算法，才可能去设计实验数据，进行实验，虽然会话多一点的时间，但是可以充分理解这个算法，和计算机主存的分配和回收情况。

兰晓铃：本实验的实验过程中还是遇到比较多的问题，程序编译时不能够一次通过，而是要不断的补充和定义，课堂上的最佳适应算法虽然通俗易懂，但要用这样基础的程序语言描述出来，并且编译通过还有相当大的距离，在老师和同学的帮助下终于实现可变分区管理方式下采用最优/佳适应分配算法实现主存的分配和回收。

实验五：存储管理一、实验目的（1）熟悉内存空闲分区的分配方式；（2）理解动态分区存储管理方式；（3）掌握动态分区的分配与回收的过程。

二、实验环境微型计算机，Ubuntu Linux10.04 ，gedit，gcc三、实验内容根据流程图和参考程序，完成模拟内存分配和回收过程。

内存空间大小为100，进程数为5，每个进程所需空间为随机产生，大小为1~20，编制程序，首先对5个进程进行内存分配，然后回收指定的进程空间，并进行适当的空闲分区合并操作，要求每次操作结束后都能显示当前的内存分配情况。

四、实验结果截图一截图二截图三五、源代码#include<stdio.h>#include<malloc.h>typedef struct MEMORY_BLOCK{int name; //进程名int address; //起始地址int length; //长度int flag; //标志,表示该块是否被分配。

struct MEMORY_BLOCK *next; //指向下一个进程}MEMORY_BLOCK;#define NUM 5#define LEN sizeof(MEMORY_BLOCK)void allocation(MEMORY_BLOCK *Header,int name,int length_p){ MEMORY_BLOCK *temp,*t,*tt;int minsize=2; //不可切割的分区阈值while(t!=0){if(t->length>length_p&&t->flag==0) break;t=t->next;}if(t->length-length_p>minsize){ //分割temp=(MEMORY_BLOCK*)malloc(LEN);temp->name=-1;temp->flag=0;temp->length=t->length-length_p;temp->address=t->address+length_p;t->name=name;t->flag=1;t->length=length_p;temp->next=t->next;t->next=temp;}else{ //直接分配t->name=name;t->flag=1;}}void reclaim(int processname, MEMORY_BLOCK *Header){ MEMORY_BLOCK *temp,*t,*tt;temp=t;while(t->name!=processname){temp=t;t=t->next;}if(t->next!=NULL){ //t非尾结点if(temp->flag==0&&t->next->flag==0){ //左右为空temp->name=-1;temp->length=temp->length+t->length+t->next->length;tt=t->next;temp->next=tt->next;}else if(temp->flag==0){ //左为空temp->name=-1;temp->length=temp->length+t->length;temp->next=t->next;}else if(t->next->flag==0){ //右为空t->name=-1;t->length=t->length+t->next->length;t->flag=0;tt=t->next;t->next=tt->next;}else{ //左右不为空t->name=-1;t->flag=0;}else{ //t是尾结点if(temp->flag==0){ //左为空temp->name=-1;temp->length=temp->length+t->length;temp=t->next;}else{ //左不为空t->name=-1;t->flag=0;}}}void main(){ //主函数int length_p,i,processname;MEMORY_BLOCK *Header,*t;Header=(MEMORY_BLOCK*)malloc(LEN); //初始化存储空间Header->name=-1;Header->address=0;Header->length=100;Header->flag=0;Header->next=NULL;srand((int)time(0));for(i=1;i<=NUM+1;i++){length_p=rand()%20+1; //随机产生进程所需存储空间，至少为1allocation(Header,i,length_p);}printf("当前内存分配情况：\n");t=Header;while(t!=0){printf("process_name:%d,address:%d,length:%d,flag:%d\n",t->name,t->address,t->length,t->flag);t=t->next;}printf("请输入回收的进程号(输入0结束):\n");scanf("%d",&processname);while(processname!=0){printf("回收process name %d\n",processname);reclaim(processname,Header);printf("当前内存分配情况：\n");t=Header;while(t!=0){printf("process_name:%d,address:%d,length=%d,flag=%d\n", t->name, t->address, t->length,t->flag);t=t->next;}。

存储管理实验报告一、实验目的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.使用性能监控工具实时监测系统的性能指标，发现内存和磁盘的利用率较高，需要优化存储管理。

实验五存储管理（二）学号：姓名：班级：实验目的：1. 了解虚拟存储器。

2. 掌握分页存储管理的原理，熟悉段式存储和段页式存储管理。

3. 掌握常用的页面置换算法。

实验内容：一、选择：1.可变分区方式常用的主存分配算法中，（C）总是找到能满足作业要求的最大空闲区分配A、最佳适应算法B、首次适应算法C、最坏适应算法D、循环首次适应算法2．下列（A ）存储方式不能实现虚拟存储器A、分区B、页式C、段式D、段页式3．操作系统处理缺页中断时，选择一种好的调度算法对主存和辅存中的信息进行高效调度尽可能地避免（D）A、碎片B、CPU空闲C、多重中断D、抖动4．分页式存储管理的主要特点是（C）A、要求处理缺页中断B、要求扩充主存容量C、不要求作业装入到主存的连续区域D、不要求作业全部同时装人主存5．LRU页面调度算法淘汰（B）的页A、最近最少使用B、最近最久未使用C、最先进入主存D、将来最久使用6．分区管理要求对每一个作业都分配（A）的主存单元A、地址连续B、若干地址不连续的C、若干连续的页D、若干不连续的帧7．在存储管理中，采用覆盖与交换技术的目的是（A）A、节省主存空间B、物理上扩充主存容量C、提高CPU的效率D、实现主存共享8．分页虚拟存储管理中，缺页中断时，欲调度一页进入主存中，内存己无空闲块，如何决定淘汰已在主存的块时，（B）的选择是很重要的A、地址变换B、页面调度算法C、对换方式D、覆盖技术9．（D）存储管理兼顾了段式在逻辑上清晰和页式在存储管理上方便的优点A、分段B、分页C、可变分区方式D、段页式10．在固定分区分配中，每个分区的大小是（C）A、随作业长度变化B、相同C、可以不同但预先固定D、可以不同但根据作业长度固定11．下述（B）页面置换算法会产生Belady现象A、最佳置换算法B、先进先出算法C、LRU算法D、Clock算法12．在一个分页式存储管理系统中，页表的内容为：若页的大小为4KB，则地址转换机构将相对地址0转换成的物理地址是（A）。

昆明理工大学信息工程与自动化学院学生实验报告（2012 —2013 学年第二学期）一、实验目的存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

通过本次实验, 要求学生通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解, 通过请求页式存储管理中页面置换算法模拟设计, 了解虚拟存储技术的特点, 掌握请求页式存储管理的页面置换算法。

二、实验原理及基本技术路线图（方框原理图）用C或C++语言模拟实现请求式分页管理。

要求实现: 页表的数据结构、分页式内存空间的分配及回收（建议采用位图法）、地址重定位、页面置换算法（从FIFO,LRU,NRU中任选一种）。

int subareaSize[num]={8,12,16,32,24,16,64,128,40,64};//分区大小Process *pro=NULL;//保持进程信息int ProcessNum=0;//进程数目int applyProcessNum=0;//每次申请进程数目int maxApplyNum=0;//最大可申请数目int *applyIndex=NULL;//申请进程队列int totalApplyNum=0;//申请总数int *assignPointer=NULL;//已分配内存的进程队列int assignFlag=0;//分配索引, 表示已申请队列已分配的进程数int exeIndex;//执行的进程号Node *subareaNode=new Node[3];//分区回收时, 进程所在分区及其前, 后分区信息LinkList createLinkList(int n );//建立空闲分区链Node firstFit(LinkList &head,Process pro);//首次适应算法Node nestFit(LinkList &head,Process pro,Node flag);//循环适应算法Node bestFit(LinkList &head,Process pro);//最佳适应算法Node worstFit(LinkList &head,Process pro);//最坏适应算法Node assign(LinkList &head,int orderIndex,int index,Node flagNode);//一次分区分配int assignMemory(LinkList &head);//内存分配void insertNode(LinkList &head,Node q,int index);//插入节点Node deleteNode(LinkList &head,int index);//删除节点int display(LinkList &head);//打印分区分配情况int lowAttemper(int *excursionPointer);//低级调度int findSubarea(LinkList &head,int index);//回收内存int creatProcess();//创建进程Process* randomCreatPro(int n);//随机产生进程下面是各种方法简述:(1) 最优替换算法, 即OPT算法。

操作系统实验-存储管理操作系统实验-存储管理1、引言1.1 概述在操作系统中，存储管理是一个关键的任务。

它负责将程序和数据加载到内存中，管理内存的分配和回收，并确保不同进程之间的内存互不干扰。

本实验旨在深入了解并实践存储管理的相关概念和算法。

1.2 目的本实验的目的是让学生通过实际操作，了解存储管理的基本原理和常用算法，包括分页、分段和虚拟内存等。

通过实验，学生将学会如何实现内存分配和回收，以及处理内存碎片等问题。

1.3 实验环境- 操作系统：Windows、Linux、MacOS等- 编程语言：C、C++等2、实验步骤2.1 实验准备- 安装相应的开发环境和工具- 创建一个空白的项目文件夹，用于存放实验代码和相关文件2.2 实验一、分页存储管理- 理解分页存储管理的概念和原理- 实现一个简单的分页存储管理系统- 设计测试用例，验证分页存储管理的正确性和有效性2.3 实验二、分段存储管理- 理解分段存储管理的概念和原理- 实现一个简单的分段存储管理系统- 设计测试用例，验证分段存储管理的正确性和有效性2.4 实验三、虚拟存储管理- 理解虚拟存储管理的概念和原理- 实现一个简单的虚拟存储管理系统- 设计测试用例，验证虚拟存储管理的正确性和有效性3、实验结果分析3.1 分页存储管理结果分析- 分析分页存储管理系统的性能优缺点- 比较不同页面大小对系统性能的影响3.2 分段存储管理结果分析- 分析分段存储管理系统的性能优缺点- 比较不同段大小对系统性能的影响3.3 虚拟存储管理结果分析- 分析虚拟存储管理系统的性能优缺点- 比较不同页面置换算法对系统性能的影响4、总结与展望4.1 实验总结- 总结本次实验的收获和体会- 分析实验中遇到的问题和解决方法4.2 实验展望- 探讨存储管理领域的未来发展方向- 提出对本实验的改进意见和建议附件：无法律名词及注释：- 存储管理：操作系统中负责管理内存的任务，包括内存分配、回收和管理等功能。

实验三存储管理一、实验内容：1.数据文件的组织；2.缓冲区管理；3.空闲空间管理；二、实验要求：1.数据文件的组织：i.段页式组织方式；ii.支持基本数据类型，可不支持大对象数据；2.缓冲区管理：i.缓冲区页面组织；ii.缓冲区查找；iii.缓冲区淘汰；3.空闲空间管理：i.空闲空间组织；ii.空闲空间分配；iii.空闲空间回收；三、实验步骤：本实验代码实现使用的是C语言。

1.数据文件的组织：我们借助Oracle里面关于数据存储的概念，划分一个表空间，表空间里面又分为数据段，索引段和数据字典段。

每个段里面又分为等长大小的区，每个区由若干个页（PAGE_PER_EXTENT我们设为200）来组成。

具体的定义在文件tablespace.h里面。

而在页中存储记录时，页头保存这个页中有多少条元组；然后剩余的空间来存储具体的记录：每个记录有记录头，记录头记录这个元组的模式的指针，元组的长度和时间戳；记录体存储具体的属性数据。

而在记录体中存储数据时，我们现在支持三种数据类型：int, char(n), vchar(n)。

考虑到对齐的因素，我们每个属性的数据都从4的整数倍的地址开始存储，所以数据字典里记录的各个属性的偏移量都是4的倍数。

具体到单个元组插入的时候过程是这样的：先读数据字典，找到这个表所在的空间（第一个区间），然后读这个区间头，找到一个有空闲空间的页，然后读出那一页，按照数据字典的解析把该元组插入到这个页中的空闲位置，然后将该页写回到文件中。

具体的文件组织可以用下面的图来表示：数据文件：｜文件头｜数据段｜索引段｜数据字典段｜数据段：｜区间一｜区间二｜区间三｜……｜区间：｜区间头｜页一｜页二｜页三｜……｜页：｜页头｜元组一｜元组二｜元组三｜……｜元组：｜记录模式指针｜长度｜时间戳｜属性一｜属性二｜属性三｜……｜我们所定义的一些头部定义如下所示：struct file_header {int magic_num; /* file magic number */unsigned char bitmap[MAX_EXTENT]; /* record which extent have free space */};struct extent_header {int rec_per_page;int next; /* null is -1 */int bitmap[MAX_DAT_PAGE];};struct index_header {char bitmap[MAX_IDX_PAGE / CHAR_BIT];};struct dict_header {struct {int flag;char tname[20];} table[MAX_TABLE_NUM];};各个头部的主要功能就是记录空闲空间，回收空闲空间。

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

通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解，熟悉动态分区存储管理的内存分配和回收。

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

具体包括：确定内存空间分配表；采用最优适应算法完成内存空间的分配和回收；编写主函数对所做工作进行测试。

三、设计思路整体思路：动态分区管理方式将内存除操作系统占用区域外的空间看成一个大的空闲区。

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

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

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

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

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

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

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

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

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

《操作系统》存储管理实验报告操作系统是计算机系统中最基础、最核心的软件之一，负责管理计算机硬件资源和提供资源的分配与调度。

而存储管理是操作系统中的重要组成部分，它负责管理计算机的内存，包括内存的分配、回收、保护等操作。

本文将针对存储管理进行实验，并撰写实验报告。

本次实验主要涉及以下内容：内存的分配与回收、内存的保护。

实验过程中，我首先根据操作系统的要求，设计了相应的算法用于内存的分配与回收。

并通过编写程序，验证了算法的正确性。

随后，我进一步研究了内存的保护机制，通过设置访问权限位和访问控制表，实现了对内存的合理保护。

在内存的分配与回收方面，我设计了一种简单的算法，首次适应算法。

具体实现如下：首先，将内存分为若干个块，每个块的大小为固定值。

当需要分配内存时，首先遍历内存块列表，找到第一个大小合适的块，将其分配给进程。

当进程终止时，将其占用的内存块回收，以便后续进程使用。

通过编写程序进行测试，结果表明该算法能够正确地进行内存的分配与回收。

在内存的保护方面，我采用了访问权限位和访问控制表的方式进行。

具体实现如下：首先，为每个进程分配一组访问权限位，记录了该进程能够访问的内存区域。

同时，设置一个访问控制表，记录了每个内存块的权限。

当进程访问一些内存块时，首先检查该进程的访问权限位，再与访问控制表中的权限进行比较，以确定该进程是否有权限访问该内存块。

通过编写程序进行测试，证明了该机制能够有效地保护内存。

总结来说，本次实验主要涉及了操作系统中的存储管理部分，包括内存的分配与回收、内存的保护。

通过设计算法和编写程序，我成功地实现了这些功能，并验证了其正确性。

通过本次实验，我进一步加深了对操作系统存储管理的理解，提高了编程和设计的能力。

存储管理实验报告题目：1。

存储管理描述请求分页存储管理。

一.产生一个作业及作业页面序列P(pi)，例如：P(0,2,3,4,1,5,2,3,0,4,1,5)。

二.分配物理内存块数M。

三.采用FIFO，LRU置换算法。

四.设计原理：本程序提供两种分区管理法供用户使用，这两种算法是最佳适应算法和首次适应算法。

最佳适应算法要求将所有的空闲区，按其大小以递增的顺序形成一空闲区链。

这样，第一次找到的满足要求的空闲区，必然是最优的。

但该算法会留下许多这样难以利用的小空闲区。

首次适应算法要求空闲分区链以地址递增的次序链接。

在进行内存分配时，从链首开始顺序查找，直至找到一个能满足其大小要求的空闲分区为止。

然后，再按照作业的大小，从该分区中划出一快内存空间分配该请求者，余下的空闲分区仍留在空闲链中。

三．不足之处：该程序可以用文件形式输入作业的信息，但是该文件没有绑定在程序中。

不过，用户用键盘输入的作业的信息会自动保存到该文件中，下次当以文件形式输入作业信息时，文件中的内容是上一次用户用键盘输入的内容。

四．源程序以及解释：#include<stdio.h>#include<time.h>#include<stdlib.h>int memoryStartAddress = -1;int memorySize = -1;struct jobList//作业后备队列的链结点{int id; //作业的ID号int size; //作业的大小int status; //作业状态struct jobList *next;};struct freeList //空闲链的链结点{int startAddress; //空闲分区的首地址int size; //空闲分区的大小struct freeList *next;};struct usedList //已分配内存的作业链{int startAddress; //以分配内存的首地址int jobID;struct usedList *next;};void errorMessage(void) //出错信息{printf("\n\t错误!\a");printf("\n按任意键继续!");getch();exit(1);}void openFile(FILE **fp,char *filename,char *mode) //打开文件函数{if((*fp = fopen(filename,mode)) == NULL){printf("\n不能打开%s.",filename);errorMessage();}}void makeFreeNode(struct freeList **empty,int startAddress,int size)//申请内存空间{if((*empty = malloc(sizeof(struct freeList))) == NULL){printf("\n没有足够空间.");errorMessage();}(*empty)->startAddress = startAddress; //当有足够空间时，则分配(*empty)->size = size;(*empty)->next = NULL;}void iniMemory(void) //输入要求分配内存的首地址，大小{char MSA[10],MS[10];printf("\n请输入要分配内存的首地址!");scanf("%s",MSA);memoryStartAddress = atoi(MSA);printf("\n请输入要分配内存的大小!");scanf("%s",MS);memorySize = atoi(MS);}char selectFitMethod(void) //选择分区管理算法{FILE *fp;char fitMethod;do{printf("\n\n请选择分区管理的算法!\\n 1 最佳适应算法\\n 2 首次适应算法\n");fitMethod = getche();}while(fitMethod < '1' || fitMethod > '3'); //选择出错时openFile(&fp,"d:\\result.cl","a");switch(fitMethod){case '1':fprintf(fp,"\n\n\n\n\t 最佳适应算法");fprintf(fp,"\n**********************************************");break;case '2':fprintf(fp,"\n\n\n\n\t首次适应算法");fprintf(fp,"\n**********************************************");break;}fclose(fp);return fitMethod;}void inputJob(void) //输入作业的信息{int /*id,size, */status = 0,jobnum = 0;FILE *fp;char id[10],size[10];openFile(&fp,"d:\\job.cl","w");fprintf(fp,"作业名\t大小\t状态");printf("\n\n\n\n请输入作业名和大小!\n输入0 0退出，job_ID由数字组成\n\n\njob_ID\tsize\n");do{/* scanf("%d%d",&id,&size); */scanf("%s\t%s",id,size); //保存作业ID，大小if(atoi(id) > 0 && atoi(size) > 0){fprintf(fp,"\n%s\t%s\t%d",id,size,status);/* fprintf(fp,"\n%d\t%d\t%d",id,size,status); */jobnum++;}else break;}while(1);if(jobnum)printf("\n完成输入!");else{printf("\n没有请求分配内存.");errorMessage();}fclose(fp);}int makeJobList(struct jobList **jobs) //把作业插入分区{char jobID[10],size[10],status[10];struct jobList *rear;FILE *fp;openFile(&fp,"d:\\job.cl","r");fscanf(fp,"%s%s%s",jobID,size,status);if((*jobs = malloc(sizeof(struct jobList))) == NULL) //当没有空闲分区时{printf("\n没有足够空间.");fclose(fp);errorMessage();}rear = *jobs;(*jobs) -> next = NULL;while(!feof(fp)){struct jobList *p;fscanf(fp,"%s%s%s",jobID,size,status);if((p = malloc(sizeof(struct jobList))) == NULL){printf("\n没有足够空间.");fclose(fp);errorMessage();}p -> next = rear -> next; //插入已在分区的作业队列中rear -> next = p;rear = rear -> next;rear -> id = atoi(jobID);rear -> size = atoi(size);rear -> status = atoi(status);}fclose(fp);return 0;}int updateJobFile(struct jobList *jobs){FILE *fp;struct jobList *p;openFile(&fp,"d:\\job.cl","w");fprintf(fp,"job_ID\tsize\tstatus");for(p = jobs -> next;p;p = p -> next)fprintf(fp,"\n%d\t%d\t%d",p -> id,p -> size,p -> status);fclose(fp);return 0;}int showFreeList(struct freeList *empty) //在屏幕上显示空闲分区{FILE *fp;struct freeList *p = empty -> next;int count = 0;openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n显示空闲内存");printf("\n\n显示空闲内存");if(p){fprintf(fp,"\nnumber\tsize\tstartAddress");printf("\n序号\t大小\t开始地址"); //显示空闲分区的大小和首地址for(;p;p = p -> next){fprintf(fp,"\n%d\t%d\t%d",++count,p -> size,p -> startAddress);printf("\n%d\t%d\t%d",count,p -> size,p -> startAddress);}fclose(fp);return 1;}Else //没有空闲分区{fprintf(fp,"\n内存已分配完!");printf("\n内存已分配完!");fclose(fp);return 0;}}void getJobInfo(struct jobList *jobs,int id,int *size,int *status) //查找作业是否在分区中{struct jobList *p = jobs->next;while(p && p->id != id) //删除作业p = p->next;if(p == NULL){printf("\n不能找到作业: %d .",id);errorMessage();}else{*size = p -> size;*status = p -> status;}}void updateJobStatus(struct jobList **jobs,int id,int status) //改变作业的状态{struct jobList *p = (*jobs)->next;while(p && p->id != id)p = p->next;if(p == NULL){printf("\n不能找到作业: %d .",id);errorMessage();}p -> status = status; //作业状态}int showUsedList(struct jobList *jobs,struct usedList *used) //显示以分配的分区{FILE *fp;struct usedList *p = used -> next;int count = 0,size,status;openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n显示已分配的内存");printf("\n\n显示已分配的内存");if(p){fprintf(fp,"\nnumber\t作业名\t大小\t开始地址");printf("\nnumber\t作业名\t大小\t开始地址"); //显示分区中的作业信息for(;p;p = p -> next){getJobInfo(jobs,p -> jobID,&size,&status);fprintf(fp,"\n%d\t%d\t%d\t%d",++count,p -> jobID,size,p -> startAddress);printf("\n%d\t%d\t%d\t%d",count,p -> jobID,size,p -> startAddress);}fclose(fp);return 1;}Else //分区中没有作业{fprintf(fp,"\n内存中没有作业.");printf("\n内存中没有作业.");fclose(fp);return 0;}}int showJobList(struct jobList *jobs) //分区上的作业{struct jobList *p;p = jobs->next;if(p == NULL){printf("\n列表上没有作业.");return 0;}printf("\n\nT列表上的作业如下:\n作业名\t大小\t状态"); //显示作业信息while(p)printf("\n%d\t%d\t%d",p->id,p->size,p->status);p = p->next;}return 1;}void moveFragment(struct jobList *jobs,struct freeList **empty,struct usedList **used) //当回收一部分分区后，进行碎片紧凑{int size,status;struct usedList *p;int address = memoryStartAddress;if((*empty)->next == NULL) //当没有空闲分区分配时，可以回收已分配内存{printf("\n内存已用完.\\n你可以先回收一些内存或者\\n按任意键再试一次!");getch();return;}for(p = (*used) -> next;p;p = p-> next) //插入作业{p -> startAddress = address;getJobInfo(jobs,p -> jobID,&size,&status);address += size;}(*empty) -> next -> startAddress = address; //删除作业，回收内存(*empty) -> next -> size = memorySize - (address - memoryStartAddress);(*empty) -> next -> next = NULL;}void order(struct freeList **empty,int bySize,int inc) //按顺序排列分区的作业{struct freeList *p,*q,*temp;int startAddress,size;for(p = (*empty) -> next;p;p = p -> next){for(temp = q = p;q;q = q -> next){switch(bySize){case 0 : switch(inc){case 0:if(q->size < temp->size) //交换作业位置temp = q;break;default:if(q->size > temp->size)//交换作业位置temp = q;break;} break;default: switch(inc){case 0:if(q->startAddress < temp->startAddress)temp = q;break; //交换作业位置default:if(q->startAddress > temp->startAddress)temp = q;break; //交换作业位置} break;}}if(temp != p){startAddress = p->startAddress;size = p->size;p->startAddress = temp->startAddress;p->size = temp->size;temp->startAddress = startAddress;temp->size = size;}}}int allocate(struct freeList **empty,int size) //按要求把分区分该作业{struct freeList *p,*prep;int startAddress = -1;p = (*empty) -> next;while(p && p->size < size)//没有足够分区，删除作业p = p -> next;if(p != NULL){if(p -> size > size) //当有足够分区，直接分配{startAddress = p -> startAddress;p -> startAddress += size;p -> size -= size;}else //将整个分区分给一个作业{startAddress = p -> startAddress;prep = *empty;while(prep -> next != p)prep = prep -> next;prep -> next = p -> next;free(p);}}else printf("\n你可以拼接碎片."); /* Unsuccessful ! */return startAddress;}void insertUsedNode(struct usedList **used,int id,int startAddress)//在分区中插入作业{struct usedList *q,*r,*prer;if((q = malloc(sizeof(struct usedList))) == NULL) //没有足够空间时{printf("\nNot enough to allocate for the used node .");errorMessage();}q -> startAddress = startAddress; //插入作业q -> jobID = id;prer = *used;r = (*used) -> next;while(r && r->startAddress < startAddress){prer = r;r = r -> next;}q -> next = prer -> next;prer -> next = q;}int finishJob(struct usedList **used,int id,int *startAddress) //删除作业，回收分区{struct usedList *p,*prep;prep = *used;p = prep -> next;while(p && p -> jobID != id) //删除作业{prep = p;p = p -> next;}if(p == NULL){printf("\n作业: %d 不在内存!",id); //找不到要删除的作业return 0;}else{*startAddress = p->startAddress;prep -> next = p -> next;free(p);return 1;}}void insertFreeNode(struct freeList **empty,int startAddress,int size)//插入空闲分区{struct freeList *p,*q,*r;for(p = *empty;p -> next;p = p -> next) ;if(p == *empty || p -> startAddress + p -> size < startAddress)//对空闲分区进行排列{makeFreeNode(&r,startAddress,size);r -> next = p -> next;p -> next = r;return ;}if(p -> startAddress + p -> size == startAddress) //插入空闲分区{p -> size += size;return ;}q = (*empty) -> next;if(startAddress + size == q -> startAddress) //插入空闲分区{q -> startAddress = startAddress;q -> size += size;}else if(startAddress + size < q -> startAddress) //插入空闲分区{makeFreeNode(&r,startAddress,size);r -> next = (*empty) -> next;(*empty) -> next = r;}else{while(q -> next && q -> startAddress < startAddress) //插入空闲分区{p = q;q = q -> next;}if(p -> startAddress + p -> size == startAddress &&\q -> startAddress == startAddress + size) //插入空闲分区{p -> size += size + q -> size;p -> next = q -> next;free(q);}else if(p -> startAddress + p -> size == startAddress &&\q -> startAddress != startAddress + size) //插入空闲分区{p -> size += size;}else if(p -> startAddress + p -> size != startAddress &&\q -> startAddress == startAddress + size) //插入空闲分区{q -> startAddress = startAddress;q -> size += size;}else{makeFreeNode(&r,startAddress,size); //申请作业空间r -> next = p -> next;p -> next = r;}}}void main(void){char fitMethod; //定义变量FILE *fp; //定义变量struct jobList *jobs; //定义一个队列struct freeList *empty;//定义一个队列struct usedList *used;//定义一个队列if((used = malloc(sizeof(struct usedList))) == NULL){printf("\n没有足够空间.");errorMessage();}used -> next = NULL;remove("d:\\result.cl");makeFreeNode(&empty,0,0);while(1) //界面设计{char ch,step; //定义变量int id,size,startAddress,status; //定义变量struct jobList *q;printf("\n 1 输入作业的信息.\\n 2 作业放到内存.\\n 3 完成作业,并回收内存.\\n 4 当前空闲的内存.\\n 5 当前已分配的内存.\\n 6 拼接碎片.\\n 7 退出.");printf("\n请选择.\n");step = getche();printf("\n");switch(step){case '1': //当选择1时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t输入作业的信息:)");used -> next = NULL; //初始化队列empty->next = NULL; //初始化队列iniMemory();makeFreeNode(&(empty->next),memoryStartAddress,memorySize);fprintf(fp,"\n\n\n你用文件形式输入吗?(Y/N) : ");//是否用文件形式输出printf("\n\n\n你用文件形式输入吗?(Y/N ): \n");ch = getche();fprintf(fp,"\n%c",ch);fclose(fp);if(ch != 'Y'&& ch != 'y') //当选择用文件形式输出时{inputJob();}makeJobList(&jobs);if(ch == 'Y'|| ch == 'y') //读入文件的作业信息{for(q = jobs->next;q;q = q->next){if(q->status == 1){startAddress = allocate(&empty,q->size);if(startAddress != -1){insertUsedNode(&used,q->id,startAddress);}}}}fitMethod = selectFitMethod();break;case '2': //当选择2时if(memoryStartAddress < 0 || memorySize < 1){printf("\n\nBad memory allocated !\a");break;}openFile(&fp,"d:\\result.cl","a"); //打开文件fprintf(fp,"\n\n\t把作业放到内存");fprintf(fp,"\n\n\n你用键盘输入作业信息吗?(Y/N): ");printf("\n\n\n你用键盘输入作业信息吗?(Y/N): \n");ch = getche();fprintf(fp,"\n%c",ch);fclose(fp);if(ch != 'Y' && ch != 'y') //把作业放到分区中{for(q = jobs->next;q;q = q->next){if(q->status == 0){switch(fitMethod) //用不同分区管理算法{case '1': order(&empty,0,0);break;case '2': order(&empty,0,1);break;case '3': order(&empty,1,0);break;case '4': order(&empty,1,1);break;}startAddress = allocate(&empty,q->size);if(startAddress != -1){insertUsedNode(&used,q->id,startAddress);//把作业插入到以分配内存中updateJobStatus(&jobs,q->id,1);}}}updateJobFile(jobs);}else{showJobList(jobs); //显示可操作的作业openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n请从上面的作业中选择一个作业，输入作业名.");printf("\n请从上面的作业中选择一个作业，输入作业名.");scanf("%d",&id);fprintf(fp,"%d\n",id);getJobInfo(jobs,id,&size,&status); //把作业放入内存switch(status) //作业的不同状态{case 0: printf("\nOk !作业的状态是运行状态!");fprintf(fp,"\nOk!作业的状态是运行状态!");fclose(fp);break;case 1: printf("\n作业在内存中!");fprintf(fp,"\n作业在内存中!");fclose(fp);goto label;case 2: printf("\n作业已完成!");fprintf(fp,"\n作业已完成!");fclose(fp);goto label;default:printf("\nUnexpected job status .Please check you job file.");fprintf(fp,"\nUnexpected job status .Please check you job file.");fclose(fp);errorMessage();}switch(fitMethod) //不同分区管理方法的实现{case '1': order(&empty,0,0);break;case '2': order(&empty,0,1);break;case '3': order(&empty,1,0);break;case '4': order(&empty,1,1);break;}startAddress = allocate(&empty,size);if(startAddress != -1){insertUsedNode(&used,id,startAddress); //插入作业updateJobStatus(&jobs,id,1); //改变作业状态updateJobFile(jobs);}}label : ;break;case '3': //当选择3时if(memoryStartAddress < 0 || memorySize < 1){printf("\n\nBad memory allocated !\a");break;}do{int i;openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t作业完成(回收内存)");fclose(fp);if(showUsedList(jobs,used) == 0)break;openFile(&fp,"d:\\result.cl","a"); //打开文件fprintf(fp,"\n请从上面的作业中选择一个作业，输入作业名.\n输入-1来结束测试.");printf("\n请从上面的作业中选择一个作业，输入作业名.\n 输入-1来结束测试.");scanf("%d",&id);fprintf(fp,"%d\n",id);fclose(fp);if(id == -1)break;getJobInfo(jobs,id,&size,&status); //把作业放入内存if(status == 1) //作业状态为运行时{i = finishJob(&used,id,&startAddress);if(i){insertFreeNode(&empty,startAddress,size); //插入空闲分区updateJobStatus(&jobs,id,2); //改变作业状态updateJobFile(jobs);}}else{if(status == 0 || status == 2){if(status == 0)printf("\n作业不在内存中!");else printf("\n作业已完成!");}else{printf("\nUnexpected job status .\Please check you job file.");errorMessage();}}}while(1);break;case '4': //当选择4时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t显示空闲内存");fclose(fp);showFreeList(empty);break;case '5': //当选择5时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t显示已分配内存");fclose(fp);showUsedList(jobs,used);break;case '6': //当选择6时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t拼接碎片");fclose(fp);moveFragment(jobs,&empty,&used);break;case '7': //当选择7时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\tExit :(");fclose(fp);exit(0);default: printf("\n错误输入!");}}getch();}五．运行效果：1．运行EXE文件：2．首先要选择1，输入要分配内存的首地址，分区大小，输入作业的信息：3．按ENTER键后，选择分区管理算法：4．然后选择2,把作业放到内存：5．到此，用户就可以选择自己想要的操作功能，这里3为例：6．用户也可以选择其他功能，这里不作介绍。

存储管理实验报告总结本次实验主要是针对存储管理进行的。

存储管理是操作系统中非常重要的一部分，它负责管理计算机系统的内存空间，为进程提供必要的存储资源。

通过本次实验，我对存储管理的相关概念和技术有了更加深入的了解。

在实验中，我首先学习了存储管理的基本原理。

操作系统将内存分为若干个大小相等的页框，而进程的内存空间则被划分为若干个大小相等的页。

通过页表的映射关系，操作系统可以将进程的页映射到物理内存的页框上。

这样，进程就可以方便地访问内存中的数据。

在实验中，我还学习了虚拟内存的概念和实现方法。

虚拟内存是一种扩展内存的方法，它允许进程访问超出物理内存容量的数据。

虚拟内存通过将进程的页映射到磁盘上的页面文件中，实现了内存的扩展。

当进程需要访问某个页面时，操作系统会将该页面从页面文件中加载到物理内存中，并更新页表的映射关系。

在实验中，我还学习了页面置换算法的原理和实现。

页面置换算法是虚拟内存中非常重要的一部分，它负责决定哪些页面需要被置换出去。

常见的页面置换算法有FIFO算法、LRU算法和Clock算法等。

不同的算法有着不同的性能特点和适用场景，我们需要根据具体的应用场景选择合适的页面置换算法。

在实验中，我还学习了内存分配和回收的方法。

操作系统通过内存分配算法为进程分配内存空间，而通过内存回收算法回收进程不再使用的内存空间。

内存分配算法的选择会影响到系统的性能和资源利用率，我们需要根据具体的应用场景选择合适的内存分配算法。

通过本次实验，我深入了解了存储管理的相关概念和技术。

存储管理是操作系统中非常重要的一部分，它直接影响到系统的性能和资源利用率。

合理地管理存储资源可以提高系统的运行效率和稳定性，从而提升用户的体验。

在今后的学习和工作中，我将进一步深化对存储管理的理解，不断提升自己的技术水平。

操作系统实验实验五虚拟存储器管理学号 1115102015 姓名方茹班级 11电子A 华侨大学电子工程系实验五虚拟存储器管理实验目的1、理解虚拟存储器概念。

2、掌握分页式存储管理地址转换盒缺页中断。

实验内容与基本要求1、模拟分页式存储管理中硬件的地址转换和产生缺页中断。

分页式虚拟存储系统是把作业信息的副本存放在磁盘上，当作业被选中时，可把作业的开始几页先装入主存且启动执行。

为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存。

作业执行时，指令中的逻辑地址指出了参加运算的操作存放的页号和单元号，硬件的地址转换机构按页号查页表，若该页对应标志为“1”，则表示该页已在主存，这时根据关系式“绝对地址=块号×块长+单元号”计算出欲访问的主存单元地址。

如果块长为2 的幂次，则可把块号作为高地址部分，把单元号作为低地址部分，两者拼接而成绝对地址。

若访问的页对应标志为“0”，则表示该页不在主存，这时硬件发“缺页中断”信号，有操作系统按该页在磁盘上的位置，把该页信息从磁盘读出装入主存后再重新执行这条指令。

设计一个“地址转换”程序来模拟硬件的地址转换工作。

当访问的页在主存时，则形成绝对地址，但不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行。

当访问的页不在主存时，则输出“* 该页页号”，表示产生了一次缺页中断。

2、用先进先出页面调度算法处理缺页中断。

FIFO 页面调度算法总是淘汰该作业中最先进入主存的那一页，因此可以用一个数组来表示该作业已在主存的页面。

假定作业被选中时，把开始的m 个页面装入主存，则数组的元素可定为m 个。

实验报告内容1、分页式存储管理和先进先出页面调度算法原理。

分页式存储管理的基本思想是把内存空间分成大小相等、位置固定的若干个小分区，每个小分区称为一个存储块，简称块，并依次编号为0，1，2，3,……，n块，每个存储块的大小由不同的系统决定，一般为2的n次幂，如1KB，2 KB，4 KB等，一般不超过4 KB。