存储管理-请求页式管理中页面置换算法模拟设计

已于 2024-01-29 11:13:34 修改
阅读量504 收藏 2
点赞数
分类专栏： 操作系统 文章标签： java
于 2023-06-09 16:27:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68563008/article/details/131129420
版权

目录

 

目标

具体设计：

要求

分析

代码实现

运行结果

算法命中率比较

 

目标

通过请求页式管理中页面置换算法模拟设计，计算并输出下属算法在不同内存容量下的命中率，比较算法优劣。

1）先进先出的算法（FIFO）；

2）最近最少使用算法（LRU）；

具体设计：

要求

a、 终端先显示：

Start memory management.

Producing address flow, wait for while, please.

b、 地址流、地址页号流生成后，终端显示：

There are algorithms in the program

1、 Optimization algorithm

2、 Least recently used algorithm

Select an algorithm number, please.

用户输入适当淘汰算法的号码，并按回车，若是第一次选择，输出相应的

地址页号流。然后输出该算法分别计算的用户内存从 2k~32k 时的命中率，

若输入的号码不再 1~2 中，则显示：

there is not the algorithm in the program,并重复 b。

c、 输出结果后，终端显示 “do you try again with anther algorithm(y/n)”。若键

入 y 则重复 b,否则结束

分析

使指令的地址按下述原则生成：

1） 50%的指令是顺序执行的

2）25%的指令是均匀分布在前地址部分

3）25%的指令是均匀分布在后地址部分

解决方案：

1） 在[0，319]的指令地址之间随机选取一起点 m；

2） 顺序执行一条指令，即执行地址为 m+1 的指令；

3） 在前地址[0，m]中随机选取一条指令并执行，该指令的地址为 m’；

4）顺序执行一条指令，地址为 m’+1 的指令

5） 在后地址[m’+2，319]中随机选取一条指令并执行；

6） 重复上述步骤 1）~5），直到执行 320 次指令

public void commandSequence() {
	Random rand=new Random();
		int i=0;	
		while(i<320) {
			int m=rand.nextInt(320);		
			num[i++]=m+1;
			int m1=rand.nextInt(m+1);
			num[i++]=m1;
			num[i++]=m1+1;
			if(m1<317) {
			int m2=rand.nextInt(317-m1)+m1+2;
			num[i++]=m2;}
		}

FIFO

该算法先淘汰的是最先进入内存的页面，考虑把进入内存的页面按进入时间先后次序链接成队列， 如果即将访问的数据在物理块中，跳过； 如果不在物理块中，顺序添到物理块中，缺页数+1；如果物理块满了，替换最先进的队头，缺页数+1；

public void FIFO(int msize) {
		/*
		 * 如果即将访问的数据在物理块中，跳过； 如果不在物理块中，添到物理块中，缺页数+1；如果物理块满了，替换最先进的，缺页数+1；
		 */
		
		LinkedList<Integer> list = new LinkedList<Integer>();
		
		//commandSequence();
		int misspage = 0;// 缺页数
		//int page[]=new int[32];
		for (int i = 0; i < page.length; i++) {

			if (list.contains(page[i])) {
				continue;
			} else {
				if (list.size() !=msize) {
					list.addLast(page[i]);
					misspage++;
				} else {
					list.removeFirst();
					list.addLast(page[i]);
					misspage++;
				}
			}
		}
		double targetpage=1.0-(misspage/10*1.0/32);
		System.out.println("内存空间（物理块）为" + msize + "时\n，缺页数为：" +misspage + "\n命中率为：" +targetpage + "\n");
	}

LRU

它淘汰的是最近最久未被访问的页面，还是先把他们先链接起来，如果即将要访问的数据在物理块内，标记其已存在的序列下标，删除它再在末尾重新添加；如果将要访问的数据不在物理块内，添加到物理块，缺页数+1；如果满了，替换最久未访问的头，缺页数+1；

public void LRU(int msize) {
		/*
		 * 如果即将要访问的数据在物理块内，标记其已存在的序列下标，删除它再在末尾重新添加
		 * 如果将要访问的数据不在物理块内，添加到物理块，缺页数+1；如果满了，替换最久未访问的
		 */
		
		int misspage = 0;
		LinkedList<Integer> list = new LinkedList<Integer>();
		for (int i = 0; i < page.length; i++) {
			if (list.contains(page[i])) {
				int flag = list.indexOf(page[i]);// 标记序列下标
				list.remove(flag);
				list.addLast(page[i]);
			} else {
				if (list.size() != msize) {
					list.addLast(page[i]);
					misspage++;
				} else {
					list.removeFirst();
					list.addLast(page[i]);
					misspage++;
				}
			}

		}
		double targetpage=1.0-(misspage*1.0/10/32);
		System.out.println("内存空间（物理块）为" + msize + "时\n，缺页数为：" + misspage + "\n命中率为：" +targetpage+ "\n");
		
	}

代码实现

package com.as.storage;

import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;

public class Manage {
	int num[] = new int[320];// 指令序列
	int page[] = new int[320];// 对应的页码
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int choice = 0;
		System.out.println("Start memory management \n Producing address flow ,wait for while,please.\n");
		Manage my = new Manage();
		my.commandSequence();
		
		while (true) {
			System.out.println(
					"There are algorithms in the program\n1、First in first out algorithm\n2、Least recently used algorithm\nSelect an algotithm number,please.(0-exit)\n");
			try {
				choice = sc.nextInt();
			} catch (InputMismatchException e) {
				System.out.println("输入数据格式有误，请重新输入！");
				sc.nextInt();
				continue;
			}
			switch (choice) {
			case 1:
				for (int msize = 4; msize <= 32; msize++) {
					my.FIFO(msize);
				}
				
				break;
			case 2:
				for (int msize = 4; msize <= 32; msize++) {
					my.LRU(msize);
				}
				break;
			default:
				System.out.println("there is not the algorithm in the program,please select the number again(1-4)");
				break;
			}
			System.out.println("do you try again with another algorithm(y/n)?");
			String cho;
			try{
				cho=sc.next().toLowerCase();
			}catch (InputMismatchException e) {
				System.out.println("输入数据格式有误，请重新输入！");
				sc.nextInt();
				continue;
			}
			if(cho.equals("n")) {
				sc.close();break;
			}else if(cho.equals("y")) {sc.nextLine();}
			else {System.out.println("无效输入，请输入y/n!!!");}

		}

	}
	

	public void commandSequence() {
	Random rand=new Random();
		int i=0;	
		while(i<320) {
			int m=rand.nextInt(320);		
			num[i++]=m+1;
			int m1=rand.nextInt(m+1);
			num[i++]=m1;
			num[i++]=m1+1;
			if(m1<317) {
			int m2=rand.nextInt(317-m1)+m1+2;
			num[i++]=m2;}
		}
		
		
		System.out.println("***************生成320个随机数据*****************");
		for (int j = 0; j < 320; j++) {
			System.out.print(num[j] + "\t");
			if ((j+1)% 10 == 0) {
				System.out.println();
			}
		}
		System.out.println("*********************对应的页码数************************");
		for (int k = 0; k < 320; k++) {
			page[k] = num[k] / 10;
			System.out.print(page[k] + "\t");
			if ((k+1) % 10 == 0) {
				System.out.println();
			}
		}

	}

	/**
	 * 先进先出
	 */
	public void FIFO(int msize) {
		/*
		 * 如果即将访问的数据在物理块中，跳过； 如果不在物理块中，添到物理块中，缺页数+1；如果物理块满了，替换最先进的，缺页数+1；
		 */
		
		LinkedList<Integer> list = new LinkedList<Integer>();
		
		//commandSequence();
		int misspage = 0;// 缺页数
		//int page[]=new int[32];
		for (int i = 0; i < page.length; i++) {

			if (list.contains(page[i])) {
				continue;
			} else {
				if (list.size() !=msize) {
					list.addLast(page[i]);
					misspage++;
				} else {
					list.removeFirst();
					list.addLast(page[i]);
					misspage++;
				}
			}
		}
		double targetpage=1.0-(misspage/10*1.0/32);
		System.out.println("内存空间（物理块）为" + msize + "时\n，缺页数为：" +misspage + "\n命中率为：" +targetpage + "\n");
	}

	/**
	 * 最近最少使用
	 */
	public void LRU(int msize) {
		/*
		 * 如果即将要访问的数据在物理块内，标记其已存在的序列下标，删除它再在末尾重新添加
		 * 如果将要访问的数据不在物理块内，添加到物理块，缺页数+1；如果满了，替换最久未访问的
		 */
		
		int misspage = 0;
		LinkedList<Integer> list = new LinkedList<Integer>();
		for (int i = 0; i < page.length; i++) {
			if (list.contains(page[i])) {
				int flag = list.indexOf(page[i]);// 标记序列下标
				list.remove(flag);
				list.addLast(page[i]);
			} else {
				if (list.size() != msize) {
					list.addLast(page[i]);
					misspage++;
				} else {
					list.removeFirst();
					list.addLast(page[i]);
					misspage++;
				}
			}

		}
		double targetpage=1.0-(misspage*1.0/10/32);
		System.out.println("内存空间（物理块）为" + msize + "时\n，缺页数为：" + misspage + "\n命中率为：" +targetpage+ "\n");
		
	}

}

运行结果

f6672d67e3684b54a3d9e1df00d33d00.png

 71d0dcac9c9e4842aeff796504d67c5f.png      bb3c2596810d4763b0fbb5b22ab75598.png

 f584f8e0e3b64414ac82f733a50fb0b0.png                    2cc9634e31324110bb5073e124387e4a.png

 

      aa20d55e8c9b449c849ffa5ca80a7a82.png                           739bab32086243a780806b336e401954.png

 

算法命中率比较

当用户的内存容量（物理块大小）增加时，命中率也随之增加，到内存容量32的时候，基本在90%的命中率。

比较下来内存容量在20左右以下的时候，FIFO命中率大多更高些，以上的话，LRU更高些；

 

 

 

42341352315125115
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
《计算机操作系统》请求页式存储管理中页面置换算法的模拟设计
02-07
《计算机操作系统》请求页式存储管理中页面置换算法的模拟设计
页面置换算法模拟程序课程设计报告
03-01
详细的页面置换算法模拟程序课程设计报告，清晰明了的设计步骤，全面展示页面置换算法与其他算法的区别。
存储管理
愿戎马一生，归来仍少年
04-27 384
结合虚拟技术，分析了虚拟内存空间的分页式存储，页面置换算法、高速缓存、与磁盘I/O交换技术。最后提到分段技术，并与分页进行简单的对比
页面置换算法模拟实现（C）
Qxxchampion的博客
05-17 2075
页面置换算法模拟实现C语言代码 #include "stdio.h" #include "stdlib.h" typedef struct item { int num; //页号 int time; //等待时间，LRU算法会用到这个属性 }Pro; int pageNum; //系统分配给作业的主存中的页面数 int memoryNum; //可用内存页面数 void print(Pro *page1); //打印当前主存中的页面 int Search(int num1, Pro
Java模拟页式管理过程_java实现页式存储管理
weixin_39611382的博客
03-01 484
123.png基本框架屏幕快照 2017-11-24 12.41.42.pngpage.java//page类package pagedStorageManagement;public class page {private int pageNumber;//页号private int physicsNumber;//物理页号private boolean state;//状态位private i...
操作系统-请求页式存储管理中常用页面置换算法模拟
he5895的博客
11-06 5788
请求页式存储管理中常用页面置换算法模拟 先进先出调度算法（FIFO）、最近最少调度算法（LRU）、最近最不常用调度算法（LFU）、最优调度算法（OPT）。
页式存储管理： 最佳置换(OPT)--先进先出页面置换(FIFO)--最久未使用置换(LRU)
weixin_46048542的博客
04-15 5316
实验题目 设计和实现最佳置换算法、先进先出置换算法、最近最久未使用置换算法、页面缓冲置换算法；通过页面访问序列随机发生器实现对上述算法的测试及性能比较。 实验要求 假设前提 模拟的虚拟内存的地址为16位，页面大小为1K，模拟的物理内存有32K； 页表用整数数组或结构数组来表示； 页面访问序列串是一个整数序列，整数的取值范围为0到N - 1。页面访问序列串中的每个元素p表示对页面p的一次访问。 性能测评及问题说明 测试不同的页面访问序列及不同的虚拟内存尺寸，并从缺页率、算法开销等方面对各个算法进行比较。（
c语言 请求页式存储管理,存储管理之分页存储管理方式C语言模拟（实验五）
weixin_42515301的博客
05-17 1284
#include #define PAGE 20int memory[PAGE];struct page{ //描述进程信息int process;int page_num;int user[PAGE];int f;page(){f = 0;process = 0;page_num = 0;memset(user,0,PAGE);}};struct page *Mem = new page[PAG...
请求页式存储管理中常用页面置换算法模拟
02-24
请求页式存储管理中常用页面置换算法模拟
操作系统课程设计——页面置换算法模拟实现
02-24
通过对请求页式存储管理中页面置换算法的模拟设计，掌握请求页式存储管理页面置换算法，并进一步理解虚拟存储技术的原理及特点。 设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰...
请求页式存储管理中常用页面置换算法模拟.doc
05-12
请求页式存储管理中常用页面置换算法模拟.doc
实验报告3页面置换算法演示.doc
08-23
页面置换算法演示 实验目的 1. 分析内存管理办法中每个页面置换算法原理； 2. 掌握页面置换算法执行过程。 二、实验预备内容 1. 熟悉内存管理办法； 2. 熟悉页面置换算法原理； 3. 熟悉不同页面置换算法的置换过程。 要求自选编程语言实现最佳置换算法、先进先出页面置换算法和最近最久未使用置换算法的演示置换过程，并给出运行结果（置换次数和缺页率）。
页式存储管理（FIFO）实现
02-10
通过编写和调试请求页式存储管理的模拟程序以加深对请求页式存储管理方案的理解。 为了简单起见。页面淘汰算法采用 FIFO页面淘汰算法，并且在淘汰一页时，判断它是否被改写过，如果被修改过，将它写回到辅存。
请求调页存储管理方式模拟
01-14
假设每个页面中可存放10条指令，分配给作业的内存块数为4。 用C语言语言模拟一个作业的执行过程，该作业共有320条指令， 即它的地址空间为32页，目前它的所有页都还未调入内存。在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。如果所访问的指令还未装入内存，则发生缺页，此时需要记录缺页的次数，并将相应页调入内存。如果4个内存块均已装入该作业，则需要进行页面置换，最后显示其物理地址，并转向下一条指令。在所有320条指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。 置换算法：请分别考虑最佳置换算法（OPT）、先进先出（FIFO）算法和最近最久未使用算法（LRU）。 作业中指令的访问次序按下述原则生成： 50%的指令是顺序执行的； 25%的指令是均匀分布在前地址部分； 25%的指令是均匀分布在后地址部分； 具体的实施方法是： 　　　在[0，319]的指令地址之间随机选取一起点m； 　　　顺序执行下一条指令，即执行地址序号为m+1的指令； 　　　通过随机数，跳转到前地址部分[0,m+1]中的某条指令处，其序号为m1； 　　　顺序执行下一条指令，其地址序号为m1+1的指令； 　　　通过随机数，跳转到后地址部分[m1+2，319]中的某条指令处，其序号为m2； 　　　顺序执行下一条指令，其地址序号为m2+1的指令； 重复跳转到前地址部分，顺序执行，跳转到后地址部分，顺序执行的过程直至执行320条指令。
请求分页储存管理的页置换算法模拟.exe
06-16
C++编写的请求分页储存管理的页置换算法模拟程序，模拟OPT，FIFO和LRU算法。可以输入序列也可以随机生成访问序列。可以输出整个调度的流程（表），缺页次数和缺页率。
2.3.1操作系统-存储管理：页式存储、逻辑地址、物理地址、物理地址逻辑地址之间的地址关系、页面大小与页内地址长度的关系、缺页中断、内存淘汰规则
郝开的博客
03-09 2929
页的大小一般是以KB为单位的，相对来说，页面大小比较小。在页式存储中，对于内存进行页面分配的时候，要么页面空闲，我们把它塞满，要么它已经占用了，一般可以利用到的碎片空间都可以利用，如果碎片空间小于页面大小，才不能够使用，所以在分配内存的时候，空闲的碎片一般会小于页面大小，空间利用率高，分配管理起来就比较简单。但也正因为如此，页面太过于零碎，所以每次都需要查表去找相应的页面，这样增加了系统的开销；以页面位单位来进行调度的时候可能会产生抖动现象。
实验二 请求式分页存储管理算法设计与实现
qq_41162638的博客
12-04 7869
实验请求式分页存储管理算法设计与实现 1．实验内容：模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断； 2．要求： ① 指令序列的设定可以执行拟定，格式如表3； ② 在完成了FIFO换页策略后，可以选做LRU的换页策略，并进行比较； ③ 作业允许的页架数m在不同情况下的缺页中断率； ④ 程序运行时显示地址转变和页面调入调出过程。 3．步骤： ① 设计页表...
存储管理之虚拟存储器实现（页面置换算法的模拟）
代码不会敲的博客
04-27 4251
页面置换算法 先进先出算法（FIFO）： 先进先出算法是最简单的分页替换算法，是指每次有新的分页需要调入时，会选择调入内存时间最久的分页换出。它简单，容易实现，但这种绝对的公平方式容易导致效率的降低。 --------发生缺页中断时，即最先进来的淘汰出去 最近最久未使用算法（LRU）算法： 即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的。即最近最
虚拟存储管理：C语言实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance
yoyo_hu的博客
03-14 3310
1 实验内容：虚拟存储管理。 编写一个 C程序模拟实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance，并设计输入用例验证结果。 2 程序所涉及到的算法介绍以及相关实现函数 在计算机操作系统使用分页的虚拟内存管理，页面置换算法决定哪些内存页页出，有时也被称为换出，或写入到磁盘上，当一个页面被分配的内存需求。当请求的页面不在内存中（页面错误）并且空闲页面无法用于满足分配时，就会发生页面替换，要么是因为没有页面，要么是因为空闲页
请求页式存储管理中页面置换算法实验代码
最新发布
05-22
这里是一个简单的页面置换算法（FIFO）的实验代码，用C++语言编写： ```c++ #include <iostream> #include <queue> #include <vector> using namespace std; int main() { int n, m; // n为物理块数，m为访问序列长度 cout << "请输入物理块数和访问序列长度："; cin >> n >> m; vector<int> sequence(m); // 访问序列 cout << "请输入访问序列："; for (int i = 0; i < m; i++) { cin >> sequence[i]; } queue<int> page_frames; // 物理块队列 int page_faults = 0; // 缺页次数 for (int i = 0; i < m; i++) { int page = sequence[i]; // 当前访问的页面 bool page_found = false; for (int j = 0; j < page_frames.size(); j++) { if (page_frames.front() == page) { page_found = true; break; } page_frames.push(page_frames.front()); page_frames.pop(); } if (!page_found) { // 缺页 page_faults++; if (page_frames.size() < n) { // 物理块未满 page_frames.push(page); } else { // 物理块已满，进行页面置换 page_frames.pop(); page_frames.push(page); } } } cout << "缺页次数为：" << page_faults << endl; return 0; } ``` 该实验代码演示了FIFO页面置换算法的过程，通过输入物理块数和访问序列，模拟了页面在物理块中的存储和替换，最终输出了缺页次数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

42341352315125115

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值