下载文档原格式
一、实验目的1. 理解分页存储的基本原理和作用。
2. 掌握分页存储的实现方法。
3. 分析分页存储对系统性能的影响。
4. 提高对虚拟内存管理的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 实验工具：IDLE三、实验内容1. 分页存储的基本原理分页存储是将程序的逻辑地址空间划分为若干个大小相等的页，并将这些页存储在物理内存中。
在分页存储中，页表用于记录每个页在物理内存中的位置。
2. 分页存储的实现方法（1）定义数据结构首先，定义一个类来表示页表，该类包含以下属性：- 页号：表示页在逻辑地址空间中的编号。
- 物理页号：表示页在物理内存中的编号。
- 是否在内存：表示页是否在物理内存中。
（2）初始化页表在程序开始时，初始化页表，将所有页都标记为不在内存。
（3）处理页表请求当程序访问一个逻辑地址时，首先检查页表，如果该页在内存中，则直接访问；如果不在内存，则需要执行页面置换算法，将一个页替换出内存，并将需要访问的页加载到内存中。
（4）页面置换算法本实验采用LRU（最近最少使用）算法作为页面置换算法。
LRU算法的基本思想是：当一个页需要被替换出内存时，选择最近最少被访问的页进行替换。
3. 分析分页存储对系统性能的影响（1）提高内存利用率分页存储可以将程序中不常用的页存储在磁盘上，从而提高内存利用率。
（2）减少内存碎片分页存储可以减少内存碎片，因为每个页的大小是固定的，不会出现大小不一的内存碎片。
（3）降低系统性能分页存储会降低系统性能，因为每次访问一个页时，都需要查询页表，如果页不在内存中，还需要执行页面置换操作，这将增加系统的开销。
四、实验步骤1. 编写程序实现分页存储的基本功能。
2. 设置不同大小的页，观察对内存利用率的影响。
3. 设置不同的页面置换算法，比较其对系统性能的影响。
4. 分析实验结果，得出结论。
五、实验结果与分析1. 设置不同大小的页当页的大小较小时，内存利用率较低，因为每个页只包含少量数据。
实验6请求分页存储管理实验6:请求分页存储管理1。
实验的目的是深入理解请求分页存储管理的基本概念和实现方法，重点是地址转换、分页、替换算法等的实现思路。
2.实验属性本实验是综合性和设计性的。
3.实验仪器和设备通用PC386或以上微机4。
这个实验需要两个小时才能完成。
该实验需要以下任务:(1)建立相关数据结构:页表、页表寄存器、存储块表等。
(2)指定分配给进程的物理内存块的数量，并设置进程的页面访问顺序；(3)设计页面替换算法，可以选择OPT、FIFO、LRU等。
并计算相应的缺页率来比较它们的优缺点；(4)编写地址转换函数，通过查找页表完成从逻辑地址到物理地址的转换；如果页面丢失，选择一些替换算法(选择，先进先出，LRU等)。
)来完成页面交换；(5)可视化整个过程。
实验前应复习实验涉及的理论知识和算法，根据实验要求完成基本代码编译和预览报告，在实验中认真调试编译好的代码并进行必要的测试，记录和分析实验结果。
实验结束后，认真编写符合标准格式的实验报告(见附件一)，并要求正式的实验报告纸和封面装订整齐，按时提交。
三、设计过程3.1算法原理分析OPT算法是未来最远的，当当前内存中没有页面即将访问时，替换当前页面在未来访问页面中最远的页面或者永远不出现。
先进先出算法是先进先出。
当当前内存中没有要访问的页面时，将替换最高级的页面。
LRU算法是最近最长的未使用页面。
当当前存储器中没有将要被访问的页面时，当前页面中最近且最长时间未被使用的页面被替换。
3.2数据定义int长度、num_page、计数、种子；//长度记录访问字符串的长度，页数，计算[20] [30]，[30]，[10]中丢失的页数；//result记录结果，order存储访问字符串，a存储当前页中的值int pos1、flag1、flag2、flag3//pos1位置变量、标志1等。
标志变量是字符结果1[30]；//记录缺失的页面数组void opt() //best void fifo() //先进先出bool search(int n) //找出当前内存中是否已经存在页面3.3流程图和操作截图，执行的指令是否启动，指令是否首先存储在内存中，指令是否被删除，是否有任何指令结束以获得命中率图6.1 FIFO()函数流程图；开始在内存中输入分发页的数据时，第一个访问页初始化第一列值并请求访问页？内存中是否已经存在前一列的直接副本？内存中有空闲页面吗？直接插入到替换内存中，输出所有将来不会发生或离当前页面最远的页面更改。
一、实验目的1. 理解请求分页的基本原理和实现方法。
2. 掌握操作系统内存管理的基本知识。
3. 提高编程能力和系统设计能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验原理请求分页是一种内存管理策略，其基本思想是当进程访问内存中的某页时，如果该页不在内存中，则从磁盘读取该页到内存，并将内存中的一部分页调出磁盘。
请求分页可以提高内存的利用率，避免内存碎片。
四、实验内容1. 设计请求分页系统2. 实现请求分页算法3. 测试请求分页系统的性能五、实验步骤1. 设计请求分页系统（1）定义数据结构定义进程结构体、内存块结构体、页面表结构体等。
（2）初始化系统初始化内存块、页面表、进程队列等。
（3）请求分页算法实现实现FIFO、LRU、LFU等请求分页算法。
2. 实现请求分页算法（1）FIFO算法FIFO（先进先出）算法是最简单的请求分页算法，当请求分页时，总是选择最先进入内存的页面调出。
（2）LRU算法LRU（最近最少使用）算法选择最近最少被访问的页面调出，可以有效减少缺页中断。
（3）LFU算法LFU（最少使用频率）算法选择使用频率最低的页面调出，适用于页面使用频率不均匀的情况。
3. 测试请求分页系统的性能（1）定义测试用例设计一系列测试用例，包括不同大小的进程、不同类型的页面访问模式等。
（2）运行测试用例运行测试用例，记录缺页中断次数、页面命中率等性能指标。
（3）分析结果分析测试结果，比较不同请求分页算法的性能。
六、实验结果与分析1. 实验结果通过实验，我们得到了以下结果：（1）FIFO算法：缺页中断次数为50，页面命中率为90%。
（2）LRU算法：缺页中断次数为30，页面命中率为95%。
（3）LFU算法：缺页中断次数为35，页面命中率为92%。
2. 分析结果从实验结果可以看出，LRU算法在三种算法中性能最好，其次是LFU算法，FIFO算法性能最差。
实验四请求分页存储管理模拟实验一：实验目的通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求分页存储管理系统的原理和实现技术的理解。
二：实验容假设每个页面可以存放10条指令，分配给进程的存储块数为4。
用C语言或Pascal语言模拟一进程的执行过程。
设该进程共有320条指令，地址空间为32个页面，运行前所有页面均没有调入存。
模拟运行时，如果所访问的指令已经在存，则显示其物理地址，并转下一条指令；如果所访问的指令还未装入存，则发生缺页，此时需要记录缺页产生次数，并将相应页面调入存，如果4个存块已满，则需要进行页面置换。
最后显示其物理地址，并转下一条指令。
在所有指令执行完毕后，显示进程运行过程中的缺页次数和缺页率。
页面置换算法：分别采用OPT、FIFO、LRU三种算法。
进程中的指令访问次序按如下原则生成：50%的指令是顺序执行的。
25%的指令是均匀分布在低地址部分。
25%的指令是均匀分布在高地址部分。
三：实验类别分页存储管理四：实验类型模拟实验五：主要仪器计算机六：结果OPT:LRU:FIFO:七：程序# include<stdio.h># include<stdlib.h># include<conio.h># define blocknum 4//页面尺寸大小int m; //程序计数器，用来记录按次序执行的指令对应的页号static int num[320]; //用来存储320条指令typedef struct BLOCK //声明一种新类型--物理块类型{int pagenum; //页号int accessed; //访问量，其值表示多久未被访问}BLOCK;BLOCK block[blocknum]; //定义一大小为8的物理块数组void init() //程序初始化函数,对block初始化{for(int i=0;i<blocknum;i++){block[i].pagenum=-1;block[i].accessed=0;m=0;}}int pageExist(int curpage)//查找物理块中页面是否存在,寻找该页面curpage是否在存块block中，若在，返回块号{for(int i=0; i<blocknum; i++){if(block[i].pagenum == curpage )return i; //在存块block中，返回块号}return -1;}int findSpace()//查找是否有空闲物理块,寻找空闲块block，返回其块号{for(int i=0;i<blocknum;i++){if(block[i].pagenum==-1)return i; //找到了空闲的block，返回块号}return -1;}int findReplace()//查找应予置换的页面{int pos = 0;for(int i=0;i<blocknum;i++){if(block[i].accessed > block[pos].accessed)pos = i; //找到应该置换页面，返回BLOCK中位置}return pos;void display()//显示物理块中的页面号{for(int i=0; i<blocknum; i++){if(block[i].pagenum != -1){printf(" %02d ",block[i].pagenum);printf("%p |",&block[i].pagenum);}}printf("\n");}void randam()//产生320条随机数,显示并存储到num[320]{int flag=0;printf("请为一进程输入起始执行指令的序号(0~320):\n");scanf("%d",&m);//用户决定的起始执行指令printf("******进程中指令访问次序如下：(由随机数产生)*******\n");for(int i=0;i<320;i++){//进程中的320条指令访问次序的生成num[i]=m;//当前执行的指令数，if(flag%2==0)m=++m%320;//顺序执行下一条指令if(flag==1)m=rand()%(m-1);//通过随机数，跳转到低地址部分[0，m-1]的一条指令处，设其序号为m1if(flag==3)m=m+1+(rand()%(320-(m+1)));//通过随机数，跳转到高地址部分[m1+2，319]的一条指令处，设其序号为m2flag=++flag%4;printf(" %03d",num[i]);//输出格式：3位数if((i+1)%10==0) //控制换行,每个页面可以存放10条指令，共32个页面printf("\n");}}void pagestring() //显示调用的页面序列,求出此进程按次序执行的各指令所在的页面号并显示输出{for(int i=0;i<320;i++){printf(" %02d",num[i]/10);//输出格式：2位数if((i+1)%10==0)//控制换行,每个页面可以存放10条指令，共32个页面printf("\n");}}void OPT() //最佳替换算法{int n=0;//记录缺页次数int exist,space,position;int curpage;//当前指令的页面号for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist=pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space=findSpace();if(space != -1){ //当前存在空闲的物理块block[space].pagenum = curpage; //将此页面调入存display();//显示物理块中的页面号n++;//缺页次数+1}else{ //当前不存在空闲的物理块，需要进行页面置换for(int k=0;k<blocknum;k++){for(int j=i;j<320;j++){//找到在最长（未来）时间不再被访问的页面if(block[k].pagenum!= num[j]/10){block[k].accessed = 1000;} //将来不会被访问，设置为一个很大数else{ //将来会被访问，访问量设为jblock[k].accessed = j;break;}}}position = findReplace();//找到被置换的页面 ,淘汰block[position].pagenum = curpage;// 将新页面调入display();n++; //缺页次数+1}}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void LRU() //最近最久未使用算法{int n=0;//记录缺页次数int exist,space,position ;int curpage;//当前指令的页面号for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist = pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space = findSpace();if(space != -1){ //当前存在空闲的物理块block[space].pagenum = curpage; //将此页面调入存display();//显示物理块中的页面号n++;//缺页次数+1}else{ //当前不存在空闲的物理块，需要进行页面置换position = findReplace();block[position].pagenum = curpage;display();n++; //缺页次数+1}}elseblock[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1for(int j=0; j<blocknum; j++){//其余的accessed++block[j].accessed++;}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void FIFO(){int n=0;//记录缺页次数int exist,space,position ;int curpage;//当前指令的页面号int blockpointer=-1;for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist = pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space = findSpace();if(space != -1){ //当前存在空闲的物理块blockpointer++;block[space].pagenum=curpage; //将此页面调入存n++;//缺页次数+1display();//显示物理块中的页面号}else{ // 没有空闲物理块，进行置换position = (++blockpointer)%4;block[position].pagenum = curpage; //将此页面调入存n++;display();}}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void main(){int choice;printf("************请求分页存储管理模拟系统*************\n");randam();printf("************此进程的页面调用序列如下**************\n");pagestring();while(choice != 4){printf("********1:OPT 2:LRU 3:FIFO 4:退出*********\n");printf("请选择一种页面置换算法:");scanf("%d",&choice);init();switch(choice){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;}}}。
实验四请求分页存储管理模拟实验一：实验目得通过对页面、页表、地址转换与页面置换过程得模拟,加深对请求分页存储管理系统得原理与实现技术得理解.二：实验内容假设每个页面可以存放１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;ﻩ｝}}。
2015-2016学年第二学期操作系统课程实验设计报告班级网络2班学号 201414620207姓名韩金铖成绩指导教师于复兴1、实验题目：（1）模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程。
（2）采用先进先出（或LRU）算法实现分页管理的缺页调度。
2、实验目的：（1）通过实验模拟请求分页存储管理中的硬件地址转换和产生却页中断帮助理解在分页式存储管理中怎样虚拟存储器。
（2）通过采用先进先出（或LRU）算法实现分页管理的缺页调度帮助理解和掌握模拟分页式虚拟存储管理的缺页中断，帮助自己对请求分页管理的概念有一个清楚的理解。
3、程序设计及实现过程：（1）请求分页储存管理是把作业的全部信息存在磁盘上，当作业被选中时，可把作业的开始几页先装入主存并启动运行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表格式为：其中，标志表示对应页是否已经装入主存，“标志 = 0”表示该页尚未装入主存，“标志= 1”表示该页已在主存。
主存块号表示已装入主存的页所占用的块号。
外存地址表示该页在外存的地址。
（2）作业执行完时，指令中的逻辑地址指出了参加运算的操作数存放的页号和单元号，硬件地址转换机构按页号查页表，若该页对应的标志为“1”，则表示该页已在主存。
根据关系式：绝对地址=块号*块长+单元号。
计算出欲访问的主存单元地址，将块长设成2的整次幂，可把块号作为地址寄存器的高位部分，单元号作为低位部分。
两个拼接形成绝对地址。
按计算出的绝对地址取操作数，完成一条指令的执行。
若访问的页对应标志为“0”，则表示不在主存，这时硬件发缺页中断信号，由操作系统按页表中的该页对应的外存地址把该页装入主存后，执行该指令。
（3）设计一个“地址变换”程序来模拟硬件的地址转换工作。
当访问的页不在主存时，则形成绝对地址后不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行，当访问的页不在主存时，则输出“*”，表示产生了一次缺页中断。
分页管理实验报告课程名称：操作系统姓名： ******专业班级： ***********学号： **************** 指导老师： *****一、实验目的连续分配方式会形成许多“碎片”，虽然可通过“紧凑“方法将许多碎片拼接成可用的大块空间，但为之需付出很大开销。
为了将一个进程直接分散地装入到许多的不相邻的分区中，我们引入离散分配方式。
这里，离散分配的基本单位是页，成为分页存储管理方式。
本次试验，通过实际操作，加深同学们对分页存储管理方式的认识和印象，掌握分页存储方式的基本使用方法和应注意的事项。
二、实验要求（1）根据基本分页存储管理方式的原理，模拟基本分页存储管理进行内存分配，实验过程中可建立A[i][j]来存储系统内存分区块数，如A[10][10]，表示内存块100个，十行十列；建立一个数组B[m][n]，存储进程和该进程所分配的内存块。
（2）调度分页存储管理方式算法，为各进程分配内存块，输入进程名称和进程所需页数，对进程进行内存块分配。
（3）为进程进行内存分配前，检查内存块数与进程所需页数，内存块不足，不进行分配，做出错误判断。
（4）对内存块进行初始化分配，对于已分配给进程的内存块，可以回收，并且可以查看内存分配情况。
三、实验内容模拟基本分页存储方式对内存进行分配。
建立系统内存块：A[100]：一百个内存块建立进程实体：typedef struct LNode{char name; //进程名int n; //进程页数int ye[100]; //进程各页所在物理块struct LNode *next;}LNode,*LinkList四、实验结果运行菜单界面：初始化内存情况：15个已分配，可分配内存块85添加下列进程：1添加进程A：2添加进程B：3添加进程C：可分配内存块为85，A和B已分配60，剩余25，无法为C分配内存块。
4.添加进程d（20）：5.回收进程B：6.查看内存使用情况：7.回收A和d：8.内存分配情况：回收所有已分配给进程的内存块，内存恢复初始化状态。
实验六：请求分页存储管理一．实验目的深入理解请求页式存储管理的基本概念和实现方法，重点认识其中的地址变换、缺页中断、置换算法等实现思想。
二．实验属性该实验为综合性、设计性实验。
三．实验仪器设备及器材普通PC386以上微机四．实验要求本实验要求2学时完成。
本实验要求完成如下任务：（1）建立相关的数据结构：页表、页表寄存器、存储块表等；（2）指定分配给进程的内存物理块数，设定进程的页面访问顺序；（3）设计页面置换算法，可以选择OPT、FIFO、LRU等，并计算相应的缺页率，以比较它们的优劣；（4）编写地址转换函数，实现通过查找页表完成逻辑地址到物理地址的转换；若发生缺页则选择某种置换算法（OPT、FIFO、LRU等）完成页面的交换；（5）将整个过程可视化显示出来。
实验前应复习实验中所涉及的理论知识和算法，针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A），并要求用正规的实验报告纸和封面装订整齐，按时上交。
三、设计过程3.1算法原理分析OPT算法是未来最远出现，当当前内存中没有正要访问的页面时，置换出当前页面中在未来的访问页中最远出现的页面或再也不出现的页面。
FIFO算法是先进先出，当当前内存中没有正要访问的页面时，置换出最先进来的页面。
LRU算法是最近最久未使用，当当前内存中没有正要访问的页面时，置换出在当前页面中最近最久没有使用的页面。
3.2数据定义int length,num_page,count,seed; //length记录访问串的长度，num_page页面数，count记录缺页次数int result[20][30],order[30],a[10]; //result记录结果,order存储访问串,a存储当前页面中的值int pos1,flag1,flag2,flag3; //pos1位置变量，flag1等为标志变量 char result1[30]; //记录缺页数组 void opt() //最佳void fifo() //先进先出bool search(int n) //查找当前内存中是否已存在该页3.3流程图与运行截图图6.1 FIFO （）函数流程图;否是 是否 开始得到执行的指令指令是否在内存中最先存入指令被淘汰下面是否还有指令 结束得出命中率图2.2 OPT算法流程图四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
页式存储管理一、实验目的：掌握分页式存储管理的基本概念和实现方法。
要求编写一个模拟的分页式管理程序，并能对分页式存储的页面置换算法进行编写和计算各个算法的缺页率。
二、程序设计：首先创建页面链指针数据结构，并设计页面映像表，采用数组的方法给定页面映像。
申请缓冲区，将一个进程的逻辑地址空间划分成若干个大小相等的部分，每一部分称做页面或页。
每页都有一个编号，叫做页号，页号从0开始依次编排，如0，1，2……。
设置等大小的内存块。
初始状态：将数据文件的第一个页面装入到该缓冲区的第0块。
设计页面置换算法，这里分别采用最佳页面置换算法OPT和最近最久未使用置换算法LRU,并分别计算它们的缺页率，以比较它们的优劣。
三、算法说明：执行程序时，当主存没有可用页面时，为了选择淘汰主存中的哪一页面，腾出1个空闲块以便存放新调入的页面。
淘汰哪个页面的首要问题是选择何种置换算法。
该程序采用人工的方法选择，依置换策略选择一个可置换的页，并计算它们的缺页率以便比较。
/*分页式管理实验-源程序*/#include"stdio.h"#define N 16#define num 5 /*进程分配物理块数目*/int A[N]={1,2,3,4,5,6,7,8,5,2,3,2,7,8,1,4}; /*页表映像*/typedef struct page{ int address; /*页面地址*/struct page *next;}page;struct page *head,*run,*rear;void jccreat() /*进程分配物理块*/{ int i=1;page *p,*q;head=(page *)malloc(sizeof(page)); p=head;for(i=1;i<=num;i++) { q=(page *)malloc(sizeof(page));p->next=q; q->address=0; q->next=NULL; p=q; }rear=p;}int search(int n){page *p;int i=0;p=head;while(p->next){if(p->next->address==n){printf("Get it at the page %d\n",i+1);run=p;return 1;}p=p->next;i++;}return 0;}void changeOPT(int n,int position){int i;int total=0;int flag=1;int distance[num];int MAX;int order=0;page *p,*q;p=head->next;q=head->next;for(i=0;i<num;i++)distance[i]=100;i=0;while(p){if(p->address==0){flag=0;break;}p=p->next;i++;}if(!flag){p->address=n;printf("Change the page %d\n",i+1);}else{while(q){for(i=position;i<N;i++){if(q->address==A[i])distance[total]=i-position;}total++;q=q->next;}MAX=distance[0];for(i=0;i<num;i++){if(distance[i]>MAX){MAX=distance[i];order=i;}}printf("Change the page %d\n",order+1);i=0;while(p){if(i==order)p->address=n;i++;p=p->next;}}}void changeLRU(int n){int i=0;int flag=1;page *p,*delect;p=head->next;while(p){if(p->address==0){flag=0;p->address=n;printf("Change the page %d\n",i+1);break;}p=p->next;i++;}if(flag){delect=head->next;head->next=delect->next;printf("Delect from the head, and add new to the end.\n");delect->address=n;rear->next=delect;rear=delect;rear->next=NULL;}}float OPT(){int i;int lose=0;float losef;float percent;for(i=0;i<N;i++){if(search(A[i])==0){lose++;changeOPT(A[i],i);}}losef=lose;percent=1-(losef/N);return percent;}float LRU(){int i;int lose=0;float losef;float percent;page *p;for(i=0;i<N;i++){if(search(A[i])==0){lose++;changeLRU(A[i]);}else{p=run->next;run->next=p->next;rear->next=p;rear=p;rear->next=NULL;printf("Move it to end of queue.\n");}}losef=lose;percent=1-(losef/N);return percent;}main() /*主函数部分*/{float percent;int choice;printf("Select the arithmetic:\n(1)OPT\n(2)LRU\nyour choice is:"); scanf("%d",&choice);/*选择页面置换算法*/jccreat(); /*创建进程*/if(choice==1) /*采用OPT算法置换*/{percent=OPT(); /*计算OPT时的缺页率*/ printf("The percent of OPT is %f",percent);}else if(choice==2) /*采用LRU算法置换*/ {percent=LRU(); /*计算LRU时的缺页率*/ printf("The percent of OPT is %f",percent);}else printf("Your choice is invalid.");getch();}四．运行结果:最佳（Optimal）置换算法：最近最久未使用(LRU)置换算法：五、心得体会掌握分页式存储管理的基本概念和实现方法。
分页存储实验报告分页存储实验报告一、引言分页存储是计算机系统中一种常见的内存管理技术。
它将主存分成固定大小的页框，并将进程的地址空间划分为相同大小的页面。
本实验旨在通过设计和实现一个简单的分页存储系统，深入理解分页存储的原理和实现方式。
二、实验目标1. 设计并实现一个简单的分页存储系统；2. 理解分页存储的工作原理；3. 掌握分页存储的实现方法。
三、实验内容1. 设计页表结构页表是分页存储系统中的关键数据结构，用于记录页框与页面之间的映射关系。
在本实验中，我们可以使用一个简单的二维数组来表示页表。
其中，每一行表示一个页框，每一列表示一个页面，数组元素的值表示页面所在的页框号。
2. 实现地址转换地址转换是分页存储系统中的核心操作，它将逻辑地址转换为物理地址。
在本实验中，我们可以通过将逻辑地址的高位作为页号，低位作为页内偏移量，根据页表中的映射关系计算出物理地址。
3. 模拟页面置换算法页面置换算法是分页存储系统中解决内存不足问题的关键。
在本实验中，我们可以选择一种简单的页面置换算法，如FIFO（先进先出）算法或LRU（最近最少使用）算法，并在实验中模拟其运行过程。
四、实验步骤1. 设计页表结构根据实验要求，设计一个合适的页表结构，并初始化页表。
2. 实现地址转换根据页表的映射关系，实现逻辑地址到物理地址的转换函数。
3. 编写测试程序编写一个简单的测试程序，生成一系列逻辑地址，并通过地址转换函数将其转换为物理地址。
4. 模拟页面置换算法选择一种页面置换算法，并在测试程序中模拟其运行过程。
记录每次页面置换的情况，包括被置换出的页面和被置换入的页面。
五、实验结果与分析通过实验，我们可以得到一系列的物理地址，并根据页面置换算法的运行情况进行分析。
可以观察到不同页面置换算法对系统性能的影响，如命中率、缺页率等指标的变化。
六、实验总结通过本次实验，我们深入理解了分页存储的原理和实现方式。
通过设计和实现一个简单的分页存储系统，我们掌握了页表的结构和地址转换的方法，并熟悉了页面置换算法的运行过程。
2015-2016学年第二学期操作系统课程实验设计报告班级网络2班学号201414620207姓名金铖成绩指导教师于复兴1、实验题目：（1）模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程。
（2）采用先进先出（或LRU）算法实现分页管理的缺页调度。
2、实验目的：（1）通过实验模拟请求分页存储管理中的硬件地址转换和产生却页中断帮助理解在分页式存储管理中怎样虚拟存储器。
（2）通过采用先进先出（或LRU）算法实现分页管理的缺页调度帮助理解和掌握模拟分页式虚拟存储管理的缺页中断，帮助自己对请求分页管理的概念有一个清楚的理解。
3、程序设计及实现过程：（1）请求分页储存管理是把作业的全部信息存在磁盘上，当作业被选中时，可把作业的开始几页先装入主存并启动运行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表格式为：其中，标志表示对应页是否已经装入主存，“标志= 0”表示该页尚未装入主存，“标志= 1”表示该页已在主存。
主存块号表示已装入主存的页所占用的块号。
外存地址表示该页在外存的地址。
（2）作业执行完时，指令中的逻辑地址指出了参加运算的操作数存放的页号和单元号，硬件地址转换机构按页号查页表，若该页对应的标志为“1”，则表示该页已在主存。
根据关系式：绝对地址=块号*块长+单元号。
计算出欲访问的主存单元地址，将块长设成2的整次幂，可把块号作为地址寄存器的高位部分，单元号作为低位部分。
两个拼接形成绝对地址。
按计算出的绝对地址取操作数，完成一条指令的执行。
若访问的页对应标志为“0”，则表示不在主存，这时硬件发缺页中断信号，由操作系统按页表中的该页对应的外存地址把该页装入主存后，执行该指令。
（3）设计一个“地址变换”程序来模拟硬件的地址转换工作。
当访问的页不在主存时，则形成绝对地址后不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行，当访问的页不在主存时，则输出“*”，表示产生了一次缺页中断。
该算法框图如下：地址变换算法：假定主存的每块长度为126个字节；现有一个共7页的作业，其中第0页至第3页已装入，其余三页尚未装入主存，该作业的页表为：页号标志主存块号外存地址0 1 5 0111 1 8 0122 1 9 0133 1 14 05 06 0 121运行设计的地址变换机构程序，显示或打印运行结果。
因仅模拟地址变换，并不模拟指令的实际执行。
（4）在分页式虚拟存贮系统中，当硬件发出缺页中断后，转操作系统处理缺页中断。
如果主存中已无空闲块，当采用先进先出算法时，则淘汰最先进入主存的一页，若该页修改过，还要存入磁盘，然后在把当前要访问的页装入该块，并修改页表中的对应标志。
当采用LRU算法时，则淘汰最近没有访问的页。
大概流程图如下：（5）有了具体的核心算法实现法之后，就可以开发简单的界面，并且把以上综合到程序中，最后调试BUG，完成实验。
4、实验结果及分析：（1）对于题目一我制作了一个帮助界面（如图1），可以便于我记起实验的容以及理解相应知识，有了已知容，我输入逻辑地址（例如320），则程序输出为（如图2）。
图1 “题目一帮助界面”图2 “题目一运行界面”（2）对于题目二我同样制作了一个帮助界面（如图3），可以便于我操作程序不出现格式错误，如果出错程序会弹出窗口报错（如图4）。
当物理块数为3，页面使用列表为23 3 2 23 12 3 23 3时，则采用先进先出算法时table表应如下：23 3 2 2 12 12 23 323 3 3 2 2 12 2323 23 3 3 2 12* * * * * * （‘*‘代表缺页中断）采用LRU算法时table表应如下：23 3 2 23 12 3 23 323 3 2 23 12 3 2323 3 2 23 12 12* * * * * （‘*‘代表缺页中断）则程序输出为（如图5、6）。
图3 “题目二帮助界面”图4 “题目二错误窗口”图5 “题目二FIFO算法”图6 “题目二LRU算法”5、实验收获和体会：通过本次实验，使我对于虚拟存储管理的相关容有了更深的认识，同时提升了我的编程水平和思考问题的能力，对于以后学习或者工作上的困难克服有很大的积极作用。
通过程序设计的训练，我进一步学习和掌握了对程序的设计和编写，从中体会到了面向对象程序设计的便和巧妙。
懂得了在进行编写一个程序之前，要有明确的目标和整体的设计思想。
另外某些具体的细节容也是相当的重要。
这些宝贵的编程思想和从中摸索到的经验都是在编程的过程中获得的宝贵财富。
这些经验对我以后的编程会有很大的帮助的，我要好好利用。
我很珍惜这次实验的机会，冰冻三尺非一日之寒，我相信以后会更加细心、更加勤奋。
6、源程序：1、下面是MenuFrame.Javapackage .hjc;import static .hjc.Constant.*;import java.awt.Button;import java.awt.Color;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.Toolkit;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;// 菜单界面public class MenuFrame extends Frame implements ActionListener {/****/private static final long serialVersionUID = 1L;private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image text = Toolkit.getDefaultToolkit().getImage("image//text.png"); // 文字private Button workOne = new Button("进入题目一"); // Button1private Button workTwo = new Button("进入题目二"); // Button2public MenuFrame(String title) {this.setTitle(title); // 设置题目this.setLayout(null); // 设置布局this.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置图标this.setBackground(Color.YELLOW); // 设置背景workOne.setBounds((EXE_WIDTH - 200) / 2, (EXE_HEIGHT - 40) / 2, 200, 40);workOne.addActionListener(this);this.add(workOne); // 添加Button1workTwo.setBounds((EXE_WIDTH - 200) / 2, (EXE_HEIGHT - 40) / 2 + 80, 200, 40);workTwo.addActionListener(this);this.add(workTwo); // 添加Button2this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {super.windowClosing(e);System.exit(0);}}); // 添加窗口监听this.setResizable(false); // 设置不可改变大小this.setVisible(true); // 设置可视}// 绘制的法public void paint(Graphics g) {Color c = g.getColor(); // 得到初始g颜色g.setColor(Color.BLUE); // 设置画笔为蓝色g.drawImage(text, (EXE_WIDTH - 400) / 2, 40, 400, 150, this); // 绘制text图片g.drawString("(实验四)", 400, 160); // 绘制文字g.drawString("题目一：模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程", 50, 400); // 绘制文字g.drawString("题目二：采用先进先出（或LRU）算法，实现分页管理的缺页调度", 50, 430); // 绘制文字g.setColor(Color.RED); // 设置画笔为红色g.drawRect(45, 380, 400, 70); // 绘制矩形g.setColor(Color.CYAN);g.drawString("制作:乐事@Happy", 380, 480);g.setColor(c); // 恢复画笔初始颜色}public static void main(String[] args) {new MenuFrame("欢迎");}// 动作监听public void actionPerformed(ActionEvent e) {if (e.getSource() == workOne) {this.setVisible(false);new workOneFrame(this);} else if (e.getSource() == workTwo) {this.setVisible(false);new workTwoFrame(this);}}}2、下面是Constant.Javapackage .hjc;import java.awt.Toolkit;public class Constant {public static int EXE_WIDTH = 500; // 应用宽度public static int EXE_HEIGHT = 500; // 应用高度public static int PM_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width; // 得到屏幕宽度public static int PM_HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().height; // 得到屏幕高度public static int MAX = 100;}3、下面是Page.Javapackage .hjc;public class Page {int pno;// 页号int flag;// 标志位int cno;// 主存号int addr;// 外存地址public Page(int pno, int flag, int addr) {this.pno = pno;this.flag = flag;this.addr = addr;}public Page(int pno, int flag, int cno, int addr) {this.pno = pno;this.flag = flag;o = cno;this.addr = addr;}}4、下面是helpOneFrame.Javapackage .hjc;import static .hjc.Constant.EXE_HEIGHT;import static .hjc.Constant.EXE_WIDTH;import static .hjc.Constant.PM_HEIGHT;import static .hjc.Constant.PM_WIDTH;import java.awt.Color;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.Toolkit;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;public class helpOneFrame extends Frame {/****/private static final long serialVersionUID = 1L;private workOneFrame wof;private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image back = Toolkit.getDefaultToolkit().getImage("image//helponeback.png"); // 背景public helpOneFrame(workOneFrame wof) {this.wof = wof;this.setTitle("帮助");this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置应用图标this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);wof.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}public void paint(Graphics g) {Color c = g.getColor();g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.setColor(c);}}5、下面是helpTwoFrame.Javapackage .hjc;import static .hjc.Constant.EXE_HEIGHT;import static .hjc.Constant.EXE_WIDTH;import static .hjc.Constant.PM_HEIGHT;import static .hjc.Constant.PM_WIDTH;import java.awt.Color;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.Toolkit;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;public class helpTwoFrame extends Frame {/****/private static final long serialVersionUID = 1L;private workTwoFrame wtf;private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image back = Toolkit.getDefaultToolkit().getImage("image//helptwoback.png"); // 背景public helpTwoFrame(workTwoFrame wtf) {this.wtf = wtf;this.setTitle("帮助");this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); //应用的位置this.setIconImage(icon); // 设置应用图标this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);wtf.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}public void paint(Graphics g) {Color c = g.getColor();g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.setColor(c);}}6、下面是workOneFrame.Javapackage .hjc;import static .hjc.Constant.EXE_HEIGHT;import static .hjc.Constant.EXE_WIDTH;import static .hjc.Constant.PM_HEIGHT;import static .hjc.Constant.PM_WIDTH;import java.awt.Button;import java.awt.Color;import java.awt.Font;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.TextArea;import java.awt.TextField;import java.awt.Toolkit;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import javax.swing.JOptionPane;public class workOneFrame extends Frame implements ActionListener {/****/private static final long serialVersionUID = 1L;private MenuFrame mf; // 大管家private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image back = Toolkit.getDefaultToolkit().getImage("image//back.png"); // 背景private Button start = new Button("Run...");private Button btHelp = new Button("帮助");private TextField tf_Logical_Address = new TextField();private TextArea ta_Output = new TextArea();private static int Each_Length = 126; // 主存的每块长度private static int Max_Numbers = 7; // 作业页数public workOneFrame(MenuFrame mf) {this.mf = mf;this.setTitle("地址转换和产生却页中断的过程");this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置应用图标tf_Logical_Address.setBounds(200, 110, 100, 30);tf_Logical_Address.setFont(new Font("Courier", Font.PLAIN, 25));tf_Logical_Address.addKeyListener(new KeyAdapter() { // 只允输入数字public void keyTyped(KeyEvent e) {int keyChar = e.getKeyChar();if (keyChar >= KeyEvent.VK_0&& keyChar <= KeyEvent.VK_9) {} else {e.consume(); // 关键，屏蔽掉非法输入}}});this.add(tf_Logical_Address);start.setBounds(320, 160, 100, 30);start.addActionListener(this);this.add(start);btHelp.setBounds(320, 200, 100, 30);btHelp.addActionListener(this);this.add(btHelp);ta_Output.setBounds((EXE_WIDTH - 450) / 2, 250, 450, 200);ta_Output.setFont(new Font("Courier", Font.PLAIN, 15));ta_Output.setEditable(false);this.add(ta_Output);this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);mf.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}public void paint(Graphics g) {Color c = g.getColor();g.setColor(Color.BLACK);g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.drawString("指令的逻辑地址：", 100, 130);g.setColor(c);}public void changeaddr(Page p[], int logaddr) {// 地址变换int j = logaddr / Each_Length; // 对应的块号int k = logaddr % Each_Length; // 对应的偏移量int flag = 0; // 页面标志int addr; // 物理地址for (int i = 0; i < Max_Numbers; i++) {// 找到对应的页号if (p[i].pno == j) {// 页面标志为1if (p[i].flag == 1) {addr = p[i].cno * Each_Length + k;ta_Output.setText(ta_Output.getText() + "物理地址为: " + addr+ "\n");ta_Output.setText(ta_Output.getText() + "详细信息: \t页面号："+ p[i].pno + "\t主存号:" + p[i].cno + "\t偏移量：" + k+ "\n");flag = 1;break;}}}if (flag == 0) {ta_Output.setText(ta_Output.getText() + "该页不在主存,产生缺页中断\n");}ta_Output.setText(ta_Output.getText() + "\n\n");}public void Run() {int ins;// 指令逻辑地址Page[] p = new Page[8];p[0] = new Page(0, 1, 5, 011);p[1] = new Page(1, 1, 8, 012);p[2] = new Page(2, 1, 9, 013);p[3] = new Page(3, 1, 1, );p[4] = new Page(4, 0, );p[5] = new Page(5, 0, );p[6] = new Page(6, 0, 121);ins = Integer.parseInt(tf_Logical_Address.getText());ta_Output.setText(ta_Output.getText() + "您输入指令的逻辑地址：" + ins +"\n\n");changeaddr(p, ins);}public void actionPerformed(ActionEvent e) {if (e.getSource() == start) {try {ta_Output.setText(" ");ta_Output.setText("");Run();} catch (Exception ee) {JOptionPane.showMessageDialog(null, "对不起，输入错误，请检查输入格式！", "错误",JOptionPane.ERROR_MESSAGE);}}if (e.getSource() == btHelp) {this.setVisible(false);new helpOneFrame(this);}}}7、下面是workTwoFrame.Javapackage .hjc;import static .hjc.Constant.*;import java.awt.Button;import java.awt.Color;import java.awt.Font;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.TextArea;import java.awt.TextField;import java.awt.Toolkit;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import javax.swing.JOptionPane;public class workTwoFrame extends Frame implements ActionListener {/****/private static final long serialVersionUID = 1L;private TextField ta_Serial_Numbers = new TextField();private TextField ta_Physical_Block_Numbers = new TextField();private TextArea taOutput = new TextArea();private Button btFIFO = new Button("先进先出");private Button btLRU = new Button("近期最少");private Button btClear = new Button("清空");private Button btHelp = new Button("帮助");private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image line = Toolkit.getDefaultToolkit().getImage("image//line.png"); // 线private Image back = Toolkit.getDefaultToolkit().getImage("image//back.png"); // 背景public MenuFrame mf; // MenuFrame引用private int Physical_Block_Numbers;private int[] Serial;private int Max_Digits;private int Pages_Missing_Numbers;public workTwoFrame(MenuFrame mf) {this.mf = mf;this.setTitle("分页管理的缺页调度"); // 设置标题this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置应用图标btClear.setBounds(400, 50, 80, 30);btClear.addActionListener(this);this.add(btClear);// 物理块数输入框ta_Physical_Block_Numbers.setBounds(100, 50, 200, 30);ta_Physical_Block_Numbers.setFont(new Font("Courier", Font.PLAIN, 25));ta_Physical_Block_Numbers.addKeyListener(new KeyAdapter() { // 只允输入数字public void keyTyped(KeyEvent e) {int keyChar = e.getKeyChar();if (keyChar >= KeyEvent.VK_0&& keyChar <= KeyEvent.VK_9) {} else {e.consume(); // 关键，屏蔽掉非法输入}}});this.add(ta_Physical_Block_Numbers);// 页面号引用串输入框ta_Serial_Numbers.setBounds(100, 110, 380, 30);ta_Serial_Numbers.setFont(new Font("Courier", Font.PLAIN, 25));ta_Serial_Numbers.addKeyListener(new KeyAdapter() { // 只允输入数字和空格public void keyTyped(KeyEvent e) {int keyChar = e.getKeyChar();if ((keyChar >= KeyEvent.VK_0 && keyChar <= KeyEvent.VK_9)|| keyChar == KeyEvent.VK_SPACE) {} else {e.consume(); // 关键，屏蔽掉非法输入}}});this.add(ta_Serial_Numbers);taOutput.setBounds(30, 200, 300, 280);taOutput.setFont(new Font("Courier", Font.PLAIN, 15));taOutput.setEditable(false);this.add(taOutput);btFIFO.setBounds(365, 230, 100, 30);btFIFO.addActionListener(this);this.add(btFIFO);btLRU.setBounds(365, 310, 100, 30);btLRU.addActionListener(this);this.add(btLRU);btHelp.setBounds(365, 390, 100, 30);btHelp.addActionListener(this);this.add(btHelp);this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);mf.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}// 绘制法public void paint(Graphics g) {Color c = g.getColor(); // 先得到背景色g.setColor(Color.black); // 设置画笔颜色为黑色g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.drawImage(line, 0, 160, 500, 10, this);g.drawString("物理块数:", 30, 70);g.drawString("页面使用列表:", 20, 130);g.drawString("输出：", 30, 190);g.setColor(c); // 恢复为背景色}public void actionPerformed(ActionEvent e) {if (e.getSource() == btFIFO) { // 先进先出按钮try {Physical_Block_Numbers = Integer.parseInt(ta_Physical_Block_Numbers.getText()); // 为物理块数赋值String[] s = ta_Serial_Numbers.getText().replaceAll(" +", " ").split(" ");Serial = new int[s.length];Max_Digits = 0;for (int i = 0; i < s.length; i++) {Serial[i] = Integer.parseInt(s[i]); // 为串号列表数组赋值if (String.valueOf(Serial[i]).length() > Max_Digits) {Max_Digits = String.valueOf(Serial[i]).length();}}taOutput.setText("");Pages_Missing_Numbers = 0;FIFO(); // 先进先出算法} catch (Exception exception) {JOptionPane.showMessageDialog(null, "对不起，输入错误，请检查输入格式！", "错误",JOptionPane.ERROR_MESSAGE);}}if (e.getSource() == btLRU) { // 先进先出按钮try {Physical_Block_Numbers = Integer.parseInt(ta_Physical_Block_Numbers.getText()); // 为物理块数赋值String[] s = ta_Serial_Numbers.getText().replaceAll(" +", " ").split(" ");Serial = new int[s.length];Max_Digits = 0;for (int i = 0; i < s.length; i++) {Serial[i] = Integer.parseInt(s[i]); // 为串号列表数组赋值if (String.valueOf(Serial[i]).length() > Max_Digits) {Max_Digits = String.valueOf(Serial[i]).length();}}taOutput.setText("");Pages_Missing_Numbers = 0;LRU(); // 先进先出算法} catch (Exception exception) {JOptionPane.showMessageDialog(null, "对不起，输入错误，请检查输入格式！", "错误",JOptionPane.ERROR_MESSAGE);}}if (e.getSource() == btClear) {ta_Physical_Block_Numbers.setText(" ");ta_Physical_Block_Numbers.setText("");ta_Serial_Numbers.setText(" ");ta_Serial_Numbers.setText("");taOutput.setText(" ");taOutput.setText("");}if (e.getSource() == btHelp) {this.setVisible(false);new helpTwoFrame(this);}}// FIFO算法public void FIFO() {char flag;int Serial_Length = Serial.length;int[] mem = new int[Physical_Block_Numbers + 2];char[] f = new char[Serial_Length];int[][] table = new int[Physical_Block_Numbers][Serial_Length];taOutput.setText(taOutput.getText() + "*FIFO算法*\n\n");taOutput.setText(taOutput.getText() + "输出结果为下表*代表有缺页\n\n");for (int i = 0; i < mem.length; i++) {mem[i] = -1;}for (int i = 0; i < Serial_Length; i++) {int q = 0;while ((Serial[i] != mem[q]) && (q != Physical_Block_Numbers)) { q++;}if (q == Physical_Block_Numbers) {flag = '*'; // 缺页则置标志flag为'*'Pages_Missing_Numbers++;} else {flag = ' ';}if (flag == '*') {for (int j = Physical_Block_Numbers - 1; j > 0; j--) {// 淘汰最先调入的页面调入当前访问的mem[j] = mem[j - 1];}mem[0] = Serial[i];}for (int j = 0; j < Physical_Block_Numbers; j++) {table[j][i] = mem[j];}f[i] = flag;}for (int i = 0; i < Physical_Block_Numbers; i++) {for (int j = 0; j < Serial_Length; j++) {String s = "";int temp = Max_Digits - String.valueOf(table[i][j]).length();if (table[i][j] == -1) {for (int k = 0; k < Max_Digits; k++) {s += " ";}taOutput.setText(taOutput.getText() + s + " ");} else {for (int k = 0; k < temp; k++) {s += " ";}taOutput.setText(taOutput.getText() + table[i][j] + s+ " ");}}taOutput.setText(taOutput.getText() + "\n");}for (int i = 0; i < Serial_Length; i++) {taOutput.setText(taOutput.getText() + f[i] + " ");for (int j = 0; j < Max_Digits; j++) {taOutput.setText(taOutput.getText() + " ");}}taOutput.setText(taOutput.getText() + "\n\n缺页次数："+ Pages_Missing_Numbers);}// LRU算法public void LRU() {char flag;int Serial_Length = Serial.length;int[] mem = new int[Physical_Block_Numbers + 2];char[] f = new char[Serial_Length];int[][] table = new int[Physical_Block_Numbers][Serial_Length];taOutput.setText(taOutput.getText() + "*LRU算法*\n\n");taOutput.setText(taOutput.getText() + "输出结果为下表*代表有缺页\n\n");for (int i = 0; i < mem.length; i++) {mem[i] = -1;}for (int i = 0; i < Serial_Length; i++) {int q = 0;while ((Serial[i] != mem[q]) && (q != Physical_Block_Numbers)) { q++;}if (q == Physical_Block_Numbers) {flag = '*'; // 缺页则置标志flag为'*'Pages_Missing_Numbers++;} else {flag = ' ';}for (int j = q; j > 0; j--) {mem[j] = mem[j - 1];}mem[0] = Serial[i];for (int j = 0; j < Physical_Block_Numbers; j++) {table[j][i] = mem[j];}f[i] = flag;}for (int i = 0; i < Physical_Block_Numbers; i++) {for (int j = 0; j < Serial_Length; j++) {String s = "";int temp = Max_Digits - String.valueOf(table[i][j]).length();if (table[i][j] == -1) {for (int k = 0; k < Max_Digits; k++) {s += " ";}taOutput.setText(taOutput.getText() + s + " ");} else {for (int k = 0; k < temp; k++) {s += " ";}taOutput.setText(taOutput.getText() + table[i][j] + s+ " ");}}taOutput.setText(taOutput.getText() + "\n");}for (int i = 0; i < Serial_Length; i++) {taOutput.setText(taOutput.getText() + f[i] + " ");for (int j = 0; j < Max_Digits; j++) {taOutput.setText(taOutput.getText() + " ");}}taOutput.setText(taOutput.getText() + "\n\n缺页次数："+ Pages_Missing_Numbers);}}。
