操作系统实验-页面置换算法

最新推荐文章于 2023-11-25 23:49:20 发布
最新推荐文章于 2023-11-25 23:49:20 发布
阅读量2.7k 收藏 43
点赞数 8
文章标签： 页面置换算法 LRU FIFO 缺页率 性能测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51355516/article/details/112018395
版权

页面置换算法

前言：

  • 在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换算法。
实验要求：
  • 设计并实现最近最久未使用页面置换（LRU）算法；
  • 实现最不常用页面置换算法（LFT），页面缓冲置换算法（PBA）和改进型CLOCK页面置
    换算法（可选）；
  • 编写测试程序，对不同页面置换算法的性能进行测试和比较。
本代码实现了最佳页面置换算法（OPT），先进先出置换算法（FIFO），最不常用置换算法（LFT），最近最久未使用置换算法（LRU）以及改进型CLOCK页面置换算法。

注： 改进型CLOCK页面置换算法仅仅实现算法思想。

算法思想
- 请到: 此处查看. 不要懒，百度百科你值得拥有。

在这里插入图片描述

  • 如果代码需要在Linux内核中实现，请将页面下滑至最后，有你想要的。

在这里插入图片描述

C语言代码实现:

#include <stdio.h>
#include <stdlib.h>
int kh;
struct LNode
	{
		int data;
		int flag;//访问位
		int modify;//修改位
	};//改进型Clock算法数据结构

//输出内存块页面序号
int OutputBlockofMemory(int *BlockofMemory, int BlockCount, int ReplacePage, int PageNum)
{
	int i;

	printf("访问页面 %d 后，", PageNum);
	printf("内存中的页面号为:\t");
	for(i = 0; i < BlockCount; i++)
	{
		if(BlockofMemory[i] < 0)
			printf("#  ");
		else
			printf("%d  ", BlockofMemory[i]);
	}

	if(ReplacePage != -1)
		printf("\t淘汰页面号为:%d", ReplacePage);

	printf("\n");

	return -1;
}

//输出页面引用串号
void OutputPageNumofRef(int* PageNumofRef, int PageNumRefCount)
{
	int i = 0;
	printf("页面引用串为:\t");
	for(i = 0; i < PageNumRefCount; i++)
		printf("%d  ", PageNumofRef[i]);
	printf("\n");
}

//内存块页面号清零
void ResetBlockofMemory(int *BlockofMemory, int BlockCount)
{
	int i;
	for(i = 0; i < BlockCount; i++)
		BlockofMemory[i] = -1;
}

//判断页是否在内存中，如果页在内存中，返回1，否则返回0；
int PageInBlockofMemory(int PageNum, int *BlockofMemory, int BlockCount)
{
	int i;
	for(i = 0; i < BlockCount; i++)
		if(PageNum == BlockofMemory[i])
			return 1;
	return 0;
}
//LFT算法判断页是否在内存中，如果页在内存中，返回1，相应计数器加1，否则返回0；
int PageInBlockofMemoryLFT(int PageNum, int *BlockofMemory, int BlockCount,int *sum)
{
	int i;
	for(i = 0; i < BlockCount; i++)
		if(PageNum == BlockofMemory[i])
			{sum[i]++;
			return 1;}
	return 0;
}

//下次访问次序
//参数j:  页面在内存块中的位置
//参数i： 页面号在页面号引用串中的位置
int DistanceOpt(int *BlockofMemory, int *PageNumofRef, int j, int i, int PageNumRefCount)
{
	int k;
	for(k = i + 1; k < PageNumRefCount; k++)
		if(BlockofMemory[j] == PageNumofRef[k])
			return k;
	return PageNumRefCount;
}

//最佳页面置换算法
float Opt(int *BlockofMemory, int *PageNumofRef, int BlockCount, int PageNumRefCount)
{
	int i, j, k;
	int MaxIndex1, MaxIndex2;
	int MissCount = 0;
	int ReplacePage;
	int EmptyBlockCount = BlockCount;

	printf("**********最佳页面置换算法：**********\n");

	//输出页面引用串号
	OutputPageNumofRef(PageNumofRef, PageNumRefCount);

	for(i = 0; i < PageNumRefCount; i++)
	{
		if(!PageInBlockofMemory(PageNumofRef[i], BlockofMemory, BlockCount)) //页不在内存中
		{
			MissCount++;

			if(EmptyBlockCount > 0)
			{
				BlockofMemory[BlockCount - EmptyBlockCount] = PageNumofRef[i];
				OutputBlockofMemory(BlockofMemory, BlockCount, -1, PageNumofRef[i]);
				EmptyBlockCount--;
			}
			else
			{
				MaxIndex1 = MaxIndex2 = 0;
				//求出未来最长时间不被访问的页
				for(j = 0; j < BlockCount; j++)
				{
					MaxIndex2 = DistanceOpt(BlockofMemory, PageNumofRef, j, i, PageNumRefCount);
					if(MaxIndex1 < MaxIndex2)
					{
						MaxIndex1 = MaxIndex2;
						k = j;
					}
				}
				ReplacePage = BlockofMemory[k];
				BlockofMemory[k] = PageNumofRef[i];
				OutputBlockofMemory(BlockofMemory, BlockCount, ReplacePage, PageNumofRef[i]);
			}
		}
		else
		{
			OutputBlockofMemory(BlockofMemory,BlockCount, -1, PageNumofRef[i]);
		}
	}

	printf("缺页次数为: %d\n", MissCount);
	printf("OPT缺页率为: %.3f\n", (float)MissCount / PageNumRefCount);
	return (float)MissCount / PageNumRefCount;
}
//最不常用页面置换算法
float LFT(int *BlockofMemory, int *PageNumofRef, int BlockCount, int PageNumRefCount)
{
	int i, j, k=0,l;
	int *sum;//为每个页面设置计数器
	int MissCount = 0;
	int ReplacePage;
	int EmptyBlockCount = BlockCount;
	sum = (int*)malloc(BlockCount * sizeof(int));//生成计数器
	for(l=0;l<BlockCount;l++)
		sum[l]=0;//初始化计数器
	printf("**********最不常用页面置换算法：**********\n");

	//输出页面引用串号
	OutputPageNumofRef(PageNumofRef, PageNumRefCount);

	for(i = 0; i < PageNumRefCount; i++)
	{
		if(!PageInBlockofMemoryLFT(PageNumofRef[i], BlockofMemory, BlockCount,sum)) //页不在内存中
		{
			MissCount++;

			if(EmptyBlockCount > 0)//内存物理快有空间
			{
				BlockofMemory[BlockCount - EmptyBlockCount] = PageNumofRef[i];
				sum[BlockCount - EmptyBlockCount]++;
				OutputBlockofMemory(BlockofMemory, BlockCount, -1, PageNumofRef[i]);
				EmptyBlockCount--;
			}
			else
			{
				for(j=0;j<BlockCount;j++)
				if(sum[j]<sum[k])
				 k=j;
				 sum[k]=1;//被替换页面访问次数置1
				 ReplacePage = BlockofMemory[k];
				BlockofMemory[k] = PageNumofRef[i];
				OutputBlockofMemory(BlockofMemory, BlockCount, ReplacePage, PageNumofRef[i]);
			}
		}
		else
		{
			OutputBlockofMemory(BlockofMemory,BlockCount, -1, PageNumofRef[i]);
		}
	}

	printf("缺页次数为: %d\n", MissCount);
	printf("LFU缺页率为: %.3f\n", (float)MissCount / PageNumRefCount);
	return (float)MissCount / PageNumRefCount;
}
//先进先出页面置换算法
float Fifo(int *BlockofMemory,int *PageNumofRef,int BlockCount,int PageNumRefCount)
{
	int i;
	int ReplacePage;
	int ReplaceIndex = 0;
	int MissCount = 0;
	int EmptyBlockCount = BlockCount;

	printf("**********先进先出页面置换算法：**********\n");
	
	//输出页面引用串号
	OutputPageNumofRef(PageNumofRef,PageNumRefCount);

	for(i = 0; i < PageNumRefCount; i++)
	{
		if(!PageInBlockofMemory(PageNumofRef[i], BlockofMemory, BlockCount)) //页不在内存中
		{
			MissCount++;

			if(EmptyBlockCount > 0)
			{
				BlockofMemory[BlockCount - EmptyBlockCount] = PageNumofRef[i];
				OutputBlockofMemory(BlockofMemory, BlockCount, -1, PageNumofRef[i]);
				EmptyBlockCount--;
			}
			else
			{
				ReplacePage = BlockofMemory[ReplaceIndex];
				BlockofMemory[ReplaceIndex] = PageNumofRef[i];
				ReplaceIndex = (ReplaceIndex + 1) % BlockCount;
				OutputBlockofMemory(BlockofMemory, BlockCount, ReplacePage, PageNumofRef[i]);
			}
		}
		else
			OutputBlockofMemory(BlockofMemory, BlockCount, -1, PageNumofRef[i]);
	}
	printf("缺页次数为：%d\n", MissCount);
	printf("FIFO缺页率为：%.3f\n", (float)MissCount / PageNumRefCount);
	return (float)MissCount / PageNumRefCount;
}
//内存块页面号清零
void ResetBlockofMemoryClock(struct LNode *nodes, int BlockCount)
{
	int i;
	for(i = 0; i < BlockCount; i++)
		{
			nodes[i].data = -1;
			nodes[i].data = -1;
			nodes[i].data = -1;
		}
}
int PageInBlockofMemoryclock(int PageNum, struct LNode *LNode, int BlockCount)
{
	int i;
	for(i = 0; i < BlockCount; i++)
		if(PageNum == LNode[i].data)
			return 1;
	return 0;
}
int OutputBlockofMemoryclock(struct LNode *LNode, int BlockCount, int ReplacePage, int PageNum)
{
	int i;

	printf("访问页面 %d 后，", PageNum);
	printf("内存中的页面号为:\t");
	for(i = 0; i < BlockCount; i++)
	{
		if(LNode[i].data < 0)
			printf("#  ");
		else
			printf("%d  ", LNode[i].data);
	}

	if(ReplacePage != -1)
		printf("\t淘汰页面号为:%d", ReplacePage);

	printf("\n");

	return -1;
}
float upclock(struct LNode *LNode, int *PageNumofRef, int BlockCount, int PageNumRefCount)
{
	int i;
	int *sum;//为每个页面设置计数器
	int MissCount = 0;
	int ReplacePage;
	int EmptyBlockCount = BlockCount;
	
	printf("**********改进Clock页面置换算法：**********\n");

	//输出页面引用串号
	OutputPageNumofRef(PageNumofRef, PageNumRefCount);

	for(i = 0; i < PageNumRefCount; i++)
	{
		if(!PageInBlockofMemoryclock(PageNumofRef[i], LNode, BlockCount)) //页不在内存中
		{
			MissCount++;

			if(EmptyBlockCount > 0)//内存物理快有空间
			{
				LNode[BlockCount - EmptyBlockCount].data = PageNumofRef[i];
				LNode[BlockCount - EmptyBlockCount].flag = 1;
				if( i % 2 == 0)
					LNode[BlockCount - EmptyBlockCount].modify = 1;
				else
					LNode[BlockCount - EmptyBlockCount].modify = 0;
				OutputBlockofMemoryclock(LNode, BlockCount, -1, PageNumofRef[i]);
				EmptyBlockCount--;
			}
			else
			{
				int j = 0, flag= -1;
				while(1)
				{
					if((j / BlockCount) % 2 == 0)
					{
						if(LNode[j % BlockCount].flag == 0 && LNode[j % BlockCount].modify == 0)
						{
							flag = j % BlockCount;
							break;
						}//if
					}//if
					if((j / BlockCount) % 2 == 1)
					{
						if(LNode[j % BlockCount].flag == 0 && LNode[j % BlockCount].modify == 1)
						{
							flag = j % BlockCount;
							break;
						}//if
						else
							LNode[j % BlockCount].flag = 0;//访问位置0
					}//if
					j++;
				}//close while
				 ReplacePage = LNode[flag].data;
				LNode[flag].data = PageNumofRef[i];
				LNode[flag].flag = 1;
				if( i % 2 == 0)
					LNode[flag].modify = 1;
				else
					LNode[flag].modify = 0;
				OutputBlockofMemoryclock(LNode, BlockCount, ReplacePage, PageNumofRef[i]);
			}
		}
		else
		{
			OutputBlockofMemoryclock(LNode, BlockCount, -1, PageNumofRef[i]);
		}
	}

	printf("缺页次数为: %d\n", MissCount);
	printf("改进型clock算法缺页率为: %.3f\n", (float)MissCount / PageNumRefCount);
	return (float)MissCount / PageNumRefCount;
}
//最近最久未使用页面置换算法
void count(int l,int *f)         //数组未存满时,并且不在内存中  值最大要淘汰
	{
		int i;
		if(l<5)
		{
			f[l]=1;
			
			for(i=0;i<l;i++)
			{
				f[i]++;
			}
		}
		l++;
	}
	int count1(int *f)    //数组存满时,并且不在内存中  值最大要淘汰  b是指针
	{
		int a=0,b,i;
		for(i=0;i<5;i++)
		{
			if(f[i]>a) {a=f[i];b=i;}
		}

		for(i=0;i<5;i++)
		{
			if(i==b) {}
			else
			{
				if(f[i]<f[b]) f[i]++;
			}
		}
		f[b]=1;

		printf("%d",b);

		return b;
	}
	void count2(int l,int *f)    //在内存中
	{
		int i;
		for(i=0;i<=l;i++)
		{
			if(i==kh) {}
			else
			{
				if(f[i]<f[kh]) f[i]++;
			}
		}
		f[kh]=1;
	}
float Lru(int *BlockofMemory, int *PageNumofRef, int BlockCount, int PageNumRefCount)
{
	int i,j=1;int l=0;int f[5];
	int ReplacePage;
	int ReplaceIndex = 0;
	int MissCount = 0;
	int EmptyBlockCount = BlockCount;
	
	
	

	printf("************最近最久未使用页面置换算法：************\n");
	
	//输出页面引用串号
	OutputPageNumofRef(PageNumofRef, PageNumRefCount);

	for(i = 0; i < PageNumRefCount; i++)
	{
		if(!PageInBlockofMemory(PageNumofRef[i], BlockofMemory, BlockCount)) //页不在内存中
		{
			MissCount++;
			if(EmptyBlockCount > 0)
			{
				count(l,f);
				BlockofMemory[BlockCount - EmptyBlockCount] = PageNumofRef[i];
				OutputBlockofMemory(BlockofMemory, BlockCount, -1, PageNumofRef[i]);
				EmptyBlockCount--;
				
			}
			else
			{
				ReplacePage = BlockofMemory[count1(f)];
				BlockofMemory[count1(f)] = PageNumofRef[i];
				ReplaceIndex = (ReplaceIndex + 1) % BlockCount;
				OutputBlockofMemory(BlockofMemory, BlockCount, ReplacePage, PageNumofRef[i]);
			}
		}
		else
		{
			
			OutputBlockofMemory(BlockofMemory, BlockCount, -1, PageNumofRef[i]);
			count2(l,f);
			}
	}

	printf("缺页次数为：%d\n", MissCount);
	printf("LRU缺页率为：%.3f\n", (float)MissCount / PageNumRefCount);
	return (float)MissCount / PageNumRefCount;
}

int main()
{
	int *BlockofMemory;		//内存物理块
	const int BlockCount = 3;
	int i,j=0,k=0;
	int PageNumofRef[] = {3,5,0,5,1,0,8,2,5,1,3};  //页面号引用串
	int PageNumRefCount = sizeof(PageNumofRef) / sizeof(PageNumofRef[0]);
	float t[5];
	struct LNode *nodes = NULL;
	nodes = (struct LNode*)malloc(BlockCount * sizeof(struct LNode));
	BlockofMemory = (int*)malloc(BlockCount * sizeof(int));
	if(BlockofMemory == (int*)NULL)
	{
		printf("内存分配出错\n");
		exit(1);
	}

	ResetBlockofMemory(BlockofMemory, BlockCount);
	t[0]=Opt(BlockofMemory, PageNumofRef, BlockCount, PageNumRefCount);

	ResetBlockofMemory(BlockofMemory,BlockCount);
	t[1] =Fifo(BlockofMemory, PageNumofRef, BlockCount, PageNumRefCount);
	
	ResetBlockofMemory(BlockofMemory,BlockCount);
	t[2] =LFT(BlockofMemory, PageNumofRef, BlockCount, PageNumRefCount);

	ResetBlockofMemory(BlockofMemory,BlockCount);
	t[3]=Lru(BlockofMemory, PageNumofRef, BlockCount, PageNumRefCount);
	free(BlockofMemory);

	ResetBlockofMemoryClock(nodes, BlockCount);
	t[4] =upclock(nodes,PageNumofRef,BlockCount,PageNumRefCount);
	free(nodes);

	printf("\n");
	printf("按缺页率从小到大排序结果如下:\n");
	for(i=0;i<5;i++)
	{
		for(k=0;k<5;k++)
		{
		if(t[k]<t[j])
			j=k;
		}
		switch(j)
		{
		case 0:printf("最佳置换算法的缺页率为：%.3f\n", t[0]);break;
		case 1:printf("先进先出置换算法的缺页率为：%.3f\n", t[1]);break;
		case 2:printf("最不常用置换算法的缺页率为：%.3f\n", t[2]);break;
		case 3:printf("最近最久未使用置换算法的缺页率为：%.3f\n", t[3]);break;
		case 4:printf("改进型clock置换算法的缺页率为：%.3f\n", t[4]);break;
		}
		t[j]=99;
	}
	return 0;
}

执行结果：
在这里插入图片描述

Linux实现步骤：

  1. 启动Engintime Linux Lab。
  2. 使用“Linux011应用程序”模板新建一个Linux011应用程序项目。项目名称可以
    是“linuxapp”。
  3. 编辑LinuxApp.c文件，将main函数改为上面你复制的代码。【注】将注释全部删除，否则会报错。
  4. 按F7生成项目。
  5. 按F5启动调试
  6. 将生成的可执行文件从软盘B拷贝到硬盘，命令如下：
mcopy  b:linuxapp.exe  app
  1. 给app文件添加可执行权限，命令如下：
chmod +x  app
  1. 执行“sync”命令，将对文件的更改保存到磁盘。
  2. 查看可执行文件app的信息，
ls –l app
  1. 运行可执行文件app，分析运行结果。

执行结果：
在这里插入图片描述
【注】由于不能滑动，只有这么大，不要见怪。
在这里插入图片描述

一条'虫'
关注
操作系统最近最久未使用，最佳置换，先进先出置换
m0_46356812的博客
09-17 2733
实验报告 班级： 计算机B191 学号： 2019537130 姓名： 陈力源 日期： 5月20 ⒈ 实验题目 模拟分页式虚拟存储管理实验。 2．实验要求 编写一段程序来模拟页面置换算法。要求能分别显示最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最久未使用(LRU)置换算法的置换过程。 3. 实验目的 通过本实验帮助学生理解虚拟存储器的工作方法。了解分页式存储管理里中各页面置换算法是怎样实现的，各算法有怎样的优缺点...
【操作系统/OS笔记07】页面置换算法，最优、FIFO、最近最久未使用、时钟
记录学习痕迹的公众号：Piper蛋窝
09-20 1594
页面置换算法，最优、FIFO、最近最久未使用、时钟、两种全局置换算法。
操作系统：实验四 页面置换算法
顾道长生的科研笔记
11-15 3405
一. 实验目的： 1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。熟悉虚存管理的各种页面淘汰算法 2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。 二 . 实验指导： 设计一个请求页式存储管理方案。并编写模拟程序实现之。流程图见下图。 产生一个需要访问的指令地址流。它是一系列需要访问的指令的地址。为不失一般性，你可以适当地（用人工指定地方法或用随机数产生器）...
操作系统实验-页面置换算法C语言实现
05-30
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率： 要求设计主界面以灵活选择某算法，且以下算法都要实现 1）先进先出算法（FIFO） 2）最近最久未使用算法（LRU） 3）最佳置换算法（OPT）
页面置换算法；最佳置换算法、先进先出置换算法、最近最久未使用置换算法
热门推荐
再走一步
06-20 2万+
一、 实验目的和要求1. 了解虚拟存储技术的特点。2. 掌握请求页式存储管理的页面置换算法，如最佳（Optimal）置换算法、先进先出（Fisrt In First Out）置换算法和最近最久未使用（LeastRecently Used）置换算法。二、实验内容设计模拟实现OPT、FIFO和LRU页面置换算法的C语言程序。1. OPT算法：需要发生页面置换时，算法总是选择在将来最不可...
操作系统实验六 页面置换算法
06-13
包括实验题目，代码及运行结果 实验6 页面置换算法（2学时） 一、实验目的 通过实验加强对虚拟存储管理中页面置换算法的理解和掌握。 二、实验内容 编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法。 三、实验要求 1、任意给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。 2、分配给该作业一定的物理块（如3块、4块等）。 3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。 4、每访问一个页面均需给出内存中的内容（内存中的页面号），若有淘汰还需给出淘汰的页面号。
操作系统实验-页面置换算法.doc
10-12
总之，这个实验旨在深入理解页面置换算法在操作系统中的作用，通过实践掌握各种算法的逻辑，并通过比较不同算法的性能，选择适合特定应用场景的策略。这种实践性的学习方式有助于我们更好地理解和应用虚拟内存管理的...
操作系统实验三页面置换算法实验报告.docx
12-22
操作系统实验三页面置换算法实验报告 该实验报告主要介绍了操作系统中的页面置换算法实验，涵盖了 FIFO、Optimal 和 LRU 等三种常见的页面置换算法。实验报告中还提供了实验源码，展示了如何使用 C 语言实现这些...
操作系统实验内存页面置换算法实验zip.zip
最新发布
04-21
本次实验的文件包括"vmrp.cc"、"vmrp.h"和"Makefile"，这表明我们将实现或分析一种特定的页面置换算法，可能是指定的“VMRP”（Virtual Memory Replacement Policy）。"vmrp.cc"可能是C++源代码文件，包含了算法的...
计算机操作系统实验4页面置换算法.pdf
09-30
本篇文档主要讨论的页面置换算法实验，包括了 OPT、FIFO、LRU 和 CLOCK 算法，并通过 Java 编程语言的实现来展示这些算法的原理和过程。 ### 页面置换算法概述 页面置换算法的主要目的是在发生缺页中断时，选择一...
操作系统实验五 虚拟内存页面置换算法
02-02
操作系统实验五 虚拟内存页面置换算法（内含源代码和详细实验报告），详细介绍：http://blog.csdn.net/xunciy/article/details/79239096
操作系统实验：页面置换算法
12-19
是关于操作系统三种页面置换算法的代码，希望对你们有帮助！
操作系统试验(页面置换算法js版)
12-07
操作系统试验(页面置换算法javascript版).用了jquery的简单方法，代码简单易懂。
操作系统实验——内存管理之页面置换算法
12-15
操作系统实验——内存管理之页面置换算法，包括FIFO，LRU，CLOCK三种算法
操作系统实验报告 用C++实现页面置换算法，LRU与FCFS
12-02
操作系统实验报告，用C++实现 最近最久未使用LRU,先来先服务页面置换算法FIFO
操作系统 实验四：页面置换算法
lixuzeng的博客
05-28 5099
操作系统 实验四：页面置换算法 16281042 安全1601 一、设计基本信息 1、模拟的虚拟内存的地址为16位，页面大小为1K 2、模拟的物理内存有32K 页面大小等于块的大小为1K，物理地址16位对应程序需要的物理空间为216B，需要216/1K = 64个页面，工作集的大小为 64，维护的物理内存块共32个 二、算法实现 0、程序设计、页面访问序列产生 struct Page { int...
操作系统实验四：页面置换算法
weixin_41680909的博客
05-27 1399
实验目的及基本要求 设计和实现： 最佳置换算法(Optimal) 先进先出置换算法(FIFO) 最近最久未使用置换算法(LRU) 改进型Clock置换算法 页面缓冲置换算法(PBA) 假设模拟的虚拟内存的地址为16位，页面大小为1K ，模拟的物理内存有32K，通过页面访问序列随机发生器实现对上述算法的测试及性能比较。 基本知识： 请求分页虚拟内存管理 请求分页虚拟内存管理...
页面置换算法
weixin_44795839的博客
11-09 315
#include <iostream> #define M 3 #define N 20 using namespace std; struct block { int iPageNum; //物理块里存储的页面号 int iBlockFlag; //在三种算法中用到的标记。例如在FIFO中为在内存中的时间 }; //算法模拟移位寄存器原理 void FIFO(int iTempPage[N],int flag[N],block myBlock[M]); voi
操作系统实验——页面置换算法
m0_63927576的博客
11-25 622
先进先出（FIFO）算法 当需要选择一个页面淘汰时，总是选择最先进入内存空间的那一个页面。只要在系统中建立 一个 FIFO 队列，以反映页面的活动情况。被选择的页面总是处于队首的页面，而最近调入的页 面永远存放在队列的尾部。最近最久未使用（LRU）算法 该算法的基本思想是用最近的过去估计最近的将来。假定在内存中某个页面，在最近一段时 间内未被使用的时间最长，那么在最近的将来也可能不再被使用。最佳页面置换（OPT）算法： 这是一种理想情况下的页面置换算法，但实际上不可能实现。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值