下载文档原格式
操作系统存储管理实验报告实验5存储管理第一，实验的目的1，加深对操作系统存储管理的理解2，可以过度模拟页面调试算法，加深对操作系统内存管理的理解二、一般设计思想、环境语言、工具等一般设计思想:1.编写一个函数来计算和输出以下算法的命中率:(1) OPT页面替换算法OPT选定的过时页面是已经转移到内存中并且将来不会被使用或者在最长时间内不会被访问的页面。
因此，如何找到这样的页面是算法的关键。
每页可以设置一个步长变量。
它的初始值是一个足够大的数字。
对于不在内存中的页面，其值将重置为零。
对于内存中的页面，其值被重置为当前访问的页面与页面首次出现时的距离。
因此，该值越大，在最长时间内不会被访问的页面就越多，并且可以选择它作为交换页面。
(2)先进先出页面替换算法先进先出总是选择首先进入内存的页面进行清除，因此可以设置先进先出的繁忙页面帧队列，新转移到内存的页面挂在队列的尾部，当没有空闲页面帧时，可以从队列的头部取出下一个页面帧作为空闲页面帧，然后再转移到需要的页面。
(3) LRU页面替换算法LRU 根据转移到存储器中的页面的使用做出决定。
它使用“最近的过去”作为“最近的未来”的近似，并选择最长时间没有使用的页面进行删除。
该算法主要通过页面结构中的访问时间来实现。
时间记录页面的最后访问时间。
因此，当需要删除一个页面时，选择时间值最小的页面，即最近最长时间没有使用的页面进行删除。
(4) LFU页面替换算法LFU要求每个页面配置一个计数器(即页面结构中的计数器)。
一旦页面被访问，计数器的值将增加1。
当需要替换一个页面时，将选择计数器值最小的页面，即存储器中访问次数最少的页面进行清除。
⑤NUR页面替换算法NUR要求为每个页面设置一个访问位(访问位仍然可以由页面结构中的计数器表示)。
当页面被访问时，其访问位计数器被设置为1。
当需要页面替换时，替换算法从替换指针(最初指向第一页)开始顺序检查内存中的每一页。
如果其访问位为0，则选择页面进行替换，否则，替换指针向下移动以继续向下搜索。
一目的与要求(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．设计一个虚拟存储区和内存工作区；例如内存工作区大小为9个内存块，假设系统中最多可运行3个进程，每个进程分配3个内存块；2．模拟实现FIFO、LRU、OPT算法，给出页面走向，可计算缺页率；3．根据实验结果比较几种算法的差别。
实验步骤及分析：（一）FIFO算法实现提示定义一个常量total_instruction来记录页面总共使用的次数；定义一个变量diseffect记录总共换入页面的次数。
利用公式diseffect/total_instruction*100%可以得到缺页率。
（1）初始化。
设置两个数组page[ap]和pagecontrol[pp]分别表示进程页面数和内存分配的页面数，并产生一个随机数序列pageorder[total_instruction ]（这个序列由page[]的下标随机构成）表示待处理的进程页面顺序，diseffect置0。
（2）看pageorder[]中是否有下一个元素，若有，就由pageorder[]中获取该页面的下标，并转到（3）；如果没有就转到（7）。
（3）如果该page已在内存中，就转到（2）；否则就到（4），同时未命中的diseffect加1。
（4）观察pagecontrol是否占满，如果占满须将使用队列中最先进入的pagecontrol单元“清干净”，同时将对应的page[]单元置为“不在内存中”。
（5）将该page[]与pagecontrol[]建立关系。
可以改变pagecontrol[]的标志位，也可以采用指针链接，总之至少要使对应的pagecontrol单元包含两个信息：一是它被使用了，二是哪个page[]单元使用的。
Page[]单元也包含两个信息：对应的pagecontrol 单元号和本 page[]单元已在内存中。
____大学____学院实验报告课程名称：计算机操作系统实验名称：存储管理实验实验日期：班级：姓名：学号：仪器编号： XX实验报告要求：1.实验目的 2.实验要求 3.实验步骤 4.程序清单 5.运行情况6.流程图 7.实验体会1、实验目的①通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解，熟悉虚存管理的各种页面淘汰法。
②通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
2、实验要求①设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
可以假定每个作业都是批处理作业，并且不允许动态申请内存。
为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。
②设计一个可变式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。
对分区的管理法可以是下面三种算法之一：首次适应算法；最坏适应算法；最佳适应算法。
③编写并调试一个段页式存储管理的地址转换的模拟程序。
首先设计好段表、页表，然后给出若干个有一定代表性的地址，通过查找段表页表后得到转换的地址。
要求打印转换前的地址，相应的段表，页表条款及转换后的地址，以便检查。
3、实验步骤（1）理解实验要求，联系所学知识；（2）根据要求编写调度算法；（3）编写完整的实验代码并在VC++ 6.0环境下编译运行；（4）调试程序直至得出结果。
4、程序清单①#include <stdio.h>#include <stdio.h>#include<math.h>#include<stdlib.h>#define NUM 4#define alloMemory(type) (type*)malloc(sizeof(type)) struct partiTab{int no;int size;int firstAddr;char state;}parTab[NUM];typedef struct partiTab PARTITAB;typedef struct jcb { /*定义作业控制块JCB ,部分信息省略*/ char name[10]; //作业名int size; //作业大小struct jcb* link; //链指针}JCB;typedef struct{JCB *front,*rear;}jcbQue;jcbQue *jcbReadyQue;void AllocateMemory(int size);void createTab();void checkTab();void recycleMemory(int i);void AllocateMemory(int size){int i;for(i=0;i<NUM;i++){PARTITAB p=parTab[i];if(p.state='N' && p.size>size)parTab[i].state='Y';elseprintf("没有空闲分区，无法分配内存！\n"); }}void createTab(){int i;for( i=1;i<=NUM;i++){//getPartiTab(PARTITAB);parTab[i-1].no=i;parTab[i-1].size=20;parTab[i-1].firstAddr=21;parTab[i-1].state='N';}}void checkTab(){int i;printf("分区号\t大小\t起址\t状态\n");for(i=0;i<NUM;i++){printf("%d\t",parTab[i].no);printf("%d\t",parTab[i].size);printf("%d\t",parTab[i].firstAddr);printf("%c\t",parTab[i].state);printf("\n");}}void recycleMemory(int i){parTab[i-1].state='N';}int main(int argc, char* argv[]){int i;printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t实验一存储管理实验\n");printf("\t\t\t\t固定式分区分配存储管理\n");printf("\t\t*********************************************\t\t\n"); createTab();checkTab();printf("请按任意键继续：\n");getchar();printf("每个分区装入一道作业：\n");for(i=0;i<NUM;i++){AllocateMemory((i+1)*3);}checkTab();printf("请按任意键继续：\n");getchar();printf("假如一段时间后，其中一个作业结束，回收给它分配的分区(假如该作业在第2分区)\n");recycleMemory(2);checkTab();printf("请按任意键继续：\n");getchar();printf("接着,从外存后备作业队列中选择一个作业装入该分区(假如该作业大小为10)\n");AllocateMemory(10);checkTab();return 0;}#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#define n 10#define m 10#define minisize 100struct{float address;float length;int flag;}used_table[n];struct{float address;float length;int flag;}free_table[m];void allocate(char J,float xk) {int i,k;float ad;k=-1;for(i=0; i<m; i++)if(free_table[i].length>=xk&&free_table[i].flag==1) if(k==-1||free_table[i].length<free_table[k].length) k=i;if(k==-1){printf("无可用空闲区\n");return;}if(free_table[k].length-xk<=minisize){free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;}else{free_table[k].length=free_table[k].length-xk;ad=free_table[k].address+free_table[k].length;}i=0;while(used_table[i].flag!=0&&i<n)i++;if(i>=n){printf("无表目填写已分分区，错误\n");if(free_table[k].flag==0)free_table[k].flag=1;else{free_table[k].length=free_table[k].length+xk;return;}}else{used_table[i].address=ad;used_table[i].length=xk;used_table[i].flag=J;}return;}void reclaim(char J){int i,k,j,s,t;float S,L;s=0;while((used_table[s].flag!=J||used_table[s].flag==0)&&s<n)s++;if(s>=n){printf("找不到该作业\n");return;}used_table[s].flag=0;S=used_table[s].address;L=used_table[s].length;j=-1;k=-1;i=0;while(i<m&&(j==-1||k==-1)){if(free_table[i].flag==1){if(free_table[i].address+free_table[i].length==S)k=i; if(free_table[i].address==S+L)j=i;}i++;}if(k!=-1)if(j!=-1) /* 上邻空闲区，下邻空闲区，三项合并*/ {free_table[k].length=free_table[j].length+free_table[k].length+L; free_table[j].flag=0;}else/*上邻空闲区，下邻非空闲区，与上邻合并*/free_table[k].length=free_table[k].length+L;else if(j!=-1) /*上邻非空闲区，下邻为空闲区，与下邻合并*/{free_table[j].address=S;free_table[j].length=free_table[j].length+L;}else /*上下邻均为非空闲区，回收区域直接填入*/{/*在空闲区表中寻找空栏目*/t=0;while(free_table[t].flag==1&&t<m)t++;if(t>=m) /*空闲区表满,回收空间失败,将已分配表复原*/{printf("主存空闲表没有空间,回收空间失败\n");used_table[s].flag=J;return;}free_table[t].address=S;free_table[t].length=L;free_table[t].flag=1;}return;}/*主存回收函数结束*/int main( ){printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t实验三存储管理实验\n");printf("\n\t\t\t可变式分区分配 (最佳适应算法)\n");printf("\t\t*********************************************\n");int i,a;float xk;char J;/*空闲分区表初始化：*/free_table[0].address=10240; /*起始地址假定为10240*/free_table[0].length=10240; /*长度假定为10240，即10k*/free_table[0].flag=1; /*初始空闲区为一个整体空闲区*/for(i=1; i<m; i++)free_table[i].flag=0; /*其余空闲分区表项未被使用*//*已分配表初始化：*/for(i=0; i<n; i++)used_table[i].flag=0; /*初始时均未分配*/{printf("功能选择项：\n1。
操作系统存储管理实验报告一、实验目的本次实验的目的是通过编写一段程序，实现对内存的分配和回收操作，并验证算法的正确性和性能。
二、实验内容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.使用性能监控工具实时监测系统的性能指标，发现内存和磁盘的利用率较高，需要优化存储管理。
操作系统实验报告一、实验题目：存储管理（该实验为综合性实验，共用8个学时）二、实验要求：1、通过随机数产生一个指令序列，共320条指令。
其地址按下述原则生成：①50%的指令是顺序执行的；②25%的指令是均匀分布在前地址部分；③25%的指令是均匀分布在后地址部分；具体的实施方法是：A.在[0，319]的指令地址之间随机选取一起点M；B.顺序执行一条指令，即执行地址为M+1的指令；C.在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’；D.顺序执行一条指令，其地址为M’+1；E.在后地址[M’+2，319]中随机选取一条指令并执行；F.重复A—E，直到执行320次指令。
2、指令序列变换成页地址流，设：①页面大小为1K；②用户内存容量为4页到32页；③用户虚存容量为32K。
在用户虚存中，按每页存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条～第9条指令为第0页（对应虚存地址为[0，9]）；第10条～第19条指令为第1页（对应虚存地址为[10，19]）；…………第310条～第319条指令为第31页（对应虚存地址为[310，319]）；3、计算并输出下述各种算法(可任选三个)在不同内存容量下的命中率。
A. FIFO先进先出置换算法；B. LRU最近最久未使用置换算法；C. OPT最佳置换算法。
D. NUR最近未使用置换算法。
E. LFU最少使用置换算法。
三、总的设计思想、环境语言、工具等总的设计思想：1、编写函数计算并输出下述各种算法的命中率①OPT页面置换算法OPT所选择被淘汰的页面是已调入内存，且在以后永不使用的，或是在最长时间内不再被访问的页面。
因此如何找出这样的页面是该算法的关键。
可为每个页面设置一个步长变量，其初值为一足够大的数，对于不在内存的页面，将其值重置为零，对于位于内存的页面，其值重置为当前访问页面与之后首次出现该页面时两者之间的距离，因此该值越大表示该页是在最长时间内不再被访问的页面，可以选择其作为换出页面。
操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分，它直接影响着系统的性能和资源利用率。
本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法，通过实际操作和观察，掌握存储分配、回收、地址转换等关键技术，并对不同存储管理策略的性能进行分析和比较。
二、实验环境本次实验在 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、对于最佳适应算法，在遍历链表时，选择大小最接近需求的空闲分区进行分配，并对链表进行相应的调整。
操作系统实验三存储管理实验班级：2009211311 学号：姓名：schnee目录1. 实验目的 (2)2. 实验内容 (2)(1) 通过随机数产生一个指令序列，共320条指令 (2)(2) 将指令序列变换成为页地址流 (2)(3) 计算并输出下述各种算法在不同内存容量下的命中率 (2)3. 随机数产生办法 (3)环境说明 (3)4. 程序设计说明 (3)4.1.全局变量 (3)4.2.随机指令序列的产生 (4)4.3.FIFO算法 (4)4.4.LRU算法 (4)4.5.OPT算法 (5)5. 编程实现（源程序）： (5)6. 运行结果及分析 (11)6.1.运行（以某两次运行结果为例，列表如下：） (11)6.2.Belady’s anomaly (11)1.实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
2.实验内容(1) 通过随机数产生一个指令序列，共320条指令指令的地址按下述原则生成：a) 50% 的指令是顺序执行的；b) 25% 的指令是均匀分布在前地址部分；c) 25% 的指令是均匀分布在后地址部分；具体的实施方法是：a) 在[0，319]的指令地址之间随机选取一起点m；b) 顺序执行一条指令，即执行地址为m+1的指令；c) 在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m';d) 顺序执行一条指令，其地址为m'+1;e) 在后地址[m'+2，319]中随机选取一条指令并执行;f) 重复上述步骤a)~f)，直到执行320次指令。
(2) 将指令序列变换成为页地址流设：a) 页面大小为1K；b) 用户内存容量为4页到32页；c) 用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条~第9条指令为第0页（对应虚存地址为[0，9]）；第10条~第19条指令为第1页（对应虚存地址为[10，19]）；……第310条~第319条指令为第31页（对应虚存地址为[310，319]）。
按以上方式，用户指令可以组成32页。
(3) 计算并输出下述各种算法在不同内存容量下的命中率a) 先进先出的算法（FIFO）；b) 最近最少使用算法（LRU）；c) 最佳淘汰算法（OPT）；命中率=1-页面失效次数/页地址流长度在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
3.随机数产生办法关于随机数产生办法，可以采用操作系统提供的函数，如Linux或UNIX系统提供函数srand()和rand()，分别进行初始化和产生随机数。
例如：srand();语句可以初始化一个随机数；a[0]=10*rand()/32767*319+1;a[1]=10*rand()/32767*a[0];…语句可以用来产生a[0]与a[1]中的随机数。
环境说明此实验采用的是Win7下Code::blocks 10.05编译器编程。
此word实验文档中采用notepad++的语法高亮。
4.程序设计说明4.1.全局变量const int maxn =320;//序列个数const int max = maxn +20;//数组大小const int maxp = max/10;//最大页数int inst[max];//指令序列int page[max];//页地址流int size;//内存能容纳的页数bool in[maxp];//该页是否在内存里，提高效率int pin[maxp];//现在在内存里的页其中in[]数组是为了方便直接判断该页是否在内存里，而不用遍历内存里所有页来判断。
fault_n用来记录缺页次数。
4.2.随机指令序列的产生按照实验要求的写了，但是由于没有考虑细节，开始时出了点问题。
（1）当m=319时，我们顺序执行m+1会产生第32页的页地址，从而使页地址没能按要求限制在[0, 31]之间。
解决方法：采用循环模加来避免超出范围。
（2）但是这样之后有可能出现模0的问题。
所以我索性将等于0的模数都赋值为160.最后的程序如下。
void produce_inst(){int m, n;int num =0;while(num < maxn){m = rand()% maxn;inst[num++]=(m+1)%maxn;if(num == maxn)break;m =(m+2)% maxn;if(m ==0) m =160;n = rand()% m;inst[num++]=(n+1)%maxn;if(num == maxn)break;n =(n+2)% maxn;m = maxn - n;if(m ==0) m =160;m = rand()% m + n;inst[num++]= m;}}4.3.FIFO算法定义变量ptr。
一开始先预调页填满内存。
在这一部分，ptr指向下一个要存放的位置。
之后继续执行剩下的指令。
此时，ptr表示队列最前面的位置，即最先进来的位置，也就是下一个要被替换的位置。
ptr用循环加，即模拟循环队列。
4.4.LRU算法定义数组ltu[],即last_time_use来记录该页最近被使用的时间。
定义变量ti模拟时间的变化，每执行一次加一。
这个算法，我没有预调页，而是直接执行所有指令。
若当前需要的页没在内存里，就寻找最近最少使用的页，也就是ltu[]最小的页，即最近一次使用时间离现在最久的页，然后替换掉它。
或者在内存还未满时，直接写入，这个我以初始化内存里所有页为-1来实现。
若已经在内存里了，则只遍历内存内的页，把当前页的最近使用时间改一下即可。
4.5.OPT算法定义数组ntu[], 即next_time_use来记录下一次被使用的时间，即将来最快使用时间。
初始化为-1.开始时预调页填满内存里的页。
同样利用变量ptr来表示下一个要存放的位置从而控制预调页的过程。
接着初始化ntu数组为-1。
然后求出每一页下一次被使用的指令号，以此代替使用时间。
如果所有剩下的序列都没有用该页时，则还是-1.这种值为-1的页显然是最佳替换对象。
然后执行所有剩下的指令。
当该页不在内存里时，遍历ntu数组，遇到-1的直接使用该页，没有则用ntu[]值最大的，也就是最晚使用的。
无论该页在不在内存里，因为这一次已经被使用了，所以都应该更新这个页的ntu[]，只需往前看要执行的页流，记录下第一个遇到的该页即可。
如果没有找到同样添-1即可。
5.编程实现（源程序）：#include <stdio.h>#include <stdlib.h>#include <time.h>#include <string.h>using namespace std;const int maxn =320;//序列个数const int max = maxn +20;//数组大小const int maxp = max/10;//最大页数int inst[max];//指令序列int page[max];//页地址流int size;//内存能容纳的页数bool in[maxp];//该页是否在内存里，提高效率int pin[maxp];//现在在内存里的页void welcome(){printf("******************************************\n");printf("** By schnee On2011-12-06 **\n");printf("** 班级:09211311 班内序号：30 **\n");printf("******************************************\n\n");}void input_hint(){printf("\n1--create new instruction sequence 2--set memory page number(4 to 32)\n");printf("3--solve by FIFO algorithm 4--solve by LRU algorithm\n");printf("5--solve by OPT algorithm 0--exit\n");printf("*********Please input Your choice: ");}/*通过随机数产生一个指令序列，共320条指令*/void produce_inst(){int m, n;int num =0;while(num < maxn){m = rand()% maxn;inst[num++]=(m+1)%maxn;if(num == maxn)break;m =(m+2)% maxn;if(m ==0) m =160;n = rand()% m;inst[num++]=(n+1)%maxn;if(num == maxn)break;n =(n+2)% maxn;m = maxn - n;if(m ==0) m =160;m = rand()% m + n;inst[num++]= m;}}/*将指令序列变换成为页地址流*/void turn_page_address(){for(int i=0; i<maxn; i++)page[i]= inst[i]/10;}void FIFO_solve(){memset(in,false,sizeof(in));int fault_n =0;//缺页率int ptr, i;//预调页填满空间ptr =0;//下一个要放的位置for(i=0; i<maxn && ptr<size; i++)if(!in[page[i]]){pin[ptr++]= page[i];in[page[i]]=true;fault_n++;}//继续执行剩下的指令ptr =0;//队列里最先进来的位置，即下一个要被替换的位置for(; i<maxn; i++)if(!in[page[i]]){in[pin[ptr]]=false;in[page[i]]=true;pin[ptr]= page[i];fault_n++;ptr =(ptr+1)% size;}printf("\nBy FIFO algorithm, the fault-page number is: %d\n", fault_n);printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0)); }void LRU_solve(){int ltu[maxp];//last_time_useint ti =1;//模拟时间int fault_n =0;memset(ltu,0,sizeof(ltu));memset(in,false,sizeof(in));memset(pin,-1,sizeof(pin));int min, ptr, i, j;for(i=0; i<maxn; i++){if(!in[page[i]]){//寻找lrumin=; ptr=0;for(j=0; j<size; j++){if(ltu[j]< min){min = ltu[j];ptr = j;}}//替换或写入if(pin[ptr]!=-1)in[pin[ptr]]=false;in[page[i]]=true;pin[ptr]= page[i];fault_n++;ltu[ptr]= ti++;}else//已经在内存里则只需更改最近使用时间{for(j=0; j<size; j++)if(pin[j]== page[i]){ltu[j]= ti++;break;}}}printf("\nBy LRU algorithm, the fault-page number is: %d\n", fault_n);printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0)); }void OPT_solve(){int ntu[maxp];//next_time_useint fault_n =0;int i, j;memset(in,false,sizeof(in));memset(ntu,-1,sizeof(ntu));//预调页填满int ptr =0;for(i=0; i<maxn && fault_n<size; i++){if(!in[page[i]]){in[page[i]]=true;pin[ptr]= page[i];fault_n++;ptr++;}}//初始化ntu数组ptr =0;for(j=i; j<maxn && ptr<32; j++){if(ntu[page[j]]==-1){ntu[page[j]]= j;ptr++;}}int max;for(; i<maxn; i++){if(!in[page[i]]){max =0;ptr =0;for(j=0; j<size; j++){if(ntu[pin[j]]==-1){ptr = j;break;}if(ntu[pin[j]]> max){max = ntu[pin[j]]; ptr = j;}}in[pin[ptr]]=false;in[page[i]]=true;pin[ptr]= page[i];fault_n++;}ntu[page[i]]=-1;for(j=i+1; j<maxn; j++)if(page[j]== page[i]){ntu[page[i]]= j;break;}}printf("\nBy OPT algorithm, the fault-page number is: %d\n", fault_n);printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0)); }int main(){srand(time(NULL));welcome();int choice;while(1){input_hint();scanf("%d",&choice);printf("\n");if(choice ==0){printf("BYE-BYE!!!\n");break;}if(choice ==1){produce_inst();turn_page_address();printf("New page address sequence is set OK!!!\n");}else if(choice ==2){printf("Please input the size of memory page number: ");scanf("%d",&size);}else if(choice ==3)FIFO_solve();else if(choice ==4)LRU_solve();else if(choice ==5)OPT_solve();elseprintf("INPUT ERROR !!! \n");}return0;}6.运行结果及分析6.1.运行（以某两次运行结果为例，列表如下：）内存 4 5 10 15 20 25 32 FIFO 285 272 23LRU 285 274 224 185 139 91 32 OPT 221 2 32 FIFO 272 262 2 2LRU 271 265 2 2 OPT 201 7 32随着页数的增多，除了FIFO对某些序列会有Belady’s anomaly（详见6.2）外，大部分情况和LRU算法、OPT算法都是缺页率减小。
