操作系统课程设计-虚拟内存系统的页面置换算法模拟

已于 2024-03-01 15:57:10 修改
阅读量1.7k 收藏 32
点赞数 11
分类专栏： 操作系统 文章标签： 算法 c++ windows
于 2024-01-18 10:50:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63306482/article/details/135668407
版权
本文详细描述了一个关于虚拟内存系统页面置换算法的实验，包括OPT、FIFO、LRU和CLOCK算法的实现步骤、关键代码以及实验结果分析。通过模拟指令序列，探讨了不同算法的缺页性能。
摘要由CSDN通过智能技术生成

目录

前言

1 实验题目

2 实验目的

3 实验内容

3.1 步骤

3.2 关键代码

3.2.1 生成指令序列

3.2.2 OPT函数

3.2.3 FIFO函数

3.2.4 LRU函数

3.2.5 CLOCK函数

4 实验结果与分析

5 代码

前言

         本实验为课设内容，博客内容为部分报告内容，仅为大家提供参考，请勿直接抄袭，另外，本次实验所用平台是dev c++5.11

1 实验题目

        实验八 虚拟内存系统的页面置换算法模拟

2 实验目的

       通过对页面、页表、地址转换和页面置换过程的模拟，加深对虚拟页式内存管理系统的页面置换原理和实现过程的理解。

3 实验内容

3.1 步骤

        （1）通过随机数产生一个指令序列，共 320 条指令。 
                ① 50%的指令是顺序执行的； 
                ② 25%的指令是均匀分布在前地址部分； 
                ③ 25%的指令是均匀分布在后地址部分； 
        （2）实现OPT算法函数。
        （3）实现LRU算法函数。
        （4）实现FIFO算法函数。
        （5）实现CLOCK算法函数。

3.2 关键代码

3.2.1 生成指令序列

void createOpt(){
	srand((unsigned)time(0));
	int i=0;
	while(i<optNum){
		int m=rand()%optNum; //生成[0，319]之间的随机数
		if(m==optNum-1)continue; //如果生成的是319，则m+1不能放进去 
		opt[i++]=m+1; //把m+1放进去
		if(i>=optNum)break;
		
		int m1=rand()%(m+2); //生成[0，m+1]之间的随机数
		opt[i++]=m1; //把随机的m1指令放入数组 
		if(i>=optNum)break;
		if(m1==optNum-1)continue; //如果生成的是319，则m1+1不能放进去 
		opt[i++]=m1+1; //把m1+1放进去 
		if(i>=optNum)break;
		
		m=(rand()%(optNum-m1-2))+m1+2; //0,319-m1-2,生成[m1+2，319]之间的随机数 
		opt[i++]=m;
	}
}

3.2.2 OPT函数

void OPT(){
	int pageNum=0;
	int err=0; 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				page[j].num=i;
				//cout<<opt[i]/10<<"\n";
				break;
			}
		}
		if(!flag){
			err++;
			int max=0;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum].index=opt[i]/10;
				page[pageNum].num=i;
				pageNum++;
			}else{
				//已满，需要置换
				for(int j=0;j<pageNum;j++){
					int k=i+1;
					for(;k<optNum;k++){
						if(page[j].index==opt[k]/10){
							page[j].num=k;
							break;
						}
					}
					if(k==optNum){
						page[j].num=optNum;//320
					}
					if(page[max].num<page[j].num){
						max=j;
					}
				} 
				page[max].index=opt[i]/10;
				page[max].num=i;
			}
			//cout<<"F "<<opt[i]/10<<"\n";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<"OPT算法的缺页次数："<<err<<"\n";
	cout<<"OPT算法的缺页率：";
	printf("%.6lf\n",res);
}

3.2.3 FIFO函数

void FIFO(){
	int pageNum=0;
	int err=0; 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				//cout<<opt[i]/10<<"\n";
				break;
			}
		}
		if(!flag){
			err++;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum++].index=opt[i]/10;
			}else{
				//已满，需要置换
				for(int j=1;j<pageNum;j++){
					page[j-1].index=page[j].index;
				} 
				page[pageNum-1].index=opt[i]/10;
			}
			//cout<<"F "<<opt[i]/10<<"\n";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<"FIFO算法的缺页次数："<<err<<"\n";
	cout<<"FIFO算法的缺页率：";
	printf("%.6lf\n",res);
}

3.2.4 LRU函数

void LRU(){
	int pageNum=0;
	int err=0; 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				page[j].num=i;
				//cout<<opt[i]/10<<"\n";
				break;
			}
		}
		if(!flag){
			err++;
			int min=0;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum].index=opt[i]/10;
				page[pageNum].num=i;
				pageNum++;
			}else{
				//已满，需要置换
				for(int j=0;j<pageNum;j++){
					if(page[min].num>page[j].num){
						min=j;
					}
				} 
				page[min].index=opt[i]/10;
				page[min].num=i;
			}
			//cout<<"F "<<opt[i]/10<<"\n";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<"LRU算法的缺页次数："<<err<<"\n";
	cout<<"LRU算法的缺页率：";
	printf("%.6lf\n",res);
}

3.2.5 CLOCK函数

void CLOCK(){
	int pageNum=0;
	int err=0; 
	int p=0; //指针 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				page[j].num=1;
				//cout<<opt[i]/10<<"\n";
				break;
			}
		}
		if(!flag){
			err++;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum].index=opt[i]/10;
				page[pageNum].num=1;
				pageNum++;
				p=(p+1)%proPageNum;
			}else{
				//已满，需要置换
				for(;;p=(p+1)%proPageNum){
					//在环缓冲区找第一个0 
					if(page[p].num==1){
						page[p].num=0;
					}else{
						//找到第一个0，替换 
						page[p].index=opt[i]/10;
						page[p].num=1;
						p=(p+1)%proPageNum;
						break;
					}
				}
			}
			//cout<<"F "<<opt[i]/10<<"\n";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<"CLOCK算法的缺页次数："<<err<<"\n";
	cout<<"CLOCK算法的缺页率：";
	printf("%.6lf\n",res);
}

4 实验结果与分析

根据指导书要求，若访问的指令已在内存中就直接输出其物理地址，若不在内存中，则发生缺页先输出F，置换后再输出其物理地址，运行结果如下面两张图片所示，经统计和计算，每个算法的缺页次数和缺页率是正确的。

图1.1 OPT算法和FIFO算法

图1.2 LRU和CLOCK算法

5 代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

#define optNum 320 // 指令数 
#define proPageNum 4 //程序可用页数
#define pageOptNum 10 //一页的指令数 

struct memClock{
	int index; //页号 
	int num; //使用次数 
};

int test[]={20,30,20,10,50,20,40,50,30,20,50,20};
memClock test1[]={{20,0},{30,0},{20,0},{10,0},{50,0},{20,0},{40,0},{50,0},{30,0},{20,0},{50,0},{20,0}};

int opt[optNum]; //指令数数组 
memClock page[proPageNum]; //程序可用页面 

void createOpt(){
	srand((unsigned)time(0));
	int i=0;
	while(i<optNum){
		int m=rand()%optNum; //生成【0，319】之间的随机数
		if(m==optNum-1)continue; //如果生成的是319，则m+1不能放进去 
		opt[i++]=m+1; //把m+1放进去
		if(i>=optNum)break;
		
		int m1=rand()%(m+2); //生成【0，m+1】之间的随机数
		opt[i++]=m1; //把随机的m1指令放入数组 
		if(i>=optNum)break;
		if(m1==optNum-1)continue; //如果生成的是319，则m1+1不能放进去 
		opt[i++]=m1+1; //把m1+1放进去 
		if(i>=optNum)break;
		
		m=(rand()%(optNum-m1-2))+m1+2; //0,319-m1-2,生成【m1+2，319】之间的随机数 
		opt[i++]=m;
	}
}

void OPT(){
	int pageNum=0;
	int err=0; 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				page[j].num=i;
				cout<<opt[i]/10<<" ";
				break;
			}
		}
		if(!flag){
			err++;
			int max=0;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum].index=opt[i]/10;
				page[pageNum].num=i;
				pageNum++;
			}else{
				//已满，需要置换
				for(int j=0;j<pageNum;j++){
					int k=i+1;
					for(;k<optNum;k++){
						if(page[j].index==opt[k]/10){
							page[j].num=k;
							break;
						}
					}
					if(k==optNum){
						page[j].num=optNum;//320
					}
					if(page[max].num<page[j].num){
						max=j;
					}
				} 
				page[max].index=opt[i]/10;
				page[max].num=i;
			}
			cout<<"F "<<opt[i]/10<<" ";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<endl<<"OPT算法的缺页次数："<<err<<"\n";
	cout<<"OPT算法的缺页率：";
	printf("%.6lf\n",res);
}

void FIFO(){
	int pageNum=0;
	int err=0; 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				cout<<opt[i]/10<<" ";
				break;
			}
		}
		if(!flag){
			err++;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum++].index=opt[i]/10;
			}else{
				//已满，需要置换
				for(int j=1;j<pageNum;j++){
					page[j-1].index=page[j].index;
				} 
				page[pageNum-1].index=opt[i]/10;
			}
			cout<<"F "<<opt[i]/10<<" ";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<endl<<"FIFO算法的缺页次数："<<err<<"\n";
	cout<<"FIFO算法的缺页率：";
	printf("%.6lf\n",res);
}

void LRU(){
	int pageNum=0;
	int err=0; 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				page[j].num=i;
				cout<<opt[i]/10<<" ";
				break;
			}
		}
		if(!flag){
			err++;
			int min=0;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum].index=opt[i]/10;
				page[pageNum].num=i;
				pageNum++;
			}else{
				//已满，需要置换
				for(int j=0;j<pageNum;j++){
					if(page[min].num>page[j].num){
						min=j;
					}
				} 
				page[min].index=opt[i]/10;
				page[min].num=i;
			}
			cout<<"F "<<opt[i]/10<<" ";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<endl<<"LRU算法的缺页次数："<<err<<"\n";
	cout<<"LRU算法的缺页率：";
	printf("%.6lf\n",res);
}

void CLOCK(){
	int pageNum=0;
	int err=0; 
	int p=0; //指针 
	for(int i=0;i<optNum;i++){
		int flag=0;
		for(int j=0;j<pageNum;j++){
			if(opt[i]/10==page[j].index){
				flag=1;
				page[j].num=1;
				cout<<opt[i]/10<<" ";
				break;
			}
		}
		if(!flag){
			err++;
			if(pageNum<proPageNum){ 
				//程序页面没有放满 
				page[pageNum].index=opt[i]/10;
				page[pageNum].num=1;
				pageNum++;
				p=(p+1)%proPageNum;
			}else{
				//已满，需要置换
				for(;;p=(p+1)%proPageNum){
					//在环缓冲区找第一个0 
					if(page[p].num==1){
						page[p].num=0;
					}else{
						//找到第一个0，替换 
						page[p].index=opt[i]/10;
						page[p].num=1;
						p=(p+1)%proPageNum;
						break;
					}
				}
			}
			cout<<"F "<<opt[i]/10<<" ";
		} 
	}
	double res=(double)err*1.0/optNum;
	cout<<endl<<"CLOCK算法的缺页次数："<<err<<"\n";
	cout<<"CLOCK算法的缺页率：";
	printf("%.6lf\n",res);
}

int main(){
	createOpt();
	OPT();
	FIFO();
	LRU();
	CLOCK();
	return 0;
}

望525
关注
  • 11
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统课程设计-页式虚拟存储管理页面置换算法-c++描述
欢迎来到GEEK卷轶浩繁的博客
05-31 8624
1．目的和要求 存储管理的主要功能之一是合理的分配空间。请求页式管理是一种常用的虚拟存储管理技术。本实验的目的是：通过编写和调试请求页式存储管理中页面置换算法的模拟程序以加深对存储管理方案的理解，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换方法。 2．实验内容 阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。 编写程序模拟实现页式虚拟存储管理的最佳页面置换算法。 前提： ...
操作系统课程设计：虚拟内存页面置换算法的模拟与实现
m0_46107238的博客
07-10 1317
虚拟内存页面置换算法的模拟与实现1、实验目的2、实验基本知识及原理3、实验内容4、源代码 1、实验目的 通过对页面、页表、地址转换和页面置换过程的模拟，加深对虚拟页式内存管理系统的页面置换原理和实现过程的理解。 2、实验基本知识及原理 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标： 把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 教材给出的常用的页面置换算法包括： 1）最佳置换算法(OPT)：置换时淘汰“未来
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
这是一个自己完成软件工程的操作系统课程课程设计题目：此程序用于模拟虚拟磁盘页面置换算法，实现了FIFO页面置换算法和LRU页面置换算法，获得课程设计优秀的好成绩
山东大学软件学院操作系统课程设计Nachos-实验七-虚拟内存
m0_47470899的博客
01-21 3375
说明：blog 中写到的这几个实验，不全面而且也不是上交实验报告的最终版本（是自己实验过程中用typora简单记录的笔记），完整内容（含代码+实验报告）可以通过（山东大学软件学院操作系统课设）下载，或者微信公众号关注“陌兮blog”免费获取 文章目录一、虚拟内存1、问题分析1.1、请求式分页技术1.2、页置换1.3、帧的分配2、实现虚拟内存1、实现缺页异常处理2、实现页置换3、测试 一、虚拟内存 1、问题分析 结合实验指导书，实现nachos虚拟内存的过程大概可以分为：处理缺页异常、页置换、帧分配这三个部
实验八 页面置换模拟程序设计
最新发布
m0_74644005的博客
06-06 252
网上找到的程序得到的答案经过手算验证是错的，所以自己实现了一个，具体实现看代码吧，多余的操作已经去掉了。opt和lru算法
页面置换算法的模拟实现.docx
03-03
（1）设计一个虚拟存储区和内存工作区，编程序演示下述算法的具体实现过程，并计算各个算法的缺页率。 （2）用C语言实现，要求设计主界面以灵活选择某算法，且以下算法都要实现： a:最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。 b: 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 c：最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。 （3）程序采用人工的方法选择，依次换策略选择一个可置换的页，并计算它们的缺页率以便比较。
页面置换算法模拟实现-操作系统课程设计基于Java
Magnolia_He的博客
11-01 4990
操作系统课程设计--页面置换算法的实现
存储管理页面置换算法模拟实现及比较
qq_44808056的博客
07-03 6050
存储管理页面置换算法模拟实现及比较 1、目的 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。页式管理中页面置换算法，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 2、学年设计内容 （1）通过随机数产生一个指令序列，共320条指令。 指令的地址按下述原则生成： ①一半的指令是顺序执行的； ②四分之一的指令是均匀分布在前地址部分； ③四分之一的指令是均匀分布在前地址部分。 具体的实施办法是： ① 在[0，319]之间选一起点m； ② 顺序执行一条指令，即m+
操作系统 页面置换算法模拟
yiokio的博客
05-14 1558
据实验作业挑选了几种页面置换算法进行实验.(仅个人理解 1.先进先出页面置换算法(FIFO). 2.最近最久未被使用页面置换算法(LRU). 3.最佳页面置换算法(OPT). 一.  首先是 先进先出页面置换算法(FIFO). 每次需要置换时都会淘汰最先进入内存的页面. 如若这样解释,我们是不能换种说法 – 每次需要置换时都删除队头元素, 然后在队尾添加一个新的元素? 所以这就是一个队列 queue 操作. 当然如果不需要置换时, 也就是
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
热门推荐
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
操作系统虚拟内存页面置换算法
weixin_48569452的博客
04-05 730
为了加深对虚拟内存页面置换概念的理解，进一步掌握先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。 (1)输入的形式：输入1-3的整数选择算法，比如输入1调用FIFO算法，输入2调用LRU算法，输入3调用OPT算法。已在程序中预置好页面信息和页面访问顺序，页框数量为3 (2)输出的形式：页面置换的过程和置换后内存的状态 (3)程序所能达到的功能：模拟先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法 (4)测试数据，计算相应的缺页率。 源代码： #include &l
操作系统课程设计——页面置换算法模拟实现
02-24
通过对请求页式存储管理中页面置换算法的模拟设计，掌握请求页式存储管理页面置换算法，并进一步理解虚拟存储技术的原理及特点。 设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰...
操作系统课程设计---页面置换算法的模拟实现--高分课设---c语言编写
05-15
操作系统课程设计---页面置换算法的模拟实现--高分课设---c语言编写 资源里包含源码和课程设计报告，可供学习。高分课设 页面置换算法的模拟实现 用C或C++语言设计一个虚拟存储区和内存工作区，编程序演示下述算法的...
操作系统课程设计之页面置换算法（流程模拟）
12-22
本项目是关于操作系统课程设计的一个实践，重点在于模拟不同的页面置换算法，使用的编程语言是C#。 在这个项目中，我们将探讨以下几个关键知识点： 1. **虚拟内存**：虚拟内存是一种将计算机物理内存与硬盘空间相...
操作系统课程设计 模拟页面置换算法的实现 基于Qt
07-07
基于Qt开发的，模拟操作系统的内存页面置换算法的实现。该项目主要是模拟操作系统的内存管理中的页面置换算法，对比几种算法的优劣，并将结果以动态的形式展示出来。选择了四种置换算法：先来先服务(FIFO)、最近最少...
操作系统课程设计---页面置换算法的模拟.doc
05-30
操作系统课程设计的目标是让学生在学习完“操作系统原理”后，通过模拟页面置换算法来深入理解和实践操作系统的虚拟存储管理技术。这一设计旨在强化理论知识，提高编程能力，并增强对Linux系统的基本操作理解。 ...
《操作系统》页面置换算法模拟
m0_73569129的博客
05-06 655
if(p1[page[i]].pfn==INVALID) /*页面失效*/if(p1[page[i]].pfn==INVALID) /*页面失效*/if(p1[page[i]].pfn==INVALID) //页面失效。if(freepf_head==NULL) /*无空闲页面*/if(freepf_head==NULL) /*无空闲页面*/if(freepf_head==NULL) //无空闲页面。void LRU(int total_pf) /*LRU算法*/
操作系统实验2 页面置换算法的模拟实现（C语言版）
m0_61128650的博客
07-09 1264
一、实验目的和要求要求了解操作系统的基本原理及基本概念，掌握实现各原理的算法，能结合实际开发工具模拟演示课程中涉及的算法，以达到深入掌握操作系统理论的目的。要求学生上机之前充分准备，给出算法的设计流程和详细代码；认真做实验，要求给出调试通过的可运行程序；认真解答思考题中的问题，记录实验中遇到的问题和解决方法；独立编写实验报告。掌握虚拟存储管理中页面置换算法的原理，设计恰当的数据结构和算法，模拟实现页面置换算法。二、实验方法与步骤（需求分析、算法设计思路、流程图等）通过本次实验加深了我对页面置换算法的理解，页
操作系统课设(三种页面置换算法模拟实现)
lzx614204743的博客
04-20 1717
操作系统课设之页面置换算法模拟实现 设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰算法（OPT），最近最久未使用算法（LRU）计算不同内存容量下的缺页率，模拟表示出不同算法内存中页面的变化情况。 C语言编写，运行结果如下 具体代码移步：https://ttaozhi.com/t/t/newshop.html?id=g0IisuzGUN&share=L3MGNPop ......
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值