存储管理实验报告.doc
存储器管理实验实验报告
存储器管理实验实验报告一、实验目的存储器管理是操作系统的重要组成部分，本次实验的目的在于深入理解存储器管理的基本原理和方法，通过实际操作和观察，掌握存储器分配与回收的算法，以及页面置换算法的实现和性能评估。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容与步骤（一）存储器分配与回收算法实现1、首次适应算法（1）原理：从空闲分区链的首地址开始查找，找到第一个满足需求的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态（已分配或空闲）。
当有分配请求时，从链表头部开始遍历，找到第一个大小满足需求的空闲分区。
将该分区进行分割，一部分分配给请求，剩余部分仍作为空闲分区留在链表中。
若找不到满足需求的空闲分区，则返回分配失败。
2、最佳适应算法（1）原理：从空闲分区链中选择与需求大小最接近的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历整个链表，计算每个空闲分区与需求大小的差值。
选择差值最小的空闲分区进行分配，若有多个差值相同且最小的分区，选择其中起始地址最小的分区。
对选中的分区进行分割和处理，与首次适应算法类似。
3、最坏适应算法（1）原理：选择空闲分区链中最大的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历链表，找到最大的空闲分区。
对该分区进行分配和处理。
（二）页面置换算法实现1、先进先出（FIFO）页面置换算法（1）原理：选择在内存中驻留时间最久的页面进行置换。
（2）实现步骤：建立页面访问序列。
为每个页面设置一个进入内存的时间戳。
当发生缺页中断时，选择时间戳最早的页面进行置换。
2、最近最久未使用（LRU）页面置换算法（1）原理：选择最近一段时间内最长时间未被访问的页面进行置换。
操作系统存储器管理实验报告.doc
一目的与要求(1) 请求页式虚存管理是常用的虚拟存储管理方案之一。
(2) 通过请求页式虚存管理中对页面置换算法的模拟，加深理解虚拟存储技术的特点。
(3) 模拟页式虚拟存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断.二实验内容或题目(1)本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。
(2)虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。
(3)要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。
(4)程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。
三实验步骤与源程序（1）实验步骤1、理解好相关实验说明。
2、根据实验说明，画出相应的程序流程图。
3、按照程序流程图，用C语言编程并实现。
（2）流程图如下：①虚页和实页结构在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。
pfn代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。
time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。
在实页结构中中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。
pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。
next是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。
②程序流程图如下：（3）源程序如下:#include<iostream.h>#define M 40int N;struct Pro{int num,time;};int Input(int m,Pro p[M]){cout<<"请输入实际页数:";do{cin>>m;if(m>M)cout<<"数目太多，请重试"<<endl;else break;}while(1);//cout<<"请输入各页面号:";for(int i=0;i<m;i++){cout<<"第"<<i<<"个页面号为:";cin>>p[i].num;p[i].time=0;}return m;}void print(Pro *page1)//打印当前的页面{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,Pro *page1 ){Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)if(e==page[i].num)return i; return -1;}int Max(Pro *page1){Pro *page=new Pro[N];page=page1;int e=page[0].time,i=0;while(i<N)//找出离现在时间最长的页面{if(e<page[i].time)e=page[i].time;i++;}for( i=0;i<N;i++)if(e==page[i].time)return i;return -1;}int Compfu(Pro *page1,int i,int t,Pro p[M]){Pro *page=new Pro[N];page=page1;int count=0;for(int j=i;j<M;j++){if(page[t].num==p[j].num )break;else count++;}return count;}int main(){cout<<"可用内存页面数:";cin>>N;Pro p[M];Pro *page=new Pro[N];char c;int m=0,t=0;float n=0;m=Input(m,p);do{for(int i=0;i<N;i++)//初试化页面基本情况{page[i].num=0;page[i].time=2-i;}i=0;cout<<"************************"<<endl;cout<<"*****f:FIFO页面置换*****"<<endl;cout<<"*****l:LRU页面置换******"<<endl;cout<<"*****o:OPT页面置换******"<<endl;cout<<"*****按其它键结束*******"<<endl;cout<<"************************"<<endl;cout<<"请选择操作类型(f,l,o):";cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"页面置换情况: "<<endl;while(i<m){if(Search(p[i].num,page)>=0)i++;//找到相同的页面else{if(t==N)t=0;else{n++;//page[t].num=p[i].num;print(page);t++;}}}cout<<"缺页次数："<<n<<" 缺页率:"<<n/m<<endl; }if(c=='l')//LRU页面置换{ n=0;cout<<"页面置换情况: "<<endl;while(i<m){int k;k=t=Search(p[i].num,page);if(t>=0)page[t].time=0;else{n++;t=Max(page);page[t].num=p[i].num;page[t].time=0;}if(t==0){page[t+1].time++;page[t+2].time++;}if(t==1){page[2].time++;page[0].time++;}if(t==2){page[1].time++;page[0].time++;}if(k==-1) print(page); i++;}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}if(c=='o')//OPT页面置换{n=0;while(i<m){if(Search(p[i].num,page)>=0)i++;else{int temp=0,cn;for(t=0;t<N;t++){if(temp<Compfu(page,i,t,p)){temp=Compfu(page,i,t,p); cn=t;}}page[cn]=p[i];n++;print(page);i++;}}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl; }}while(c=='f'||c=='l'||c=='o');return 0;});四测试数据与实验结果五结果分析与实验体会通过上机，我了解了许多关于操作系统的专业知识。
存储管理实验报告
存储管理实验报告存储管理实验报告引言：存储管理是计算机系统中非常重要的一部分，它负责管理计算机系统中的存储资源，包括内存和外存。
合理的存储管理能够提高计算机系统的性能和效率，保证系统的稳定运行。
本次实验旨在通过实践操作，深入了解存储管理的原理和方法，并通过实验结果分析，探讨存储管理的优化策略。
一、实验目的本次实验的主要目的是通过实践操作，深入了解存储管理的原理和方法，并通过实验结果分析，探讨存储管理的优化策略。
具体目标如下：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 算法在减少页面置换次数方面更为出色。
六、实验总结本次实验通过实际操作，深入理解了存储管理的原理和技术，并探索了不同的存储管理策略对系统性能的影响。
(完整word版)Linux操作系统实验报告 存储管理试验
(3)实现FIFO页面淘汰算法。
(4)实现页故障率反馈模型。
2、实验目的与要求
①(1)用C语言是实现模拟Linux系统中连续内存分配用到的伙伴对算法。
(2)通过链表的形式输出在内存申请和释放过程中内存状态的对比图。
②(1)了解工作集模型的原理及其特点。
printmem();
}
int power(int x,int y){
int k=0,tmp=1;
for(;k<y;k++){
tmp=tmp*x;
}
return tmp;
}
int root(int x,int y){
int result=y,count=0;
while(result!=1){
result=result/x;
merge(tempId,merger);
}else {
return 0;
}
return 1;
}else {
second=second->next;
isFirst++;
}
}
return 1;
}
int freeb(int size){
block * first=(struct block *)malloc(sizeof(struct block));
if((second->start==nextStart || second->start==preStart) && second->loc==0){
merger->size=(first->size)+(second->size);
存储管理调度_实验报告
一、实验目的1. 理解操作系统存储管理的基本概念和原理。
2. 掌握分页式存储管理中地址转换和缺页中断的产生。
3. 学习并分析常见的页面调度算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等。
4. 比较不同页面调度算法的性能，提高对虚拟存储技术特点的理解。
二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 实验工具：gdb、gcc三、实验内容1. 模拟分页式存储管理中硬件的地址转换和产生缺页中断。
2. 使用先进先出（FIFO）页面调度算法处理缺页中断。
3. 使用最近最少使用（LRU）页面调度算法处理缺页中断。
4. 比较FIFO和LRU算法的性能。
四、实验步骤1. 定义虚拟页和实页的结构体，包括页号、物理页号、时间戳等。
2. 模拟地址转换过程，当访问的虚拟页不在内存时，产生缺页中断。
3. 使用FIFO算法处理缺页中断，将最早的页面替换出内存。
4. 使用LRU算法处理缺页中断，将最近最少使用的页面替换出内存。
5. 比较FIFO和LRU算法的性能，包括页面命中率、页面置换次数等。
五、实验结果与分析1. 实验结果（1）地址转换过程在模拟实验中，我们使用了一个简单的地址转换过程。
当访问一个虚拟页时，系统会检查该页是否在内存中。
如果在内存中，则直接返回对应的物理地址；如果不在内存中，则产生缺页中断。
（2）FIFO算法在FIFO算法中，当产生缺页中断时，系统会将最早进入内存的页面替换出内存。
实验结果显示，FIFO算法在页面访问序列较长时，页面命中率较低。
（3）LRU算法在LRU算法中，当产生缺页中断时，系统会将最近最少使用的页面替换出内存。
实验结果显示，LRU算法在页面访问序列较长时，页面命中率较高。
2. 实验分析（1）FIFO算法的缺点FIFO算法简单，但性能较差。
当页面访问序列较长时，FIFO算法可能会频繁地发生页面置换，导致页面命中率较低。
（2）LRU算法的优点LRU算法可以较好地适应页面访问模式，提高页面命中率。
存储管理实训报告
一、实训目的1. 通过本次实训，加深对存储管理方案的理解，掌握虚拟存储器的管理方式，熟悉虚存管理的各种页面淘汰算法。
2. 通过编写和调试地址转换过程的模拟程序，加强对地址转换过程的理解。
3. 培养编程能力和问题解决能力，提高实际操作水平。
二、实训环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 20194. 硬件配置：CPU：Intel Core i5，内存：8GB，硬盘：256GB SSD三、实训原理1. 虚拟存储器：虚拟存储器是一种将内存与外存相结合的存储管理技术，可以扩大程序可访问的存储空间。
2. 页面置换算法：页面置换算法是虚拟存储器中的一种内存管理技术，用于确定在内存中保留哪些页面，淘汰哪些页面。
3. 地址转换过程：地址转换过程是将逻辑地址转换为物理地址的过程。
四、实训内容1. 设计一个请求页式存储管理方案，并编写模拟程序实现。
2. 产生一个需要访问的指令地址流，其中50%的指令是顺序执行的，25%的指令均匀地散布在前地址部分，25%的地址是均匀地散布在后地址部分。
3. 指定内存页表的最大长度，并对页表进行初始化。
4. 每访问一个地址时，计算该地址所在的页的页号，然后查页表，判断该页是否在主存。
5. 如果该页已在主存，则打印页表情况；如果该页不在主存，则采用FIFO页面淘汰算法淘汰一页，并将该页在页表中抹去。
6. 编写代码实现上述功能，并进行测试。
五、实训过程1. 确定虚拟存储器的大小、内存大小、页面大小和页面置换算法。
2. 设计数据结构存储页面信息，包括页号、是否在内存中、是否被修改等。
3. 编写函数实现地址转换过程，包括计算页号、判断页是否在内存中等。
4. 编写FIFO页面淘汰算法，淘汰不在内存中的页面。
5. 编写测试程序，生成指令地址流，并调用相关函数进行测试。
六、实训结果1. 成功实现了请求页式存储管理方案，并编写了相应的模拟程序。
操作系统：实验4 存储管理(实验报告)
欢迎共阅班级： 姓名： 学号：5) 当前计算机的实际内存大小为：______________________________________ 分析程序4-1，请回答问题：1) 理论上每个Windows 应用程序可以独占的最大存储空间是：_____________2) 程序中，用于检查系统中虚拟内存特性的API 函数是：__________________ 4.2 Windows 虚拟内存本节实验的目的是：实验4存储管理1) 通过实验了解Windows内存的使用，学习如何在应用程序中管理内存，体会Windows应用程序内存的简单性和自我防护能力。
2) 学习检查虚拟内存空间或对其进行操作；3) 了解Windows的内存结构和虚拟内存的管理，进而了解进程堆和Windows为使用内存而提供的一些扩展功能。
1. 工具/准备工作在开始本节实验之前，请回顾教材的相关内容。
需要准备一台运行Windows系统的计算机，且安装了C/C++编译器。
2. 实验内容与步骤将系统当前的保留区（reserved）虚拟地址空间填入表4.3中。
表4.3 实验记录2) 根据运行结果，请简单描述程序运行的流程：_________________________________________________________________________________________________________________________________________的程序段，该段程序试图通过VirtualAlloc()函数，然后利用物理备用内存将整个块分配到虚拟内存空间的任何位置。
这种技术只对拥有1GB以上的RAM且都有换页文件的计算机可行。
从运行结果看，这种技术成功了吗？_________________。
3) 程序中说明为___________________________________________________的程序段，该段程序利用VirtualAlloc()函数，如果函数成功，则获得大块内存，但不将任何物理内存调配到此块中。
存储管理实验报告
存储管理实验报告一、实验目的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、原理段式存储管理将作业按照逻辑结构划分为若干个段，每个段有自己的名字和长度。
存储管理实验报告_6
昆明理工大学信息工程与自动化学院学生实验报告（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算法。
实验四操作系统存储管理实验报告
实验四操作系统存储管理实验报告一、实验目的本次实验的主要目的是深入理解操作系统中存储管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收、页面置换算法等关键概念，并能够分析和解决存储管理中可能出现的问题。
二、实验环境本次实验在装有 Windows 操作系统的计算机上进行，使用了 Visual Studio 等编程工具和相关的调试环境。
三、实验内容（一）内存分配与回收算法实现1、首次适应算法首次适应算法从内存的起始位置开始查找，找到第一个能够满足需求的空闲分区进行分配。
在实现过程中，我们通过建立一个空闲分区链表来管理内存空间，每次分配时从表头开始查找。
2、最佳适应算法最佳适应算法会选择能够满足需求且大小最小的空闲分区进行分配。
为了实现该算法，在空闲分区链表中，分区按照大小从小到大的顺序排列，这样在查找时能够快速找到最合适的分区。
3、最坏适应算法最坏适应算法则选择最大的空闲分区进行分配。
同样通过对空闲分区链表的排序和查找来实现。
（二）页面置换算法模拟1、先进先出（FIFO）页面置换算法FIFO 算法按照页面进入内存的先后顺序进行置换，即先进入内存的页面先被置换出去。
在模拟过程中，使用一个队列来记录页面的进入顺序。
2、最近最久未使用（LRU）页面置换算法LRU 算法根据页面最近被使用的时间来决定置换顺序，最近最久未使用的页面将被置换。
通过为每个页面设置一个时间戳来记录其最近使用的时间，从而实现置换策略。
3、时钟（Clock）页面置换算法Clock 算法使用一个环形链表来模拟内存中的页面，通过指针的移动和页面的访问标志来决定置换页面。
四、实验步骤（一）内存分配与回收算法的实现步骤1、初始化内存空间，创建空闲分区链表，并为每个分区设置起始地址、大小和状态等信息。
2、对于首次适应算法，从链表表头开始遍历，找到第一个大小满足需求的空闲分区，进行分配，并修改分区的状态和大小。
3、对于最佳适应算法，在遍历链表时，选择大小最接近需求的空闲分区进行分配，并对链表进行相应的调整。
存储管理实验报告
存储管理实验报告题目：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．用户也可以选择其他功能，这里不作介绍。
存储管理实验报告
长度——指出从起始地址开始的一个连续空闲的长度。
状态一一有两种状态，一种是 “未分配”状态，指出对应的由起址指出的某个长度的 区域是空闲区；另一种是 “空表目”状态， 表示表中对应的登记项目是空白（无效） 可用来登记新的空闲区（例如，作业完成后，它所占的区域就成了空闲区，应找一个
prin tf("\n输入作业所需运行时间：”);
sca nf("%d",&p->n time);
p->state='w';
p->li nk=NULL;
sort(); /*调用sort函数*/
}
printf("\n按任一键继续\n");
getch();
}
void in put2()/*建立要回收区域的函数*/
1、可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求， 并且分区个数是可以调整的。 当要装入一个作业时， 根据作业需要的主存量查看是否 有足够的空闲空间， 若有，则按需要量分割一个分区分配给该作业；若无， 则作业不 能装入，作业等待。随着作业的装入、完成，主存空间被分成许多大大小小的分区， 有的分区被作业占用，而有的分区是空闲的。
给作业占用；另一部分又成为一个较小的空闲区，留在空闲区表中。 为了尽量减少由于
分割造成的空闲区，尽可能分配低地址部分的空闲区，而尽量保存高地址部分有较大的
连续空闲区域，以利于大型作业的装入。 为此，在空闲区说明表中，把每个空闲区按其 地址顺序从低到高登记， 即每个后继的空闲区其起始地址总是比前者大。为了方便查找
还可使表格“紧缩”，总是让“空表目”项留在表格的后部。
操作系统实验报告三存储器管理实验
操作系统实验报告三存储器管理实验操作系统实验报告三：存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收的算法，以及页面置换算法的工作过程和性能特点，从而提高对操作系统资源管理的认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容1、内存分配与回收算法实现首次适应算法（First Fit）最佳适应算法（Best Fit）最坏适应算法（Worst Fit）2、页面置换算法模拟先进先出页面置换算法（FIFO）最近最久未使用页面置换算法（LRU）时钟页面置换算法（Clock）四、实验原理1、内存分配与回收算法首次适应算法：从内存的起始位置开始，依次查找空闲分区，将第一个能够满足需求的空闲分区分配给进程。
最佳适应算法：在所有空闲分区中，选择能够满足需求且大小最小的空闲分区进行分配。
最坏适应算法：选择空闲分区中最大的分区进行分配。
2、页面置换算法先进先出页面置换算法：选择最早进入内存的页面进行置换。
最近最久未使用页面置换算法：选择最近最长时间未被访问的页面进行置换。
时钟页面置换算法：给每个页面设置一个访问位，在页面置换时，从指针指向的页面开始扫描，选择第一个访问位为0 的页面进行置换。
五、实验步骤1、内存分配与回收算法实现定义内存分区结构体，包括分区起始地址、大小、是否已分配等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
编写测试程序，创建多个进程，并使用不同的算法为其分配内存，观察内存分配情况和空闲分区的变化。
2、页面置换算法模拟定义页面结构体，包括页面号、访问位等信息。
实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。
编写测试程序，模拟页面的调入和调出过程，计算不同算法下的缺页率，比较算法的性能。
实验报告实验二：存储管理.doc
实验二 存储管理一． 实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二． 实验内容（1） 通过计算不同算法的命中率比较算法的优劣。
同时也考虑了用户内存容量对命中率的影响。
页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。
在本实验中，假定页面大小为1k ，用户虚存容量为32k ，用户内存容量为4页到32页。
（2） produce_addstream 通过随机数产生一个指令序列，共320条指令。
A 、 指令的地址按下述原则生成： 1）50%的指令是顺序执行的2）25%的指令是均匀分布在前地址部分 3）25%的指令是均匀分布在后地址部分 B 、 具体的实施方法是：1） 在[0，319]的指令地址之间随机选取一起点m ； 2） 顺序执行一条指令，即执行地址为m+1的指令； 3） 在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m ’；4） 顺序执行一条指令，地址为m ’+1的指令5） 在后地址[m ’+2，319]中随机选取一条指令并执行； 6） 重复上述步骤1）~5），直到执行320次指令C 、 将指令序列变换称为页地址流在用户虚存中，按每k 存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条~第9条指令为第0页（对应虚存地址为[0，9]）； 第10条~第19条指令为第1页（对应虚存地址为[10，19]）； 。
第310条~第319条指令为第31页（对应虚存地址为[310，319]）； 按以上方式，用户指令可组成32页。
（3） 计算并输出下属算法在不同内存容量下的命中率。
1） 先进先出的算法（FIFO ）； 2） 最近最少使用算法（LRU ）； 3） 最佳淘汰算法（OPT ）； 4） 最少访问页面算法（LFR ）；页地址流长度页面失效次数命中率-=1其中3）和4）为选择内容三．系统框图四．页面置换算法程序代码（部分）五．运行结果运行程序前先新建一个页面流文件文件（格式为*.txt），在文件中存储的是一系列页面号（页面号用整数表示，用空格作为分隔符），用来模拟待换入的页面。
存储器管理实验报告
一、实验目的1. 理解存储器管理的概念和作用。
2. 掌握虚拟存储器的实现原理。
3. 熟悉存储器分配策略和页面置换算法。
4. 提高动手实践能力，加深对存储器管理知识的理解。
二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 开发环境：GCC编译器三、实验内容1. 虚拟存储器实现原理（1）分页式存储管理：将内存划分为固定大小的页，进程的逻辑地址空间也划分为相应的页。
内存与外存之间通过页表进行映射，实现虚拟存储器。
（2）页表管理：包括页表建立、修改和删除等操作。
（3）页面置换算法：包括FIFO、LRU、LRU时钟等算法。
2. 存储器分配策略（1）固定分区分配：将内存划分为若干个固定大小的分区，每个分区只能分配给一个进程。
（2）可变分区分配：根据进程需求动态分配内存，分为首次适应、最佳适应和最坏适应等策略。
（3）分页存储管理：将内存划分为固定大小的页，进程的逻辑地址空间也划分为相应的页，通过页表进行映射。
3. 页面置换算法（1）FIFO算法：根据进程进入内存的顺序进行页面置换，最早进入内存的页面将被淘汰。
（2）LRU算法：淘汰最近最少使用的页面。
（3）LRU时钟算法：结合LRU算法和FIFO算法的优点，通过一个时钟指针实现页面置换。
四、实验步骤1. 编写程序实现虚拟存储器的基本功能，包括分页式存储管理、页表管理、页面置换算法等。
2. 编写测试程序，模拟进程在虚拟存储器中的运行过程，观察不同页面置换算法的效果。
3. 分析实验结果，比较不同页面置换算法的性能差异。
五、实验结果与分析1. 实验结果通过模拟实验，验证了虚拟存储器的基本功能，包括分页式存储管理、页表管理、页面置换算法等。
实验结果显示，不同页面置换算法对系统性能的影响较大。
2. 实验分析（1）FIFO算法：实现简单，但可能导致频繁的页面置换，影响系统性能。
（2）LRU算法：性能较好，但实现复杂，需要额外的硬件支持。
（3）LRU时钟算法：结合LRU算法和FIFO算法的优点，在性能和实现复杂度之间取得平衡。
存储管理实验报告
一、实验目的1. 理解操作系统存储管理的概念和作用。
2. 掌握存储管理的基本算法和策略。
3. 通过实验，加深对存储管理原理的理解，提高实际操作能力。
二、实验环境1. 操作系统：Windows 102. 软件环境：虚拟机软件VMware Workstation 153. 实验平台：Linux系统三、实验内容1. 存储管理概述2. 页式存储管理3. 段式存储管理4. 分段分页存储管理5. 存储管理算法四、实验步骤1. 页式存储管理实验（1）设置虚拟内存：在Linux系统中，使用`cat /proc/meminfo`命令查看内存信息，然后使用`vmstat`命令查看虚拟内存的使用情况。
（2）编写实验程序：使用C语言编写一个简单的程序，模拟页式存储管理过程。
（3）运行实验程序：编译并运行实验程序，观察程序运行过程中页面的分配、置换和回收过程。
2. 段式存储管理实验（1）设置虚拟内存：同页式存储管理实验。
（2）编写实验程序：使用C语言编写一个简单的程序，模拟段式存储管理过程。
（3）运行实验程序：编译并运行实验程序，观察程序运行过程中段页的分配、置换和回收过程。
3. 分段分页存储管理实验（1）设置虚拟内存：同页式存储管理实验。
（2）编写实验程序：使用C语言编写一个简单的程序，模拟分段分页存储管理过程。
（3）运行实验程序：编译并运行实验程序，观察程序运行过程中段页的分配、置换和回收过程。
4. 存储管理算法实验（1）编写实验程序：使用C语言编写一个简单的程序，模拟不同的存储管理算法（如FIFO、LRU、LFU等）。
（2）运行实验程序：编译并运行实验程序，观察不同算法在页面分配、置换和回收过程中的表现。
五、实验结果与分析1. 页式存储管理实验实验结果表明，页式存储管理可以将大程序离散地存储在内存中，提高内存利用率。
但页式存储管理也存在页面碎片问题，导致内存碎片化。
2. 段式存储管理实验实验结果表明，段式存储管理可以将程序按照逻辑结构划分为多个段，提高了内存的利用率。
本地存储管理实验报告
一、实验目的1. 理解本地存储的基本概念和原理。
2. 掌握localStorage和sessionStorage的使用方法。
3. 通过实验验证不同存储方式的特点和适用场景。
4. 提高对前端存储管理的实际操作能力。
二、实验环境1. 操作系统：Windows 102. 浏览器：Google Chrome3. 开发工具：HTML、CSS、JavaScript三、实验内容1. localStorage和sessionStorage的创建与访问（1）创建localStorage和sessionStorage```javascript// 创建localStorage对象var localData = localStorage;// 创建sessionStorage对象var sessionData = sessionStorage;// 存储数据localData.setItem('name', '张三');sessionData.setItem('age', '20');// 获取数据console.log('localStorage name:', localData.getItem('name')); console.log('sessionStorage age:', sessionData.getItem('age'));```（2）删除localStorage和sessionStorage```javascript// 删除localStorage数据localData.removeItem('name');// 删除sessionStorage数据sessionData.removeItem('age');```2. localStorage和sessionStorage的生命周期（1）localStorage的生命周期是永久性的，除非用户手动删除。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
存储管理实验报告
北方工业大学
《计算机操作系统》实验报告
实验名称存储管理实验序号 2
实验日期2013.11.27实验人
一、实验目的和要求
1．请求页式存储管理是一种常用的虚拟存储管理技术。
本实验目的
是通过请求页式存储管理中页面置换算法的模拟设计，了解虚拟存储
技术的特点，掌握请求页式存储管理的页面置换算法。
二、相关背景知识
1．随机数产生办法
关于随机数产生办法， Linux 或 UNIX 系统提供函数 srand() 和 rand() ，分
别进行初始化和产生随机数。
三、实验内容
(1)．通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：
1.50% 的指令是顺序执行的；
2.25% 的指令是均匀分布在前地址部分；
3.25% 的指令是均匀分布在后地址部
分；具体的实施方法是：
1.在[0， 319]的指令地址之间随机选取一起点 m；
2.顺序执行一条指令，即执行地址为 m+1 的指令；
3.在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m’；
4.顺序执行一条指令，其地址为 m’+1；
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， 19]）；
第 310 条至第 319 条指令为第 31 页（对应虚存地址为 [310，319]）；
按以上方式，用户指令可以组成 32 页。
(3)计算并输出下述各种算法在不同内存容量下的命中率。
1.先进先出页面淘汰算法（ FIFO ）
2.最近最久未使用页面淘汰法（ LRU ）
命中率 =1 - 页面失效次数 /页地址流长度
在本实验中，页地址流长度为 320，页面失效次数为每次访问相应指令时，
该指令对应的页不在内存的次数。
四、关键数据结构与函数的说明
ty ：页地址流长度。
int d[320] ：装指令序列。
int page[320] ：装页地址流。
int p[32] ：内存页面。
que：记录缺页次数。
time[32] ：记录页面距离上次被访问的时间。
creat() ：对内存页面进行初始化
FIFO() ：先进先出页面淘汰算法。
LRU() ：最近最久未使用算法。
srand(10*getpid()): 每次运行时进程号不同，用来作为初始化随机数队列的" 种子"。
rand() ：可以生成0~RAND_MAX之间的一个随机
数。
五、编译与执行过程截图
六、实验结果与分析
运行结果： FIFO 算法与 LRU 算法的命中率相差不大，一般在0.03 以内，随着内存页面的增加，命中率上升， 4 页时一般在50%左右， 32 页一般在90% 左右。
分析： FIFO 算法是以先进内存先替换而LRU 是以最久没访问先替换，当内存中页面数量增加时，访问的内容在内存的概率会越高。
七、调试时遇到的问题及解决方法（提供BUG 截屏）
解决： linux 不支持头文件 PROCESS.H ，但是使用 srand() 需要
用该头文件，于是用支持srand() 的头文件 unistd.h 替代
PROCESS.H 。
解决后试调：
八、调试后的程序源代码
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#define NULL 10000
const int ty=320;
int d[320]; //指令序列
int page[320]; // 页地址流
int p[32]; // 内存页面
int que; //缺页次数
int time[32]; //记录页面距离上次被访问的时间
//******* 初始化内存页面
void creat(int leng) //leng 为内存页面数量{
int i;
que=0;
for(i=0;i<leng;i++)
{
//让内存页面置空
p[i]=NULL;
time[i]=0;
}
}
//****** 先进先出算法
//leng 为内存页面数量
void FIFO(int leng)
{
int i,j,k;
int n; //n 为要被替换的页面号，按 0,1,2...leng,0,1,2...leng循环变化creat(leng); //初始化内存页面
n=0;
for(i=0;i<ty;i++)
{
k=0;
for(j=0;j<leng;j++)
{
if(p[j]==NULL)
break;
else if(p[j]==page[i])// 在内存中有该页
{
k=1;
break;
}
}
if(k==0)
{
北方工业大学
que++;
p[n]=page[i];
n++;
}
if(n==leng)
n=0;
}
printf("%-7.3f\t",1-(float)que/ty);
}
//******** 最近最久未使用算法
//leng 为内存页面数量void LRU(int leng)
{
int i,j,k;
//存 time 的最大值
int tmax;
int t; //t 为要被访问的页面号
creat(leng); //初始化内存页面
for(i=0;i<ty;i++)
{
k=0;
for(j=0;j<leng;j++)
{
if(p[j]==NULL)
break;
else if(p[j]==page[i])// 在内存中有该页
{
k=1;
t=j;
break;
}
}
if(k==0)
{
que++;
tmax=time[0];
t=0;
for(j=0;j<leng;j++)//查找最久没访问的页面号赋予t
{
if(tmax<time[j])
{
tmax=time[j];
t=j;
}
}
p[t]=page[i];
}
for(j=0;j<leng;j++)//将每个页面 time 自增
time[j]++;
time[t]=0; //将这次被访问的页面time 清零
}
printf(" %-7.3f\t",1-(float)que/ty);
}
void main( )
{
int m,i;
srand(10*getpid()); // 用来作为初始化随机数队列的
" 种子"
m=(int)((float)(ty-1)*(rand()/(RAND_MAX+1.0))); // 选 0-319 中一数
for (i=0; i<ty; i+=4) //产生指令队列
{
d[i]=m; // 任选一指令访问点m
d[i+1]=d[i]+1;//顺序执行一条指令m+1
d[i+2]=(int)((float)d[i]*(rand()/(RAND_MAX+1.0)));/* 执行前地址指
令 m',即选择 (0，m+1)之间的数 */ d[i+3]=d[i+2]+1;//顺序执行一条指令
m= (int)((float)((ty-1)-d[i+2])*(rand()/(RAND_MAX+1.0))) + d[i+2];
//选(m'+2,319) 之间数}
for(i=0;i<ty;i++) //将指令序列变换成页地址流
page[i]=d[i]/10;
printf("PAGE\tFIFO\t LRU\t\n");
for(i=4;i<=32;i++)//内存从 4 页到 32 页
{
printf(" %2d\t",i);
FIFO(i);
LRU(i);
printf("\n");
}
}
九、实验体会
这一次实验是对请求页式存储管理的一次模拟实验，设计和测试了 FIFO 和 LRU 这两种请求页式存储管理的页面置换算法的命中率。
通过这次实验我了解虚拟存储技术的特点，并掌握了这两种请求页式存储管理的页面置换算法，知道它们的操作是如何进行的，同时实验中查找资料时，也了解了其他的一些
替换算法，还知道了如何使用 srand（）、rand （）如何使用，如何生成随机
数。
对于存储管理的课程内容更为熟练和明白。