模拟操作系统的页面置换

最新推荐文章于 2024-02-13 18:23:39 发布
最新推荐文章于 2024-02-13 18:23:39 发布
阅读量972 收藏
点赞数
分类专栏： 算法&数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piwwwiq/article/details/9104265
版权

这个实验要求有点神奇,所以按照书上的要求写了

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import java.util.*;

/*
 *  @author Anima_libera
 */

/*
 * display
 */
public class Display extends JFrame implements ActionListener{
	
	/*
	 * 程序入口
	 */
	public static void main(String args[]){
		new Display();
	}
	
	/*
	 * 变量
	 */
	private int arr[],time[],blockArr[];
	private int lack = 0;
	
	private JPanel centre = new JPanel();
	private JPanel choice = new JPanel();
	private JPanel top = new JPanel();
	private JPanel cal = new JPanel();
	private JPanel par = new JPanel();
	private JPanel author = new JPanel();
	private JPanel chopar = new JPanel();
	
	private int pageNum,blockNum;
	
	private JButton create = new JButton("生成序列");
	
	private ButtonGroup bg = new ButtonGroup();
	
	private JLabel authorLab[] = new JLabel[3];
	private JLabel parLab[] = new JLabel[2];
	private JLabel calLab[] = new JLabel[2];
	
	private JTextField parJTF[] = new JTextField[2];
	private JTextField calJTF[] = new JTextField[2];
	
	private JScrollPane JSP[] = new JScrollPane[2];
	
	private JTextArea order = new JTextArea();
	private JTextArea JTA = new JTextArea();
	
	private JRadioButton choBut[] = new JRadioButton[3]; 

	
	/*
	 * 构造函数
	 */
	Display(){
		setTitle("页面置换");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(800,700);
		init();
		setVisible(true);
	}
	
	/*
	 * 初始化
	 */
	public void init(){
		initTop();
		initCal();
		initCent();
	}
	/*
	 * 事件处理
	 */
	public void actionPerformed(ActionEvent e){
		if(parJTF[0].getText().toString().matches("[0-9]+") && parJTF[1].getText().toString().matches("[0-9]+")){
			blockNum = Integer.parseInt(parJTF[0].getText().toString());
			pageNum = Integer.parseInt(parJTF[1].getText().toString());
			if((pageNum >= blockNum) && pageNum > 2 && blockNum > 1){
				orderChange();
				}
			else{
				JOptionPane.showMessageDialog(null, "页数要大于或等于块数且页数要大于2,块数大于1", "输入错误", JOptionPane.INFORMATION_MESSAGE);
			}
		}else{
			JOptionPane.showMessageDialog(null, "输入格式错误或者无输入", "输入错误", JOptionPane.INFORMATION_MESSAGE);
		}
			
	}
	/*
	 * initTop
	 */
	public void initTop(){
		top.setLayout(new GridLayout(2,1));
		author.setLayout(new FlowLayout(FlowLayout.CENTER,60,1));
		
		for(int i = 0;i < authorLab.length;++ i){
			authorLab[i] = new JLabel();
		}
		
		authorLab[0].setText("王勇杰");
		authorLab[1].setText("20112004037");
		authorLab[2].setText("8班");
		
		for(int i = 0;i < authorLab.length; ++ i){
			author.add(authorLab[i]);
		}
		
		chopar.setLayout(new GridLayout(1,2));
		
		par.setBorder(new TitledBorder("输入参数"));
		for(int i = 0;i < parJTF.length; ++ i){
			parLab[i] = new JLabel();
			parJTF[i] = new JTextField(5);
		}
		
		parLab[0].setText("分配块数:");
		parLab[1].setText("程序页数:");
		
		par.add(parLab[0]);
		par.add(parJTF[0]);
		par.add(parLab[1]);
		par.add(parJTF[1]);
		par.add(create);
		create.addActionListener(this);
		
		
		choice.setBorder(new TitledBorder("算法选择"));
		for(int i = 0;i < choBut.length;++ i){
			choBut[i] = new JRadioButton();
			choice.add(choBut[i]);
			bg.add(choBut[i]);
		}
		
		choBut[0].setSelected(true);
		choBut[0].setText("OPT");
		choBut[1].setText("FIFO");
		choBut[2].setText("LRU");
		
		chopar.add(choice);
		chopar.add(par);
		top.add(author);
		top.add(chopar);
		
		Container con = getContentPane();
		con.add(top,BorderLayout.NORTH);
		setVisible(true);
	}
	/*
	 * initCent
	 */
	public void initCent(){
		for(int i = 0;i < JSP.length;++ i){
			JSP[i] = new JScrollPane();
		}
		GridBagLayout GBL = new GridBagLayout();
		GridBagConstraints GBC = new GridBagConstraints();
		centre.setLayout(GBL);
		
		GBC.fill = GridBagConstraints.BOTH;
		GBC.weightx = 10;
		GBC.weighty = 2;
		GBC.gridwidth = GridBagConstraints.REMAINDER;//换行
		GBL.setConstraints(JSP[0], GBC);

		GBC.weighty = 50;
		GBC.gridheight = 5;
		GBL.setConstraints(JSP[1], GBC);
		
		JSP[0].setBorder(new TitledBorder("页面序列"));
		JSP[1].setBorder(new TitledBorder("置换过程"));
		
		JSP[0].setViewportView(order);
		JSP[1].setViewportView(JTA);
		
		order.setEditable(false);
		JTA.setEditable(false);
		
		centre.add(JSP[0]);
		centre.add(JSP[1]);//JScrollPane是个面板,是容器,应该吧contenPane里面加上一个JScrollPane子容器
		
		Container con = getContentPane();
		con.add(centre,BorderLayout.CENTER);
		setVisible(true);
	}
	/*
	 * initCal
	 */
	public void initCal(){
		for(int i = 0;i < calJTF.length; ++ i){
			calLab[i] = new JLabel();
			calJTF[i] = new JTextField(10);
		}
		
		calLab[0].setText("缺页次数:");
		calLab[1].setText("缺页率:");
		
		
		for(int i = 0;i < calLab.length;++ i){
			cal.add(calLab[i]);
			cal.add(calJTF[i]);
			calJTF[i].setEditable(false);
		}

		cal.setBorder(new TitledBorder("性能评估"));
		Container con = getContentPane();
		con.add(cal,BorderLayout.SOUTH);
		setVisible(true);
	}
	/*
	 * orderChange
	 */
	public void orderChange(){
		order.setText(" ");
		int num = (pageNum + 1)/ 2;
		
		arr = new int[pageNum];

		for(int i = 0 ;i < num;++ i){
			arr[i] = (int)(Math.random() * Integer.MAX_VALUE + 1);
		}
		Arrays.sort(arr, 0, num );
		for(int i = 0;i < num / 2;++ i){//25%前向取值
			arr[num + i] = arr[(int)(Math.random() * num / 2)];
		}
		for(int i = 0;i < (pageNum - num - num / 2);++ i){//25%后向取值
			arr[num + i + (num / 2)] = arr[(int)(Math.random() * num / 2) + (num / 2)];
		}
		for(int i = 0 ;i < arr.length;++ i){
			order.append(arr[i] + "	");
		}
		
		blockChange();
	}
	/*
	 * JTAChange,参数用于直接添加还是晴空后添加
	 */
	public void JTAChange(){
		for(int i = 0;i < blockNum;++ i){
			JTA.append(blockArr[i] + "	");
		}	
		JTA.append("\n");
	}
	/*
	 * calChange
	 */
	public void calChange(){
		calJTF[0].setText(Integer.toString(lack));
		float lackp = (float)(lack) / (float)(pageNum);
		calJTF[1].setText(Float.toString(lackp) + "%");
	}
	/*
	 * blockChange
	 */
	public void blockChange(){

		blockArr = new int[blockNum];
		time = new int[blockNum];
		boolean flag = true;
		for(int i = 0; i < blockNum;++ i){//第一次把整个队列填满
			for(int j = 0;j < blockArr.length;++ j){
				if(blockArr[j] == arr[i])
					flag = false;
			}
			if(flag){
				blockArr[i] = arr[i];
				time[i] = blockNum - i - 1;
			}
		}
		
		JTA.setText("");
		for(int i = 0 ;i < blockNum;++ i){
			if(blockArr[i] == 0 || blockNum == ((pageNum + 1) / 2)){
				JTA.append("无需替换:\n");
				for(int j = 0;j < blockNum;++ j){
					if(blockArr[j] != 0){
						JTA.append(blockArr[j] + "	");
					}
				}
				lack = 0;
				calChange();
				return ;
			}
		}
		if(choBut[0].isSelected())
			OPT();
		if(choBut[1].isSelected())
			FIFO();
		if(choBut[2].isSelected())
			LRU();
	}
	/*
	 * OPT
	 */
	public void OPT(){
		lack = 0;
		int cha = 0,j = 0;
		for(int i = 0;i < (pageNum - blockNum);++ i,cha ++){
			j = cha + blockNum + 1;
			JTA.append("正在执行第" + j + "页:\n");
			OPTRun(cha);
			JTAChange();
		}
		calChange();
	}
	/*
	 * OPTrun
	 */
	public void OPTRun(int cha){
		int tem = 0,tem1 = 0;
		boolean fl = false;
		boolean fla = false;
		for(int i = 0;i < blockNum;++ i){
			if(arr[blockNum + cha] == blockArr[i])
				fla = true;
		}
		if(fla)
			return;
		for(int i = 0;i < blockNum;++ i){
			for(int j = blockNum + cha;j < pageNum;j ++){
				if(blockArr[i] == arr[j]){
					if(j > tem){
						tem = j;//记录多久后交换
						tem1 = i;//记录要换的序号
						fl = true;
						break;
					}
					fl = true;
				}
			}
			if(!fl){//没找到
				tem1 = i;
				break;
			}
			fl = false;
		}
		blockArr[tem1] = arr[blockNum + cha];
		lack ++;
	}
	/*
	 * FIFO
	 */
	public void FIFO(){
		lack = 0;
		int cha = 0,j = 0,k = 0;
		for(int i = 0;i < (pageNum - blockNum);++ i,cha ++){
			j = cha + blockNum + 1;
			JTA.append("正在执行第" + j + "页:\n");
			
			boolean fla = false;
			for(int x = 0;x < blockNum;++ x){
				if(arr[blockNum + cha] == blockArr[x])
					fla = true;
			}
			if(!fla){
				blockArr[k] = arr[blockNum + cha];
				k = (k + 1) % blockNum;
				lack ++;
			}
			
			JTAChange();
		}
		calChange();
	}
	/*
	 * LRU
	 */
	public void LRU(){
		lack = 0;
		int cha = 0,j = 0;
		for(int i = 0;i < (pageNum - blockNum);++ i,cha ++){
			j = cha + blockNum + 1;
			JTA.append("正在执行第" + j + "页:\n");
			
			boolean fla = false;
			for(int x = 0;x < blockNum;++ x){
				if(arr[blockNum + cha] == blockArr[x]){
					fla = true;
					time[x] = 0;
				}
				else{
					time[x]++;
				}
			}
			if(!fla){
				int tem = 0,tem1 = 0;
				for(int y = 0;y < blockNum;y ++){
					if(time[y] > tem){
						tem = time[y];
						tem1 = y;
					}
				}
				blockArr[tem1] = arr[blockNum + cha];
				time[tem1] = 0;
				lack ++;
			}
			
			JTAChange();
		}
		calChange();
	}
}


 

操作系统页面置换模拟系统
leolin_的专栏
06-05 1185
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; int address[322];//指令地址 int
操作系统之页面置换模拟程序设计_FIFO
StuTan
01-11 1468
介绍 假设分给一作业的内存块数为4，每个页面中可存放10条指令。 用C语言设计一个程序，模拟一作业的执行过程。设该作业共有320条指令，即它的地址空间为32页，目前它的所有页面都还未调入内存。在模拟过程中，如果所访问的指令已经在内存，则显示其物理地址，并转下一条指令。如果所访问的指令尚未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。如果4个内存块中均已装入该作业的虚页面，...
操作系统页面置换模拟
12-14
页面置换OPT、FIFO、LRU三种方式
模拟操作系统页面置换过程，Java图形化界面，实现了OPT、LRU、FIFO、CLOCK
10-14
模拟了操作系统页面置换的过程，使用Java语言实现了四种经典算法，即OPT算法、LRU算法、FIFO算法、CLOCK算法，并且利用Java图形库制作了一个粗糙的图形化界面。整个页面置换过程完全使用数组实现，并未定义复杂的...
模拟操作系统页面置换算法实现
"该资源是华南师范大学计算机学院的一份实验报告，主题是模拟操作系统的页面置换，旨在让学生理解和掌握页面置换算法，包括FIFO、OPT和RLU算法，并通过C++编程实现。实验中，学生需要用随机数生成满足特定条件的指令...
C语言模拟操作系统页面置换算法的动态过程
07-22
此代码用C语言模拟实现计算机操作系统页面置换算法的动态过程 ps：使用时需要添加easyx图形库，编译过后需要自己粘贴程序运行时的背景图片到工程文件中，并改名为1.jpg，还可设置背景音乐。。
操作系统课程设计——页面置换算法模拟实现
02-24
通过对请求页式存储管理中页面置换算法的模拟设计，掌握请求页式存储管理页面置换算法，并进一步理解虚拟存储技术的原理及特点。 设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰...
操作系统实验：页面置换算法的模拟实现及命中率对比.rar
06-28
本资源使用Java实现了页面置换算法OPT、...该资源的文字版信息请访问博客《操作系统实验：页面置换算法的模拟实现及命中率对比（学习笔记）》（https://blog.csdn.net/weixin_40589192/article/details/106997447）。
操作系统 页面置换模拟
12-07
页面置换算法的模拟实现 分别实现最佳置换算法(optimal)、先进先出(FIFO)页面置换算法和最近最久未使用(LRU)置换算法,并给出各算法缺页次数和缺页率。 #include #include #include const int MAXSIZE=100; //定义访问串最大长度 const int PAGE_FRAME_NUM=3; //定义固定分配给该进程的页面数 const int PAGE_NUM=8; //定义该进程分页数 int Queue[MAXSIZE]; //保存访问串 int QueueNum=0; //保存访问串长度 bool PFAllocation[PAGE_FRAME_NUM]; //页面分配表（标识该页面是否已分配）false-未分配；true-已分配
操作系统 页面置换算法模拟
yiokio的博客
05-14 1624
据实验作业挑选了几种页面置换算法进行实验.(仅个人理解 1.先进先出页面置换算法(FIFO). 2.最近最久未被使用页面置换算法(LRU). 3.最佳页面置换算法(OPT). 一.  首先是 先进先出页面置换算法(FIFO). 每次需要置换时都会淘汰最先进入内存的页面. 如若这样解释,我们是不能换种说法 – 每次需要置换时都删除队头元素, 然后在队尾添加一个新的元素? 所以这就是一个队列 queue 操作. 当然如果不需要置换时, 也就是
操作系统常见的十种页面置换算法
最新发布
yushibing717的博客
02-13 2084
一、定义： 在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换算法。 二、目标： 如今已经有很多页面置换算法，但是不同页面置换算法的主要目标还是使页面置换频率最低（即缺页率最低）。 三、常见的算法： 1. 最佳置换算法 基本思想：选择以后再也不用的页面；没有的话，选择以后最长时间不用的页面； 实现：无法实现，因为页
页面置换算法模拟实现-操作系统课程设计基于Java
Magnolia_He的博客
11-01 5066
操作系统课程设计--页面置换算法的实现
操作系统实验（2）-- 模拟操作系统的页面置换 LRU OPT FIFO
小邓笔记
06-03 7703
一、实验内容 （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
操作系统中的页面置换
qq_37402392的博客
11-25 651
历史 页面替换算法是1960年代和1970年代研究和辩论的热门话题。那主要是随着复杂的LRU（最近最少使用）的近似和工作集算法的发展而告终。从那时起，传统的页面替换算法所做的一些基本假设就失效了，从而导致了研究的复兴。特别是，基础硬件和用户级软件的以下行为趋势已影响页面替换算法的性能： 主存储的大小增加了多个数量级。有了几GB的主内存，要求定期检查每个内存帧的算法变得越来越不实用。 内存层次结构...
用数组顺序栈实现表达式运算(后缀表达式)
0≡(-∞,+∞)
10-20 1255
//这个是用中缀转为后缀再进行运算,根据书上的改写,感觉书上写的有点麻烦...没办法,按照要求.还是硬生生的改写了函数,虽然有点不堪入目,但还好实现了带浮点,括号,负数的运算 #include #include"SeqStack.h" class Calculator { public: Calculator(int sz=100):s(sz){} void Run(); void Cle
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值