页面置换算法——C/C++实现 [ OTP, FIFO, LRU, LFU + 开源代码 + 详细解析]

最新推荐文章于 2024-05-24 10:57:20 发布
最新推荐文章于 2024-05-24 10:57:20 发布
阅读量2.7w 收藏 602
点赞数 121
分类专栏： 操作系统学习笔记 文章标签： 算法 c语言 c++ 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wang_Dou_Dou_/article/details/122127087
版权

⌛️

文章目录

Page Replacement Algorithm ⌨️

零、运行结果图

在这里插入图片描述
◆ 对上图说明：后面分别用四种算法，对该样例都进行了检验，结果一致。

● 后文代码的常见变量：
  [1] n：物理页框数。
  [2] len：地址走向的长度。
  [3] save_Frame：含有n个格子的物理页框（即一个长度为n的动态数组，指针申请的）。
  [4] interview_Array：长度为len的地址数组（即一个长度为len的动态数组，指针申请的）。


一、最佳置换算法（OPT）

● 替换规则：将以后永不使用的或在最长时间内不再被访问的页面进行替换。

● 这是一种理想化的算法，有点 “先知” 算法的味道，故在实际上是难以实现的。但它可作为衡量各种实用的页面置换算法的标准。

● 样例：假设采用固定分配策略，为进程分配 3 个存储页框，进程运行时形成的访问地址走向为 2，3，2，1，5，2，4，5，3，2，5 和 2。则 OPT 算法运行结果如下。
在这里插入图片描述
◆ 说明：
  ① 第一个红箭头：因为后面需访问地址里面没有 “1”，所以用 “5” 置换 “1”。
  ② 第二个红箭头：因为后面需访问的地址里面，“2” 是最长时间内不被访问的，所以置换它。
  ③ 当进程运行完毕时，系统进行了 3 次置换，缺页中断次数为 6 次，即蓝色箭头加上红色箭头的个数。缺页率为 6/12 = 50% 。


● 算法设计：

[1] 依次读取每一个页面地址addr，然后看当前页框是否装满。如果未装满则执行[2]，否则执行[3]。

[2] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，然后返回执行步骤[1]，否则执行[4](即未命中的情况)。

[3] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，然后返回执行步骤[1]，否则执行[5](即未命中的情况)。

[4] 把当前地址addr装入空闲的物理页框，然后返回执行步骤[1]。

[5] 执行Find_LeastInteviewTime()函数，找出需要替换的页面地址(在物理页框中的)，并进行替换，然后返回执行步骤[1]。

● 核心代码：【注：Init()函数、Find_Exist()等函数在后文的完整代码中】

int Find_LeastInteviewTime(int sta, int addr, int* interview_Array, int len)
{
	for (int i = sta; i < len; i++)
	{
		if (interview_Array[i] == addr)
			return i - sta;
	}
	return 99999;
}

void OPT_Agorithm()
{
	printf("欢迎使用 OPT \n");
	int n = 0, len = 0, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
		
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);

	int addr;		// 地址
	int cnt = 0;			// 物理页框已装满的份数(大于 n 时无效) 
	int score = 0;			// 成功的访问次数
	int fail_time = 0;		// 不成功的访问次数
	int iter = 0;	// 迭代次数
	while (iter < len)
	{
		printf("\n第%d轮：", iter);
		addr = interview_Array[iter];		// 读取地址
		iter++;
		...
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				...
			}
			else // 未命中，但有空间 
			{
				fail_time++;
				...
				save_Frame[cnt] = addr;
				...
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				...
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int* least_Time = (int*)malloc(n * sizeof(int));
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					least_Time[i] = Find_LeastInteviewTime(iter, save_Frame[i], interview_Array, len);
					if (least_Time[i] > max_Time)
					{
						max_Time = least_Time[i];
						index = i;
					}
				}
				...
				save_Frame[index] = addr;
				...
			}
		}
	}
	...
}

● 运行结果：

在这里插入图片描述


二、先进先出算法（FIFO）

● 替换规则：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以替换。

● 依旧沿用上面的样例来图形化说明：假设采用固定分配策略，为进程分配 3 个存储页框，进程运行时形成的访问地址走向为 2，3，2，1，5，2，4，5，3，2，5 和 2。则 OPT 算法运行结果如下。
在这里插入图片描述
◆ 说明：
  ① 第一个红箭头：因为 “2” 最先进来，所以用 “5” 置换 “2”。
  ② 当进程运行完毕时，系统进行了 6 次置换，缺页中断次数为 9 次，即蓝色箭头加上红色箭头的个数。缺页率为 9 /12 = 75% 。


● 算法设计：【in_HereTime[]：记录每个页面驻留的时间】

[1] 依次读取每一个页面地址addr，然后看当前页框是否装满。如果未装满则执行[2]，否则执行[3]。

[2] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，然后执行Update_InHereTime()函数来更新in_HereTime[]数组，然后返回执行步骤[1]，否则执行[4](即未命中的情况)。

[3] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，然后执行Update_InHereTime()函数来更新in_HereTime[]数组，然后返回执行步骤[1]，否则执行[5](即未命中的情况)。

[4] 把当前地址addr装入空闲的物理页框，然后执行Update_InHereTime()函数来更新in_HereTime数组，然后返回执行步骤[1]。

[5] 从in_HereTime[]找出最大值对应的那个页面地址(在物理页框中的)，并进行替换，然后返回执行步骤[1]。

● 核心代码：【注：Init()函数、Find_Exist()函数等函数在后文的完整代码中】

void Update_InHereTime(int* in_HereTime, int n, int ind)
{
	for (int i = 0; i < n; i++)
		in_HereTime[i]++;
	if (ind != -1)
		in_HereTime[ind] = 0;
}

void FIFO_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
		
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);

	int* in_HereTime = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		in_HereTime[i] = 0;		// 初始化都为零

	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		printf("\n第%d轮：", iter);
		addr = interview_Array[iter];
		iter++;
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				...
				Update_InHereTime(in_HereTime, cnt, -1);
			}
			else // 未命中，但有空间
			{
				fail_time++;
				...
				save_Frame[cnt] = addr;
				...
				Update_InHereTime(in_HereTime, cnt, cnt);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				...
				Update_InHereTime(in_HereTime, n, -1);
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					if (in_HereTime[i] > max_Time)
					{
						max_Time = in_HereTime[i];
						index = i;
					}
				}
				...
				save_Frame[index] = addr;
				...
				int ind = Find_Exist(save_Frame, n, addr);
				Update_InHereTime(in_HereTime, n, ind);
			}
		}
	}
	...
}

● 测试结果：
在这里插入图片描述


三、最近最久未使用算法（LRU）

● 替换规则：替换最近一段时间内最久未被使用的页面。

● 依旧沿用上面的样例来图形化说明：假设采用固定分配策略，为进程分配 3 个存储页框，进程运行时形成的访问地址走向为 2，3，2，1，5，2，4，5，3，2，5 和 2。则 OPT 算法运行结果如下。

在这里插入图片描述
◆ 说明：
  ① 第一个红箭头：因为 “2” 最近被访问过，“1”刚刚才被调入，只有 “3” 最近最久未被访问，所以置换它。
  ② 当进程运行完毕时，系统进行了 4 次置换，缺页中断次数为 7 次，即蓝色箭头加上红色箭头的个数。缺页率为 7 /12 = 58.33% 。



● 算法设计：

[1] 依次读取每一个页面地址addr，然后看当前页框是否装满。如果未装满则执行[2]，否则执行[3]。

[2] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，然后返回执行步骤[1]，否则(即未命中)执行[4]。

[3] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，然后返回执行步骤[1]，否则(即未命中)执行[5]。

[4] 把当前地址addr装入空闲的物理页框，然后返回执行步骤[1]。

[5] 执行Find_LeastNotUseTime()函数，找出需要替换的页面地址(在物理页框中的)，并进行替换，然后返回执行步骤[1]。

● 核心代码：【注：Init()函数、Find_Exist()函数等函数在后文的完整代码中】

int Find_LeastNotUseTime(int end, int addr, int* interview_Array)
{
	for (int i = end - 1; i >= 0; i--)
	{
		if (interview_Array[i] == addr)
			return end - i;
	}
	return 99999;
}

void LRU_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
		
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);

	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		addr = interview_Array[iter];
		iter++;
		...
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				...
			}
			else // 未命中，但有空间
			{
				fail_time++;
				...
				save_Frame[cnt] = addr;
				...
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				...
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int* Not_UseTime = (int*)malloc(n * sizeof(int));
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					Not_UseTime[i] = Find_LeastNotUseTime(iter, save_Frame[i], interview_Array);
					if (Not_UseTime[i] > max_Time)
					{
						max_Time = Not_UseTime[i];
						index = i;
					}
				}
				...
				save_Frame[index] = addr;
				...
			}
		}
	}
	...
}

● 测试结果：

在这里插入图片描述


四、最不经常使用算法（LFU）

● 替换规则：把当前为止，访问次数最少的页面予以替换。

● 和上面的样例有一点不同(地址走向不同)：假设采用固定分配策略，为进程分配 3 个存储页框，进程运行时形成的访问地址走向为 2，3，2，1，2，1，5，4，2，4，4 和 6。则 LFU 算法运行结果如下。
在这里插入图片描述
◆ 说明：
  ① 第一个红箭头：因为 “3” 被访问（即被命中）的次数为 0，而其他两个页面( “2” 和 “1” 都分别有 2、1 次命中)，所以“3” 的访问次数最少，所以置换它。
  ② 当进程运行完毕时，系统进行了 3 次置换，缺页中断次数为 6 次（即蓝色箭头加上红色箭头的个数）。缺页率为 6 /12 = 50% 。


● 算法设计：【interview_Time[]：记录每个页面被访问的次数】

[1] 依次读取每一个页面地址addr，然后看当前页框是否装满。如果未装满则执行[2]，否则执行[3]。

[2] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，并且使对应的interview_Time加1，然后返回执行步骤[1]，否则(即未命中)执行[4]。

[3] 执行Find_Exist()函数，看页框中是否已存在当前地址。如果存在则 “命中”，并且使对应的interview_Time加1，然后返回执行步骤[1]，否则(即未命中)执行[5]。

[4] 把当前地址addr装入空闲的物理页框，然后返回执行步骤[1]。

[5] 执行Find_LeastNotInterviewTime()函数，找出需要替换的页面地址(在物理页框中的)进行替换，并使对应的的interview_Time重新赋值为0，然后返回执行步骤[1]。

● 核心代码：【注：Init()函数、Find_Exist()函数等函数在后文的完整代码中】

int Find_LeastNotInterviewTime(int n, int* interview_Time)
{
	int min_Time = 99999;
	int ind;
	for (int i = 0; i < n; i++)
	{
		if (interview_Time[i] < min_Time)
		{
			min_Time = interview_Time[i];
			ind = i;
		}
	}
	return ind;
}

void LFU_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);

	int* interview_Time = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		interview_Time[i] = 0;

	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		printf("\n第%d轮：", iter);
		addr = interview_Array[iter];
		iter++;
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				...
				int ind = Find_Exist(save_Frame, cnt, addr);
				interview_Time[ind]++;
			}
			else // 未命中，但有空间
			{
				fail_time++;
				...
				save_Frame[cnt] = addr;
				...
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				...
				int ind = Find_Exist(save_Frame, n, addr);
				interview_Time[ind]++;
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int index = Find_LeastNotInterviewTime(n, interview_Time);
				...
				save_Frame[index] = addr;
				...
			}
		}
	}
	...
}

● 测试结果：

在这里插入图片描述


五、完整代码 —— C语言版本

● 补充说明：完整代码中，还包含 “输出内存驻留的页面集合”【Print_Frame()函数】 、“缺页次数” 和 “缺页率” 等功能【Page_Loss_Rate()函数】。

#include <stdio.h>
#include <stdlib.h>
void OPT_Agorithm();
void FIFO_Agorithm();
void LRU_Agorithm();
void LFU_Agorithm();
double Page_Loss_Rate(int, int);
int Find_Exist(int*, int, int);
int Find_LeastInteviewTime(int, int, int*, int);
void Update_InHereTime(int*, int, int);
int Find_LeastNotUseTime(int, int, int*);
int Find_LeastNotInterviewTime(int, int*);
void Print_Frame(int*, int);
void Print_Menu();
void Init(int*, int*);

int main()
{
	int choice;
	do
	{
		Print_Menu();
		printf("请选择要实现的算法：");
		scanf_s("%d", &choice);
		switch (choice)
		{
		case 1:
			OPT_Agorithm();
			break;
		case 2:
			FIFO_Agorithm();
			break;
		case 3:
			LRU_Agorithm();
			break;
		case 4:
			LFU_Agorithm();
			break;
		case 0:
			break;
		}
		system("pause");
		system("cls");
	} while (choice);
	return 0;
}

/*
* 用于遍历 save_Frame[] 的 n 个存储页框, 是否有 “待定地址 -> addr”
* 如果有就返回 ture, 否则返回 false
*/
int Find_Exist(int* save_Frame, int n, int addr)
{
	for (int i = 0; i < n; i++)
	{
		if (save_Frame[i] == addr)
		{
			return i;
		}
	}
	return -1;
}

void Print_Menu()
{
	/* 输入模块 */
	printf("+---------------------------------------+\n");
	printf("|\t***算法清单***\t\t\t|\n");
	printf("|\t1.最佳置换算法(OPT)\t\t|\n|\t2.先进先出算法(FIFO)\t\t|\n");
	printf("|\t3.最近最久未使用算法(LRU)\t|\n|\t4.最不经常使用算法(LFU)\t\t|\n");
	printf("|\t0.退出\t\t\t\t|\n");
	printf("+---------------------------------------+\n");
}

void Print_Frame(int* save_Frame, int n)
{
	printf("\t");
	for (int i = 0; i < n; i++)
	{
		if (i == 0)
		{
			if (save_Frame[i] == -999)
				printf("/ /");
			else
				printf("/%d/", save_Frame[i]);
		}
		else
		{
			if (save_Frame[i] == -999)
				printf(" /");
			else
				printf("%d/", save_Frame[i]);
		}
	}
	printf("\n");
}

void Init(int* n, int* len)
{
	printf("请输入 n :");
	scanf_s("%d", n);

	printf("请输入地址走向的长度：");
	scanf_s("%d", len);
}

/*
 * 缺页中断率：
 * 假设进程 P 在运行中成功的内存访问次数为 s 
 * 不成功的访问次数为 F，则缺页中断率为 R = F/(S+F)
*/
double Page_Loss_Rate(int S, int F)
{
	double ans = 1.0 * F / (1.0 * S + 1.0 * F) * 100;
	return ans;
}

/*
* 最佳置换算法(OPT)：
* 将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
* 数据结构：数组
*/

int Find_LeastInteviewTime(int sta, int addr, int* interview_Array, int len)
{
	for (int i = sta; i < len; i++)
	{
		if (interview_Array[i] == addr)
		{
			return i - sta;
		}
	}
	return 99999;
}
void OPT_Agorithm()
{
	printf("欢迎使用 OPT \n");
	int n = 0, len = 0, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);
	printf("\n");

	//测试样例： 1 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		addr = interview_Array[iter];
		iter++;
		printf("\n第%d轮：", iter);
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);
			}
			else // 未命中，但有空间
			{
				fail_time++;
				printf("未命中，\"%d\" 被装入 \t------->", addr);
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int* least_Time = (int*)malloc(n * sizeof(int));
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					least_Time[i] = Find_LeastInteviewTime(iter, save_Frame[i], interview_Array, len);
					if (least_Time[i] > max_Time)
					{
						max_Time = least_Time[i];
						index = i;
					}
				}
				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
				save_Frame[index] = addr;
				Print_Frame(save_Frame, n);
				free(least_Time);
			}
		}
		// printf("\n");
	}
	printf("\n");
	printf("缺页次数为：%d\n", fail_time);
	printf("缺页中断率 R = %.2f%%\n", Page_Loss_Rate(score, fail_time));
	free(save_Frame);
	free(interview_Array);
}

void Update_InHereTime(int* in_HereTime, int n, int ind)
{
	for (int i = 0; i < n; i++)
		in_HereTime[i]++;

	if (ind != -1)
		in_HereTime[ind] = 0;
}
/*
* 先进先出算法(FIFO)：
* 淘汰最先使用内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
* 数据结构：数组
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
*/
void FIFO_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);
	printf("\n");

	int* in_HereTime = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		in_HereTime[i] = 0;		// 初始化都为零

	//测试样例： 2 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		printf("\n第%d轮：", iter);
		addr = interview_Array[iter];
		iter++;
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);
				Update_InHereTime(in_HereTime, cnt, -1);
			}
			else // 未命中，但有空间
			{
				fail_time++;
				printf("未命中，\"%d\" 被装入 \t------->", addr);
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				Update_InHereTime(in_HereTime, cnt, cnt);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);
				Update_InHereTime(in_HereTime, n, -1);
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					if (in_HereTime[i] > max_Time)
					{
						max_Time = in_HereTime[i];
						index = i;
					}
				}
				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
				save_Frame[index] = addr;
				Print_Frame(save_Frame, n);
				int ind = Find_Exist(save_Frame, n, addr);
				Update_InHereTime(in_HereTime, n, ind);
			}
		}
	}
	printf("\n");
	printf("缺页次数为：%d\n", fail_time);
	printf("缺页中断率 R = %.2f\%%\n", Page_Loss_Rate(score, fail_time));
	free(save_Frame);
	free(interview_Array);
	free(in_HereTime);
	return;
}

int Find_LeastNotUseTime(int end, int addr, int* interview_Array)
{
	for (int i = end - 1; i >= 0; i--)
	{
		if (interview_Array[i] == addr)
		{
			return end - i;
		}
	}
	return 99999;
}
/*
* 最近最久未使用算法(LRU)：
* 淘汰最近最久未被使用的页面。
* 数据结构：数组
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
*/
void LRU_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);
	printf("\n");
	//测试样例： 3 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		addr = interview_Array[iter];
		iter++;
		printf("\n第%d轮：", iter);
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);

			}
			else // 未命中，但有空间
			{
				fail_time++;
				printf("未命中，\"%d \" 被装入 \t------->", addr);
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int* Not_UseTime = (int*)malloc(n * sizeof(int));
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					Not_UseTime[i] = Find_LeastNotUseTime(iter, save_Frame[i], interview_Array);
					if (Not_UseTime[i] > max_Time)
					{
						max_Time = Not_UseTime[i];
						index = i;
					}
				}
				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
				save_Frame[index] = addr;
				Print_Frame(save_Frame, n);
				free(Not_UseTime);
			}
		}
	}
	printf("\n");
	printf("缺页次数为：%d\n", fail_time);
	printf("缺页中断率 R = %.2f%%\n", Page_Loss_Rate(score, fail_time));
	free(save_Frame);
	free(interview_Array);
}

int Find_LeastNotInterviewTime(int n, int* interview_Time)
{
	int min_Time = 99999;
	int ind;
	for (int i = 0; i < n; i++)
	{
		if (interview_Time[i] < min_Time)
		{
			min_Time = interview_Time[i];
			ind = i;
		}
	}
	return ind;
}
/*
* 最不经常使用算法(LFU):
* 即选择最近一段时间内最长时间没有被访问过的页面进行置换
* 数据结构：数组
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
*/
void LFU_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len);
	save_Frame = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		save_Frame[i] = -999;
	printf("请输入地址走向:");
	interview_Array = (int*)malloc(len * sizeof(int));
	for (int i = 0; i < len; i++)
		scanf_s("%d", &interview_Array[i]);
	printf("\n");

	int* interview_Time = (int*)malloc(n * sizeof(int));
	for (int i = 0; i < n; i++)
		interview_Time[i] = 0;

	// 测试样例一：4 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	// 测试样例二：4 3 12 2 3 2 1 2 1 5 4 2 4 4 6
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		printf("\n第%d轮：", iter);
		addr = interview_Array[iter];
		iter++;
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);
				int ind = Find_Exist(save_Frame, cnt, addr);
				interview_Time[ind]++;
			}
			else // 未命中，但有空间
			{
				fail_time++;
				printf("未命中，\"%d\" 被装入 \t------->", addr);
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				printf("\"%d\" 被命中了\t\t------->", addr);
				Print_Frame(save_Frame, n);
				int ind = Find_Exist(save_Frame, n, addr);
				interview_Time[ind]++;
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int index = Find_LeastNotInterviewTime(n, interview_Time);
				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
				save_Frame[index] = addr;
				interview_Time[index] = 0;
				Print_Frame(save_Frame, n);
			}
		}
	}
	printf("\n");
	printf("缺页次数为：%d\n", fail_time);
	printf("缺页中断率 R = %.2f\%%\n", Page_Loss_Rate(score, fail_time));
	free(save_Frame);
	free(interview_Array);
	free(interview_Time);
}

六、完整代码 —— C++版本

● 补充说明：完整代码中，还包含 “输出内存驻留的页面集合”【Print_Frame()函数】 、“缺页次数” 和 “缺页率” 等功能【Page_Loss_Rate()函数】。

#include <iostream>
#include <stdlib.h>
using namespace std;
void OPT_Agorithm();
void FIFO_Agorithm();
void LRU_Agorithm();
void LFU_Agorithm();
double Page_Loss_Rate(int, int);
int Find_Exist(int*, int, int);
int Find_LeastInteviewTime(int, int, int*, int);
void Update_InHereTime(int*, int, int);
int Find_LeastNotUseTime(int, int, int*);
int Find_LeastNotInterviewTime(int, int*);
void Print_Frame(int*, int);
void Print_Menu();

int main()
{
	int choice;
	do
	{
		Print_Menu();
		cout << "请选择要实现的算法：";
		cin >> choice;
		switch (choice)
		{
		case 1:
			OPT_Agorithm();
			break;
		case 2:
			FIFO_Agorithm();
			break;
		case 3:
			LRU_Agorithm();
			break;
		case 4:
			LFU_Agorithm();
			break;
		case 0:
			break;
		}
		system("pause");
		system("cls");
	} while (choice);
	return 0;
}

/*
* 用于遍历 save_Frame[] 的 n 个存储页框, 是否有 “待定地址 -> addr”
* 如果有就返回 ture, 否则返回 false
*/
int Find_Exist(int* save_Frame, int n, int addr)
{
	for (int i = 0; i < n; i++)
	{
		if (save_Frame[i] == addr)
		{
			return i;
		}
	}
	return -1;
}

void Print_Menu()
{
	/* 输入模块 */
	cout << "+---------------------------------------+" << endl;
	cout << "|\t***算法清单***\t\t\t|" << endl;
	cout << "|\t1.最佳置换算法(OPT)\t\t|" << endl << "|\t2.先进先出算法(FIFO)\t\t|" << endl;
	cout << "|\t3.最近最久未使用算法(LRU)\t|" << endl << "|\t4.最不经常使用算法(LFU)\t\t|" << endl;
	cout << "|\t0.退出\t\t\t\t|" << endl;
	cout << "+---------------------------------------+" << endl;
}

void Print_Frame(int* save_Frame, int n)
{
	cout << "\t";
	for (int i = 0; i < n; i++)
	{
		if (i == 0)
		{
			if (save_Frame[i] == -999)
				cout << "/ /";
			else
				cout << "/" << save_Frame[i] << "/";
		}
		else
		{
			if (save_Frame[i] == -999)
				cout << " /";
			else
				cout << save_Frame[i] << "/";
		}
	}
	cout << endl;
}
void Init(int* n, int* len, int*& save_Frame, int*& interview_Array)
{
	cout << "请输入 n :";
	cin >> *n;
	save_Frame = new int[*n];
	for (int i = 0; i < *n; i++)
		save_Frame[i] = -999;

	cout << "请输入地址走向的长度：";
	cin >> *len;
	cout << "请输入地址走向:";
	interview_Array = new int[*len];
	for (int i = 0; i < *len; i++)
		cin >> interview_Array[i];
}

/*
* 缺页中断率：
* 假设进程 P 在运行中成功的内存访问次数为 s
* 不成功的访问次数为 F，则缺页中断率为 R = F/(S+F)
*/
double Page_Loss_Rate(int S, int F)
{
	double ans = 1.0 * F / (1.0 * S + 1.0 * F) * 100;
	return ans;
}

int Find_LeastInteviewTime(int sta, int addr, int* interview_Array, int len)
{
	for (int i = sta; i < len; i++)
	{
		if (interview_Array[i] == addr)
		{
			return i - sta;
		}
	}
	return 99999;
}
/*
* 最佳置换算法(OPT)：
* 将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
* 数据结构：数组
*/
void OPT_Agorithm()
{
	cout << "欢迎使用 OPT " << endl;
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len, save_Frame, interview_Array);
	//测试样例： 1 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		addr = interview_Array[iter];
		iter++;
		cout << endl << "第" << iter << "轮：";
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);
			}
			else // 未命中，但有空间，" << "\" << addr << "\" 被装入 
			{
				fail_time++;
				cout << "未命中，" << "\"" << addr << "\" 被装入 \t------->";
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int* least_Time = new int[n];
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					least_Time[i] = Find_LeastInteviewTime(iter, save_Frame[i], interview_Array, len);
					if (least_Time[i] > max_Time)
					{
						max_Time = least_Time[i];
						index = i;
					}
				}
				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
				save_Frame[index] = addr;
				Print_Frame(save_Frame, n);
				delete[] least_Time;
			}
		}
	}
	cout << endl;
	cout << "缺页次数为：" << fail_time << endl;
	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
	delete[] save_Frame;
	delete[] interview_Array;
}

void Update_InHereTime(int* in_HereTime, int n, int ind)
{
	for (int i = 0; i < n; i++)
	{
		in_HereTime[i]++;
	}
	if (ind != -1)
		in_HereTime[ind] = 0;
}
/*
* 先进先出算法(FIFO)：
* 淘汰最先使用内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
* 数据结构：数组
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
*/
void FIFO_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len, save_Frame, interview_Array);

	int* in_HereTime = new int[n];
	for (int i = 0; i < n; i++)
		in_HereTime[i] = 0;		// 初始化都为零

	//测试样例： 2 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		cout << endl << "第" << iter << "轮：";
		addr = interview_Array[iter];
		iter++;
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);
				Update_InHereTime(in_HereTime, cnt, -1);
			}
			else // 未命中，但有空间
			{
				fail_time++;
				cout << "未命中，" << "\"" << addr << "\" 被装入 \t------->";
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				Update_InHereTime(in_HereTime, cnt, cnt);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);
				Update_InHereTime(in_HereTime, n, -1);
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					if (in_HereTime[i] > max_Time)
					{
						max_Time = in_HereTime[i];
						index = i;
					}
				}
				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
				save_Frame[index] = addr;
				Print_Frame(save_Frame, n);
				int ind = Find_Exist(save_Frame, n, addr);
				Update_InHereTime(in_HereTime, n, ind);
			}
		}
	}
	cout << endl;
	cout << "缺页次数为：" << fail_time << endl;
	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
	delete[] save_Frame;
	delete[] interview_Array;
	delete[]  in_HereTime;
	return;
}

int Find_LeastNotUseTime(int end, int addr, int* interview_Array)
{
	for (int i = end - 1; i >= 0; i--)
	{
		if (interview_Array[i] == addr)
		{
			// cout << " i = " << i << endl;
			return end - i;
		}
	}
	return 99999;
}
/*
* 最近最久未使用算法(LRU)：
* 淘汰最近最久未被使用的页面。
* 数据结构：数组
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
*/
void LRU_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len, save_Frame, interview_Array);

	//测试样例： 3 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		addr = interview_Array[iter];
		iter++;
		cout << endl << "第" << iter << "轮：";
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);

			}
			else // 未命中，但有空间
			{
				fail_time++;
				cout << "未命中，" << "\"" << addr << "\" 被装入 \t------->";
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int* Not_UseTime = new int[n];
				int max_Time = 0;
				int index;
				for (int i = 0; i < n; i++)
				{
					Not_UseTime[i] = Find_LeastNotUseTime(iter, save_Frame[i], interview_Array);
					if (Not_UseTime[i] > max_Time)
					{
						max_Time = Not_UseTime[i];
						index = i;
					}
				}
				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
				save_Frame[index] = addr;
				Print_Frame(save_Frame, n);
				delete[] Not_UseTime;
			}
		}
	}
	cout << endl;
	cout << "缺页次数为：" << fail_time << endl;
	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
	delete[] save_Frame;
	delete[] interview_Array;
}

int Find_LeastNotInterviewTime(int n, int* interview_Time)
{
	int min_Time = 99999;
	int ind;
	for (int i = 0; i < n; i++)
	{
		if (interview_Time[i] < min_Time)
		{
			min_Time = interview_Time[i];
			ind = i;
		}
	}
	return ind;
}
/*
* 最不经常使用算法(LFU):
* 即选择最近一段时间内最长时间没有被访问过的页面进行置换
* 数据结构：数组
* 第一行输入参数：n ，代表存储页框数
* 第二行输入参数：a_1、a_2、...、a_n，代表访问地址的走向
* 输出要求：输出内存驻留的页面集合，缺页次数以及缺页率；
*/
void LFU_Agorithm()
{
	int n, len, * save_Frame = NULL, * interview_Array = NULL;
	Init(&n, &len, save_Frame, interview_Array);

	int* interview_Time = new int[n];
	for (int i = 0; i < n; i++)
		interview_Time[i] = 0;

	// 测试样例一：4 3 12 2 3 2 1 5 2 4 5 3 2 5 2
	// 测试样例二：4 3 12 2 3 2 1 2 1 5 4 2 4 4 6
	int addr;
	int cnt = 0;
	int score = 0;
	int fail_time = 0;
	int iter = 0;
	while (iter < len)
	{
		cout << endl << "第" << iter << "轮：";
		addr = interview_Array[iter];
		iter++;
		if (cnt < n)
		{
			if (Find_Exist(save_Frame, cnt, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);
				int ind = Find_Exist(save_Frame, cnt, addr);
				interview_Time[ind]++;
			}
			else // 未命中，但有空间
			{
				fail_time++;
				cout << "未命中，" << "\"" << addr << "\" 被装入 \t------->";
				save_Frame[cnt] = addr;
				Print_Frame(save_Frame, n);
				cnt++;
			}
		}
		else
		{
			if (Find_Exist(save_Frame, n, addr) != -1)
			{
				score++;
				cout << "\"" << addr << "\" 被命中了\t\t------->";
				Print_Frame(save_Frame, n);
				int ind = Find_Exist(save_Frame, n, addr);
				interview_Time[ind]++;
			}
			else // 未命中，但没了空间
			{
				fail_time++;
				int index = Find_LeastNotInterviewTime(n, interview_Time);
				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
				save_Frame[index] = addr;
				interview_Time[index] = 0;
				Print_Frame(save_Frame, n);
			}
		}
	}
	cout << endl;
	cout << "缺页次数为：" << fail_time << endl;
	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
	delete[] save_Frame;
	delete[] interview_Array;
	delete[] interview_Time;
}

七、参考附录

无。
(纯手敲，原创，可能存在未知 Bug，烦请指正…)

⭐️ ⭐️

一支王同学
关注
  • 121
    点赞
  • 踩
  • 602
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
页面置换算法（FIFO，LRU，OPT）c模拟
03-21 4528
/* * memory.c * * Created on: Jun 9, 2010 * Author: WangYun */ #include #define PAGE_NUM 20 #define BLOCK 3 void get_page(int page_seq[]) { int i=PAGE_NUM; printf("Please input %d numb
操作系统—页面置换算法（C++实现）
05-13
页面置换算法: 资源包含三个算法：OPT---最佳置换算法、//FIFO---先进先出、//LRU---最近最久未使用 操作：用户输入物理块数、页面待要访问的个数、每个页面编号，计算出缺页数、置换数、缺页率 语言：C++ 运行环境：Visual Studio 2013/更高版本
C/C++ BEEP Core-开源
05-29
面向连接的异步请求/响应消息的 P2P 应用协议框架（RFC3080、RFC3081）。 允许在一个传输连接上多路复用消息流。 支持二进制和文本消息、TLS、SASL/匿名、SASL/OTP。
计算机操作系统中部分页面置换算法（OPT、LRU、FIFO）的代码实现
最新发布
weixin_74126658的博客
05-24 375
OS中页面置换算法（OPT、LRU、FIFO）的代码实现
操作系统--页面置换算法
qq_56056920的博客
11-27 1605
利用例题讲解FIFO和LRU页面置换算法的原理，并使用JAVA代码进行具体实现
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现算法比较的程序输出，比如：缺页率和页面置换次数等。 3.采用固定分配局部置换，且可以在程序中实现块数重新分配。 具有抖动判断和Belady异常判断机制 根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,置换次数,命中率的结果; 3.进行虚拟存储算法设计分析。
操作系统 三种页面置换算法
qq_43341807的博客
12-05 7721
三种页面置换算法 一、算法描述 1.先进先出（FIFO）置换算法 （1）描述：FIFO算法是最早出现的置换算法。该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 （2）优点：该算法实现简单，只需要把一个进程已调入内存的页面按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。 （3）缺点：该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如：含有全局变量、常用函数、例程等的页面，FIFO算法并不能保证这些页面不被淘汰。 2.最佳（O
用于实现RFC 6238和RFC 4226的OpenBSD的OTP身份验证。-C/C++开发
05-27
login_otp OpenBSD的OTP身份验证类型，以使用身份验证器应用（例如Google Authenticator）登录。 此工具实现RFC 6238（TOTP）和RFC 4226（HOTP）。 安装此程序仅取决于libc，login_otp OTP身份验证类型，OpenBSD才能...
sanjava 页面置换可实现 （FIFO 、OTP、LRU）
07-02
本项目通过Java编程语言实现了三种常见的页面置换算法：FIFO（先进先出）、OTP（最近未使用）和LRU（最近最少使用）。接下来，我们将详细探讨这些算法及其实现。 **FIFO（先进先出）页面置换算法** FIFO是最简单的...
适用于Erlang / OTP的小型，快速，现代HTTP服务器。-C/C++开发
05-26
Cowboy Cowboy是适用于Erlang / OTP的小型，快速，现代化的HTTP服务器。 Goals Cowboy的目标是在一个小的代码库中提供完整的HTTP堆栈。 它针对低延迟和低内存使用进行了优化，部分原因是Cowboy Cowboy是适用于Erlang...
Boot9 / Boot11代码执行。-C/C++开发
05-26
Boot9strap Boot9 / Boot11代码执行。 有关更多详细信息，请参阅此处的演示。 通过SafeB9SInstaller安装。 从SD卡或CTRNAND启动“ boot.firm”。 在启动时按住开始+选择+ X，以转储bootroms Boot9strap Boot9 / Boot...
5种页面置换算法C++实现
06-28
计算并输出下述各种算法在不同内存容量下的命中率。 A. FIFO先进先出的算法 B. LRR最近最少使用算法 C. OPT最佳淘汰算法（先淘汰最不常用的页地址）
最佳置换OPT页面置换算法
02-19
最佳置换OPT页面置换算法的源代码，以及可执行程序。
四种页面置换算法代码
09-06
四种页面置换算法齐全，c++上可以直接运用
嵌入式系统/ARM技术中的基于MCU+DSP嵌入式平台的机接口与引导设计
11-12
本文以MCF5272（ColdFire系列MCU）和ADSP-BF527（Blackfin DSP）为例，详细讨论了如何利用DSP的主机DMA端口（HOSTDP）实现主机引导加载程序以及两者间的通信。 MCF5272是一种32位MCU，拥有第二代ColdFire V2核心，...
操作系统实验：页面置换算法之FIFO和LRU算法的实现c++
123
06-07 1915
页面置换算法模拟程序 目的： 熟悉页面置换算法及其实现，引入计算机系统性能评价方法的概念。 内容： 编制页面置换算法的模拟程序。 要求： (1) 用随机数方法产生页面走向，页面走向长度为L。 (2) 根据页面走向，分别采用FIFO和LRU算法进行页面置换，统计缺页率。 (3) 假定可用内存块和页表长度 (作业的页面数)分别为m和k，初始时，作业页面都不在内存。 随机数产生程序： function random: real: begin Seed: =125.0∗(seed+1.0) Seed: =See
操作系统分页存储以及三种页面置换算法（FIFO，OPT，LRU）
weixin_74237918的博客
11-16 1263
分页存储以及三种页面置换算法（FIFO，OPT，LRU）
虚拟存储管理：C语言实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance
yoyo_hu的博客
03-14 3427
1 实验内容：虚拟存储管理。 编写一个 C程序模拟实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance，并设计输入用例验证结果。 2 程序所涉及到的算法介绍以及相关实现函数 在计算机操作系统使用分页的虚拟内存管理，页面置换算法决定哪些内存页页出，有时也被称为换出，或写入到磁盘上，当一个页面被分配的内存需求。当请求的页面不在内存中（页面错误）并且空闲页面无法用于满足分配时，就会发生页面替换，要么是因为没有页面，要么是因为空闲页
最近最久未使用（LRU）置换算法的C++实现
Yuhan2001的CSDN博客
04-06 7495
操作系统的课程实验，最近最久未使用（LRU）置换算法。
UE4+AirSim
09-13
UE4 AirSim是一个用于无人机驾驶研究的工具，它提供了一个基于Unreal Engine 4(UE4)的模拟环境。为了配置基于UE4的AirSim环境，你可以按照以下步骤进行操作： 1. 首先，你需要克隆AirSim的代码仓库。你可以通过以下命令克隆代码仓库： ``` git clone https://github.com/Microsoft/AirSim.git ``` 2. 接下来，进入AirSim目录。你可以使用以下命令进入目录： ``` cd AirSim ``` 3. 现在，你需要将下载的AirSim插件复制到你的UE4项目的插件目录下。假设你的插件目录是CarGame/Plugins，而你下载的AirSim插件位于D:\002_UE4\AirSim-1.5.0-windows\Unreal\Environments\Blocks\Plugins下。你可以按照以下步骤进行复制： - 打开文件浏览器，导航到D:\002_UE4\AirSim-1.5.0-windows\Unreal\Environments\Blocks\Plugins。 - 复制AirSim文件夹。 - 打开CarGame项目的文件浏览器，导航到CarGame/Plugins。 - 将复制的AirSim文件夹粘贴到Plugins目录下。 通过以上步骤，你就可以成功配置基于UE4的AirSim环境了。如果你还有其他问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一支王同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值