实验五动态页式存储管理实现过程的模拟
实习五 虚拟存储器实验报告
实习五虚拟存储器实验报告一、实验目的本次虚拟存储器实验旨在深入理解计算机系统中虚拟存储器的工作原理和机制，通过实际操作和观察，掌握虚拟存储器的相关概念和技术，包括页式存储管理、地址转换、页面置换算法等。
同时，培养我们的实践能力和问题解决能力，为今后学习和工作中涉及到的计算机系统相关知识打下坚实的基础。
二、实验环境本次实验使用的操作系统为 Windows 10，开发工具为 Visual Studio 2019，编程语言为 C+＋。
三、实验原理1、虚拟存储器的概念虚拟存储器是一种利用硬盘等辅助存储器来扩充主存容量的技术。
它将程序和数据按照一定的页面大小划分，并在需要时将页面从硬盘调入主存，从而实现了使用有限的主存空间运行较大规模的程序。
2、页式存储管理页式存储管理将主存和辅存空间都划分为固定大小的页面。
程序的地址空间被分成若干页，主存也被分成相同大小的页框。
通过页表来记录页面和页框的对应关系，实现地址转换。
3、地址转换当 CPU 执行指令时，给出的是逻辑地址。
通过页表将逻辑地址转换为物理地址，才能在主存中访问相应的数据。
4、页面置换算法当主存空间不足时，需要选择一个页面换出到硬盘，以腾出空间调入新的页面。
常见的页面置换算法有先进先出（FIFO）算法、最近最少使用（LRU）算法等。
四、实验内容与步骤1、设计并实现一个简单的页式存储管理系统定义页面大小和主存、辅存的容量。
实现页表的数据结构，用于记录页面和页框的对应关系。
编写地址转换函数，将逻辑地址转换为物理地址。
2、实现页面置换算法分别实现 FIFO 和 LRU 页面置换算法。
在页面调入和调出时，根据相应的算法选择置换的页面。
3、测试和分析实验结果生成一系列的访问序列，模拟程序的运行。
统计不同页面置换算法下的缺页次数和命中率。
分析实验结果，比较不同算法的性能。
五、实验过程与结果1、页式存储管理系统的实现我们将页面大小设置为 4KB，主存容量为 16MB，辅存容量为 1GB。
实验五动态分区存储管理模拟
实验五动态分区存储管理模拟一、实验目的深入了解可变分区存储管理式主存分配回收的实现。
二、实验预备知识可变分区存储管理式不预先将主存划分成几个区域，而把主存除操作系统占用区域外的空间看作一个大的空闲区。
当进程要求装入主存时，根据进程需要主存空间的大小查询主存各个空闲区，当从主存空间找到一个大于或等于该进程大小要求的主存空闲区时，选择其中一个空闲区，按进程需求量划出一个分区装入该进程。
进程执行完后，它所占的主存分区被回收，成为一个空闲区。
如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。
这个实验主要需要考虑三个问题：(1)设计记录主存使用情况的数据表格，用来记录空闲区和进程占用的区域；(2)在设计的数据表格基础上设计主存分配算法；(3)在设计的数据表格基础上设计主存回收算法。
首先，考虑第一个问题：设计记录主存使用情况的数据表格，用来记录空闲区和进程占用的区域。
由于可变分区的大小是由进程需求量决定的，故分区的长度是预先不固定的，且分区的个数也随主存分配和回收而变动。
总之，所有分区情况随时可能发生变化，数据表格的设计必须和这个特点相适应。
由于分区长度不同，因此设计的表格应该包括分区在主存中的起始地址和长度。
由于分配时空闲区有时会变成两个分区：空闲区和已分分区，回收主存分区时，可能会合并空闲分区，这样如果整个主存采用一表格记录已分分区和空闲区，就会使表格操作繁琐。
主存分配时查找空闲区进行分配，然后填写已分分区表，主要操作在空闲区；某个进程执行完成后，将该分区变成空闲区，并将其与相邻空闲区合并，主要操作也在空闲区。
由此可见，主存分配和回收主要是对空闲区的操作。
这样，为了便于对主存空间的分配和回收，就建立两分区表记录主存使用情况，一表格记录进程占用分区的“已分分区表”；一是记录空闲区的“空闲区表”。
这两表的实现法一般有两种，一种是链表形式，一种是顺序表形式。
在实验中，采用顺序表形式，用数组模拟。
实验五 请求页式存储管理中常用页面置换算法模拟
else { cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:"; cin>>Nsize; } } break; case 2: cout<<"请输入分配的物理块数的大小: "; cin>>Nsize; while(1) { if(Nsize>0&&Nsize<=10) { Init(QString,Nsize); cout<<"页面号引用串: "; for(i=0;i<Psize;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"LRU算法结果如下:"<<endl; LRU(Nsize); BlockClear(Nsize); cout<<"----------------------"<<endl; system("pause"); system("cls");
void BlockClear(int Nsize) {//块清除 for(int i=0; i<Nsize; i++) { block[i].yemian = -1; block[i].biaoji = 0; } } /*主程序*/ void main(void) { int i,select,Nsize,QString[Psize]={0}; while(select) { cout<<"页面号引用串: "; for(i=0;i<20;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"+******************************+"<<endl; cout<<"+------------欢迎--------------+"<<endl; cout<<"+--------页面置换算法----------+"<<endl; cout<<"+-----选择<1>应用FIFO算法------+"<<endl; cout<<"+-----选择<2>应用LRU算法-------+"<<endl; cout<<"+-----选择<3>应用OPT算法-------+"<<endl; cout<<"+---选择<4>插入新的页面号引用串+"<<endl; cout<<"+-------选择<0>退出------------+"<<endl;
实验五 存储管理(实验报告格式)
实验五：存储管理一、实验目的（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;}。
实验五动态分区分配算法的模拟
实验五动态分区分配算法的模拟为了更好地理解动态分区分配算法的工作原理，我们可以进行一次模拟实验。
在实验中，我们将模拟一个内存分区，并使用动态分区分配算法来管理这些分区。
首先，让我们定义一个内存大小为1000字节的分区。
我们假设这个内存中包含几个已分配的分区和几个空闲的分区。
我们使用首次适应算法来进行分区的首次适应分配。
首先，我们将整个内存空间标记为空闲状态，并创建一个初始的空闲链表。
我们假设初始时只有一个空闲分区，大小为1000字节，起始地址为0。
现在，假设有一个进程请求分配一个250字节大小的内存空间。
我们首先检查空闲链表，找到一个大小大于等于250字节的空闲分区。
在这种情况下，我们发现第一个空闲分区的大小是1000字节，所以我们将它拆分成250字节的已分配分区和750字节的空闲分区。
我们在已分配分区上标记一个进程编号，并将空闲分区加入空闲链表。
接下来，假设我们的进程需要申请500字节的内存空间。
在这种情况下，我们需要查找一个大小大于等于500字节的空闲分区。
我们发现第一个可用的空闲分区大小是750字节，我们将它拆分为已分配的500字节和剩余的250字节的空闲分区。
然后，我们假设有进程释放了先前分配的250字节的内存空间。
当一个进程释放分配的内存空间时，我们需要合并相邻的空闲分区。
在这种情况下，释放的分区位于地址0，大小为250字节，并且其下一个分区是地址500，大小为500字节的空闲分区。
因此，我们将这两个分区合并为一个大小为750字节的空闲分区。
接下来，我们假设另一个进程将请求600字节的内存空间。
根据首次适应算法，我们将在第一个满足条件的空闲分区进行分配。
在这种情况下，我们将分配200字节的空闲分区和分配400字节的空闲分区拆分为600字节的已分配分区和空闲分区。
最后，假设一个进程请求200字节的内存空间。
根据首次适应算法，我们在第一个满足条件的空闲分区进行分配。
在这种情况下，我们将250字节的空闲分区拆分为200字节的已分配分区和50字节的空闲分区。
实验五-动态分区存储管理
实验五动态分区存储管理一、实验目的深入了解采用动态分区存储管理方式的内存分配回收的实现。
通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解，熟悉动态分区存储管理的内存分配和回收。
二、实验内容编写程序完成动态分区存储管理方式的内存分配回收。
具体包括：确定内存空间分配表；采用最优适应算法完成内存空间的分配和回收；编写主函数对所做工作进行测试。
三、设计思路整体思路：动态分区管理方式将内存除操作系统占用区域外的空间看成一个大的空闲区。
当作业要求装入内存时，根据作业需要内存空间的大小查询内存中的各个空闲区，当从内存空间中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业需求量划出一个分区装人该作业，作业执行完后，其所占的内存分区被收回，成为一个空闲区。
如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。
设计所采用的算法：采用最优适应算法，每次为作业分配内存时，总是把既能满足要求、又是最小的空闲分区分配给作业。
但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行，这时，空闲区分割后剩下的空闲区就很小以致很难再使用，降低了内存的使用率。
为解决此问题，设定一个限值minsize，如果空闲区的大小减去作业需求长度得到的值小于等于minsize，不再将空闲区分成己分分区和空闲区两部分，而是将整个空闲区都分配给作业。
内存分配与回收所使用的结构体：为便于对内存的分配和回收，建立两张表记录内存的使用情况。
一张为记录作业占用分区的“内存分配表”，内容包括分区起始地址、长度、作业名/标志（为0时作为标志位表示空栏目）；一张为记录空闲区的“空闲分区表”，内容包括分区起始地址、长度、标志（0表空栏目，1表未分配）。
两张表都采用顺序表形式。
关于分配留下的内存小碎片问题：当要装入一个作业时，从“空闲分区表”中查找标志为“1”（未分配）且满足作业所需内存大小的最小空闲区，若空闲区的大小与作业所需大小的差值小于或等于minsize，把该分区全部分配给作业，并把该空闲区的标志改为“0”（空栏目）。
实验报告-实验五 动态模型的建模分析
实验课程名称：_ 数据分析与建模__实验项目名称实验五动态模型的建模分析实验成绩实验者专业班级组别无同组者无实验日期2018年10月18日第一部分：实验预习报告（包括实验目的、意义，实验基本原理与方法，主要仪器设备及耗材，实验方案与技术路线等）一、实验目的、意义本实验旨在通过资料查阅和上机实验，使学生熟悉和掌握动态模型的分析方法和理论，掌握数据分析工具Mathematica，能够绘制特殊图形，培养和提高数据分析的能力。
二、实验基本原理与方法动态模型的分析方法，数据分析工具Mathematica的使用方法，以及帮助指南文档等。
利用Mathematica绘图。
三、实验内容及要求1、动态模型的建模分析，写出求解过程及分析结论。
（1）求解微分方程y'-xy=3x（2）求微分方程x2y''-2xy'+2y=3x满足条件y(1)=0，y'(1)=1的特解。
（3）求微分方程组的通解。
（4）求函数f(x)=x3-4x+3在区间[-2，2]的极值。
（5）已知一组数据(-1,2)，(0,2.5)，(1,3)，(2,4)，(3,4.5)，(4,5.5)，求已知数据的拟合函数。
（6）应用Mathematica求解传染病模型，模型Ⅰ（指数模型）的通解与特解，并绘图。
（7）应用Mathematica求解传染病模型，模型Ⅱ（阻滞模型，SI模型），的通解与特解，并绘图（三种形状：S形状，正态形状，钟形）。
（8）应用Mathematica求解传染病模型，模型Ⅲ（SIS模型），的通解与特解。
（9）课程第7讲中的问题。
在一片没有管理的林区，硬材树与软材树竞争可用的土地和水分。
越可用的硬材树生长得越慢。
软材树靠生长快、有效消耗水分和土壤养分与硬材树竞争。
硬材树靠生长的高度与软材树竞争，它们遮挡了小树的阳光，也更抗疾病。
这两种树能否同时在一片林区中无限期地共存，或者一种树是否会迫使另一种树灭绝？应用Mathematica求解以下方程。
实验五存储管理实验报告
计算机与信息技术学院综合性实验报告一、实验目的通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。
二、实验仪器或设备微型计算机、Linux操作系统、dev C++三、总体设计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]）；按以上方式，用户指令可组成32页。
3、计算并输出下述算法在不同内存容量下的命中率。
A. FIFO先进先出置换算法；B. LRU最近最久未使用置换算法；C. NUR最近未使用置换算法。
命中率=1-页面失效次数/页地址流长度在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
4、相关定义(1)数据结构○1页面类型typedef struct /*页面结构*/{int pn,pfn,time;}pl_type;其中pn为页面号，pfn为页帧号，time为访问时间○2页帧控制结构struct pfc_struct{ /*页帧控制结构*/int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;其中pfc_type pfc[total_vp]定义用户进程虚页控制结构*freepf_head为空闲页帧头的指针*busypf_head为忙页帧头的指针*busypf_tail忙页帧尾的指针(2)函数定义void initialize(int):初始化函数void FIFO(int):计算使用FIFO算法时的命中率void LRU(int):计算使用LRU算法时的命中率void NRU(int):计算使用NRU算法时的命中率(3)变量定义int a[total_instruction]:指令流数组int diseffect:页面失效次数int page[total_instruction]:每条指令所属页面号int offset[total_instruction]:每页装入10条指令后取模运算得出的页内偏移地址int total_pf:用户进程的内存页面数四、实验步骤按照流程图编写代码、并上机调试运行程序代码：#include <stdlib.h>#include <stio.h>#define TRUE 1#define FALSE 0#define INVALID -1#define total_instruction 320 /*指令流长*/#define total_vp 32 /*虚页长*/typedef struct /*页面结构*/{int pn,pfn,time;}pl_type;pl_type pl[total_vp]; /*页帧结构数组*/struct pfc_struct{ /*页帧控制结构*/int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;int diseffect,a[total_instruction];int page[total_instruction],offset[total_instruction];void initialize(int);void FIFO(int);void LRU(int);void NRU(int);int main( ){int s,i;/*由于每次运行时进程号不同，故可用来作为初始化随机数队列的“种子”*/ srand(10*getpid());s=(float)319*rand( )/RAND_MAX+1;for(i=0;i<total_instruction;i+=4) /*产生指令队列*/{a[i]=s; /*任选一指令访问点m*/a[i+1]=a[i]+1; /*顺序执行一条指令*/a[i+2]=(float)a[i]*rand( )/RAND_MAX; /*执行前地址指令m' */a[i+3]=a[i+2]+1; /*顺序执行一条指令*/s=(float)(318-a[i+2])*rand( )/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 ",i);void FIFO(int);void LRU(int);void NRU(int);printf("\n");}}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].time=-1;}for(i=0;i<total_pf-1;i++){ pfc[i].next=&pfc[i+1];pfc[i].pfn=i;} /*建立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 total_pf; /* 用户进程的内存页面数 */ { int i,j;pfc_type *p, *t;initialize(total_pf); /* 初始化相关页面控制用数据结构*/ busypf_head=busypf_tail=NULL: /* 忙页面队列头,队列尾链接 */for(i=0;i=total_instruction;i++){ if(p1[page[i]].pfn= =INVALID） /* 页面失效 */{ disaffect+=1； /* 失效次数 */if（freep_headf= =NULL） /* 无空闲页面 */{ p=busypf_head->next;p1[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];p1[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)disaffect/320);}void LRU (int total_pf) /*最近最久未使用算法*/int total_pf;{ int min,minj,i,j,present_time;initialize(total_pf);present_time=0;for(i=0;i<total_instruction;i++){ if(p1[page[i]].pfn= =INVALID) /* 页面失效 */ { disaffect++;if(freepf_head= =NULL) /* 无空闲页面 */ { min=32767;for(j=0;j<total_vp;j++)if(min>p1[j].time&&p1[j].pfn !=INVALID){ min=p1[j].time;minj=j;}freepf_head=&pfc[p1[minj].pfn];p1[minj].pfn=INVALID;p1[min].time=-1;freepf_head->next=NULL;}p1[page[i]].pfn=freepf_head->pfn;p1[page[i]].time=present_time;freepf_head=freepf_head->next;}elsep1[page[i]].time=present_time;present_time++;}printf(“LRU:%6.4f”,1-(flaot)disaffect/320);}void NRU(int total_pf) /*最近未使用置换算法*/ int total_pf;{ int i,j,dp,cont_flag,old_dp;pfc_type *t;initialize(total_pf);dp=0;for(i=0;i<total_instruction;i++){ if(p1[page[i]].pfn= =INVALID) /* 页面失效 */ { diseffect++;if(freepf_head= =NULL) /* 无空闲页面 */ { cont_flag=TRUE;old_dp=dp;while(cont_flag)if(p1[dp].counter= =0 && p1[dp].pfn!=INVALID)cont_flag=FLASE;else{ dp++;if(dp= =total_vp)dp=0;if(dp= =old_dp)for(j=0;j<total_vp;j++)p1[j].counter=0;}freepf_head=&pfc[p1[dp].pfn];p1[dp].pfn=INVALID;freepf_head->next=NULL:}p1[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}elsep1[page[i]].counter=1;if(i%clear_period= =0)for(j=0;j<total_vp;j++)p1[j].counter=0;}printf(“NUR:%6.4f”,1-(float)disaffect/320);}void OPT(total_pf)int total_pf;{ int i,j,max,maxpage,d,dist[total_vp];pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){ if(p1[page[i]].pfn= =INVALID){ diseffect++;if(freepf_head= =NULL){ for(j=0;j<total_vp;j++)if(p1[j].pfn !=INVALID)dist[j]=32767;elsedist[j]=0;d=1;for(j=i+1;j<total_instruction;j++){ if(p1[page[j]].pfn!=INVALID)dist[page[j]]=d;d++;}max=-1;for(j=0;j<total_vp;j++)if(max<dist[j]){ max=dist[j];maxpage=j;}freepf_head=&pfc[p1[maxpage].pfn];freepf_head->next=NULL;p1[maxpage].pfn=INVALID;}p1[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}}printf(“OPT:%6.4f”,1-(float)disaffect/320);}显示结果：4 page frames FIFO:0.4969 LRU:0.5000 NUR:0.50005 page frames FIFO:0.5188 LRU:0.5125 NUR:0.50626 page frames FIFO:0.5281 LRU:0.5188 NUR:0.53447 page frames FIFO:0.5406 LRU:0.5500 NUR:0.55628 page frames FIFO:0.5500 LRU:0.5719 NUR:0.55319 page frames FIFO:0.5625 LRU:0.5812 NUR:0.578110 page frames FIFO:0.5844 LRU:0.5969 NUR:0.596911 page frames FIFO:0.5938 LRU:0.6094 NUR:0.625012 page frames FIFO:0.6156 LRU:0.6281 NUR:0.659413 page frames FIFO:0.6375 LRU:0.6344 NUR:0.650014 page frames FIFO:0.6844 LRU:0.6625 NUR:0.650015 page frames FIFO:0.6844 LRU:0.6812 NUR:0.687516 page frames FIFO:0.7062 LRU:0.7062 NUR:0.709417 page frames FIFO:0.7094 LRU:0.7125 NUR:0.725018 page frames FIFO:0.7188 LRU:0.7281 NUR:0.734419 page frames FIFO:0.7281 LRU:0.7531 NUR:0.753120 page frames FIFO:0.7281 LRU:0.7656 NUR:0.759421 page frames FIFO:0.7812 LRU:0.7781 NUR:0.790622 page frames FIFO:0.7875 LRU:0.7937 NUR:0.812523 page frames FIFO:0.7960 LRU:0.8094 NUR:0.818724 page frames FIFO:0.8000 LRU:0.8219 NUR:0.821925 page frames FIFO:0.8344 LRU:0.8312 NUR:0.834426 page frames FIFO:0.8625 LRU:0.8438 NUR:0.859427 page frames FIFO:0.8625 LRU:0.8652 NUR:0.878128 page frames FIFO:0.8750 LRU:0.8656 NUR:0.881229 page frames FIFO:0.8844 LRU:0.8781 NUR:0.881230 page frames FIFO:0.8875 LRU:0.8875 NUR:0.890631 page frames FIFO:0.8875 LRU:0.8906 NUR:0.900032 page frames FIFO:0.9000 LRU:0.9000 NUR:0.9000五、结果分析与总结从上述结果可知，当内存页面数较少（4~5页面）时，5种算法的命中率差别不大，都是50%左右。
动态页式存储管理的模拟实现C语言
在内存划出一块区域，并进行页面划分；设计请求页表；模拟页面分配；分别模拟“先进先出页面淘汰算法FIFO”、“最近最少使用页面淘汰算法LRU”和“理想型淘汰算法OPT”本程序随机产生请求序列，分别模拟FIFO,LRU,OPT三种算法。
将结果保存在FIFO.txt,LRU.txt,OPT.txt三个文件中。
程序代码：#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 20#define P 3struct DuLNode{int data;struct DuLNode *prior;struct DuLNode *next;};int pageFIFO[N+1];int front=0,rear=0;int pageing[N+1],pmem[P+1];int memcount=1;void init(int a[],int T){int i;for(i=0;i<=T;i++)a[i]=-2;}int insert_item(int item,int queue[],int T){if((rear+1)%(T+1)==front)return 1;queue[rear]=item;rear=(rear+1)%(T+1);return 0;}int remove_item(int *item,int queue[],int T){if(front == rear)return 1;*item=queue[front];front=(front+1) % (T+1);return 0;}int findif(int a[],int b,int T){int i;for(i=1;i<=T;i++){if(a[i]==b)return i;}return -1;}void insertintomem(int a[],int b,int n) {if(memcount<=P){a[memcount]=b;memcount++;}elsea[n]=b;}void initpage(int page[]){int temp,i;srand((unsigned)time(0));for(i=1;i<=N;i++){temp=rand()%10;page[i]=temp;}}void addtoLink(struct DuLNode *p,int e) {struct DuLNode *add;add=malloc(sizeof(struct DuLNode));add->data=e;add->prior=p->prior;p->prior->next=add;add->next=p;p->prior=add;}int getI(struct DuLNode *p,int e){struct DuLNode *cd=p;for(i=1;;i++){cd=cd->next;if(cd->data==e)return i;if(cd==p)return -1;}}void deleLink(struct DuLNode *p,int i,int *e) {int n;struct DuLNode *cd=p;for(n=1;n<=i;n++)cd=cd->next;*e=cd->data;cd->prior->next=cd->next;cd->next->prior=cd->prior;free(cd);}void removebottom(struct DuLNode *p,int *e) {struct DuLNode *cd=p->next;*e=cd->data;cd->next->prior=p;p->next=cd->next;free(cd);}int getcount(int a[],int b,int n,int T){int i;for(i=n;i<=T;i++){if(a[i]==b)return (i-n);}return -1;}void getreplacepage(int a[],int b[],int i,int *e) {int t,c[P+1],temp,T,count=0,error[P+1];for(t=1;t<=P;t++)if(getcount(a,b[t],i,N)!=-1)c[t]=getcount(a,b[t],i,N);else{error[++count]=b[t];}}if(count==0){temp=c[1];T=b[1];for(t=1;t<=P;t++){if(c[t]>temp){temp=c[t];T=b[t];}}*e=T;}else{for(t=1;t<=count;t++){c[t]=findif(a,error[t],N);}temp=c[1];T=error[1];for(t=1;t<=count;t++){if(c[t]<temp){temp=c[t];T=error[t];}}*e=T;}}void main(){int i,temp,temp1,error=0,ErrorC[P];FILE *fp1,*fp2,*fp3;struct DuLNode *p;p=(struct DuLNode *)malloc(sizeof(struct DuLNode));p->prior=p->next=p;initpage(pageing);init(pmem,P);if((fp1=fopen("FIFO.txt","a"))==NULL){printf("不能打开文件！\n");exit(1);}for(i=1;i<=N;i++){fprintf(fp1," %d ",pageing[i]);}fprintf(fp1,"\n");for(i=1;i<=N;i++){if(memcount>P&&findif(pmem,pageing[i],P)==-1){remove_item(&temp,pageFIFO,N);insertintomem(pmem,pageing[i],findif(pmem,temp,P));insert_item(pageing[i],pageFIFO,N);fprintf(fp1,"%d被引用，%d被替换->出现第%d 次错误！\n",pageing[i],temp,++error);}else{if(memcount<=P&&findif(pmem,pageing[i],P)==-1){insertintomem(pmem,pageing[i],memcount);insert_item(pageing[i],pageFIFO,N);fprintf(fp1,"页中未满。
动态分区存储管理的模拟实现
printf("请输入需要分配的内存大小(KB)：");
scanf("%d", &size);
if (size <= 0)
{
printf("错误：分配内存大小必须为正值\n");
continue;
}
//调用分配算法
bestFit(taskId, size);
definecrtsecurenowarnings1includestdiohincludestdlibhenumstatefreebusy划出所需大小区分配给请求一个表项下为空上下都为空上下都不为空将上面的空闲区合并并回收将下面的空闲区合并并回收将上下的空闲区合并并回收直接将其回收intaddr
计算机科学与工程学院学生实验报告
#include<stdlib.h>
enum STATE
{
Free,
Busy
};
struct subAreaNode
{
int addr; //起始地址
int size; //分区大小
int taskId; //作业号
STATE state; //分区状态
subAreaNode *pre; //分区前向指针
}used_table[n];/*已分配区表*/
(2)未分配区表：
#define m 10/*假定系统允许的空闲区表最大为m，m值为10*/
struct
{int number;/*序号*/
int address;/*空闲区起始地址，单位为KB */
int length;/*空闲区长度，单位为KB*/
存储管理实验报告
一、实验目的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)在设计的数据表格基础上设计主存分配算法；(3)在设计的数据表格基础上设计主存回收算法。
首先，考虑第一个问题：设计记录主存使用情况的数据表格，用来记录空闲区和进程占用的区域。
由于可变分区的大小是由进程需求量决定的，故分区的长度是预先不固定的，且分区的个数也随主存分配和回收而变动。
总之，所有分区情况随时可能发生变化，数据表格的设计必须和这个特点相适应。
由于分区长度不同，因此设计的表格应该包括分区在主存中的起始地址和长度。
由于分配时空闲区有时会变成两个分区：空闲区和已分分区，回收主存分区时，可能会合并空闲分区，这样如果整个主存采用一张表格记录已分分区和空闲区，就会使表格操作繁琐。
主存分配时查找空闲区进行分配，然后填写已分分区表，主要操作在空闲区；某个进程执行完成后，将该分区变成空闲区，并将其与相邻空闲区合并，主要操作也在空闲区。
由此可见，主存分配和回收主要是对空闲区的操作。
这样，为了便于对主存空间的分配和回收，就建立两张分区表记录主存使用情况，一张表格记录进程占用分区的“已分分区表”；一张是记录空闲区的“空闲区表”。
这两张表的实现方法一般有两种，一种是链表形式，一种是顺序表形式。
在实验中，采用顺序表形式，用数组模拟。
存储管理动态分区分配算法的模拟
存储管理动态分区分配算法的模拟一(题目: 存储管理--- 动态分区分配算法的模拟二(任务: 设计主界面以灵活选择某算法，且以下算法都要实现:首次适应算法、循环首次适应算法、最佳适应算法;。
三(思想: 对任务进行构思和设想。
(1) 首次适应算法:FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时，从链首开始顺巡查找，直到找到一个大小能够满足要求的空闲分区为止; 然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲区间仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。
该算法倾向于优先利用内存中低址部分的空闲分区，从而保留了高址部分的大空闲区。
这给为以后到达的大作业分配大的内存空间创造了条件。
(2) 循环首次适应算法该算法是由首次适应算法演变而成的。
在为进程分配内存空间时，不再是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到一个能满足要求的空闲分区，从中划出一块的请求大小相等的内存空间分配给作业。
为实现该算法，应设置一起始查找指针，用于指示下一次起始查询的空闲分区，并采用循环查找方式，即如果最后一个( 链尾)空闲分区的大小仍不能满足要求，则返回到第一个空闲分区，比较大小是否满足，找到后，应调整起始查询指针。
(3) 最佳适应算法是将最小的空闲分区分配给作业，避免"大材小用"。
为了加速寻找，该算法要求将所有的空闲分区按照某容量以从小到大的顺序形成一空闲分区链。
这样，第一次找到的能满足要求的空闲区，必然是最佳的。
(4) 内存回收:将释放作业所在内存块的状态改为空闲状态，删除其作业名，设置为空。
并判断该空闲块是否与其他空闲块相连，若释放的内存空间与空闲块相连时，则合并为同一个空闲块，同时修改分区大小及起始地址。
四(目的: 在构思中提出要达到的目的。
(1) 按照首次适应算法对内存进行分配，得到(2) 按照循环首次适应算法对内存(3) 按照最佳适应算法对内存进行分配(4) 在作业完成时，释放作业所在内存块，使其能够再次被利用五(方案: 对构思的细化，提出粗略的方案。
黄天实验五虚拟存储器管理实验报告
实验五虚拟存储器管理学号 1415251011 姓名黄天班级 14集成1班华侨大学电子工程系设计目的1、理解虚拟存储器概念。
2、掌握分页式存储管理地址转换和缺页中断。
设计内容与基本要求1、模拟分页式存储管理中硬件的地址转换和产生缺页中断。
2、用先进先出页面调度算法处理缺页中断。
设计报告内容1、分页式存储管理和先进先出页面调度算法原理。
1).分页式存储管理原理在存储器管理中，连续分配方式会形成许多“碎片”，虽然可通过“紧凑”方法将许多碎片拼接成可用的大块空间，但须为之付出很大开销。
如果允许将一个进程直接分散地装入到许多不相邻的分区中，则无须再进行“紧凑”。
基于这一思想而产生了离散分配方式。
如果离散分配的基本单位是页，则称为分页存储管理方式。
在分页存储管理方式中，如果不具备页面对换功能，则称为基本分页存储管理方式，或称为纯分页存储管理方式，它不具有支持实现虚拟存储器的功能，它要求把每个作业全部装入内存后方能运行。
请求式分页系统是建立在基本分页基础上的，为了能支持虚拟存储器功能，而增加了请求调页功能和页面置换功能。
2).先进先出页面调度算法原理优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。
该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。
但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。
2、程序流程图LAB5_HT_14152510113、程序及注释。
#include<cstdio>#include<cstring>#define SizeOfPage 100 //定义页面#define SizeOfBlock 128#define M 4struct info//页表信息结构体{bool flag; //页标志，1表示该页已在主存，0表示该页不在主存long block;//块号4、运行结果以及结论。
计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》
《计算机操作系统》课程设计题目：存储管理——动态分区分配算法的模拟专业：软件工程年级：2012级小组成员：指导教师：时间：地点：2012年5 月目录目录 (1)概述 (3)2. 课程设计任务及要求 (3)2.1 设计任务 (3)2.2 设计要求 (3)2.3 课程设计任务安排 (3)3. 算法及数据结构 (4)3.1算法的总体思想（流程） (4)3.2首次适应算法 (4)3.2.1 功能 (4)3.2.2 数据结构（包括变量的定义，要注释！） (4)3.2.3 算法（流程图表示，或伪C表示） (5)3.3循环首次适应算法 (6)3.3.1功能 (6)3.3.2 数据结构 (6)3.3.3算法 (7)3.4最佳适应算法 (8)3.4.1功能 (8)3.4.2 数据结构 (8)3.4.3算法 (8)3.5最坏适应算法 (10)3.5.1功能 (10)3.5.2 数据结构 (10)3.5.3算法 (11)4. 程序设计与实现 (12)4.1 程序流程图 (12)4.2 程序代码（要注释） (12)4.3 实验结果 (21)5. 结论 (23)6. 收获、体会和建议。
(23)A的总结： (23)B的总结： (23)7. 参考文献。
(24)概述动态分区分配是根据进程的实际需要，动态地为之分配内存空间，而在分配时，须按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业。
在本实验中运用了五种分配算法，分别是：1.首次适应算法2.循环首次适应算法3.最坏适应算法4.最佳适应算法5. 快速适应算法2. 课程设计任务及要求2.1设计任务要求设计主界面以灵活选择其中算法，5种算法都要求实现。
2.2设计要求1）首先由系统生成当前的内存状态，要求未分配的分区数量不少于3个，且空间大小随机，然后随机生成一个数，表示等待分配进程的大小。
2）然后显示上述算法由用户选择，结果显示分配后的状态。
3. 算法及数据结构3.1算法的总体思想（流程）设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
页式存储管理模拟
实验内容：
此实验模拟页式虚拟存储管理中硬件的地址转换和采用先进先出算法（FIFO）的缺页中断处理。
地址转换是由硬件完成的，实验中使用软件程序模拟地址转换过程，模拟地址转换的流程图如图1所示(模拟实验中假定主存64KB，每个主存块1024字节，即n=10,m=16，物理地址中块号6位，块内地址10位；作业最大64KB，即m=16，逻辑地址中页号6位，页内地址10位)。
在模拟实验中页表格式如图2所示。
模拟实验执行一条指令时，不模拟指令的执行，只是考虑执行是否修改页面，若修该页面，则将页面的页表中修改标志置为“1”，然后输出转换后的物理地址，并输出物理地址来表示一条指令的完成；如果访问的页不存在时，则产生缺页中断，往后直接转去缺页中断处理，最后模拟中断返回，就是返回重新进行地址转换。
一条指令执行的模拟流程图如图4所示。
模拟程序中首先手工输入页表信息，创建该作业的页表；然后循环执行假定的指令，观察地址转换情况。
模拟程序的完整流程图如图5所示。
THANKS !!!
致力为企业和个人提供合同协议，策划案计划书，学习课件等等
打造全网一站式需求
欢迎您的下载，资料仅供参考
-可编辑修改-。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
标志
主存块号
在磁盘上的位置
图10 页表格式
其中，标志----用来表示对应页是否已经装入主存，标志位=1，则表示该页已经在主存，标志位=0，则表示该页尚未装入主存。
主存块号----用来表示已经装入主存的页所占的块号。
在磁盘上的位置----用逻辑地址指出了参加运算的操作存放的页号和单元号，硬件的地址转换机构按页号查页表，若该页对应标志为“1”，则表示该页已在主存，这时根据关系式：
二、实验环境
VC++6.0集成开发环境或java程序开发环境。
三、实验内容
模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断。
四、实验原理
1、地址转换
（1）分页式虚拟存储系统是把作业信息的副本存放在磁盘上，当作业被选中时，可把作业的开始几页先装入主存且启动执行。为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表的格式如图10所示：
绝对地址=块号×块长+单元号
计算出欲访问的主存单元地址。如果块长为2的幂次，则可把块号作为高地址部分，把单元号作为低地址部分，两者拼接而成绝对地址。若访问的页对应标志为“0”，则表示该页不在主存，这时硬件发“缺页中断”信号，有操作系统按该页在磁盘上的位置，把该页信息从磁盘读出装入主存后再重新执行这条指令。
编制一个FIFO页面调度程序，为了提高系统效率，如果应淘汰的页在执行中没有修改过，则可不必把该页调出（因在磁盘上已有副本）而直接装入一个新页将其覆盖。因此在页表中增加是否修改过的标志，为“1”表示修改过，为“0”表示未修改过，格式如图12：
图12 页表格式
图12 页表格式
由于是模拟调度算法，所以，不实际启动输出一页和装入一页的程序，而用输出调出的页号和装入的页号来代替一次调出和装入的过程。
3、用最近最少用（LRU）页面调度算法处理缺页中断。
（1）在分页式虚拟存储系统中，当硬件发出“缺页中断”后，引出操作系统来处理这个中断事件。如果主存中已经没有空闲块，则可用LRU页面调度算法把该作业中最先进入主存的一页调出，存放到磁盘上，然后再把当前要访问的页装入该块。调出和装入后都要修改页表页表中对应页的标志。
（3）设计一个“地址转换”程序来模拟硬件的地址转换工作。当访问的页在主存时，则形成绝对地址，但不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行。当访问的页不在主存时，则输出“* 该页页号”，表示产生了一次缺页中断。该模拟程序的算法如图11。
图11 地址转换模拟算法
2、用先进先出（FIFO）页面调度算法处理缺页中断。
P[0]，P[1]，….，P[m-1]
其中每一个P[i]（i=0，1，….，m-1）表示一个在主存中的页面号。它们的初值为：P[0]:=0，P[1]:=1，….，P[m-1]:=m-1
用一指针k指示当要装入新页时，应淘汰的页在数组中的位置，k的初值为“0”。当产生缺页中断后，操作系统选择P[k]所指出的页面调出，然后执行：P[k]:=要装入页的页号；k:=(k+1) mod m；再由装入程序把要访问的一页信息装入到主存中。重新启动刚才那条指令执行。
（2）LRU页面调度算法总是淘汰该作业中距现在最久没有访问过的那一页，因此可以用一个数组来表示该作业已在主存的页面。数组中的第一个元素总是指出当前刚访问的页号，因此最久没被访问的页总是由最后一个元素指出。
编制一个LRU页面调度程序，为了提高系统效率，如果应淘汰的页在执行中没有修改过，则可不必把该页调出。模拟调度算法不实际启动输出一页和装入一页的程序，而用输出调出的页号和装入的页号来代替。
（1）在分页式虚拟存储系统中，当硬件发出“缺页中断”后，引出操作系统来处理这个中断事件。如果主存中已经没有空闲块，则可用FIFO页面调度算法把该作业中最先进入主存的一页调出，存放到磁盘上，然后再把当前要访问的页装入该块。调出和装入后都要修改页表页表中对应页的标志。
（2）FIFO页面调度算法总是淘汰该作业中最先进入主存的那一页，因此可以用一个数组来表示该作业已在主存的页面。假定作业被选中时，把开始的m个页面装入主存，则数组的元素可定为m个。例如：
实验五动态页式存储管理实现过程的模拟
一、实验目的与要求
在计算机系统中，为了提高主存利用率，往往把辅助存储器（如磁盘）作为主存储器的扩充，使多道运行的作业的全部逻辑地址空间总和可以超出主存的绝对地址空间。用这种办法扩充的主存储器称为虚拟存储器。通过本实验帮助学生理解在分页式存储管理中怎样实现虚拟存储器；掌握物理内存和虚拟内存的基本概念；掌握重定位的基本概念及其要点，理解逻辑地址与绝对地址；掌握动态页式存储管理的基本原理、地址变换和缺页中断、主存空间的分配及分配算法；掌握常用淘汰算法。
五、程序流程图
把第一题中程序稍作修改，与FIFO页面调度和LRU页面调度模拟算法结合起来，程序流程图分别如图13和图14所示：
图14 LRU页面调度模拟算法