实验五：页面调度算法模拟实验报告
页面调度算法模拟实验中遇到的问题
页面调度算法模拟实验中遇到的问题在页面调度算法模拟实验中，可能会遇到以下一些问题：
1、算法选择问题：不同的页面调度算法有不同的优势和适用场景，如FIFO、LRU、OPT等。
在实验中，选择合适的算法是一个挑战。
可能需要考虑内存大小、访问模式、页面访问频率等因素，以确定使用哪种算法进行模拟实验。
2、数据集选择问题：在模拟实验中，需要使用真实或合成的数据集来模拟页面访问的情况。
选择合适的数据集是一个关键问题，需要考虑数据集的规模、访问模式的真实性以及数据集的可用性等因素。
3、实验结果的评估问题：页面调度算法的性能可以通过不同的指标进行评估，如缺页率、命中率、平均访问时间等。
在实验中，选择合适的评估指标以及评估方法是一个重要问题。
4、实验参数的设置问题：在模拟实验中，还需要考虑一些参数的设置，如内存大小、页面大小、进程数量等。
这些参数的选择可能会对实验结果产生影响，需要合理设置以保证实验的可靠性和有效性。
5、实验结果的可视化问题：实验结果的可视化是一个重要的环节，可以通过图表、曲线等形式展示实验结果，以便于对比不同算法的性能表现。
在实验中，实现合适的可视化方式可能会遇到一些技术上的挑战。
这些问题都需要在实验前进行充分的准备和规划，以确保实验的
可靠性和有效性。
同时，也需要注意实验过程中可能遇到的其他问题，并及时进行调整和解决。
操作系统-实验五-进程调度与算法模拟-实验报告
计算机与信息工程学院实验报告一、实验内容设计一个按优先数调度算法实现处理器调度的程序。
(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪8080”状态和“结束”状态。
五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
本实验由于为了检查的方便，优先数和运行时间采用下表中的数值。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程，用指针指出队列的连接情况。
例：队首标志K1K2K3K4K5(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。
在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统实验5 进程调度模拟程序设计
一、实验内容进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）或者时间片轮转法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
等待I/O的时间以时间片为单位进行计算，可随机产生，也可事先指定。
每个进程的状态可以是就绪R（Ready）、运行R（Run）、等待（Wait）或完成F（Finish）四种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、等待进程以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
用C或C++二、实验目的与要求在采用多道程序设计的设计中的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度工作。
三、实验环境Visual+C++6.0四、实验步骤1、实验准备知识处理器调度总是选对首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本次实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数—1要求运行时间—1来模拟进程的一次运行。
进程运行一次后，若要求运行时间≠0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间≠0，则把它的状态修改成“结束”，且结束队列。
操作系统实验报告——调度算法
操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。
2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。
3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。
在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。
在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。
实验五 Linux页面调度
可见，最高命中率已经由原来的0.9000增加到0.9500。
经过多组实验，我发现当分配页面增加时，最高命中率下降；反之，最高命中率增加。但遇到的问题是始终未找到合适的分配方式使命中率可以达到1，希望老师能给出指导意见。
3）五种算法中，最少访问页面算法较其他四种命中率较低；
4）随着页面序号的上升，五种算法的命中率趋于一致；
5）我认为由于此次实验用到了随机函数，所以要得到更科学合理的结果，应进行多次实验取平均值。
4、关于思考题：要求修改程序，分析各算法在用户内存容量达到多大时命中率为1。经过思考，我发现需要对页数进行修改，从而达到修改页地址流长度的目的，进而改变各算法命中率：
实验报告
姓名
学号
专业班级
课程名称
操作系统实验
实验日期
成绩
指导教师
批改日期
实验名称
实验五Linux页面调度
一、实验目的：
1、理解虚拟存储管理技术的管理原理和特点
2、掌握基本的内存管理知识，能够实时查看内存、回收内存3、掌握请求也是存储管理页面调度算法二、实验要求：
Time参数为页面在内存中的时间;
经过对代码中各种页面置换算法的分析，我得到如下流程图：
三、实验内容与步骤：
1、用free命令健康内存使用情况
2、用vmstat命令件事虚拟内存的使用情况
3、经过对mm_test.c的编译与运行后，我对产生的结果进行了分析，表格如下：
经分析我得出一下几点结论：
1）五种算法在页面序号升高的情况下，命中率也基本呈上升趋势；
2）五种算法中，最佳淘汰算法较其他四种有较高的命中率；
调度的调度算法实验报告
调度的调度算法实验报告调度的调度算法实验报告引言：调度是计算机科学中一个重要的概念，它涉及到任务分配、资源管理和优化等方面。
调度算法则是实现调度的关键，它决定了任务的执行顺序和资源的分配方式。
在本次实验中，我们将探讨几种常见的调度算法，并通过实验对其性能进行评估和比较。
一、先来先服务算法（FCFS）先来先服务算法是最简单的调度算法之一，它按照任务到达的先后顺序进行处理。
实验中，我们模拟了一个任务队列，每个任务有不同的执行时间。
通过实验结果可以看出，FCFS算法的优点是简单易懂，但当任务的执行时间差异较大时，会导致平均等待时间较长。
二、最短作业优先算法（SJF）最短作业优先算法是一种非抢占式调度算法，它根据任务的执行时间来进行排序。
实验中，我们将任务按照执行时间从短到长进行排序，并进行调度。
实验结果显示，SJF算法的优点是能够最大程度地减少平均等待时间，但当任务的执行时间无法预测时，该算法可能会导致长任务等待时间过长的问题。
三、时间片轮转算法（RR）时间片轮转算法是一种抢占式调度算法，它将任务分为多个时间片，并按照顺序进行调度。
实验中，我们设置了每个时间片的长度，并将任务按照到达顺序进行调度。
实验结果表明，RR算法的优点是能够公平地分配资源，但当任务的执行时间超过一个时间片时，会导致上下文切换频繁，影响系统的性能。
四、最高响应比优先算法（HRRN）最高响应比优先算法是一种动态调度算法，它根据任务的等待时间和执行时间来计算响应比，并选择响应比最高的任务进行调度。
实验中，我们根据任务的到达时间、执行时间和等待时间计算响应比，并进行调度。
实验结果显示，HRRN算法能够在一定程度上平衡长任务和短任务的等待时间，但当任务的执行时间过长时，会导致其他任务的等待时间过长。
五、多级反馈队列算法（MFQ）多级反馈队列算法是一种综合性的调度算法，它将任务分为多个队列，并根据任务的执行情况进行调度。
实验中，我们设置了多个队列，并根据任务的执行时间和等待时间进行调度。
页面调度实验报告
一、实验内容（1）页面调度算法目前有许多页面调度算法，本实验主要涉及先进先出调度算法、最近最少调度算法、最近最不常用调度算法。
本实验使用页面调度算法时作如下假设，进程在创建时由操作系统为之分配一个固定数目物理页，执行过程中物理页的数目和位置不会改变。
也即进程进行页面调度时只能在分到的几个物理页中进行。
下面对各调度算法的思想作一介绍。
<1> 先进先出调度算法先进先出调度算法根据页面进入内存的时间先后选择淘汰页面，先进入内存的页面先淘汰，后进入内存的后淘汰。
本算法实现时需要将页面按进入内存的时间先后组成一个队列，每次调度队首页面予以淘汰。
<2>最近最少调度算法先进先出调度算法没有考虑页面的使用情况，大多数情况下性能不佳。
根据程序执行的局部性特点，程序一旦访问了某些代码和数据，则在一段时间内会经常访问他们，因此最近最少用调度在选择淘汰页面时会考虑页面最近的使用，总是选择在最近一段时间以来最少使用的页面予以淘汰。
算法实现时需要为每个页面设置数据结构记录页面自上次访问以来所经历的时间。
<3>最近最不常用调度算法由于程序设计中经常使用循环结构，根据程序执行的局部性特点，可以设想在一段时间内经常被访问的代码和数据在将来也会经常被访问，显然这样的页面不应该被淘汰。
最近最不常用调度算法总是根据一段时间内页面的访问次数来选择淘汰页面，每次淘汰访问次数最少的页面。
算法实现时需要为每个页面设置计数器，记录访问次数。
计数器由硬件或操作系统自动定时清零。
（2）缺页调度次数和缺页中断率、缺页置换率计算缺页中断次数是缺页时发出缺页中断的次数。
缺页中断率=缺页中断次数/总的页面引用次数*100%缺页调度次数是调入新页时需要进行页面调度的次数缺页置换率=缺页调度次数/总的页面引用次数*100%二、总体设计1、算法的原理说明FIFO 先进先出调度算法：当页面框满时，最早进来的页面调出；LRU 最近最少使用调度算法：当页面框满时，最近最少使用的页面调出LFU 最近最不常用调度算法：当页面框满时，最近最不常用的页面调出SECOND 二次机会调度算法：当页面框满时，页面调入时R=0，当被访问时R = 1。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《计算机操作系统》实验报告实验五：页面调度算法模拟学校：╳╳╳院系：╳╳╳班级：╳╳╳姓名：╳╳╳学号：╳╳╳指导教师：╳╳╳目录一、实验题目 (3)二、实验学时 (3)三、指导老师 (4)四、实验日期 (4)五、实验目的 (4)六、实验原理 (4)6.1页面的含义 (4)6.2 页面置换算法的含义 (4)6.3 置换算法 (4)6.3.1最佳置换算法(Optimal) (4)6.3.2先进先出(FIFO)页面置换算法 (5)6.3.3 LRU置换算法 (5)七、实验步骤及结果 (5)7.1 验证最佳置换算法 (5)7.1.1 实验截图 (5)7.1.2 实验分析 (5)7.2 验证先进先出(FIFO)页面置换算法 (6)7.2.1 实验截图 (6)7.2.2 实验分析 (6)7.3 验证LRU置换算法 (7)7.3.1 实验截图 (7)7.3.2 实验分析 (8)八、报告书写人 (8)附录一最佳置换算法(Optimal) (9)附录二先进先出(FIFO)页面置换算法 (14)附录三 LRU置换算法 (18)实验五：页面调度算法模拟一、实验题目页面调度算法模拟二、实验学时2学时三、指导老师╳╳╳四、实验日期2018年12月10日星期一五、实验目的(1)熟悉操作系统页面调度算法(2)编写程序模拟先进先出、LRU等页面调度算法，体会页面调度算法原理六、实验原理6.1页面的含义分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。
6.2 页面置换算法的含义在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。
但应将哪个页面调出，须根据一定的算法来确定。
通常，把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。
6.3 置换算法一个好的页面置换算法，应具有较低的页面更换频率。
从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。
6.3.1最佳置换算法(Optimal)它是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，便可以利用此算法来评价其它算法。
6.3.2先进先出(FIFO)页面置换算法这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
6.3.3 LRU置换算法LRU置换算法是选择最近最久未使用的页面予以淘汰。
七、实验步骤及结果7.1 验证最佳置换算法7.1.1 实验截图7.1.2 实验分析in 7 2 7 7 1 0 4 4 0 8 0 4 b1 7 7 7 7 4 4b2 2 2 2 2 8b3 1 1 1 1b4 0 0 0out 7 27.2 验证先进先出(FIFO)页面置换算法7.2.1 实验截图7.2.2 实验分析7.3 验证LRU置换算法7.3.1 实验截图7.3.2 实验分析in 9 6 8 7 7 3 7 1 2 6 7 0b1 9 9 9 9 3 3 3 6 6 b2 6 6 6 6 1 1 1 0 b3 8 8 8 8 2 2 2 b4 7 7 7 7 7 7out 9 6 8 3 1八、报告书写人╳╳╳附录一最佳置换算法(Optimal)#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 12 /*随机数列的长度*/#define B 4 /*内存页面数*/int IsInBuf(int buf[],int list[],int num){int i,j=-1;int max_p;int max_d=0;for(i=0;i<B;i++){if(buf[i]==list[num]) //当x在buf中，返回-1return -1;else if(buf[i]==-1) //当x不在buf中，且buf[i]为空，则把x 填入buf，并返回-1{buf[i]=list[num];return -2;}}for(i=0;i<B;i++){for(j=num+1;j<N;j++){if(buf[i]==list[j]){if(max_d<j){max_d=j;//buf[i]在list[]中的最近距离max_p=i;//list[j]在buf[]的位置}break;}}if(j==N) //如果buf满，并且buf[i]不在list[]的后半部分，返回位置ireturn i;}return max_p;//返回距离最远的buf[]的位置}int main(){int list[N];//={4,3,2,1,4,3,5,4,3,2,1,5};int buf[B],i,f[N],j,m,bufuse=0,tmp;int change=0; //置换次数int interrupt=0; //中断次数int successfully=0; //访问成功次数srand((int)time(NULL));for(i=0;i<B;i++)buf[i]=f[i]=-1;printf("\n\n");printf("The Optimal List:");for(i=0;i<N;i++){list[i]=(int) rand()%10;printf("%2d",list[i]);}printf("\n");printf("\nthe lost in Optimal:\n");for(i=0;i<N;i++){j=IsInBuf(buf,list,i);if(j==-1){successfully++;for(m=0;m<=B;m++){printf(" "); /*成功的打印*/}printf(" in<--%d successfully\n",list[i]);/*成功的打印*/}else if(j==-2){bufuse++;interrupt++;printf("newbuf=");for(m=0;m<bufuse;m++){printf("%d ",buf[m]); /*缺页中断次数的打印*/}for(m;m<B;m++){printf(" "); /*缺页中断的打印*/}printf(" in<--%d interrupt\n",list[i]);/*缺页中断的打印*/}else{tmp=buf[j];buf[j]=list[i];change++;printf("newbuf=");for(m=0;m<bufuse;m++){printf("%d ",buf[m]); /*缺页置换的打印*/}for(m;m<B;m++){printf(" ");/*缺页置换的打印*/}printf(" in<--%d change %d-->out\n",list[i],tmp);/*缺页置换的打印*/}}printf("\n\n");printf("interrupt=%d\n",interrupt);printf("change=%d\n",change);printf("successfully=%d\n",successfully);return 0;}附录二先进先出(FIFO)页面置换算法#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 12 /*随机数列的长度*/#define B 4 /*内存页面数*/int IsInBuf(int buf[],int x){int i;for(i=0;i<B;i++){if(buf[i]==x) /*当x在buf中，返回其位置*/return -1;else if(buf[i]==-1) /*当x不在buf中，且buf[i]为空，则把x填入buf，并返回其位置*/{buf[i]=x;return -2;}}return 0;}int main(){int list[N];//={4,3,2,1,4,3,5,4,3,2,1,5};int buf[B],i,f[N],j,m,bufuse=0,tmp;int old=0;int change=0; //置换次数int interrupt=0; //中断次数int successfully=0; //访问成功次数srand((int)time(NULL));for(i=0;i<B;i++)buf[i]=f[i]=-1;printf("\n\n");printf("The FIFO List:");for(i=0;i<N;i++){list[i]=(int) rand()%10;printf("%2d",list[i]);}printf("\n");printf("\nthe lost in FIFO:\n");for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){successfully++;for(m=0;m<=B;m++){printf(" "); /*成功的打印*/ }printf(" in<--%d successfully\n",list[i]);/*成功的打印*/}else if(j==-2){bufuse++;interrupt++;printf("newbuf=");for(m=0;m<bufuse;m++){printf("%d ",buf[m]); /*缺页中断次数的打印*/}for(m;m<B;m++){printf(" "); /*缺页中断的打印*/}printf(" in<--%d interrupt\n",list[i]);/*缺页中断的打印*/}else{tmp=buf[old];buf[old]=list[i];old=(old+1)%(int)B; /*数据在ｂｕｆ中的储存是循环的*/change++;printf("newbuf=");for(m=0;m<bufuse;m++){printf("%d ",buf[m]); /*缺页置换的打印*/}for(m;m<B;m++){printf(" ");/*缺页置换的打印*/}printf(" in<--%d change %d-->out\n",list[i],tmp);/*缺页置换的打印*/}}printf("\n\n");printf("interrupt=%d\n",interrupt);printf("change=%d\n",change);printf("successfully=%d\n",successfully);return 0;}附录三 LRU置换算法#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 12 /*随机数列的长度*/#define B 4 /*内存页面数*/int IsInBuf(int buf[],int list[],int num){int i,j=-1;for(i=0;i<B;i++){if(buf[i]==list[num]) /*当x在buf中，返回其位置*/{j=i;break;}else if(buf[i]==-1) /*当x不在buf中，且buf[i]为空，则把x填入buf，并返回其位置*/{buf[i]=list[num];j=-2;break;}}return j;}int Get(int buf[],int list[],int num){int buff[B];int buffuse=0;int i,j,k,m;for(m=0;m<B;m++)buff[m]=-1;for(i=num-1;i>=0;i--){for(j=0;j<B;j++){if(list[i]==buf[j]){for(k=0;k<buffuse;k++){if(list[i]==buff[k])break;}if(k==buffuse){buff[buffuse]=list[i];buffuse++;if(buffuse==B)return j;}break;}}}return 0;}int main(){int list[N];//int list[12]=int buf[B],i,f[N],j,m,bufuse=0,tmp;int old=0;int change=0;int interrupt=0;int successfully=0;srand((int)time(NULL));for(i=0;i<B;i++)buf[i]=f[i]=-1;printf("The Random List:");for(i=0;i<N;i++){list[i]=(int) rand()%10;printf("%2d",list[i]);}printf("\n\n");printf("\nthe lost in LRU:\n");change=0; /*中断的次数*/for(i=0;i<N;i++){j=IsInBuf(buf,list,i);if(j==-1){old=Get(buf,list,i);tmp=buf[old];buf[old]=list[i];change++;printf("newbuf=");for(m=0;m<bufuse;m++){printf("%d ",buf[m]); /*缺页置换的打印*/ }for(m;m<B;m++){printf(" ");/*缺页置换的打印*/}printf(" in<--%d change %d-->out\n",list[i],tmp);/*缺页置换的打印*/}else if(j==-2){bufuse++;interrupt++;printf("newbuf=");for(m=0;m<bufuse;m++){printf("%d ",buf[m]); /*缺页中断次数的打印*/}for(m;m<B;m++){printf(" "); /*缺页中断的打印*/}printf(" in<--%d interrupt\n",list[i]);/*缺页中断的打印*/}else{successfully++;for(m=0;m<=B;m++){printf(" "); /*成功的打印*/}printf(" in<--%d successfully\n",list[i]);/*成功的打印*/}}printf("\n\n");printf("interrupt=%d\n",interrupt);printf("change=%d\n",change);printf("successfully=%d\n",successfully);return 0;}。