FIFO页面置换算法

合集下载

【算法】页面置换算法FIFO、LRU和LFU的概述以及实现方式

【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式页⾯置换算法，我们最常⽤的页⾯置换算法包括FIFO先来先服务，LRU最近最久未被使⽤，LFU最近最少被使⽤以及我们的时钟置换算法。

⼀、FIFO算法——先来先服务1、简述FIFO算法FIFO算法是我们⽐较简单的置换算法，就是先来先服务或者说是先进先出。

也就是说在进⾏页⾯置换的时候，最先来的那个会被最先置换出去。

先进⼊的指令先完成并引退，跟着才执⾏第⼆条指令。

2、FIFO算法的简单实现FIFO算法的简单实现：可以通过维护⼀个链表结构去存储当前调⼊的页⾯；将最先进⼊的页⾯维护在链表的最前，最后进⼊的页⾯维护在链表的最后；这样，当发⽣缺页中断时，需要进⾏置换的时候，淘汰表头的页⾯并将新调⼊的页⾯加到链表的尾部；当然除了链表以外我们还可以采⽤数组或者队列等来进⾏实现。

3、FIFO算法的特点（1）FIFO算法实现简单，易于理解易于编程。

FIFO算法实现简单，⽆须硬件⽀持，只需要⽤循环数组管理物理块即可。

（2）FIFO算法可能会出现Belady现象。

也就是在FIFO算法中，如果未分配够⼀个进程所要求的页⾯，有时就会出现分配的页⾯数增多，却也率反⽽增加Belady现象。

（3）FIFO算法可能会置换调重要的页⾯，其效率不⾼。

（4）在FIFO算法可能中会导致多次的页⾯置换。

当页⾯置换的时间⼤于所要操作的时间的时候，这时候其效率就会很低。

当其不停的进⾏页⾯置换的时候会出现⼤量的系统抖动现象。

⼆、LRU算法——最近最久未被使⽤1、简述LRU算法LRU算法是最近最久未被使⽤的⼀种置换算法。

也就是说LRU是向前查看。

在进⾏页⾯置换的时候，查找到当前最近最久未被使⽤的那个页⾯，将其剔除在内存中，并将新来的页⾯加载进来。

2、LRU算法的实现LRU的实现就相对于FIFO的实现复杂⼀点。

我们可以采⽤哈希映射和链表相结合。

操作系统页面置换算法（opt,lru,fifo,clock）实现

操作系统页⾯置换算法（opt,lru,fifo,clock ）实现选择调出页⾯的算法就称为页⾯置换算法。

好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。

常见的置换算法有以下四种（以下来⾃操作系统课本）。

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。

图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。

该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。

但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。

图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例，⾤⽤FIFO 算法进⾏页⾯置换。

进程访问页⾯2时，把最早进⼊内存的页⾯7换出。

然后访问页⾯3时，再把2, 0, 1中最先进⼊内存的页换出。

页式虚拟存储管理FIFO、LRU和OPT页面置换算法

目录1 需求分析 (2)1.1 目的和要求 (2)1.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 课程设计总结 (9)7 参考文献 (10)8 附录：源程序清单 (10)1 需求分析1.1 目的和要求在熟练掌握计算机虚拟存储技术的原理的基础上，利用一种程序设计语言模拟实现几种置换算法，一方面加深对原理的理解，另一方面提高学生通过编程根据已有原理解决实际问题的能力，为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。

1.2 研究内容模拟实现页式虚拟存储管理的三种页面置换算法（FIFO(先进先出)、LRU （最近最久未使用）和OPT（最长时间不使用）），并通过比较性能得出结论。

前提：（1）页面分配采用固定分配局部置换。

（2）作业的页面走向和分得的物理块数预先指定。

可以从键盘输入也可以从文件读入。

（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。

2 概要设计本程序主要划分为4个功能模块，分别是应用FIFO算法、应用LRU算法、应用OPT算法和页面引用串的插入。

1.1各模块之间的结构图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个数字页面引用串。

最佳页面置换算法

最佳页面置换算法(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次缺页中断时被置换掉了。

页面置换算法

页面置换算法2008-03-01 22:30评价一个算法的优劣,可通过在一个特定的存储访问序列（页面走向）上运行它，并计算缺页数量来实现。

1 先入先出法（FIFO）最简单的页面置换算法是先入先出（FIFO）法。

这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。

理由是：最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。

建立一个FIFO队列，收容所有在内存中的页。

被置换页面总是在队列头上进行。

当一个页面被放入内存时，就把它插在队尾上。

这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不高。

因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。

FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。

当然，导致这种异常现象的页面走向实际上是很少见的。

2 最优置换算法（OPT）最优置换（Optimal Replacement）是在理论上提出的一种算法。

其实质是：当调入新的一页而必须预先置换某个老页时，所选择的老页应是将来不再被使用，或者是在最远的将来才被访问。

采用这种页面置换算法，保证有最少的缺页率。

但是最优页面置换算法的实现是困难的，因为它需要人们预先就知道一个进程整个运行过程中页面走向的全部情况。

不过，这个算法可用来衡量（如通过模拟实验分析或理论分析）其他算法的优劣。

3 最久未使用算法（LRU）FIFO算法和OPT算法之间的主要差别是，FIFO算法利用页面进入内存后的时间长短作为置换依据，而OPT算法的依据是将来使用页面的时间。

如果以最近的过去作为不久将来的近似，那么就可以把过去最长一段时间里不曾被使用的页面置换掉。

它的实质是，当需要置换一页时，选择在最近一段时间里最久没有使用过的页面予以置换。

这种算法就称为最久未使用算法（Least Recently Used，LRU）。

fifo 页面置换算法

fifo 页面置换算法页面置换算法是操作系统中一种重要的内存管理技术，用于决定当内存中某个时间点所包含的页面（即帧）数量大于物理内存容量时，应该淘汰哪个页面，以便为新的页面腾出空间。

FIFO （FirstInFirstOut，先进先出）页面置换算法是一种常见的算法，其基本思想是优先淘汰最先进入内存的页面。

一、算法原理FIFO页面置换算法的基本原理是，当需要为新的页面分配内存时，选择最早进入内存的页面进行淘汰。

这种算法的优点是实现简单，缺点是对频繁调用的页面影响较大，因为这些页面最先进入内存，所以被淘汰的可能性也较大。

但是它能够确保被淘汰的页面是最早进入内存的页面，因此它能够提供一定的公平性。

二、算法步骤FIFO页面置换算法的实施步骤如下：1.记录每个页面进入和离开内存的时间；2.当需要为新的页面分配内存时，比较该页面与其最先进入内存的时间；3.优先淘汰最先进入内存的页面；4.将新页面放入空出的帧中。

三、算法优缺点1.优点：a.实现简单，易于实现；b.在许多场景下能提供较好的性能；c.有利于保持页面的有序性。

2.缺点：a.频繁调用的页面被淘汰的可能性较大，可能导致频繁的页面加载和卸载操作；b.对于某些应用场景可能不够高效，因为一些页面可能长时间在内存中占据空间，而不会被频繁使用。

因此需要对其进行优化，以便在减少页面的浪费和提高系统性能之间找到平衡。

四、应用场景FIFO页面置换算法适用于各种操作系统和应用程序，包括但不限于Web服务器、数据库系统、桌面环境等。

它尤其适用于那些对响应速度要求较高且对内存使用效率要求不高的场景。

例如，一些网页浏览、邮件阅读等应用场景，由于页面加载频率较高，FIFO算法可能会影响性能。

五、总结总的来说，FIFO页面置换算法是一种简单易行的内存管理技术，但在实际应用中需要根据具体场景进行优化。

在实际操作中，需要根据应用的特点和需求选择合适的页面置换算法，以提高系统的性能和稳定性。

页面置换算法(FIFO算法_LRU算法)

实验四页面置换算法一、实验目的理解并掌握模拟分页式虚拟存储管理的缺页中断，以及选择页面调度算法处理缺页中断。

二、实验内容及要求选择一种或几种页面置换算法进行编程以实现该算法。

三、实验流程图四、实验程序1、FIFO算法#include"stdio.h"#define n 20#define m 4void main(){int ym[n],i,j,q,mem[m]={0},table[m][n];char flag,f[n];printf("请输入页面访问序列\n");for(i=0;i<n;i++)scanf("%d",&ym[i]);printf("\n");for(i=0;i<n;i++) //查页表，看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页，则置标志flag为‘*’else flag='';if(flag=='*'){for(j=m-1;j>0;j--) //淘汰最先调入的页面调入当前访问的mem[j]=mem[j-1];mem[0]=ym[i];}for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表（0代表为空，*代表有缺页）：\n");for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);}2、LRU算法#include"stdio.h"#define n 20#define m 5void main(){int ym[n],i,j,q,mem[m]={0},table[m][n];char flag,f[n];printf("请输入页面访问序列\n");for(i=0;i<n;i++)scanf("%d",&ym[i]);printf("\n");for(i=0;i<n;i++) //查页表，看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页，则置标志flag为‘*’else flag=' ';for(j=q;j>0;j--)mem[j]=mem[j-1];mem[0]=ym[i];for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表（0代表为空，*代表有缺页）：\n");for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);}五、实验结果1、FIFO(四内存块)2、LRU(五内存块)。

说明fifo置换算法的置换过程。

1.引言1.1 概述FIFO（First In, First Out）置换算法是一种常用的页面置换算法，也被称为先进先出置换算法。

该算法基于一个简单的原则：最早进入内存的页面将是最早被替换出去的页面。

在现代操作系统中，内存管理是一个关键的任务，因为内存资源有限且需求不断增长。

为了实现有效的内存利用和保证系统的正常运行，当内存中的页框（页面的固定大小单元）不足时，操作系统需要选择某些页面进行替换，以便为新的页面提供空间。

FIFO置换算法尽管简单，但其实现简单和直观的特点使其成为操作系统中最常用的页面置换算法之一。

它不需要复杂的数据结构支持，只需要使用一个先进先出的队列来记录页面的进入顺序即可。

简单来说，FIFO算法根据页面被访问的时间顺序进行替换。

当某个页面需要装入内存但没有可用的页框时，操作系统会选择最早进入内存的页面进行替换，以便为新页面腾出空间。

这样，最早进入内存的页面总是被替换出去，而最晚进入内存的页面则相对较新，有更高的机会被保留在内存中。

然而，FIFO算法也存在一些缺点。

最主要的问题是不考虑页面的访问频率和重要性，只关注页面进入内存的时间顺序。

这可能导致一些重要的页面被替换掉，从而影响系统的性能。

此外，FIFO算法也容易遭受局部性原理（Locality Principle）的冲击，在某些访问模式下，可能导致频繁的页面调度，增加了页面调度的开销。

尽管存在这些限制，FIFO置换算法仍然是一种重要且常用的页面置换算法。

了解其置换过程对于理解操作系统的内存管理机制以及其他高级页面置换算法的实现原理都是非常有益的。

在接下来的正文中，我们将详细描述FIFO置换算法的执行过程及其与其他算法之间的比较。

1.2 文章结构本文按照以下结构进行展开讨论FIFO（First-In-First-Out）置换算法的置换过程：1. 算法介绍：在这一部分，将对FIFO置换算法进行详细介绍。

clock页面置换算法例题详解

clock页面置换算法例题详解Clock页面置换算法（也称为时钟置换算法或FIFO算法）是一种简单的页面置换算法，它总是选择当前最久未使用的页面进行置换。

下面是一个关于Clock页面置换算法的例题详解：假设有一个程序需要使用6个页面，分别为A、B、C、D、E和F，而且它需要使用4个内存块（也可以说是4个页面框）。

让我们跟随程序的执行，看看这个程序使用Clock页面置换算法时会发生什么。

1、初始状态：程序开始执行时，内存中没有任何页面。

2、第一次缺页中断：程序需要访问页面A，但内存中没有该页面。

于是，发生一次缺页中断。

现在内存中只有一个空闲的内存块，所以可以将页面A加载到内存中。

3、第二次缺页中断：程序需要访问页面B，但内存中没有该页面。

同样地，发生一次缺页中断。

此时内存中仍然只有一个空闲的内存块，所以可以将页面B加载到内存中。

4、第三次缺页中断：程序需要访问页面C，但内存中没有该页面。

再次发生一次缺页中断。

此时内存中仍然只有两个空闲的内存块，所以可以将页面C加载到内存中。

5、第四次缺页中断：程序需要访问页面D，但内存中没有该页面。

再次发生一次缺页中断。

此时内存中仍然只有三个空闲的内存块，所以可以将页面D加载到内存中。

6、第五次缺页中断：程序需要访问页面E，但内存中没有该页面。

再次发生一次缺页中断。

此时内存中仍然只有四个空闲的内存块，所以可以将页面E加载到内存中。

7、第六次缺页中断：程序需要访问页面F，但内存中没有该页面。

再次发生一次缺页中断。

此时内存中已经满了，不能再加载任何页面了。

此时需要使用Clock页面置换算法来决定哪个页面应该被置换出去。

在这个例子中，我们假设Clock页面置换算法的参数是k=2（即每次只淘汰两个最近最少使用的页面之一）。

首先，我们需要找到当前最久未使用的两个页面。

根据算法的规则，总是选择当前最久未使用的页面进行置换。

在这个例子中，我们可以选择A和B作为最久未使用的两个页面之一。

操作系统——模拟页面置换算法（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。

请求页式管理中的置换算法

请求页式管理中的置换算法页式管理是计算机内存管理的一种方式，它利用虚拟内存和分页技术使得操作系统可以在有限的物理内存下运行更多的进程。

在页式存储管理中，操作系统将物理内存分成若干个固定的大小的块，称为物理块，同时将进程分成若干个大小相等的块，称为页面。

当一个进程需要访问某个页面时，操作系统就将页面调入物理块中，若所有物理块都被占满，则需要选择一个物理块将其替换成即将调入的页面，这就需要使用到置换算法。

常见的置换算法有如下几种：1. 先进先出算法（FIFO）该算法是最简单的、最易实现的一种页面置换算法。

其原理是将先进入内存的页面优先替换出去。

使用一个先进先出的队列来维护物理块的使用情况，每次选择队列头的页面进行置换。

因此该算法的缺点就是无法考虑页面替换的实际使用情况。

2. 最近最少使用算法（LRU）该算法会将最近未被使用的页面优先置换出去，即在内存中驻留时间最长的页面最不容易被替换出去。

其难点在于如何确定何时页面被使用过。

可以使用栈或者链表来实现。

3. 最不常用算法（LFU）该算法会将内存中使用次数最少的页面优先置换出去，即在内存中使用次数最少的页面最容易被替换出去。

为实现该算法，需要维护每个页面的使用次数。

4. 时钟算法（Clock）该算法是一种Clock页面置换算法，在物理块使用情况时采用了一个环形链表的结构。

每个页面都有一个标志位，若该位为1，则说明该页面在当前的一轮中被使用过，同时将该位变为0；若该位为0，则说明该页面未被使用过，这时候会考虑是否将该页面替换出去。

5. 二次机会算法（Second chance）该算法对时钟算法进行了改进，增加了一个修改位，表明是否被修改过。

每次选择的是位0(未被使用/未被修改)或者1(未被使用/被修改)的页面，如果选择到的是1则把修改位清零，并转化为0重新加入内存块队列。

以上是常见的五种页面置换算法，不同的算法有各自的优缺点，需要根据内存管理的需要、机器性能和系统配置来选择合适的算法来实现。

页面置换算法的模拟-(1)

课程设计报告课程名称：操作系统实验题目：页面置换算法的模拟日期：2010.07.01目录一、课程设计分析 (3)二、相关知识 (3)三、功能设计分析 (4)四、程序设计 (4)五、运行截图 (5)六、参考程序 (7)七、结果分析 (15)八、心得体会 (15)一、课程设计分析编写程序实现页面置换算法中常用的FIFO、LRU。

FIFO页面置换算法：FIFO淘汰算法是最先使用的页面最先被淘汰。

该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。

先进先出(FIFO)页面置换算法，是根据页面调入内存后的使用情况进行决策的。

该算法是选择在内存中驻留时间最久的页面予以淘汰。

该算法赋于请求调入页面一个空间（工作集），淘汰掉最先调入的页，取而代之的是紧随它进来的页，这样就基本上实现了对最先进入内存的页面的淘汰。

LRU页面置换算法：该算法淘汰的页面是在最近一段时间里较久未被访问的那一页，它是根据程序执行时的局部性原理而设计的。

二、相关知识1．虚拟存储器的引入局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。

2．虚拟存储器的定义虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。

3．虚拟存储器的实现方式分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。

请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。

4．页面分配平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。

按比例分配算法，根据进程的大小按比例分配物理块。

考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。

页面分配FIFO算法

先进先出(FIFO)页面置换算法一、设计思想该算法总是淘汰最先进入内存的页面，既选择内存中驻留时间最久的页面予以淘汰。

该算法实现简单，只需要把一个进程已调入内存的页面，按照先后测序链接成一个队列，并设置一个指针，使他总是指向最老的页面。

但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO 算法并不能保证这些页面不被淘汰。

这里，我们用下面的例子，采用FIFO 算法进行页面置换。

当进程第一次访问页面2时，将把第七页换出，因为它是最先被调入内存的；在第一次范文页面3时，又将把第零页换出，因为他在现有的2，0，1三个页面中是最老的页。

由下图可以看出，利用FIFO 算法时进行了十二次页面置换，比最佳置换算法正好多一倍。

引用率0 1二、运行结果1、输入分配的物理块数和页面号引用串，执行算法。

2、执行FIFO算法过程如下：三、源程序代码#include <iostream>#include <iomanip> //使用setw()时用到的头文件#include <stdio.h>#include <stdlib.h>#include <conio.h> //使用getchar()时用到的头文件using namespace std;#define Max 30 //某进程调入内存中的最大页面数#define Size 10 //系统为某进程分配的最大物理块数void Init(int Block[],int m) //初始化物理块{ int i;for(i=0;i<m;i++){Block[i]=-1;}}void creat(int Page[],int n) //输入页面串引用号{ int i;for(i=0;i<n;i++){cin>>Page[i];}void FIFO(int Page[],int Block[],int n,int m){//max_stay:比较当前内存中页面驻留的最久时间,count:统计页面置换次数//get:某物理块是否等待驻入新页面(-1:否)//flag:标记当前序号页面是否已驻入内存(-1:否)//block_num:驻留内存时间最长的页面所在的物理块序号//time[]标记对应序号的物理块中页面驻留时间int i,j,max_stay=0,count=0;int get=-1,flag=-1,block_num=-1;int time[Size];for(i=0;i<m;i++) //初始化time[]{ time[i]=0;}for(i=0;i<n;i++){ for(j=0;j<m;j++) //有空闲物理块时，页面直接驻入内存空闲块{ if(Block[j]==-1){get=j; //物理块j即将(/等待)驻入新页面break;}}for(j=0;j<m;j++) //查找序号相同的页面{ if(Block[j]==Page[i])//物理块j中页面与当前期望调入内存的页面相同{flag=j;break;}}for(j=0;j<m;j++) //找到驻留内存时间最久的页面置换出{if(time[j]>max_stay){max_stay=time[j];block_num=j; //block_num标记当前序号物理块中页面驻留时间最久}}if(flag==-1) //不存在相同页面{ if(get!=-1) //物理块即将(/等待)驻入新页面{Block[get]=Page[i]; //存入页面time[get]=0; //当前物理块重新计时for(j=0;j<=get;j++) //已驻入页面的驻留时间加1{time[j]++;}get=-1;}else //页面调度置换，序号block_num的物理块是驻留时间最久的{Block[block_num]=Page[i];time[block_num]=0;for(j=0;j<Size;j++){time[j]++;}block_num=-1;max_stay=0;count++;}}else //待调入页面与序号flag的物理块中页面相同{for(j=0;j<m;j++){time[j]++;}flag=-1;}for(j=0;j<m;j++) //输出物理块中的页面驻入情况{cout<<setw(3)<<Block[j];}cout<<endl;}if(n>m)count=count+m-3;cout<<"缺页中断次数为:"<<count<<endl;}void main(){ int n,m,Page[Max],Block[Size];cout<<"*******先进先出FIFO页面置换算法*******"<<endl;cout<<"--------------------------------------"<<endl;cout<<"*******(默认:-1表示物理块空闲)*******"<<endl;cout<<endl<<"请输入系统为进程分配的物理块数(m<=10):";while(1){cin>>m;if(m>Size||m<1){cout<<"警告：输入的数据错误！"<<endl;cout<<"请重新输入物理块数:";}else break;}Init(Block,m);cout<<"请输入总页面数(n<=30):";cin>>n;cout<<"\n请输入页面号引用串:";creat(Page,n);cout<<"FIFO算法过程如下:"<<endl;FIFO(Page,Block,n,m);getchar(); //直接执行exe文件时做停留查看结果之用getchar();}。

先进先出（FIFO）页面置换算法C语言实现、最近最久未使用（LRU）页面置换算法C语言实现

先进先出（FIFO）页⾯置换算法C语⾔实现、最近最久未使⽤（LRU）页⾯置换算法C语⾔实现1.实现效果2.实现源代码1 #include<iostream>2 #include<process.h>3 #include<stdlib.h>4 #include<ctime>5 #include<conio.h>6 #include<stdio.h>7 #include<string.h>8using namespace std;910#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")/*表格控制*/11#define bsize 4 //物理块⼤⼩12#define psize 16 //进程⼤⼩13void chushihua();//初始化函数14void ymzh();16void changeaddr(struct Page p[], int logaddr);17void dizhizhuanhuan();18void menu();19int wang();2021int yemianliu[32]={0};//全局变量数组,地址流22int p;23struct Page {24int pno;//页号25int flag;//标志位26int cno;//主存号27int modf;//修改位28int addr;//外存地址29 }Page; //全局变量p是⼀共有多少地址流3031 typedef struct pagel32 {33int num; /*记录页⾯号*/34int time; /*记录调⼊内存时间*/35 }Pagel; /*页⾯逻辑结构,⽅便算法实现*/3637 Pagel b[bsize]; /*内存单元数*/38int c[bsize][psize];/*保存内存当前的状态:缓冲区*/39int queue[100];/*记录调⼊队列*/40int k;/*调⼊队列计数变量*/41int phb[bsize]={0};//物理块标号42int pro[psize]={0};//进程序列号43int flag[bsize]={0};//进程等待次数(存放最久未被使⽤的进程标志)*/ 44int i=0,j=0;//i表⽰进程序列号,j表⽰物理块号*/45int m =-1,n =-1;//物理块空闲和进程是否相同判断标志*/46int mmax=-1, maxflag=0;//标记替换物理块进程下标*/47int count =0; //统计页⾯缺页次数4849void chushihua() //初始化函数50 {51int t;52 srand(time(0));//随机产⽣指令序列53 p=12+rand()%32;54 cout<<"地址流序列:";55 cout<<endl;56for(i=0; i<p; i++)57 {58 t=1+rand()%9;59 yemianliu[i]=t;//将随机产⽣的指令数存⼊页⾯流60 }61for (i=p-1;i>=0;i--)62 {63 cout<<yemianliu[i]<<"";64 }65 cout<<endl;66 }67void ymzh()68 {69 chushihua();70 yemianzhihuan();71 }7273void yemianzhihuan()74 {75int a;76 printf("----------------------------------\n");77 printf("☆☆欢迎使⽤分页模拟实验系统☆☆\n");78 printf("----------------------------------");79 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");80 printf("☆☆1.进⼊硬件地址变换算法☆☆\n");81 printf("☆☆------------------------☆☆\n");82 printf("☆☆2.进⼊页⾯置换算法☆☆\n");83 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");84 printf("请输⼊您的选择:");85switch(a)86 {87case1:88 ymzh();89break;90case2:91 wang();92break;93default:94 cout<<"输⼊有误,请重新输⼊!"<<endl;95break;96 }97 }98100int j=logaddr/64;//对应的块号101int k=logaddr%64; //对应的偏移量102int flag=0;103int addr;104for(int i=0;i<8;i++)105 {106if(p[i].pno==j)//找到对应的页号107 {108if(p[i].flag==1)//页⾯标志为1109 {110 addr=p[i].cno*64+k;111 cout<<"物理地址为:"<<addr<<endl;112 cout<<"详细信息:"<<"\t页⾯号:"<<p[i].pno<<"\t 主存号："<<p[i].cno<<"\t偏移量:"<<k<<endl; 113 flag=1;114break;115 }116 }117 }118119if(flag==0)120 cout<<"该页不在主存,产⽣缺页中断"<<endl;121 }122123void dizhizhuanhuan()124 {125int a;126int ins;//指令逻辑地址127struct Page p[8];128 p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;129 p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;130 p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;131 p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;132 p[4].pno=4;p[4].flag=0;p[4].addr=017;133 p[5].pno=5;p[5].flag=0;p[5].addr=025;134 p[6].pno=6;p[6].flag=0;p[6].addr=212;135 p[7].pno=7;p[7].flag=0;p[7].addr=213;136 printf("\t\t\t--------------------------------\n");137 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");138 printf("\t\t\t---------------------------------\n");139 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");140 printf("\t\t\t☆☆1.输⼊指令☆☆\n");141 printf("\t\t\t☆☆------------------------☆☆\n");142 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");143 printf("\t\t\t☆☆------------------------☆☆\n");144 printf("\t\t\t☆☆0.EXIT ☆☆\n");145 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");146while(a!=0)147 {148 cout<<endl<<"请输⼊您的选择:";149 cin>>a;150151 cout<<"页号"<<"标记位"<<"外存地址"<<"主存号"<<endl;152for(int i=0;i<8;i++)153 {154 cout<<p[i].pno<<"\t"<<p[i].flag<<"\t"<<p[i].addr<<"\t";155if(p[i].flag)156 cout<<p[i].cno;157 cout<<endl;158 }159160switch(a)161 {162case0:printf("\t\t\t再见!\t\t\t\n"); break;163case1:164 cout<<"请输⼊指令的逻辑地址:";165 cin>>ins;166 changeaddr(p, ins);break;167case2: system("CLS"); a=wang();break;168default:cout<<"输⼊有误,请重新输⼊!"<<endl;break;169 }170 }171 }172173void menu()174 {175int a;176 printf("\t\t\t--------------------------------\n");177 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");178 printf("\t\t\t---------------------------------\n");179 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");180 printf("\t\t\t☆☆1.输⼊指令☆☆\n");181 printf("\t\t\t☆☆------------------------☆☆\n");182 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");184 printf("\t\t\t☆☆0.EXIT ☆☆\n");185 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n"); 186 printf("请选择所要执⾏的操作:");187 scanf("%d",&a);188switch(a)189 {190case0: printf("\t\t\t-再见!-\t\t\t\n");break;191case1: dizhizhuanhuan (); break;192case2: wang (); break;193default:cout<<"输⼊有误,请重新输⼊!"<<endl;break; 194 }195 }196int main()197 {198 menu();199 }200201//****************随机产⽣序列号函数202int* build()203 {204 printf("随机产⽣⼀个进程序列号为:\n");205int i=0;206for(i=0; i<psize; i++)207 {208 pro[i]=10*rand()/(RAND_MAX+1)+1;209 printf("%d ", pro[i]);210 }211 printf("\n");212return(pro);213 }214215//***************************************查找空闲物理块216int searchpb()217 {218for (j=0;j<bsize; j++)219 {220if(phb[j] == 0)221 {222 m=j;223return m;224break;225 }226 }227return -1;228 }229//************************************查找相同进程230int searchpro()231 {232for(j=0;j< bsize;j++)233 {234if(phb[j] =pro[i])235 {236 n=j;237return j;238 }239 }240return -1;241 }242243//*************************初始化内存244void empty()245 {246for(i=0;i<bsize;i++)247 phb[i]=0;248 count=0; //计数器置零249 } //******先进先出页⾯置换算法250void FIFO()251 {252for( i=0; i<psize; i++)253 {254// m=searchpb();255// n=searchpro();256//找到第⼀个空闲的物理快257for(j=0;j<bsize;j++) {258if(phb[j] == 0){259 m=j;260break;261 }262 }263//找与进程相同的标号264for(j=0;j<bsize;j++) {265if(phb[j] == pro[i]){266 n=j;268 }269270//找flag值最⼤的271for(j=0;j<bsize;j++)272 {273if(flag[j]>maxflag)274 {275 maxflag = flag[j];276 mmax = j;277 }278 }279280if(n == -1)//不存在相同进程281 {282if(m != -1)//存在空闲物理块283 {284 phb[m]=pro[i];//进程号填⼊该空闲物理块285// count++;286 flag[m]=0;287for (j=0;j<=m; j++)288 {289 flag[j]++;290 }291 m=-1;292 }293else//不存在空闲物理块294 {295 phb[mmax] =pro[i];296 flag[mmax] =0;297for (j=0;j<bsize;j++)298 {299 flag[j]++;300 }301 mmax = -1;302 maxflag = 0;303 count++;304 }305 }306else//存在相同的进程307 {308 phb[n] = pro[i];309for(j=0;j<bsize;j++)310 {311 flag[j]++;312 }313 n=-1;314 }315for(j=0;j < bsize;j++)316 {317 printf("%d ", phb[j]);318 }319 printf("\n");320 }321 printf("缺页次数为:%d\n",count);322 printf("缺页率 :%16. 6f",(float)count/psize);323 printf("\n");324 }325/*初始化内存单元、缓冲区*/326void Init(Pagel *b,int c[bsize][psize])327 {328int i,j;329for (i=0;i<psize;i++)330 {331 b[i].num=-1;332 b[i].time=psize-i-1;333 }334for(i=0;i<bsize;i++)335for(j=0;j<psize;j++)336 c[i][j]=-1;337 }338/*取得在内存中停留最久的页⾯,默认状态下为最早调⼊的页⾯*/ 339int GetMax(Pagel *b)340 {341int i;342int max=-1;343int tag=0;344for(i=0;i<bsize;i++)345 {346if(b[i].time>max)347 {348 max=b[i].time;349 tag= i;350 }353 }354355/*判断页⾯是否已在内存中*/356int Equation(int fold, Pagel *b)357 {358int i;359for(i=0;i<bsize;i++)360 {361if(fold==b[i]. num)362return i;363 }364return -1;365 }366/*LRU核⼼部分*/367void Lruu(int fold, Pagel *b)368 {369int i;370int val;371 val=Equation(fold, b);372if (val>=0)373 {374 b[val].time=0;375for(i=0;i<bsize;i++)376if (i!=val)377 b[i].time++;378 }379else380 {381 queue[++k]=fold;/*记录调⼊页⾯*/382 val=GetMax(b);383 b[val].num=fold;384 b[val].time=0;385for (i=0;i<bsize;i++){386387// URLcount++;388if (i!=val)389 b[i].time++;390 }391 }392 }393394void LRU()395 {396int i,j;397 k=0;398 Init(b, c);399for(i=0; i<psize; i++)400 {401 Lruu(pro[i],b);402 c[0][i]=pro[i];403/*记录当前的内存单元中的页⾯*/404for(j=0;j<bsize;j++)405 c[j][i]=b[j].num;406 }407408/*结果输出*/409 printf("内存状态为:\n");410 Myprintf;411for(j=0;j<psize;j++)412 printf("|%2d", pro[j]);413 printf("|\n");414 Myprintf;415416for(i=0;i<bsize;i++)417 {418for(j=0; j<psize; j++)419 {420if(c[i][j]==-1)421 printf("|%2c",32);422else423 printf("|%2d",c[i][j]);424 }425 printf("|\n");426 }427428 Myprintf;429// printf("\n调⼊队列为:");430// for(i=0;i<k;i++)431// printf("%3d", queue[i]);432433 printf("\n缺页次数为:%6d\n 缺页率 :%16. 6f", k+1,(float)(k+1)/psize); 434 }437int wang()438 {439int sel;440do{441 printf("\t\t\t--------------------------------\n");442 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");443 printf("\t\t\t---------------------------------\n");444 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");445 printf("\t\t\t☆☆虚拟内存☆☆\n");446 printf("\t\t\t☆☆------------------------☆☆\n");447 printf("\t\t\t☆☆1.产⽣随机序列☆☆\n");448 printf("\t\t\t☆☆------------------------☆☆\n");449 printf("\t\t\t☆☆2.最近最久未使⽤☆☆\n");450 printf("\t\t\t☆☆------------------------☆☆\n");451 printf("\t\t\t☆☆3.先进先出☆☆\n");452 printf("\t\t\t☆☆------------------------☆☆\n");453 printf("\t\t\t☆☆0.退出☆☆\n");454 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");455 printf("请选择所要执⾏的操作:");456 scanf("%d",&sel);457switch(sel)458 {459case0: printf("\t\t\t再见!t\t\t\n"); break;460case1: build(); break;461case2: printf("最近最久未使⽤\n"); LRU();empty(); printf("\n");break; 462case3: printf("先进先出算法\n"); FIFO();empty();printf("\n");break; 463default:printf("请输⼊正确的选项号!");printf("\n\n");break;464 }465 }while(sel !=0 );466return sel;467 }。

FIFO页面置换算法

FIFO页面置换算法1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。

2）用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。

在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。

如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。

在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。

3）置换算法：先进先出FIFO算法。

#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define N 4#define size 320typedef struct Block{int block_num; //块号int page_num; //页号struct Block *next;}BLOCK,*BLOCKLIST;typedef struct instruct{ //指令数据结构int address; //指令地址int page_num; //指令所存的页号}INSTRUCTION,*INSTRUCTIONLIST;INSTRUCTION instructions[size]; //定义320条指令BLOCKLIST block_head,front_in; //block_head指向块链表的头，front_in指向最老的页面，即被淘汰的页面int diseffect=0; //缺页次数int blockSize=0; //标记块是否满//初始化指令void Init_Instructions(){for(int i=0;i<320;i++)instructions[i].address=rand()%320;for(int k=0;k<320;k++)instructions[k].page_num=(int)instructions[k].address/10;}//初始化块（循环链表）BLOCKLIST Init_block(){BLOCKLIST head=(BLOCKLIST)malloc(sizeof(BLOCK)) ;BLOCKLIST p;for(int i=1;i<=N;i++) {if(i==1) p=head;else {p->next=(BLOCKLIST)malloc(sizeof(BLOCK));p=p->next;}p->block_num=i;p->page_num=-1;}p->next=head;return head;}//显示块内的数据void display(INSTRUCTION instructions){BLOCKLIST p=block_head;printf("The new page: (page_num==%d),(address==%d)\n",instructions.page_num,instructions.address);printf("block_num,page_num\n");do{printf(" %2d %10d\n",p->block_num,p->page_num);p=p->next;}while(p!=block_head);}//显示页面对应的物理地址void show_physical_address(BLOCKLIST &p,INSTRUCTION instructions) {int address;printf("physical address:");address=p->block_num*1024+instructions.address%10;printf("%d\n\n",address);}//查找该页是否存在，存在不要置换，否则置换int Find_page_in_block(INSTRUCTION instructions,BLOCKLIST &p) {p=block_head;do{if(p->page_num==instructions.page_num)return 1;p=p->next;}while(p!=block_head);return 0;}//用于将四个块填满void loadpage(INSTRUCTION instructions){BLOCKLIST p;p=block_head;while(p->page_num!=-1)p=p->next;p->page_num=instructions.page_num;blockSize++;}//按FIFO置换页面void replace_page(INSTRUCTION instructions,BLOCKLIST &p) {front_in->page_num=instructions.page_num;p=front_in;front_in=front_in->next;}void main(){BLOCKLIST p;Init_Instructions();block_head=Init_block();front_in=block_head;for(int i=0;i<size;i++) {if(Find_page_in_block(instructions[i],p)){display(instructions[i]);show_physical_address(p,instructions[i]);getchar();continue;}else if(blockSize<N) {diseffect++;loadpage(instructions[i]);display(instructions[i]);}else {diseffect++;replace_page(instructions[i],p);display(instructions[i]);show_physical_address(p,instructions[i]);}getchar();}printf("NRU %f\n",(float)diseffect/size);getchar();getchar();getchar();}。

最佳页面置换算法

最佳页面置换算法(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算法,LRU算法)

实验四页面置换算法一、实验流程图二、实验程序#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define null 0#define len sizeof(struct page)struct page{ int num;int tag;struct page *next;};struct page *create(int n) /*建立分配的内存空间，并初始化，返回头结点*/{int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len); //开辟一个新的单元,并将malloc返回的指针转换为结构体类型的指针p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;struct page *cp,*dp,*head,*new1;int count=0;head=create(n);p=array;while(*p!=-1){ cp=dp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if (cp->num==*p) printf(" ! " );else{ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){cp->num=*p;printf(" * ");}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*new1,*endp;head=create(n);while(*p!=-1){cp=dp=rp=endp=head;for(;endp->next!=null;) endp=endp->next;for(;cp->num!=*p&&cp->next!=null;){rp=cp;cp=cp->next;}if(cp->num==*p){printf(" ! ");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;{printf(" * ");cp->num=*p;cp->tag=0;}else{new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*new1;p=array;head=create(n);while(*p!=-1){ cp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if(cp->num!=*p){ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){printf(" * ");cp->num=*p;cp->tag=0;}else{ i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){ for(;*q!=cp->num&&cp->next!=null;) cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){for(;cp->tag!=0;) cp=cp->next;printf(" %d ",cp->num);cp->num=*p;}else{ cp=head;for(;cp->tag!=0;) cp=cp->next;if(cp==head){ for(;cp->next!=null;) cp=cp->next;new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}else{ printf(" %d ",cp->num);cp->num=*p;}}cp=head;for(;cp->next!=null;) {cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf(" ! ");p++;}printf("\nQueye Zongshu : %d \n",count);}main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Cann't open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF)/*将数字字符串转化成整型-开始*/ {if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1) break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n') break;else{space=1;j++;i=0;}}}}}/*结束*/if(pt==EOF) {str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1) {printf(" %d ",page[i]);i++;}fclose(fp);printf("\n");printf(" ! : mean no moved \n * : mean have free space \n\n"); printf("FIFO ");FIFO(page,3);printf("\nLRU ");LRU(page,3);printf("\nOPT ");OPT(page,3);}。

页面置换算法c语言fifo

页面置换算法C语言FIFO第一部分：介绍页面置换算法页面置换算法是操作系统中用于管理内存的一种重要算法，其目的是在物理内存不足时选择合适的页面进行替换，以保证系统的正常运行。

本部分将简要介绍页面置换算法的基本概念和作用。

1. 页面置换算法概述：页面置换算法是解决虚拟内存管理中的一个关键问题，即在有限的物理内存中如何有效地管理大量的进程和数据。

FIFO（First-In-First-Out）是其中一种经典的页面置换算法，它按照页面进入内存的先后顺序进行置换。

2. FIFO算法原理：FIFO算法采用队列的数据结构，将最早进入内存的页面视为队列的队首，最后进入的页面视为队尾。

当需要置换页面时，选择队首的页面进行替换。

这种方式保持了页面进入内存的顺序，但可能导致"Belady异常"现象。

第二部分：FIFO算法的C语言实现1. FIFO算法的基本实现：在C语言中，可以使用数组或链表来模拟队列结构，实现FIFO算法。

定义一个队列数据结构，包括队列的大小、队首和队尾指针等成员。

通过数组或链表实现入队和出队操作，完成FIFO算法的基本功能。

2. C语言代码示例：以下是一个简单的FIFO算法的C语言实现示例：c#include <stdio.h>define MAX_SIZE 10int fifo_queue[MAX_SIZE];int front = -1, rear = -1;入队操作void enqueue(int page) {if (rear == MAX_SIZE - 1) {printf("队列已满，无法入队\n");return;}if (front == -1) {front = 0;}rear++;fifo_queue[rear] = page;}出队操作void dequeue() {if (front == -1) {printf("队列为空，无法出队\n");return;}printf("出队的页面：%d\n", fifo_queue[front]); if (front == rear) {front = rear = -1;} else {front++;}}第三部分：FIFO算法的应用场景1. 操作系统内存管理：FIFO算法常用于操作系统的虚拟内存管理中，用于页面的置换。

页面置换算法FIFO算法

网络教育学院《操作系统》课程设计题目：页面置换算法FIFO算法学习中心：层次：专业：年级：年春/秋季学号：学生：井杰辅导教师：龙珠完成日期： 2016 年 1 月 28 日页面置换算法FIFO算法在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。

当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。

而用来选择淘汰哪一页的规则叫做页面置换算法。

在请求分页存储器管理系统中，我们需要一个页面置换算法，而先进先出算法就是最早出现的一种算法，利用该算法可以实现页面的置换，实现内存的充分利用，使进程可以执行。

先进先出置换算法（FIFO）最简单的页面置换算法是先入先出（FIFO）法。

这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。

理由是：最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。

建立一个FIFO队列，收容所有在内存中的页。

被置换页面总是在队列头上进行。

当一个页面被放入内存时，就把它插在队尾上。

这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不高。

因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。

FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。

当然，导致这种异常现象的页面走向实际上是很少见的。

优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。

该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。

但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。

1．先进先出（FIFO）该算法实现简单，只需把一个进程已调入内存的页面，按先后顺序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。

1、输入当前要调用的页面号2、判断该页面是否已在队列内，若在队列内，不执行任何操作若不在队列内。