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

最新推荐文章于 2024-05-30 19:52:03 发布
最新推荐文章于 2024-05-30 19:52:03 发布
阅读量5k 收藏 38
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42481964/article/details/90647275
版权

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

16281042 安全1601

一、设计基本信息

1、模拟的虚拟内存的地址为16位，页面大小为1K
2、模拟的物理内存有32K
页面大小等于块的大小为1K，物理地址16位对应程序需要的物理空间为216B，需要216/1K = 64个页面，工作集的大小为 64，维护的物理内存块共32个

二、算法实现

0、程序设计、页面访问序列产生

struct Page
{
	int pagenum;//页号
	int blocknum;//所存储的块号
	int presence = 0;//存在位，初始为0表示不存在
	int modify = 0;//修改位，初始位0，表示未被修改
	int visit = 0;//访问位，初始值未0表示未被访问
};
页面访问序列产生函数

符合局部访问特性的随机生成算法
1、确定虚拟内存的尺寸N，工作集的起始位置p，工作集中包含的页数e，工作集移动率m（每处理m个页面访问则将起始位置p +1），以及一个范围在0和1之间的值t；
2、生成m个取值范围在p和p + e间的随机数，并记录到页面访问序列串中；
3、生成一个随机数r，0 ≤ r ≤ 1；
4、如果r < t，则为p生成一个新值，否则p = (p + 1) mod N；
5、如果想继续加大页面访问序列串的长度，请返回第2步，否则结束。

实现代码：

int product(int b[1000], int N, int p, int e, int m, double t)
{
	int flag = 1;
	int place = 0;
	while (flag)
	{	
		for (int i = 0; i < m; i++,place++)
		{
			b[place] = (abs(rand()) % e) + p;
		}
		double r = (abs(rand()) % 100) / 100;
		if (r < t)
		{
			p = abs(rand());
		}
		else
		{
			p = (p + 1) % N;
		}
		printf("如果继续加大页面访问序列串的长度请输入：1,否则输入：0\n");
		scanf("%d", &flag);
	}
	return place;
}

1、最佳置换算法

特点：性能最好 可操作性差
其所选择的被淘汰页面将是以后永不使用的，或许是在最长（未来）时间内不再被访问的页面
基本思想：选择永不使用或是在最长时间内不再被访问（即距现在最长时间才会被访问）的页面淘汰出内存
具体实现函数：void optimal(int size, Page page[1000], int BLOCK[32])
函数参数：size为维护的页面访问序列的大小，page为具体的页面访问序列，BLOCK为维护的物理块
辅助函数：int find_optimal(int a, int begin, Page page[1000])
函数参数：a为页号，begin为开始在页面访问序列寻找的开始位置，page为页面访问序列
函数功能：在页面访问序列中找到最开始访问指定页面a的位置，返回值为在页面访问序列中的位置，-1为未找到
辅助函数：int find_all(int a, int BLOCK[32])
函数参数：a为页号，BLOCK为维护的物理块
函数功能：在物理块中寻找指定的页面，返回值为是否找到，0为未找到，1为找到

实现代码：

int get_pageplace(int a, Page page[40000], int end)
{
	for (int i = 0; i < end; i++)
	{
		if (page[i].pagenum == a)
			return i;
	}
}

int find_all(int a, int BLOCK[32])
{
	for (int i = 0; i < 32; i++)
	{
		if (a == BLOCK[i])
			return 1;
	}
	return 0;
}

int find_optimal(int a, int begin, Page page[1000])
{
	int i = begin;
	int flag = 1;
	for (i; i < 30000; i++)
	{
		if (page[i].pagenum == a)
			return i;
		else
			flag = 0;
	}
	if (flag == 0)
	{
		return -1;
	}
}

void optimal(int size, Page page[30000], int BLOCK[32])
{
	int num = 0;
	int deletion = 0;
	while (num < size)
	{
		if (find_all(page[num].pagenum, BLOCK))
		{
			num++;
		}
		else
		{
			int tag = 0;
			for (int i = 0; i < 32; i++)
			{
				if (BLOCK[i] == -1)//找到空闲块直接存储
				{
					BLOCK[i] = page[num].pagenum;
					page[num].blocknum = i;
					num++;
					tag = 1;
					i = 32;
				}
			}
			if (tag == 0)//未找到空闲块
			{
				int b = 0;
				int change = -1;//决定替换内容的页位置
				int page_c;//决定替换的页号
				while (b < 32)
				{
					int temp = find_optimal(BLOCK[b], num, page);
					if (temp > change)//不断迭代找到最久未使用的页面号
					{
						change = temp;
						page_c = page[change].pagenum;
					}
					if (temp == -1)
					{
						page_c = BLOCK[b];
						b = 64;//跳出循环，已找到以后不会使用的页面
					}
					b++;
				}
				for (int i = 0; i < 32; i++)//找到对应物理内存中要替换的页
				{
					if (BLOCK[i] == page_c)
					{
						BLOCK[i] = page[num].pagenum;
						page[num].blocknum = i;
					}
				}
				deletion++;
				num++;
			}
		}
	}
	double rate = (double(deletion) / double(size));
	printf("最佳置换算法：*****缺页次数：%d，缺页率：%.3f\n", deletion, rate);
}

2、先进先出置换算法

特点：简单 性能较差
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
基本思想：选择最先进入内存即在内存驻留时间最久的页面换出到外存
具体实现函数：void fifo(int size, Page page[1000], int BLOCK[32])
函数参数：size为维护的页面访问序列的大小，page为具体的页面访问序列，BLOCK为维护的物理块

实现代码：

void fifo(int size, Page page[30000], int BLOCK[32])
{
	int num = 0;
	int deletion = 0;
	while (num < size)
	{
		if (find_all(page[num].pagenum, BLOCK))
		{
			num++;
		}
		else
		{
			int tag = 0;
			for (int i = 0; i < 32; i++)
			{
				if (BLOCK[i] == -1)//找到空闲块直接存储
				{
					BLOCK[i] = page[num].pagenum;
					page[num].blocknum = i;
					num++;
					tag = 1;
					i = 32;
				}
			}
			if (tag == 0)//未找到空闲块
			{
				int b = 0;
				int change = 40000;//决定替换内容的页位置
				while (b < 32)
				{
					for (int j = 0; j < num; j++)
					{
						if (page[j].pagenum == BLOCK[b])
						{
							if (j < change)
								change = j;
						}
					}
					b++;
				}
				for (int i = 0; i < 32; i++)//找到对应物理内存中要替换的页
				{
					if (BLOCK[i] == page[change].pagenum)
					{
						BLOCK[i] = page[num].pagenum;
						page[num].blocknum = i;
					}
				}
				deletion++;
				num++;
			}
		}
	}
	double rate = (double(deletion) / double(size));
	printf("先进先出置换算法：******缺页次数：%d，缺页率：%.3f\n", deletion, rate);
}

3、最近最久未使用置换算法

与最佳置换算法比较，最佳置换算法是从“向后看”的观点出发的，即它是依据以后各页的使用情况进行判断；而LRU算法则是“向前看”的，即根据各页以前的使用情况来判断，而页面过去和未来的走向之间并无必然联系。
基本思想：以“最近的过去”作为“最近的将来”的近似，选择最近一段时间最长时间未被访问的页面淘汰出内存
具体实现函数：void LRU(int size, Page page[1000], int BLOCK[32])
函数参数：size为维护的页面访问序列的大小，page为具体的页面访问序列，BLOCK为维护的物理块

实现代码：

void LRU(int size, Page page[30000], int BLOCK[32])
{
	int num = 0;
	int deletion = 0;
	while (num < size)
	{
		if (find_all(page[num].pagenum, BLOCK))
		{
			num++;
		}
		else
		{
			int tag = 0;
			for (int i = 0; i < 32; i++)
			{
				if (BLOCK[i] == -1)//找到空闲块直接存储
				{
					BLOCK[i] = page[num].pagenum;
					page[num].blocknum = i;
					num++;
					tag = 1;
					i = 32;
				}
			}
			if (tag == 0)//未找到空闲块
			{
				int b = 0;
				int change = 40000;//决定替换内容的页位置
				while (b < 32)
				{
					for (int j = num; j >= 0; j--)//从当前位置向前找最近一次使用的记录
					{
						if (page[j].pagenum == BLOCK[b])
						{
							if (j < change)
								change = j;
							j = -1;//第一次找到跳出循环
						}
					}
					b++;
				}
				for (int i = 0; i < 32; i++)//找到对应物理内存中要替换的页
				{
					if (BLOCK[i] == page[change].pagenum)
					{
						BLOCK[i] = page[num].pagenum;
						page[num].blocknum = i;
					}
				}
				deletion++;
				num++;
			}
		}
	}
	double rate = (double(deletion) / double(size));
	printf("LRU置换算法：*****缺页次数：%d，缺页率：%.3f\n", deletion, rate);
}

4、改进型Clock置换算法

改进型的Clock算法需要综合考虑某一内存页面的访问位和修改位来判断是否置换该页面。在实际编写算法过程中，同样可以用一个等长的整型数组来标识每个内存块的修改状态。访问位A和修改位M可以组成一下四种类型的页面。

1类(A =0, M = 0)：表示该页面最近既未被访问，又未被修改，是最佳淘汰页。

2类(A =0, M = 1)：表示该页面最近未被访问，但已被修改，并不是很好的淘汰页。

3类(A =1, M = 0)：表示该页面最近已被访问，但未被修改，该页有可能再被访问。

4类(A =1, M = 1)：表示该页最近已被访问且被修改，该页可能再被访问。

基本思想：
① 从查寻指针当前位置起扫描内存分页循环队列，选择A=0且M=0的第一个页面淘汰；若未找到，转②
② 开始第二轮扫描，选择A=0且M=1的第一个页面淘汰，同时将经过的所有页面访问位置0；若不能找到，转①

算法性能：与简单Clock算法相比，可减少磁盘的I/O操作次数，但淘汰页的选择可能经历多次扫描，故实现算法自身的开销增大。
具体实现函数：void clock(int size, Page page[1000], int BLOCK[32])
函数参数：size为维护的页面访问序列的大小，page为具体的页面访问序列，BLOCK为维护的物理块
实现代码：

void clock(int size, Page page[30000], int BLOCK[32])
{
	int num = 0;
	int deletion = 0;
	while (num < size)
	{
		if (find_all(page[num].pagenum, BLOCK))//在现有的物理内存中找到页面修改其访问位为1
		{
			page[num].visit = 1;
			num++;
		}
		else
		{
			int tag = 0;
			for (int i = 0; i < 32; i++)
			{
				if (BLOCK[i] == -1)//找到空闲块直接存储
				{
					BLOCK[i] = page[num].pagenum;
					page[num].blocknum = i;
					num++;
					tag = 1;
					i = 32;
				}
			}
			if (tag == 0)//未找到空闲块
			{
				int b = 0;
				int flag = 0;//判断是否找到替换页面，初始值为0表示未找到
				int change = 40000;//决定替换页的物理位置
				while (!flag)//直到找到为止
				{
					for (int i = 0; i < 32 && !flag; i++)
					{
						int place = get_pageplace(BLOCK[i], page, num);
						if (page[place].visit == 0 && page[place].modify == 0)
						{
							if (i < change)//最开始找到的为替换位置
							{
								change = i;
								flag = 1;
							}
						}
					}
					if (flag != 1)
					{
						for (int i = 0; i < 32 && !flag; i++)
						{
							int place2 = get_pageplace(BLOCK[i], page, num);
							if (page[place2].visit == 0 && page[place2].modify == 1)
							{
								page[place2].visit = 0;//将所有访问到的页面访问位都置0
								if (i < change)//最开始找的的为替换位置
								{
									change = i;
									flag = 1;
								}
							}
						}
					}
				}
				BLOCK[change] = page[num].pagenum;//直接在替换位置替换
				deletion++;
				num++;
			}
		}
	}
	double rate = (double(deletion) / double(size));
	printf("改进clock算法：****缺页次数：%d，缺页率：%.3f\n", deletion, rate);
}

5、页面缓冲算法PBA

基本思想：设置一个空闲的物理块链表，把替换的物理块与空闲的物理块交换，如果不存在空闲的物理块则更改物理块中存储的页面内容。
算法性能：建立公共使用的空闲物理块相当于增大所有进程的分配的物理块大小可以提高效率，减少从磁盘读写的次数
实现函数：PBA(int size, Page page[1000], int BLOCK[32], int freeblock[2])
函数参数：size为维护的页面访问序列的大小，page为具体的页面访问序列，BLOCK为维护的物理块，freeblock为设置的共用空闲物理块
实现代码：

void PBA(int size, Page page[30000], int BLOCK[32], int freeblock[2])//freeblock为空闲块，用于替换换下来的块
{
	freeblock[0] = -1;
	freeblock[1] = -1;//初始化为-1表示没有存储内容
	int num = 0;
	int deletion = 0;
	while (num < size)
	{
		if (find_all(page[num].pagenum, BLOCK))
		{
			num++;
		}
		else
		{
			int tag = 0;
			for (int i = 0; i < 32; i++)
			{
				if (BLOCK[i] == -1)//找到空闲块直接存储
				{
					BLOCK[i] = page[num].pagenum;
					page[num].blocknum = i;
					tag = 1;
					i = 32;
					num++;
				}
			}
			if (tag == 0)//未找到空闲块
			{
				int b = 0;
				int change = 40000;//决定替换内容的页位置
				while (b < 32)
				{
					for (int j = 0; j < num; j++)
					{
						if (page[j].pagenum == BLOCK[b])
						{
							if (j < change)
								change = j;
						}
					}
					b++;
				}
				deletion++;
				num++;
				for (int i = 0; i < 32; i++)//找到对应物理内存中要替换的页
				{
					int exit = 0;
					if (BLOCK[i] == page[change].pagenum)
					{
						for (int j = 0; j < 2; j++)//从存储置换下来页面的空闲块内寻找是否存在要置换的页面
						{
							if (freeblock[j] == page[change].pagenum)//如果存在，直接置换块，将换下来的块加入空闲块的队列
							{
								freeblock[j] = page[change].pagenum;
								BLOCK[i] = freeblock[j];
								exit = 1;
							}
						}
						if (exit == 0);
						{
							for (int j = 0; j < 2; j++)
							{
								if (freeblock[j] == -1)
								{
									exit = 1;
									freeblock[j] = BLOCK[i];
									BLOCK[i] = page[num].pagenum;
									page[num].blocknum = i;
								}
							}
						}
						if (exit == 0)
						{
							freeblock[0] = BLOCK[i];
							BLOCK[i] = page[num].pagenum;
							page[num].blocknum = i;
						}
					}
				}
			}
		}
	}
	double rate = (double(deletion) / double(size));
	printf("PBA算法：****缺页次数：%d，缺页率：%.3f\n", deletion, rate);
}

3、运行结果

在这里插入图片描述

4、实验感想

本次的实验还是比较简单的，但是PBA算法的是新啊还是废了点力气因为最开始没有搞清楚算法的基本原理，等清楚原理之后还是很简单的。

github地址

https://github.com/LiXuzeng/2019_OS_LXZ/tree/master/16281042_李许增_实验四

Lixuzeng
关注
  • 2
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
操作系统实验四：页面置换算法 实验报告
Invictus的博客
05-28 4万+
1、实验目的 设计和实现最佳置换算法、先进先出置换算法、最近最久未使用置换算法、页面缓冲置换算法；通过页面访问序列随机发生器实现对上述算法的测试及性能比较。 2、页面置换算法背景知识 （1） 请求分页虚拟内存管理 请求分页虚拟内存管理是建立在基本分页基础上的，为了能支持虚拟存储器功能，而增加了请求调页功能和置换功能。 （2） 工作集 多数程序都显示出高度的局部性，也就是说，在一个时间段内，一组页面...
操作系统实验：页面置换算法
qq_45668081的博客
11-27 2335
实验目的： 通过模拟实现三种内存页面置换算法，使学生进一步掌握页面置换的方法；对操作系统中虚拟存储器的管理有一个实践上的认识。 实验内容： 1、在Linux环境下，使用C/C++语言，编写程序模拟实现FIFO和LRU页面置换算法。 2、输入 （1）分配的物理块数 （2）访问的页面号序列 3、输出 （1）页面置换过程 （2）缺页中断次数和缺页率 测试数据： 物理块数：3 模拟序列（-1结束）：7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1 -1 FIFO用队列模拟物理块；LR
操作系统实验四：页面置换算法
lllzzzhhh2589的记录
05-28 1407
操作系统实验四：页面置换算法 代码地址点这里 1.生成随机访问序列 确定虚拟内存的尺寸N（初始设置为3，可修改），工作集的起始位置p，工作集中包含的页数e，工作集移动率m（每处理m个页面访问则将起始位置p +1），以及一个范围在0和1之间的值t； 生成m个取值范围在p和p + e间的随机数，并记录到页面访问序列串中； 生成一个随机数r，0 ≤ r ≤ 1； 如果r < t，则为p生成一个新值...
Python 页面置换算法
youyouxiong的博客
05-30 331
在操作系统中，页面置换算法是用来决定哪些页面应该被加载到物理内存中，哪些应该被置换出去的策略。这些算法通常用于处理当物理内存不足以容纳当前所有活跃进程的所有页面时的情况。以下是一些常见的页面置换算法，以及如何在Python中实现它们的基本思路。
操作系统 | 实验五 页面置换算法
猫天意的博客
05-31 1万+
（1）加深对页面置换算法的理解。 （2）掌握几种页面置换算法的实现方法。 （3）通过实验比较各种置换算法的优劣。
计算机操作系统实验：页面置换算法的实现
m0_72471315的博客
05-05 1万+
本实验的目的是通过编程模拟不同的页面置换算法，比较它们的缺页率和命中率，加深对操作系统内存管理的理解。本实验采用C语言编写，实现了最佳置换算法（OPT）、先进先出置换算法（FIFO）和最近最久未使用算法（LRU）。实验中，页面号引用串从文本文件中读取，输出每次访问页面时内存中的页面情况，以及最终的缺页次数、缺页率和命中率。本文档将介绍实验的设计思路、流程图、代码和运行结果。
操作系统：实验四 页面置换算法
顾道长生的科研笔记
11-15 3389
一. 实验目的： 1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。熟悉虚存管理的各种页面淘汰算法 2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。 二 . 实验指导： 设计一个请求页式存储管理方案。并编写模拟程序实现之。流程图见下图。 产生一个需要访问的指令地址流。它是一系列需要访问的指令的地址。为不失一般性，你可以适当地（用人工指定地方法或用随机数产生器）...
计算机操作系统实验之页面置换算法（C语言）
热门推荐
小姚的博客
12-08 4万+
在进程运行过程中，如果它需要访问的页面不在内存，需要把它调入内存，但是内存已满时，需要把内存中的某页数据送到磁盘的对换区中。而选择哪个页面，则由固定的算法来决定，称为页面置换算法
操作系统实验：页面置换算法——FIFO、LRU 代码实现
zhashuang的博客
11-02 5493
通过FIFO、LRU算法实现操作系统页面置换。
操作系统实验四：页面置换实验
weixin_43826712的博客
05-28 1950
页面置换实验
操作系统实验四：页面置换算法实验报告.pdf
12-22
操作系统实验四：页面置换算法实验报告 页面置换算法是操作系统中的一种关键机制，它可以有效地提高系统的性能和效率。在本实验报告中，我们将对页面置换算法进行实验和研究，并对其性能进行比较。 pages ...
操作系统实验：页面置换算法的模拟实现及命中率对比.rar
06-28
本资源使用Java实现了页面置换算法OPT、...该资源的文字版信息请访问博客《操作系统实验：页面置换算法的模拟实现及命中率对比（学习笔记）》（https://blog.csdn.net/weixin_40589192/article/details/106997447）。
操作系统实验三：页面置换算法.rar
06-09
总的来说，这个实验旨在让学生深入了解操作系统中内存管理和页面置换算法的原理，并通过编程实践来提升对这些概念的理解。通过比较不同算法的性能，可以更好地理解它们的优劣，并为实际操作系统设计提供理论基础。
《操作系统》实验五：页面置换算法模拟.pdf
09-30
《操作系统》实验五：页面置换算法模拟.pdf
操作系统实验三页面置换算法实验报告.docx
12-22
操作系统实验三页面置换算法实验报告 该实验报告主要介绍了操作系统中的页面置换算法实验，涵盖了 FIFO、Optimal 和 LRU 等三种常见的页面置换算法。实验报告中还提供了实验源码，展示了如何使用 C 语言实现这些...
基于Springboot和Vue的图书借还管理系统源码 图书借还管理系统代码（高分毕设）
最新发布
07-28
图书借还管理系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
C语言内存管理：静态与动态分配的较量
07-28
C语言是一种通用的编程语言，由丹尼斯·里奇（Dennis Ritchie）在20世纪70年代早期于美国电话电报公司（AT&T）的贝尔实验室开发。C语言以其高效性、灵活性和可移植性而闻名，它是一种过程式编程语言，提供了对底层硬件的直接访问能力。 C语言的特点包括： 1. **简洁高效**：C语言的语法简洁，执行效率高，适合编写系统软件。 2. **接近硬件**：C语言提供了对内存地址和位操作的直接控制，使其非常适合硬件级编程。 3. **可移植性**：C语言编写的程序可以在不同的操作系统和硬件平台上编译和运行，具有很好的可移植性。 4. **丰富的库支持**：C语言拥有大量的标准库，如标准输入输出库（stdio.h）、数学库（math.h）等。 5. **结构化编程**：C语言支持结构化编程，允许使用循环、条件判断和函数等控制结构。 6. **指针**：C语言的指针功能强大，可以操作内存地址，实现复杂的数据结构和算法。 7. **编译型语言**：C语言是一种编译型语言，源代码需要通过编译器转换成机器码才能运行。 C语言广泛应用于操作系统（如Unix和Linux）、嵌入式系统、高性能
通讯协议规范-命令包格式
07-28
提供一份通讯协议规范，包含命令包、格式等，在上下位机调试的时候可参考该文档，制定对应的通讯协议。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值