（操作系统实验）内存页面淘汰算法---FIFO、LRU、OPT

最新推荐文章于 2024-08-16 15:19:46 发布
最新推荐文章于 2024-08-16 15:19:46 发布
阅读量2.9k 收藏 30
点赞数 3
分类专栏： 操作系统基础篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccnuacmhdu/article/details/84112746
版权

算法介绍

参考操作系统或计算机组成原理相关教材，很容易理解，介绍略。可以参考笔者后续实验结果，有助于理解算法。

源代码

由于算法简单，不再进行画图设计思路，笔者直接编写代码，遇到问题随之解决。下面是源代码文件，只有一个文件，Main.java，使用文件输入，输入文件是in.txt，注意把该输入文件和Main.java放在同一个文件夹下，再用命令行编译运行即可。


import java.util.*;
import java.io.*;
import java.time.format.FormatStyle;

public class Main{
//仅仅为了操作方便，本程序就是用面向对象的语言写结构化程序，都是public级别

	public ArrayList<Integer> pageList;//页走向序列
	public ArrayList<Integer> pageTable;//这个是存储页的表
	public int size;//页框大小
	public ArrayList<String> pathList;//用于记录路径
	public int missingPage;
	public static final int MAX = 10000;

	public Main(){}

	public static void main(String[] args){
		new Main().run();
	}

	public void run(){
		this.input();//文件输入数据
		System.out.print("请输入页框大小：");
		Scanner scan = new Scanner(System.in);
		this.size = scan.nextInt();
		this.OPT();
		this.FIFO();
		this.LRU();
	}
	
	public void input(){
		pageList = new ArrayList<Integer>();
		pageTable = new ArrayList<Integer>();
		pathList = new ArrayList<String>();
		try{
			File file = new File("in.txt");
			BufferedReader br = new BufferedReader(new FileReader(file));
			String str = br.readLine(); 
			if(str!=null){
				String[] splits = str.split(" ");
				for(int i = 0; i < splits.length; i++){
					this.pageList.add(Integer.valueOf(splits[i]));
				}	
			}
			br.close();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	public void print(){
		
		System.out.println("--------------------------------------------------------------------");
		System.out.print("pages");
		for(int i = 0; i < pageList.size(); i++){
			System.out.print(" "+pageList.get(i));
		}
		System.out.println();
		for(int i = 0; i < size; i++){
			System.out.print("page"+(i+1));
			for(int j =0; j< pathList.size(); j++){
				System.out.print("\t"+pathList.get(j).charAt(i));
			}
			System.out.println();
		}
		System.out.print("     ");
		for(int j =0; j< pathList.size(); j++){
			System.out.print("\t"+pathList.get(j).charAt(pathList.get(j).length()-1));
		}
		System.out.println();
		System.out.println("共发生"+missingPage+"次缺页中断");
		System.out.println("--------------------------------------------------------------------");
		System.out.println();
	}

	public void OPT(){
		boolean missingPageMark = false;
		missingPage = 0;
		for(int i = 0; i < this.pageList.size(); i++){
			missingPageMark = false;
			if(pageTable.size() < this.size){//如果当前页框尚没有满
				if(pageTable.contains(pageList.get(i))==false){
					missingPageMark = true;
					pageTable.add(0, pageList.get(i));
					missingPage++;
				}else {
					
				}
				
			}else{
				if(pageTable.contains(pageList.get(i))){//页框中含有该页
					
				}else{//缺页中断
					missingPageMark=true;
					missingPage++;
					//搜索一下当前表中的每个页距离下次出现还有多少距离
					int[] distances = new int[size];
					for(int j = 0; j < size; j++){
						int tmpCnt = 1;
						boolean flag = false;//标志下是否能找到再次出现
						for(int k = i; k < pageList.size(); k++){
							if(pageList.get(k) != pageTable.get(j)){
								tmpCnt++;
							}else{
								flag =true;
								break;
							}
						}
						if(flag){
							distances[j] = tmpCnt;
						}else{
							distances[j] = MAX;
						}
					}
					int max = -1;
					int loc = -1;
					//找到最大距离的页的位置
					for(int kk = 0; kk < size; kk++){
						if(distances[kk] > max){
							max = distances[kk];
							loc = kk;
						}
					}
					//把该页替换掉即可
					pageTable.set(loc, pageTable.get(0));
					pageTable.set(0, pageList.get(i));
				}
			}
			//记录路径
			String pathTmp = "";
			for(int m=0; m<pageTable.size();m++){
				pathTmp += pageTable.get(m);
			}
			for(int m = pageTable.size(); m< size; m++){
				pathTmp += " ";
			}
			if(missingPageMark) {pathTmp+="X";}
			else {pathTmp+="√";}
			pathList.add(pathTmp);
		}
		System.out.println("OPT:");
		print();
		pageTable.clear();//清空页表
		pathList.clear();
	}
	
	public void FIFO(){
		missingPage=0;
		boolean missingPageMark = false;
		for(int i = 0; i < this.pageList.size(); i++){
			missingPageMark=false;
			
			if(pageTable.size() < this.size){//如果当前页框尚没有满
				if(pageTable.contains(pageList.get(i))==false){
					missingPageMark = true;
					pageTable.add(0, pageList.get(i));
					missingPage++;
				}else {
					if(pageTable.size()==1) {
						
					}else {
						pageTable.remove(pageList.get(i));
						pageTable.add(0, pageList.get(i));
					}
				}
			}else{
				if(pageTable.contains(pageList.get(i))){//页框中含有该页
					
				}else{//缺页中断
					missingPageMark=true;
					missingPage++;
					pageTable.add(0, pageList.get(i));	
					pageTable.remove(pageTable.size()-1);
				}
			}
			//记录路径
			String pathTmp = "";
			for(int m=0; m<pageTable.size();m++){
				pathTmp += pageTable.get(m);
			}
			for(int m = pageTable.size(); m< size; m++){
				pathTmp += " ";
			}
			if(missingPageMark) {pathTmp+="X";}
			else {pathTmp+="√";}
			pathList.add(pathTmp);
		}
		System.out.println("FIFO:");
		print();
		pageTable.clear();//清空页表
		pathList.clear();
	}
	
	public void LRU(){
		missingPage=0;
		boolean missingPageMark = false;
		for(int i = 0; i < this.pageList.size(); i++){
			missingPageMark=false;
			if(pageTable.size() < this.size){//如果当前页框尚没有满
				if(pageTable.contains(pageList.get(i))==false){
					missingPageMark = true;
					pageTable.add(0, pageList.get(i));
					missingPage++;
				}else {
					if(pageTable.size()==1) {
						
					}else {
						pageTable.remove(pageList.get(i));
						pageTable.add(0, pageList.get(i));
					}
				}
			}else{
				if(pageTable.contains(pageList.get(i))){//页框中含有该页
					pageTable.add(0, pageList.get(i));
					pageTable.remove(pageTable.size()-1);
				}else{//缺页中断
					missingPageMark=true;
					missingPage++;
					pageTable.add(0, pageList.get(i));	
					pageTable.remove(pageTable.size()-1);
				}
			}
			//记录路径
			String pathTmp = "";
			for(int m=0; m<pageTable.size();m++){
				pathTmp += pageTable.get(m);
			}
			for(int m = pageTable.size(); m< size; m++){
				pathTmp += " ";
			}
			if(missingPageMark) {pathTmp+="X";}
			else {pathTmp+="√";}
			pathList.add(pathTmp);
		}
		System.out.println("LRU:");
		print();
		pageTable.clear();//清空页表
		pathList.clear();
	}
	
}

输入文件in.txt的数据如下：
4 3 2 1 4 3 5 4 3 2 1 5

在这里插入图片描述

Only you, only you!
关注
专栏目录
6. （操作系统实验）内存页面淘汰算法---FIFO、LRU、OPT
qq_45134373的博客
04-17 1577
算法参考
opt, lru, fifo, lfu等页面置换算法的python实现
qq_38520400的博客
05-29 1693
页面置换算法（opt, lru, fifo, lfu) python （1） 通过计算不同算法的命中率比较算法的优劣。同时也考虑了用户内存容量对命中率的影响。 页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。 在本实验中，假定页面大小为1k，用户虚存容量为32k，用户内存容量为4页到32页。 （2） produce_addstream通过随机数产生一个指令序列，共320条指令。...
操作系统课设 分页式存储管理（内含OPT，FIFO，LRU，LFU四种算法，用到了线程）
01-13
操作系统课设 分页式存储管理（内含OPT，FIFO，LRU，LFU四种算法，用到了线程），用eclipse打开，我给的是创建的整个源包，打开就可以运行，这个是经过最佳改正过的
操作系统虚拟内存中的四种典型页替换算法(OPT,LRU,FIFO,Clock)
热门推荐
haoshen's blog
10-24 3万+
页面置换：在地址映射过程中，若在页面中发现所要访问的页面不再内存中，则产生缺页中断(page fault)。当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。    典型的置换算法有四种，如下所示：  OPT：最佳替换算法（optional replacement）。替换下次访问距当前时间最长的页。opt算法需要知道操作系统将来的事件，显然不可
算法：LRU（Least Recently Used）
最新发布
AWSDN的博客
08-16 561
本文主要介绍LRU的知识
操作系统 淘汰算法 FIFO算法
06-09
对于动态页式存储管理 采用FIFO淘汰算法的实现 采用静态方法在程序中输入 当然动态的稍作改变即可实现
页面置换算法（OPT、FIFO、LRU）实现--C++版本-页面置换算法（Optimal、FIFO、LRU）
12-18
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面...
FIFO-LRU-OPT-Clock.rar_LRU Clock OPT_OPT_OPT FIFO LRU_clock页面置换_
09-22
本资料包主要涵盖了四种常见的页面置换算法：FIFO（先进先出）、LRU（最近最久未使用）、OPT（最佳页面置换）以及NUR（最近未使用）。下面将对这四种算法进行详细阐述。 首先，FIFO（First In First Out）是最简单...
操作系统实验之页面置换算法（FIFIO、OPT、LRU）
11-29
代码主体非本人原创，主要内容来源于：https://blog.csdn.net/houchaoqun_xmu/article/details/55541715，由于原代码测试中有些问题，因此我经过修改...可以实现LRU、OPT、FIFO算法打印置换情况并计算缺页数、缺页率。
FIFO、OPT、LRU页面置换算法实验代码和截图
12-24
实验代码中，程序首先会提示用户输入系统分配给作业的主存中的页面数和内存页面数，然后用户可以选择使用FIFO、OPT或LRU页面置换算法。对于每种算法，程序都会统计缺页次数和缺页率。 对于FIFO页面置换算法，程序会...
操作系统实验五 虚拟内存页面置换算法
02-02
操作系统实验五 虚拟内存页面置换算法（内含源代码和详细实验报告），详细介绍：http://blog.csdn.net/xunciy/article/details/79239096
内存FIFO页面置换算法 C++
06-13
用一种计算机高级语言来实现请求分页存储管理方式先进先出（FIFO）置换算法，设计要求如下： ⑴ 能够输入给作业分配的内存块数； ⑵ 能够输入给定的页面，并计算发生缺页的次数以及缺页率； ⑶ 缺页时，如果发生页面置换，输出淘汰的页号。
【南邮操作系统实验】页面置换算法 （FIFO、LRU、OPTP）
TTz012的博客
11-28 1151
写在前面 操作系统内存管理的页面置换算法，因为懒得看老师给的代码（太长了而且据说好像还有错误）就自己写了一个python版本的，因为比较菜，所以写的一般般，仅供大伙参考一下Orz python版本的 代码如下： import random #生成n个页面请求 def Page_Request(n): pagerequest_list = [] for i in range(n): tmp = random.randint(0,20) pagereques
操作系统实验--页面置换算法（OPT/FIFO/LRU/LFU）cpp
qq_43721935的博客
05-17 1775
前言 学习笔记 void IntoPage(int m);//将第m条指令转化为对应的页数 int isInside(int number,int Msize);//判断页号是否在内存中 void OPT(int num,int Msize);//最佳置换算法（OPT） void FIFO(int num,int Msize);//先进现出置换算法（FIFO） void LRU(int num,int Msize);//最近最久未使用置换算法（LRU） void LFU(int num,int Msize
操作系统：页面淘汰/置换算法。JAVA实现
weixin_45038876的博客
10-02 534
【题目要求】通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。 针对一个页框，根据实验数据，以OPT算法为参考，研究FIFO页面淘汰算法、LRU页面淘汰以及CLOCK算法针对同一批实验数据的缺页率，以及研究在不同页框设置下的各算法缺页率表现情况。 页面引用序列为：4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5 （1）固定分配局部置换情况下，驻留集大小为3，针对该内存页面引
操作系统实验--页面替换算法（FIFO,OPT,LRU）
qq_42481935的博客
01-22 788
#include<iostream> #include<string.h> #include<iomanip> using namespace std; int N;//物理块的个数 int M;//页面序列中页面的个数 int block[N];//物理块数组 int page[M];//页面序列数组 int FIFO(); int LRU(); int O...
操作系统实验（2）-- 模拟操作系统的页面置换 LRU OPT FIFO
小邓笔记
06-03 7666
一、实验内容 （1）设程序中地址范围为0 到32767 ，采用随机数生成256 个指令地址，满足50%的地址是顺序执行，25%向前跳，25% 向后跳。为满足上述条件，可采取下列方法：设d0=10000，第 n个指令地址为dn，第 n+1 个指令地址为dn+1 ，n的取值范围为0 到255。每次生成一个 1 到1024范围内的随机数a，如果a落在1 到512 范围内，则dn+1 =dn+1。如果a
操作系统实验三-----内存管理
GOV_D的博客
07-13 1606
一、实验目的 1、了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。 2、了解程序设计技术和内存泄露的原因 二、实验内容 模拟实现请求页式存储管理的几种基本页面置换算法 （1）最佳淘汰算法（OPT） （2）先进先出的算法（FIFO） （3）最近最久未使用算法（LRU）） 二、实验原理  UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调
操作系统缺页中断-FIFO、LRU、OPT算法实现
kr2563的博客
11-19 894
目前只针对于三个页框的实现，笔者后续实现人页框的自由调整。 // Exercise4.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #include &lt;iostream&gt; using namespace std; int pageList[12] = {4,3,2,1,4,3,5,4,3,2,1,5}; /*检测该页号是否已经存入*/ i...
操作系统实验：页面置换算法-OPT, FIFO, LRU模拟
该文档是关于操作系统实验报告，主要探讨了三种页面置换算法：OPT（最佳页面置换算法）、FIFO（先进先出页面置换算法）和LRU（最近最久未使用页面置换算法）。实验中使用C语言编写了相应的算法模拟程序，并提供了...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值