页面淘汰算法实验报告概述
lru页面淘汰算法
lru页面淘汰算法摘要：1.LRU 页面淘汰算法的定义2.LRU 页面淘汰算法的工作原理3.LRU 页面淘汰算法的优缺点4.LRU 页面淘汰算法的应用实例正文：一、LRU 页面淘汰算法的定义LRU（Least Recently Used，最近最少使用）页面淘汰算法是一种常用的内存管理策略，主要用于虚拟内存和页面替换算法中。
当内存中的页面数量不足以容纳新的页面时，LRU 算法会根据页面的使用频率来选择一个或多个页面进行替换，从而为新页面腾出空间。
二、LRU 页面淘汰算法的工作原理LRU 算法的核心思想是，将最近最少使用的页面替换出去。
具体来说，LRU 算法会维护一个页面访问顺序列表，每次访问一个页面时，将该页面在列表中的位置移动到列表的头部。
当需要进行页面替换时，LRU 算法会从列表的头部开始查找，找到第一个在访问顺序中位于尾部的页面进行替换。
三、LRU 页面淘汰算法的优缺点1.优点：LRU 算法能有效地反映页面的使用频率，将最近最少使用的页面替换出去，从而提高内存的利用率。
同时，LRU 算法实现简单，无需额外的数据结构支持。
2.缺点：LRU 算法对于某些页面访问模式可能存在一定的不公平性，例如访问顺序固定的页面序列。
此外，在页面访问顺序发生逆转时，LRU 算法可能会产生较多的页面替换。
四、LRU 页面淘汰算法的应用实例LRU 算法广泛应用于操作系统、数据库管理系统、浏览器缓存等领域。
例如，在操作系统中，LRU 算法可以用于虚拟内存的页面替换，从而提高内存的利用率；在数据库管理系统中，LRU 算法可以用于缓存策略，提高查询效率；在浏览器缓存中，LRU 算法可以用于页面缓存策略，提高网页加载速度。
总结：LRU 页面淘汰算法是一种简单有效的内存管理策略，能够根据页面的使用频率进行页面替换，提高内存的利用率。
页面置换算法实验报告
页面置换算法实验报告
一、实验内容
本次实验主要围绕页面置换算法进行，以实验课本的实例介绍，采用FIFO页面置换算法对后面提到的参数进行置换，最终得出页面置换的结果和比较所得结果。
二、实验步骤
(一) 熟悉FIFO算法
首先是要了解FIFO页面置换算法，FIFO全称（First In First Out），按页面进入内存的顺序来替换相应内存页面，先进先出，将先进入内存的页面先替换出去。
(二) 阅读实验课本
在阅读实验课本之前要先熟悉实验书上所介绍的FIFO算法，然后在实验书上找出需要做的实验，并对实验环境和表格进行观察，掌握实验的基本内容。
(三) 开始页面置换
在开始实验之前，熟悉实验环境，根据实验书上的参数，首先模拟进程分配内存，根据FIFO算法去进行计算，根据上表中的参数去比较，最后得出最终结果。
(四) 在本次实验的补充
这次实验中，可以把FIFO的概念应用到实际应用中，也可以模拟不同情况，例如改变页面的大小，观察不同页面置换算法的结果，实验出最合适的结果。
三、实验结论
本次实验是为了了解FIFO页面置换算法，实验出最终的结果，最后得出页面置换的结果及比较结果。
操作系统fifo算法模拟实验总结
FIFO算法模拟实验总结操作系统中的页面置换算法是为了有效管理计算机内存空间而设计的。
FIFO （First-In, First-Out）是最简单和最常见的页面置换算法之一。
通过对FIFO算法进行模拟实验，我们可以更好地理解其工作原理，评估其性能，并进一步探讨其局限性和优化方向。
重要观点1.FIFO算法的基本原理：FIFO算法按照页面进入内存的先后顺序进行置换，即最早进入内存的页面将最先被淘汰。
这一原理确保了页面的公平访问，但可能导致较低的缓存命中率。
2.页面置换的开销问题：无论使用哪种页面置换算法，都需要进行页面调度和数据迁移，这涉及到CPU和内存之间频繁的数据传输。
因此，算法的开销也需考虑在内。
3.缺页中断的处理：当CPU请求的页面不在内存中时，会发生缺页中断。
FIFO算法需要将最早进入内存的页面替换出去，为新页面腾出位置来处理缺页中断。
这需要涉及读取磁盘上的页面数据，带来了较高的I/O开销。
4.FIFO算法的局限性：FIFO算法没有考虑页面的重要性和访问频率，只单纯按照进入内存的顺序进行页面置换。
这种简单的先进先出策略可能会导致较低的缓存命中率和较大的开销。
关键发现通过对FIFO算法进行模拟实验，我们得出了一些关键发现：1.FIFO算法的缓存命中率与页面引用模式密切相关。
在连续引用的页面中，若页面较大且请求频繁，FIFO算法的缓存命中率可能会较低。
2.长作业更容易导致缺页中断。
FIFO算法可能更频繁地替换长时间运行的作业所需的页面，因为长作业往往具有更大的作业集。
3.FIFO算法对缓存容量的依赖。
当缓存容量较大时，FIFO算法可以维持较高的命中率。
然而，当缓存容量有限时，FIFO算法的性能可能急剧下降。
进一步思考通过对FIFO算法模拟实验的总结，我们可以进一步思考如下问题：1.如何提高FIFO算法的性能？可以尝试引入更智能的页面置换算法，如LRU（Least Recently Used）算法，根据页面的访问频率和重要性进行置换，以提高缓存命中率。
先进先出页面置换算法实验报告电子版
验
内
容
先进先出页面置换算法，该算法淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
实
验
步
骤
#include "stdafx.h"
#include<stdio.h>
#define M 20
#define N 3
void FIFO(int a[N],int b[M])
{
int i,j,k;
}
printf("\n"); }
s=k*1.0/M;
printf("中断次数为：%d\n",k);
printf("缺页率为：%f\n",s);
}
void main()
{int a[N]={0,0,0};
int b[M]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
FIFO(a,b);
}
研
究
与
探
讨
通过实验更加了解了各种页面置换算法之间的区别。在实验中，不知道如何来选择是否要置换，后想到可以另加一个数组存0,1，用以标记是否发生缺页中断。
int c[M]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
float s;
for(i=0;i<N;i++)
{
a[i]=b[i];
for(j=0;j<=i;j++)
{
printf("%d ",a[j]);
}
printf("\n");
}
k=N;
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现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算法的实现需要维护一个记录页面使用时间的链表或队列。
C语言 页面淘汰算法 OPT FIFO LRU CLOCK
《操作系统原理》上机作业（报告）作业：页面淘汰算法作业编号 6 题目页面淘汰/置换算法作业要求【题目要求】通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
针对一个页框，根据实验数据，以OPT算法为参考，研究FIFO页面淘汰算法、LRU页面淘汰以及CLOCK算法针对同一批实验数据的缺页率，以及研究在不同页框设置下的各算法缺页率表现情况。
页面引用序列为：4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5（1）固定分配局部置换情况下，驻留集大小为3，针对该内存页面引用序列模拟各算法的运行过程，并计算缺页率。
（2）模拟驻留集大小为4和5的情况下各算法的运行过程和缺页率。
其菜单如下：*************内存分配和回收***********=================================0. 退出1. OPT算法实现2. LRU算法实现3. FIFO算法实现4. CLOCK算法5. 显示缺页率对比表=================================【实习要求】可选编程语言：C/C++/Java/C#/Python；实现在同一个程序文件中（C/C++）；请适当注释；【实现提示】所需变量N：程序执行需要访问的页面数Msize：内存中可容纳的页数lack：在一次页面走向序列中用来统计缺页次数rate：缺页次数/总页数变量声明如下图所示：队列结构页面引用序列pages[N]和内存容量Memory[m]均用简单的数据结构线性表实现，其声明如图所示：【选做内容】改进型CLOCK算法实现。
构造一个页面引用序列，并出现Belady现象。
报告正文（运行屏幕截图及源代码）一．截图。
二．附录。
#include"stdio.h"#define N 30 //最大页数static int Msize; //内存容页数static int lacknum; //缺页数static int pages[N] = {4,3,2,1,4,3,5,4,3,2,1,5};static int memery[10];void Initial(){int i;for(i = 0; i < 10; i++){memery[i] = 0;}lacknum = 0;}int To_left(int index, int page) //计算之前的本页到现在已经多久了{int i = index - 1;while(i>=0){if(pages[i] == page)。
虚拟页面管理实验报告(3篇)
第1篇一、实验目的1. 理解虚拟存储器的概念和作用。
2. 掌握分页式存储管理的基本原理和地址转换过程。
3. 熟悉几种常见的页面置换算法，并比较其优缺点。
4. 通过实验，加深对虚拟存储器管理机制的理解。
二、实验内容1. 模拟分页式存储管理中的地址转换过程。
2. 比较几种常见的页面置换算法：FIFO、LRU、LFU和OPT。
三、实验原理虚拟存储器是一种将内存和磁盘结合使用的存储管理技术，它允许程序使用比实际物理内存更大的地址空间。
虚拟存储器通过将内存划分为固定大小的页（Page）和相应的页表（Page Table）来实现。
1. 分页式存储管理分页式存储管理将内存划分为固定大小的页，每个页的大小相同。
程序在运行时，按照页为单位进行内存访问。
分页式存储管理的主要优点是内存碎片化程度低，便于实现虚拟存储器。
2. 页面置换算法当内存中没有足够的空间来存放新请求的页面时，需要将某个页面从内存中移除，这个过程称为页面置换。
以下介绍几种常见的页面置换算法：（1）FIFO（先进先出）：优先淘汰最早进入内存的页面。
（2）LRU（最近最少使用）：优先淘汰最近最少被访问的页面。
（3）LFU（最不频繁使用）：优先淘汰最不频繁被访问的页面。
（4）OPT（最佳置换）：优先淘汰未来最长时间内不再被访问的页面。
四、实验步骤1. 模拟分页式存储管理中的地址转换过程（1）创建一个模拟内存的数组，表示物理内存。
（2）创建一个模拟页表的数组，用于存放虚拟页号和物理页号之间的映射关系。
（3）模拟进程对内存的访问，将访问的虚拟页号转换为物理页号。
2. 比较几种常见的页面置换算法（1）创建一个模拟进程的数组，包含访问的虚拟页号序列。
（2）对每个页面置换算法，模拟进程的运行过程，记录缺页中断次数。
（3）计算不同页面置换算法的缺页率，并比较其性能。
五、实验结果与分析1. 分页式存储管理中的地址转换过程实验结果表明，分页式存储管理能够有效地将虚拟地址转换为物理地址，实现虚拟存储器。
一种量化的页面淘汰算法
Ａｂ ｔａ ｔＬＲＵ－ｋｉ ｎ ｆｔ ｅｍｏ ｔｗｉ ｅｙ ａ ｐｉｄ ｐ ｇ －ｅ ｌｃｍｅ ｔａｇ ｒｔ ｍｓｉ ｈ ｄ ｒ ｐ ｒ ｔ ｇ ｓ ｓｅ ｎ ｓｒ ｃ ： ｓｏ ｅｏ ｈ ｓ ｄ ｌ ｐ ｌ ａ ｅｒｐａ ｅ ｎ ｌｏ ｉ ｅ ｈ ｎ ｔｅｍｏ ｅｎ ｏ ｅａｉ ｙ ｔｍｓａ ｄ ｎ ｄ ｔｂ ｓ ｙ ｔｍ ｓ Ｈｏ ｖ ｒ ａａ ａｅｓ ｓｅ ． ｗｅ ｅ ，ｗｉ ｈｅｉｃｅ ｎ ｆｔｅ ｎ ｍｂ ｒ ｏ ｅｏ ｄ ｒ ｔｒｇ ｅ ｉｅ ａ ｉｇ ｄｆｅｅ ｔｒａ － ｉ ｔ ｔ ｎ ｒｍｅ ｔｏ ｈ ｕ ｅ ｆｓ ｃｎ ａｙ ｓｏ ａ ｅｄ ｖｃｓ ｈ ｖｎ ｉ ｒｎ ｅ ｄｗｒｔ ｈ ｆ ｅ ｓ ｅ ｄ ｈ ｙ ｔｍ ，ｔ ｅｄ ａ ａｋ ｏ ＲＵ－ ｈ ｔ ｎ ｙｔｅｆｅ ｕ ｎ ｙｏ ｅ ｅ ｔｐ ｇ ｅｅｅ ｃｓｉ ａ ｅ ｔ ｃ ｏ ｎ Ｏｐ ｅ ｐ ｅ ｓｉ ｔ ｅｓ ｓｅ ｎ ｈ ｒｗｂ ｃ ｆＬ ｋｔ ａ ｌ ｒｑ ｅ ｃ ｆｒｃ ｎ ａ ｅｒｆｒｎ ｅ ｓｔｋ ｎ ｉ ｏａ ｃ ｕ ｔｔ ｒ — ｏ ｈ ｎ
ｄｃ ｈ ｏ ａ ｅ ｎ ｔ ｅ ｎ ａ ｕ ｕ ｅ ｉ ｏ ｎ ｐ Ｉ ｈｓ ｐ ｐ ｒ ｕ ｎ ｉ ｔ ｎ ａｇ ｒｔ ｍ ａ ｄ ＥＬ ｉｔｔ ｅｈ ｔ ｇ ｓ ｉ ｈ ｅ ｒ ｆ ｔ ｒ ｓ ｃ ｍｉ ｇ ｕ ． ｎ ｔ ｉ ａ ｅ ，ａ ｑ ａ ｔｚ ｉ ｌ ｏ ｉ ｐ ａｏ ｈ ｎ ｍｅ ＲＵＫ ｓ ｐ ｏ ｏ ｅ ｏ ｉ ｒ ｐ ｓｄ ｆ ｒ
ｍｏ ｅ ｉ ｃ ｍ ｎｙｕ ｅ ｒ ｙ ｔｍ ｉ ｉ ｅｅ ｔ ｉｄ ｆ ｅｏ ｄ ｒ ｔｒｇ ｅ ｉ ｓｄ ｍｏ ｓｒ ｔ ｈ ｔ ＲＵ 尼ｉ ｊ ｓ ａ ｄ ｌｓ ｏ ｍｏ ｌ ｓｄ ｆ ｓ ｓｅ ｗ ｔ ｄｆ ｒ ｎ ｎ ｓ ｃ ｎ ａｙ ｓｏ ａ ｅｄ ｖ ｅ ｅ ｎ ｔ ｅ ｔ ａ Ｌ － ｓ ｕ ｔ ｏ ａ ｈ ｆ ｋ ｏ ｓ ｃ ａ ｓ
使用最近未使用页淘汰(NRU)算法模拟实现页淘汰进程
使用最近未使用页淘汰（NRU）算法模拟实现页淘汰进程摘要：最近未使用页淘汰（NRU）算法或者时钟算法是实际使用的诸多页淘汰算法中的一种。
本课程设计是使用C程序设计语言，在windows平台下对页淘汰（NRU）算法模拟，通过页淘汰（NRU）算法的模拟来进一步的加深对使用NRU算法的了解，及对C程序设计语言的使用。
关键词：页淘汰 NRU 时钟算法一．设计的背景介绍1.1 介绍相关概念，相关算法页淘汰工作通常是由一个系统进程或线程完成的，该进程称为页淘汰进程。
页淘汰的时机：当内存空闲页面数低于系统所配置的最小阈值时启动（唤醒）页淘汰的进程，页淘汰进程被启动后就开始不停地选择和淘汰释放页，直到内存的空闲页面数达到系统所配置的最大阈值为止。
此后，页淘汰进程进入睡眠（等待）状态，直到下次因内存空闲页面数少于最小阈值而被再次唤醒（启动）。
最近未使用页淘汰（NRU）算法的原理：①该算法为每个页面设置两个硬件位—访问位和修改位访问位= 0:该页尚未被访问过; 访问位= 1:该页已经被访问过修改位= 0:该页尚未被修改过; 访问位= 1:该页已经被修改过②开始时所有页的访问位,修改位都设为0, 访问/修改时再置1。
③当页淘汰进程工作时,首先淘汰那些访问位为0的页。
然后，如果还需要继续淘汰（即空闲页面尚未达到最大阈值），则淘汰那些访问位为1但修改位为0的页。
最后如果空闲页面还不够，则淘汰那些修改位为1的页。
④由于大多数页迟早要被访问，故页淘汰进程定期遍历内存页—将每页的访问位都置为0（周期性地对访问位清零）。
这种清除过程类似于时针在时钟面上的运行故NRU算法又称为时钟（clock）算法。
1.2 简要介绍设计环境、设计工具利用VC++6.0/TC3.0在Dos/Windows平台使用最近未使用页淘汰（NRU）算法模拟实现页淘汰进程二．设计思路和总体流程图2.1 基本思路以命令行方式运行程序，调用read()函数读入页面请求队列，按照页面请求队列的先后顺序逐个处理请求页面。
页面置换算法实验报告
一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。
1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、简单时钟(钟表)算法（CLOCK）命中率＝１－页面失效次数／页地址流(序列)长度三、实验原理UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页，核心配置了四种数据结构：页表、页帧（框）号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
（1）通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：A：50%的指令是顺序执行的B：25%的指令是均匀分布在前地址部分C：25%的指令是均匀分布在后地址部分具体的实施方法是：A：在[0，319]的指令地址之间随机选取一起点mB：顺序执行一条指令，即执行地址为m+1的指令C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’D：顺序执行一条指令，其地址为m’+1E：在后地址[m’+2，319]中随机选取一条指令并执行F：重复步骤A-E，直到320次指令（2）将指令序列变换为页地址流设：页面大小为1K；用户内存（页帧）容量为4页~32页；用户虚存容量为32K。
页面淘汰算法
页面淘汰算法1. 引言在现代科技发展迅猛的时代，网页成为人们获取信息、交流、娱乐的主要途径之一。
然而，随着互联网的快速发展，页面数量的快速增长也给用户体验带来了很大的挑战。
为了提供更好的用户体验，页面淘汰算法应运而生。
2. 页面淘汰算法的定义和意义页面淘汰算法是一种根据用户需求和行为对网页进行排序和筛选的算法技术。
其主要目的是将用户最有可能需要的页面展示在搜索结果的前面，同时排除冗余、垃圾或过时的页面，提高用户体验和信息的准确性。
页面淘汰算法的重要性在于它能够为用户提供更加精准、有用的搜索结果。
它能够避免用户在海量信息中迷失，节省用户的时间和精力。
通过淘汰那些不再被人们关注的、过时的页面，也可以为互联网资源的高效利用提供保障。
3. 传统页面淘汰算法的缺点传统页面淘汰算法主要基于页面的静态特征（如关键词匹配、网页排名等）来进行排序和筛选，存在一些明显的缺点：3.1 主观性较强：传统算法主要依赖人工制定的规则和关键词匹配等因素，容易受到个人主观意识和商业利益的影响，导致搜索结果的准确性和公正性存在一定局限性。
3.2 难以适应用户个性化需求：传统算法往往无法充分考虑用户个性化需求，导致搜索结果的个性化程度较低，不能很好地满足用户的具体需求。
3.3 对新兴内容的处理困难：传统算法主要基于历史数据和统计规律，对于新兴话题或者特定领域的内容处理能力较弱，无法及时给出相关的搜索结果。
4. 基于机器学习的页面淘汰算法为了克服传统页面淘汰算法的缺点，近年来，研究者们开始运用机器学习和数据挖掘等技术来开发更加智能和高效的页面淘汰算法。
4.1 数据驱动：基于机器学习的页面淘汰算法主要通过对大量的用户行为数据进行分析和学习，实现对用户需求的准确预测和页面的个性化推荐。
4.2 模型构建：基于机器学习的页面淘汰算法通过构建各种模型，如深度神经网络模型、协同过滤模型等，对用户行为进行建模和预测，从而实现对页面的准确排序和筛选。
实验三页面置换算法
操作系统实验报告班级：姓名：学号：实验三：页面置换算法一、实验目的1、熟悉内存分页管理策略。
2、编写OPT、FIFO、LRU，LFU四种置换算法并模拟实现。
3、锻炼知识的运用能力和实践能力。
二、实验内容设计主界面，输入一串系列模拟页面请求，实现以下算法：1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)三、代码及运行结果分析#include <stdio.h>#include <stdlib.h>int mSIZE;int pSIZE;static int memery[10]={0};static int page[100]={0};static int temp[100][10]={0};void FIFO();void LRU();void OPT();void print(unsigned int t);void read();void mDelay(unsigned int Delay);int main(){int i,k,code;printf("请输入物理块的个数(M<=10)：");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100)："); scanf("%d",&pSIZE);puts("请依次输入页面号引用串：");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);read();do{puts("输入的页面号引用串为：");for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}}printf("---------------------------------------------\n");printf("* 请选择页面置换算法：\t\t\t *\n");printf("* ----------------------------------------- *\n");printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n"); printf("* 3.最佳(OPT) 4.退出*\n");printf("--------------------------------------------\n");printf("请选择操作：[ ]\b\b");scanf("%d",&code);switch(code){case 1:FIFO();break;case 2:LRU();break;case 3:OPT();break;case 4:system("cls");exit(0);default:printf("输入错误，请重新输入：");}printf("按任意键重新选择置换算法：>>>"); getchar();}while (code!=4);getchar();}void read(){int i;for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++) {mDelay((pSIZE+mSIZE)/2);printf(">"); }printf("获取成功，按任意键进入置换算法选择界面：");getchar(); }void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}void print(unsigned int t) {int i,j,k,l;int flag;for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1))) printf("%d\n",page[i]);elseprintf(" %d ",page[i]);}for(j=0;j<mSIZE;j++){for(i=20*k;(i<mSIZE+20*k)&&(i<pSIZE);i++) {if(i>=j)printf(" |%d|",temp[i][j]);elseprintf(" | |");}for(i=mSIZE+20*k;(i<pSIZE)&&(i<20*(k+1));i++) { for(flag=0,l=0;l<mSIZE;l++)if(temp[i][l]==temp[i-1][l])flag++;if(flag==mSIZE)/*页面在物理块中*/printf(" ");elseprintf(" |%d|",temp[i][j]);}if(i%20==0)continue;printf("\n");}}printf("----------------------------------------\n");printf("缺页次数：%d\t\t",t+mSIZE);printf("缺页率：%d/%d\n",t+mSIZE,pSIZE);printf("置换次数：%d\t\t",t);printf("访问命中率：%d%%\n",(pSIZE-(t+mSIZE))*100/pSIZE); printf("----------------------------------------\n");}/*计算过程延迟*/void compute(){int i;printf("正在进行相关计算，请稍候");for(i=1;i<20;i++){mDelay(15);if(i%4==0)printf("\b\b\b\b\b\b \b\b\b\b\b\b"); elseprintf("...");}for(i=0;i++<30;printf("\b"));for(i=0;i++<30;printf(" "));for(i=0;i++<30;printf("\b"));}void FIFO(){int memery[10]={0};int time[10]={0};int i,j,k,m;int max=0;int count=0;for(i=0;i<mSIZE;i++){memery[i]=page[i];time[i]=i;for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++) {for(j=0,k=0;j<mSIZE;j++) {if(memery[j]!=page[i])k++;}if(k==mSIZE){count++;max=time[0]<time[1]?0:1; for(m=2;m<mSIZE;m++) if(time[m]<time[max]) max=m;memery[max]=page[i]; time[max]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}/*最近最久未使用置换算法*/void LRU(){int memery[10]={0};int flag[10]={0}; /*记录页面的访问时间*/ int i,j,k,m;int max=0;int count=0;for(i=0;i<mSIZE;i++){memery[i]=page[i];flag[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;elseflag[j]=i;}if(k==mSIZE){count++;max=flag[0]<flag[1]?0:1;for(m=2;m<mSIZE;m++)if(flag[m]<flag[max])max=m;memery[max]=page[i];flag[max]=i; /*记录该页的访问时间*/temp[i][j]=memery[j]; }else{for(j=0;j<mSIZE;j++) temp[i][j]=memery[j]; }}compute();print(count);}void OPT(){int memery[10]={0}; int next[10]={0};int i,j,k,l,m;int max;int count=0;for(i=0;i<mSIZE;i++) {memery[i]=page[i];temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++) {for(j=0,k=0;j<mSIZE;j++) {if(memery[j]!=page[i])k++;}if(k==mSIZE){count++;for(m=0;m<mSIZE;m++) {for(l=i+1;l<pSIZE;l++)if(memery[m]==page[l]) break;next[m]=l;}max=next[0]>=next[1]?0:1;for(m=2;m<mSIZE;m++) if(next[m]>next[max]) max=m;for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}else {for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}}compute();print(count);}四、实验心得。
页面淘汰算法实验报告
操作系统实验报告课题：页面淘汰算法专业：班级：学号：姓名：年月日目录一实验目的 (3)二实验要求 (3)三背景知识 (3)四总体设计 (4)五详细设计 (7)六运行结果分析 (9)七心得体会 (13)八参考文献 (14)附：源代码 (15)一、实验目的本实验主要对操作系统中请求分页式内存管理及其应用的一些关键算法进行模拟。
学生通过设计与实现Clock算法，能够加强对相应理论的理解，并对了解操作系统内部的基本处理原理与过程也有很多益处。
利用简单的数据结构，模拟实现操作系统中的页面置换机制，通过写程序模拟实现上述三种内存页面置换算法，使学生进一步掌握内存页面置换的方法。
对操作系统中内存的管理有一个实践上的认识。
1、用C语言编写OPT、FIFO、LRU三种置换算法。
2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
二、实验要求●设计随机页面序号产生程序，并说明随机的性能和其性能可能对算法的影响●编写页面淘汰算法(FIFO、OPT、LRU)●结果数据的显示或提取●结果数据的分析几点说明：●设计并绘制算法流程，附加说明所需的数据结构●如何标记时间的先后、最久的将来、最久未被使用●描述Clock算法的基本原理、必要的数据结构、算法执行流程图、编码实现。
1）初始化：输入作业可占用的总页框数，初始化置空。
2）输入请求序列：输入一个作业页号访问请求序列，依次占用相应页框，直至全部占用；3）Clock算法：当页框全部占用后，对于后续新的页号访问请求，执行Clock 算法，淘汰1个页面后装入新的页号。
4）显示当前分配淘汰序列：显示淘汰的页号序列。
三、背景知识：在操作系统当中，在进程运行过程中，若其访问的页面不在内存中而需把他们调入内存，但内存已无空闲空间时，为了保证该进程能够正常的运行，系统必须从内存中调出一页程序或数据送到磁盘的兑换区中，但是应该是哪个页面被调出，需根据一定的算法来确定。
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页面淘汰当内存块已满时，选择链表头部的页面进行淘汰，将新访问的页面加入链表尾部。
fifo页面淘汰算法总结(共5篇)
fifo页面淘汰算法总结第1篇假设虚拟内存的地址是16位，页面大小为1K，则进程的大小为 2 16 = 64 K B2^{16}=64KB 216=64KB分页个数 = 进程的大小页面的大小 = 逻辑地址表示的大小页面的大小 = 2 16 B 1 K B = 2 6 页分页个数=\frac{进程的大小}{页面的大小}=\frac{逻辑地址表示的大小}{页面的大小}=\ frac{2^{16B}}{1KB}=2^{6}页分页个数=页面的大小进程的大小=页面的大小逻辑地址表示的大小=1KB216B=26页因此页号P占用前6位，页内偏移量W=16-6=10位。
每一个页表项占用2B,因此页表存储空间需要 2 6 ∗ 2 B = 128 B 2^6*2B=128B 26∗2B=128B页面结构以及页表项设计如下：算法流程如下：具体实现如下：算法流程如下：具体实现如下：算法流程如下：其中调用了randBool()函数，随机的生成0或者1，其具体实现如下算法规则：选择永不使用或是在最长时间内不再被访问（即距现在最长时间才会被访问）的页面淘汰出内存。
假定系统为某进程分配了三个物理块，并考虑有以下页面访问序列： [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淘汰……依此类推。
算法流程图如下：OPT算法具体实现如下：算法规则：在发生页面替换时，被替换的对象应该是最早进入内存的。
仍然采用上述的例子，此时页面置换过程如下表所示FIFO算法流程图如下所示：FIFO页面置换算法具体实现如下：初始化设置m=8,e=8,s=10; 页框数=3，访问序列长度=20；选择算法2：先进先出淘汰算法置换过程算法规则：在发生页面替换时，被替换的页面应该满足，在之前的访问队列中，该对象截止目前未被访问的时间最长。
最长时间未使用页面淘汰算法
最近最久未使用者淘汰算法交通计算机翟高寿最近最久未使用者淘汰算法LRU❑基本思想以“最近的过去”作为“最近的将来”的近似，选择最近一段时间最长时间未被访问的页面淘汰出内存❑评价适用于各种类型的程序，性能较好，但需要较多的硬件支持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 4 4 4 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 3 3 3 3 3 3 0 0 0 0 0 1 1 1 3 3 3 2 2 2 2 2 2 2 2 2 7 7 7某进程分配获得三个物理块缺页中断次数为9次，缺页率45%页面访问序列内存页面分布情况页面预先装入最近最久未使用者淘汰算法举例说明最近最久未使用者淘汰算法硬件支持——移位寄存器B# R R7 R6 R5 R4 R3 R2 R1 R01 0 1 0 1 0 0 1 02 1 0 1 0 1 1 0 03 0 0 0 0 1 1 0 04 0 1 1 0 1 0 1 15 1 1 0 1 0 1 1 06 0 0 1 0 1 0 1 17 0 0 0 0 0 1 1 18 0 1 1 0 1 1 0 1最近最久未使用者淘汰算法硬件支持 —— 栈44 7 470 7 4 07 0 471 7 0 4 10 1 7 4 01 0 7 412 1 0 7 4 21 2 0 7 4 12 1 0 7 4 26 2 1 0 76某进程分配获得五个物理块页面访问序列知行合一，开拓进取！最近最久未使用者淘汰算法■。
实验12章页面淘汰算法
3．比较各种页面置换算法的优缺点。
1
实验1 Linux系统的安装
二．实验内容 模拟实现各种页面置换算法。具体步骤为： 1．使用产生随机数函数得到一个随机的数列，做为将 要载入的页面序列。 2 ．可以选择使用先进先出（ FIFO ）算法、最近最久 未使用（ LRU ）置换算法和最佳（ OPT ）置换算法，给出 所需淘汰的页面号序列。 3．列出缺页中断次数。 三．实验环境 本实验可以在Turbo C环境下实现，也可以使Linux系 统的gcc实现。
2
实验1 Linux系统的安装
四．实验源程序清单 程序说明： 本程程假设内存为程序分配的内存块数为4. 进入程序后可以根据菜单项进入不同的模块。 1. 使用首次适应算法分配空间 2. 最近最久未使用的页面 3. 使用最佳适应算法分配空间 4. 显示有多少个缺页中断 5. 退出系统
3
实验1 Linux系统的安装
实验12章页面淘汰算法页面置换算法实验报告页面淘汰算法fifo页面淘汰算法页面置换算法实验lru页面淘汰算法银行家算法实验报告算法设计与实验题解des加密算法实验报告遗传算法实验报告
实验1 Linux系统的安装
实验12 页面置换算法模拟实验
一．实验目的
1．进一步掌握虚拟存储器的实现方法。
2．掌握各种页面置换算法。
பைடு நூலகம்
THE END
4
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验报告课题：页面淘汰算法专业：班级：学号：姓名：年月日目录一实验目的……………………………………………………错误！未定义书签。
二实验要求 (3)三背景知识 (3)四总体设计 (4)五详细设计……………………………………………………错误！未定义书签。
六运行结果分析 (9)七心得体会 (13)八参考文献 (14)附：源代码 (15)一、实验目的本实验主要对操作系统中请求分页式内存管理及其应用的一些关键算法进行模拟。
学生通过设计与实现Clock算法，能够加强对相应理论的理解，并对了解操作系统内部的基本处理原理与过程也有很多益处。
利用简单的数据结构，模拟实现操作系统中的页面置换机制，通过写程序模拟实现上述三种内存页面置换算法，使学生进一步掌握内存页面置换的方法。
对操作系统中内存的管理有一个实践上的认识。
1、用C语言编写OPT、FIFO、LRU三种置换算法。
2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
二、实验要求●设计随机页面序号产生程序，并说明随机的性能和其性能可能对算法的影响●编写页面淘汰算法(FIFO、OPT、LRU)●结果数据的显示或提取●结果数据的分析几点说明：●设计并绘制算法流程，附加说明所需的数据结构●如何标记时间的先后、最久的将来、最久未被使用●描述Clock算法的基本原理、必要的数据结构、算法执行流程图、编码实现。
1）初始化：输入作业可占用的总页框数，初始化置空。
2）输入请求序列：输入一个作业页号访问请求序列，依次占用相应页框，直至全部占用；3）Clock算法：当页框全部占用后，对于后续新的页号访问请求，执行Clock 算法，淘汰1个页面后装入新的页号。
4）显示当前分配淘汰序列：显示淘汰的页号序列。
三、背景知识：在操作系统当中，在进程运行过程中，若其访问的页面不在内存中而需把他们调入内存，但内存已无空闲空间时，为了保证该进程能够正常的运行，系统必须从内存中调出一页程序或数据送到磁盘的兑换区中，但是应该是哪个页面被调出，需根据一定的算法来确定。
通常，我们把这一类的算法称为“页面置换算法”，页面置换算法执行效率的高低，往往直接影响到操作系统的性能。
内存页面置换算法：1、<1> 先进先出调度算法（FIFO）先进先出调度算法根据页面进入内存的时间先后选择淘汰页面。
本算法实现时需要将页面按进入内存的时间先后组成一个队列，每次置换掉最早进入的页面。
这是最早出现的置换算法，该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最长的页面换出，予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO算法并不能保证这些页面不被淘汰。
<2>最近最久未使用的置换算法（LRU）最近最久未使用的置换算法，是根据页面调入内存后的使用情况进行决策的。
由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU 置换算法是选择最近最久未使用的页面予以淘汰。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t,，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。
<3> 最佳置换算法（OPT）最佳置换算法是可以说的一种理想的页面置换算法，它是由Belady于1966 年提出的一种理论上的算法。
其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但可以利用此算法来评价其它算法。
<4>时钟页面置换算法时钟页面置换算法是把所有的页面都保存在一个类似钟面的环形链表中，一个表针指向最老的页面，如图所示。
当发生缺页中断时，算法首先检查表针指向的页面，如果它的R位是0就淘汰该页面，并把新的页面插入这个位置，然后把表针前移一个位置；如果R位是1就清除R位并把表针前移一个位置，重复这个过程直到找到了一个R位为0的页面为止。
四、总体设计●根据要求设计页面淘汰算法的活动图运行程序进入主页面，在正上方，已经通过随机生成函数生成了页面号，在其下方，显示可选项：0、退出程序1、FIFO算法2、OPT算法3、LRU算法。
根据需要，选择相应的法，程序自动生成页面淘汰的先后顺序，以及置换次数和缺页次数，并打印在下方，执行完以后，再次进入主页面，到输入0，退出程序。
●算法流程图FIFO算法流程图：新的指令页面内存中的所有页面time+1载入新页面time=0内存物理块集合已满？已在内存物理块中？内存中所有页面time+1选择time值最大的页面换出否否是是O PT算法流程图新的指令页面载入该页面内存物理块集合已满？已在内存物理块中？对内存中每个页面，向后遍历剩余指令集合，记录每个页面距离再次被利用的页面跨度否否是是选择跨度最大的页面换出L RU算法流程图：新的指令页面内存中的所有页面time+1载入新页面time=0内存物理块集合已满？已在内存物理块中？内存中所有页面time+1选择time值最大的页面换出否否是是该页面time=0五、详细设计（一）、设计思想1、最佳置换算法(OPT)用数组Temppages[]存储当前物理块中页面信息，数组TimeArry[]存储当前在物理块中的页面的获得内存时的时间，当页面不在内存中时，根据当前已获得物理块数的页面在所有的页面当中将来不在请求内存或者很少请求内存的情况进行置换2、先进先出算法(FIFO)用数组Temppages[]存储当前物理块中页面信息，变量temp记录内存中物理块页面置换状态，每进行一次置换，页面置换状态变化，便于下一次的置换。
3、最近最久未使用算法(LRU)用数组Temppages[]存储当前物理块中页面信息，数组TimeArry[]存储当前在物理块中的页面的获得内存时的时间，当页面不在内存中时，选择TimeArry[]数组中值最小并且对应物理块中的页面进行置换。
（二）、设计步骤首先根据程序要求，我们分别定义两个宏，用以存放我们的物理块数目以及页面数目，再定义一个结构体，用以物理块的存储，代码如下：#define MemPageCount 4#define InstructionCount 20struct page{int serial; //页面号int time; //时间计数}mempage[MemPageCount];其次，建立主函数，根据程序需要，定义相应的变量，建立switch语句，用以算法的选择，部分定义如下：int i,j,k,m,n; //指令页面集合,可以考虑让页面指令集合随机生成int instruction[InstructionCount];int mem_counter; //内存页面集合计数器int switch_counter; //置换次数最后，根据算法流程图，实现相应算法的代码编写。
（三）、算法流程设计主函数流程:STEP1:输入分配的页框数，页面访问次数和要访问的页面号序列STEP2:内存页面初始化。
内存中页面的数据结构为单循环链表，含有页号值yehao和访问位值a。
开始时页号均为-1，访问位为0.STEP3：测试数据。
具体算法是依要访问的页面号，调用find()函数查找是否已经存在于内存中。
若存在，则修改其访问位为1.若不存在，触发缺页中断，调用tihuan()函数。
最后，打印当前内存状态。
如此循环直至测试串都访问完毕。
1)主要函数实现a)Makenode(double)函数：用于初始化一个节点。
b)Find（double）函数：依据输入的页号，查询内存中是否已存在此页面。
若存在返回值1，不存在返回值0.c)Tihuan（double）函数：在发生缺页中断时，时钟指针查找访问位为0的页面进行替换，指针扫过的页面访问位置0，新加入的页面访问位置1。
替换后指针下移。
d)Print_state()函数：打印当前内存中存在的页面的状态以及当前时钟指针所指向的页面位置。
2)测试数据估计输入：输入分配的页框数3输入页面访问次数15输入要访问的页面号序列3 4 2 6 4 3 7 4 3 6 3 4 8 4 6输出（仅最后一项）：3)结果分析以下是clock算法对应输入页面号序列3 4 2 6 4 3 7 4 3 6 3 4 8 4 6的分析表六、运行结果分析：a)开始界面2、采用随机数产生的结果2、采用自定义页面信息产生结果自定义页面数为：15 物理块数为：4页面序列为：1 2 3 4 5 6 7 8 9 4 5 6 7 0 8根据结果，我们不难发现，OPT算法，是三种算法中性能最好的，它的置换次数最少，LRU次之，，不过性能最差的还是FIFO，由于缺页率=缺页次数/总的页面数，所以我们不难发现，随着物理块数的增加，缺页率都相应有所增加，但是OPT算法的增加较为明显，即产生了belady现象。
七、心得体会：这次课程设计，让我对算法的编写更加的熟练，同时更加了解页面置换的相关算法，也提高了我对算法设计的严密性，对以后的程序设计有很大帮助。
我们不仅对常用的算法进行了编写，还对一些理想的算法也进行了编写，并且通过适当的方法，得以了验证。
就该程序而言，随机性使得程序出现了更多的可能性，为我们验证算法提供很大的方便，电脑自动分配，大大的节约了我们的时间，但是我们通过实验不难发现，如果所设的页面项目过大，也会影响我们算法的性能执行效率。
对我们所涉及的算法，让我有很大的感触。
在FIFO 算法中，无论有无发生缺页或者置换，都需要对每个在内存中的页面的time 值进行增加操作，以保持最先进入的那个页面的time 值是最大的；一个新进来的页面，其time值设置为0。
当然，该算法也可以通过队列结构来实现，利用队列的先进先出（FIFO）特性完成，无需设置time字段。
distance 用于记录内存物理块集合中每个页面距离再次被使用的页面跨度，缺省值为9999，如果某个页面在后续指令集合中不再出现，则用最大值9999 缺省取代；如果页面再次被使用，则两次使用所跨的页面数，为页面跨度。
用最大页面跨度表示以后永不使用或未来最长时间内不再被访问。
在LRU 算法中，无论是否发生缺页或者置换，除了命中（刚刚被访问过的页面）页面time 值清零之外，其它所有内存中的页面的time 值都加一，以保证最近刚刚被访问的页面的time 值最小，相应time 值最大的页面就是最近最久没有被访问的页面。