模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断
大作业用先进先出(FIFO)页面调度算法处理缺页中断
实验四 用先进先出（FIFO ）页面调度算法处理缺页中断1．实验目的深入了解页式存储管理如何实现地址转换；进一步认识页式虚拟存储管理中如何处理缺页中断。
2．实验预备知识页式存储管理中的地址转换的方法；页式虚拟存储的缺页中断处理方法。
3．实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。
实验具体包括：首先对给定的地址进行地址转换工作，若发生缺页则先进行缺页中断处理，然后再进行地址转换；最后编写主函数对所作工作进程测试。
假定主存64KB ，每个主存块1024字节，作业最大支持到64KB ，系统中每个作业分得主存块4块。
4．提示与讲解页式存储管理中地址转换过程很简单，假定主存块的大小为2n 字节，主存大小为2m'字节和逻辑地址m 位，则进行地址转换时，首先从逻辑地址中的高m-n 位中取得页号，然后根据页号查页表，得到块号，并将块号放入物理地址的高m'-n 位，最后从逻辑地址中取得低n 位放入物理地址的低n 位就得到了物理地址，过程如图1所示。
图1 页式存储管理系统地址转换示意图地址转换是由硬件完成的，实验中使用软件程序模拟地址转换过程，模拟地址转换的流程图如图2所示（实验中假定主存64KB ，每个主存块1024字节，逻辑地址即n=10,m'=16，物理地址中块号6位、块内地址10位；作业最大64KB，即m=16，逻辑地址中页号6位、页内地址10位）。
在页式虚拟存储管理方式中，作业信息作为副本放在磁盘上，作业执行时仅把作业信息的部分页面装入主存储器，作业执行时若访问的页面在主存中，则按上述方式进行地址转换，若访问的页面不在主存中，则产生一个“缺页中断”，由操作系统把当前所需的页面装入主存储器后，再次执行时才可以按上述方法进行地址转换。
页式虚拟存储管理方式中页表除页号和该页对应的主存块号外，至少还要包括存在标志（该页是否在主存），磁盘位置（该页的副本在磁盘上的位置）和修改标志（该页是否修改过）。
操作系统习题及答案四
四、计算题1、某虚拟存储器的用户编程空间共32个页面，每页为1KB ，内存为16KB 。
假定某时刻一用户页表中已调入内存的页面的页号和物理块号的对照表如下：则逻辑地址0A5C(H)所对应的物理地址是什么？要求：写出主要计算过程。
1．解：页式存储管理的逻辑地址分为两部分：页号和页内地址。
由已知条件“用户编程空间共32个页面”，可知页号部分占5位；由“每页为1KB”，1K=210，可知内页地址占10位。
由“内存为16KB”，可知有16块，块号为4位。
逻辑地址0A5C （H ）所对应的二进制表示形式是：000 1010 0101 1100，根据上面的分析，下划线部分为页内地址，编码 “000 10” 为页号，表示该逻辑地址对应的页号为2。
查页表，得到物理块号是11（十进制），即物理块地址为：10 11，拼接块内地址10 0101 1100，得10 1110 0101 1100，即2E5C （H ）。
2、对于如下的页面访问序列：1， 2， 3， 4， 1， 2， 5， 1， 2， 3， 4， 5当内存块数量为3时，试问：使用FIFO 、LRU 置换算法产生的缺页中断是多少？写出依次产生缺页中断后应淘汰的页。
（所有内存开始时都是空的，凡第一次用到的页面都产生一次缺页中断。
要求写出计算步骤。
） 2．解：采用先进先出（FIFO ）调度算法，页面调度过程如下：页面次序主存 页面 情况共产生缺页中断9次。
依次淘汰的页是1、2、3、4、1、2。
采用最近最少使用（LRU ）调度算法，页面调度过程如下： 共产生缺页中断10次。
依次淘汰的页是1、2、3、4、5、1、2。
3、下表给出了某系统中的空闲分区表，系统采用可变式分区存储管理策略。
现有以下作业序列：96K 、20K 、200K 。
若用首次适应算法和最佳适应算法来处理这些作业序列，试问哪一种算法可以满足该作业序列的请求，为什么?空闲分区表页面次序1 2 3 4 1 2 5 1 2 3 4 5 主存 页面 情况3．解：若采用最佳适应算法，在申请96K 存储区时，选中的是5号分区，5号分区大小 与申请空间大d,-致，应从空闲分区表中删去该表项；接着申请20K 时，选中1号分区，分配后1号分区还剩下12K ；最后申请200K ，选中4号分区，分配后剩下18K 。
操作完整系统模拟测验考试参考标准答案
操作完整系统模拟测验考试参考标准答案操作系统模拟试题一参考答案一．单项选择题(在每小题地四个备选答案中，选出一个正确答案，并将正确答案地序号填在题干地括号内.每小题2分，共20分) ACDBC AB CDB二．填空题(将正确地答案填入下列空格，每格1分，共10分)1.计算机硬件、计算机软件2.等待态、就绪态、运行态3.封闭性、可再见性4.中断装置5.流式文件、记录式文件三．判断题(判断下列各题，对地打“√”，错地打“╳”.每小题2分，共20分)√√×√√×√√××四、简答题（每小题5分，共20分）1.从资源管理地观点看，操作系统由哪些功能部分组成？答：处理器管理、存储管理、文件管理、设备管理、操作系统地这些部分相互配合，协调工作，实现对计算机地资源地管理，控制程序地执行以及扩充系统功能.为用户提供良好地运行环境.2.简述可变分区方式存储管理采用移动技术地目地及注意问题.答：目地：集中分散地空闲区和便于作业动态扩充主存.注意地问题：移动会增加系统开销、移动是有条件地.（参考书上地条件）3.简述文件系统应具有地功能.答：实现从逻辑文件到物理文件之间地转换有效地分配文件地存储空间建立文件目录提供合适地存取方式确保文件地安全提供对文件地操作.4.请列举五种常用地作业调度算法.答：先来先服务算法、计算时间短地作业优先算法、响应比高者优先算法、优先级调度算法、均衡调度算法五、综合应用题（每小题10分，共30分）1. 在单道批处理系统中，有下列三个作业，试用计算时间短地作业优先算法进行调度，完成下表，并计算平均周转时间T.（注：忽略系统开销.）2来自键盘地一个数存入缓冲器B中，供进程W1打印输出；进程R2每次从磁盘上读一个数存放到缓冲器B中，供进程W2打印输出.为防止数据地丢失和重复打印，现编制了如下程序：beginS,S1,S2:semaphore;B:integer;S:=1;Ｓ１＝0;S2=0;cobeginprocess R1x:integer;beginL1:{接收来自键盘地数};x:=接收地数;③P(S);B:=x;V(S1);goto L1end;……process W2J:integer;beginL4:P(S2)J:=B;V(S){打印J中数};goto L4end;coend;end;请根据以上程序写出①~⑤中相应地语句3．假定在一个请求页式存储管理系统中，某作业J所涉及地页面依次为：3，2，1，4，4，5，3，4，3，2，1，5并已知主存中有3个可供作业J使用地空白存储块（块地大小与页面大小相同），试说明采用FIFO和LRU两种算法进行页面置换时，缺页中断地次数各是多少？写出内存块中页面变化地过程.答：FIFO 缺6次.ＬＲＵ算法：6次操作系统模拟试题二参考答案一．单项选择题(在每小题地四个备选答案中，选出一个正确答案，并将正确答案地序号填在题干地括号内.每小题2分，共20分) DBBACBDADC二．填空题(将正确地答案填入下列空格，每格1分，共10分)1计算机最内层硬件包括（中央处理器（CPU））、（存储器）、（输入输出控制系统）、（输入输出设备）四大部分2在处理器调度过程中，当一个进程地处理器时间片用完以后，该进程地状态为（就绪态）3 作业在执行过程中，只能允许一个作业使用地设备称之为（独占设备），可以让多个作业同时使用地设备称之为（可共享设备），其中计算机中地硬盘属于（可共享设备）4. 在采用线程技术地操作系统中，线程是(处理机调度)和执行单位，而进程是（资源分配）单位.三．判断题(判断下列各题，对地打“√”，错地打“╳”.每小题2分，共20分) ×√×√√√√×√√四、简答题（每小题5分，共20分）1.简述设备管理地功能.答：实现对外围设备地分配与回收、实现外围设备地启动、实现对磁盘地驱动调度、处理外围设备地中断事件、实现虚拟设备.2. 什么是临界区？解决临界区问题地原则是什么？答：并发进程中与共享变量有差地程序段，称之为临界区.解决临界区地原则（参照课本P114页，三个要求）3. 简述固定分区存储管理系统和可变分区存储管理系统地主要区别?答：固定分区地大小固定，但不一定相等，数据往往不能点满整个分区.可变分区，根据数据地大小分区，数据可以占满整个分区.固定分区分区个数固定，可变分区分区可数不确定.固定分区回收分区时，会收回和分区连在一起地碎片.而可变分区不会.固定分区内存地利用率较低，可变分区利用率较高4. 什么是死锁？死锁地必要条件是什么？答：若系统中存在一组进程、它们中地每一个都占用了某种资源而又在等待该给进程中地别一个进程所占用地资源，这种永远等待将不能结束，称之为死锁.死锁地必要条件是：互斥地使用资源、占有且等待资源、非抢占式分配资源、循环等待资源.五、综合应用题（每小题10分，共30分）1．40.假设一个磁盘组有100个柱面(编号为0~99)，每个柱面有16个磁道(又称盘面，编号为0～15)，每个盘面有8个扇区(编号为0~7)，每个盘面用一个读写磁头.现采用位示图方法管理磁盘空间，其字号位号均从第0字第0位递增编号.令磁盘块号按柱面顺序和盘面顺序编排.请回答下列问题：(1)若采用32位地字组成位示图，共需要多少个字?答：100*16*8/32=200（字）(2)第20字地第18位对应于哪个柱面、哪个读写磁头和哪个扇区?答：一个柱面存放：16*8个信息块(20*32+18)/(16*8)= 5.14(在第编号为４地柱面)(20*32+18)mod(16*8)=18(在编号1地磁道，编号为１扇区)2．设有一个具有N个信息元素地环形缓冲区，A进程顺序地把信息写入缓冲区，B进程依次地从缓冲区读出信息.回答下列问题：（假设A、B进程操作可以并行执行）(1)叙述A、B两进程地相互制约关系；答：Ａ地关系为同步关系(2)判别下列用P、V操作表示地同步算法是否正确？如不正确，试说明理由，并修改成正确算法.V AR buffer:ARRAY［0…N-1］OF T;in,out:0..N-1;V AR s1,s2:semaphore;s1:=0;s2:=N;in:=0;out:=0;PROCEDURE A:BEGINREPEAT生产数据m;P（s2）;Buffer［in］:=m;in:=(in+1)MOD N;V(s1);foreverENDPROCEDURE B:BEGINREPEATP(S1)//V（s2）;m:=Buffer［out］;消费m;out:=(out+1)MOD N;V(S2);//P(s1);foreverEND3．设有4道作业，它们地提交时间及执行时间如下表所示：作业地提交时间和执行时间作业号提交时间执行时间1 10 2.02 10.2 1.03 10.4 0.54 10.5 0.3试计算在单道程序环境下，采用最短作业优先（计算时间短地作业优先）调度算法时地每个作业地周转时间和平均周转时间，并指出它们地调度过程.（时间单位：小时，以十进制进行计算）.答：作业号提交时间执行时间调度过程周转时间1 10 2.0 10 22 10.2 1.0 12.8 3.63 10.4 0.5 12.3 2.44 10.5 0.3 12 1.8平均周转时间：(2+3.6+2.4+1.8)/4=2.45操作系统模拟试题三参考答案一．单项选择题(在每小题地四个备选答案中，选出一个正确答案，并将正确答案地序号填在题干地括号内.每小题2分，共20分) CBDABBDAAD二．填空题(将正确地答案填入下列空格，每格1分，共10分)1计算机软件可以分为（系统软件）、（支撑软件）和（应用软件）三大类.2进程控制块通常包括以上四类信息，它们是标识信息、（说明信息）、（现场信息）、（管理信息）.3 计算机设备管理地主要功能为实现对外围设备地分配与回收，（实现外围设备地启动），（实现对磁盘地驱动调度），（处理外围设备地中断事件），（实现虚拟设备）三．判断题(判断下列各题，对地打“√”，错地打“╳”.每小题2分，共20分)×√×√√√×××√四、简答题（每小题5分，共20分）1.什么是进程控制块？进程控制块应包含哪些信息？答：进程控制块就是对进程进行管理和调度地信息地集合，它主要管理四类信息：标识信息、说明信息、现场信息、管理信息.2.要使一个系统不发生死锁，一般可采用哪些方法？简述它们地实现原理.答：破坏产生死锁地四个必要条件中地一个或是多个.静态分配资源按序分配资源剥夺式分配资源采用合理地分配算法等.3.分页存储管理中，页表地功能是什么？答：保存逻辑页号和内存块地对应关系，及物理地址地起始位置4.简述存储管理常用地方法及特点：答：单用户连续存储管理固定分区存储管理可变分区存储管理页式虚拟存储管理.五、综合应用题（每小题10分，共30分）1. 在一个请求分页系统中，假如系统分配给一个作业地物理块数为3，且此作业地页面走向为3 2 4 2 1 3 1 5 2 3 42.试用先进先出（FIFO）调度算法时，作业执行过程中会产生多少次缺页中断（包括首次访问一页时地缺页）？写出依次产生缺页中断后应淘汰地页.2. 桌上有一个空盒，盒内只允许放一个水果，妈妈向盒内放苹果或桔子.儿子专等吃盒中地桔子，女儿专等吃盒中地苹果，若盒内已有水果，放者必须等待，若盒内没有自己要吃地水果，吃者必须等待.用PV操作来协调三人地关系时，请回答下列问题：（1）应设置地信号量及其初值:S=1(表示盘中可以放地水果数),S1=0(表示盘中桔子数量)，S2=0(表示盘中苹果数量)（2）在三组工作流程地虚线位置填上适当地P、V操作，实现三人正确地活动.妈：____________(1) ____P(S)________向盒内放水果（苹果或桔子）if水果==桔子then____________V(S1)____________else____________V(S2)____________儿：____________P(S1)____________拿盒中地桔子____________V(S) ____________吃桔子女：___________P(S2) ____________拿盒中地苹果____________V(S)____________吃苹果3. 假定磁盘地移动臂现在处于第8柱面，有如下6个请求者等待访问磁盘，请你列出最省时间地响应次序：序号柱面磁头号扇区号（1）9 6 3（2） 6 5 6（3）9 20 3（4）9 4 4（5）20 9 5（6） 6 15 2 答：6,2,1,3,4,5操作系统模拟试题四参考答案一．单项选择题(在每小题地四个备选答案中，选出一个正确答案，并将正确答案地序号填在题干地括号内.每小题2分，共20分) BBBB CC ACDB二．填空题(将正确地答案填入下列空格，每格1分，共10分)1操作系统地功能分为（处理器管理）、（存储管理）、（文件管理）、（设备管理）.2(进程)是资源分配地单位,又是调度和执行地单位.而(线程)是进程中可以独立执行地子任务.3 在计算机硬盘中，定位一个信息块地存放位置由三个参数决定，它们是（柱面号）,（磁头号），（扇区号）．4. 我们把并发进程中与共享变量有关地程序段称为“（临界区）”.三．判断题(判断下列各题，对地打“√”，错地打“╳”.每小题2分，共20分)√√√√×××√×√四、简答题（每小题5分，共20分）1. 简述页式存储管理地原理?答：页式存储是把主存储器分成大小相等地许多区，每个区称之分一块，与些对应，编制地程地逻辑地址也分成页，页地大小与块地大小相等，这样逻辑上地每一页就可以到内存中物理地每一块中去了.页式存储管理通过页表来管理逻辑页面和物理页面地对应关系.2. 简述固定分区管理和可变分区存储管理地区别答：固定分区地大小固定，但不一定相等，数据往往不能点满整个分区.可变分区，根据数据地大小分区，数据可以占满整个分区.固定分区分区个数固定，可变分区分区可数不确定.固定分区回收分区时，会收回和分区连在一起地碎片.而可变分区不会.固定分区内存地利用率较低，可变分区利用率较高3. 简述文件系统地功能答：实现从逻辑文件到物理文件之间地转换有效地分配文件地存储空间建立文件目录提供合适地存取方式确保文件地安全提供对文件地操作.4. 简述操作系统地功能答：处理器管理、存储管理、文件管理、设备管理、操作系统地这些部分相互配合，协调工作，实现对计算机地资源地管理，控制程序地执行以及扩充系统功能.为用户提供良好地运行环境.五、综合应用题（每小题10分，共30分）1.某操作系统采用可变分区分配存储管理方法，用户区为512K且始值为0，用空闲分区表管理空闲分区.若分配时采用分配空闲低地址部分地方案，其初始时用户区地512K空间空闲，对下述申请序列：申请300K，申请100K，释放300K，申请150K，申请30K，申请40K，申请60K，释放30K；回答下列问题：（1）采用首次适应算法，空闲分区中有哪些空闲块（给出始址，大小）？（2）采用最佳适应算法，空闲分区中有哪些空闲块（给出始址，大小）？最佳适应算法空闲块2. 桌上有一空盘，允许存放一只水果.爸爸可向盘中放苹果，也可向盘中放桔子，儿子专等吃盘中地桔子，女儿专等吃盘中地苹果.规定当盘空时一次只能放一只水果供吃者取用，请用P、V原语实现爸爸、儿子、女儿三个并发进程地同步.答：(略)3.假设有一磁盘含有64000块，每块长度为1024字节，块号记为1～64000，现用2000个32位(Bit)地字作该盘地位示图，试问第59999块对应于位示图中第几字地第几位(字位均从0开始)；而第1599字地第17位(同上，从0开始)对应于第几块?(10分) 答：59999/32=1874（字）地第32位上.1599*32+(17-1)=5184（块）操作系统模拟试题五参考答案一．单项选择题(在每小题地四个备选答案中，选出一个正确答案，并将正确答案地序号填在题干地括号内.每小题2分，共20分) BAAADC A DDC二．填空题(将正确地答案填入下列空格，每格1分，共10分) １. 机系统包括（计算机硬件）和（计算机软件）两大部分2.了防止用户程序使用特权指令，ＣＰＵ地硬件中，有两种工作状态，分别为（目态）和（管态）3. （进程)是资源分配地单位,又是调度和执行地单位.而(线程)是进程中可以独立执行地子任务.4. 重定位技术是把（逻辑地址）转换为（物理地址）．5. 从使用角度看，外围设备可分为（独占设备）和（共享设备）.三．判断题(判断下列各题，对地打“√”，错地打“╳”.每小题2分，共20分)×××√√√√√×√四、简答题（每小题5分，共20分）1. 简述存储管理地功能．答：主要是对主存储器中地用户区域进行管理，包括主存空间地分配与回收、主存空间地共享与保护、地址转换以及主存空间地扩充等工作.2. 列举磁盘移臂调度几种常用算法答：先来先服务算法、最短寻找时间优先算法、电梯调度算法3. 什么是多道程序设计？设计多道程序时应注意哪些问题？答：让多个作业同时进入计算机系统地主存储器并行执行，这种程序设计方法称之为多道程序设计，设计多道程序时应注意以下几个问题：存储保护技术：解决办法，地址重定位技术和地址保护机制.程序浮支技术：内存移动地办法解决处理器地管理和分配：处理机调度管理系统资源地管理和调度：设备管理、资源管理算法等4.虚拟存储器地特征是什么？虚拟存储器地容量都受哪些因素影响？答：虚拟存储器是为扩大主存而采用地一种设计技巧，利用程序地局部性原理，把作业在运行时不用地，或暂时不用地，或某种条件下才用地程序和数据，全部驻留于主存中是对宝贵地主存次源地一种良费，大大降低了主存地利用率，于是提出作业提交时，先全部进入辅助存储器中，作业投这行时，把作业部分信息装入主存，其余信息先放在辅腲存储器中，待用到这些信息地时候，再由系统自动把它们装入到主存储器中.虚拟存器地容量与主存大小无关，只受地址结构和辅助存储器大小地限制. 五、综合应用题（每小题10分，共30分）1．设有4道作业，它们地进入输入井时间、需执行时间如下表所示.采用短作业优先调度算（1）填写表中各个作业地开始时间、完成时间和周转时间.（2）写出这4个作业地执行顺序.答：1、４、３、２（3）这4个作业地平均周转时间是多少？（120+226+154+108）/4=152分钟(2小时32分钟)2．设有10个缓冲区构成地循环缓冲池，每个缓冲区能容纳一个整数.写进程Writer把整数逐个存入缓冲池，读进程Reader则逐个从缓冲池中取出并打印输出，要求打印地与输入地完全一样，即整数地个数、次序、数均一样.试问：（1）写进程与读进程之间地制约关系（同步）.（2）用PV操作同步机制写出这两个进程地同步算法程序.V AR buffer:ARRAY［0…9］OF Integer;in,out:0..9;V AR s1,s2:semaphore;s1:=0;s2:=10;in:=0;out:=0;PROCEDURE writer:BEGINREPEAT产生数据m;P（s2）;Buffer［in］:=m;in:=(in+1)MOD N;V(s1);foreverENDPROCEDURE Reader:BEGINREPEATP(S1)//V（s2）;m:=Buffer［out］;打印mout:=(out+1)MOD N;V(S2);//P(s1);foreverEND3．.假定在某动臂磁盘上，刚处理了访问75号柱面地请求，目前正在74号柱面上读信息，48,22,78,92,101,156,188,193（2）写出最短寻找时间优先算法时处理地序列次序；78,92,101,156,188,193,48,22（3）采用最短寻找时间优先算法处理时臂地移动方向改变了2次？版权申明本文部分内容，包括文字、图片、以及设计等在网上搜集整理.版权为个人所有This article includes some parts, including text, pictures, and design. Copyright is personal ownership.AVktR43bpw 用户可将本文地内容或服务用于个人学习、研究或欣赏，以及其他非商业性或非盈利性用途，但同时应遵守著作权法及其他相关法律地规定，不得侵犯本网站及相关权利人地合法权利.除此以外，将本文任何内容或服务用于其他用途时，须征得本人及相关权利人地书面许可，并支付报酬.ORjBnOwcEdUsers may use the contents or services of this article for personal study, research or appreciation, and othernon-commercial or non-profit purposes, but at the same time, they shall abide by the provisions of copyright law and other relevant laws, and shall not infringe upon the legitimate rights of this website and its relevant obligees. In addition, when any content or service of this article is used for other purposes, written permission and remuneration shall be obtained from the person concerned and the relevant obligee.2MiJTy0dTT 转载或引用本文内容必须是以新闻性或资料性公共免费信息为使用目地地合理、善意引用，不得对本文内容原意进行曲解、修改，并自负版权等法律责任.gIiSpiue7AReproduction or quotation of the content of this article must be reasonable and good-faith citation for the use of news or informative public free information. It shall not misinterpret or modify the original intention of the content of this article, and shall bear legal liability such as copyright.uEh0U1Yfmh。
实验四页式虚拟存储管理中地址转换和页式中断FIFOLRUOPTC++版本
实验四页式虚拟存储管理中地址转换和页式中断FIFO一、实验目的深入了解页式存储管理如何实现地址转换；进一步认识页式虚拟存储管理中如何处理缺页中断以及页面置换算法。
二、实验主要内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。
实验具体内容包括：首先对给定的地址进行转换工作，若发现缺页则先进行缺页中断处理，然后再进行地址转换；最后编写主函数对所做工作进行测试。
假定主存64KB，每个主存块1024字节，作业最大支持到64KB，系统中每个作业分得主存块4块。
三、实验原理1）地址转换过程：首先从逻辑地址中的高位取得页号，然后根据页号查页表，得到块号；然后从逻辑地址中的低位取得页内地址，将块号和页内地址合并即得到物理地址。
2）缺页中断处理根据页号查找页表，判断该页是否在主存储器中，若该页标志位“0”，形成缺页中断。
操作系统让调出中断处理程序处理中断。
四、实验方法与步骤实现地址转换与缺页中断处理，主要考虑三个问题：第一，设计页式虚拟存储管理方式中页表的数据结构；第二，地址转换算法的实现；第三，缺页中断处理算法的实现。
1)设计页表的数据结构页式虚拟存储管理方式中页表除了页号和该页对应的主存块号外，至少还要包括存在标志（该页是否在主存），磁盘位置（该页的副本在磁盘上的位置）和修改标志（该页是否修改过）。
在实验中页表用数组模拟，其数据结构定义如下：struct{int lnumber; //页号int flag; //表示页是否在主存中，“1”表示在，“0”表示不在int pnumber; // 该页所在主存块的块号int write; //该页是否被修改过，“1”表示修改过，“0“表示没有修改过int dnumber; //该页存放在磁盘上的位置，即磁盘块号}page[n]; //页表定义2）地址转换算法的实现地址转换是由硬件完成的，实验中使用软件程序模拟地址转换过程。
在实验中，每个主存块1024字节，则块内地址占10位；主存64KB，则主存共64块，即块号占6位；物理地址共占16位；作业最大64KB，则作业最大占64块，即页号占6位，逻辑地址共占16位。
三级网络技术笔试-42
三级网络技术笔试-42(总分：100.00，做题时间：90分钟)一、选择题(总题数：60，分数：60.00)1.ATM为异步传输模式，但本质上仍是一种( )传输模式。
（分数：1.00）A.报文B.分组√C.线路D.都不是解析：2.下列关于协议转换器的说法不正确的是 ( )（分数：1.00）A.协议转换器执行互联网间协议的转换B.协议转换器应有适当的硬件、软件来实现其功能C.随着技术的进步，通用的协议转换器将在不久面世√D.协议转换器是高层的网络互联设备解析：3.下面哪种页面淘汰算法会产生Delay异常现象 ( )（分数：1.00）A.最佳页面淘汰算法(OPT)B.最近最少使用页面淘汰算法(LRU)C.最不经常使用页面淘汰算法(LFU)D.先进先出页面淘汰算法(FIFO) √解析：4.在DQDB双总线子网的访问控制中能够提供等时服务的媒体访问控制协议是 ( )（分数：1.00）A.载波监听多路访问B.预先仲裁访问√C.分布式排队访问D.时分多址访问解析：5.市话网上数据传输期间，在源节点与目的节点之间有一条利用中间节点构成的物理连接线路。
这种市话网采用( )技术。
（分数：1.00）A.报文交换B.电路交换√C.分组交换D.数据交换解析：6.网络新闻组USENET使用( )协议在互联网上发送网络新闻。
（分数：1.00）A.HTIPB.FTPC.SMTPD.NNTP √解析：7.下列哪一存储器对盘腔内清洁度要求很高，包含空气过滤系统 ( )（分数：1.00）A.磁带机B.光盘存储器C.软磁盘D.硬磁盘√解析：8.ALOHA网是一个报文分组( )网。
（分数：1.00）A.光纤B.双绞线C.无线√D.同轴电缆解析：9.X．25分组头用于网络控制，其长度随分组类型不同而有所不同，但至少包含前 ( )（分数：1.00）A.四个B.三个√C.五个D.八个解析：10.EPROM是指 ( )（分数：1.00）A.只读存储器B.可编程的只读存储器C.可擦可编程的只读存储器√D.电可改写只读存储器解析：11.路由器的路由表通常包含 ( )（分数：1.00）A.目的网络和到达目的网络的完整路径B.所有的目的主机和到达该目的主机的完整路径C.目的网络和到达该目的网络路径上的下一个路由器的IP地址√D.互联网中所有路由器的IP地址解析：12.WWW服务器把信息组织成为 ( )（分数：1.00）A.集中网页B.分布式的超文本√C.关系数据库D.都不是解析：13.在数据通信中，当发送数据出现差错时，发送端无须进行数据重发的差错控制方法为 ( )（分数：1.00）A.ARQB.FEC √C.BECD.CRC解析：14.在DOS操作系统下，可使用( )对压缩文件进行解压。
模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断
实验报告课程名称操作系统原理实验名称虚拟页式管理姓名学号专业班级网络实验日期成绩指导教师赵安科（①实验目的②实验原理③主要仪器设备④实验内容与步骤⑤实验数据记录与处理⑥实验结果与分析⑦问题建议）实验二模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断1．内容：模拟请求页式存储管理中硬件的地址转换和缺页中断处理2．思想：装入新页置换旧页时，若旧页在执行中没有被修改过，则不必将该页重写磁盘。
因此，页表中增加是否修改过的标志，执行“存”指令和“写”指令时将对应的修改标志置成“1”3．要求及方法：①设计一个地址转换程序来模拟硬件的地址转换和缺页中断。
当访问的页在主存时则形成绝对地址，但不去模拟指令的执行，可以输出转换后的绝对地址来表示一条指令已执行完成。
当访问的页不在主存中时，则输出“*页号”来表示硬件产生了一次缺页中断。
模拟地址转换流程见图1。
②编制一个FIFO页面调度程序；FIFO页面调度算法总是先调出作业中最先进入主存中的哪一页。
因此可以用一个数组来表示（或构成）页号队列。
数组中每个元素是该作业已在主存中的页面号，假定分配给作业的页架数为m，且该作业开始的m页已装入主存，则数组可由m个元素构成。
P[0]，P[1]，P[2]，…，P[m-1]它们的初值为P[0]：=0，P[1]：=1，P[2]：=2，…，P[m-1]：=m-1用一指针K指示当要调入新页时应调出的页在数组中的位置，K的初值为“0”，当产生缺页中断后，操作系统总是选择P[K]所指出的页面调出，然后执行：P[K]：=要装入的新页页号 K ：=(k+1)mod m在实验中不必实际地启动磁盘执行调出一页和装入一页的工作，而用输出“OUT 调出的页号”和“IN 要装入的新页页号”来模拟一次调出和装入过程，模拟程序的流程图见附图1。
按流程控制过程如下：提示：输入指令的页号和页内偏移和是否存指令⎩⎨⎧0 1非存指令存指令，若d 为-1则结束，否则进入流程控制过程，得P 1和d ，查表在主存时，绝对地址=P 1×1024+d③ 假定主存中页架大小为1024个字节，现有一个共7页的作业，其副本已在磁盘上。
国开电大操作系统形考作业1-3答案
国开电大操作系统形考作业1-3答案形考作业一题目随机，请使用Ctrl+F组合键查找题目题目：按照所起的作用和需要的运行环境，操作系统属于（）。
答案：系统软件题目：UNIX操作系统核心层的实现结构设计采用的是（）。
答案：层次结构题目：UNIX命令的一般格式是（）。
答案：命令名[选项][参数]题目：操作系统的基本职能是（）答案：控制和管理系统内各种资源，有效地组织多道程序的运行题目：操作系统对缓冲区的管理属于（）的功能。
答案：设备管理题目：操作系统内核与用户程序、应用程序之间的接口是（）。
答案：系统调用题目：工业过程控制系统中运行的操作系统最好是（）。
答案：实时系统题目：进程从运行状态变为阻塞状态的原因是（）。
答案：输入或输出事件发生题目：进程控制块是描述进程状态和特性的数据结构，一个进程（答案：只能有唯一的进程控制块题目：进程与程序之间有密切联系，但又是不同的概念。
答案：程序是静态概念，进程是动态概念题目：两个进程合作完成一个任务，在并发执行中，一个进程要等待其合作伙伴发来信息，或者建立某个条件后再向前执行，这种关系是进程间的（）关系。
答案：同步问题：两个进程争取统一个资源（）。
答案：不一定死锁问题：某进程由于需求从磁盘上读入数据而处于阻塞状态。
答案：从阻塞变成就绪问题：批处置惩罚系统的主要缺点是（）。
答案：失去了交互性题目：如果信号量S的值是0 ,此时进程A执行P（S）操作，那么，进程A会（）。
答案：进入阻塞态，让出CPU 题目：若P、V操作的信号量S初值为2，当前值为-1，则表示有（）个等待进程。
答案：1题目：实时操作系统追求的目标是（）。
答案：快速响应问题：死锁的四个必要条件中，没法破坏的是（）。
答案：互斥条件题目：为了描述进程的动态变化过程，采用了一个与进程相联系的（），根据它而感知进程的存在。
答案：进程控制块题目：为了使系统中所有的用户都能得到及时的响应，该操作系统应该是（）。
答案：分时系统题目：为用户分配主存空间，保护主存中的程序和数据不被破坏，提高主存空间的利用率。
模拟分页式虚拟存储管理中硬件的地址转换和缺页中断--选择页面调度算法处理缺页中断
操作系统实验二〔第一题〕一．实验内容模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断。
二．实验目的在电脑系统总，为了提高主存利用率，往往把辅助存储器作为主存储器的扩充，使多道运行的作业的全部逻辑地址空间综合可以超出主存的绝对地址空间。
用这种方法扩充的主存储区成为虚拟存储器。
三．实验题目模拟分页式存储管理中硬件的地址转换和产生缺页中断。
四．程序清单//// 操作实验二.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．将作业相对地址空间的相对地址转换成内存中的绝对地址的过程称为地址重定位。
2．使用覆盖与对换技术的主要目的是提高内存的利用率。
3．存储管理中，对存储空间的浪费是以内部碎片和外部碎片两种形式表现出来的。
4．地址重定位可分为静态重定位和动态重定位两种。
5．在可变分区存储管理中采用最佳适应算法时，最好按尺寸法来组织空闲分区链表。
6．在分页式存储管理的页表里，主要应该包含页号和块号两个信息。
7．静态重定位在程序装入时进行，动态重定位在程序执行时进行。
8．在分页式存储管理中，如果页面置换算法选择不当，则会使系统出现抖动现象。
9．在请求分页式存储管理中采用先进先出（FIFO）页面淘汰算法时，增加分配给作业的块数时，缺页中断的次数有可能会增加。
10．在请求分页式存储管理中，页面淘汰是由于缺页引起的。
二、选择1．虚拟存储器的最大容量是由 A 决定的。
A．内、外存容量之和 B．计算机系统的地址结构C．作业的相对地址空间 D．作业的绝对地址空间2．采用先进先出页面淘汰算法的系统中，一进程在内存占3块（开始为空），页面访问序列为1、2、3、4、1、2、5、1、2、3、4、5、6。
运行时会产生 D 次缺页中断。
A．7 B．8 C．9 D．10从图3-8中的“缺页计数”栏里可以看出应该选择D。
图3-8 选择题2配图3．系统出现“抖动”现象的主要原因是由于 A 引起的。
A．置换算法选择不当 B．交换的信息量太大C．内存容量不足 D．采用页式存储管理策略4．实现虚拟存储器的目的是 D 。
A．进行存储保护 B．允许程序浮动C．允许程序移动 D．扩充主存容量5．作业在执行中发生了缺页中断，那么经中断处理后，应返回执行 B 指令。
A．被中断的前一条 B．被中断的那条C．被中断的后一条 D．程序第一条6．在实行分页式存储管理系统中，分页是由 D 完成的。
A．程序员B．用户C．操作员D．系统7．下面的 A 页面淘汰算法有时会产生异常现象。
用先进先出（FIFO）页面调度算法处理缺页中断
//页面调度算法（FIFO）#include<stdio.h>#define TRUE 1#define FALSE 0#define MAX 7 // 页的最大数#define IN 4 // 在主存中的页数#define count 13 // 指令数量int P[IN]; // 表示已在主存中的页面int k; // 表示P数组中最先进入内存的页的位置typedef struct{int num; // 页号bool pre; // 标志int random; // 主存块号bool revise; // 修改标志int location; // 在磁盘上的位置}Page_Item;Page_Item Page_Record[MAX];// 指令数据结构typedef struct{char oper; // 操作符int Page_Num; // 页号int Unit_Num; // 单元号}Instruction;Instruction IC[count];// 初始化指令和页表void Init(){k=0; // 指向最先进入内存的页// 初始化页表Page_Record[0].num=0;Page_Record[0].pre=TRUE;Page_Record[0].random=5;Page_Record[0].revise=FALSE;Page_Record[0].location=011;Page_Record[1].num=1;Page_Record[1].pre=TRUE;Page_Record[1].random=8;Page_Record[1].revise=FALSE;Page_Record[1].location=012; Page_Record[2].num=2;Page_Record[2].pre=TRUE; Page_Record[2].random=9; Page_Record[2].revise=FALSE; Page_Record[2].location=013;Page_Record[3].num=3;Page_Record[3].pre=TRUE; Page_Record[3].random=1; Page_Record[3].revise=FALSE; Page_Record[3].location=021;Page_Record[4].num=4;Page_Record[4].pre=FALSE; Page_Record[4].random=0; Page_Record[4].revise=FALSE; Page_Record[4].location=022;Page_Record[5].num=5;Page_Record[5].pre=FALSE; Page_Record[5].random=0; Page_Record[5].revise=FALSE; Page_Record[5].location=023;Page_Record[6].num=6;Page_Record[6].pre=FALSE; Page_Record[6].random=0; Page_Record[6].revise=FALSE; Page_Record[6].location=121;// 初始化指令序列IC[0].oper='+';IC[0].Page_Num=0;IC[0].Unit_Num=70;IC[1].oper='+';IC[1].Page_Num=1;IC[1].Unit_Num=50;IC[2].oper='*';IC[2].Page_Num=2;IC[2].Unit_Num=15;IC[3].oper='w';IC[3].Page_Num=3;IC[3].Unit_Num=21;IC[4].oper='r';IC[4].Page_Num=0;IC[4].Unit_Num=56;IC[5].oper='-';IC[5].Page_Num=6;IC[5].Unit_Num=40;IC[6].oper='>';IC[6].Page_Num=4;IC[6].Unit_Num=53;IC[7].oper='+';IC[7].Page_Num=5;IC[7].Unit_Num=23;IC[8].oper='w';IC[8].Page_Num=1;IC[8].Unit_Num=37;IC[9].oper='r';IC[9].Page_Num=2;IC[9].Unit_Num=78;IC[10].oper='+';IC[10].Page_Num=4;IC[10].Unit_Num=1;IC[11].oper='r';IC[11].Page_Num=6;IC[11].Unit_Num=84;IC[12].oper='#';IC[12].Page_Num=0;IC[12].Unit_Num=0;}// 根据FIFO算法替换页,所需要的参数是被调入页的页结构体void replace(Page_Item page){// 被替换的页已经修改了if(TRUE==Page_Record[P[k]].revise){// 修改被调出页的存在标志Page_Record[P[k]].pre=FALSE;// 修改被调出页的修改标志Page_Record[P[k]].revise=FALSE;printf("调出%d页\n",P[k]);}// 将调入页的存在标志修改为TRUEpage.pre=TRUE;// 将被调出页的主存块号赋给调入页的主存块号page.random=Page_Record[P[k]].random;// 将调入页的页号赋给P[k]P[k]=page.num;printf("调入%d页\n",page.num);// 修改k指针k=(k+1)%IN;}// 指令执行过程void excute(){int i=0; // 指向当前正在执行的指令while('#'!=IC[i].oper){printf("执行%c指令,需%d页\n",IC[i].oper,IC[i].Page_Num);// 若正在执行的指令所需的页不在内存中if(FALSE==Page_Record[IC[i].Page_Num].pre){printf("该页不在内存中,请求调入.........\n");// 调用替换函数，调入所需的页replace(Page_Record[IC[i].Page_Num]);}// 修改指令对该页的操作if('+'==IC[i].oper||'*'==IC[i].oper||'-'==IC[i].oper||'>'==IC[i].oper){printf("%c指令修改了%d页\n",IC[i].oper,IC[i].Page_Num);// 修改该页的修改标志Page_Record[IC[i].Page_Num].revise=TRUE;}i++; // 指向下一条指令}for(i=0;i<IN;i++){if(TRUE==Page_Record[P[i]].revise){printf("%d页写回外存!\n",P[i]);}}}void main(){Init();excute();}。
操作系统——模拟页面置换算法（FIFO——先入先出、LRU——最近最少使用、LFU——最近。。。
操作系统——模拟页⾯置换算法（FIFO——先⼊先出、LRU——最近最少使⽤、LFU——最近。
操作系统——模拟页⾯置换算法（FIFO——先⼊先出、LRU——最近最少使⽤、LFU——最近最不常使⽤），计算置换率（包含程序框图）导语：1. FIFO页⾯置换算法：最简单的页⾯置换算法。
这种算法的基本思想是：当需要淘汰⼀个页⾯时，总是选择驻留主存时间最长的页⾯进⾏淘汰，即先进⼊主存的页⾯先淘汰。
(看时间)2. LRU页⾯置换算法：最近最少使⽤，简单来说就是将数据块中，每次使⽤过的数据放在数据块的最前端，然后将存在的时间最长的，也就是数据块的末端的数据置换掉。
(看时间)3. LFU页⾯置换算法：近期最少使⽤算法，选择近期最少访问的页⾯作为被替换的页⾯，如果⼀个数据在最近⼀段时间内使⽤次数很少，那么在将来⼀段时间内被使⽤的可能性也很⼩。
(看次数)4. 置换率与与缺页率不同。
置换率⽤置换次数算，缺页率⽤缺页中断次数算。
FIFO页⾯置换算法：Linux效果图（采⽤UOS + VScode + g++）程序框图C++代码(FIFO)：#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int *analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int a[],int n,int x) //判断数组中是否已有x，若有返回其下标值，没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换，y是⽤来置换的页⾯，x是被置换的页⾯ {int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}int main() {int i;int maxanalogblock=-1;//模仿队列的定义int x;cout<<"请输⼊页框⼤⼩物理块数：\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数：\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}analogblock=new int[mnum];block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=-1;for (i=0;i<mnum;i++) block[i]=-1;///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下：\n";srand( (unsigned)time( NULL ) );//以time函数值（即当前时间）作为种⼦数，保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"先进先出(FIFO)页⾯置换算法，结果： \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[maxanalogblock]=process[x];//新元素从尾部插⼊block[maxanalogblock]=process[x];//新元素从尾部插⼊cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//队列法插⼊(尾部元素出，新元素从头部⼊)cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0]<<endl; replace(process[x],mnum,analogblock[0]);//置换物理块中页⾯for (i=0;i<mnum-1;i++)LRU 页⾯置换算法：Linux 效果图（采⽤UOS + VScode + g++）程序框图C++代码(LRU)： analogblock[i]=analogblock[i+1];analogblock[mnum-1]=process[x];//////////////////maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值count++;} else //若数组中存在待插⼊元素 {maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}}}//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1) cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}cout<<endl<<"页⾯换算次数为："<<count<<endl;cout<<"置换率为："<<(float)count/pnum<<endl;return 0;}//g++ test71.cpp -o test71 -lpthread&&./test71#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int *analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int a[],int n,int x) //判断数组中是否已有x ，若有返回其下标值，没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换，y是⽤来置换的页⾯，x是被置换的页⾯ { int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}void move(int a[],int n,int i) //移动下标为i的元素到尾部 {int j;int m=a[i];for (j=i;j<n-1;j++)a[j]=a[j+1];a[n-1]=m;}int main() {int i;int maxanalogblock=-1;//模仿栈的定义int x;cout<<"请输⼊页框⼤⼩物理块数：\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数：\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}analogblock=new int[mnum];block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=-1;///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下：\n";srand( (unsigned)time( NULL ) );//以time函数值（即当前时间）作为种⼦数，保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"最近最少使⽤(LRU)页⾯置换算法，结果： \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1LFU 页⾯置换算法：Linux 效果图（采⽤UOS + VScode + g++）程序框图 if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[maxanalogblock]=process[x];//新元素从尾部插⼊block[maxanalogblock]=process[x];//新元素从尾部插⼊cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断 调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {move(analogblock,maxanalogblock,judge(analogblock,mnum,process[x]));//移动下标为i 的元素到尾部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//栈法插⼊(第⼀个元素出，后⾯元素前移，新元素从尾部⼊)cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断 页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0]<<endl; replace(process[x],mnum,analogblock[0]);//物理块中页⾯置换for (i=0;i<mnum-1;i++)analogblock[i]=analogblock[i+1];analogblock[mnum-1]=process[x];//////////////////maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值count++;} else //若数组中存在待插⼊元素 {move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i 的元素到尾部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}}}//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}cout<<endl<<"页⾯换算次数为："<<count<<endl;cout<<"置换率为："<<(float)count/pnum<<endl;return 0;}//g++ test72.cpp -o test72 -lpthread&&./test72C++代码(LFU)：#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int **analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int *a[],int n,int x) //判断数组中是否已有x，若有返回其下标值，没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i][0])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换，y是⽤来置换的页⾯，x是被置换的页⾯ { int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}void move(int *a[],int n,int i) //移动下标为i的元素，⽐较访问次数次多少进⾏前进 {int j;int m=a[i][0];int m2=a[i][1];for (j=i;j<n-1;j++) {if(m2>=a[j+1][1]) {a[j][0]=a[j+1][0];a[j][1]=a[j+1][1];a[j+1][0]=m;a[j+1][1]=m2;}}}int main() {int i;int maxanalogblock=-1;//模仿栈的定义int x;//动态数组初始化cout<<"请输⼊页框⼤⼩物理块数：\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数：\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}analogblock=(int**) (new int[mnum]);block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=(int*) new int[2];//⽤于保存页⾯号和访问次数for (i = 0; i < mnum; i++) {analogblock[i][0]=-1;analogblock[i][1]=0;}///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下：\n";srand( (unsigned)time( NULL ) );//以time函数值（即当前时间）作为种⼦数，保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"最近最不常使⽤(LFU)页⾯置换算法，结果： \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i][0]!=-1)cout<<analogblock[i][0]<<" ";//<<"访问次数"<<analogblock[i][1]<<" "}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[0][0]=process[x];//新元素从头部插⼊analogblock[0][1]=1;block[maxanalogblock]=process[x];//新元素从尾部插⼊move(analogblock,mnum,0);//移动下标为i的元素到相同访问次数页⾯的顶部cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {// move(analogblock,maxanalogblock,judge(analogblock,mnum,process[x]));//移动下标为i的元素到尾部analogblock[judge(analogblock,mnum,process[x])][1]++;move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i的元素到相同访问次数页⾯的顶部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//栈法插⼊(新元素从头部⼊，替换掉头部)cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0][0]<<endl; replace(process[x],mnum,analogblock[0][0]);//物理块中页⾯置换analogblock[0][0]=process[x];analogblock[0][1]=1;move(analogblock,mnum,0);//移动下标为i的元素相同访问次数页⾯的顶部//////////////////maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值count++;} else //若数组中存在待插⼊元素 {analogblock[judge(analogblock,mnum,process[x])][1]++;move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i的元素到相同访问次数页⾯的顶部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在直接访问"<<endl; }}}//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i][0]!=-1)cout<<analogblock[i][0]<<" ";}cout<<endl<<"页⾯换算次数为："<<count<<endl;cout<<"置换率为："<<(float)count/pnum<<endl;return 0;}//g++ test73.cpp -o test73 -lpthread&&./test73。
请求页式管理缺页中断模拟设计--FIFO、OPT
请求页式管理缺页中断模拟设计--FIFO、OPT1.程设计目的与功能2.1 目的实现请求页式管理缺页中断FIFO、OPT算法，掌握页式存储管理系统的相关理论知识。
2.2 功能实现指定淘汰算法。
能够处理一下情形：2.2.1能够输入给作业分配的内存块数；2.2.2 能够输入给定的页面，并计算发生缺页的次数以及缺页率；2.2.3 缺页时，如果发生页面置换，输出淘汰的页号。
2.需求分析，数据结构或模块说明(功能与框图)2.1算法的原理描述:2.1.1先进先出页面置换（FIFO）FIFO法基本思想：选择在内存驻留时间最长的页将其淘汰。
FIFO 算法认为先调入内存的页不再被访问的可能性要比其他页大，因而选择最先调入内存的页换出。
2.1.2理想型淘汰页面置换算法（OPT）OPT法基本思想：当要调入一新页而必须淘汰一旧页时，所淘汰的页是以后不再使用的，或者是以后相当长的时间内不会使用的。
这样，淘汰掉该页将不会造成因需要访问该页而又立即把它调入的现象。
该算法无法实现，因为，它要求必须预先知道每一个进程的访问串。
2.2 本次课程设计中的算法流程图2.2.1 FIFO算法的流程图如下图所示：2.2.2 OPT算法的流程图如下图所示：3.源程序的主要部分3.1 程序中要到的全局变量说明#define M 40//最大的访问页面序列数目int N;//内存页面块数3.2 结构体说明struct Pro{int num;//num 记录页面序列号};3.3主函数说明及注释void main(){ cin>>N;// 请输入可用内存物理块数:";Pro p[M];//最大的访问页面序列数目Pro *page=new Pro[N];char c;int m=0,t=0;float n=0;int fifoout[M];//记录FIFO算法淘汰的页面int optout[M];//记录OPT算法淘汰的页面int f=0,o=0;m=Input(m,p);//m返回输入的访问页面总书目do{for(int i=0;i<N;i++){page[i].num=0;//初试化内存页面}i=0;cout<<"****请选择页面置换的(f代表FIFO,o代表OPT)****策略"<<endl;cout<<"f:FIFO页面置换"<<endl;cout<<"o:OPT页面置换"<<endl;cout<<"其他键退出"<<endl;cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"******FIFO页面置换算法运行结果如下:******"<<endl;cout<<"FIFO页面置换情况为: "<<endl;while(i<m)//i为当前页面在输入序列中的位置{if(Search(p[i].num,page)>=0)//判断当前输入页面p[i].num 是否已经在内存中,若在则返回其在内存页面块中的位置{i++;//找到相同的页面}else{if(t==N)//N为内存页面数目，t记录是那个页面最先进入内存页面，用来判断内存页面块是否已满t=0;else{n++;//记录缺页次数fifoout[f]=page[t].num;//记录淘汰页面f++;page[t].num=p[i].num;//换入print(page);//输出当前内存页面分配情况t++;}}}cout<<"采用FIFO算法时依次淘汰的页面为：";for(i=0;i<f;i++)//输出淘汰页面号{if(fifoout[i]==0)continue;elsecout<<fifoout[i]<<" ";}cout<<"采用FIFO算法时的缺页次数为："<<n<<endl;cout<<"采用FIFO算法时的缺页率为: "<<(double)n/m<<endl;}if(c=='o')//OPT算法页面置换情况{n=0;cout<<"******OPT页面置换算法运行结果如下:******"<<endl;cout<<"OPT页面置换情况为: "<<endl;int count=0;while(i<m)//i为当前页面在输入序列中的位置{if(Search(p[i].num,page)>=0)//判断当前输入页面p[i].num 是否已经在内存中,若在则返回其在内存页面块中的位置{i++;}else{count++;if(count<=N)//判断内存页面是否有空空闲页面{page[count-1].num=p[i].num;//进入空闲内存n++;print(page);continue;}int temp=0,cn;for(t=0;t<N;t++)//t记录是那个页面最先进入内存页面{if(temp<Compfu(page,i,t,p))//在以后不回访问内存{temp=Compfu(page,i,t,p);cn=t;}}optout[o]=page[cn].num;//输出淘汰页面o++;page[cn].num=p[i].num;//页面置换n++;print(page);i++;}}cout<<"采用OPT算法时依次淘汰的页面为：";for(i=0;i<o;i++){if(optout[i]==0)continue;elsecout<<optout[i]<<" ";}cout<<"采用OPT算法时的缺页次数为："<<n<<endl;cout<<"采用OPT算法时的缺页率："<<(double)n/m<<endl;}else{exit;}}while(c=='f'||c=='o');}3.4输入函数Input(int m,Pro p[M])int Input(int m,Pro p[M]){ cout<<"请输入访问页面目数：";do{cin>>m;//访问页面数目if(m>M)cout<<"数目太多，请重试"<<endl;elsebreak;}while(1);cout<<"请输入访问页面号序列:";for(int i=0;i<m;i++){cin>>p[i].num;//依次输入页面访问顺序}return m;//返回输入的访问页面总数目}3.5输出函数print(Pro *page1)void print(Pro *page1)//输出当前内存块中的访问页面{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)cout<<page[i].num<<" ";cout<<endl;}3.6 Search(int e,Pro *page1 ) 函数int Search(int e,Pro *page1 )// 用于查找当前页面是否已在内存块中{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)if(e==page[i].num)return i;//返回页面号为e的页面在那个内存页面中return -1;//若不在则返回-1}3.7 Compfu(Pro *page1,int i,int t,Pro p[M]) 函数int Compfu(Pro *page1,int i,int t,Pro p[M])//i为当前页面在输入序列中的位置，t记录页面进入内存的顺序,此函数判断内存快中的页面page[t]在后续访问序列中出现的次数{Pro *page=new Pro[N];page=page1;int count=0;//记录当前页面的未来访问的次数for(int j=i;j<M;j++)//{if(page[t].num==p[j].num )break;//页面已经在内存中else count++;}return count;//返回当前页面在未来还要出现的次数}4、测试用例，运行结果与运行情况分析4.1测试用例设计4.1.1用例1设计：内存物理块数：N=3页面引用序列中总页面个数为：m=12页面引用序列为：4、3、2、1、4、3、5、4、3、2、1、54.1.2用例2设计：内存物理块数：N=4页面引用序列中总页面个数为：m=15页面引用序列为：3、7、4、8、3、1、6、7、8、3、1、2、9、3、5 4.2运行结果及运行情况分析4.2.1测试用例1运行结果如下：4.2.1.1 FIFO算法的运行结果：缺页率＝缺页次数/ 总访问次数＝9 / 12＝75%依次淘汰的页面号为：4、3、2、1、4、34.2.1.2 OPT算法的运行结果为：缺页率＝缺页次数/ 总访问次数＝7 / 12＝58.33%依次淘汰的页面号为：2、1、4、24.2.2测试用例2运行结果如下：4.2.2.1 FIFO算法运行结果如下：缺页率＝缺页次数/ 总访问次数＝12/ 15＝80%依次淘汰的页面号为：3、7、4、8、1、6、7、3 4.2.2.2 OPT算法运行结果缺页率＝缺页次数/ 总访问次数＝10/ 15＝66.67%以此淘汰的页面号为：4、1、7、4、2、35、自我评价与总结本周我们进行了《操作系统》的课程设计，在拿到题目以后便着手准备，通过查阅课本和相关的资料，对本次课程设计要实现的功能有了深刻的了解，在此基础上写起实验代码变得心应手。
页面调度算法实验报告
页面调度算法实验报告引言页面调度算法是操作系统中的重要概念之一，主要用于管理操作系统中的虚拟内存。
虚拟内存是指通过硬盘空间来扩展系统的可用内存空间，将一部分数据放在内存中，将另一部分数据放在硬盘上。
为了高效地管理虚拟内存，需要使用合适的页面调度算法。
在本次实验中，我们将实现三种页面调度算法：先进先出（FIFO），最近最久未使用（LRU），和时钟（Clock）算法。
通过对这些算法的实现和比较，我们将能够更好地理解页面调度算法的原理和效果。
算法介绍1. 先进先出（FIFO）算法：该算法是最简单的页面调度算法之一。
它按照页面进入内存的先后顺序决定删除哪个页面，即最早进入内存的页面被删除。
该算法不考虑页面的使用频率和重要性。
2. 最近最久未使用（LRU）算法：该算法是一种根据页面的使用历史来进行页面调度的算法。
它假设最近一段时间内最久未使用的页面很可能在未来也不会被使用，因此将这些页面优先删除。
3. 时钟（Clock）算法：该算法是一种综合了FIFO算法和LRU算法的页面调度算法。
它使用一个环形链表来存储页面，并使用一个指针指向当前时钟。
当发生页面调度时，指针按照顺时针方向移动，并检查每个页面的访问位。
如果访问位为0，则说明该页面最近未被使用，可以删除；如果访问位为1，则将访问位置为0，表示该页面最近被使用。
实验设计本次实验中，我们将使用python语言实现上述三种页面调度算法，并通过相同的测试数据对它们进行性能比较。
环境配置在开始实验之前，需要安装Python 3.0及以上版本，并确保环境配置正确。
测试数据我们将使用一个虚拟内存大小为4个页面的系统来测试算法的性能。
假设系统会访问一个包含10个页面的访问序列。
访问序列：1, 2, 3, 4, 5, 1, 2, 6, 7, 8实验步骤1. 实现FIFO算法，并对测试数据进行页面调度。
2. 实现LRU算法，并对测试数据进行页面调度。
3. 实现时钟算法，并对测试数据进行页面调度。
模拟分页式存储管理中硬件的地址转换和缺页中断2
模拟分页式存储管理中硬件的地址转换和产生缺页中断分页式虚拟存储系统是把作业信息的副本存放在磁盘上，当作业被选中时，可把作业的开始几页先装入主存且启动执行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存。
作业执行时，指令中的逻辑地址指出了参加运算的操作存放的页号和单元号，硬件的地址转换机构按页号查页表，若该页对应标志为“1”，则表示该页已在主存，这时根据关系式“绝对地址=块号×块长+单元号”计算出欲访问的主存单元地址。
如果块长为2 的幂次，则可把块号作为高地址部分，把单元号作为低地址部分，两者拼接而成绝对地址。
若访问的页对应标志为“0”，则表示该页不在主存，这时硬件发“缺页中断”信号，有操作系统按该页在磁盘上的位置，把该页信息从磁盘读出装入主存后再重新执行这条指令。
设计一个“地址转换”程序来模拟硬件的地址转换工作。
当访问的页在主存时，则形成绝对地址，但不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行。
当访问的页不在主存时，则输出“* 该页页号”，表示产生了一次缺页中断。
①定义相关数据结构如下typedef struct{int address; //进程的逻辑地址int meaddress; //进程的物理地址int page; //进程所在页号int add; //进程的位移量}arccell,AdjMatrix[MAX];typedef struct{char vex[MAX]; //进程名AdjMatrix arcs; //指向进程地址的数组int vexnum; //进程总数}Pro;typedef struct{int page; //页号int block; //块号int status; //该页是否在内存的状态位}pa_cell,pa_matrix[MAX];typedef struct{pa_matrix ptab; //指向页表相关信息的数组}pa_tab;②定义必要函数：void create_ptable(pa_tab & pa) //创建页表void exchange(Pro & P,pa_tab & pa) //地址转换函数③具体实验代码：#include<iostream.h>#define MAX 64#define eachpage 1024 // eachpage为每页(每块大小)int m; //m为简化后的页表行数typedef struct{int address; //进程的逻辑地址int meaddress; //进程的物理地址int page; //进程所在页号int add; //进程的位移量}arccell,AdjMatrix[MAX];typedef struct{char vex[MAX]; //进程名AdjMatrix arcs; //指向进程地址的数组int vexnum; //进程总数}Pro;void Create_pro(Pro & P)//创建进程{int i;cout<<"请输入进程总数：";cin>>P.vexnum;cout<<"请输入各进程名：";for(i=0;i<P.vexnum;i++)cin>>P.vex[i];cout<<"请输入各进程地址: ";for(i=0;i<P.vexnum;i++)cin>>P.arcs[i].address;for(i=0;i<P.vexnum;i++){P.arcs[i].page=P.arcs[i].address/eachpage;P.arcs[i].add=P.arcs[i].address%eachpage; // 逻辑地址=页号*页大小+位移量}}void print(Pro & P) //输出进程的相关信息{cout<<"各进程的页号页内地址为："<<endl;for(int i=0;i<P.vexnum;i++)cout<<"进程名"<<P.vex[i]<<" 页号"<<P.arcs[i].page<<" 页内地址"<<P.arcs[i].add<<endl;cout<<endl;}//-------------页表的结构体-----------------typedef struct{int page; //页号int block; //块号int status; //该页是否在内存的状态位(为1表示在内存，为0表示不在内存)}pa_cell,pa_matrix[MAX];typedef struct{pa_matrix ptab; //指向页表相关信息的数组}pa_tab;void create_ptable(pa_tab & pa) //创建页表{int a,b,c;cin>>m; //输入页表行数cout<<"请输入页表相关信息："<<endl;for(int i=0;i<m;i++){cin>>a>>b>>c;pa.ptab[i].page=a;pa.ptab[i].block=b;pa.ptab[i].status=c; //依次输入每行的页表信息}}//--------------地址转换函数-----------------void exchange(Pro & P,pa_tab & pa){for(int i=0;i<P.vexnum;i++)for(int j=0;j<m;j++)if(pa.ptab[j].page==P.arcs[i].page) //查询到页表里相对应的页号{if(pa.ptab[j].status==1) //若进程访问的页状态位为1，输出该进程物理地址{P.arcs[i].meaddress=pa.ptab[j].block*eachpage+P.arcs[i].address;//物理地址=块号*块大小+位移量cout<<"第"<<i+1<<"个进程物理地址为: "<<P.arcs[i].meaddress<<endl;}else //若访问的页状态位为0,表示该页不在主存,发生“缺页中断”信号cout<<"第"<<i+1<<"个进程地址转换发生缺页中断!"<<endl;}}void main(){Pro P;Create_pro(P); //创建进程cout<<endl;print(P);pa_tab pa;cout<<"由于页表信息太大，为了简化运算，请输入想输入的页表行数: ";create_ptable(pa); //创建页表exchange(P,pa); //调度地址转换函数}。
计算机操作系统实验_源码_模拟请求分页虚拟存储管理中的硬件地址变换过程[技巧]
![计算机操作系统实验_源码_模拟请求分页虚拟存储管理中的硬件地址变换过程[技巧]](https://img.taocdn.com/s3/m/d47a4d5c4afe04a1b071dee2.png)
地址变换算法框图如图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;
页式虚拟存储管理FIFO、LRU和OPT页面置换算法
目录1 需求分析 (2)目的和要求 (2)研究内容 (2)2 概要设计 (2)2．1 FIFO算法 (3)2．2 LRU算法 (3)2．3 OPT算法 (3)2．4 输入新的页面引用串 (3)3 详细设计 (4)3．1 FIFO（先进先出）页面置换算法： (4)3．2 LRU（最近最久未使用）置换算法： (4)3．3 OPT（最优页）置换算法 (4)4 测试 (5)5 运行结果 (5)6 课程设计总结 (10)7 参考文献 (10)8 附录：源程序清单 (10)1 需求分析目的和要求在熟练掌握计算机虚拟存储技术的原理的基础上，利用一种程序设计语言模拟实现几种置换算法，一方面加深对原理的理解，另一方面提高学生通过编程根据已有原理解决实际问题的能力，为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。
研究内容模拟实现页式虚拟存储管理的三种页面置换算法（FIFO(先进先出)、LRU（最近最久未使用）和OPT（最长时间不使用）），并通过比较性能得出结论。
前提：（1）页面分配采用固定分配局部置换。
（2）作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。
2 概要设计本程序主要划分为4个功能模块，分别是应用FIFO算法、应用LRU算法、应用OPT算法和页面引用串的插入。
各模块之间的结构图2．1 FIFO 算法该模块的主要功能是对相应页面引用串进行处理，输出经过FIFO 算法处理之后的结果。
2．2 LRU 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过LRU 算法处理之后的结果。
2．3 OPT 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过OPT 算法处理之后的结果。
2．4 输入新的页面引用串该模块的主要功能是用户自己输入新的页面引用串，系统默认的字符串是0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0，用户可以自定义全新的20个数字页面引用串。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断
1．内容：模拟请求页式存储管理中硬件的地址转换和缺页中断处理
2．思想：
装入新页置换旧页时，若旧页在执行中没有被修改过，则不必将该页重写磁盘。
因此，页表中增加是否修改过的标志，执行“存”指令和“写”指令时将对应的修改标志置成“1”
3．要求及方法：
①设计一个地址转换程序来模拟硬件的地址转换和缺页中断。
当访问的页在主存时则形成绝对地址，但不去模拟指令的执行，可以输出转换后的绝对地址来表示一条指令已执行完成。
当访问的页不在主存中时，则输出“*页号”来表示硬件产生了一次缺页中断。
模拟地址转换流程见图1。
②编制一个FIFO页面调度程序；FIFO页面调度算法总是先调出作业中最先进入主存中的哪一页。
因此可以用一个数组来表示（或构成）页号队列。
数组中每个元素是该作业已在主存中的页面号，假定分配给作业的页架数为m，且该作业开始的m页已装入主存，则数组可由m个元素构成。
P[0]，P[1]，P[2]，…，P[m-1]
它们的初值为P[0]：=0，P[1]：=1，P[2]：=2，…，P[m-1]：=m-1
用一指针K指示当要调入新页时应调出的页在数组中的位置，K的初值为“0”，当产生缺页中断后，操作系统总是选择P[K]所指出的页面调出，然后执行：
P[K]：=要装入的新页页号
K：=(k+1)mod m
在实验中不必实际地启动磁盘执行调出一页和装入一页的工作，而用输出“OUT调出的页号”和“IN要装入的新页页号”来模拟一次调出和装入过程，模拟程序的流程图见附图1。
按流程控制过程如下：
提示：输入指令的页号和页内偏移和是否存指令⎩⎨
⎧
0 1非存指令存指令，若d 为-1则结束，否则进
入流程控制过程，得P 1和d ，查表在主存时，绝对地址=P 1×1024+d
③ 假定主存中页架大小为1024个字节，现有一个共7页的作业，其副本已在磁盘上。
系统为该作业分配了4个页架，且该作业的第0页至第3页已装入内存，其余3页未装入主
依次执行上述指令调试你所设计的程序（仅模拟指令的执行，不考虑序列中具体操作的执行）。
④ 为进一步考察程序的执行，可自行确定若干组指令，运行程序，核对执行结果。
4．书写实验报告：
① 实验题目；
② 程序中所用的数据结构及说明； ③ 源程序并附上必要的说明；
④ 按照指令的执行序列，打印输出结果：绝对地址或调出、调入的页号。
图1 模拟算法流程。