请求分页式存储管理的地址转换过程实现
第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 1
3、输入当前执行进程所要访问的逻辑地址，并将其转换成相应的物理地址。
4、进程退出时，根据其页表内容向位示图反向回填“1”。
5、扩充页表，将其变成支持请求和置换功能的二维页表（增加存在位等）。
创建进程时可装入固定的前三页（或键盘输入初始装入页数，不同进程
的装入个数可以不同），其余页装入到置换空间内（置换空间大小应为内
存空间大小的1.5倍，对其还需建立独立的位示图）。
6、分别采用FIFO和LRU置换算法对地址转换过程中遇到的缺页现象进行页
面置换，可将多次地址转换过程中所涉及到的页号视为进程的页面访问
序列，从而计算置换次数和缺页率。
import java.util.Vector;
import java.io.*;
class Process{
Page []PageTable;
Vector
private int size;
private int Pagecount;
private String name;
double visit;
double replacement;
public void setPage(Page []PageTable) {
this.PageTable=new Page[PageTable.length];
for(int i=0;i this.PageTable[i]=PageTable[i]; } } public int getPageBlock(int PageNum) { return PageTable[PageNum].getBlockNum(); } public void setSize(int size) { this.size=size; } public void setPagecount(int Pagecount) { this.Pagecount=Pagecount; } public int getPagecount() { return Pagecount; } { visit=0; replacement=0; } public Process() { } public Process(String name){ https://www.wendangku.net/doc/df3091095.html,=name; } public String toString(){ return name; } } class Page { int flag; int blockNum; int writed;//xiu gai wei int accessfield;//fang wen zi duan int swapsapce_blockno;//wai cun dizhi int t; { blockNum=0; writed=0; accessfield=0; t=0; } public Page() { flag=1; swapsapce_blockno=-1; } public Page(int flag,int swapsapce_blockno) { this.flag=flag; this.swapsapce_blockno=swapsapce_blockno; } public int getBlockNum() { return blockNum; } public int getFlag() { return flag; } } class OS2 { public static Vector public static Process running; public static BufferedReader br; static int [][]a=new int[8][8]; static int[][]d=new int[10][10];//置换空间 static int count=0; public OS2() { ready=new Vector blocked=new Vector br=new BufferedReader(new InputStreamReader(System.in)); for(int i=0;i for(int j=0;j if(Math.random()<0.5) { a[i][j]=0; } else { a[i][j]=1; } } } for(int i=0;i for(int j=0;j if(Math.random()<0.5) { d[i][j]=0; } else { d[i][j]=1; } } } System.out.println("位示图----------------"); print(a); System.out.println("置换空间--------------"); print(d); } public static void go() { while(true){ System.out.println("==================================================== ==================="); System.out.println("1:进程创建"); System.out.println("2:进程到时"); System.out.println("3:进程阻塞"); System.out.println("4:进程唤醒"); System.out.println("5:进程结束"); System.out.println("6:逻辑地址转换为物理地址"); System.out.println("7:查看页表"); System.out.println("8:显示位示图和置换空间"); System.out.println("9:查看置换次数和缺页率"); System.out.println("0:退出-->"); try{ int i=Integer.parseInt(br.readLine()); switch(i){ case 0: System.exit(0); case 1: createNewProcess(); break; case 2: switchCurrentProcess(); break; case 3: blockCurrentProcess(); break; case 4: wakeupBlockedProcess(); break; case 5: terminateCurrentProcess(); break; case 6: transform(); break; case 7: showPage(); break; case 8: System.out.println("位示图----------------"); print(a); System.out.println("置换空间--------------"); print(d); break; case 9: look(); break; } } catch(Exception e){ System.out.println(e); } System.out.println("执行进程:"+(running==null?"none":running)); System.out.print("就绪进程:"); printList(ready); System.out.print("阻塞进程:"); printList(blocked); } } public static void printList(Vector v){ for(int i=0;i System.out.print(v.elementAt(i)+"\t"); System.out.println(); } public static void createNewProcess(){ try{ System.out.print("进程名称:"); String name=br.readLine(); Process process=new Process(name); ready.add(process); System.out.print("进程大小:"); double size=Integer.parseInt(br.readLine()); int numPage=0; numPage=(int)Math.ceil(size/1024); process.setPagecount(numPage); Page []P=new Page[numPage]; process.PageQueue=new Vector st: for(int i=0;i for(int j=0;j if(a[i][j]==0) { if(count<3) { //Page p1=new Page(); //P[count]=p1; P[count]=new Page(); P[count].blockNum=8*i+j; process.PageQueue.add(P[count]); P[count].t=3-count; count++; a[i][j]=1; if(count==numPage) { break st; } } else { for(int m=0;m for(int n=0;n if(d[m][n]==0) { //Page p2=new Page(); //P[count]=p2; P[count]=new Page(0,-1); P[count].blockNum=-1; P[count].swapsapce_blockno=8*m+n; count++; d[m][n]=1; if(count==numPage) { count=0; break st; } } } } } } } } if(running==null){ running=(Process)ready.elementAt(0); ready.removeElementAt(0); } process.setPage(P); } catch(Exception e){ System.out.println(e); } } public static void switchCurrentProcess(){ if(running!=null) ready.add(running); if(ready.size()>0){ running=(Process)ready.elementAt(0); ready.removeElementAt(0); } else running=null; } public static void blockCurrentProcess(){ if(running!=null) { blocked.add(running); } if(ready.size()>0) { running=(Process)ready.elementAt(0); ready.removeElementAt(0); } else { running=null; } } public static void wakeupBlockedProcess() { if(blocked.size()>0){ //running=(Process)blocked.elementAt(0); ready.add((Process)blocked.elementAt(0)); blocked.removeElementAt(0); if(running==null) { running=(Process)ready.elementAt(0); ready.removeElementAt(0); } } else { //blocked=null; } } public static void terminateCurrentProcess() { whileExit(); if(running!=null) { running=null; } if(ready.size()>0) { running=(Process)ready.elementAt(0); ready.removeElementAt(0); } else if(blocked.size()>0){ running=(Process)blocked.elementAt(0); blocked.removeElementAt(0); } else { running=null; } } public static void transform() { try { if(running!=null) { System.out.print("输入逻辑地址:"); int LogicAdds=Integer.parseInt(br.readLine()); int PageNumber=LogicAdds/1024; if(PageNumber>running.getPagecount()-1) { while(true) { //if(PageNumber>running.getPagecount()-1) { System.out.println("逻辑地址超出范围,请重新输入:"); LogicAdds=Integer.parseInt(br.readLine()); PageNumber=LogicAdds/1024; if(PageNumber<=running.getPagecount()-1) { break; } //} } } int offset=LogicAdds%1024; int PageBlockNum=running.getPageBlock(PageNumber); ++running.PageTable[PageNumber].accessfield; ++running.visit; if(running.PageTable[PageNumber].getFlag()==0) { ++running.replacement; System.out.println("请选择你所想要置换的算法(提示:1代表FIFO算法,2代表LRU算法)："); int ch=Integer.parseInt(br.readLine()); if(ch==1) { System.out.println("正在FIFO置换算法，对地址进行转换"); Fifo(PageNumber); } else { System.out.println("正在LRU置换算法，对地址进行转换"); Lru(PageNumber); } int PhyAdds=(running.getPageBlock(PageNumber))*1024+offset; System.out.println("物理地址:"+PhyAdds); } else { int PhyAdds=(running.getPageBlock(PageNumber))*1024+offset; System.out.println("物理地址:"+PhyAdds); } } else { System.out.println("no running process"); } } catch(Exception e) { System.out.println(e); } } public static void whileExit() { for(int i=0;i if(running.PageTable[i].flag==1) { int m=running.PageTable[i].blockNum/8; int n=running.PageTable[i].blockNum%8; a[m][n]=0; } else { int m=running.PageTable[i].swapsapce_blockno/8; int n=running.PageTable[i].swapsapce_blockno%8; d[m][n]=0; } } } public static void Fifo(int PageNumber) { running.PageTable[PageNumber].blockNum=((Page)running.PageQueue.elementAt(0)).bloc kNum; st:for(int i=0;i for(int j=0;j if(d[i][j]==0&&running.PageQueue.size()>0) { d[i][j]=1; ((Page)running.PageQueue.elementAt(0)).flag=0; ((Page)running.PageQueue.elementAt(0)).blockNum=-1; ((Page)running.PageQueue.elementAt(0)).writed=0; ((Page)running.PageQueue.elementAt(0)).accessfield=0; ((Page)running.PageQueue.elementAt(0)).swapsapce_blockno=8*i+j; ((Page)running.PageQueue.elementAt(0)).t=0; running.PageQueue.removeElementAt(0); running.PageQueue.add(running.PageTable[PageNumber]); break st; } } } //sb:for(int m=0;m // for(int n=0;n // if(a[m][n]==0) { //a[m][n]=1; running.PageTable[PageNumber].flag=1; //running.PageTable[PageNumber].blockNum=8*m+n; running.PageTable[PageNumber].writed=0; //++running.PageTable[q].accessfield; //running.PageTable[q].swapsapce_blockno=8*m+n; // break sb; //} // } // } } public static void Lru(int PageNumber) {//process.PageTable[count].t int k=getPageTime(); st:for(int i=0;i for(int j=0;j if(d[i][j]==0) { d[i][j]=1; running.PageTable[k].flag=0; running.PageTable[k].blockNum=-1; running.PageTable[k].writed=0; running.PageTable[k].accessfield=0; running.PageTable[k].swapsapce_blockno=8*i+j; running.PageTable[k].t=1; break st; } } } sb:for(int m=0;m for(int n=0;n if(a[m][n]==0) { a[m][n]=1; running.PageTable[PageNumber].flag=1; running.PageTable[PageNumber].blockNum=running.PageTable[k].blockNum; running.PageTable[PageNumber].writed=0; //++running.PageTable[q].accessfield; //running.PageTable[q].swapsapce_blockno=8*m+n; break sb; } } } for(int i=0;i if(i!=k) { ++running.PageTable[i].t; } } } public static int getPageTime() { int max=running.PageTable[0].t; int place=0; for(int i=0;i if(max max=running.PageTable[i].t; place=i; } } return place; } public static void print(int [][]a) { for(int i=0;i for(int j=0;j System.out.print(" "+a[i][j]); } System.out.println(); } } public static void showPage() { if(running==null) { System.out.println("no running process"); return; } System.out.println("页号"+"块号"+"状态位"+" 修改位"+" 访问字段"+"外存地址"); for(int i=0;i System.out.print(i); System.out.print(" "+running.PageTable[i].blockNum); System.out.print(" "+running.PageTable[i].flag); System.out.print(" "+running.PageTable[i].writed); System.out.print(" "+running.PageTable[i].accessfield); System.out.println(" "+running.PageTable[i].swapsapce_blockno); } } public static void look() { System.out.println("置换次数:"+running.replacement); System.out.println("访问次数:"+running.visit); if(running.visit!=0.0) { System.out.println("缺页率"+(running.replacement*100)/running.visit+"%"); } System.out.println("缺页率akjsnala5ds435ax1"); } public static void main(String[]args) { new OS2().go(); } } 操作系统模拟实验 实验名称：请求分页存储管理模拟实验 实验目的：通过实验了解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); 任务四、请求分页存储管理（虚拟存储）一、实验目的 通过请求分页存储管理的设计，让学生了解虚拟存储器的概念和实现方法。进行运行时不需要将所有的页面都调入内存，只需将部分调入内存，即可运行，在运行的过程中若要访问的页面不在内存时，则需求有请求调入的功能将其调入。假如此时若内存没有空白物理块，则通过页面置换的功能将一个老的不用的页面淘汰出来，其中淘汰的算法有多种。 二、实验内容 模拟仿真请求分页调度算法，其中淘汰的算法可选下列其一 1、先进先出算法 2、最近最久算法 3、CLOCK算法 三、实验代码 #include 内存的存储管理段式和页式管理的区别 页和分段系统有许多相似之处，但在概念上两者完全不同，主要表现在： 1、页是信息的物理单位，分页是为实现离散分配方式，以消减内存的外零头，提高内存的利用率；或者说，分页仅仅是由于系统管理的需要，而不是用户的需要。 段是信息的逻辑单位，它含有一组其意义相对完整的信息。分段的目的是为了能更好的满足用户的需要。 2、页的大小固定且由系统确定，把逻辑地址划分为页号和页内地址两部分，是由机器硬件实现的，因而一个系统只能有一种大小的页面。 段的长度却不固定，决定于用户所编写的程序，通常由编辑程序在对源程序进行编辑时，根据信息的性质来划分。 3、分页的作业地址空间是维一的，即单一的线性空间，程序员只须利用一个记忆符，即可表示一地址。 分段的作业地址空间是二维的，程序员在标识一个地址时，既需给出段名，又需给出段内地址。 参考资料：/ctsn/os/skja4.htm 添加评论 炎炎1981|2009-08-2618:28:33 有0人认为这个回答不错|有0人认为这个回答没有帮助 一页式管理 1页式管理的基本原理将各进程的虚拟空间划分成若干个长度相等的页(page)，页式管理把内存空间按页的大小划分成片或者页面（pageframe），然后把页式虚拟地址与内存地址建立一一对应页表，并用相应的硬件地址变换机构，来解决离散地址变换问题。页式管理采用请求调页或预调页技术实现了内外存存储器的统一管理。 它分为 1静态页式管理。静态分页管理的第一步是为要求内存的作业或进程分配足够的页面。系统通过存储页面表、请求表以及页表来完成内存的分配工作。静态页式管理解决了分区管理时的碎片问题。但是，由于静态页式管理要求进程或作业在执行前全部装入内存，如果可用页面数小于用户要求时，该作业或进程只好等待。而且作业和进程的大小仍受内存可用页面数的限制。 2动态页式管理。动态页式管理是在静态页式管理的基础上发展起来的。它分为请求页式管理和预调入页式管理。 优点：没有外碎片，每个内碎片不超过页大小。一个程序不必连续存放。便于改变程序占用空间的大小（主要指随着程序运行而动态生成的数据增多，要求地址空间相应增长，通常由系统调用完成而不是操作系统自动完成）。 缺点：程序全部装入内存。 要求有相应的硬件支持。例如地址变换机构，缺页中断的产生和选择淘汰页面等都要求有相应的硬件支持。这增加了机器成本。增加了系统开销，例如缺页中断处理机，请求调页的算法如选择不当，有可能产生抖动现象。虽然消除了碎片，但每个作业或进程的最后一页内总有一部分空间得不到利用果页面较大，则这一部分的损失仍然较大。 二段式管理的基本思想 把程序按内容或过程（函数）关系分成段，每段有自己的名字。一个用户作 页眉 实验六：请求分页存储管理 一．实验目的 深入理解请求页式存储管理的基本概念和实现方法，重点认识其中的地址变换、缺页中断、置换算法等实现思想。 二．实验属性 该实验为综合性、设计性实验。 三．实验仪器设备及器材 普通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 记录缺页次数 页脚 页眉 存储访问,order//result记录结果int result[20][30],order[30],a[10]; 存储当前页面中的值串,a flag1等为标志变量int pos1,flag1,flag2,flag3; //pos1位置变量，//最佳void opt() char result1[30]; //记录缺页数组 void fifo() //先进先出 bool search(int n) //查找当前内存中是否已存在该页 3.3流程图与运行截图 开始 第十六讲存储器管理之请求分页存储管理方式 1 基本概述 请求分页管理是建立在基本分页基础上的，为了能支持虚拟存储器而增加了请求调页功能和页面置换功能。 基本原理：地址空间的划分同页式；装入页时，可装入作业的一部分(运行所需)页即可运行。 2 请求分页的硬件支持 为实现请求分页，需要一定的硬件支持，包括：页表机制、缺页中断机构、地址变换机构。 2.1 页表机制 作用：将用户地址空间的逻辑地址转换为内存空间的物理地址。 因为请求分页的特殊性，即程序的一部分调入内存，一部分仍在外存，因此页表结构有所不同。如图： 说明： （1）状态位P：指示该页是否已调入内存。 （2）访问字段A：记录本页在一段时间内被访问的次数或最近未被访问的时间。 （3）修改位M：表示该页在调入内存后是否被修改过。若修改过，则换出时需重写至外存。（4）外存地址：指出该页在外存上的地址。 2.2 缺页中断机构 在请求分页系统中，每当所要访问的页面不在内存时，便产生缺页中断，请求OS将所缺的页调入内存。 缺页中断与一般中断的区别： （1）在指令执行期间产生和处理中断信号 （2）一条指令在执行期间，可能产生多次缺页中断 2.3 地址变换机构 请求分页系统的地址变换机构。是在分页系统地址变换机构的基础上，又增加了一些功能。 例：某虚拟存储器的用户空间共有32个页面，每页1KB，主存16KB。假定某时刻系统为用户的第0、1、2、3页分别分配的物理块号为5、10、4、7，试将虚拟地址0A5C和093C 变换为物理地址。 解：虚拟地址为：页号（2^5=32）5位页内位移（1K =2^10=1024）10位物理地址为物理块号（2^4=16）4位因为页内是10 位，块内位移（1K =2^10=1024）10位 虚拟地址OA5C对应的二进制为： 00010 1001011100 即虚拟地址OA5C的页号为2，页内位移为1001011100，由题意知对应的物理地址为：0100 1001011100即125C 同理求093C。略 3 内存分配策略和分配算法 在请求分页系统中，为进程分配内存时，将涉及以下三个问题： 最小物理块数的确定；物理块的分配策略；物理块的分配算法。 3.1最小物理块数的确定 概念：最小物理块数：是指能保证进程正常运行所需的最小物理块数。 确定方法：与计算机的硬件结构有关，取决于指令的格式、功能和寻址方式。 3.2物理块的分配策略 内存分配策略：固定和可变分配策略 置换策略：全局置换和局部置换 三种合适的策略如下： （1）固定分配局部置换（Fixecd Allocation,Local replacement）：为每个进程分配固定数目n的物理块，在整个运行中都不改变。如出现缺页，则从中置换一页。 （2）可变分配全局置换(VariableAllocatio,Global Repalcement)：分配固定数目的物理块， 一、选择 1．分页存储管理的存储保护是通过( )完成的. A.页表（页表寄存器） B.快表 C.存储键 D.索引动态重定 2．把作业地址空间中使用的逻辑地址变成存中物理地址称为（）。 A、加载 B、重定位 C、物理化 D、逻辑化3．在可变分区存储管理中的紧凑技术可以---------------。 A.集中空闲区 B.增加主存容量 C.缩短访问时间 D.加速地址转换 4．在存储管理中，采用覆盖与交换技术的目的是( )。 A.减少程序占用的主存空间 B.物理上扩充主存容量 C.提高CPU效率 D.代码在主存中共享 5．存储管理方法中，( )中用户可采用覆盖技术。 A．单一连续区 B. 可变分区存储管理 C．段式存储管理 D. 段页式存储管理 6．把逻辑地址转换成物理地址称为（）。 A.地址分配 B.地址映射 C.地址保护 D.地址越界 7．在存分配的“最佳适应法”中，空闲块是按（）。 A.始地址从小到大排序 B.始地址从大到小排序 C.块的大小从小到大排序 D.块的大小从大到小排序 8．下面最有可能使得高地址空间成为大的空闲区的分配算法是（）。A.首次适应法 B.最佳适应法 C.最坏适应法 D.循环首次适应法 9．那么虚拟存储器最大实际容量可能是( ) 。 A.1024K B.1024M C.10G D.10G+1M 10．用空白链记录存空白块的主要缺点是（）。 A.链指针占用了大量的空间 B.分配空间时可能需要一定的拉链时间 C.不好实现“首次适应法” D.不好实现“最佳适应法” 11．一般而言计算机中（）容量(个数)最多. A.ROM B.RAM C.CPU D.虚拟存储器 12．分区管理和分页管理的主要区别是（）。 A.分区管理中的块比分页管理中的页要小 B.分页管理有地址映射而分区管理没有 C.分页管理有存储保护而分区管理没有 D.分区管理要求一道程序存放在连续的空间而分页管理没有这种要求。13．静态重定位的时机是（）。 A.程序编译时 B.程序时 C.程序装入时 D.程序运行时 14．通常所说的“存储保护”的基本含义是（） A.防止存储器硬件受损 B.防止程序在存丢失 C.防止程序间相互越界访问 D.防止程序被人偷看 15．能够装入存任何位置的代码程序必须是( )。 A.可重入的 B.可重定位 基本分页存储管理的模拟实现 学院 专业 学号 学生姓名 指导教师姓名 2014年03月18日 目录 一、设计目的与内容 二、各个功能模块 三、主要功能模块流程图 四、系统测试 五、结论 六、源程序及系统文件使用说明 一、设计目的与内容 设计的目的： 操作系统课程设计是计算机专业重要的教学环节, 它为学生提供了一个既动手又动脑, 将课本上的理论知识和实际有机的结合起来, 独立分析和解决实际问题的机会。 1. 进一步巩固和复习操作系统的基础知识。 2. 培养学生结构化程序、模块化程序设计的方法和能力。 3. 提高学生调试程序的技巧和软件设计的能力。 4. 提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。 设计内容： 根据设计要求实现对基本分页存储管理的模拟 设计要求： 1. 2. 进程名, 进程所需页数, 也 可从文件读出。 3. 况。 所采用的数据结构： typedef struct LNode{ int f; //进程号 char name[8]; //进程名 int size; //进程大小 int n; //进程页数 int ye[100]; //页表,下标表示页号, 内容表示进程各页所在物理块 struct LNode *next; }LNode,*LinkList; 二、各个功能模块 主要功能模块流程图 四、系统测试 主界面： （显示程序的各个功能块）1、选择1, 运行界面如下： （选择1, 输入进程名, 显示内存物理块分配情况） 2、选择2, 运行界面如下： （显示2回收进程, 若进程名输入错误, 则显示进程不存在, ）3、选择3, 运行界面如下： 合肥学院 计算机科学与技术系实验报告 2011～2012学年第一学期 课程操作系统原理 课程设计名称模拟分页式存储管理中硬件的地址转换和产生缺页中断 学生姓名 学号 专业班级10计本（2）班 指导教师 2011年11月 1.实验目的： 通过实验模拟分页式存储管理中硬件的地址转换和产生缺页中断帮助理解在分页式存储管理中怎样虚拟存储器。 2.实验内容： 分页式虚拟存储系统是把作业信息的副本存放在磁盘上，当作业被选中时，可把作业的开始几页先装入主存且启动执行。作业执行时，指令中的逻辑地址指出了参加运算的操作存放的页号和单元号，硬件的地址转换机构按页号查页表，若该页对应标志为“1”，则表示该页已在主存，这时根据关系式： 绝对地址=块号×块长+单元号 计算出欲访问的主存单元地址。如果块长为2的幂次，则可把块号作为高地址部分，把单元号作为低地址部分，两者拼接而成绝对地址。若访问的页对应标志为“0”，则表示该页不在主存，这时硬件发“缺页中断”信号，由操作系统按该页在磁盘上的位置，把该页信息从磁盘读出装入主存后再重新执行这条指令。 3.实验步骤： 任务分析： (1)分页式虚拟存储系统是把作业信息的副本存放在磁盘上，当作业被选中时，可把作业 的开始几页先装入主存且启动执行。为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表的格式为： 其中，标志----用来表示对应页是否已经装入主存，标志位=1，则表示该页已经在主存，标志位=0，则表示该页尚未装入主存。 主存块号----用来表示已经装入主存的页所占的块号。 在磁盘上的位置----用来指出作业副本的每一页被存放在磁盘上的位置。 (2)作业执行时，指令中的逻辑地址指出了参加运算的操作存放的页号和单元号，硬件的地址转换机构按页号查页表，若该页对应标志为“1”，则表示该页已在主存，这时根据关系式： 绝对地址=块号×块长+单元号 计算出欲访问的主存单元地址。如果块长为2的幂次，则可把块号作为高地址部分，把单元号作为低地址部分，两者拼接而成绝对地址。若访问的页对应标志为“0”，则表示该页不在主存，这时硬件发“缺页中断”信号，由操作系统按该页在磁盘上的位置，把该页信息从磁盘读出装入主存后再重新执行这条指令。 (30设计一个“地址转换”程序来模拟硬件的地址转换工作。当访问的页在主存时，则形成绝对地址，但不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行。当访问的页不在主存时，则输出“* 该页页号”，表示产生了一次缺页中断。 (4)假定主存的每块长度为128个字节；现有一个共七页的作业，其中第0页至第3页已经装入主存，其余三页尚未装入主存；该作业的页表为： （1）概要设计： 定义页表结构体typedef struct {页号、标志、主存块号、在磁盘存储位置 《操作系统》课程实验报告实验名称：基本分页储存管理 实验五基本分页存储管理 实验目的：熟悉并掌握基本分页存储管理的思想。 熟悉并掌握基本分页存储管理的分配和回收方式，并能够模拟实现。 实验内容：用高级语言模拟实现基本分页存储管理，要求： 1、内存空间的初始化——可以由用户输入初始内存空间各个物理 块情况。（用二维矩阵的方式按物理块号，逐行给出每个物理块的 状态，1——表示已分配，0——表示未分配，并能够将行标、列标 转换为对应的物理块号，以查看或修改每一个块的状态，要求：初 始时部分物理块已分配） 2、基本分页的分配过程：由用户输入作业号和作业的大小（这里的 大小是逻辑页面数），实现分配过程：空间充足，分配，修改状态 矩阵的相应位置的值（值由0转变为1），并用专门的数据记录下 该作业占用的物理块的块号，以备删除作业时回收空间。 3、作业空间的的回收：用户输入作业号，实现分区回收（通过相应 的数据结构找到该作业占有的物理块号，将块号转变成对应的行标、 列标，将对应位置的值由1转变成0就完成了回收） 4、分区的显示：任何时刻，可以查看当前内存的情况（显示记录内 存情况的矩阵的值） 要求考虑：（1）内存空间不足的情况，要有相应的显示； （2）作业不能同名，但是删除后可以再用这个名字； （3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。 三、实验代码 <> <> N 100 共有100个内存块 [N][1]; 存放每个进程的页表 [N]; 内存块状态标志数组，0：空闲，1：使用 ; 记录当前内存剩余空间 ; 记录当前进程数 = ; (); (); (); (); () { /* 设块长为64 该进程只有10页，且已经全部进入主存 */ #include { if(m==p[i].pno) { addr=p[i].cno*64+n;//访问物理地址，物理地址=内存块号*块大小+页内偏移量 printf("物理地址为:%d\n",addr); printf("详细信息:\t页面号:%d\t块号:%d\t偏移量:%d\n\n",p[i].pno,p[i].cno,n); } } } return; } void menu() { printf(" -------------------------------- \n"); printf("| 1.地址转换|\n"); printf("| 2.结束转换|\n"); printf(" -------------------------------- \n"); } int main() { menu(); int log_Addr,select; Init_Page(p); do{ printf("输入你的选择(1还是2):"); scanf("%d",&select); switch(select) { case 1: printf("输入指令的逻辑地址:"); scanf("%d",&log_Addr); change_Addr(p,log_Addr); break; case 2: printf("谢谢使用，不足之处请多多指教!\n"); exit(0); default: printf("选择错误，请重输\n"); } 软件学院 操作系统实验报告 专业：软件工程 班级： RB软工互152 学号： 201560160226 学生姓名：王泽华 指导教师：韩新超 实验四：请求页式存储管理 一．实验目的 深入理解请求页式存储管理的原理，重点认识其中的地址变换、缺页中断、置换算法等实现思想。 二．实验属性 该实验为综合性、设计性实验。 三．实验仪器设备及器材 普通PC386以上微机 四．实验要求 本实验要求4学时完成。 本实验要求完成如下任务： （1）建立相关的数据结构：存储块表、页表等； （2）实现基本分页存储管理，如分配、回收、地址变换； （3）在基本分页的基础上实现请求分页存储管理； （4）给定一批作业/进程，选择一个分配或回收模拟； （5）将整个过程可视化显示出来。 实验前应复习实验中所涉及的理论知识和算法，针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。实验后认真书写符合规范格式的实验报告（参见附录A），并要求用正规的实验报告纸和封面装订整齐，按时上交。 五、实验提示 1、本实验虽然不以前面实验为基础，但建议在其界面中继续增加请求页式存储管理功能。 2、数据结构：内存分配表、页表空间（用数组实现），修改PCB结构增加页表指针、页表长度。 3、存储管理：编写内存分配、内存回收算法、页面置换算法。 4、主界面设计：在界面上增加一个请求分页内存分配按钮、请求分页内存回收按钮、装入指定进程的指定页按钮。 触发请求分页内存分配按钮，弹出作业大小输入框，输入后调用内存分配函数，在内存分配表和页表中看到分配的存储块。触发请求分页内存回收按钮，弹出进程ID输入框，输入后调用内存回收函数，在内存分配表中看到回收后的状态改变。 5、功能测试：从显示出的内存分配表和页表，可查看操作的正确与否。 六、实验步骤 （1）任务分析： 第四章存储管理 1. C 存储管理支持多道程序设计，算法简单，但存储碎片多。 A. 段式 C. 固定分区 2. 虚拟存储技术是 B 。B. D. 页式段页式 A. 补充内存物理空间的技术 B. 补充相对地址空间的技术 C. 扩充外存空间的技术 D. 扩充输入输出缓冲区的技术 3. 虚拟内存的容量只 D 的限制。 A. 物理内存的大小 B. 磁盘空间的大小 C. 数据存放的实际地址 D. 计算机地址位数 4. 动态页式管理中的 C 是：当内存中没有空闲页时，如何将已占据 A. 调入策略 B. 地址变换 C. 替换策略 D. 调度算法 5. 多重分区管理要求个作业都分 B 的内存单元。 A. 地址连续 B. 若干地址不连续 C. 若干连续的帧 D. 若干不连续的帧 6. 段页式管理每取一要访问 C 次内存。 A. 1 B. 2 C. 3 D. 4 7. 分段管理提供 B 维的地址结 A. 1 B. 2 C. 3 D. 4 8.系统抖动是指 B 。 A.使用计算机时，屏幕闪烁的现象 B.刚被调出内存的页又立刻被调入所形成的频繁调入调出的现象 C.系统盘不干净，操作系统不稳定的现象 D.由于内存分配不当，造成内存不够的现象 9.在 A 中，不可能产生系统抖动现象。 A.静态分区管理 B. 请求分页式管理 C. 段式存储管理 D. 段页式存储管理 10.在分段管理中 A 。 A.以段为单元分配，每段是一个连续存储区 B.段与段之间必定不连续 C.段与段之间必定连续 D.每段是等长的 11.请求分页式管理常用的替换策略之一有 A 。 A.LRU B. BF C. SCBF D. FPF 12.可由 CPU调用执行的程序所对应的地址空间为D A.名称空间 B. 虚拟地址空间 C. 相对地址空间 D. 物理地址空间 13. C 存储管理方式提供二维地址结构。 A.固定分区 B. 分页 请求分页式存储管理 为简单起见。页面淘汰算法采用 FIFO 页面淘汰算法， 只将该页在页表中修改状态位。 而不再判断它是否被改写过， 也不 将它 输入进程大小（例如 5300bytes ）,对页表进行初始化 系统为进程分配3个物理块（页框），块号分别为0、1、2，页框管理表（空闲块表） 任意输入一个需要访问的指令地址流（例如： 4355，输入负数结束），打印页表情况。 每访问一个地址时， 首先要计算该地址所在的页的页号， 然后查页表，判断该页是否在 主存 ——如果该页已在主存，则打印页表情况；如果该页不在主存且页框未满 （查空闲块表, 找到空闲块），则调入该页并修改页表，打印页表情况；如果该页不在主存且页框已满，则 按FIFO 页面淘汰算法淘汰一页后调入所需的页，修改页表，打印页表情况。 存储管理算法的流程图见下页。 三、实验要求 完成实验内容并写出实验报告，报告应具有以下内容： 1、 实验目的。 2、 实验内容。 3、 程序及运行情况。 4、 实验过程中出现的问题及解决方法。 #in clude void output(int size){ //打印int i,j; printf(”页号\t\t物理块号\t\t状态位\n\n"); for(i=0;i 请求分页存储管理模拟实验 1.实验目的 请求页式管理是一种常用的虚拟存储管理技术。本设计通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。 2.实验内容： 通过随机数产生一个指令序列，共320条指令。指令的地址按下述原则生成： ① 50% 的指令是顺序执行的； ② 25% 的指令是均匀分布在前地址部分； ③ 25% 的指令是均匀分布在后地址部分。 具体的实施方法是： ①在 [0,319] 的指令地址之间随机选取一起点 m； ②顺序执行一条指令； ③在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为 m′； ④顺序执行一条指令，其地址为 m′+1； ⑤在后地址 [m′+2,319] 中随机选取一条指令并执行； ⑥重复上述步骤② ~ ⑤，直到执行 320 次指令。 将指令序列变换成为页地址流 设：①页面大小为 1K； ②用户内存容量为 4 页到 32 页； ③用户虚存容量为 32K 。 在用户虚存中，按每 K 存放 10 条指令排列虚存地址，即 320 条指令在虚存中的存放方式为： 第 0 条 ~ 第 9 条指令为第 0 页 ( 对应虚存地址为 [0,9])； 第 10 条 ~ 第 19 条指令为第 1 页 ( 对应虚存地址为 [10,19] ) ； ┇ ┇ 第 310 条 ~ 第 319 条指令为第 31 页 ( 对应虚存地址为 [310,319]) 。 按以上方式，用户指令可组成 32 页。 计算并输出下述各种算法在不同内存容量下的命中率。 先进先出的算法 (FIFO)；最近最少使用算法 (LRR)； 最少访问页面算法 (LFR)；最近最不经常使用算法 (NUR)。 3．实验环境 每个学生一台微机，需要安装windows98或windows2000操作系统，配备VC、VB、java或C编程语言，每个学生上机时间不少于24个小时。 （1）、分页请求系统 为了能实现请求调页和置换功能，系统必须提供必要的硬件支持，其中，最重要的是： （1）请求分页的页表机制。它是在分页的页表机制上增加若干个项而形成的，作为请求分页的数据结构； （2）缺页中断机构。每当用户程序要访问的页面尚未调入内存时，便产生一缺页中断，以请求OS将所缺的页面调入内存； （3）地址变换机构。它同样是在分页的地址变换机构的基础上发展形成的。 为了实现请求调页还须得到OS的支持，在实现请求调页功能时，石油OS将所需的页从外存调入内存；在实现置换功能时，也是由OS将内存的某些页调至外存。 4．实验提示 提示：A.命中率=1-页面失效次数/页地址流长度 B.本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。 C.关于随机数产生方法，采用TC系统提供函数RAND()和RANDOMIZE()来产生。 5.算法的理解 ㈠FIFO页面置换算法 ⑴原理简述 ①在分配内存页面数(AP)小于进程页面数(PP)时，当然是最先运行的AP个页面放入内存。 ②这时有需要处理新的页面，则将原来内存中的AP个页面最先进入的调出(是以称为FIFO)，然后将新页面放入。 ③以后如果再有新页面需要调入，则都按⑵的规则进行。 ** 习题 ** 选择最合适的答案 1．分页存储管理的存储保护是通过( )完成的. A.页表（页表寄存器） B.快表 C.存储键 D.索引动态重定 2．把作业地址空间中使用的逻辑地址变成内存中物理地址称为（）。 A、加载 B、重定位 C、物理化 D、逻辑化 3．在可变分区存储管理中的紧凑技术可以（）。 A.集中空闲区 B.增加主存容量 C.缩短访问时间 D.加速地址转换 4．在存储管理中，采用覆盖与交换技术的目的是( )。 A.减少程序占用的主存空间 B.物理上扩充主存容量 C.提高CPU效率 D.代码在主存中共享 5．存储管理方法中，( )中用户可采用覆盖技术。 A．单一连续区 B. 可变分区存储管理 C．段式存储管理 D. 段页式存储管理 6．把逻辑地址转换成物理地址称为（）。 A.地址分配 B.地址映射 C.地址保护 D.地址越界 7．在内存分配的“最佳适应法”中，空闲块是按（）。 A.始地址从小到大排序 B.始地址从大到小排序 C.块的大小从小到大排序 D.块的大小从大到小排序 8．下面最有可能使得高地址空间成为大的空闲区的分配算法是（）。 A.首次适应法 B.最佳适应法 C.最坏适应法 D.循环首次适应法 9．那么虚拟存储器最大实际容量可能是( ) 。 A.1024K B.1024M C.10G D.10G+1M 10．用空白链记录内存空白块的主要缺点是（）。 A.链指针占用了大量的空间 B.分配空间时可能需要一定的拉链时间 C.不好实现“首次适应法” D.不好实现“最佳适应法” 11．一般而言计算机中（）容量(个数)最多. ** B.RAM C.CPU D.虚拟存储器 课程设计任务书及成绩评定 课题名称基本分页存储管理系统的设计 Ⅰ、题目的目的和要求： 巩固和加深对操作系统(OS)原理的理解，初步掌握操作系统组成模块和应用接口的使用方法，提高进行工程设计和系统分析的能力；通过选做上面的课题，实现OS最基本模块的管理功能，重点放在数据结构设计、文档规范化和程序设计风格。 Ⅱ、设计进度及完成情况 日期内容 6.16- 7.18 选取参考书，查阅有关文献资料，完成课程设计说明书内容1部分。完成课程设计说明书内容2-4部分 6.19~6.23 创建相关数据结构,录入源程序 6.24~6.25 调试程序并记录调试中的问题，完成课程设计说明书第5部分。 6.26 系统测试，演示设计成果，考核成绩。 6.27 整理课程设计说明书，上午11时，由学习委员交课程设计说明书(计算机科学系9#213或直接交给指导教师) Ⅲ、主要参考文献及资料 [1] 汤子赢等. 计算机操作系统（第二版）.西安电子科技大学出版社,2006.8 [2] 冯耀霖等. 操作系统，西安电子科技大学出版社.1992 [3] 谭耀铭. 操作系统.中国人民大学出版社,2003.4 [4] 任爱华操作系统实用教程清华大学出版社，2001 [5] 张尧学史美林计算机操作系统教程（第2版）清华大学出版社2000 Ⅳ、成绩评定： 设计成绩：（教师填写） 指导老师：（签字） 二○○八年六月二十七日 目录 第一章概述 (1) 第二章系统分析 (2) 第三章系统设计 (3) 第四章程序设计流程图或N-S图 (5) 第五章源程序清单 (8) 第六章调试过程中的问题及系统测试情况 (14) 第七章结束语 (16) 实验四 请求分页存储管理模拟实验 一：实验目的 通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求分页存储管理系统的原理和实现技术的理解。 二：实验容 假设每个页面可以存放10条指令，分配给进程的存储块数为4。 用C语言或Pascal语言模拟一进程的执行过程。设该进程共有320条指令，地址空间为32个页面，运行前所有页面均没有调入存。模拟运行时，如果所访问的指令已经在存，则显示其物理地址，并转下一条指令；如果所访问的指令还未装入存，则发生缺页，此时需要记录缺页产生次数，并将相应页面调入存，如果4个存块已满，则需要进行页面置换。最后显示其物理地址，并转下一条指令。在所有指令执行完毕后，显示进程运行过程中的缺页次数和缺页率。 页面置换算法：分别采用OPT、FIFO、LRU三种算法。 进程中的指令访问次序按如下原则生成： 50%的指令是顺序执行的。 25%的指令是均匀分布在低地址部分。 25%的指令是均匀分布在高地址部分。 三：实验类别 分页存储管理 四：实验类型 模拟实验 五：主要仪器 计算机 六：结果 OPT: LRU: FIFO: 七：程序 # include 基本分页存储管理 实验目的 连续内存分配方式会形成许多“碎片”，虽然可以通过“紧凑”方法将许多碎片拼接成可用的大块空间，但须为之付出很大开销。如果允许将一个进程直接分散地装入到许多不相邻接的分区中，则无需再进行“紧凑”。基于这一思想而产生了离散分配方式。如果离散分配的基本单位是页，则称为分页存储管理方式；如果离散分配的基本单位是段，则称为分段存储管理方式。 在分页存储管理方式中，如果不具备页面兑换功能，则称为基本的分页存储管理方式，或称为纯分页存储管理方式，它不具备支持虚拟存储器的功能，它要求把每个作业全部装入内存后方能运行。 本实验通过程序模拟操作系统的基本分页存储管理方式，进一步理解这一内存分配方式的原理和特点，加深对理论知识的掌握。 实验要求 1、用C语言或Java语言编写程序模拟操作系统对内存的基本分页存储管理方式 2、程序要能正确对“内存”进行“分配”和“回收”，能接受用户的输入，显示内存的分配情况，并有一定的容错能力。 3、每个人独立按时完成实验内容。 实验内容 本实验假定内存空间已经按块划分，目标程序无需关心内存块大小等底层细节，只需按算法对内存块进行分配即可。程序应该实现以下功能： 1、内存初始化。假定内存块共有N个，初始化后的内存空间应该有一部分已经被使用，这可以用随机数或程序内部的其他算法完成。 2、程序应该能接受用户输入的进程信息，并为之分配内存，返回分配结果（成功或失败），注意，此处应该考虑到不合法的输入并进行相应处理。 3、程序能回收用户指定的进程所占用的内存空间，因此，程序可能需要为每个进程分配一个唯一的进程号并给出详细的提示信息。 4、能直观合理地显示内存分配情况。 5、程序界面友好，便于操作和查看运行结果。 操 作 系 统 实 验 报 告 姓名：卢一一 学号：201607010209 学校：清华大学 专业：计算机科学与技术 班级：2008级—2班 基本分页存储管理 实验目的 连续内存分配方式会形成许多“碎片”，虽然可以通过“紧凑”方法将许多碎片拼接成可用的大块空间，但须为之付出很大开销。如果允许将一个进程直接分散地装入到许多不相邻接的分区中，则无需再进行“紧凑”。基于这一思想而产生了离散分配方式。如果离散分配的基本单位是页，则称为分页存储管理方式；如果离散分配的基本单位是段，则称为分段存储管理方式。 在分页存储管理方式中，如果不具备页面兑换功能，则称为基本的分页存储管理方式，或称为纯分页存储管理方式，它不具备支持虚拟存储器的功能，它要求把每个作业全部装入内存后方能运行。 本实验通过程序模拟操作系统的基本分页存储管理方式，进一步理解这一内存分配方式的原理和特点，加深对理论知识的掌握。 实验要求 1、用C语言或Java语言编写程序模拟操作系统对内存的基本分页存储管理方式 2、程序要能正确对“内存”进行“分配”和“回收”，能接受用户的输入，显示内存的分配情况，并有一定的容错能力。 3、每个人独立按时完成实验内容。 实验内容 本实验假定内存空间已经按块划分，目标程序无需关心内存块大小等底层细节，只需按算法对内存块进行分配即可。程序应该实现以下功能： 1、内存初始化。假定内存块共有N个，初始化后的内存空间应该有一部分已经被使用，这可以用随机数或程序内部的其他算法完成。 2、程序应该能接受用户输入的进程信息，并为之分配内存，返回分配结果（成功或失败），注意，此处应该考虑到不合法的输入并进行相应处理。 3、程序能回收用户指定的进程所占用的内存空间，因此，程序可能需要为每个进程分配一个唯一的进程号并给出详细的提示信息。 4、能直观合理地显示内存分配情况。 5、程序界面友好，便于操作和查看运行结果。请求分页存储管理模拟实验
请求分页存储管理(虚拟存储)
内存的存储管理段式和页式管理的区别
实验六请求分页存储管理
存储器管理之请求分页存储管理方式
计算机操作系统存储管理练习题
基本分页存储管理的模拟实现
模拟分页式存储管理中硬件的地址转换和产生缺页中断
基本分页存储管理
模拟基本分页式存储管理的地址转换
请求页式存储管理
第四章操作系统存储管理(练习题)
操作系统实验3 请求分页式存储管理
请求分页管理实验报告
操作系统原理-第五章存储管理习题
基本分页存储管理系统的设计 操作系统课程设计
操作系统实验4-请求分页存储管理模拟实验
操作系统-基本分页存储管理(内有代码)
C语言基本分页存储管理
- 请求分页存储管理方式
- 请求分页存储管理方式
- 请求分页存储管理设计
- 请求分页存储管理模拟实验
- 操作系统实验3 请求分页式存储管理
- 模拟操作系统的请求分页存储管理java代码
- 操作系统 请求分页存储管理模拟实现
- 模拟操作系统的请求分页存储管理JAVA代码
- 存储管理请求分页系统
- 请求分页式存储管理的地址转换过程实现
- 请求页式存储管理
- 存储器管理之请求分页存储管理方式
- 实验--编程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法
- 实验六请求分页存储管理
- 操作系统原理存储管理请求分页系统
- 操作系统实验4-请求分页存储管理模拟实验
- 实验六请求分页存储管理
- 设计一个请求页式存储管理方案
- 操作系统实验4-请求分页存储管理模拟实验
- 操作系统实验4-请求分页存储管理模拟实验