计算机操作系统实验源码模拟请求分页虚拟存储管理中的硬件地址变换过程

合集下载

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

操作系统实验报告-页式虚拟存储管理中地址转换和缺页中断实验四页式虚拟存储管理中地址转换和缺页中断一．实验目的（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;};//在模拟之前初始化一个命令表，通过程序可以让其顺序执行。

请求调页存储管理方式的模拟LFU(含源代码)

课程设计课程设计名称：请求调页存储管理方式的模拟4专业班级：学生姓名：学号：指导教师：课程设计时间：2012.12.24-2012.12.28计算机科学专业课程设计任务书说明：本表由指导教师填写，由教研室主任审核后下达给选题学生，装订在设计（论文）首页填表说明1．“课题性质”一栏：A．工程设计；B．工程技术研究；C．软件工程（如CAI课题等）；D．文献型综述；E．其它。

2．“课题来源”一栏：A．自然科学基金与部、省、市级以上科研课题；B．企、事业单位委托课题；C．校、院（系、部）级基金课题；D．自拟课题。

1 需求分析1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。

2）用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。

在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。

如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。

在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。

3）置换算法：最少访问（LFU）算法。

通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求调页系统的原理和实现过程的理解。

所有内容均为独立完成。

2 概要设计本实验主要分为以下几个重要实现过程：（1）首先由对应函数按照题目要求产生对应的320条随即指令。

（2）当指令到来时，首先查询4个物理模块中是否含有当前指令，如果有则直接下一条指令，若没有就进行判定查找物理块中是否还有空闲盘块，有该指令则直接调入，无则要发生页面置换。

（3）按照一定规则（LFU）进行页面置换，知道最后一条指令完成后，显示缺页次数和缺页率。

程序中自定义的函数（函数名，参数，以及功能）及结构等如下：#define Bsize 4 定义一个全局的物理块大小4struct BLOCK { 物理块类型的申明int pagenum; //用于存储页号int use; //用于计算最近使用次数};int num=0; //记录指令的序号int n=0; //记录缺页的次数static int temp[320]; //用来存储320条指令struct BLOCK block[4]; //大小为4的物理块数组int findExist(int curpage);//查找物理块中是否有该页面int findSpace(); //查找是否有空闲物理块int findReplace(); //查找应予置换的页面void display(); //显示置换过程void zhiling(); //产生320条指令,显示并存储到temp[320],并调度页号队列void LFU(); //LFU算法3 运行环境软件：Windows 98及以上操作系统，Microsoft Visual C++ 6.0版本硬件： 512M CPU内存及以上的计算机4 开发工具和编程语言开发工具：Microsoft Visual C++ 6.0编程语言：C语言5 详细设计（1）产生320条指令,显示并存储到temp[320],并调度页号队列320条随即指令的产生规则如下：①在[0，319]的指令地址之间随机选取一起点m；②顺序执行一条指令，即执行地址为m+1的指令；③在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m′；④顺序执行一条指令，其地址为m′+1的指令；⑤在后地址[m′+2，319]中随机选取一条指令并执行；⑥重复上述步骤①～⑤，直到执行320次指令。

模拟请求页式存储管理中硬件的地址转换和缺页中断

课程名称操作系统原理实验名称模拟请求页式存储管理中硬件的地址转换和缺页中断姓名学号专业班级实验日期成绩指导老师(①实验目的②实验原理③主要仪器设备④实验内容与步骤⑤实验数据记录与处理⑥实验结果分析⑦问题建议)一、实验目的模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断。

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

因此，页表中增加是否修改过的标志，执行“存”指令和“写”指令时将对应的修改标志置成模拟算法流程三、程序及截图程序:#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;}截图:五．心得体会在实验过程中，遇到了一些问题但是在调试的过程中，会出现很多错误，有的自己可以解决，也有一些在同学的帮助下，基本都解决了所有问题。

操作系统实验4-请求分页存储管理模拟实验

实验四请求分页存储管理模拟实验一：实验目得通过对页面、页表、地址转换与页面置换过程得模拟,加深对请求分页存储管理系统得原理与实现技术得理解.二：实验内容假设每个页面可以存放１0条指令，分配给进程得存储块数为４。

用C语言或Ｐａscａｌ语言模拟一进程得执行过程。

设该进程共有320条指令，地址空间为32个页面,运行前所有页面均没有调入内存。

模拟运行时,如果所访问得指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问得指令还未装入内存，则发生缺页，此时需要记录缺页产生次数，并将相应页面调入内存，如果４个内存块已满，则需要进行页面置换。

最后显示其物理地址,并转下一条指令。

在所有指令执行完毕后,显示进程运行过程中得缺页次数与缺页率.页面置换算法：分别采用OPT、ＦIFＯ、LRＵ三种算法。

进程中得指令访问次序按如下原则生成：50%得指令就是顺序执行得。

2５%得指令就是均匀分布在低地址部分.25％得指令就是均匀分布在高地址部分.三：实验类别分页存储管理四:实验类型模拟实验五：主要仪器计算机六：结果OＰＴ:ＬRU：FIFO：七：程序＃ i ｎclude 〈stdio 、h 〉＃ｉncl ｕde 〈ｓtdlib 、h 〉＃ include 〈ｃｏnio 、ｈ＞＃ def ｉne blockn ｕm ４//页面尺寸大小int ｍ; //程序计数器，用来记录按次序执行得指令对应得页号s ｔa ｔi ｃ in ｔｎum ［３20]； //用来存储3２0条指令ｔｙpedef s ｔruct BLOCK ／/声明一种新类型—－物理块类型{ﻩint ｐagenum; ／/页号ﻩint ａｃces ｓｅd; ／/访问量，其值表示多久未被访问}BLOCK ；BLOCK bl ｏck ［bl ｏcknum ］；／/定义一大小为8得物理块数组void init （） /／程序初始化函数，对bl ｏck 初始化｛for （ｉnt i=0;i ＜ｂlo ｃknum;i+＋)bｌｏｃｋ[ｉ]、ｐａgｅnum＝—1；bｌock［ｉ］、accｅsｓed=0；ﻩm=0;｝｝ｉｎt ｐａｇｅＥxist（ｉnt curpagｅ)/／查找物理块中页面就是否存在，寻找该页面curpage就是否在内存块bｌoｃｋ中,若在，返回块号｛ﻩfor（int i=0；i<bｌocknum; i+＋)ﻩ{ﻩﻩｉf(bｌock［i］、ｐagｅnｕm ＝＝ cuｒpaｇe ）ﻩﻩｒeturn i； //在内存块blｏck中,返回块号ﻩ｝ｒetuｒn -1;}ｉnｔ findSpace（）／/查找就是否有空闲物理块，寻找空闲块bｌock，返回其块号｛foｒ(int ｉ=0；ｉ<bｌocknｕm;i＋+)ﻩ｛ｉf（blｏｃｋ[i］、paｇenum=＝－1)ﻩｒeｔuｒn i；／／找到了空闲得ｂlｏcｋ,返回块号｝ﻩrｅｔurｎ -1；｝int findReplａcｅ(）//查找应予置换得页面{ﻩint ｐoｓ = 0;ﻩｆor（int i＝0；i〈ｂlocｋnｕm；ｉ++){if(blｏｃk［ｉ]、ａｃcessed 〉blｏck［pos]、aｃceｓsｅd）ﻩpos = ｉ； //找到应该置换页面，返回BＬOCK中位置ﻩ｝reｔurn pｏs；｝voｉd displaｙ(）//显示物理块中得页面号｛ﻩﻩfor(int i=0; i〈bｌocknｕm; i＋＋）ﻩ｛ﻩif(blocｋ[ｉ］、ｐａｇenum != -1）ﻩ｛ﻩﻩpriｎtf（” ％02d "，block［ｉ]、paｇenum）;ﻩﻩﻩprintf("%p |”，＆blocｋ[ｉ]、pagｅnum）；ﻩﻩ｝ｐrｉｎtf（"\n＂）;｝vｏid rａｎdaｍ（)/／产生320条随机数,显示并存储到ｎｕm[３２0]｛int ｆlａｇ=0;pｒintｆ（”请为一进程输入起始执行指令得序号(0~320）:\n”)；ﻩscanｆ（"%d",＆ｍ）；//用户决定得起始执行指令ｐriｎｔｆ（"*＊＊**＊进程中指令访问次序如下：(由随机数产生)＊*＊*＊＊＊＼n"）;fｏr（int i=0；i〈３2０；ｉ＋+）｛/／进程中得320条指令访问次序得生成ﻩﻩnum[ｉ]＝m;//当前执行得指令数，ﻩﻩｉf（flag％２==0）ﻩm＝++m％３２０；//顺序执行下一条指令ﻩﻩｉf（flag==１）ﻩﻩm＝rａnd（）％（m-1)；//通过随机数,跳转到低地址部分[0，m—1］得一条指令处，设其序号为ｍ1ｉf(flag＝=3）ﻩﻩm=m+1＋(rand()%(３2０－（m+1）)）；//通过随机数,跳转到高地址部分［ｍ1+2，3１９]得一条指令处，设其序号为m2ﻩﻩfｌag＝＋+ｆｌag%４；ﻩprｉntｆ（” %0３d”,num［i］)；／/输出格式:3位数ﻩﻩiｆ（（i+１）%1０==0）／/控制换行，每个页面可以存放１０条指令,共32个页面ﻩprintf（”\n”）；｝｝ｖoid pageｓtrｉng（) //显示调用得页面序列,求出此进程按次序执行得各指令所在得页面号并显示输出｛ｆor（int i＝0;i〈３２0；i++）ﻩ｛printf(”％０２d＂,nuｍ[i］／１0);//输出格式：２位数if((ｉ＋1）%10==0)//控制换行，每个页面可以存放10条指令,共32个页面ﻩﻩｐｒintf("＼n”);}｝void OPＴ() //最佳替换算法{ﻩinｔ n=0；//记录缺页次数inｔ exist，space，posiｔｉon；ﻩinｔｃurpaｇe;//当前指令得页面号ﻩfｏr(int i＝０;i＜３2０；ｉ＋＋）ﻩ｛ﻩm=num［i］;ﻩcurpage=ｍ/10;ﻩﻩeｘiｓt=ｐageExist（cuｒｐage);ﻩif(exist==-1)ﻩﻩ{ ／/当前指令得页面号不在物理块中space＝findＳpace（）；ﻩﻩif(sｐａｃe ！= -１）ﻩﻩ｛//当前存在空闲得物理块ﻩﻩｂloｃk［ｓｐａce]、pagenuｍ＝ cｕｒpaｇe；/／将此页面调入内存ﻩﻩﻩdiｓｐlay（）;／/显示物理块中得页面号ﻩﻩn++;/／缺页次数+1ﻩ｝ﻩﻩelｓeﻩﻩ{ ／/当前不存在空闲得物理块，需要进行页面置换foｒ（inｔk=0；k＜blocknum；k++）ﻩﻩﻩﻩ{ｆor（int j=i；ｊ〈３２０；j＋+）ﻩ{//找到在最长(未来)时间内不再被访问得页面ﻩﻩﻩﻩif(block［k］、pagenum！= ｎｕｍ［j]/1０）ﻩﻩﻩ{ﻩﻩbloｃk［ｋ］、acｃeｓseｄ = 1０00;ﻩﻩﻩ} //将来不会被访问,设置为一个很大数ﻩﻩﻩelseﻩﻩﻩ{ //将来会被访问,访问量设为ｊﻩﻩﻩｂlｏcｋ[ｋ］、ａｃｃessｅd = j；ﻩﻩﻩﻩﻩbｒeak;ﻩﻩﻩﻩ｝ﻩﻩﻩ}ﻩ}ﻩposiｔｉon = ｆiｎdReｐlａｃe（）；//找到被置换得页面，淘汰ﻩblock［ｐosｉtｉon］、pａgenum = ｃurpａｇｅ；// 将新页面调入dispｌay();ﻩﻩn++； //缺页次数+１ﻩ｝｝ﻩ｝ﻩpｒintf(”缺页次数：％ｄ\n＂,n);printｆ(＂缺页率：％f％％＼n"，（n／320、0）＊100）；}void LＲU() //最近最久未使用算法{inｔ n=0；//记录缺页次数ﻩiｎt ｅxｉｓt,ｓｐacｅ，ｐosition ;ﻩｉnｔ curpaｇe；／/当前指令得页面号ﻩｆｏｒ（ｉｎt i=0；i＜320;i++）ﻩ{ﻩm＝num［i]；ﻩﻩcuｒｐagｅ=m／10；ﻩｅxist = pageＥｘiｓt(curpａge);ﻩｉｆ（ｅxist＝=-1）ﻩﻩ｛ //当前指令得页面号不在物理块中ｓｐaｃe = fｉnｄSpace（）;ﻩﻩif（sｐａcｅ！= —１)ﻩ{ //当前存在空闲得物理块ﻩﻩｂｌock［spａce]、pagenum = ｃｕrｐage；//将此页面调入内存ﻩﻩｄisplay（）；//显示物理块中得页面号ﻩn++;／／缺页次数+1ﻩﻩ｝else｛ //当前不存在空闲得物理块，需要进行页面置换ﻩﻩpｏsｉｔioｎ＝ finｄＲeｐlace(）；ﻩbｌocｋ[positｉon]、paｇenum ＝ cｕrｐａge；ﻩﻩdiｓplaｙ(）;ﻩn++；//缺页次数+1ﻩ｝ﻩﻩ}elsｅﻩﻩbｌｏck［exｉsｔ］、acｃesｓed = -１；//恢复存在得并刚访问过得ＢLOCK中页面ａccessｅｄ为-１for(int j=0; j<blockｎum； j＋+)ﻩﻩ｛//其余得accessed++ﻩﻩｂlｏｃk［ｊ］、acｃｅssed+＋;｝ﻩ}prｉntf("缺页次数:%d\n”,n）；ﻩpriｎｔf("缺页率：％f%％\n",（n／３20、0）*10０);｝voｉd FIFO（）{int n=0;//记录缺页次数int eｘist，spacｅ，ｐositｉｏn ;ﻩ iｎｔ cｕrｐaｇe；/／当前指令得页面号iｎt blｏckpｏinter=－１;for（iｎｔ i=０;i<３20；ｉ++）ﻩ｛ﻩ m=num［i］;cｕrpａge=m／１0；ﻩexｉst = pageＥｘist(ｃｕrpａge）；ﻩ iｆ(eｘiｓｔ＝=－１）｛／/当前指令得页面号不在物理块中ﻩ spaｃe = fｉｎdＳpaｃe（);ﻩﻩif（space ！＝-1)ﻩ { ／/当前存在空闲得物理块ﻩﻩ blocｋpoiｎter＋+;ﻩﻩﻩｂlock［spａcｅ]、ｐａｇｅnｕm=curpagｅ; /／将此页面调入内存ﻩ n++;//缺页次数＋1ﻩﻩﻩ diｓｐlay(）;//显示物理块中得页面号ﻩ｝ﻩ elseﻩ { /／没有空闲物理块,进行置换ﻩﻩﻩﻩpｏsitｉon = （++blockpｏintｅr）％4;ﻩ block[positｉon]、ｐaｇｅnum ＝ cuｒｐａge；／/将此页面调入内存ﻩﻩn＋+；ﻩﻩ disｐｌay（）；ﻩ｝ﻩ }｝ｐrｉｎtf(＂缺页次数:％d＼n＂,n）;printf（＂缺页率:%ｆ%%\n",(n/3２0、0)*100）；}void ｍain(）{ﻩint choice;ﻩpriｎtf（"＊＊＊＊*＊＊*＊*＊＊请求分页存储管理模拟系统*＊＊*＊＊＊＊＊＊*＊*\n")；ﻩrandａm（);ｐｒintf(＂＊＊*＊*＊＊*****此进程得页面调用序列如下***＊＊＊＊*＊＊＊**＊\n”）;pageｓtriｎｇ（）;ﻩwｈilｅ（choicｅ！= ４)｛ﻩﻩprinｔf(＂****＊*＊＊1:OPT ２：LRU 3:ＦＩFO 4：退出＊＊*＊＊＊***\n”）;ﻩprintf（"请选择一种页面置换算法:”）;ﻩｓｃａnf("%d＂,＆cｈoｉcｅ）；ﻩiｎit();ﻩswitch（choiｃe)ﻩ｛ﻩcａｓe 1:ﻩﻩﻩｐｒintf(”最佳置换算法OPT：\n")；ﻩpｒintf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址＼n"）;ﻩﻩﻩOPＴ（）；ﻩbreak；ﻩcａse 2：ﻩﻩｐrinｔf("最近最久未使用置换算法LRＵ:\n"）；ﻩｐrｉntf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址＼n＂）;ﻩＬRU()；ﻩﻩﻩｂreaｋ；ﻩﻩcaｓe 3：ﻩprintf("先进先出置换算法FＩＦＯ：\n＂）；ﻩpｒiｎｔf（＂页面号物理地址页面号物理地址页面号物理地址页面号物理地址\ｎ＂);ＦIFO(）；ﻩﻩbreａk;ﻩ｝}}。

请求分页式存储管理的地址转换过程实现

第2部分、请求分页式存储管理的地址转换过程实现：●基本要求：在第1部分实验基础上实现进程的分页式内存分配和地址转换过程，并进一步实现请求分页式存储分配和地址转换过程。

页面置换算法至少应实现先进先出（FIFO ）、最近最久未使用（LRU ）等算法。

●参考学时：16学时 ●实验提示：1、建立一个位示图，用来模拟内存的分配情况，位示图的位数与设定的物理块个数相同。

程序启动时可利用一组随机0和1填充位示图，表示内存已被占用情况。

假设内存容量为64K ，块大小为1K ，则共有64个块，对应的位示图可能的值如下：该位示图表示内存的2（0字节第2位）、3（0字节第3位）、6（0字节第6位）、8（1字节第0位）、9（1字节第1位）、12（1字节第4位）、15（1字节第7位）…等块没有被占用。

2、创建进程时输入进程大小，并根据程序中设定的物理块大小为进程分配物理块，同时建立页表。

例如，在上图基础上，若要建立一个大小为5000字节的进程，则：● 计算出该进程共有“向上取整（5000/1024）=5”个页，需要占用5个内存块；● 建立空的页表，即长度为5的一维整数数组；● 从位示图中找出前5个“0”位在整个位示图中的位置号（即i 字节j 位为0，则该位的位置为8*i+j ），并将这些号依次填入页表中，同时把前5个“0”改为“1”，以示对应内存块已经分配。

第0字节 1 0 1 1 0 0 1 1 第2字节 1 1 1 0 0 1 1 1 第4字节 0 0 0 1 1 1 1 1 第6字节1 1 1 1 1 0 0 0第1字节 0 1 1 0 1 1 0 0 第3字节 1 0 0 0 0 1 1 1 第5字节 0 1 1 1 0 0 1 1 第7字节0 0 0 0 0 0 0 13、输入当前执行进程所要访问的逻辑地址，并将其转换成相应的物理地址。

4、进程退出时，根据其页表内容向位示图反向回填“1”。

5、扩充页表，将其变成支持请求和置换功能的二维页表（增加存在位等）。

页式虚拟存储地址变换.

页式虚拟存储管理中地址转换和缺页中断的模拟
实验目的：
1.深入了解页式虚拟存储管理技术如何实现地址转换。

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

实验要求：
编写程序模拟实现页式虚拟存储管理中的地址转换过程以及缺
页中断的处理过程。

实验指导：
1.请求分页中硬件地址变换过程。

(1)
自己设计一个主存分配表。

(2)对逻辑地址进行划分为页号和页内地址
(3)越界检查，若越界直接中断退出程序的执行。

（不越界情况下）检索页表分2种情况：其一，若该页在内存，则找到其对应的物理块号；合并块号和块内地址形成物理地址。

进行输出。

(4)其二，若该页不再内存，产生缺页中断，调用缺页中断子
程序执行缺页中断处理过程。

中断返回后重新执行被中断的指令。

2.采用某一种页面置换算法实现分页管理的缺页调度。

(1)当硬件发出缺页中断后转操作系统处理缺页中断。

查看主存分块表看有无可用空闲块。

若有则为进程分配一块。

若无空闲块，当采用一种页面置换算法（例如FIFO形成队列），其头部放在变量K 中淘汰最先进入主存的一页，若该页修改过，好要重新写回磁盘。

然后再把当前要访问的页装入该内存块，并修改页表和存储分块表。

数组P中各个元素为作业已在主存的页号。

假定作业最多可分配m块。

当淘汰一页时，总是淘汰P[K]所指页。

之后调整数组P：
P[K]=要装入的页；
K=（K+1）mod m;
流程图如下：。

模拟分页式虚拟存储管理中硬件的地址转换和缺页中断--选择页面调度算法处理缺页中断

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

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

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

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

四．程序清单//// 操作实验二.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 : 定义控制台应用程序的入口点。

操作系统实验六-虚拟存储器实验报告

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

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

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

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

三、实验题目本实验有三道题目，其中第一题必做，第二，三题中可任选一个。

第一题：模拟分页式存储管理中硬件的地址转换和产生缺页中断。

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

为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表的格式为：其中，标志----用来表示对应页是否已经装入主存，标志位=1，则表示该页已经在主存，标志位=0，则表示该页尚未装入主存。

主存块号----用来表示已经装入主存的页所占的块号。

在磁盘上的位置----用来指出作业副本的每一页被存放在磁盘上的位置。

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

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

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

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

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

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

操作系统课程设计模拟请求页式存储管理

操作系统课程设计报告项目：模拟请求页式存储管理一、目的和要求1、实训目的（1）通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。

熟悉虚存管理的各种页面淘汰算法（2）通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

2、实训要求编写并调试完成请求页式存储管理程序。

页面置换算法：最佳置换算法（OPT）、先进先出算法(FIFO)和最近最少用算法（LRU）。

要求打印每个页面置换算法的页面置换变化示意图、缺页中断次数和缺页中断率，以比较各种算法的优缺点。

二、设计思路及过程1、概要设计1.1 问题概述根据三种不同的置换算法（FIFO、LRU、OPT），依据其不同的算法方式，分别计算该页面引用串在不同算法下的缺页次数与缺页率，并显示各页面的变化情况。

1.2 内容分析对于该课程设计中模拟的请求页式存储管理的页面置换过程，只要掌握其中最基本的三种算法，包括FIFO、LRU及OPT。

另外，对于同一个页面引用串，要求能够调用不同的算法对它进行操作。

2、过程设计2.1模块设计在下图的主模块设计图中，只注重描绘了请求页式存储管理的三种主要算法，未描绘出细节部分。

图2.1 请求页式存储管理的主模块设计图2.2 算法原理分析要成功实现算法，首先要知道各个方法是怎么做的，即原理是怎样的，下面是三种算法的原理。

（1）FIFO算法：该算法认为刚被调入的页面在最近的将来被访问的可能性很大，而在主存中滞留时间最长的页面在最近的将来被访问的可能性很小。

因此。

FIFO算法总是淘汰最先进入主存的页面，即淘汰在主存中滞留时间最长的页面。

（2）LRU算法是最近最久未使用，当当前内存中没有正要访问的页面时，置换出在当前页面中最近最久没有使用的页面。

该算法总是选择最近一段时间内最长时间没有被访问过的页面调出。

它认为那些刚被访问过的页面可能在最近的将来还会经常访问他们，而那些在较长时间里未被访问的页面，一般在最近的将来再被访问的可能性较小。

《编程演示三种存储管理方式的地址换算过程》实验报告

内师大计算机与信息工程学院《操作系统》课程设计报告1.设计任务编程演示三种存储管理方式的地址换算过程2 设计的功能目标1、分页方式的地址换算2、分段方式的地址换算3、段页式的地址换算3 设计的思想、方法和技术（含数据结构、算法）实验要求演示分页方式的地址换算，分段方式的地址换算，段页式的地址换算。

1.分页方式通过自定义的逻辑地址算出页号与页内地址，页号=逻辑地址/页面大小，业内地址=逻辑地址%页面大小，然后通过页表来实现向物理地址的转换。

物理地址=块号*页面大小+页内地址2.分段方式通过段号和段内地址得到物理地址。

物理地址=段首地址+段内地址，段首地址根据段号找到，段号和逻辑地址自定义3.段页式通过段号得到页表首地址，通过页号得到块号，进而得到物理地址。

物理地址=页表首地址+块号*页面长度+页内地址，通过段号找到页表首地址，通过页号找到块号，其中逻辑地址段号，页号，页内地址自定义。

4 设计的主要代码及注释分页式部分：int page(int A,int L){int pl,pa;printf("int luo ji di zhi:");scanf("%d",&pl);printf("int ye mian da xiao:");scanf("%d",&pa);if(pl>256)printf("luo ji di zhi %d > ye biao chang du,wrong\n",pl);else{int d,P,kd,i;int WD;int PT[256];for(i=0;i<256;i++){PT[i]=rand() %512;}P=pl/pa;d=pl%pa;if(P>=256) printf("ye hao > biao chang du,wrong\n");else {printf("ye hao = luo ji di zhi / ye mian da xiao=%d,ye nei di zhi = luo ji di zhi % ye mian da xiao=%d\n",P,d);kd=PT[P];printf("gen ju ye hao:%d get kuai hao:%d\n",P,kd);WD=kd*pa+d;printf("wu li kuai hao=kuai hao*ye mian da xiao+ye nei di zhi\n");printf("wu li di zhi=%d*%d+%d\n",kd,pa,d);printf("luo ji di zhi huan suan hou wu li di zhi=%d\n\n",WD);return (0);}}}分段式部分：int Segment(int sn,int sd){int i,wd;for(i=0;i<255;i++){st.segf[i]=rand()%255;st.segl[i]=rand()%2048;}if(sn>256) printf("duan hao > duan biao chang du 256,wrong\n\n",sn);else if(sd>st.segl[sn]) printf("duan nei di zhi > duan chang du ,wrong\n\n",sd,st.segl[sn]);else{printf("gen ju duan hao zhao dao duan shou di zhi:%d\n",st.segf[sn]);printf("wu li di zhi=duan shou di zhi+duan nei di zhi\n");printf("wu li di zhi =%d+%d\n",st.segf[sn],sd);wd=st.segf[sn]+sd;printf("huan suan de dao de wu li di zhi=%d\n\n",wd);}return (0);}段页式部分：int SegPagt(int sn,int pn,int pd){int i,wd;sp.pl=256;for(i=0;i<255;i++){sp.pf[i]=sp.segf[i]=rand()%26624;sp.ptl[i]=sp.segl[i]=rand()%512;sp.pt[i]=rand()%256;}if(sn>=256)printf("duan hao %d > ye biao chang du 256,wrong\n\n",sn);elseif(pn>=256)printf("ye hao %d > ye biao chang du 256,wrong\n\n",pn);elseif(pd>sp.pl)printf("ye nei di zhi > ye mian chang du,wrong\n\n",pd,sp.pl);else{printf("tong guo duan hao:%d get ye biao shou di zhi:%d\n,tong guo ye hao:%d get kuai hao:%d\n",sn,sp.pf[sn],pn,sp.pt[pn]);printf("wu li di zhi=ye biao shou di zhi+kuai hao*ye mian chang du+ye nei di zhi\n");printf("wu li di zhi=%d+%d*%d+%d\n",sp.pf[sn],sp.pt[pn],sp.pl,pd);wd=sp.pf[sn]+sp.pt[pn]*sp.pl+pd;printf("wu li di zhi:%d\n\n",wd);}return (0);}5 结果分析（含实现中出错原因分析）分页式:分段式：段页式：6 设计小结（即收获和体会）通过本次实验，对分页式，分段式，段页式的地址转换有了更深的了解。

操作系统管理-虚拟存储器-实验报告-代码7页

操作系统管理-虚拟存储器-实验报告-代码7页一、实验目的学习操作系统中虚拟存储器的概念，掌握虚拟存储器的实现思路和方式。

二、实验要求在C语言环境下，实现基于分页机制的虚拟存储和页表管理。

三、实验内容1.实现一个虚拟存储器，其中分页大小为4KB，虚拟地址空间大小为4GB（每个进程可以使用的虚拟地址空间）。

物理内存大小为512MB，即实际内存中有128个物理页面。

2.实现页表管理，将虚拟地址映射到物理地址。

3.实现页面替换算法，当物理内存不足时，需要将某些页面从内存中置换出来。

4.实现程序的运行，能够根据页面缺失率输出性能参数。

四、实验步骤1.确定程序设计思路和数据结构。

2.实现虚拟存储器和页表管理。

3.实现页面替换算法。

五、实验代码及解析对于程序设计思路，首先需要确定虚拟存储器和物理内存的大小，以及页面大小。

虚拟存储器大小默认为4GB，物理内存大小为512MB，页面大小为4KB。

其次，需要设计页表数据结构。

页表可以使用一个二维数组表示，其中第一维表示页表项，第二维表示页内地址。

页表项有四个字段，分别为标志位（是否在内存中）、页框号（页面所在的物理页框号）、保护（页面的读写权限）、计数（页面使用情况的计数器）。

第三，需要设计页面替换算法。

本程序采用最近最少使用算法（LRU）作为页面替换算法，当物理内存不足时，选择使用最近最少使用的页面进行替换。

#define PAGE_SIZE 4096 // 页面大小#define VIRTUAL_MEM_SIZE 4 * 1024 * 1024 * 1024 // 虚拟存储器大小#define PHYSICAL_MEM_SIZE 512 * 1024 * 1024 // 物理内存大小#define PAGE_NUM (VIRTUAL_MEM_SIZE / PAGE_SIZE) // 页面总数#define PHYSICAL_PAGE_NUM (PHYSICAL_MEM_SIZE / PAGE_SIZE) // 物理页面数struct page_table_entry {int present; // 是否在内存中（1为在，0为不在）int page_frame; // 页面所在的物理页框号int protect; // 页面的读写权限int count; // 页面使用情况的计数器}struct page_table_entry page_table[PAGE_NUM][PAGE_SIZE]; // 页表虚拟存储器和页表管理需要掌握的是页表的相关数据结构，还有一个重要的点，就是如何将虚拟地址映射到物理地址。

模拟操作系统的请求分页存储管理java代码

请求分页存储管理的实现写出方案实现代码（1）page类package homework;public class Page {private int pagenumb;//页号private int physicsnumb;//物理块号private boolean state;//状态位private int visitcount;//访问字段private boolean change;//修改位private int CRTaddress;//外存地址public Page(){this.pagenumb=-1;this.physicsnumb=-1;this.state=false;this.visitcount=0;this.change=false;this.CRTaddress=-1;}public Page(int pagenumb,int physicsnumb,boolean state,int visitcount,boolean change,int CRTaddress){this.pagenumb=pagenumb;this.physicsnumb=physicsnumb;this.state=state;this.visitcount=visitcount;this.change=change;this.CRTaddress=CRTaddress;}public void setPagenumb(int pagenumb){this.pagenumb=pagenumb;}public void setPhysicsnumb(int physicsnumb){this.physicsnumb=physicsnumb;}public void setState(boolean state){this.state=state;}public void setVisitcount(int visitcount){this.visitcount=visitcount;}public void setChange(boolean change){this.change=change;}public void setCRTaddress(int CRTaddress){this.CRTaddress=CRTaddress;}public int getPagenumb(){return this.pagenumb;}public int getPhysicsnumb(){return this.physicsnumb;}public boolean getState(){return this.state;}public int getVisitcount(){return this.visitcount;}public boolean getChange(){return this.change;}public int getCRTaddress(){return this.CRTaddress;}}（2）Shell类：页表package homework;import java.util.Scanner;public class Shell {Page shell[];private int current;private int length;public Shell(){ };public Shell(int length){this.length=length;this.current=0;shell=new Page[length];for(int i=0;i<length;i++){this.shell[i]=new Page();}}public void setCurrent(int current){this.current=current;} public int getCurrent(){return this.current;}public int searchpage(int pagenumb){int i=0;if(this.current==0){return -2;}else{while(i<this.current){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}}public void Inchange(int b[],String ch,int number){Scanner a=new Scanner(System.in);switch(ch){case"yes":{System.out.println("请输入一个新的数据");b[this.shell[number].getPhysicsnumb()]=a.nextInt();this.shell[number].setChange(true);System.out.println("修改成功！");break;}case"no":{break;}default:{System.out.println("输入字符有误，将退出程序！！");System.exit(0);}}}public int Isover(){if(this.current>=this.length){return 1;}else return 0;}public int MinVisitcount(){int i,t=0;for(i=1;i<this.current;i++){if(this.shell[i].getVisitcount()<this.shell[t].getVisitcount()){ t=i;}}return t;}public int Ischange(int number){if(this.shell[number].getChange()==true){return 1;}else return 0;}public void printPageShell(){System.out.println("页表：");System.out.println("索引\t"+"页号\t"+"物理块号\t"+"状态\t"+"访问次数\t"+"修改\t"+"外存地址\t");for(int i=0;i<this.length;i++){System.out.println(i+"\t"+this.shell[i].getPagenumb()+"\t"+this.shell[i ].getPhysicsnumb()+"\t"+this.shell[i].getState()+"\t"+this.shell[i].getVisi tcount()+"\t"+this.shell[i].getChange()+"\t"+this.shell[i].getCRTaddress()) ;}}public void programFunction(){System.out.println("****************************请求分页存储系统****************************");System.out.println("功能：");System.out.println("\t 1.查看页表");System.out.println("\t 2.查看快表");System.out.println("\t 3.查看外存");System.out.println("\t 4.在内存修改数据");System.out.println("\t 5.继续访问页面");System.out.println("\t 6.退出程序");}public void Dealfunction(int i,KShell TLB,Source s[],int b[]){ if(i==1){this.printPageShell();}else if(i==2){TLB.printKShell();}else if(i==3){System.out.println("外存：");System.out.println("外存地址\t"+"页号\t"+"数据\n");for(int k=0;k<20;k++){s[k].printSource(k);}}else if(i==4){String ch="yes";int pageNumb;Scanner a=new Scanner(System.in);System.out.print("请输入一个页号:");pageNumb=a.nextInt();int numb=this.searchpage(pageNumb);if(numb<0){System.out.println("内存中没有此页号");}else{this.Inchange(b, ch,numb);}}else if(i==6){System.out.println("结束程序");System.exit(0);}}public static void main(String[] args){Scanner a=new Scanner(System.in);int i,number=-10,k1,k2,result;int k3=0;//当前存储的内存地址int t;//页表中访问次数最小的索引int b[]=new int[10];//内存中存储的数据String ch;int slength,plength,Tlength,data;System.out.print("请输入外存大小：");slength=a.nextInt();System.out.print("请输入页表大小：");plength=a.nextInt();System.out.print("请输入快表大小：");Tlength=a.nextInt();//定义页表,快表，外存Shell pageshell=new Shell(plength);//页表Source s[]=new Source[slength];//外存KShell TLB=new KShell(Tlength);//快表System.out.println("产生一个随机序列作为外存数据！");//录入外存地址和数据for(i=0;i<slength;i++){data=(int)(100*Math.random());System.out.print(data+"\t");s[i]=new Source(i,data);System.out.println("\n外存设置成功");//请求页面do{//TLB.printKShell();//打印当前快表的情况//pageshell.printPageShell();//打印当前页表的情况System.out.println("请输入一个页面的页号(0-19)：");k1=a.nextInt();if(k1>=20||k1<0){System.out.println("输入数据有错，将退出程序！！");System.exit(0);}//检测快表,快表存储当前的页表项，即当快表满时采用最近最久未被使用算法置换快表System.out.println("进入快表检测");if(TLB.getCurrent()>0){number=TLB.searchpage(k1);if(number!=-1&&number!=-2){result=b[TLB.shell[number].getPhysicsnumb()];System.out.println("在快表中找到,结果为："+result);//找出该页号在页表中的位置并修改访问字段number=TLB.shell[number].getIndex();pageshell.shell[number].setVisitcount(pageshell.shell[number].getVisitc ount()+1);}}if(TLB.getCurrent()<=0||number==-1){System.out.println("在快表中找不到！"+"进入内存检测：");//在快表中找不到,去内存区的页表找if(pageshell.current>0){number=pageshell.searchpage(k1);//页号k1所在的下标if(number!=-1&&number!=-2){result=b[pageshell.shell[number].getPhysicsnumb()];System.out.println("在页表中找到,结果为："+result);//修改访问字段和状态位pageshell.shell[number].setVisitcount(pageshell.shell[number].getVisitc ount()+1);//修改快表TLB.changeKShell(pageshell, number);}if(pageshell.current<=0||number==-1){System.out.println("在内存中找不到！！");System.out.println("从外存中调入内存：");//在页表找不到，去外存区找for(i=0;i<slength;i++){if(k1==s[i].getPagenumb()){//在外存找到了缺页k2=pageshell.Isover();if(k2==1){//内存已满t=pageshell.MinVisitcount();System.out.println("内存已满！即将调出页号"+pageshell.shell[t].getPagenumb());}else{t=pageshell.current;pageshell.setCurrent(pageshell.getCurrent()+1);}//判断是否修改了内存的数据if(pageshell.Ischange(t)==1){s[pageshell.shell[t].getCRTaddress()].setSts(b[pageshell.shell[t].getPh ysicsnumb()]);}//调入内存pageshell.shell[t].setPagenumb(k1);if(k2==1){b[pageshell.shell[t].getPhysicsnumb()]=s[i].getSts();}else{pageshell.shell[t].setPhysicsnumb(k3);//未满则设置物理块号，满了只改变其他5个字段b[k3]=s[i].getSts();k3++;//物理块号}pageshell.shell[t].setState(true);pageshell.shell[t].setVisitcount(1);pageshell.shell[t].setChange(false);pageshell.shell[t].setCRTaddress(i);System.out.println("调入内存成功！");//修改快表TLB.changeKShell(pageshell,t);System.out.println("修改快表成功！");System.out.println("结果为："+b[k3-1]);break;}}}}do{pageshell.programFunction();System.out.print("请输入一个整数（1-6）:");i=a.nextInt();while(i<1||i>6){System.out.println("输入有误，请重新输入(1-6):");i=a.nextInt();}pageshell.Dealfunction(i,TLB,s,b);}while(i!=5);/*System.out.println("是否继续请求访问页面(1 or 0):");i=a.nextInt();while(i!=1&&i!=0){System.out.println("输入有误，请重新输入(1 or 0):");i=a.nextInt();}*/}while(i==5);System.out.println("退出程序！");}}（4）KShell类：快表package homework;public class KShell {KPage shell[];private int current;private int length;private int changenumb;//修改快表的次数public KShell(){ };public KShell(int length){this.length=length;this.current=0;this.changenumb=0;shell=new KPage[length];for(int i=0;i<length;i++){this.shell[i]=new KPage();}public void setCurrent(int current){this.current=current;}public void setChangenumb(int changenumb){this.changenumb=changenumb;} public int getCurrent(){ return current;}public int getChangenumb(){return changenumb;}public int getLength(){ return length;}public int searchpage(int pagenumb){int i=0;if(this.changenumb==0&&this.current==0){return -2;}else if(this.changenumb<this.length){while(i<this.current){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}else{while(i<this.length){if(this.shell[i].getPagenumb()==pagenumb){return i;}i++;}return -1;}}public void changeKShell(Shell pageshell,int number){if(this.getChangenumb()>=this.getLength()){if(this.getCurrent()==this.getLength()){this.setCurrent(0);}System.out.println("快表已满,快表中即将调出页号"+this.shell[this.current].getPagenumb());}if(this.getCurrent()<this.getLength()){this.shell[this.getCurrent()].setIndex(number);this.shell[this.getCurrent()].setPagenumb(pageshell.shell[number].getPa genumb());this.shell[this.getCurrent()].setPhysicsnumb(pageshell.shell[number].ge tPhysicsnumb());this.setCurrent(this.getCurrent()+1);this.setChangenumb(this.getChangenumb()+1);}}public void printKShell(){System.out.println("快表：");System.out.println("索引\t"+"页号\t"+"物理块号\t"+"在页表下的索引");for(int i=0;i<this.length;i++){System.out.println(i+"\t"+this.shell[i].getPagenumb()+"\t"+this.shell[i ].getPhysicsnumb()+"\t"+this.shell[i].getIndex());}}}（5）Source类：外存package homework;public class Source {private int pagenumb;//页号private int sts; //数据int length;public Source(){}public Source(int pagenumb,int sts){this.pagenumb=pagenumb;this.sts=sts;}public void setPagenumb(int pagenumb){this.pagenumb=pagenumb;}public void setSts(int sts){this.sts=sts;}public int getPagenumb(){return this.pagenumb;}public int getSts(){return this.sts;}public void printSource(int i){System.out.println(i+"\t"+this.pagenumb+"\t"+this.sts+"\n");}}4.用户使用说明答：本程序是使用java语言编写的实现请求分页存储管理的程序，是在eclipise下运行的结果，只需运行Shell类就行了首先先设置外存，页表和快表的大小，然后输入一个请求访问的页面。

操作系统实验六_虚拟存储器实验报告

操作系统实验六_虚拟存储器实验报告
实验目的：
通过本次实验，了解虚拟存储器的实现原理，以及如何分配虚拟地址和物理地址，实现虚拟存储器管理。

实验内容：
1.按照顺序完成程序代码，以实现对虚拟地址的映射，再间接实现对物理地址的访问。

2.完成不同的页面置换算法，并分析各自的特点。

实验步骤：
1.在实验中实现了给定的伪指令程序，其中包括了虚拟存储器的实现代码。

在页面大小为1K的情况下，每个进程的虚拟地址空间为64K，物理地址空间为16K。

2.在虚拟存储器的实现中，采用了分段式存储器管理模式，其中包括了段描述符表和页表。

其中段描述符表包括了段基址、段长、段类型等信息，而页表则记录了虚拟地址和物理地址的映射关系。

3.实现了三种页面置换算法：LRU、FIFO和随机算法。

其中，LRU算法会选择最近没有使用过的页面进行置换；FIFO算法会按照先进先出原则进行页面置换；随机算法则随机选取一个页面进行置换。

4.通过本次实验，学习了如何通过虚拟地址访问物理地址，并实现了对虚拟存储器的管理。

同时，在实现页面置换算法时，也对不同算法的特点进行了分析。

实验结果：。

计算机操作系统实验_源码_模拟请求分页虚拟存储管理中的硬件地址变换过程[技巧]

4. 进行缺页中断处理。中断返回后,重新执行该指令。假定主存的每块长度为64个字节,现有一个具有8页的作业,系统为其分配了4个主存块(即 m=4),且最多分4块。其中第0页至第3页已经装入主存。该作业的页表如表10—2所示。
地址变换算法框图如图10—1所示。
运行设计的地址变换程序 ,显示或打印运行结果。。因为只是模拟地址变换,并不
cin>>menu;
while(menu)
{
switch(menu)
{
case 1:
cout<<"请输入指令的逻辑地址:";
cin>>ins;
changeaddr(p,ins);
break;
case 2:
cout<<"谢谢使用，下次再见～"<<endl;
exit(0);
break;
default:
cout<<"输入有误，请重新输入～"<<endl;
cout<<"----------\t\t1.输入指令\t\t---------"<<endl;
cout<<"----------\t\t2.退出程序\t\t---------"<<endl;
cout<<"----------欢迎使用分页虚拟存储器硬件地址变换算法---------"<<endl;
cout<<endl<<"请输入您的选择:";
p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;

操作系统_请求分页存储管理模拟实现

操作系统请求分页存储管理模拟实现#include<stdlib.h>#include<iomanip.h>#include"windows.h"#include"os.h"#define n 64//实验中假定主存的长度#define m 4//实验中假定每个作业分得主存块块数int p[m];//定义页struct{short int lnumber;//页号short int flag;//表示该页是否在主存,“1”表示在主存,“0”表示不在主存short int pnumber;//该页所在主存块的块号short int write;//该页是否被修改过,“1”表示修改过,“0”表示没有修改过short int dnumber;//该页存放在磁盘上的位置,即磁盘块号short int times;//被访问的次数,用于LRU算法}page[n];//定义页表//各个函数的实现如下:computer::computer(){int i;for(i=0;i<n;i++){page[i].lnumber = i;page[i].flag = 0;page[i].pnumber = 10000;//用10000表示为空page[i].write = 0;page[i].dnumber = i;page[i].times = 0;}//初始化页表for(i=0;i<m;i++){page[i].pnumber = i;}for(i=0;i<m;i++){p[i] = i;page[i].flag = 1;}//初始化页}void computer::showpagelist(){int i;cout<<"页号"<<"\t"<<"是否在主存中"<<"\t"<<"块号"<<"\t"<<"是否被修改过"<<"\t"<<"磁盘块号"<<"\t"<<"访问次数"<<endl;for(i=0;i<n;i++){cout<<page[i].lnumber<<"\t"<<page[i].flag<<""<<page[i].pnumber<<"\t"<<page[i].write<<" "<<page[i].dnumber<<" \t"<<page[i].times<<endl;}}void computer::showpage(){int i;for(i=0;i<m;i++){cout<<"\t"<<p[i];}cout<<endl;}void computer::transformation(){unsignedlogicAddress,logicNumber,innerAddress,physicsAddress,physicsNumber;int i,head=0,fail = 0;int method,temppage=0;short int times = 10000;cout<<"请输入一个逻辑地址(四位十六进制数):";cin>>hex>>logicAddress;//读入逻辑地址logicNumber = logicAddress >> 10;//得到页号cout<<"页号为:"<<logicNumber<<endl;innerAddress = logicAddress & 0x03ff;//得到页内地址cout<<"页内地址为:"<<innerAddress<<endl;for(i=0;i<n;i++){if(logicNumber==(unsigned)page[i].lnumber){if(page[i].flag == 1){cout<<"请求的页面在主存中!"<<endl;page[i].times++;physicsNumber = page[i].pnumber;//由页号得到块号cout<<"请求的主存块号为:"<<physicsNumber<<endl;physicsAddress = physicsNumber << 10 |innerAddress;//得到物理地址cout<<"请求的物理地址为:"<<physicsAddress<<endl;//输出物理地址break;}else{cout<<"请求的页面不在主存中! 将进行缺页中断处理!"<<endl<<"请选择算法!"<<endl; cout<<"1.先进先出"<<endl<<"2.最近最少用"<<endl<<"请选择置换算法:";cin>>method;if(method == 1) //采用先进先出算法{cout<<"采用先进先出算法!"<<endl;fail = p[head];cout<<"第"<<fail<<"页将被替换!"<<endl;p[head] = logicNumber;head = (head+1) % m;if(page[fail].write == 1)cout<<"第"<<fail<<"页曾被修改过!"<<endl;page[fail].flag = 0;page[logicNumber].flag = 1;page[logicNumber].write = 0;page[logicNumber].pnumber = page[fail].pnumber; page[fail].pnumber = 10000;page[logicNumber].times++;break;}else if(method == 2) //采用最近最少用算法{cout<<"采用最近最少用算法!"<<endl;for(i=0;i<n;i++){if(page[i].flag == 1){if(page[i].times<times){times = page[i].times;temppage = page[i].lnumber;}}}cout<<"第"<<temppage<<"页将被替换!"<<endl; for(i=0;i<m;i++){if(p[i] == temppage){p[i] = logicNumber;}}if(page[temppage].write == 1)cout<<"第"<<temppage<<"页曾被修改过!"<<endl; page[temppage].flag = 0;page[logicNumber].flag = 1;page[logicNumber].write = 0;page[logicNumber].pnumber = page[temppage].pnumber; page[temppage].pnumber = 10000;page[logicNumber].times++;break;}else{ cout<<"你输入有误,即将退出!";exit(1);}}}}}void main(){char c,d;computer os;cout<<"页表正在初始化中...,3秒钟后为你显示页和页表!"<<endl; Sleep(3000);os.showpage();os.showpagelist();T:os.transformation();cout<<"是否显示页和页表?(Y/N)";cin>>c;switch(c){case 'y':os.showpage();os.showpagelist();case 'n':cout<<"是否继续进行请求分页?(Y/N)";cin>>d;if (d=='Y'||d=='y')goto T;else if (d=='N'||d=='n')exit(1);elsecout<<"输入错误!"<<endl; default:cout<<"输入错误!"<<endl; } }。

请求分页存储管理模拟实验

操作系统模拟实验实验名称：请求分页存储管理模拟实验实验目的：通过实验了解windows系统中的线程同步如何使用，进一步了解操作系统的同步机制。

实验内容：调用Windows API，模拟解决生产者－消费者问题；思考在两个线程函数中哪些是临界资源？哪些代码是临界区？哪些代码是进入临界区？哪些代码是退出临界区？进入临界区和退出临界区的代码是否成对出现？学习Windows API中的如何创建线程，互斥，临界区等。

程序运行结果：源程序：#include "stdAfx.h"//包含头文件以支持多线程#include "windows.h"#include "stdio.h"//用于标志所有的子线程是否结束//每次子线程结束后，此值便加1。

static long ThreadCompleted = 0;//互斥量HANDLE mutex;//信号量，用于生产者通知消费者HANDLE full;//信号量，用于消费者通知生产者HANDLE empty;//信号量，当所有的子线程结束后，通知主线程，可以结束。

HANDLE evtTerminate;//生产标志#define p_item 1//消费标志#define c_item 0//哨兵#define END 10//缓冲区最大长度const int max_buf_size=11;const int cur_size=10;//缓冲区定义int BUFFER[max_buf_size];//放消息指针int in=0;//取消息指针int out=0;int front=0;int tail=0;int sleep_time=1000;bool flag=true;//线程函数的标准格式unsigned long __stdcall p_Thread(void *theBuf);unsigned long __stdcall c_Thread(void *theBuf);//打印缓冲区内容void PrintBuf(int buf[],int buf_size);int main(int argc, char* argv[]){//初始化缓冲区unsigned long TID1, TID2;for(int i=0;i<cur_size;i++)BUFFER[i]=0;//互斥量和信号量的创建，函数用法可查看MSDNmutex=CreateMutex(NULL,false,"mutex");full=CreateSemaphore(NULL,0,1,"full");empty=CreateSemaphore(NULL,max_buf_size,max_buf_size,"empty");evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");//创建一个生产者线程和消费者线程。

操作系统实验请求分页存储管理模拟实验

实验四请求分页存储管理模拟实验一：实验目的通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求分页存储管理系统的原理和实现技术的理解;二：实验内容假设每个页面可以存放10条指令,分配给进程的存储块数为4;用C语言或Pascal语言模拟一进程的执行过程;设该进程共有320条指令,地址空间为32个页面,运行前所有页面均没有调入内存;模拟运行时,如果所访问的指令已经在内存,则显示其物理地址,并转下一条指令；如果所访问的指令还未装入内存,则发生缺页,此时需要记录缺页产生次数,并将相应页面调入内存,如果4个内存块已满,则需要进行页面置换;最后显示其物理地址,并转下一条指令;在所有指令执行完毕后,显示进程运行过程中的缺页次数和缺页率;页面置换算法：分别采用OPT、FIFO、LRU三种算法;进程中的指令访问次序按如下原则生成：50%的指令是顺序执行的;25%的指令是均匀分布在低地址部分;25%的指令是均匀分布在高地址部分;三：实验类别分页存储管理四：实验类型模拟实验五：主要仪器计算机六：结果OPT:LRU: FIFO:七：程序include<>include<>include<>define blocknum 4agenum=-1;blocki.accessed=0;m=0;}}int pageExistint curpageagenum == curpagereturn i; agenum==-1return i; ccessed > blockpos.accessedpos = i; agenum = -1{printf" %02d ",blocki.pagenum;printf"%p |",&blocki.pagenum;}}printf"\n";}void randamagenum = curpage; agenum= numj/10{blockk.accessed = 1000;} ccessed = j;break;}}}position = findReplace;agenum = curpage;agenum = curpage; agenum = curpage;display;n++; ccessed = -1;ccessed++;}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void FIFO{int n=0;agenum=curpage; agenum = curpage; //将此页面调入内存n++;display;}}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void main{int choice;printf"请求分页存储管理模拟系统\n";randam;printf"此进程的页面调用序列如下\n";pagestring;whilechoice = 4{printf"1:OPT 2:LRU 3:FIFO 4:退出\n";printf"请选择一种页面置换算法:";scanf"%d",&choice;init;switchchoice{case 1:printf"最佳置换算法OPT:\n";printf"页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n";OPT;break;case 2:printf"最近最久未使用置换算法LRU:\n";printf"页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n";LRU;break;case 3:printf"先进先出置换算法FIFO:\n";printf"页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n";FIFO;break;}}}。

模拟分页式虚拟存储管理中地址转换和缺页中断

合肥学院计算机科学与技术系实验报告2009 ～2010 学年第一学期课程操作系统原理实验名称模拟分页式存储管理中硬件的地址转换和产生缺页中断学生姓名方岚王庆红王兆娟何佳丽专业班级07计本（1）指导教师屠菁2009 年 11 月一、实验目的在计算机系统中，为了提高主存利用率，往往把辅助存储器（如磁盘）作为主存储器的扩充，使多道运行的作业的全部逻辑地址空间总和可以超出主存的绝对地址空间。

通过这次实习理解在分页式存储管理中怎样实现虚拟存储器。

深入了解分页式存储管理如何实现地址转换,进一步认识分页式虚拟存储管理中如何处理缺页中断。

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

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

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

三、实验步骤1. 概要设计分页式存储管理中地址转换过程很简单，假定主存块的大小为2n 字节，主存大小为2m'字节和逻辑地址m 位，则进行地址转换时，首先从逻辑地址中的高m-n 位中取得页号，然后根据页号查页表，得到块号，并将块号放入物理地址的高m'-n 位，最后从逻辑地址中取得低n 位放入物理地址的低n 位就得到了物理地址，过程如图1所示。

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

《操作系统》实验报告三页式虚拟存储管理中地址转换和缺页中断

实验项
目
名称
页式虚拟存储管理中地址转换和缺页中断
实验目的及要求1、深入了解页式存储管理如何实现地址转换。

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

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

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

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

实验步骤
注：可根据实际情况加页。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

实验报告
模拟请求分页虚拟存储管理中的硬件地址变换过程
【实验目的】
1.通过实验加深对请求分页虚拟存储器管理中的地址变换加深理解。

2.熟练使用所学知识完成地址转换过程。

【实验原理】
1. 请求分页虚拟存储管理技术是把作业地址空间的全部信息存放在磁盘上。

当作业被选中运行时,,先把作业的开始几页装入主存并启动运行。

为此在为作业建立页表时,应说明哪些页已在主存,哪些页不在主存。

页表的格式如表1-1所示,其中,”标志”表示对应页是否已经装入主存:
“1”表示对应页已经装入主存;
“0”表示对应页未装入主存;
“主存快号”表示该页对应的主存快号;
“修改位”指示该页调入主存后是否修改过的标志。

“外存地址”指示该页所在的外存地址。

自己设计一个主存分块表。

2. 作业业执行时,指令中的逻辑地址指出参加运算的操作数(或指令)地址中的页号和页内偏移量。

硬件地址转换机构按页号查页表。

若该页的标志为1 ,则表示该页已在主存,从而找到该页对应的主存块号。

根据关系式:
绝对地址=块号*块的长度+页内偏移量
计算出欲访问的主存地址。

由于页号为2的整次幂,所以只要将块号与页内偏移量相拼接,放入主存地址寄存器即可。

按照该地址取指令或取操作数,完成指定的操作。

3. 设计一个”地址变换”程序,模拟硬件地址变化过程。

当访问的页在主存时,则形成绝对地址后,不去模拟指令的执行,而是输出被转换的地址。

当访问的页不在主存时,输出”该页不在主存,产生缺页中断”,以表示产生一次缺页中断。

4. 进行缺页中断处理。

中断返回后,重新执行该指令。

假定主存的每块长度为64个字节,现有一个具有8页的作业,系统为其分配了4个主存块(即m=4),且最多分4块。

其中第0页至第3页已经装入主存。

该作业的页表如表10—2所示。

地址变换算法框图如图10—1所示。

运行设计的地址变换程序,显示或打印运行结果。

因为只是模拟地址变换,并不
【实验源码】
#include<iostream>
using namespace std;
struct Page{
int pno;//页号
int flag;//标志位
int cno;//主存号
int modf;//修改位
int addr;//外存地址
}Page;
void changeaddr(struct Page p[],int logaddr){//地址变换
int j=logaddr/64;//对应的块号
int k=logaddr%64;//对应的偏移量
int flag=0;
int addr;
for(int i=0;i<8;i++)
{
if(p[i].pno==j)//找到对应的页号
{
if(p[i].flag==1)//页面标志为1
{
addr=p[i].cno*64+k;
cout<<"物理地址为: "<<addr<<endl;
cout<<"详细信息: "<<"\t页面号："<<p[i].pno<<"\t主存号:"<<p[i].cno<<"\t偏移量："<<k<<endl;
flag=1;
break;
}
}
}
if(flag==0)
cout<<"该页不在主存,产生缺页中断"<<endl;
}
void main()
{
int menu;
int ins;//指令逻辑地址
struct Page p[8];
p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;
p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;
p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;
p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;
p[4].pno=4;p[4].flag=0;p[4].addr=017;
p[5].pno=5;p[5].flag=0;p[5].addr=025;
p[6].pno=6;p[6].flag=0;p[6].addr=212;
p[7].pno=7;p[7].flag=0;p[7].addr=213;
cout<<"----------欢迎使用分页虚拟存储器硬件地址变换算法---------"<<endl;
cout<<"----------\t\t1.输入指令\t\t---------"<<endl;
cout<<"----------\t\t2.退出程序\t\t---------"<<endl;
cout<<"----------欢迎使用分页虚拟存储器硬件地址变换算法---------"<<endl;
cout<<endl<<"请输入您的选择:";
cin>>menu;
while(menu)
{
switch(menu)
{
case 1:
cout<<"请输入指令的逻辑地址：";
cin>>ins;
changeaddr(p,ins);
break;
case 2:
cout<<"谢谢使用，下次再见！"<<endl;
exit(0);
break;
default:
cout<<"输入有误，请重新输入！"<<endl;
break;
}
cout<<endl<<"请输入您的选择:";
cin>>menu;
}
}
【实验截图】
【实验小结】
1.通过对实验要求的解读，能够理解题目提出的要求，并能够按照要求进行页
表的初始化以及相关主存的分配工作。

2.实验中使用的地址变换机构可通过逻辑地址与主存块长度作取整运算获得逻
辑地址对应的页面号，再通过求余运算获得页内偏移地址。

3.实验的不足与可改进之处：当逻辑地址对应的页面在主存中时，地址变换完
全正确，符合要求。

当页面不在主存中时，仅输出“页面中断”，没有进行页面替换算法的操作，与真实情况相差较大。

由于实验中仅有4块主存空间可用，也并未要求页面进行替换，所以我在做实验的时候没有把缺页的指令再次执行，仅仅是输出中断提示。

再次部分，日后若有更高要求，可以做出改
进。