操作系统实验四存储管理

实验四页式虚拟存储管理中地址转换和缺页中断一、实验目的深入了解页式存储管理如何实现地址转换；进一步认识页式虚拟存储管理中如何处理缺页中断。

二、实验预备知识页式存储管理中地址转换的方法；页式虚拟存储的缺页中断处理方法。

三、实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。

实验具体包括：首先对给定的地址进行地址转换工作，若发生缺页则先进行缺页中断处理，然后再进行地址转换；最后编写主函数对所做工作进行测试。

假定主存64KB，每个主存块1024字节，作业最大支持到64KB，系统中每个作业分得主存块4块。

四、提示与讲解页式存储管理中地址转换过程很简单，假定主存块的大小为2n字节，主存大小为2m'字节和逻辑地址m位，则进行地址转换时，首先从逻辑地址中的高m-n位中取得页号，然后根据页号查页表，得到块号，并将块号放入物理地址的高m'-n位，最后从逻辑地址中取得低n位放入物理地址的低n位就得到了物理地址，过程如图6所示。

逻辑地址图6 页式存储管理系统地址转换示意图地址转换是由硬件完成的，实验中使用软件程序模拟地址转换过程，模拟地址转换的流程如图7所示（实验中假定主存64KB，每个主存块1024字节，即n=10,m'=16，物理地址中块号6位、块内地址10位；作业最大64KB，即m=16，逻辑地址中页号6位、页内地址10位）。

在页式虚拟存储管理方式中，作业信息作为副本放在磁盘上，作业执行时仅把作业信息的部分页面装入主存储器，作业执行时若访问的页面在主存中，则按上述方式进行地址转换，若访问的页面不在主存中，则产生一个“缺页中断”，由操作系统把当前所需的页面装入主存储器后，再次执行时才可以按上述方法进行地址转换。

页式虚拟存储管理方式中页表除页号和该页对应的主存块号外，至少还要包括存在标志（该页是否在主存），磁盘位置（该页的副本在磁盘上的位置）和修改标志（该页是否修改过）。

实验四存储管理背景知识耗尽内存是Windows 2000/XP系统中最常见的问题之一。

当系统耗尽内存时，所有进程对内存的总需求超出了系统的物理内存总量。

随后，Windows 2000/XP必须借助它的虚拟内存来维持系统和进程的运行。

虚拟内存机制是Windows 2000/XP操作系统的重要组成部分，但它的速度比物理内存慢得多，因此，应该尽量避免耗尽物理内存资源，以免导致性能下降。

解决内存不足问题的一个有效的方法就是添加更多的内存。

但是，一旦提供了更多的内存，Windows 2000/XP很可以会立即“吞食”。

而事实上，添加更多的内存并非总是可行的，也可能只是推迟了实际问题的发生。

因此，应该相信，优化所拥有的内存是非常关键的。

1. 分页过程当Windows 2000/XP求助于硬盘以获得虚拟内存时，这个过程被称为分页(paging) 。

分页就是将信息从主内存移动到磁盘进行临时存储的过程。

应用程序将物理内存和虚拟内存视为一个独立的实体，甚至不知道Windows 2000/XP使用了两种内存方案，而认为系统拥有比实际内存更多的内存。

例如，系统的内存数量可能只有16MB，但每一个应用程序仍然认为有4GB内存可供使用。

使用分页方案带来了很多好处，不过这是有代价的。

当进程需要已经交换到硬盘上的代码或数据时，系统要将数据送回物理内存，并在必要时将其他信息传输到硬盘上，而硬盘与物理内存在性能上的差异极大。

例如，硬盘的访问时间通常大约为4-10毫秒，而物理内存的访问时间为60 us，甚至更快。

2. 内存共享应用程序经常需要彼此通信和共享信息。

为了提供这种能力，Windows 2000/XP必须允许访问某些内存空间而不危及它和其他应用程序的安全性和完整性。

从性能的角度来看，共享内存的能力大大减少了应用程序使用的内存数量。

运行一个应用程序的多个副本时，每一个实例都可以使用相同的代码和数据，这意味着不必维护所加载应用程序代码的单独副本并使用相同的内存资源。

实验三存储管理【实验目的和要求】1、请求页式存储管理中页面置换算法模拟设计。

2、了解虚拟存储技术的特点。

3、掌握请求页式存储管理的页面置换算法。

【实验原理】1、存储管理的主要功能之一是合理地分配空间。

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

3、命中率=1-(页面失效次数/页地址流长度)。

本实验页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。

【实验步骤】一、问题描述与分析1、通过随机数产生一个指令序列，共320条指令。

指令的地址按下述原则生成：(1)50%的指令是顺序执行的；(2)25%的指令是均匀分布在前地址部分；(3)25%的指令是均匀分布在后地址部分。

具体的实施方法是：(1)在[0,319]的指令地址之间随机选取一起点m；(2)顺序执行一条指令，即执行地址为m+l的指今；(3)在前地址[0,m+l]中随机选取一条指令并执行，该指令的地址为m’；(4)顺序执行一条指今，其地址为m’ +l；(5)在后地址[m’ +2,319]中随机选取一条指令并执行；(6)重复上述步骤(1)一(5)，直到执行320次指令。

2、将指令序列变换成为页地址流(1)页面大小为1K；(2)用户内存容量为4页到32页；(3)用户虚存容量为32K。

在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条~第9条指令为第0页(对应虚存地址为[0,9])；第10条~第19条指令为第1页(对应虚存地址为[10, l9])；……第310条~第319条指令为第31页(对应虚存地址为[310,3191])；按以上方式，用户指令可组成32页。

3、考虑计算并输出下述各种算法在不同内存容量下的命中率。

(1)先进先出的算法(FIFO) ；(2)最近最少使用算法(LRU)；其中(1)和(2)必做三、程序设计与调试在VC++6.0环境下进行程序设计和调试。

程序分析：问题1：怎样使模拟的指令随机？答：通过使用C++的rand函数生成随机数，来产生指令，并用算法保证指定指令序列的需求。

实验四固定分区存储管理一、实验目的通过编写固定分区存储管理的模拟程序，加深对操作系统存储管理功能中的固定分区管理方式、主存分配表等相应知识的理解。

二、实验内容（1）作业J3请求资源，申请5K大小的内存空间；（2）作业J4申请33K大小的内存空间；（3）作业J1执行完毕，释放空间4、编写程序实现相应存储空间的分配和去配，若请求成功，修改主存分配表，并输出该表，若请求不能满足，输出“分配失败”。

（其中不考虑空闲分区的移动）。

实验代码：#include<stdio.h>#include<vector>#include<string>#include<string.h>#include<iostream>using namespace std;//定义进程资源类class Resource{public :string name; //用来表示占用进程int num; //用来标识分区号int begin; //用来存放其实地址int length; //用来标识内存长度int take; //用来表示当前的该资源是否被占用Resource(int n,int b,int l,int t){num = n;begin = b;length = l;take = t;}};//定义输出类class Output{public :string o_name;int o_num;int o_begin;int o_length;int o_take;};//申请资源请求bool Request(string name,int len,vector<Resource> &res) {vector<Resource *> r;//!!!!!!!!在这边定义一个指针，用来指向res，这里的好处是待会进行排序的时候，不会修改原来的res原来元素的顺序！！！！for(int m=0;m<res.size();m++){r.push_back(&res[m]);}//按书上所说的，首先对分区进行从小到大进行排序。

操作系统存储管理实验报告一、实验目的本次实验的目的是通过编写一段程序，实现对内存的分配和回收操作，并验证算法的正确性和性能。

二、实验内容1.实现首次适应算法首次适应算法是一种动态分配的内存管理算法，通过从低地址往高地址内存块，找到第一个满足需求的空闲块进行分配。

具体实现过程如下：（1）初始化内存空间，设置内存块的大小和地址范围；（2）编写一个函数，实现内存的分配操作，根据需求大小找到第一个合适的空闲块，并在其前后设置相应的标志位；（3）编写一个函数，实现内存的回收操作，根据释放块的地址，将其前后的标志位进行合并；（4）模拟应用程序的运行，测试内存的分配和回收操作。

2.实现最佳适应算法最佳适应算法是一种动态分配的内存管理算法，通过整个内存空间，找到最小的满足需求的空闲块进行分配。

具体实现过程如下：（1）初始化内存空间，设置内存块的大小和地址范围；（2）编写一个函数，实现内存的分配操作，遍历整个内存空间，找到满足需求且大小最小的空闲块进行分配；（3）编写一个函数，实现内存的回收操作，根据释放块的地址，将其前后的标志位进行合并；（4）模拟应用程序的运行，测试内存的分配和回收操作。

三、实验结果1.首次适应算法经过测试，首次适应算法能够正确地进行内存的分配和回收操作，并且算法的性能良好。

尽管首次适应算法在分配过程中可能会产生碎片，但是由于它从低地址开始，可以在较短的时间内找到满足需求的空闲块。

在实际应用中，首次适应算法被广泛采用。

2.最佳适应算法经过测试，最佳适应算法能够正确地进行内存的分配和回收操作，并且算法的性能较好。

最佳适应算法会整个内存空间，找到大小最小的满足需求的空闲块。

因此，在分配过程中不会产生很多的碎片，但是算法的执行时间较长。

四、实验总结通过本次实验，我们成功地实现了首次适应算法和最佳适应算法，并对算法的正确性和性能进行了验证。

两种算法在内存的分配和回收过程中都表现出良好的性能，可广泛应用于实际场景中。

操作系统课程实验年级2012 级专业计算机科学与技术（应用型）姓名学号指导教师日期实验四、存储管理实验一、关键问题1、实验目的理解内存分配和回收原理。

2、实验环境Ubuntu 8.0或者以上，Eclipse集成开发环境3、实验内容3.1 在控制台内观察Linux内存分配情况3.2存储管理模拟实验要求：写一动态分区管理程序，使其内存分配采用最佳适应分配算法。

老师所给的例子为内存分配算法是最先适应分配算法的系统模拟动态分区管理方案，而问题的关键就是如何把最先适应分配算法改为最佳适应分配算法。

二、设计修改思路struct freearea* min1=NULL;//定义了一个符合条件的最小空白块链表首先我们在分配内存函数中需要定义一个记录符合条件的最小空白块的链表结构指针，对当前空闲分区链进行遍历，找到符合条件的最小空白块并记录。

系统为作业分配内存时，根据指针freep查找空闲分区链。

当找到一块可以满足请求中最小的空闲分区时便分配。

当空间被分配后剩余的空间大于规定的碎片，则形成一个较小的空闲分区留在空闲链中。

三、实现修改的关键代码//有两个链:空白块链及作业链.空白块链描述空白块,链首指针freep,初始为一大块空白块.//作业链按从高址到低址的顺序链接,链首指针jobp//为作业jn分配jl大小内存，起始地址为javoid ffallocation(int jl,char jn[10],int* ja){struct mat* jp=NULL;//作业链当前节点struct mat* jp2=NULL;//新的作业节点struct mat* jp1=NULL;//struct freearea* fp=NULL;//当前空白块struct freearea* min1=NULL;//定义了一个符合条件的最小空白块链表int flag=0;int i;*ja=-1;if (totalfree<jl) //剩余空间大小不能满足作业要求return;fp=freep;while (fp!=NULL){if (fp->freesize>jl){ min1=fp;flag=1;break;}fp=fp->next;}if(freep->next!=NULL&&flag==0) {*ja=0;return;}fp=min1->next;while (fp!=NULL){if (fp->freesize>jl&&fp->freesize<min1->freesize)min1=fp;fp=fp->next;//当前空白块大小不满足要求}jobnumber++;totalfree=totalfree-jl;jp2=calloc(1,sizeof(struct mat));//在节点上登记为该作业分配的内存空间// for (i=0;i<10;i++) (jp2->jobname)[i]=' ';i=-1;while(jn[++i])(jp2->jobname)[i]=jn[i];(jp2->jobname)[i]='\0';jp2->joblength=jl;jp2->jobaddress=min1->freeaddress;//登记该作业的起始地址(块的最低地址)*ja=jp2->jobaddress;//将节点jp2插入作业链jobp,按高址到低址的顺序。

操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分，它直接影响着系统的性能和资源利用率。

本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法，通过实际操作和观察，掌握存储分配、回收、地址转换等关键技术，并对不同存储管理策略的性能进行分析和比较。

二、实验环境本次实验在 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、引言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 实验展望- 探讨存储管理领域的未来发展方向- 提出对本实验的改进意见和建议附件：无法律名词及注释：- 存储管理：操作系统中负责管理内存的任务，包括内存分配、回收和管理等功能。

实验四可变分区存储管理学时：4学时⒈实验内容主存储器空间分配实验。

⒉实验目的通过首次适应算法、最佳适应算法和最坏适应算法实现主存空间的分配，可以使读者可好地理解存储分配算法。

⒊实验题目编写一段程序来模拟可变分区管理方法。

要求能通过文件形式定义空闲区表；能随意输入作业及需要分配的空间；能分别使用首次适应算法、最佳适应算法和最坏适应算法对输入的作业进行空间分配；能显示系统空闲表和已分配空间表。

⒋实验提示⑴可变分区方式是按作业需要的主存空间大小来分区。

当装入一个作业时，首先要查看是否有足够的空闲空间来分配，若有则按指定的分配方式进行分配；否则作业不能装入。

随着作业的装入和撤离主存空间被分为若干个大大小小的不连续的区间，为了表明各区间的状态可以用一个内存分区表如表1所示来表示。

表1 内存分区表这样我们可以定义一个如下的结构表示内存分区信息。

typedef struct node{int start; //起始地址int length; //长度char tag[20]; //标志}job;⑵可变分区的三种算法就是为作业分配主存空间的方法。

●首次适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入第一个满足条件的空间中去。

●最佳适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最小的一个空间中去。

●最坏适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最大的一个空间中去。

从三种算法的说明可以看出，分配空间的过程主要可以分两步：●查询所有满足作业需求的空间块。

●按照指定的算法将作业装入空间块中。

⑶在操作的最初主存空间实际就是一个大的空闲区，不涉及到如何分配的问题。

为直接模拟运行一段时间后主存中出现了多个空闲块的状态，题目要求从一个文件读入空闲区表。

在这里我们可以设计一个空闲区表文件的结构为如表2所示：表2 空闲区表这样也可以方便地将空闲表一次读入程序中，而不必再一个个的输入。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验四存储管理班级：计科f1406 姓名：王家平学号：201416010619一、实验目的：通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。

二、实验内容：1)通过随机数产生一个指令序列，共320条指令；2)将指令序列变换为页面号；3)计算FIFO算法在分配不同内存块下的命中率。

（假设分配的内存块从4块至32块。

）注：命中率=1-缺页率。

“命中”的含义即不缺页。

要访问的指令正在内存物理块中。

三、<程序设计>设计一个虚拟存储区和内存工作区，使用FIFO算法计算访问命中率。

首先用Srand（）和rand（）函数定义和产生指令序列，然后将指令序列变换成相应的页面号，并针对FIFO算法计算相应的命中率。

命中率=1-缺页率相关定义如下：1.数据结构（1）页面类型结构pl_type中pn页号，pfn块号，counter为一个周期内访问页面次数，time为访问时间（2）页面控制结构中pfc[total_vp]定义用户进程虚页控制结构*freepf_head为空页面头的指针*busypf_head为忙页面头的指针*busypf_tail为忙页面尾的指针2．函数定义（1）void initialize（）：初始化函数，给每个相关的页面赋值（2）void FIFO（）：计算使用FIFO算法时的命中率3.变量定义（1）int a[total_instruction]：指令流数组（2）int page[total_instruction]：每条指令所属页号（3）int offset[total_instruction]：每页装入10条指令后取模运算页号偏移值（4）int total_pf：用户进程的内存块数（5）int diseffect：页面失效次数，即缺页次四、源代码：#include <math.h>#include <stdio.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define INVALID -1#define NULL 0#define total_instruction 320 /*指令流长*/#define total_vp 32 /*虚页长*/#define clear_period 50 /*清零周期*/typedef struct{ /*页面结构*/int pn,pfn,counter,time;}pl_type;pl_type pl[total_vp]; /*页面结构数组*/struct pfc_struct{ /*页面控制结构*/int pn,pfn;struct pfc_struct *next;};struct pfc_struct pfc[total_vp],*freepf_head, *busypf_head, *busypf_tail;int diseffect, a[total_instruction];int page[total_instruction], offset[total_instruction];void initialize();void FIFO( );void LRU( );void OPT( );void LFU();void CLOCK( );void NRU( );int main(){int S,i;srand(10*getpid());/*由于每次运行时进程号不同，故可用来作为初始化随机数队列的“种子”*/S=(int)(319.0*rand()/RAND_MAX)+1;for(i=0;i<total_instruction;i+=4) /*产生指令队列*/{a[i]=S; /*任选一指令访问点*/a[i+1]=a[i]+1; /*顺序执行下一条指令*/a[i+2]=(int)(1.0*a[i]*rand()/RAND_MAX); /*执行前地址指令m'*/a[i+3]=a[i+2]+1; /*执行后地址指令*/S=(int)(1.0*rand()*(318-a[i+2])/RAND_MAX)+a[i+2]+2;for(i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/ {page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++) /*用户内存工作区从4个页面到32个页面*/ {printf("%2d page frames\t",i);FIFO(i);LRU(i);NRU (i);OPT(i);SCR(i);CLOCK(i);}return 0;}void initialize(int total_pf) /*初始化相关数据结构*/{int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; /*置页面控制结构中的页号，页面为空*/pl[i].counter=0;pl[i].time=-1; /*置页面控制结构中的访问次数，时间为-1*/}for(i=1;i<total_pf;i++){pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;} /*建立pfc[i-1]和pfc[i]之间的链接*/pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0];/*空页面队列的头指针为pfc[0]*/}void FIFO(int total_pf){int i;struct pfc_struct *p;initialize(total_pf); /*初始化相关页面控制用数据结构*/busypf_head=busypf_tail=NULL; /*忙页面队列，队列尾链接*/ for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect+=1; /*失效次数*/if(freepf_head==NULL) /*无空闲页面*/{p=busypf_head->next;pl[busypf_head->pn].pfn=INVALID;freepf_head=busypf_head; /*释放忙页面队列中的第一个页面*/ freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next; /*按FIFO方式调新页面入内存页面*/ freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL) busypf_head=busypf_tail=freepf_head;else{busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%6.4f ",1-(float)diseffect/320);}void LRU(int total_pf){ }void NRU(int total_pf){ }void OPT(int total_pf){ }void LFU(int total_pf) { }void CLOCK(int total_pf) { }。

集美大学计算机工程学院实验报告课程名称：操作系统班级：计算1014指导教师：李传目姓名：林升仁实验项目编号：实验四学号：2010810116实验项目名称：存储管理实验成绩：一、目的理解动态异长存储分区资源管理，掌握所需数据结构和管理程序，了解各种存储分配算法的优点和缺点。

二、实验内容与设计思想分析UNIX最先适应(FF)存储分配算法，即map数据结构、存储分配函数malloc()和存储释放函数mfree()，找出与算法有关的成分。

修改上述与算法有关的成分，使其分别体现BF分配原则和WF分配原则。

三、实验使用环境Red Hat Enterprise linux5四、实验结果源程序：/******************************************************************** ******** Copyright (C) 2004 by root** root@simplymepis**** This program is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as pub lished by ** the Free Software Foundation; either version 2 of the License, or ** (at your option) any later version. * *** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. * *** You should have received a copy of the GNU General Public License ** along with this program; if not, write to the ** Free Software Foundation, Inc.,** 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.********************************************************************** ******/#ifdef HAVE_CONFIG_H#include <config.h>#endif#include <stdio.h>#include <stdlib.h>#define MAPSIZE 116struct map //存储资源表结构{/* char *m_size;char *m_addr;*/int m_addr;int m_size;};struct map map[MAPSIZE]; //存储资源表int FF_malloc(struct map *mp,int size) //存储分配函数{register int a,s;register struct map *bp,*bpp;for(bp = mp; bp->m_size; bp++){if (bp->m_size >= size){a = bp->m_addr;s = bp->m_size;for(bpp = bp; bpp->m_size; bpp++)//最先适应{if(bpp->m_size >= size && bpp->m_addr<=a){a = bpp->m_addr;s = bpp->m_size;bp = bpp;}}bp->m_addr += size;if ((bp->m_size -=size) == 0)do{bp++;(bp-1)->m_addr = bp->m_addr;}while((bp-1)->m_size = bp->m_size);return(a);}}return(-1);}void mfree(struct map *mp,int aa,int size) //存储释放函数{register struct map *bp;register int t;register int a;a = aa;for(bp = mp; bp->m_addr<=a && bp->m_size != 0; bp++) ;if(bp>mp && (bp-1)->m_addr+(bp-1)->m_size==a){ //与前合并(bp-1)->m_size += size;if (a+size == bp->m_addr){ //前后合并(bp-1)->m_size += bp->m_size;while (bp->m_size){bp++;(bp-1)->m_addr = bp->m_addr;(bp-1)->m_size = bp->m_size;}}}else{if (a+size == bp->m_addr && bp->m_size){ //与后合并bp->m_addr -= size;bp->m_size += size;}else if (size)do{ //无合并t = bp->m_addr;bp->m_addr = a;a = t;t = bp->m_size;bp->m_size = size;bp++;}while (size = t);}}void init(){struct map *bp;int addr,size;int i=0;bp=map;printf("Please input starting addr and total size:");scanf("%d,%d",&addr,&size);bp->m_addr=addr;bp->m_size=size;(++bp)->m_size=0; //表尾}void show_map(){int i=0;system("clear"); //调用清屏命令struct map *bp;bp=map;printf("\nCurrent memory map...\n");printf("Address\t\tSize\n");while(bp->m_size!=0){printf("<%d\t\t%d>\n",bp->m_addr,bp->m_size);bp++;}printf("\n");}main(){int a,s;int c;int i;init();do{//显示存储分配表show_map();printf("Please input, 1 for request,2 for release, 0 for exit:");scanf("%d",&c);switch(c){case 1:printf("Please input size:");scanf("%d", &s);if((a=FF_malloc(map,s))==-1) //call mallocprintf("request can't be satisfied\n");elseprintf("alloc memory at address:%d,size:%d\n",a,s);break;case 2:printf("Please input addr and size:");scanf("%d,%d",&a,&s);mfree(map,a,s);break;case 0:exit(0);}}while(1);}运行结果：五、实验分析上述算法沿用了UNIX系统所采用的数据结构，存储分配表中空闲区按m_addr 递增排列，对于任意请求，需要由表头查到表尾才能确定最佳（最坏）分配区域。

宁德师范学院计算机系
实验报告
（2014—2015学年第二学期）
课程名称操作系统
实验名称实验四存储管理
专业计算机科学与技术（非师）年级2012级
学号B2012102147 姓名王秋指导教师王远帆
实验日期2015-05-20
图1 word运行情况
“内存使用”列显示了该应用程序的一个实例正在使用的内存数量。

启动应用程序的另一个实例并观察它的内存需求。

请描述使用第二个实例占用的内存与使用第一个实例时的内存对比情况：第二个实例占用内存22772K，比第一个实例占用的内存大很多
2、教师批改学生实验报告应在学生提交实验报告10日内。

实验四存储器管理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将制定分区链入自由链,若该分区有前邻或后邻分区，则将他们拼成一个较大的空区。

当某个分配请求不能被满足,但此时系统中所有碎片总容量满足分配请求的容量时，系统立即进行内存搬家，消除碎片.即将各作业占用区集中下移到用户内存区的下部（高地址部分)，形成一片连续的作业区,而在用户内存区的上部形成一块较大的空闲，然后再进行分配。

操作系统实验报告4一、实验目的本次操作系统实验的目的在于深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关操作，通过实际的实验操作，增强对操作系统原理的理解和应用能力，提高解决实际问题的能力。

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

三、实验内容与步骤（一）进程管理实验1、进程创建与终止使用 C+＋语言编写程序，创建多个进程，并在进程中执行不同的任务。

通过进程的标识符（PID）来监控进程的创建和终止过程。

2、进程同步与互斥设计一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。

观察生产者和消费者进程在不同情况下的执行顺序和结果。

（二）内存管理实验1、内存分配与释放编写程序，使用动态内存分配函数（如｀malloc` 和｀free`）来分配和释放内存。

观察内存的使用情况和内存泄漏的检测。

2、内存页面置换算法实现几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法和最佳置换（OPT）算法。

通过模拟不同的页面访问序列，比较不同算法的性能。

（三）文件系统实验1、文件创建与读写使用 C+＋语言的文件操作函数，创建一个新文件，并向文件中写入数据。

从文件中读取数据，并进行数据的处理和显示。

2、文件目录操作实现对文件目录的创建、删除、遍历等操作。

观察文件目录结构的变化和文件的组织方式。

四、实验结果与分析（一）进程管理实验结果与分析1、进程创建与终止在实验中，成功创建了多个进程，并通过控制台输出观察到了每个进程的 PID 和执行状态。

可以看到，进程的创建和终止是按照程序的逻辑顺序进行的，操作系统能够有效地管理进程的生命周期。

2、进程同步与互斥在生产者消费者问题的实验中，通过信号量的控制，生产者和消费者进程能够正确地实现同步与互斥。

当缓冲区为空时，消费者进程等待；当缓冲区已满时，生产者进程等待。