页面替换算法FIFO，OPT，LRU的js实现

最新推荐文章于 2024-05-31 01:32:31 发布
最新推荐文章于 2024-05-31 01:32:31 发布
阅读量1.8k 收藏 11
点赞数 6
分类专栏： 玩算法 js数组 基本类型 引用类型 文章标签： FIFO LRU OPT JS 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39071183/article/details/84333894
版权

OPT，FIFO，LRU页面置换算法的JS实现

一．FIFO算法

1.1 先进先出算法基本思想：
淘汰最先进入的页面，选择在内存中驻留最久的页面的予以淘汰。
基本思想就是将先进入队列的页面先淘汰掉，如果该页面后期被命中，那也不将它的步数重置，而是按照它第一次进入页面开始记步数

FIFO

二. LRU算法

2.1 LRU置换算法基本思想：

Lru算法和fifo最大相似点就是淘汰前向步数最大的页面，也就是淘汰页面的判断依据是该页面的从前到后的步数统计，越大表明越是长时间为用到，所以予以淘汰替换。
单很明显是由明显区别的，那就是lru算法当遇到命中时会将该页面重置步数。

LRU

三．Optimal算法：

3.1 最佳置换算法基本思想：
将以后永不使用的淘汰，或者是将在最长（未来）时间内不在访问的页面淘汰。由于不能知道或预测谁是最可能永不使用或者长时间使用的页面，所以不能拿它来作为页面置换实际操作中的算法，但是可以用于评估其他算法。
（未被命中的即为“缺页”，缺页率=未命中数/总数，淘汰率=替换数/总数）
3.2具体操作思想
首先有一个页面访问顺序的数列2,3,1,5,6,7,6,3,7,8,2。内存块有3个物理块
OPT

四.运行截图

在这里插入图片描述

五.代码：

<!DOCTYPE html>
<html>
<head>
	<title>页面替换算法OPT，FIFO，LRU</title>
	<meta charset="utf-8">
	<meta author="syk">
</head>
<link rel="stylesheet" href="reset.css">
<style>
	
.container{
	position: absolute;
            top: 0;
            bottom: 0;
            left: 0;
            right: 0;
	
	background: #00ace6;

}
.container-warrper{
	width: 700px;
	padding: 0 0 0 0;
	margin: 100px auto;
	border: 1px dashed #cccccc;
}
.container span{
	color: #ffffff;
}
#liststyle{
	width: 600px;
	background: #ffffff;
	margin-top: 10px;
}
#substyle{
	text-align: center;
}
#part{
	margin: 20px 0 20px 0;
	color: #ffffff;
	text-align: center;
	height: 25px;
	line-height: 25px;
}
.arithmetic{
	
}
#but1 ,#but2 ,#but3{
	border-radius: 50%;
	background-color: bisque;
	outline: none;
	color: #000000;
	font-weight: 700;

}
#result1 ,#result2 ,#result3{
color: #ffffff;
font-weight: 600;
text-align: center;
}
</style>
<body>
<div class="container">
	<div class="container-warrper">
		<form action="#" method="POST">
			<span>页面序列：</span> <input type="text" name="list" id="liststyle" value="" placeholder="请按照'1 2 3 4 . . .'带有空格的方式写 输入7个数吧！！"> <br/>
			<input type="submit" value="确认" id="substyle">
			<p style="color:#ffffff;">-----------------------------------------------------------------------------------------------------</p>
			<p id="part"></p>
		</form>
		<div class="arithmetic">
			<p style="color:#ffffff;">-----------------------------------------------------------------------------------------------------</p>
			<button id="but1">OPT算法</button>
			<button id="but2">FIFO算法</button>
			<button id="but3">LRU算法</button>
			<p style="color:#ffffff;">-----------------------------------------------------------------------------------------------------</p>
			<div id="result1"></div>
			<p style="color:#ffffff;">-----------------------------------------------------------------------------------------------------</p>
			<div id="result2"></div>
			<p style="color:#ffffff;">-----------------------------------------------------------------------------------------------------</p>
			<div id="result3"></div>
		</div>
	</div>
</div>
</body>
<script type="text/javascript">
var Button=document.getElementById('substyle');

var Logic1=document.getElementById('but1');//opt算法对象
var Logic2=document.getElementById('but2');//fifo算法对象
var Logic3=document.getElementById('but3');//lru算法对象

var textlist=document.getElementById('liststyle');
var list =new Array();
var Plist= new Array();//页面序列
var M=new Array();
// M=[[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0]];//物理存储块向量7
var target=0;
var pointPage=0;//命中数
//实现的是点击获取当前的form表单输入值，置换成数组形式Plist[];
Button.onclick=function(){
	var x=textlist.value;
	list=x.split(" ");
	list.forEach(element => {
		Plist.push(parseInt(element));	
	});		
	console.log(Plist);

	document.getElementById('part').innerHTML="当前的页面调入数组是：["+ Plist +"]";

	console.log(target);
	return false;
}
// var a=1;
// document.getElementById('result1').innerHTML='‘'+a+'’';

// a++;
// document.getElementById('result2').innerHTML='‘'+a+'’';
var headlist=new Array();//上一次的数组
var B=new Array();
var C=new Array();
// C=[0,0,0];
function init(){
	M=[[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0]];
	C=[0,0,0];
	pointPage=0;
}
Logic1.onclick=()=>{
	console.log("OPT");
	// MisPage=3;
	init();
		Plist.forEach((p,i) => {
			if(i<=2){		//前三个是一定要产生缺页的，所以直接插入
				var w=i;
				for(w;w>=0;w--){
					if(w!=i){
						M[i].splice(w,1,B[w]);		//当没到和当前p匹配的位置时，前面都是引用上一个的数组的值。
					}else{
						M[i].splice(w,1,p);
					}				
				}		//复杂度是一个m*n的空间复杂度。
				B=M[i];
				console.log("M["+M[i]+"]");
				// M[i+1]=B;//数组是引用类型，这里会将地址统一到m[0]处，这样后面的变了，前面的理所当然的变了，所以说这里不是用引用类型！！！。
			// debugger;
			}else{//进入的条件就是数组遍历到了第i=3的位置，这时如果数组是[1,2,3,4,5,1,2],那么就会是4准备入页面了，
						if(M[i-1].some((value)=>{return value==p;})){//命中了！！这里应该用前一个索引作为当前基准，也就是说不应该是i,应为i是外面的，一直没变。。。
						
							M[i-1].forEach((element,indx) => {
								M[i].splice(indx,1,element);
								
							});
							
							pointPage++;
						}else{//没有命中则要发生替换算法了！！，
							for(let [index, item] of Plist.entries()){
								if(index>i-1){//从第4条开始寻找。以后依次往后寻找
									M[i-1].forEach((element,i) => {
									if(element==item){
										if(C[i]!=0&&C[i]<index){	 
										//找最近被替换的索引，怕出现1这个数后面出现两次，结果将大的索引去替换了之前小的索引。
										}else{
											C[i]=index;//当前所需知道的物理存储块的后面所最近出现的位置，位置越大越表示要被替换
										}
									}
								});
							}//最终找到了我们的其前面对应的3个页面各自在后方的最近被访问的索引，下面只需要比较谁大了，越大证明越远被访问到，所以被替换
						}//计算当前被替换的3个物理块中个元素在后面最先调入的索引，也就是我们所说的后面的距离。
						var x=C.indexOf(C.reduce((a,b)=>{return a>b?a:b;}));//得到应该被替换的数组的索引。
						// debugger;
						M[i-1].forEach((element,indx) => {
								M[i].splice(indx,1,element);
						});
						M[i].splice(x,1,p);
						// MisPage++;
					}
					
				// }
			// }
		}		
		});
		// dom操作，添加输出的信息。
		M.forEach((element,index) => {
			// debugger;
			M[index].forEach((e,i)=>{
				console.log(e);
				document.getElementById('result1').innerHTML="<p>["+M+"]</p><br/><p>缺页率："+(Plist.length-pointPage)/Plist.length+"</p>";//这里用innerHTML最后会被覆盖
			})
			
		});	
}

Logic2.onclick=()=>{//比较的是我们的，主流时间最长的淘汰
	init();
	C=[M[0].length,M[0].length-1,M[0].length-2];
	console.log("FIFO");
	Plist.forEach((p,i) => {
		// debugger;
		if(i<=2){		//前三个是一定要产生缺页的，所以直接插入
				var w=i;
				var stp;
				for(w;w>=0;w--){
					if(w!=i){
						M[i].splice(w,1,B[w]);		//当没到和当前p匹配的位置时，前面都是引用上一个的数组的值。
					
					}else{
						M[i].splice(w,1,p);
					}				
				}		//复杂度是一个m*n的空间复杂度。
				B=M[i];
				console.log("M["+M[i]+"]");
				// M[i+1]=B;//数组是引用类型，这里会将地址统一到m[0]处，这样后面的变了，前面的理所当然的变了，所以说这里不是用引用类型！！！。
			// debugger;
		}else{//开始判断C，和改变C。//声明一下，如果被命中了，则改处的C的计数从1开始
			
			if(M[i-1].some((value)=>{return value==p;})){//命中了！！这里应该用前一个索引作为当前基准，也就是说不应该是i,应为i是外面的，一直没变。。。	
				
						M[i-1].forEach((element,indx) => {
							M[i].splice(indx,1,element);	
						});
						C.forEach((e,idx)=>{
							C.splice(idx,1,e+1);
						})//命中每一个前面等待的加1。
						pointPage++;
			}else{//没命中的话怎么办呢？比较C数组，决定替换最大的那个，
						var x=C.indexOf(C.reduce((a,b)=>{return a>b?a:b;}));//找到最先来的是谁。
						// debugger;
						M[i-1].forEach((element,indx) => {
								M[i].splice(indx,1,element);
						});
						M[i].splice(x,1,p);
						C.forEach((e,idx)=>{
								C.splice(idx,1,e+1);
						});
						C.splice(x,1,1);//与此同时被替换的位置则重置为1。
			}

		}
	});

	M.forEach((element,index) => {
			// debugger;
			M[index].forEach((e,i)=>{
				console.log(e);
				document.getElementById('result2').innerHTML="<p>["+M+"]</p><br/><p>缺页率："+(Plist.length-pointPage)/Plist.length+"</p>";//这里用innerHTML最后会被覆盖
			})
			
		});	
}


Logic3.onclick=()=>{
	init();
	console.log("LRU");
	init();
	C=[M[0].length,M[0].length-1,M[0].length-2];
	console.log("FIFO");
	Plist.forEach((p,i) => {
		// debugger;
		if(i<=2){		//前三个是一定要产生缺页的，所以直接插入
				var w=i;
				var stp;
				for(w;w>=0;w--){
					if(w!=i){
						M[i].splice(w,1,B[w]);		//当没到和当前p匹配的位置时，前面都是引用上一个的数组的值。
					
					}else{
						M[i].splice(w,1,p);
					}				
				}		//复杂度是一个m*n的空间复杂度。
				B=M[i];
				console.log("M["+M[i]+"]");
				// M[i+1]=B;//数组是引用类型，这里会将地址统一到m[0]处，这样后面的变了，前面的理所当然的变了，所以说这里不是用引用类型！！！。
			// debugger;
		}else{//开始判断C，和改变C。//声明一下，如果被命中了，则改处的C的计数从1开始
			
			if(M[i-1].some((value)=>{return value==p;})){//命中了！！这里应该用前一个索引作为当前基准，也就是说不应该是i,应为i是外面的，一直没变。。。	
				// debugger;
						M[i-1].forEach((element,indx) => {
							M[i].splice(indx,1,element);	
						});
						C.forEach((e,idx)=>{
							if(M[i][idx]==p){
								C.splice(idx,1,1);//和fifo的区别处
							}else{
								C.splice(idx,1,e+1);
							}	
						})//命中每一个前面等待的加1。
						pointPage++;
			}else{//没命中的话怎么办呢？比较C数组，决定替换最大的那个，
						var x=C.indexOf(C.reduce((a,b)=>{return a>b?a:b;}));//找到最先来的是谁。
						// debugger;
						M[i-1].forEach((element,indx) => {
								M[i].splice(indx,1,element);
						});
						M[i].splice(x,1,p);
						C.forEach((e,idx)=>{
								C.splice(idx,1,e+1);
						});
						C.splice(x,1,1);//与此同时被替换的位置则重置为1。
			}

		}
	});

	M.forEach((element,index) => {
			// debugger;
			M[index].forEach((e,i)=>{
				console.log(e);
				document.getElementById('result3').innerHTML="<p>["+M+"]</p><br/><p>缺页率："+(Plist.length-pointPage)/Plist.length+"</p>";//这里用innerHTML最后会被覆盖
			})
			
		});	
}

</script>
</html>
雨净瞎猜
关注
  • 6
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FIFO、OPT、LRU页面置换算法实验代码和截图
ZCL
12-24 1343
一、实验代码 #include<stdio.h> #include<stdlib.h> typedef struct item { int num; int time; }Pro; int pageNum; int memoryNum; void print(Pro *page1); int Search(int num1,Pro *memory1); int main(void) { int i; int curmemory; int missNum; float
【操作系统】进程调度（1）：FIFO（先进先出）算法 原理与实践
热门推荐
X
10-12 2万+
0 前言 本文基于书籍《操作系统导论》。 1 前提铺垫 1.1 进程的设定 我们知道，进行进程调度的前提是 硬件和OS的底层，能够支持上下文切换，这里我们假设已经实现 内存中要有就绪态的进程！ 我们基于第二点，再做进一步的假设，以简化问题，对于已经进入或者即将进入内存的进程，我们它们假设： 工作时间相同 进程同时到达系统 一旦开始，进程保持运行一直到其完成 只使用CPU，不使用IO 运行时间都是已知的 我先来解释一下这几点假设 第2点：意味着有好多个等着被调度进入CPU执行的进程，坐等操作系统“翻
操作系统之页面置换算法——FIFO、OPT和LRU
最新发布
m0_75262255的博客
05-31 3044
操作系统中FIFO、OPT、LRU三种页面替换算法的定义和例题分析
缓存三种常用算法(FIFO、LRU、LFU)
fly_miqiqi的博客
02-23 1465
文章目录FIFO算法LRU(最近最久未使用)算法LFU(最近最少使用)算法 FIFO算法 FIFO思想是先进先出，这是最简单最公平的一种思想。空间满的时候，最先进入的数据先被淘汰。 FIFO算法描述：设计一种缓存结构，构造时确定大小 set(key,value) 将键值对插入该结构，当缓存满，将最先进入缓存的数据置换掉 get(key)：返回key的value值 实现策略：维护一个FIFO队列...
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
流苏的博客
06-15 1万+
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
操作系统：页面置换算法（LRU、FIFO、OPT）
u011843342的博客
12-18 1万+
继续重温操作系统系列知识，页面置换的三种常见算法为：LRU（最近最久未使用）、FIFO（先进先出）、最佳置换。 部分公司的面试会考到LRU的知识。 LRU置换算法 所谓LRU置换算法，单看字面意思较为麻烦，实际上在进行页面置换的过程中，被替换的页面块只需要按照“很久之前使用了，但最近没有使用”的规则进行选取就可以了。不需要考虑后续页面走向是否又需要读入符合上述规则的页面，因为这正是LRU的缺点。 最佳置换算法 这种算法选取被替换页面的时候，遵循以下两点 1.某个页面后续走向永远不会访问到，所以它
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
JAVA实现FIFO、LRU、OPT页面置换算法，有界面
06-28
本项目涉及到了三种经典的页面置换算法：FIFO（先进先出）、LRU（最近最久未使用）以及OPT（最佳页面置换）。这些算法在JAVA环境下实现，并且具备用户界面，便于理解和学习。 1. FIFO（先进先出）页面置换算法： ...
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
4. **算法实现**：编写FIFO和LRU的算法逻辑，处理页面的替换决策。 5. **输入/输出**：设计一种方式输入程序的运行轨迹，例如一个页面访问序列，然后输出缺页次数等性能指标。 6. **性能评估**：对不同工作负载进行...
页面替换算法opt+fifo+lru+clock
06-21
本文将详细探讨四种常见的页面替换算法：OPT（最佳页面替换算法）、FIFO（先进先出页面替换算法）、LRU（最近最少使用页面替换算法）和CLOCK（时钟页面替换算法）。 1. **OPT（最佳页面替换算法）** OPT算法被认为...
操作系统页面置换算法实现，fifo、lfu、lru、opt，界面由MFC实现
03-28
本项目实现了一个模拟器，用于演示和比较四种不同的页面置换算法：FIFO（先进先出）、LFU（最不常用）、LRU（最近最少使用）以及OPT（最佳页面置换）。界面使用Microsoft Foundation Class (MFC)库来创建，使得用户...
操作系统试验(页面置换算法js版)
12-07
操作系统试验(页面置换算法javascript版).用了jquery的简单方法，代码简单易懂。
页面置换算法FIFO LRU OPT
01-04
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率： 要求设计主界面以灵活选择某算法，且以下算法都要实现 1、先进先出算法（FIFO） 2、最近最久未使用算法（LRU） 3、最佳置换算法（OPT）
虚拟内存管理（FIFO、LRU、OPT）
05-08
在一个请求分页系统中，假如系统分配给一个作业的物理块数为 3，且此作业的页面走向为： 2，3，2，1，5，2，4，5，3，2，3，1 试分别求出用FIFO，LRU，OPT三种算法在程序访问过程中所发生的缺页次数及缺页率？（假设最初页面都在外存）
hcq.rar_FIFO OPT LRU
09-20
在这个名为"hcq.rar_FIFO OPT LRU"的压缩包中，包含的课程设计项目专注于三种经典的页面替换算法：FIFO（先进先出）、OPT（最佳页面替换）和LRU（最近最少使用）。下面我们将深入探讨这些算法的工作原理及其重要性。...
实验二 请求式分页存储管理算法设计与实现
qq_41162638的博客
12-04 8010
实验请求式分页存储管理算法设计与实现 1．实验内容：模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断； 2．要求： ① 指令序列的设定可以执行拟定，格式如表3； ② 在完成了FIFO换页策略后，可以选做LRU的换页策略，并进行比较； ③ 作业允许的页架数m在不同情况下的缺页中断率； ④ 程序运行时显示地址转变和页面调入调出过程。 3．步骤： ① 设计页表...
FIFO的基本原理
daijingxin的博客
09-15 1万+
FIFO( First Input First Output)是指先进先出。通常实现跨时钟域的处理有使用异步FIFO（结合格雷码）、锁存+握手信号和使用DMUX电路这几种方法在系统设计中，以增加数据传输率、处理大量数据流、匹配具有不同传输率的系统为目的而广泛使用FIFO存储器，从而提高了系统性能。FIFO存储器是一个先入先出的双口缓冲器，即第一个进入其内的数据第一个被移出，其中一个是存储器的输入口，另一个口是存储器的输出口。对于单片FIFO来说，主要有两种结构：触发导向结构和零导向传输结构。触发导向传输结构
页面置换算法（FIFO、第二次机会、LRU）
qq_46045632的博客
01-30 9326
页面置换算法 文章目录页面置换算法前言一、最近未使用页面置换算法二、先进先出页面置换算法三、第二次机会页面置换算法四、时钟页面置换算法四、最近最少使用页面置换算法四、最不常用算法总结 前言 当发生缺页中断时，操作系统必须在内存中选择一个页面将其换出内存，以便为即将调入的页面腾出空间。如果要换出的页面在内存驻留期间已经被修改过，就必须把它写回磁盘以更新该页面在磁盘上的副本，如果该页面没有被修改过，那么它在磁盘上的副本已经是最新的,不需要回写。直接用调入的页面覆盖被淘汰的页面就可以了。 当发生缺页中断时，
(王道计算机组成原理)第三章存储系统-第五节3：Cache替换算法（FIFO,近期最少使用算法-LRU，LFU）
快乐江湖的博客
08-31 1万+
文章目录一：随机算法（RAND）二：先进先出算法（FIFO）三：近期最少使用算法（LRU）——效率最高四：最不经常使用算法（LFU） (计算机组成原理)第三章存储系统-第六节2：Cache和主存的映射方式（全相联映射、直接映射和组相连映射）中我们讲到了Cache和主存之间的映射关系，细致分析了三种映射方式各自的特点。那么下一个亟待解决的问题就是：Cache是很小的，主存却很大，如果Cache满了应该怎么办？ 这也就是本节的主题——Cache的替换算法。需要注意的时不同映射方式其替换机制不同 全相联映射：C
页面置换算法（C++编写）.doc
05-06
页面置换算法（C++编写）.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值