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

这篇具有很好参考价值的文章主要介绍了操作系统 | 实验五 页面置换算法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、实验目的

(1)加深对页面置换算法的理解。
(2)掌握几种页面置换算法的实现方法。
(3)通过实验比较各种置换算法的优劣。

二、实验内容

参考用C语言实现的先进先出算法FIFO的代码,实现最佳置换算法OPT和最近最少使用算法LRU。使得随机给出一个页面执行序列,计算不同置换算法的缺页数,缺页率和命中率。

三、数据结构

typedef struct item
{
int num; //页号
int time; //等待时间,LRU算法会用到这个属性
}Pro;
全局变量:
int pageNum = 0; //系统分配给作业的主存中的页面数
int memoryNum = 0; //可用内存页面数

1、函数以及功能

函数名称 功能描述
void print(Pro* page1) 打印当前主存中的页面
int Search(int num1, Pro* memory1) 页面集memory1中查找num1,如果找到,返回其在memory1中的下标,否则返回-1
int Max(Pro* memory1) 选择哪种方法进行
void DisplayInfo() 信息展示
int main() main函数

四、程序流程图

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

五、实验代码

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

#define SYSINFO "页面置换算法" // 系统信息 
#define AUTHOR "Yrani - 依然" //作者 

/**
* 	@Author: Yrani - 依然
* 	@Date: 2022-05-2 20:20:17
* 	@LastEditTime: 2022-05-03 15:55:00
* 	@keywords: 页面置换算法、LRU、OPT、FIFO 
**/

typedef struct item
{
	int num;        //页号
	int time;        //等待时间,LRU算法会用到这个属性
} Pro;

int pageNum = 0;        //系统分配给作业的主存中的页面数
int memoryNum = 0;        //可用内存页面数

void PrintCurrentPage(Pro* page1);        //打印当前主存中的页面
int Search(int num1, Pro* memory1);    //在页面集memory1中查找num1,如果找到,返回其在memory1中的下标,否则返回-1
int Max(Pro* memory1);
int Optimal(int num,int tag,Pro* memory1,Pro* page1);

//信息展示
void DisplayInfo()
{
	printf("★★★★★★★★★★★★★★★★★\n");
	printf("★☆☆☆☆%s☆☆☆☆☆☆★\n",SYSINFO);
	printf("☆☆☆☆☆@Author:%s☆☆☆☆★\n",AUTHOR);
	printf("★★★★★★★★★★★★★★★★★\n");
}

void PrintCurrentPage(Pro *memory1)//打印当前的页面
{
	int j = 0;

	for(j = 0; j < memoryNum; j++)
		printf("      %d     ", memory1[j].num);
	printf("\n");
}

//在页面集memory1中查找num1,如果找到,返回其在memory1中的下标,否则返回-1
int  Search(int num1,Pro *memory1)
{
	int j;

	for(j=0; j < memoryNum; j++)
	{
		if(num1==memory1[j].num)
			return j;
	}
	return -1;
}

int Max(Pro *memory1)
{
	int max = 0;

	for(int k=1; k < memoryNum; k++)
	{
		if(memory1[k].time > memory1[max].time)
			max = k;
	}
	
	return max;
}

int Optimal(int num, int tag, Pro *memory1, Pro *page1)
{
	int k, j, min[100], min_k;
	for(k = 0; k < memoryNum; k++)
	{
		min[k] = 500;
	}
	
	for(k = 0; k < memoryNum; k++)
	{
		j = tag;
		do
		{

			j++;
			if(j>20)
				break;
		}
		while(page1[j].num != memory1[k].num);
		if(j < min[k])
		{

			min[k] = j;
		}
	}
	int max = 0;
	for(int t = 1; t < memoryNum; t++)
	{
		if(min[t] > min[max])
			max = t;
	}
	return max;
}

int main()
{
	int i = 0;
	int curmemory = 0;        //调入主存中的页面个数
	int missNum = 0;        //缺页次数
	float missRate = 0.0;        //缺页率
	char c;                //得到用户的输入字符,来选择相应的置换算法

	Pro* page = NULL;            //作业页面集
	Pro* memory = NULL;        //内存页面集
	
	DisplayInfo(); 
	
	printf("输入系统分配给作业的主存中的页面数:");
	scanf("%d", &pageNum);
	printf("输入内存页面数:");
	scanf("%d", &memoryNum);

	page = (Pro*)malloc(sizeof(Pro)*pageNum);
	memory = (Pro*)malloc(sizeof(Pro)*memoryNum);

	for(i = 0; i < pageNum; i++)
	{
		printf("第 %d 个页面号为:", i);
		scanf("%d", &page[i].num);
		page[i].time=0;            //等待时间开始默认为0
	}

	do
	{
		for(i = 0; i < memoryNum; i++)      //初始化内存中页面
		{
			memory[i].num = -1;                //页面为空用-1表示
			memory[i].time = -1;                //
		}

		printf("*****f:FIFO页面置换*****\n");
		printf("*****o:OPT页面置换*****\n");
		printf("*****l:LRU页面置换*****\n");
		printf("*****请选择操作类型(f,o,l),按其它键结束******\n");
		fflush(stdin);
		scanf("%c", &c);

		i = 0;
		curmemory = 0;

		if(c == 'f')            //FIFO页面置换
		{
			missNum = 0;

			printf("FIFO页面置换情况:   \n");
			printf("置换的页面号  ");
			for(i = 0; i < memoryNum; i++)
			{
				printf("物理块号%d  ",i+1);
			}
			printf("\n===============================================================\n");
			for(i=0; i<pageNum; i++)
			{
				if(Search(page[i].num,memory) < 0)//若在主存中没有找到该页面
				{
					missNum ++;
					if(memory[curmemory].num > -1)
					{
						printf("   %d      ", memory[curmemory].num);
					} 
					else
					{
						printf("          ");
					}
					memory[curmemory].num = page[i].num;
					PrintCurrentPage(memory);
					curmemory = (curmemory + 1) % memoryNum;
					printf("===============================================================\n");
				}
			}//end for
			missRate = (float)missNum / pageNum;
			printf("缺页次数:%d   缺页率:  %f\n", missNum, missRate);

		}//end if

		if(c == 'o')            //OPT页面置换
		{
			missNum = 0;

			printf("OPT页面置换情况:   \n");
			printf("置换的页面号  ");
			for(i = 0;  i< memoryNum; i++)
			{
				printf("物理块号%d  ", i+1);
			}
			printf("\n===============================================================\n");
			for(i = 0; i < pageNum; i++)
			{
				if(Search(page[i].num,memory) < 0)//若在主存中没有找到该页面
				{
					if(i < memoryNum)
						curmemory = i;
					else
						curmemory = Optimal(page[i].num,i,memory,page);
					missNum ++;
					if(memory[curmemory].num > -1)
					{
						printf("   %d      ",memory[curmemory].num);
					}
					else
					{
						printf("          ");
					}
					memory[curmemory].num = page[i].num;
					PrintCurrentPage(memory);
					curmemory = (curmemory+1) % memoryNum;
					printf("===============================================================\n");
				}
			}//end for
			missRate = (float)missNum / pageNum;
			printf("缺页次数:%d   缺页率:  %.2f%%\n", missNum, missRate*100);


		}//end if

		if(c=='l')            //LRU页面置换
		{
			missNum = 0;

			printf("LRU页面置换情况:   \n");
			printf("置换的页面号  ");
			for(i = 0; i < memoryNum; i++)
			{
				printf("物理块号%d  ", i+1);
			}
			printf("\n===============================================================\n");
			for(i =0; i < pageNum; i++)
			{
				for(int j=0; j<memoryNum; j++)
				{
					if(memory[j].num>=0)
						memory[j].time++;
				}
				if(Search(page[i].num,memory)<0)//若在主存中没有找到该页面
				{
					missNum ++;
					//    Printf("%d \n",curmemory);
					if(i<3)
						curmemory = i;
					else
						curmemory = Max(memory);
					if(memory[curmemory].num>-1)
					{
						printf("   %d      ",memory[curmemory].num);
					}
					else
					{
						printf("          ");
					}
					memory[curmemory].num=page[i].num;
					memory[curmemory].time = 0;
					PrintCurrentPage(memory);
					curmemory = (curmemory+1)%memoryNum;
					printf("===============================================================\n");
				}
				else
				{
					curmemory = Search(page[i].num,memory);
					memory[curmemory].time=0;
					curmemory = (curmemory+1)%memoryNum;
				}

			}//end for
			missRate = (float)missNum/pageNum;
			printf("缺页次数:%d   缺页率:  %.2f%%\n", missNum, missRate*100);



		}//end if

	}while(c=='f'||c=='l'||c=='o');
	
	return 0;
}

六、实验结果

系统信息展示
操作系统 | 实验五 页面置换算法

输入页面序列数
操作系统 | 实验五 页面置换算法

输入内存页面数
操作系统 | 实验五 页面置换算法

输入20个页面号
操作系统 | 实验五 页面置换算法

首先选择FIFO算法
操作系统 | 实验五 页面置换算法

OPT页面置换算法
操作系统 | 实验五 页面置换算法

LRU页面置换算法
操作系统 | 实验五 页面置换算法

按其他键退出即可
操作系统 | 实验五 页面置换算法

七、实验体会总结

总结与体会:文章来源地址https://www.toymoban.com/news/detail-442025.html

  1. 通过本次实验加深了我对页面置换算法的理解,本次实验中的页面置换算法有
    FIFO(先进先出置换算法)、LRU(最近最少使用页面置换算法)、OPT(最佳置换算法)。
  2. FIFO算法的核心思想是置换最先调入内存的页面,即置换在内存中驻留时间最久的页面。按照进入内存的先后次序排列成队列,从队尾进入,从队首删除。但是该算法会淘汰经常访问的页面,不适应进程实际运行的规律,目前已经很少使用。
  3. LRU算法的核心思想是置换最近一段时间以来最长时间未访问过的页面。根据程序局部性原理,刚被访问的页面,可能马上又要被访问;而较长时间内没有被访问的页面,可能最近不会被访问。LRU算法普偏地适用于各种类型的程序,但是系统要时时刻刻对各页的访问历史情况加以记录和更新,开销太大,因此LRU算法必须要有硬件的支持。
  4. OPT算法的核心思想是置换以后不再被访问,或者在将来最迟才回被访问的页面,缺页中断率最低。缺点:该算法需要依据以后各业的使用情况,而当一个进程还未运行完成是,很难估计哪一个页面是以后不再使用或在最长时间以后才会用到的页面。
  5. 这三种算法对比:OPT > LRU > FIFO 但是OPT算法是不能实现的,但该算法仍然有意义,可以作为其他算法优劣的一个标准。
  6. 此次实验难度相较于前面几次难度较大,代码较难调试,还是需要多加思考和练习。

到了这里,关于操作系统 | 实验五 页面置换算法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 计算机操作系统——页面置换算法

    声明 :本篇博客参考书籍《计算机操作系统》(西安电子科技大学出版社) 首先说说影响页面换进换出的效率的几个因素: (1)页面置换算法。该因素是影响页面换进换出效率的重要因素。一个好的页面置换算法可以使进程在运行过程中具有较低的缺页率,从而减少页面换

    2024年02月07日
    浏览(64)
  • 操作系统常见的十种页面置换算法

    OS常见页面置换算法整理 在地址映射过程中,若在页面中发现所要访问的页面不在内存中,则产生缺页中断。当发生缺页中断时,如果操作系统内存中没有空闲页面,则操作系统必须在内存选择一个页面将其移出内存,以便为即将调入的页面让出空间。而用来选择淘汰哪一页

    2024年02月02日
    浏览(46)
  • 【操作系统】抖动、缺页中断率、页面置换算法

    对于进程P的一个长度为A的页面访问序列,如果进程P在运行中发生缺页中断的次数为F,则f = F/A称为缺页中断率。 1、进程分得的主存页框数:页框数多则缺页中断率低,页框数少则缺页中断率高。 2、页面大小:页面大则缺页中断率低,页面小则缺页中断率高。 3、页面替换

    2024年01月20日
    浏览(51)
  • 【操作系统】虚拟内存相关&分段分页&页面置换算法

    【进程地址空间=虚拟地址空间=C/C++程序地址空间就是那个4G的空间】 虚拟内存是操作系统内核为了对进程地址空间进行管理,而设计的一个逻辑意义上的内存空间概念。在程序运行过程中,虚拟内存中需要被访问的部分会被映射到物理内存空间中, CPU 通过将虚拟地址翻译成

    2024年02月12日
    浏览(38)
  • 页面置换算法模拟实现-操作系统课程设计基于Java

    存储管理的主要功能之一是合理的分配空间,请求页式存储管理是一种常用的虚拟存储管理技术。在地址映射过程中,若在页表中发现所要访问的页面不在内存,则产生中断,当发生中断时,系统必须在内存选择一个页面移出内存,调用页面置换算法,以便为调入新的页面让

    2024年02月07日
    浏览(41)
  • 【操作系统】FIFO先进先出页面置换算法(C语言实现)

    FIFO页面置换算法,计算缺页率,文末附代码,及例题解析 1、内容         在地址映射过程中,若在页面中发现所要访问的页面不在内存中,则产生缺页中断。当发生缺页中断时,如果操作系统内存中没有空闲页面,则操作系统必须在内存选择一个页面将其移出内存,以便为

    2024年02月11日
    浏览(36)
  • 操作系统-请求页式存储管理中常用页面置换算法模拟

    (1)先进先出调度算法(FIFO) 先进先出调度算法根据页面进入内存的时间先后选择淘汰页面,先进入内存的页面先淘汰,后进入内存的后淘汰。本算法实现时需要将页面按进入内存的时间先后组成一个队列,每次调度队首页面予以淘汰。 (2)最近最少调度算法(LRU) 先进

    2024年02月06日
    浏览(45)
  • 【操作系统--页面置换算法】C语言详解--大作业版(附代码)

    1设计和实现FIFO,LRU,OPT和CLOCK算法 2设计和实现一个完整的可供选择不同算法的程序 3通过页面访问序列随机发生器实现对上述算法的测试及性能比较 4领略页面置换背后的资源调配思想,并将其运用到其他的操作系统的知识,以及运用到生活中的资源调配策略以及解决措施 5理

    2024年02月06日
    浏览(40)
  • 【操作系统笔记04】操作系统之内存管理方式(分页、分段、段页式)、虚拟存储技术、页面置换算法

    这篇文章,主要介绍操作系统之内存管理方式(分页、分段、段页式)、虚拟存储技术、页面置换算法。 目录 一、操作系统 1.1、基地址变换机构 1.2、具有快表的地址变换机构

    2023年04月21日
    浏览(41)
  • 【操作系统】几种基本页面置换算法的基本思想和流程图

      在地址映射过程中,若在页面中发现所要访问的页面不在内存中,则产生缺页中断。当发生缺页中断时,如果操作系统内存中没有空闲页面,则操作系统必须在内存选择一个页面将其移出内存,以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换

    2024年02月16日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包