页面置换算法程序代码
页面置换算法模拟程序课程设计报告
****学院计算机科学系课程设计报告设计名称：软件课程设计设计题目：页面置换算法模拟程序学生学号：****专业班级：学生姓名：学生成绩：指导教师（职称）：课题工作时间：2010.5.31至2010.6.11说明：1、报告中的任务书、进度表由指导教师在课程设计开始前填写并发给每个学生；四、五两项（中英文摘要）由学生在完成综合设计后填写。
2、学生成绩由指导教师根据学生的设计情况给出各项分值及总评成绩。
3、指导教师评语一栏由指导教师就学生在整个设计期间的平时表现、设计完成情况、报告的质量及答辩情况，给出客观、全面的评价。
4、所有学生必须参加课程设计的答辩环节，凡不参加答辩者，其成绩一律按不及格处理。
答辩小组成员应由2人及以上教师组成。
5、报告正文字数一般应不少于3000字，也可由指导教师根据本门综合设计的情况另行规定。
6、平时表现成绩低于6分的学生，取消答辩资格，其本项综合设计成绩按不及格处理。
计算机科学系课程设计任务书王渊博哈夫曼编码的另一种实现算法[J] 安徽教育学院学报2009(6)严蔚敏.吴伟民数据结构[M] 高等教育2004指导教师：系主任：日期：2010 年 5 月 28 日计算机科学系课程设计进度安排表指导教师签名：2010年5 月 28 日指导教师评语答辩记录表成绩评定表学生姓名：学号：班级：摘要操作系统（英语；Operating System，简称OS）是一管理电脑硬件与软件资源的程序，同时也是计算机系统的内核与基石。
操作系统身负诸如管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本事务。
操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源;控制程序运行;改善人机界面;为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。
操作系统是一个庞大的管理控制程序，大致包括5个方面的管理功能:进程与处理机管理、作业管理、存储管理、设备管理、文件管理。
页面置换常用的算法总结
页⾯置换常⽤的算法总结本⽂转载⾃：进程运⾏时，若其访问的页⾯不在内存⽽需将其调⼊，但内存已⽆空闲空间时，就需要从内存中调出⼀页程序或数据，送⼊磁盘的对换区。
选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的，因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串：7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时，先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时，产⽣缺页中断，根据最佳置换算法，选择第18次访问才需调⼊的页⾯7予以淘汰。
然后，访问页⾯0时，因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推，如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到，发⽣缺页中断的次数为9，页⾯置换的次数为6。
访问页⾯70120304230321201701物理块1777222227物理块200004000物理块31133311缺页否√√ √√√√√√√图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。
该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现FIFO、LRU和Clock算法。
二、实验原理页面置换算法是操作系统中用到的一种算法，其作用是在内存不够用时，选择牺牲已经在内存中的一些页，腾出更多的空间给新的内容。
本次实验主要实现了FIFO、LRU和Clock算法。
1、FIFO算法FIFO算法是最简单的页面置换算法，它采用先进先出的原则，即最先进入内存的页面应该最早被替换出去。
该算法的实现非常简单，只需要维护一个队列即可。
当需要置换页面时，选择队列的第一个页面进行替换即可。
2、LRU算法LRU算法是Least Recently Used的缩写，即最近最少使用算法。
该算法的核心思想是选择最久没有被使用的页面进行替换。
为了实现该算法，需要维护记录页面使用时间的链表、栈或队列等结构。
3、Clock算法Clock算法也叫做二次机会算法，是一种改良的FIFO算法。
它是基于FIFO算法的思想，并且每个页面都设置了一个使用位（use bit），用于记录该页面是否被使用过。
当需要置换一个页面时，检查该页面的使用位，如果该页面的使用位为1，则将该页面的使用位设置为0并移到队列的末尾，表示该页面有“二次机会”继续待在内存中；如果该页面的使用位为0，则选择该页面进行替换。
三、实验过程本次实验采用Python语言实现页面置换算法，并使用样例进行测试。
1、FIFO算法实现FIFO算法的实现非常简单，只需要用一个队列来维护已经在内存中的页面，当需要置换页面时，选择队列的第一个元素即可。
代码如下：```pythonfrom collections import dequeclass FIFO:def __init__(self, frame_num):self.frame_num = frame_numself.frames = deque(maxlen=frame_num)def access(self, page):if page in self.frames:return Falseif len(self.frames) >= self.frame_num:self.frames.popleft()self.frames.append(page)return True```2、LRU算法实现LRU算法的实现需要维护一个记录页面使用时间的链表或队列。
最佳页面置换算法
最佳页面置换算法(Optimal)（非常专业）评价一个算法的优劣,可通过在一个特定的存储访问序列（页面走向）上运行它，并计算缺页数量来实现。
1 先入先出法（FIFO）最简单的页面置换算法是先入先出（FIFO）法。
这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。
理由是：最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。
建立一个FIFO队列，收容所有在内存中的页。
被置换页面总是在队列头上进行。
当一个页面被放入内存时，就把它插在队尾上。
这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不高。
因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。
FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。
当然，导致这种异常现象的页面走向实际上是很少见的。
现在来看下4块的情况：0 1 2 3 2 1 3 2 5 2 3 6 2 1 4 2【解答】刚开始内存并没有这个作业，所以发生缺页中断一次。
作业的0号页进入内存。
(1次缺页中断)而页1又不在内存，又发生缺页中断一次。
作业页1进入内存。
(2次缺页中断) 页2不在内存，发生缺页中断。
页2进入内存。
(3次缺页中断)页3不在内存，发生缺页中断。
页3进入内存。
(4次缺页中断)接下来调入页2，页1，页3，页2。
由于都在内存中，并不发生缺页中断。
页5不在内存，发生缺页中断。
页5进入内存，页5置换页0。
(5次缺页中断) 接下来调入页2，页3。
由于都在内存中，并不发生缺页中断。
页6不在内存，发生缺页中断。
页6进入内存。
页6置换页1。
(6次缺页中断) 页2在内存，不发生缺页中断。
页1不在内存(在发生第6次缺页中断时被置换了)，发生缺页中断。
页1进入内存，页2被置换。
(7次缺页中断)页4置换页3，页4进入内存。
(8次缺页中断)现在调入页2，但页2在发生第7次缺页中断时被置换掉了。
页面置换算法
图 FIFO算法的Belady现象
FIFO陷阱现象示例
3个页面 123412512345 111444555555 22211111333 3332222244 9次缺页 9/12=75%
4个页面 123412512345
111111555544 22222211115 3333332222 444444333
1-随机淘汰算法
随机淘汰算法。在系统设计人员认为无法确定哪 些页被访问的概率较低时，随机地选择某个用户 的页面并将其换出将是一种明智的作法。
2-最佳页面置换(OPT)算法
7 最0 佳1 置2 换0算3法0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7 7其2所选择2 的被2 淘汰2页面，将是2以后永不再7 用
7这列样前7 ，头7当的2要页进顺行次2置换换出2 时，4，而4只把需换4 把入0置的换页指链针接0所在指F0IF的OF队I7F尾O7队即 7
可。0 0 0
333222
11 100
缺点：1a. 1算法与1进0程的0 实0际运3 行3规律不相3适应2 ，因2为进2 程1 页框中这存(的些利物某页用理些面率块页不不) 面被高经淘。常汰被。先访b进. 问由先，实出但验置先和换进测算先试法出发置现换FI算FO法算不法能的保内证
页面置换算法
置换算法的前提:若需访问的页面不在内存而需将 其调入，且内存中没有空闲页面，需从内存中调 出一页程序或数据。 目的:选出一个被淘汰的页面。 把选择换出页面的算法称为页面置换算法。 置换算法的好坏直接影响系统的性能。一个好的 置换算法应具有较低的页面更换频率。从理论上 讲，应将那些以后不会再访问的页面换出，或者 把那些在较长时间内不会再访问的页面换出。
10 次缺页
页面置换算法
页⾯置换算法 页⾯置换算法根据置换页⾯的选择范围分为局部页⾯置换算法和全局页⾯置换算法。
局部页⾯置换算法只置换本进程内的物理页⾯，进程中⼀个页⾯进内存，就代表⼀个页⾯已经被替换出内存，所以⼀个进程所占⽤的物理页⾯的总数是确定的。
全局页⾯置换算法置换内存中所有可换出的物理页⾯，即换进内存的是进程A的页⾯，换出内存的可能是进程B的页⾯，所以进程在内存中占⽤的页⾯总数是可变的。
⼀、局部页⾯置换算法： 1.最优页⾯置换算法： 预测未来最晚被使⽤的页⾯，然后把它置换到外存中去。
缺页最少，但⽆法实现，只是⼀种理想状态，所以作为其他置换算法的评测标准。
2.先进先出算法 有⼀个逻辑页⾯的链表，链表头在内存中呆的时间最长，链表尾最短，所以每次置换都是把链表头的页⾯置换到外存中去，把新加进来的页⾯放到链表尾。
这个算法虽然简单，但是造成的缺页率⽐较⾼，性能⽐较差。
3.最近最久未使⽤算法/最近最少使⽤算法 替换内存中上次被引⽤时间最早的⼀个页⾯。
可以⽤链表或栈来记录按被引⽤时间长短排序的页⾯，但不管是栈还是链表，每次替换都会牵扯到整个链表或栈的移动，算法性能⽐较好，但开销⽐较⼤。
4.时钟算法 ⽤环形链表存储各页⾯。
初始化时各页⾯的访问位为0。
如果不缺页，则把相应页⾯的访问位设置为1。
如果缺页，则从最先进⼊链表的页⾯开始遍历，遇到访问位为1的页⾯，则访问位设置为0；遇到访问位为0的页⾯，则把它替换到外存中去，然后把需要的页⾯替换进内存，且访问位为1。
然后把当前指针移到下⼀个页⾯上，再进⾏下⼀次页⾯请求处理。
⽐FIFO多了个访问位来记录页⾯的访问情况，但⽐LRU少了访问的先后顺序，所以说是FIFO和LRU的折中。
5.改进的时钟算法 在页⾯中增加了修改位，1为修改过，0为未修改过。
因为当发⽣缺页中断时，把未修改过的页⾯替换进外存就相当于把页⾯直接从内存中删除，因为内存和外存中所对应的该页⾯的内容相同，处理时间只有⼀次缺页中断访问外存的时间。
页面置换算法实验报告
操作系统课程设计报告课程名称：操作系统课程设计课程设计题目：页面置换算法学院：计算机科学与技术学院专业：科技小组成员: 庞思慧E01114081王蒙E01114161姚慧乔E01114349朱潮潮E01114408指导老师：***目录1 实验目的 (3)2 实验要求 (3)3 实验内容与步骤 (3)4 算法思想 (4)5 模块设计 (4)6 程序设计 (5)7 测试结果 (7)8 结果分析 (9)9 程序代码 (9)10 课程设计小结 (24)页面置换算法模拟设计1.实验目的（1）通过模拟实现几种基本页面置换的算法，了解虚拟存储技术的特点。
（2）掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想，并至少用三种算法来模拟实现。
（3）通过对几种置换算法命中率的比较，来对比他们的优缺点。
2.实验要求计算并输出下述各种算法在不同内存容量下的命中率。
A 先进先出的算法（FIFO）B 最近最少使用算法（LRU）C最佳淘汰算法（OPT）3.实验内容与步骤(1)通过随机数产生一个指令序列，共320条指令，具体的实施方法是：A．[0，319]的指令地址之间随机选取一起点M;B．顺序执行一条指令，即执行地址为M+1的指令；C．在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’;D．顺序执行一条指令，其地址为M’+1；E．在后地址[M’+2，319]中随机选取一条指令并执行；F．重复A—E，直到执行320次指令。
(2)指令序列变换成页地址流A.页面大小为1K；B.用户内存容量为4页到32页；C.用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条—第9条指令为第0页（对应虚存地址为[0，9]）；第10条—第19条指令为第1页（对应虚存地址为[10，19]）；。
第310条—第319条指令为第31页（对应虚存地址为[310，319]）；(3)计算并输出上述各种算法在不同内存容量下的命中率。
lru页面置换算法实验c语言总结
LRU页面置换算法实验C语言总结1.引言在计算机科学中，页面置换算法是解决主存容量有限的情况下，如何有效地管理页面（或称为内存块）的一种重要方法。
L RU（L ea st Re ce nt ly Us e d）页面置换算法是其中一种经典的策略，通过淘汰最久未使用的页面来提高内存的利用率。
本文将总结使用C语言实现L RU页面置换算法的相关实验。
2.算法原理L R U页面置换算法的核心思想是：最近被访问的页面可能在未来继续被访问，而最久未被使用的页面可能在未来也不再被访问。
基于这一思想，L R U算法维护一个页面访问的时间顺序链表，每次发生页面置换时，选择链表头部（即最久未使用）的页面进行淘汰。
3.实验设计本次实验旨在使用C语言实现LR U页面置换算法，并通过模拟页面访问的过程来验证算法的正确性。
具体设计如下：3.1数据结构为了实现LR U算法，我们需要定义几个关键的数据结构：3.1.1页面节点结构t y pe de fs tr uc tP age{i n tp ag eI D;//页面I Ds t ru ct Pa ge*n ex t;//下一个节点指针s t ru ct Pa ge*p re v;//上一个节点指针}P ag e;3.1.2内存块结构t y pe de fs tr uc tM emo r y{i n tc ap ac it y;//内存块容量i n ts iz e;//当前存储的页面数量P a ge*h ea d;//内存块链表头指针P a ge*t ai l;//内存块链表尾指针}M em or y;3.2实验步骤本次实验主要包括以下几个步骤：3.2.1初始化内存块根据实际需求，设置内存块的容量，并初始化链表头指针和尾指针。
3.2.2页面置换每次发生页面访问时，检查访问的页面是否已经在内存块中。
如果在，将该页面移动到链表尾部；如果不在，执行页面置换。
3.2.3页面淘汰当内存块已满时，选择链表头部的页面进行淘汰，将新访问的页面加入链表尾部。
操作系统-1-存储管理之LFU页面置换算法（leetcode460）
操作系统-1-存储管理之LFU页⾯置换算法（leetcode460）LFU缓存题⽬：请你为最不经常使⽤（LFU）缓存算法设计并实现数据结构。
它应该⽀持以下操作：get 和 put。
get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。
put(key, value) - 如果键不存在，请设置或插⼊值。
当缓存达到其容量时，则应该在插⼊新项之前，使最不经常使⽤的项⽆效。
在此问题中，当存在平局（即两个或更多个键具有相同使⽤频率）时，应该去除最近最少使⽤的键。
「项的使⽤次数」就是⾃插⼊该项以来对其调⽤ get 和 put 函数的次数之和。
使⽤次数会在对应项被移除后置为 0 。
⽰例： LFUCache cache = new LFUCache( 2 /* capacity (缓存容量) */ ); cache.put(1, 1); cache.put(2, 2); cache.get(1); // 返回 1 cache.put(3, 3); // 去除 key 2 cache.get(2); // 返回 -1 (未找到key 2) cache.get(3); // 返回 3 cache.put(4, 4); // 去除 key 1 cache.get(1); // 返回 -1 (未找到 key 1) cache.get(3); // 返回 3 cache.get(4); // 返回 4代码：1class LFUCache {23public LFUCache(int capacity) {45 }67public int get(int key) {89 }1011public void put(int key, int value) {1213 }14 }1516/**17 * Your LFUCache object will be instantiated and called as such:18 * LFUCache obj = new LFUCache(capacity);19 * int param_1 = obj.get(key);20 * obj.put(key,value);21*/LFU页⾯置换算法(最不经常使⽤算法) 原理： 选择到当前时间为⽌被访问次数最少的页⾯被置换； 每页设置访问计数器，每当页⾯被访问时，该页⾯的访问计数器加1； 发⽣缺页中断时，淘汰计数值最⼩的页⾯，并将所有计数清零； 如图：图中的页⾯为三页，依次向存储中加⼊432143543215这些数字。
【操作系统】页面置换算法（最佳置换算法）（C语言实现）
【操作系统】页⾯置换算法（最佳置换算法）（C语⾔实现）【操作系统】页⾯置换算法（最佳置换算法）（C语⾔实现）（编码⽔平较菜，写博客也只是为了个⼈知识的总结和督促⾃⼰学习，如果有错误，希望可以指出）1.页⾯置换算法：在地址映射过程中，若在页⾯中发现所要访问的页⾯不在内存中，则产⽣缺页中断。
当发⽣缺页中断时，如果操作系统内存中没有空闲页⾯，则操作系统必须在内存选择⼀个页⾯将其移出内存，以便为即将调⼊的页⾯让出空间。
⽽⽤来选择淘汰哪⼀页的规则叫做页⾯置换算法。
⼀个好的页⾯置换算法，应具有较低的页⾯更换频率。
从理论上讲，应该保留最近重复访问的页⾯，将以后都不再访问或者很长时间内不再访问的页⾯调出。
----百度百科2.具体的页⾯置换算法：2.1 最佳置换算法：⼀个进程在内存的若⼲个页⾯中，哪⼀个页⾯是未来最长时间内不再被访问的，那么如果发⽣缺页中断时，就将该页⾯换出，以便存放后⾯调⼊内存中的页⾯。
1.这是计算机操作系统（第四版）中的⼀个例⼦。
系统⾸先为进程分配了三个物理块。
上⾯⼀排数字是作业号。
在转满三个物理块后，要访问2号作业，2号作业不在内存，所以会发⽣缺页中断，然后系统需要将2号作业调⼊内存，但是此时物理块已经装满。
2.依据最佳置换算法，会将7号页换出（0号页在2号页后第1个就会被访问，1号页在2号页后第10个会被访问，7号页在2号页后第14个会被访问，7号页在已经装⼊内存的作业中是未来最长时间不会被访问的，所以换出7号页）。
3.后⾯依次类推。
2.2 先进先出算法：如果发⽣缺页中断，需要换出⼀个页⾯的时候，总是选择最早进⼊内存的页⾯，即选择在内存中驻留时间最久的页⾯进⾏换出。
有点不清楚。
就是每次发⽣缺页就将最早进⼊内存的页⾯换出，然后将刚调⼊的页⾯换⼊该物理块。
2.3 最近最久未使⽤（LRU）置换算法：LRU算法是缺页中断发⽣时选择最久未使⽤的页⾯进⾏换出。
这个算法其实也很好判断。
分享⼀个⼩技巧。
内存分配了k个物理块，发⽣缺页中断将要往内存调⼊某个页⾯的时候，在该页⾯往前⾯数K个物理块最前⾯的那个就会是要换出的，因为该页⾯最长时间未被使⽤过。
操作系统程序设计(编程描述页面置换算法——先进先出算法 )
nRunTime=runtime;//运行时间（运行步数）
PageTable=new page[nPageCountLogicalSpace];//根据实际需要创建页表
public page[] PageTable=new page[200];
public void InitProcess(int no,int pagetotal,int runtime)
{
nControlNo=no;
}
//模拟成功信息提示
private void hua(int x ,int y,Color n)
{
Graphics h = this.CreateGraphics(); //创建画布
Brush g = new SolidBrush(n);//创建画刷
sf.Alignment = StringAlignment.Near;
//设置字体格式
Brush g =new SolidBrush(n);
Graphics h = this.groupBox1.CreateGraphics(); //创建画布
g.Dispose();
}
//在groupbox1指定位置着色
private void sc()
{
StringFormat sf = new StringFormat();
h.DrawString(s, new Font(new FontFamily("黑体"), 8), g, x, y, sf);
}
//以groupBox1为画板指定坐标
页面置换算法模拟程序-附代码
目录1．问题的提出 (2)1.1关于页面置换算法模拟程序问题的产生 (2)1.2任务分析 (2)2．需求分析 (2)3．方案设计 (3)4．总体设计 (4)4.1程序N-S图 (4)4.2主要的函数 (4)4.3主要流程图及代码 (5)4.3.1 FIFO（先进先出） (5)4.3.2 LRU（最近最久未使用） (6)4.3.3 OPT（最佳置换算法） (8)4.4实现结果 (11)5．程序测试 (14)5.1设计测试数据 (14)5.2测试结果及分析 (15)摘要随着计算机的普及人们的物质生活得到了极大的满足，人们在精神生活方面同样也需要提高，所以越来越多的人进行着各种各样的学习。
操作系统是计算机教学中最重要的环节之一，也是计算机专业学生的一门重要的专业课程。
操作系统质量的好坏，直接影响整个计算机系统的性能和用户对计算机的使用。
一个精心设计的操作系统能极扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理，容比较繁琐，具有很强的实践性。
要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果.本课程设计是学生学习完《操作系统教程》课程后，进行的一次全面的综合训练，通过课程设计，让学生更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
熟悉页面置换算法及其实现，引入计算机系统性能评价方法的概念。
关键词：编制页面置换算法模拟程序、打印页面、FIFO页面算法、LRU页面置换算法、OPT页面置换算法。
引言1．问题的提出1.1关于页面置换算法模拟程序问题的产生在各种存储器管理方式中，有一个共同的特点，即它们都要求将一个作业全部装入存方能运行，但是有两种情况：（1）有的作业很大，不能全部装入存，致使作业无法运行；（2）有大量作业要求运行，但存容量不足以容纳所有这些作业。
而虚拟存技术正式从逻辑上扩充存容量，将会解决以上两个问题。
页面置换算法实验报告实验心得
页面置换算法实验报告实验心得
一、实验背景
页面置换算法是操作系统中的一个重要概念，是内存管理机制的核心内容之一。
页面置换算法是为了解决内存有限的问题，通过将不常用的页面换出，腾出空间给新的页面使用。
页面置换算法有多种，如LRU、FIFO、Clock等。
本次实验主要研究这几种置换算法的实现原理并通过编程实现。
二、实验过程
本次实验首先通过查阅相关资料了解了LRU、FIFO、Clock等页面置换算法的实现原理。
在了解了原理之后，我们通过使用Python语言编写程序来模拟这些算法的实现。
实验中，我们首先编写了一段程序来生成一个不同大小的访问页面序列，并将生成的页面序列分别输入到LRU、FIFO、Clock算法的模拟程序中，观察算法的置换效果，并通过比较不同算法的置换效果来评估各个算法的优劣。
三、实验结果
通过实验，我们观察到在不同的访问页面序列下，各个算法的置换效果都有所不同。
在某些情况下，FIFO算法的置换效果最好，而在
其他情况下，LRU算法的置换效果最佳。
同时，在一些场景下，Clock算法的置换效果也不错。
这说明不同的页面置换算法对于不同的内存使用情况有着不同的适用性。
四、实验心得
通过本次实验，我们深入了解了页面置换算法的实现原理，并通过编程实现了这些算法。
通过实验，我们发现在不同的场景下，不同的页面置换算法的效果会有所不同。
因此，在实际应用中，我们需要考虑内存使用情况，选择最适合的页面置换算法来提高内存利用率和程序性能。
同时，通过这次实验，我们也了解了Python编程的基本语法和常用库的使用方法，对我们的编程能力有了一定的提高。
页面置换算法 实验报告
综合性实验报告一、实验目的1.学习常见的4种页面置换算法：最佳置换算法（OPT），先进先出页面置换算法（FIFO），最近最久未使用页面算法（LRU），最少使用置换算法（LFU）。
2.编写函数并计算输出上述各种算法的命中率。
二、总体设计（设计原理、设计方案及流程等）设计原理：OPT页面置换算法OPT所选择被淘汰的页面是已调入内存，且在以后永不使用的，或是在最长时间内不再被访问的页面。
因此如何找出这样的页面是该算法的关键。
可为每个页面设置一个步长变量，其初值为一足够大的数，对于不在内存的页面，将其值重置为零，对于位于内存的页面，其值重置为当前访问页面与之后首次出现该页面时两者之间的距离，因此该值越大表示该页是在最长时间内不再被访问的页面，可以选择其作为换出页面。
FIFO页面置换算法FIFO总是选择最先进入内存的页面予以淘汰，因此可设置一个先进先出的忙页帧队列，新调入内存的页面挂在该队列的尾部，而当无空闲页帧时，可从该队列首部取下一个页帧作为空闲页帧，进而调入所需页面。
LRU页面置换算法LRU是根据页面调入内存后的使用情况进行决策的，它利用“最近的过去”作为“最近的将来”的近似，选择最近最久未使用的页面予以淘汰。
该算法主要借助于页面结构中的访问时间time来实现，time记录了一个页面上次的访问时间，因此，当须淘汰一个页面时，选择处于内存的页面中其time值最小的页面，即最近最久未使用的页面予以淘汰。
LFU页面置换算法LFU要求为每个页面配置一个计数器（即页面结构中的counter），一旦某页被访问，则将其计数器的值加1，在需要选择一页置换时，则将选择其计数器值最小的页面，即内存中访问次数最少的页面进行淘汰。
设计流程：1.通过随机数产生一个指令序列，共320条指令。
2.指令序列变换成页地址流3.计算并输出下述各种算法在不同内存容量下的命中率。
4.在主函数中生成要求的指令序列，并将其转换成页地址流；在不同的内存容量下调用上述函数使其计算并输出相应的命中率。
操作系统实验(四)实验报告--虚拟内存
操作系统实验(四)实验报告--虚拟内存操作系统实验（四）虚拟内存1、实验题目页面置换算法模拟——OPT、FIFO和LRU算法2、实验目的了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法，如最佳（Optimal）置换算法、先进先出（Fisrt In First Out）置换算法和最近最久未使用（Least Recently Used）置换算法3、实验内容1）OPT算法：需要发生页面置换时，算法总是选择在将来最不可能访问的页面进行置换。
2）FIFO算法：算法总是选择在队列中等待时间最长的页面进行置换。
3）LRU算法：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，那么，在最近未来是不大可能被访问的。
4、程序代码#include<iostream>#include <cstdlib>#include <time.h>#include <cstdio>#define L 30///页面走向长度最大为30using namespace std;int M=4; ///内存块struct P///定义一个结构体{int num,time;}p[30];int Input(int m,P p[L])///打印页面走向状态{m=30;int i,j;j=time(NULL);///取时钟时间srand(j);///以时钟时间x为种子，初始化随机数发生器cout<<"页面走向: ";for(i=0; i<m; i++){p[i].num=rand( )%10;///产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;return m;}void print(P *page1)///打印当前的页面{P *page=new P[M];page=page1;for(int i=0; i<M; i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,P *page1 )///寻找内存块中与e相同的块号{P *page=new P[M];page=page1;for(int i=0; i<M; i++)if(e==page[i].num)return i; ///返回i值return -1;}int Max(P *page1)///寻找最近最长未使用的页面用于OPT算法{P *page=new P[M];page=page1;int e=page[0].time,i=0;while(i<M) ///找出离现在时间最长的页面{if(e<page[i].time) e=page[i].time;i++;}for( i=0; i<M; i++)if(e==page[i].time)return i; ///找到离现在时间最长的页面返回其块号return -1;}int Count(P *page1,int i,int t,P p[L])///记录当前内存块中页面离下次使用间隔长度用于OPT算法{P *page=new P[M];page=page1;int count=0;for(int j=i; j<L; j++){if(page[t].num==p[j].num )break;///当前页面再次被访问时循环结束else count++;///否则count+1}return count;///返回count的值}int main(){int c=1;int m=0,t=0;float n=0;///缺页次数m=Input(m,p);///调用input函数，返回m值M=4;P *page=new P[M];///dowhile(c==1||c==2||c==3){int i=0;for(i=0; i<M; i++) ///初试化页面基本情况{page[i].num=0;page[i].time=m-1-i;}cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"3:OPT页面置换"<<endl;cout<<"按其它键结束程序；"<<endl;cin>>c;if(c==1)///FIFO页面置换///FIFO();{n=0;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0) ///当前页面在内存中{cout<<p[i].num<<" "; ///输出当前页p[i].numcout<<" "<<endl;i++; ///i加1}else ///当前页不在内存中{if(t==M)t=0;else{n++; ///缺页次数加1page[t].num=p[i].num; ///把当前页面放入内存中cout<<p[i].num<<" ";print(page); ///打印当前页面t++; //下一个内存块i++; ///指向下一个页面}}}cout<<"缺页次数："<<n<<" 缺页率："<<n<<"/"<<m<<" ="<<n/m<<endl;}if(c==2)///LRU页面置换,最近最久未使用{n=0;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){int a;t=Search(p[i].num,page);if(t>=0)///如果已在内存块中{page[t].time=0;///把与它相同的内存块的时间置0for(a=0; a<M; a++)if(a!=t)page[a].time++;///其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else ///如果不在内存块中{n++; ///缺页次数加1t=Max(page); ///返回最近最久未使用的块号赋值给tpage[t].num=p[i].num; ///进行替换page[t].time=0; ///替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0; a<M; a++)if(a!=t)page[a].time++; ///其它的时间加1}i++;}cout<<"缺页次数："<<n<<" 缺页率："<<n<<"/"<<m<<" = "<<n/m<<endl;}if(c==3)///OPT页面置换{n=0;cout<<" OPT算法置换情况如下:"<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0)///如果已在内存块中{cout<<p[i].num<<" ";cout<<" "<<endl;i++;}else///如果不在内存块中{int a=0;for(t=0; t<M; t++)if(page[t].num==0)a++;///记录空的内存块数if(a!=0) ///有空内存块{int q=M;for(t=0; t<M; t++)if(page[t].num==0&&q>t)q=t;///把空内存块中块号最小的找出来page[q].num=p[i].num;///把缺页换过来n++; ///缺页次数加一cout<<p[i].num<<" ";print(page);i++;}else{int temp=0,s;for(t=0; t<M; t++) ///寻找内存块中下次使用离现在最久的页面if(temp<Count(page,i,t,p)){temp=Count(page,i,t,p);s=t;}///把找到的块号赋给spage[s].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}}}cout<<"缺页次数："<<n<<" 缺页率："<<n<<"/"<<m<<" = "<<n/m<<endl;}}///while(c==1||c==2||c==3);return 0;}5、心得体会通过该实验，是我对虚拟内存更加了解，对最佳置换算法、先进先出算法、最近最久算法更加了解。
操作系统之页面置换算法（最佳置换OPT，先进先出FIFO，最近最久未使用LRU）
操作系统之页⾯置换算法（最佳置换OPT，先进先出FIFO，最近最久未使⽤LRU）最近学习操作系统时，实验要求实现常见的三种页⾯置换算法，博主按照书上要求试着编写，实现了案例，并记录在博客随记中，以便后续⾃⼰复习并也给需要的同学分享参考⼀下!⽔平有限，若有错，请悄悄告诉博主！博主好⽴即改正。
最佳置换算法（optimal replacement，OPT）是从内存中选择今后不再访问的页⾯或者在最长⼀段时间后才需要访问的页⾯进⾏淘汰。
如下例⼦：根据页⾯⾛向依次处理，得到最终的置换结果如下图表，整个页⾯缺页次数为7，缺页率为7/12=58%。
1 #include <iostream>2 #include <stdio.h>3 #include <stdlib.h>4#define N 125#define B 36using namespace std;78int pageArr[N]={1,2,3,4,1,2,5,1,2,3,4,5};//页⾯⾛向9int block[B]={0};//物理块3个，其数值是页号10 typedef struct FLAG {11int flags[B];12int counts;13 } FLAG;1415void opt(int pageArr[],int block[]);16int inBlock(int which);17int findFar(int next);18void Replace(int index,int value);19void disPlay();2021int main(void){22 cout << "begin:" <<endl;23 opt(pageArr,block);24 cout << "end!" <<endl;25return0;26 }2728void opt(int pageArr[],int block[]){29int getIndex;30for(int i=0;i<N;i++){31if(i<3){//前3页号#短缺#进队列32 block[i]=pageArr[i];33 printf("缺页：(null)-->%d\n",pageArr[i]);34 }35else {36if(i==3){37 disPlay();3839 }40if(inBlock(pageArr[i])!=-1){//下⼀个页⾯if在物理块中返回index并跳过,反-141 disPlay();4243continue;44 }45 getIndex=findFar(i+1);//从下⼀个页号，找到最远出现的页⾯,替换的下标46if(getIndex==-1){47 cout<<"error,not replace obj!"<<'\t';48 }49else{50 Replace(getIndex,pageArr[i]);//由下标找到上⼀组替换⽬标，⽤第⼆参数替换51 disPlay();5253 }54 }55 }56return;57 }5859//替换block中的物理块60void Replace(int index,int value){61 printf("缺页：%d--被替换为-->%d\n",block[index],value);62 block[index]=value;63return;64 }656667//找到最远出现的页⾯68int findFar(int next){69int index=-1;//error，默认返回不存在的索引70 FLAG myflag;71 myflag.flags[0]=0;72 myflag.flags[1]=0;73 myflag.flags[2]=0;74 myflag.counts=0;75int stop = N-next;76while(stop--){77 index=inBlock(pageArr[next++]);78if(index!=-1){79 myflag.flags[index]=1;80 myflag.counts++;83break;84 }85 }86for(index=0;index<B;index++){87if(myflag.flags[index]==0)88break;89 }90return index;91 }929394//下⼀个页⾯if在物理块中返回index,反-195int inBlock(int which){96//int i=0;97//while(i<B)98// if(block[i++]==which)99// return i-1;100for(int i=0;i<B;i++){101if(block[i]==which)102return i;103 }104return -1;105 }106107//打印⼀元组108void disPlay(){109int i=0;110while(i<B){111 printf("%d\t",block[i++]);112 }113 printf("\n");114return;115 }上⾯是博主使⽤C++（基本是C语法）编写的代码，运⾏结果如下：//////////////////////////////////////////////////////////////////////////begin:缺页：(null)-->1缺页：(null)-->2缺页：(null)-->31 2 3缺页：3--被替换为-->41 2 41 2 41 2 4缺页：4--被替换为-->51 2 51 2 51 2 5缺页：1--被替换为-->33 2 5缺页：3--被替换为-->44 2 54 2 5end!//////////////////////////////////////////////////////////////////////////先进先出算法：先进先出置换算法（first in first out,FIFO）是淘汰最先进⼊内存的页⾯，即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
时钟页面置换算法
时钟页⾯置换算法⼀、局部：时钟置换算法：1.最优置换算法：理论上的，预测最晚调⽤的页⾯。
2.LRU算法，置换掉最久未使⽤的。
⼀个链表。
⼀个页⾯被调⽤的话，会被从链表中（它原本的位置）移动到链表⾸，⽽每次缺页，则会将链表尾部元素置换。
3.FIFO算法，置换掉在内存中时间最长的。
（性能低 同是⼀个链表，每次缺页置换最早进⼊页⾯（时间排序）链⾸的。
新页⾯放在链表尾部。
4.clock 算法， 环形链表，不再排序⽽是使⽤2个标记，0和1， 第⼀个次加载页⾯的时候，页⾯标记被设置为0，调⽤内存中驻留的页⾯时，标记该页⾯为1， 出现缺页时，指针从当前位置循环查找环形链表，如果遇到标记为1的，标记为0，如果遇到标记为0的，置换它。
5.最不常⽤算法 标记不再是0和1，每次调⽤，标记值+1，缺页时，置换标记值最⼩的页⾯ 优化版本：定期减⼩数字clock 算法虽然不能像LRU（least recently used）算法⼀样精确的记录访问顺序，但是，开销较⼩。
改进版的clock 算法，只在访问同⼀个页⾯的时候，做写回操作，在缺页的时候，会跳过已经被改变的。
下⾯是⼀个⼩练习function clock(load){//假设同时可以加载的数⽬let workRow =3; //储存标记位let m = new Map(); //当前加载的let res=[]; //当前加载的index，workRow个let pointer = 0;//初始化for(var i=0;i<load.length;i++){if( res.length<workRow && !m.has(load[i]) ){//如果没满，初始化res.push(load[i])//设置为1m.set(load[i],0);//如果满了，⽽且需要加载的就在⾥⾯（重复）不⽤再加载}else if(m.has(load[i])){console.log('loaded what has been there',load[i]) m.set(load[i],1)}else{//缺页异常，需要置换loading(load[i],i)console.log(load[i] , res)}}function loading(task,idx){let wait = true;//检查当前指针，如果是1，标记为0，如果找到为0的，扔掉，其余移动向下，把要加载的，加载进来，设置为1，结束while(wait){pointer = idx%(workRow-1)if(m.get(res[pointer])==1){m.set(res[pointer],0)}else if(m.get(res[pointer])==0){m.delete(res[pointer])res[pointer]=taskm.set(task,1)wait = false; }pointer++;}} //内存中最后的内容return res;}clock(['a','b','b','d','b','e','c','d','e'])⼆、全局：置换算法1.尽量不更改常驻集⼤⼩的（假设⼯作集⼤⼩趋于稳定），⼯作集置换算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
//最近最少使用调度算法（LRU）
void LRU()
{
int absence=0;
int i,j;
int flag;
cout<<endl<<"----------------------------------------------------"<<endl;
pages[i].hit=0;
}
}
//读入页访问流
void readData()
{
FILE *fp;
char fname[20];
int i;
cout<<"请输入页面流文件名:";
cin>>fname;
if((fp=fopen(fname,"r"))==NULL)
{
//缺页处理
if(absence>=MAXQUEUE)
{cout<<pages[0].loaded<<" "; }// pages[0]是队列头
for(j=0;j<MAXQUEUE-1;j++)
{
pages[j]=pages[j+1];
}
pages[MAXQUEUE-1].loaded=queue[i];
{
cout<<"错误,文件打不开,请检查文件名";
}
else
{
while(!feof(fp))
{
fscanf(fp,"%d ",&queue[quantity]);
quantity++;
}
}
cout<<"读入的页访问流:";
cout<<"先进先出调度算法(FIFO)页面调出流:";
for(i=0;i<quantity;i++)
{ flag=0;
for(j=0;j<MAXQUEUE;j++)
{
if(pages[j].loaded==queue[i])
{ flag=1; }
}
}
void main()
{
versபைடு நூலகம்on();
initial();
readData();
FIFO();
init();
LRU();
}
if(flag==0)
{
if(absence>=MAXQUEUE)
{ cout<<pages[p].loaded<<" "; }
pages[p].loaded=queue[i];
p=(p+1)%MAXQUEUE;
absence++;
}
}
cout<<endl<<"总缺页数:"<<absence<<endl;
absence++; }
else
{
//页面已载入
pages[quantity]=pages[flag];
for(j=flag;j<MAXQUEUE-1;j++)
{
pages[j]=pages[j+1];
}
pages[MAXQUEUE-1]=pages[quantity];
#include<stdio.h>
#include<string.h>
#include<iostream.h>
const int MAXSIZE=1000;//定义页访问流的最大长度
const int MAXQUEUE=3;//定义可用页面数
typedef struct node
{ int loaded; int hit;
}page;
page pages[MAXQUEUE]; //定义页面表
int queue[MAXSIZE];
int quantity;
//初始化结构函数
void initial()
{
int i;
for(i=0;i<MAXQUEUE;i++)
{
pages[i].loaded=-1;
pages[i].hit=0; }
for(i=0;i<MAXSIZE;i++)
{
queue[i]=-1;
}
quantity=0;
}
//初始化页面函数
void init()
{
int i;
for(i=0;i<MAXQUEUE;i++)
{
pages[i].loaded=-1;
for(i=0;i<quantity;i++)
{
cout<<queue[i]<<" ";
}
}
//FIFO调度算法
void FIFO()
{
int i,j,p,flag;
int absence=0;
p=0;
cout<<endl<<"----------------------------------------------------"<<endl;
}
}
cout<<endl<<"总缺页数:"<<absence<<endl;
}
//显示
void version()
{
cout<<" /*******************虚拟存储管理器的页面调度****************/"<<endl;
cout<<endl;
cout<<"最近最少使用调度算法(LRU)页面调出流:";
for(i=0;i<quantity;i++)
{ flag=-1;
for(j=0;j<MAXQUEUE;j++)
{
if(queue[i]==pages[j].loaded)
{ flag=j; }
}
if(flag==-1)