页面转换算法实现(C语言)

最新推荐文章于 2024-01-04 16:28:13 发布
原创 最新推荐文章于 2024-01-04 16:28:13 发布 · 1.7k 阅读 · 41 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #os

本文详细介绍了五种常见的页面置换算法——最佳置换算法(OPT)、先进先出算法(FIFO)、最少使用算法(LFU)、最近最久未使用算法(LRU)和最近未用算法(NRU)的C语言实现。每种算法都有其独特的优缺点，例如OPT提供最低缺页率但无法预知未来，FIFO实现简单但性能较差，LFU和LRU利用历史信息优化性能，而NRU则在性能和开销间取得平衡。通过代码演示，展示了这些算法如何处理页面调度问题。

5种页面置换算法的简单实现

页面置换算法

OPT

最佳置换算法

  • 缺点：最佳置换算法是一种理想化算法，具有较好的性能，但是实际上无法实现（无法预知一个进程中的若干页面哪一个最长时间不被访问）；
  • 优点：最佳置换算法可以保证获得最低的缺页率，性能最好
void opt() //最佳转换算法，往后查找
{
	printf("--------------------------------\n");
	printf("现在执行的是最佳置换算法opt：\n");
	memset(arr, -1, sizeof(arr));
	int no = 0, tot = 0, z = 0, three = 0;
	int flag[8];
	memset(flag, 0, sizeof(flag)); //初始化一个flag数组，来确定最晚出现需要替换的点
	for (i = 0; i < M; i++)
	{
		if (no < N) //填充空数组 
		{
			arr[no++] = pageNum[i];
			tot++;
			showdata(); 
		}
		else //当数组填充满后
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
			}
			if (z == 0)
			{
				for (int k = i + 1; k < M; k++) //从下一位向后查找 
				{
					for (j = 0; j < N; j++)
					{
						if (arr[j] == pageNum[k] && three < (N-1)) //此位先出现则标记此位
						{
							if (flag[arr[j]] == 1)
								continue;
							flag[arr[j]] = 1;							
							three++;
						}
					}
				}
				for (int l = 0; l < N; l++) //遍历确定最长时间未被访问的页面
				{
					if (flag[arr[l]] == 1)
						continue;
					else         
					{
						arr[l] = pageNum[i];
						tot++;
						showdata();
					}
				}
			}
			z = 0;
			three = 0;
			memset(flag, 0, sizeof(flag));
		}
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("OPT缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

FIFO

先进先出算法

  • 优点：先进先出算法实现简单，是最直观的一个算法
  • 缺点：先进先出的性能最差，因为与通常页面的使用规则不符合，所以实际应用少
//FIFO先进先出算法
void fifo()
{
	printf("--------------------------------\n");
	printf("现在执行的是FIFO先进先出算法：\n");
	memset(arr, -1, sizeof(arr));
	int no = 0, z = 0, change = 0;
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			if (arr[j] == pageNum[i])
				z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
		}
		if (z == 0)
		{
			change++;
			arr[no++] = pageNum[i];
			showdata();
		}
		z = 0; //默认需要调度
		if (no == N) //队列已满，则归0从头开始，等效于队头出队
			no = 0;
	}
	printf("页面置换的次数为：%d\n", change);
	double rate = (double)change / M * 100;
	printf("FIFO缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

LFU

最少使用置换算法

  • 缺点：并不能真正反映出页面的真实情况
  • 优点：该算法既充分利用了主存中页面调度情况的历史信息，又正确反映了程序的局部性
void lfu() //最不经常使用算法，使用次数最少算法
{
	printf("--------------------------------\n");
	printf("现在执行的是最不经常使用算法lfu：\n");
	int count[8], tot = 0, no = 0, z = 0, least = 100, mark = -1;
	memset(arr, -1, sizeof(arr));
	memset(count, 0, sizeof(count)); //用count数组记录访问次数，当访问次数相同时
	for (i = 0; i < M; i++)          //默认取索引较小的一位
	{
		if (no < N) //填充空数组 
		{
			arr[no++] = pageNum[i];
			tot++;
			count[pageNum[i]]++;
			showdata();
		}
		else
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
				{
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
					count[pageNum[i]]++;
				}
			}
			if (z == 0)
			{
				for (int k = 0; k < N; k++) //通过循环比较出目前访问次数最小的页面进程
				{
					if (count[arr[k]] < least)
					{
						least = count[arr[k]];
						mark = k;
					}
				}
				arr[mark] = pageNum[i];
				showdata();
				tot++;
				count[pageNum[i]]++;
			}
			z = 0;
			least = 100;
			mark = -1;
		}
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("LFU缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

LRU

最近最久未使用置换算法

  • 优点：由于考虑程序访问的时间局部性，一般能有较好的性能；实际应用多
  • 缺点：实现需要较多的硬件支持，会增加硬件成本
void lru() //最近最久未访问算法，从当前位往前查找
{
	printf("--------------------------------\n");
	printf("现在执行的是最近最久未访问算法lru：\n");
	memset(arr, -1, sizeof(arr));
	int no = 0, tot = 0, z = 0, three = 0;
	int flag[8];
	memset(flag, 0, sizeof(flag)); //初始化一个flag数组，来确定最晚出现需要替换的点
	for (i = 0; i < M; i++)
	{
		if (no < N) //填充空数组 
		{
			arr[no++] = pageNum[i];
			tot++;
			showdata();
		}
		else //当数组填充满后
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
			}
			if (z == 0)
			{
				for (int k = i - 1; k >= 0; k--) //从上一位向前查找 
				{
					for (j = 0; j < N; j++)
					{
						if (arr[j] == pageNum[k] && three < (N - 1)) //此位先出现则标记此位
						{
							if (flag[arr[j]] == 1)
								continue;
							flag[arr[j]] = 1;
							three++;
						}
					}
				}
				for (int l = 0; l < N; l++) //遍历确定最长时间未被访问的页面
				{
					if (flag[arr[l]] == 1)
						continue;
					else
					{
						arr[l] = pageNum[i];
						tot++;
						showdata();
					}
				}
			}
			z = 0;
			three = 0;
			memset(flag, 0, sizeof(flag));
		}
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("LRU缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

NRU

最近未用/时钟算法

  • 优点：性能和开销比较均衡
  • 缺点：未考虑页面是否被修改过
void nru() //clock置换算法/最近未用算法/NRU算法
{
	printf("--------------------------------\n");
	printf("现在执行的是clock置换算法nru：\n");
	int ask[10], no = 0, tot = 0, z = 0, mark = 0;
	memset(arr, -1, sizeof(arr));
	memset(ask, 0, sizeof(ask)); //ask数组标记是否访问，1代表最近访问，0代表未访问
	for (i = 0; i < M; i++)
	{
		if (no < N) //填充空数组 
		{
			ask[no] = 1; //初始化为最近访问
			arr[no++] = pageNum[i];
			tot++;
			showdata();
		}
		else
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
				{
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
					ask[j] = 1; //同时更新最近访问
				}
			}
			if (z == 0)
			{
				int k = 0;
				while (1) //通过循环找出访问位为0
				{
					for (k = 0; k < N; k++)
					{
						if (ask[k] == 0)
							goto flag;
						else if (ask[k] == 1)
							ask[k] = 0;
					}
				}
				flag:
				arr[k] = pageNum[i];
				ask[k] = 1;
				showdata();
				tot++;
			}
		}
		z = 0;
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("NRU缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

代码实现(C语言)

#include <stdio.h>
#include <stdlib.h>

#define N 3
#define M 20
int i, j;
int arr[N];
int pageNum[M] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 };

void showdata()
{
	for (int i = 0; i < N; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

//FIFO先进先出算法
void fifo()
{
	printf("--------------------------------\n");
	printf("现在执行的是FIFO先进先出算法：\n");
	memset(arr, -1, sizeof(arr));
	int no = 0, z = 0, change = 0;
	for (i = 0; i < M; i++)
	{
		for (j = 0; j < N; j++)
		{
			if (arr[j] == pageNum[i])
				z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
		}
		if (z == 0)
		{
			change++;
			arr[no++] = pageNum[i];
			showdata();
		}
		z = 0; //默认需要调度
		if (no == N) //队列已满，则归0从头开始，等效于队头出队
			no = 0;
	}
	printf("页面置换的次数为：%d\n", change);
	double rate = (double)change / M * 100;
	printf("FIFO缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

void opt() //最佳转换算法，往后查找
{
	printf("--------------------------------\n");
	printf("现在执行的是最佳置换算法opt：\n");
	memset(arr, -1, sizeof(arr));
	int no = 0, tot = 0, z = 0, three = 0;
	int flag[8];
	memset(flag, 0, sizeof(flag)); //初始化一个flag数组，来确定最晚出现需要替换的点
	for (i = 0; i < M; i++)
	{
		if (no < N) //填充空数组 
		{
			arr[no++] = pageNum[i];
			tot++;
			showdata(); 
		}
		else //当数组填充满后
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
			}
			if (z == 0)
			{
				for (int k = i + 1; k < M; k++) //从下一位向后查找 
				{
					for (j = 0; j < N; j++)
					{
						if (arr[j] == pageNum[k] && three < (N-1)) //此位先出现则标记此位
						{
							if (flag[arr[j]] == 1)
								continue;
							flag[arr[j]] = 1;							
							three++;
						}
					}
				}
				for (int l = 0; l < N; l++) //遍历确定最长时间未被访问的页面
				{
					if (flag[arr[l]] == 1)
						continue;
					else         
					{
						arr[l] = pageNum[i];
						tot++;
						showdata();
					}
				}
			}
			z = 0;
			three = 0;
			memset(flag, 0, sizeof(flag));
		}
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("OPT缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

void lru() //最近最久未访问算法，从当前位往前查找
{
	printf("--------------------------------\n");
	printf("现在执行的是最近最久未访问算法lru：\n");
	memset(arr, -1, sizeof(arr));
	int no = 0, tot = 0, z = 0, three = 0;
	int flag[8];
	memset(flag, 0, sizeof(flag)); //初始化一个flag数组，来确定最晚出现需要替换的点
	for (i = 0; i < M; i++)
	{
		if (no < N) //填充空数组 
		{
			arr[no++] = pageNum[i];
			tot++;
			showdata();
		}
		else //当数组填充满后
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
			}
			if (z == 0)
			{
				for (int k = i - 1; k >= 0; k--) //从上一位向前查找 
				{
					for (j = 0; j < N; j++)
					{
						if (arr[j] == pageNum[k] && three < (N - 1)) //此位先出现则标记此位
						{
							if (flag[arr[j]] == 1)
								continue;
							flag[arr[j]] = 1;
							three++;
						}
					}
				}
				for (int l = 0; l < N; l++) //遍历确定最长时间未被访问的页面
				{
					if (flag[arr[l]] == 1)
						continue;
					else
					{
						arr[l] = pageNum[i];
						tot++;
						showdata();
					}
				}
			}
			z = 0;
			three = 0;
			memset(flag, 0, sizeof(flag));
		}
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("LRU缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

void lfu() //最不经常使用算法，使用次数最少算法
{
	printf("--------------------------------\n");
	printf("现在执行的是最不经常使用算法lfu：\n");
	int count[8], tot = 0, no = 0, z = 0, least = 100, mark = -1;
	memset(arr, -1, sizeof(arr));
	memset(count, 0, sizeof(count)); //用count数组记录访问次数，当访问次数相同时
	for (i = 0; i < M; i++)          //默认取索引较小的一位
	{
		if (no < N) //填充空数组 
		{
			arr[no++] = pageNum[i];
			tot++;
			count[pageNum[i]]++;
			showdata();
		}
		else
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
				{
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
					count[pageNum[i]]++;
				}
			}
			if (z == 0)
			{
				for (int k = 0; k < N; k++) //通过循环比较出目前访问次数最小的页面进程
				{
					if (count[arr[k]] < least)
					{
						least = count[arr[k]];
						mark = k;
					}
				}
				arr[mark] = pageNum[i];
				showdata();
				tot++;
				count[pageNum[i]]++;
			}
			z = 0;
			least = 100;
			mark = -1;
		}
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("LFU缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

void nru() //clock置换算法/最近未用算法/NRU算法
{
	printf("--------------------------------\n");
	printf("现在执行的是clock置换算法nru：\n");
	int ask[10], no = 0, tot = 0, z = 0, mark = 0;
	memset(arr, -1, sizeof(arr));
	memset(ask, 0, sizeof(ask)); //ask数组标记是否访问，1代表最近访问，0代表未访问
	for (i = 0; i < M; i++)
	{
		if (no < N) //填充空数组 
		{
			ask[no] = 1; //初始化为最近访问
			arr[no++] = pageNum[i];
			tot++;
			showdata();
		}
		else
		{
			for (j = 0; j < N; j++)
			{
				if (arr[j] == pageNum[i])
				{
					z = 1; //如果队列里已经存在此进程，则无需再进行页面调度
					ask[j] = 1; //同时更新最近访问
				}
			}
			if (z == 0)
			{
				int k = 0;
				while (1) //通过循环找出访问位为0
				{
					for (k = 0; k < N; k++)
					{
						if (ask[k] == 0)
							goto flag;
						else if (ask[k] == 1)
							ask[k] = 0;
					}
				}
				flag:
				arr[k] = pageNum[i];
				ask[k] = 1;
				showdata();
				tot++;
			}
		}
		z = 0;
	}
	printf("页面置换的次数为：%d\n", tot);
	double rate = (double)tot / M * 100;
	printf("NRU缺页率为：%.2lf%%\n", rate);
	printf("--------------------------------\n");
}

int main()
{
	fifo(); //先进先出算法
	opt(); //最佳转换算法
	lru(); //最近最久未使用
	lfu(); //最不经常使用算法
	nru(); //clock置换算法

	return 0;
}
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现算法比较的程序输出，比如：缺页率和页面置换次数等。 3.采用固定分配局部置换，且可以在程序中实现块数重新分配。 具有抖动判断和Belady异常判断机制 根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,置换次数,命中率的结果; 3.进行虚拟存储算法设计分析。
操作系统实验-页面置换算法C语言实现
05-30
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率： 要求设计主界面以灵活选择某算法，且以下算法都要实现 1）先进先出算法（FIFO） 2）最近最久未使用算法（LRU） 3）最佳置换算法（OPT）
利用C语言实现页面置换算法
braylon_zhang的博客
12-14 1万+
操作系统实验 页面置换算法（FIFO、LRU、OPT） 概念： 1.最佳置换算法（OPT）（理想置换算法）：从主存中移出永远不再需要的页面；如无这样的页面存在，则选择最长时间不需要访问的页面。于所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。 2.先进先出置换算法（FIFO）：是最简单的页面置换算法。这种算法的基本思想是：当需要淘汰一个页面时，总是选择驻留主存时间最长的页面进行淘汰，即先进入主存的页面先淘汰。其理由是：最早调入主存的页面不再被使用的可能
页面置换六种算法c语言实现
01-02
opt、FIFO、LRU/LFU、简单clock、改进型clock等算法实现页面置换
C语言实现页面置换算法
06-15
C 语言实现页面置换算法，一共实现LRU置换算法 随机置换算法 FIFO置换算法 Clock及改进型置换算法五个算法，可以算平均命中率。VC++6.0上可直接运行
【操作系统--页面置换算法】C语言详解--大作业版（附代码）
热门推荐
炼丹笔记
12-25 4万+
该实验为作者OS课程大作业，内容若有问题，望指出，多多交流
静态树表查找算法（C语言实现）
最新发布
数据结构和算法教程（C语言版）
01-04 1085
静态树表查找算法只适用于有序查找表，首先将有序表转换成一棵静态树表（二叉树），后续的查找操作都在静态树表上完成。当有序表中的元素查找概率不同时，可以使用二分查找算法，但静态树表查找算法的性能更高。当前阅读的是整套数据结构和算法教程中的一节内容，想系统学习数据结构和算法的读者，可以前往教程目录页面系统的学习，加我 q（834937624）获取教程的完整 PDF 电子版。
C语言实现最近最久未使用页面调度算法
fancy_hacker的博客
11-08 2374
一、c语言实现页面调度算法LRU（最近最久未使用算法） 这是我第一次写这个东西哟，还是个在校学生，学的不好，如果有啥错的可以发信息给我哟，一块努力一块进步，奥利给！哈哈哈！虽然写代码的过程不是那么快乐，但是写正确后的喜悦是值得的，加油陌生人！！！ 1.首先先来介绍一下什么是LRU算法： 因为我们的内存大小是有限的所以我们不可能将将我们的程序所有的都加载到内存中去运行，这时候我们会为我们的程序划分内存块，然后通过调度算法按一定的策略，将内存中的一些我们暂时用不到的一些页面号，进行调出内存中，然后将我们要用到的
操作系统实验（五）：c实现几种页面置换算法
le000426的博客
06-14 1045
操作系统实验（五）：c实现几种页面置换算法
三种页面置换算法详解(含C语言代码)（提供百度网盘链接，可免费下载）
04-16
这是和文档相对应的博客链接：https://blog.youkuaiyun.com/AaricYang/article/details/72861566 该文档是对FIFO、Optimal、LRU三种页面置换算法的详解，包含C语言代码。 另外，该word文档已经上传到百度网盘了，这是链接，可免费下载。 链接：https://pan.baidu.com/s/13lEZBX_VJAHZbhN22MvyMQ 密码：1etj， 更新于2018年04月16日。。
存储管理页面置换算法C语言实现
05-17
OPT算法、FIFO算法、LRU算法、LFU算法的具体实现
页面置换算法(fifo,lru,opt) C语言编写
07-02
页面置换算法(fifo,lru,opt) C语言编写 是我操作系统课程设计的题目,自己完成的
操作系统LRU页面置换算法 C语言程序
05-25
操作系统LRU页面置换算法 C语言程序 数组实现 简单，清晰且实用，
用c语言模拟先进先出页面置换算法
12-04
这是一个用c语言模拟先进先出页面置换算法的代码，可以任意输入页面数，物理块数与页面序列，然后进行置换后的排序。
C语言实现Optimal、FIFO、LRU页面置换算法
09-07
栈 数组 队列等数据结构 int QueueEmpty(pagequeue *q) { if(q->count==0) return 1; else return 0; } int QueueFull(pagequeue *q) { if(q->count==num) return 1; else return 0; } 等等...
计算机操作系统实验之页面置换算法（C语言）
小姚的博客
12-08 4万+
在进程运行过程中，如果它需要访问的页面不在内存，需要把它调入内存，但是内存已满时，需要把内存中的某页数据送到磁盘的对换区中。而选择哪个页面，则由固定的算法来决定，称为页面置换算法
页面置换算法（C语言版）FIFO和LRU代码
m0_70070803的博客
12-20 1755
void LRU(PageTable pagetable[6],int data[10],int block[3]){//最近最少使用页面置换算法。//首先将数据传输到相应的内存块;
C语言操作系统——页面置换算法（FIFO/LRU）
Wu_zx520的博客
06-03 1万+
由于本学期学习操作系统所以需要用代码实现一些算法，本人大二由于对C语言掌握的不太好，所以一直逼着自己用C语言写代码，还好写出来了，在这里与大家分享。首先建立一个工程文件，本人喜欢建立一个头文件，一个功能文件和一个主函数文件。头文件，page_replace.h#include &lt;stdio.h&gt;#include &lt;windows.h&gt;typedef struct Page{...
LRU页面置换算法（C语言实现）
qq_50829760的博客
11-12 1万+
编写并调试一个页面置换模拟程序，采用LRU（最近最久未使用页面置换）算法。已知系统为一进程分配的物理块数，进程运行过程中引用的页面号，编程使用LRU算法输出置换的页号、缺页中断次数及缺页率。
跨平台C语言FIFO页面替换算法实现
在C语言中实现FIFO页面切换算法，通常需要以下步骤： 1. 定义数据结构来保存内存页面信息。通常，这包括一个队列来记录页面的加载顺序。 2. 实现一个函数来模拟页面请求，该函数接收页面号作为输入，并检查该页面...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CodeSlogan

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

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

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

打赏作者

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

抵扣说明：

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

余额充值