页式虚拟存储管理中地址转换和缺页中断实验报告

操作系统实验报告-页式虚拟存储管理中地址转换和缺页中断实验四页式虚拟存储管理中地址转换和缺页中断一．实验目的（1）深入了解存储管理如何实现地址转换。

（2）进一步认识页式虚拟存储管理中如何处理缺页中断。

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

三．实验原理页式存储管理把内存分割成大小相等位置固定的若干区域，叫内存页面，内存的分配以“页”为单位，一个程序可以占用不连续的页面，逻辑页面的大小和内存页面的大小相同，内外存的交换也以页为单位进行，页面交换时，先查询快表，若快表中找不到所需页面再去查询页表，若页表中仍未找到说明发生了缺页中断，需先将所需页面调入内存再进行存取。

四．实验部分源程序#define size 1024//定义块的大小，本次模拟设为1024个字节。

#include "stdio.h"#include "string.h"#includestruct plist{int number; //页号int flag; //标志，如为1表示该页已调入主存，如为0则还没调入。

int block; //主存块号，表示该页在主存中的位置。

int modify; //修改标志，如在主存中修改过该页的内容则设为1，反之设为0int location; //在磁盘上的位置};//模拟之前初始化一个页表。

struct plist p1[7]={{0,1,5,0,010},{1,1,8,0,012},{2,1,9,0,013},{3,1,1,0,021},{4,0,-1,0,022},{5,0,-1,0,023},{6, 0,-1,0,125}};//命令结构，包括操作符，页号，页内偏移地址。

struct ilist{char operation[10];int pagenumber;int address;};//在模拟之前初始化一个命令表，通过程序可以让其顺序执行。

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

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

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

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

三、实验原理1）地址转换过程：首先从逻辑地址中的高位取得页号，然后根据页号查页表，得到块号；然后从逻辑地址中的低位取得页内地址，将块号和页内地址合并即得到物理地址。

2）缺页中断处理根据页号查找页表，判断该页是否在主存储器中，若该页标志位“0”，形成缺页中断。

操作系统让调出中断处理程序处理中断。

四、实验方法与步骤实现地址转换与缺页中断处理，主要考虑三个问题：第一，设计页式虚拟存储管理方式中页表的数据结构；第二，地址转换算法的实现；第三，缺页中断处理算法的实现。

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

在实验中页表用数组模拟，其数据结构定义如下：struct{int lnumber; //页号int flag; //表示页是否在主存中，“1”表示在，“0”表示不在int pnumber; // 该页所在主存块的块号int write; //该页是否被修改过，“1”表示修改过，“0“表示没有修改过int dnumber; //该页存放在磁盘上的位置，即磁盘块号}page[n]; //页表定义2）地址转换算法的实现地址转换是由硬件完成的，实验中使用软件程序模拟地址转换过程。

在实验中，每个主存块1024字节，则块内地址占10位；主存64KB，则主存共64块，即块号占6位；物理地址共占16位；作业最大64KB，则作业最大占64块，即页号占6位，逻辑地址共占16位。

存储器管理(一)一、实验目的模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断。

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

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

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

三、实验题目示例程序给出了模拟分页式存储管理中硬件的地址转换和产生缺页中断；请写出用先进先出（FIFO）页面调度算法处理缺页中断或用最近最少用（LRU）页面调度算法处理缺页中断的程序。

四、示例程序源代码#include "stdio.h"#define blockLength 128typedef enum {NO=0,YES}FLAG;typedef struct pagetable {int pageNumber;FLAG flag;int memoryBlock;int place;}PAGETAB;typedef struct job{int pageNumber;int unitNumber;}JOB;PAGETAB pageTAB[7]={0,YES,5,11,1,YES,8,12,2,YES,9,13,3,YES,1,21,4,NO,-1,22,5,NO,-1,23,6,NO,-1,121};JOB work[12] = {0,70,1,50,2,15,3,21,0,56,6,40,4,53,5,23,1,37,2,78,4,1,6,84};int main(int argc, char* argv[]){//first init page table// and work list// look for the work list and pick one to fix the page tablefor(int i=0; i<12;i++){printf("Instruction sequence :%d\n",i+1);int j = work[i].pageNumber;printf("The page %d is in the memory? %s!\n",j,(pageTAB[j].flag == YES)?"YES":"NO");if(pageTAB[j].flag == YES){int absoluteAddress = pageTAB[j].memoryBlock*blockLength+work[i].unitNumber; printf("Instruction absolute address:%d\n",absoluteAddress);}else{printf("missing page interrupt, page fault interrupt!\n");}}return 0;}存储器管理(二)一、实验目的：掌握分页式存储管理的基本概念和实现方法。

第1篇一、实验目的1. 理解虚拟存储器的概念和作用。

2. 掌握分页式存储管理的基本原理和地址转换过程。

3. 熟悉几种常见的页面置换算法，并比较其优缺点。

4. 通过实验，加深对虚拟存储器管理机制的理解。

二、实验内容1. 模拟分页式存储管理中的地址转换过程。

2. 比较几种常见的页面置换算法：FIFO、LRU、LFU和OPT。

三、实验原理虚拟存储器是一种将内存和磁盘结合使用的存储管理技术，它允许程序使用比实际物理内存更大的地址空间。

虚拟存储器通过将内存划分为固定大小的页（Page）和相应的页表（Page Table）来实现。

1. 分页式存储管理分页式存储管理将内存划分为固定大小的页，每个页的大小相同。

程序在运行时，按照页为单位进行内存访问。

分页式存储管理的主要优点是内存碎片化程度低，便于实现虚拟存储器。

2. 页面置换算法当内存中没有足够的空间来存放新请求的页面时，需要将某个页面从内存中移除，这个过程称为页面置换。

以下介绍几种常见的页面置换算法：（1）FIFO（先进先出）：优先淘汰最早进入内存的页面。

（2）LRU（最近最少使用）：优先淘汰最近最少被访问的页面。

（3）LFU（最不频繁使用）：优先淘汰最不频繁被访问的页面。

（4）OPT（最佳置换）：优先淘汰未来最长时间内不再被访问的页面。

四、实验步骤1. 模拟分页式存储管理中的地址转换过程（1）创建一个模拟内存的数组，表示物理内存。

（2）创建一个模拟页表的数组，用于存放虚拟页号和物理页号之间的映射关系。

（3）模拟进程对内存的访问，将访问的虚拟页号转换为物理页号。

2. 比较几种常见的页面置换算法（1）创建一个模拟进程的数组，包含访问的虚拟页号序列。

（2）对每个页面置换算法，模拟进程的运行过程，记录缺页中断次数。

（3）计算不同页面置换算法的缺页率，并比较其性能。

五、实验结果与分析1. 分页式存储管理中的地址转换过程实验结果表明，分页式存储管理能够有效地将虚拟地址转换为物理地址，实现虚拟存储器。

计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求1.目的：请求页式虚存管理是常用的虚拟存储管理方案之一。

通过请求页式虚存管理中对页面置换算法的模拟，有助于理解虚拟存储技术的特点，并加深对请求页式虚存管理的页面调度算法的理解。

2.要求：本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。

其中虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。

要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。

程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。

二、实验说明1．设计中虚页和实页的表示本设计利用C语言的结构体来描述虚页和实页的结构。

在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。

pfn 代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。

time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。

在实页结构中中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。

pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。

next是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。

2．关于缺页次数的统计为计算命中率，需要统计在20次的虚页访问中命中的次数。

为此，程序应设置一个计数器count，来统计虚页命中发生的次数。

每当所访问的虚页的pfn项值不为-1，表示此虚页已被装入某实页内，此虚页被命中，count加1。

最终命中率=count/20*100%。

3．LRU算法中“最近最久未用”页面的确定为了能找到“最近最久未用”的虚页面，程序中可引入一个时间计数器countime，每当要访问一个虚页面时，countime的值加1，然后将所要访问的虚页的time项值设置为增值后的当前countime值，表示该虚页的最后一次被访问时间。

操作系统实验二〔第一题〕一．实验内容模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断。

二．实验目的在电脑系统总，为了提高主存利用率，往往把辅助存储器作为主存储器的扩充，使多道运行的作业的全部逻辑地址空间综合可以超出主存的绝对地址空间。

用这种方法扩充的主存储区成为虚拟存储器。

三．实验题目模拟分页式存储管理中硬件的地址转换和产生缺页中断。

四．程序清单//// 操作实验二.cpp : 定义控制台应用程序的入口点。

//#include "stdafx.h"#include<iostream>#include<string>#include<fstream>using namespace std;class ins{private:string ope;long int page;long int unit;public:ins(){ }ins(string o,long int p,long int u):ope(o),page(p),unit(u){}void setope(string o){ ope=o;}void setpage(long int p){ page=p;}void setunit(long int u){ unit=u;}string getope(){return ope;}long int getpage(){return page;}long int getunit(){return unit;}};class work{private:long int Page;int sym;long int inum;long int onum;public:work(){}work(long int P, int s,long int i,long int o):Page(P),sym(s),inum(i),onum(o){} void setPage(long int P){ Page=P;}void setsym( int s){ sym=s;}void setinum(long int i){ inum=i;}void setonum(long int o){ onum=o;}long int getPage(){return Page;}int getsym(){return sym;}long int getinum(){return inum;}long int getonum(){return onum;}};void diaodu(work *w,ins * i,int numofins){ for(int j=0;j<numofins;j++){long int tempofk;long int a =i[j].getpage();for(int k=0;k<7;k++) //7是页表的页数if(w[k].getPage()!=a)continue;else{tempofk=k;break;}if(w[tempofk].getsym()==1)cout<<"绝对地址："<<w[tempofk].getinum()*128+i[j].getunit()<<" "<<"磁盘地址为："<<w[tempofk].getonum()<<" "<<"操作为："<<i[j].getope()<<endl;else cout<<"*"<<"发生缺页中断"<<endl;}}int main(){ins*INS=new ins[12];INS[0].setope ("+");INS[0].setpage(0);INS[0].setunit(70);INS[1].setope ("+");INS[1].setpage(1);INS[1].setunit(50);INS[2].setope ("×");INS[2].setpage(2);INS[2].setunit(15);INS[3].setope ("存"); INS[3].setpage(3);INS[3].setunit(21);INS[4].setope ("取"); INS[4].setpage(0);INS[4].setunit(56);INS[5].setope ("-");INS[5].setpage(6);INS[5].setunit(40);INS[6].setope ("移位"); INS[6].setpage(4);INS[6].setunit(53);INS[7].setope ("+");INS[7].setpage(5);INS[7].setunit(23);INS[8].setope ("存"); INS[8].setpage(1);INS[8].setunit(37);INS[9].setope ("取"); INS[9].setpage(2);INS[9].setunit(78);INS[10].setope ("+"); INS[10].setpage(4);INS[10].setunit(1);INS[11].setope ("存"); INS[11].setpage(6);INS[11].setunit(84);work*W =new work[7]; ifstream in("g://operate1.txt");long int p;int s;long int i;long int o;for(int jj=0;jj<7 ;jj++){in>>p;in>>s;in>>i;in>>o ;W[jj].setPage(p);W[jj].setsym(s);W[jj].setinum(i);W[jj].setonum(o);}diaodu(W,INS,12);}五．结果显示操作系统实验二〔第二题〕一．用先进先出〔FIFO〕九．程序清单/ 操作系统实验二.cpp : 定义控制台应用程序的入口点。

虚拟存储器管理实验报告防灾科技学院实验报告系别灾害信息工程系专业班级0950412 学号095041219学生姓名郑平贞实验日期2011-12-8 成绩课程名称计算机操作系统实验题目虚拟存储器管理实验记录实验目的：1 理解虚拟存储器的概念2 掌握分页式存储管理地址转换和缺页中断实验环境：Windows XP VC++6.0实验内容：1 模拟分页式存储管理中硬件的地址转换和产生缺页中断2 用先进先出页面调度算法处理缺页中断实验过程：1.实验设计（1）模拟分页式存储管理中硬件的地址转换和产生缺页中断。

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

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

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

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

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

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

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

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

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

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

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

2.程序代码：(1)模拟分页式存储管理中硬件的地址转换和产生缺页中断。

页式虚拟存储管理中地址转换和缺页中断一、实验目的模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断。

二、实验内容1.内容：模拟请求页式存储管理中硬件的地址转换和缺页中断处理2.思想：装入新页置换旧页时，若旧页在执行中没有被修改过，则不必将该页重写磁盘。

因此，页表中增加是否修改过的标志，执行“存”指令和“写”指令时将对应的三、程序及截图程序主要代码:#include<iostream>#include<iomanip>#include<list>using namespace std;char useSign[12][5]={{'+'},{'-'},{'*'},{"存"},{"取"},{'-'},{"移位"},{'+'},{"存"},{"取"},{'+'},{"存"}};int PageAddress[12]={70,50,15,21,56,40,53,23,37,78,01,84};int PageNum[12]={0,1,2,3,0,6,4,5,1,2,4,6};int S_Station;int pPageNum[7];//页号pPageint pSign[7];int pStool[7];//页架号int pModify[7];//修改标志int pStation[7];//磁盘位置static int z=0;void Store(){for(int i=0;i<7;i++){if(i<4){pSign[i]=1;}elsepSign[i]=0;pPageNum[i]=i;pModify[i]=0;}int p1=1,p2=2,p3=3;for(i=0;i<7;i++){if(i<3){pStation[i]=p1;p1++;}elseif(i<6){pStation[i]=p2;p2++;}elsepStation[i]=p3;}pStool[0]=5;pStool[1]=8;pStool[2]=9;pStool[3]=1;}void CShow(){cout<<"操作";cout<<"页号";cout<<"页内地址";cout<<"标志";cout<<"绝对地址";cout<<"修改页号";cout<<"页架号";cout<<"绝对地址";cout<<endl;}void Find(){int m_Pagenum;int m_Station;int Y_Station;//绝对地址int m_Stool;cout<<"输入页号及页内地址查询操作：";cin>>m_Pagenum>>m_Station;CShow();int i,j=0;//string m_Modify;for(i=0;i<12;i++){if(PageAddress[i]==m_Station){break;}}Y_Station=pStool[m_Pagenum]*1024+m_Station;if(pSign[m_Pagenum]==1){if(strcpy(useSign[i],"存")!=0){pModify[m_Pagenum]=1;}}cout<<useSign[i]<<" ";cout<<m_Pagenum<<" ";cout<<m_Station<<" ";cout<<pSign[m_Pagenum]<<" ";if(Y_Station!=m_Station){cout<<Y_Station<<" ";cout<<" ";cout<<pStool[m_Pagenum]<<" ";cout<<Y_Station<<endl;}else{cout<<"*"<<m_Pagenum<<" ";for(j=z;j<7;j++){if(pSign[j]==1){z++;break;}}cout<<m_Pagenum<<"->"<<j<<" ";pStool[m_Pagenum]=pStool[j];pSign[j]=0;pStool[j]=0;cout<<pStool[m_Pagenum]<<" ";cout<<pStool[m_Pagenum]*1024+m_Station<<endl;}}int main(void){Store();char judge='Y';while(judge=='Y'){Find();cout<<"是否继续输入？Y = 是N=否"<<endl;cin>>judge;}return 0;}运行结果截图:五．心得体会在实验过程中，在调试的过程中遇到了一些问题，导致出现很多错误，在同学的帮助下，基本都解决了所有问题。

模拟分页式存储管理中硬件的地址转换和产生缺页中断分页式虚拟存储系统是把作业信息的副本存放在磁盘上，当作业被选中时，可把作业的开始几页先装入主存且启动执行。

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

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

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

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

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

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

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

①定义相关数据结构如下typedef struct{int address; //进程的逻辑地址int meaddress; //进程的物理地址int page; //进程所在页号int add; //进程的位移量}arccell,AdjMatrix[MAX];typedef struct{char vex[MAX]; //进程名AdjMatrix arcs; //指向进程地址的数组int vexnum; //进程总数}Pro;typedef struct{int page; //页号int block; //块号int status; //该页是否在内存的状态位}pa_cell,pa_matrix[MAX];typedef struct{pa_matrix ptab; //指向页表相关信息的数组}pa_tab;②定义必要函数：void create_ptable(pa_tab & pa) //创建页表void exchange(Pro & P,pa_tab & pa) //地址转换函数③具体实验代码：#include<iostream.h>#define MAX 64#define eachpage 1024 // eachpage为每页(每块大小)int m; //m为简化后的页表行数typedef struct{int address; //进程的逻辑地址int meaddress; //进程的物理地址int page; //进程所在页号int add; //进程的位移量}arccell,AdjMatrix[MAX];typedef struct{char vex[MAX]; //进程名AdjMatrix arcs; //指向进程地址的数组int vexnum; //进程总数}Pro;void Create_pro(Pro & P)//创建进程{int i;cout<<"请输入进程总数：";cin>>P.vexnum;cout<<"请输入各进程名：";for(i=0;i<P.vexnum;i++)cin>>P.vex[i];cout<<"请输入各进程地址: ";for(i=0;i<P.vexnum;i++)cin>>P.arcs[i].address;for(i=0;i<P.vexnum;i++){P.arcs[i].page=P.arcs[i].address/eachpage;P.arcs[i].add=P.arcs[i].address%eachpage; // 逻辑地址=页号*页大小+位移量}}void print(Pro & P) //输出进程的相关信息{cout<<"各进程的页号页内地址为："<<endl;for(int i=0;i<P.vexnum;i++)cout<<"进程名"<<P.vex[i]<<" 页号"<<P.arcs[i].page<<" 页内地址"<<P.arcs[i].add<<endl;cout<<endl;}//-------------页表的结构体-----------------typedef struct{int page; //页号int block; //块号int status; //该页是否在内存的状态位(为1表示在内存，为0表示不在内存)}pa_cell,pa_matrix[MAX];typedef struct{pa_matrix ptab; //指向页表相关信息的数组}pa_tab;void create_ptable(pa_tab & pa) //创建页表{int a,b,c;cin>>m; //输入页表行数cout<<"请输入页表相关信息："<<endl;for(int i=0;i<m;i++){cin>>a>>b>>c;pa.ptab[i].page=a;pa.ptab[i].block=b;pa.ptab[i].status=c; //依次输入每行的页表信息}}//--------------地址转换函数-----------------void exchange(Pro & P,pa_tab & pa){for(int i=0;i<P.vexnum;i++)for(int j=0;j<m;j++)if(pa.ptab[j].page==P.arcs[i].page) //查询到页表里相对应的页号{if(pa.ptab[j].status==1) //若进程访问的页状态位为1，输出该进程物理地址{P.arcs[i].meaddress=pa.ptab[j].block*eachpage+P.arcs[i].address;//物理地址=块号*块大小+位移量cout<<"第"<<i+1<<"个进程物理地址为: "<<P.arcs[i].meaddress<<endl;}else //若访问的页状态位为0,表示该页不在主存,发生“缺页中断”信号cout<<"第"<<i+1<<"个进程地址转换发生缺页中断!"<<endl;}}void main(){Pro P;Create_pro(P); //创建进程cout<<endl;print(P);pa_tab pa;cout<<"由于页表信息太大，为了简化运算，请输入想输入的页表行数: ";create_ptable(pa); //创建页表exchange(P,pa); //调度地址转换函数}。

实验五虚拟存储器管理学号 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、运行结果以及结论。

一、实验目的1. 理解缺页中断的概念及其在操作系统中的作用。

2. 掌握常见的页面置换算法，如先进先出（FIFO）、最近最少使用（LRU）等。

3. 通过模拟实验，验证不同页面置换算法对缺页中断次数的影响。

4. 深入了解页式虚拟存储管理中地址转换的过程。

二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 实验工具：Visual Studio三、实验内容1. 模拟缺页中断的产生2. 实现不同的页面置换算法3. 分析页面置换算法对缺页中断次数的影响4. 模拟地址转换过程四、实验步骤1. 模拟缺页中断的产生（1）定义一个模拟指令序列，包含多个页面号。

（2）创建一个模拟的页表，用于记录每个页面是否在内存中。

（3）根据指令序列，遍历页表，判断访问的页面是否在内存中。

（4）如果页面不在内存中，则产生缺页中断。

2. 实现不同的页面置换算法（1）先进先出（FIFO）算法：- 定义一个队列，用于存储内存中的页面号。

- 当发生缺页中断时，将新页面号入队，同时判断队列长度是否超过内存块数。

- 如果队列长度超过内存块数，则将队首元素出队，模拟页面置换过程。

（2）最近最少使用（LRU）算法：- 定义一个链表，用于存储内存中的页面号。

- 当发生缺页中断时，将新页面号插入链表尾部。

- 如果链表长度超过内存块数，则从链表头部删除元素，模拟页面置换过程。

3. 分析页面置换算法对缺页中断次数的影响（1）定义一个变量，用于记录缺页中断次数。

（2）遍历模拟指令序列，根据不同的页面置换算法处理缺页中断。

（3）统计不同算法下的缺页中断次数，并进行比较。

4. 模拟地址转换过程（1）根据指令中的逻辑地址，计算页号和偏移量。

（2）根据页号，查找页表，判断页面是否在内存中。

（3）如果页面在内存中，则根据偏移量计算物理地址。

（4）如果页面不在内存中，则产生缺页中断。

五、实验结果与分析1. 模拟缺页中断的产生通过模拟指令序列，成功产生了缺页中断。

在四页虚拟存储管理中使用先进先出版本的地址转换和页面中断进行实验四页虚拟存储管理中的地址转换和页中断先进先出实验首先，实验的目的是深入理解基于页面的存储管理如何实现地址转换。

进一步了解在页面虚拟存储管理中如何处理分页和页面替换算法。

其次，实验的主要内容是编写一个程序来完成地址转换过程，并模拟基于页面的虚拟存储管理中缺页中断的处理。

实验的具体内容包括:首先，给定的地址被转换。

如果发现缺页，首先中断该页，然后转换地址。

最后，编写主要函数来测试所做的工作。

假设主内存为64KB，每个主内存块为1024字节，支持的最大作业数为64KB，系统中的每个作业分为4个主内存块。

3.实验原则1)地址翻译过程:首先，从逻辑地址中的高位获得页号，然后根据页号搜索页表以获得块号。

然后，从逻辑地址的低位获得页内地址，并且通过组合块号和页内地址获得物理地址。

2)缺页中断处理根据页码查找页表，以确定该页是否在主存储器中。

如果页面标志位为“0”，则形成缺页中断。

操作系统让调用中断处理程序处理中断。

四、实现地址翻译和分页处理的实验方法和步骤，主要考虑三个问题:首先，设计了页面虚拟存储管理模式下页面表的数据结构。

二是地址转换算法的实现；第三，缺页中断处理算法的实现。

1)设计页表的数据结构。

在页型虚拟存储管理模式中，除了对应于该页的页号和主存储器块号之外，页表还应至少包括存在标志(该页是否在主存储器中)、磁盘位置(该页在磁盘上的副本的位置)和修改标志(该页是否已被修改)。

在实验中，页表由数组模拟，其数据结构定义如下:结构{ int lnumber//页码int标志；//表示页面是否在主存中，“1”表示“0”表示不在整数中；//页面所在的主内存块的块号为int write//页面是否已被修改，“1”表示已被修改，“0”表示未被修改为数字；//页面在磁盘上存储的位置，即磁盘块号}页面[n]；//页表定义2)地址转换算法由硬件实现。

在实验中，使用软件程序来模拟地址转换过程。

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

二．实验仪器PC、windows操作系统、Visual C++6.0三．实验原理编写程序完成页式存储管理中地址转换过程和模拟缺页中断的处理。

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

四．实验步骤代码一#include <stdio.h>#include <string.h>#define n 64 //模拟实验中假定的页表长度#define length 10struct{int lnumber;//页号int flag;//表示页是否在主存，"1"表示在，"0"表示不在int pnumber;//该页所在主存块的块号int write; //该页是否被修改过，"1"表示修改过，"0"表示没有被修改过int dnumber;//该页存放在磁盘上的位置，即磁盘块号}page[n];//页表定义int m; //作业在主存中的主存块块数int page_length;//页表实际长度int p[length];//存放在主存中页的页号int head;//主存中页号队列头指针page_interrupt(lnumber) //缺页中断int lnumber;{int j;printf("发生缺页中断* %d\n",lnumber);j=p[head];//淘汰页的页号p[head]=lnumber; //新装入的页号head=(head+1) %m;if (page[j].write==1) //如果该页被修改过printf("将页%d写回磁盘第%d块\n",j,page[j].dnumber);//输出页号page[j].flag=0; //该页不在主存，执行缺页中断，将标志改为不在主存page[lnumber].pnumber=page[j].pnumber; //使j转去执行缺页中断page[lnumber].flag=1;//将所需页重新调入内存page[lnumber].write=0;//将标志改为未被修改过printf("淘汰主存%2d 中的页数%2d,从磁盘第%d 块中调入页%2d\n",page[j].pnumber,j,page[lnumber].dnumber,lnumber);}command(laddress,write)unsigned laddress;int write;{unsigned paddress,ad,pnumber,lnumber;kk:lnumber=laddress >> 10;ad=laddress &0x3ff;if(lnumber >= page_length)//如果页号大于页表长度，则该页不存在{printf("不存在该页\n");return;}if(page[lnumber].flag==1)//如果页表在主存内{pnumber=page[lnumber].pnumber;//从页表中取得块号paddress=pnumber<<10|ad;//合并块号和块内地址形成物理地址paddress;printf("逻辑地址是: %x 对应物理地址是:%x\n",laddress,paddress);if(write==1)//如果需要写，修改页的修改标志位page[lnumber].write=1;}else{page_interrupt(lnumber);//执行缺页中断goto kk;}}//命令处理函数结束void main(){int lnumber,flag,pnumber,write,dnumber;unsigned laddress;int i;printf("输入页表的信息,创建页表(若页号为-1,则结束输入)\n");printf("输入页号和辅存地址:");scanf("%d %d",&lnumber,&dnumber);//读入页号和辅存地址i=0;while(lnumber!=-1)//当页号不存在时，修改页表的信息，将各种标志位置0 {page[i].lnumber=lnumber;page[i].flag=0;page[i].write=0;page[i].dnumber=dnumber;i++;printf("输入页号和辅存地址:");scanf("%d%d",&lnumber,&dnumber);//重新读入新的页号和辅存地址}page_length=i;//页表的长度为页面的数量printf("输入主存块号,主存块数要小于%d,(以-1结束):",i);scanf("%d",&pnumber);m=0;//作业在主存中的主存块块数head=0;//主存中页号队列头指针while(pnumber!=-1){if(m<=i)//块号小于页号{page[m].pnumber=pnumber;//将块号写入页表，并装入内存page[m].flag=1;p[m]=m;m++;}scanf("%d",&pnumber);}printf("输入指令性质(1-修改,0-不需要,其他一结束程序运行)和逻辑地址:");scanf("%d%x",&write,&laddress);while(write==0||write==1){command(laddress,write);//执行相应的指令printf("输入指令性质(1-修改,0-不需要,其他一结束程序运行)和逻辑地址:");scanf("%d%x",&write,&laddress);}}//main()结束代码二#include<iostream>#include<iomanip>#include<list>using namespace std;char useSign[12][5]={{'+'},{'-'},{'*'},{"存"},{"取"},{'-'},{"移位"},{'+'},{"存"},{"取"},{'+'},{"存"}}; int PageAddress[12]={70,50,15,21,56,40,53,23,37,78,01,84};int PageNum[12]={0,1,2,3,0,6,4,5,1,2,4,6};int S_Station;int pPageNum[7];//页号pPageint pSign[7];int pStool[7];//页架号int pModify[7];//修改标志int pStation[7];//磁盘位置static int z=0;void Store(){for(int i=0;i<7;i++){if(i<4){pSign[i]=1;}elsepSign[i]=0;pPageNum[i]=i;pModify[i]=0;}int p1=1,p2=2,p3=3;for(i=0;i<7;i++){if(i<3){pStation[i]=p1;p1++;}elseif(i<6){pStation[i]=p2;p2++;}elsepStation[i]=p3;}pStool[0]=5;pStool[1]=8;pStool[2]=9;pStool[3]=1;}void CShow(){cout<<"操作";cout<<"页号";cout<<"页内地址";cout<<"标志";cout<<"绝对地址";cout<<"修改页号";cout<<"页架号";cout<<endl;}void Find(){int m_Pagenum;int m_Station;int Y_Station;//绝对地址int m_Stool;cout<<"输入页号及页内地址查询操作：";cin>>m_Pagenum>>m_Station;CShow();int i,j=0;//string m_Modify;for(i=0;i<12;i++){if(PageAddress[i]==m_Station){break;}}Y_Station=pStool[m_Pagenum]*1024+m_Station; if(pSign[m_Pagenum]==1) {if(strcpy(useSign[i],"存")!=0){pModify[m_Pagenum]=1;}}cout<<useSign[i]<<"\t";cout<<m_Pagenum<<"\t";cout<<m_Station<<"\t ";cout<<pSign[m_Pagenum]<<"\t";if(Y_Station!=m_Station){cout<<Y_Station<<"\t";cout<<pStool[m_Pagenum]<<"\t";cout<<Y_Station<<endl;}else{cout<<"*"<<m_Pagenum<<" "; for(j=z;j<7;j++){if(pSign[j]==1){z++;break;}}cout<<m_Pagenum<<"->"<<j<<"\t";pStool[m_Pagenum]=pStool[j];pSign[j]=0;pStool[j]=0;cout<<pStool[m_Pagenum]<<"\t";cout<<pStool[m_Pagenum]*1024+m_Station<<endl; }}int main(void){Store();char judge='Y';while(judge=='Y'){Find();cout<<"是否继续输入(请输入大写字母)？Y = 是N=否"<<endl;judge='N';cin>>judge;}return 0;}五．实验现象、结果记录及整理代码一代码二。

一．实验内容模拟请求页式存储管理中硬件的地址转换和缺页中断处理 二．实验原理装入新页置换旧页时，若旧页在执行中没有被修改过，则不必将该页重写磁盘。

因此，页表中增加是否修改过的标志，执行“存”指令和“写”指令时将对应的修改标志置成“1”三．要求及方法：① 设计一个地址转换程序来模拟硬件的地址转换和缺页中断。

当访问的页在主存时则形成绝对地址，但不去模拟指令的执行，可以输出转换后的绝对地址来表示一条指令已执行完成。

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

模拟地址转换流程见图1。

② 编制一个FIFO 页面调度程序；FIFO 页面调度算法总是先调出作业中最先进入主存中的哪一页。

因此可以用一个数组来表示（或构成）页号队列。

数组中每个元素是该作业已在主存中的页面号，假定分配给作业的页架数为m ，且该作业开始的m 页已装入主存，则数组可由m 个元素构成。

P[0]，P[1]，P[2]，…，P[m-1]它们的初值为P[0]：=0，P[1]：=1，P[2]：=2，…，P[m-1]：=m-1用一指针K 指示当要调入新页时应调出的页在数组中的位置，K 的初值为“0”，当产生缺页中断后，操作系统总是选择P[K]所指出的页面调出，然后执行：P[K]：=要装入的新页页号 K ：=(k+1)mod m在实验中不必实际地启动磁盘执行调出一页和装入一页的工作，而用输出“OUT 调出的页号”和“IN 要装入的新页页号”来模拟一次调出和装入过程，模拟程序的流程图见附图1。

按流程控制过程如下：提示：输入指令的页号和页内偏移和是否存指令⎩⎨⎧ 0 1非存指令存指令，若d 为-1则结束，否则进入流程控制过程，得P1和d，查表在主存时，绝对地址=P1×1024+d③假定主存中页架大小为1024个字节，现有一个共7页的作业，其副本已在磁盘上。

系统为该作业分配了4个页架，且该作业的第0页至第3页已装入内存，其余3页未装入主四．主要代码及其说明#include <stdio.h>#include <string.h>#include <stdlib.h>#define M 1024#define R 4typedef struct _PTable{int Number; //页号int Flag; //标志int Fnum; //页架号int Mflag; //修改标志int Position; //该页存放在磁盘上的位置}PTable;//初始化PTable ptable[]={{0, 1, 5, 0, 11},{1, 1, 8, 0, 12},{2, 1, 9, 0, 13},{3, 1, 1, 0, 21},{4, 0, -1, 0, 22},{5, 0, -1, 0, 23},{6, 0, -1, 0, 121},};void menu();int change(char op,int number,int add);void display();int p[]={0,1,2,3},k=0;void main(void){int number,add,n;char op;while(n){display();fflush( stdin );printf("输入:操作页号页内地址(存指令用\"c\"代表)\n");scanf("%c %d %d",&op,&number,&add);change(op,number,add);printf("\"是否继续! (按1 继续按任意键结束)\"\n");scanf("%d",&n);system( "cls ");if(n==1)continue;elsebreak;}}void menu(){printf("操作码\t页号\t页内地址页架标志修改标志出入状态绝对地址(L)\n");}int change(char op,int number,int add){bool flag1=false;bool flag2=false;int i,address,cout,temp;;for(i=0;i<7;i++){if(op=='c'){ptable[number].Mflag=1;}if(ptable[i].Number==number && ptable[i].Flag==1){address=ptable[i].Fnum*M+add;flag1=true;}if(ptable[i].Number==number && ptable[i].Flag==0){cout=i;temp = p[k]; //将要出的页if(ptable[temp].Mflag==1){flag2=true;}//修改页表ptable[number].Flag=1; //修改新页标志ptable[number].Fnum=ptable[temp].Fnum; //修改新页页架address=ptable[number].Fnum*M+add;ptable[temp].Flag=0; //修改旧页ptable[temp].Fnum=-1; //修改页架ptable[temp].Mflag=0; //修改修改标志p[k]=number; //新页k=(k+1)%R;}}menu();if(flag1)printf("%c\t %d\t %d\t %d\t %d\t %d\t 无出入\t%d\n",op,number,add,ptable[number].Fnum,ptable[number].Flag,ptable[number].Mflag,address);else if(flag2)printf("%c\t *%d\t %d\t %d\t %d\t%d OUT:%d,IN:%d %d\n",op,number,add,number,ptable[number].Fnum,ptable[number].Flag,ptable[number].Mflag,temp,number,address);elseprintf("%c\t *%d\t %d\t %d\t %d\t %d\t IN%d\t %d\n",op,number,add,ptable[number].Fnum,ptable[number].Flag,ptable[number].Mflag,number,address);return 0;}void display(){int i;printf("********当前页表中的状态*********\n");printf("页号标志页架修标志\n");for(i=0;i<7;i++){printf("%d\t%d\t%d\t%d\n",ptable[i].Number,ptable[i].Flag,ptable[i].Fnum,ptable[i]. Mflag);}printf("当前主存中的页号为: ");for(i=0;i<4;i++){printf("%d ",p[i]);}printf("\n*********************************\n");}五,实验截图。

一、实验目的1. 了解操作系统内存管理中缺页处理的基本原理和方法。

2. 熟悉页面置换算法在缺页处理中的应用。

3. 分析不同页面置换算法的性能，为实际应用提供参考。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 实验工具：Jupyter Notebook三、实验原理缺页管理是操作系统内存管理的重要组成部分，主要解决虚拟存储器中页面请求与物理内存冲突的问题。

当进程请求访问一个不在物理内存中的页面时，系统需要进行缺页处理，将所需的页面从磁盘调入内存，并将对应的物理页面换出。

常见的页面置换算法有：1. 最佳适应算法（OPT）2. 先进先出算法（FIFO）3. 最近最少使用算法（LRU）4. 最近最不经常使用算法（LFU）四、实验步骤1. 设计实验数据：创建一个包含若干页面的数组，表示虚拟存储器中的页面。

2. 实现页面置换算法：根据选择的算法，实现相应的页面置换逻辑。

3. 运行实验：模拟进程访问页面，记录缺页次数、页面置换次数等指标。

4. 分析实验结果：比较不同页面置换算法的性能。

五、实验结果与分析1. 实验数据虚拟存储器包含100个页面，进程请求访问的页面顺序为：0, 1, 2, ..., 99。

2. 实验结果（1）最佳适应算法（OPT）缺页次数：18页面置换次数：18（2）先进先出算法（FIFO）缺页次数：26页面置换次数：26（3）最近最少使用算法（LRU）缺页次数：19页面置换次数：19（4）最近最不经常使用算法（LFU）缺页次数：22页面置换次数：223. 实验结果分析通过实验结果可以看出，不同页面置换算法的性能存在差异。

在本次实验中，最佳适应算法（OPT）的性能最佳，其次是最近最少使用算法（LRU），先进先出算法（FIFO）和最近最不经常使用算法（LFU）的性能较差。

六、结论1. 最佳适应算法（OPT）在本次实验中表现出最佳性能，但实际应用中难以实现，因为需要预先知道进程访问页面的顺序。

一、实验目的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算法可以较好地适应页面访问模式，提高页面命中率。