Linux页面置换算法的C语言实现

最新推荐文章于 2023-12-20 20:31:50 发布
最新推荐文章于 2023-12-20 20:31:50 发布
阅读量3.1k 收藏 56
点赞数 9
文章标签： 页面置换算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40406916/article/details/85794423
版权

Linux页面置换算法的C语言实现

	编写算法，实现页面置换算法FIFO、LRU、OPT；针对内存地址引用串，进行页面置换算法进行页面置换。
	其中，算法所需的各种参数由输入产生（手工输入或者随机数产生）；输出内存驻留的页面集合，缺页次数以及缺页率。

#include <stdio.h>
//#include <conio.h>
#include <stdlib.h>
#include <time.h>//随机数
 
#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")   //*表格控制*/

int M; 
int N;  

typedef struct page 
{ 
	int num;  /*记录页面号*/ 
	int time;   /*记录调入内存时间*/        //（lru那用到）
	int index;  //记录调入内存的先后次序   //从1开始（FIFO那用到）
}Page;                   /* 页面逻辑结构，结构为方便算法实现设计*/ 
Page b[10];            /*内存单元数*/  //从0开始

int c[10][150];   /*暂保存内存当前的状态：缓冲区*/ 
int queue[100];       /*记录调入队列*/ 
int K;             /*调入队列计数变量*/ 


/*初始化内存单元、缓冲区*/ 
void Init(Page *b,int c[10][150]) 
{ 
	int i,j; 
	for(i=0;i<M;i++) 
	{ 
		b[i].num=-1; 
		b[i].time=M-i-1; 
		b[i].index=i+1;
	} 
	for(i=0;i<M;i++) 
		for(j=0;j<N;j++) 
			c[i][j]=-1; 
} 

/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/ 
int GetMaxTime(Page *b) 
{
	int i;
	int max=-1; 
	int tag=0; 
	for(i=0;i<M;i++) 
	{ 
		if(b[i].time>max) 
		{ 
			max=b[i].time; 
			tag=i; 
		} 
	} 
	return tag; 
} 

/**int GetMinTime(Page *b) 
{
	int i;
	int min=1000; 
	int tag=0; 
	for(i=0;i<M;i++) 
	{ 
		if(b[i].time<min) 
		{ 
			min=b[i].time; 
			tag=i; 
		} 
	} 
	return tag; 
} **/

/*判断页面是否已在内存中*/ 
int    Equation(int fold,Page *b) 
{ 
	int i; 
	for(i=0;i<M;i++) 
	{ 
		if (fold==b[i].num) 
			return i; 
	} 
	return -1; 
} 

//LRU核心部分     最近最久未使用置换算法
void Lru(int fold,Page *b) 
{ 
	int i; 
	int val; 
	val=Equation(fold,b);   //判断页面是否已在内存中，val代表在内存中的位置
	if (val>=0)       //在内存中
	{ 
		b[val].time=0;   //存在就把那个东西的时间变成0
		for(i=0;i<M;i++) 
			if (i!=val) 
				b[i].time++;  // 其他的时间就要累加
	} 
	else 
	{ 
		queue[++K]=fold;/*记录调入页面*/ 
		val=GetMaxTime(b);    //取得在内存中停留最久的页面,默认状态下为最早调入的页面，val代表在内存中的位置
		b[val].num=fold; 
		b[val].time=0; 
		for(i=0;i<M;i++) 
			if (i!=val) 
				b[i].time++; 
	} 
} 

//FIFO核心部分     先进先出置换算法
void FIFO(int fold,Page *b)
{
	int i; 
	int val; 
	bool flag=false;
	val=Equation(fold,b);   //判断页面是否已在内存中，val代表在内存中的位置

	if (val<0)       //不在内存中 
	{
		queue[++K]=fold;/*记录调入页面*/
		for(i=0;i<M;i++)
		{
			if (b[i].num<0)//如果有空
			{
				b[i].num=fold;
				b[i].index=i+1;
				flag=true;
				break;
			}
		}
		if (flag==false)//如若没有空余则找到最先进去的被淘汰
		{
			for(i=0;i<M;i++) 
			{ 
				if(b[i].index==1) 
				{ 
					val=i; 
				} 
			} 
			b[val].num=fold; 
			b[val].index=M;  
			for(i=0;i<M;i++) 
			{
				if(i!=val) 
			      b[i].index--; //因为有一个被淘汰了，所有其他的Index就需要更新
			}
		}
	}  
}

//Optimal核心部分      最佳置换算法
void Optimal(int a[150],int pos,Page *b)
{
	int i,j; 
	int val;
	int fold=a[pos];
	bool flag=false;

	val=Equation(fold,b);   //判断页面是否已在内存中，val代表在内存中的位置
	
	if (val<0)       //不在内存中 
	{
		queue[++K]=fold;/*记录调入页面*/
		for(i=0;i<M;i++)
		{
			if (b[i].num<0)
			{
				b[i].num=fold;
				flag=true;
				break;
			}
		}
		if (flag==false)
		{
			for(i=0;i<M;i++) 
			{ 
				for(j=pos+1;j<N;j++)
				{
					if (b[i].num!=a[j])
					{ b[i].time= 1000; }//如果后面不需要再用它了把时间改成最大1000
					else
					{
						b[i].time=j;//否则赋值为j
						break;
					}
				}
			} 
			val=GetMaxTime(b);    //取得在内存中停留最久的页面,默认状态下为最早调入的页面，val代表在内存中的位置
			b[val].num=fold; 
		}
	}  
}

void LruMain(int a[150]) 
{  
	int i,j; 
	K=-1; 
	Init(b, c); 
	for(i=0;i<N;i++) //
	{ 
		Lru(a[i],b); 
		c[0][i]=a[i]; 
		/*记录当前的内存单元中的页面*/ 
		for(j=0;j<M;j++) 
			c[j][i]=b[j].num; 
	} 

	/*结果输出*/ 
	printf("\n内存状态为：\n"); 
	Myprintf; 
	for(j=0;j<N;j++) 
		printf("|%2d ",a[j]); 
	printf("|\n");
	
	Myprintf; //#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")   //*表格控制*/ 
	for(i=0;i<N;i++) 
	{   
		for(j=0;j<M;j++) 
		{ 
			if(c[j][i]==-1) 
				printf("%3c ",32); 
			else 
				printf("%3d ",c[j][i]); 
		} 
		printf("\n"); 
	} 

	Myprintf; 
	printf("\n调入队列为:"); 
	for(i=0;i<K+1;i++) 
		printf("%3d",queue[i]); 
	printf("\n缺页次数为：%6d\n缺页率：%16.6f",K+1,(float)(K+1)/N); 
}

void FIFOMain(int a[150]) 
{  
	int i,j; 
	K=-1; 
	Init(b, c); 
	for(i=0;i<N;i++) //
	{ 
		FIFO(a[i],b); 
		c[0][i]=a[i]; 
		/*记录当前的内存单元中的页面*/ 
		for(j=0;j<M;j++) 
			c[j][i]=b[j].num; 
	} 
	/*结果输出*/ 
	printf("\n内存状态为：\n"); 
	Myprintf; 
	for(j=0;j<N;j++) 
		printf("|%2d ",a[j]); 
	printf("|\n");
	
	Myprintf; //#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")   //*表格控制*/ 
	for(i=0;i<N;i++) 
	{   
		for(j=0;j<M;j++) 
		{ 
			if(c[j][i]==-1) 
				printf("%3c ",32);//空格 
			else 
				printf("%3d ",c[j][i]); 
		} 
		printf("\n"); 
	} 
	
	Myprintf; 
	printf("\n调入队列为:"); 
	for(i=0;i<K+1;i++) 
		printf("%3d",queue[i]); 
	printf("\n缺页次数为：%6d\n缺页率：%16.6f",K+1,(float)(K+1)/N); 
}

void OptimalMain(int a[150]) 
{  
	int i,j; 
	K=-1; 
	Init(b, c); 
	for(i=0;i<N;i++) //
	{ 
		Optimal(a,i,b); 
		c[0][i]=a[i]; 
		/*记录当前的内存单元中的页面*/ 
		for(j=0;j<M;j++) 
			c[j][i]=b[j].num; 
	} 
	/*结果输出*/ 
	printf("\n内存状态为：\n"); 
	Myprintf; 
	for(j=0;j<N;j++) 
		printf("|%2d ",a[j]); 
	printf("|\n");
	
	Myprintf; //#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")   //*表格控制*/ 
	for(i=0;i<N;i++) 
	{   
		for(j=0;j<M;j++) 
		{ 
			if(c[j][i]==-1) 
				printf("%3c ",32); 
			else 
				printf("%3d ",c[j][i]); 
		} 
		printf("\n"); 
	} 
	
	Myprintf; 
	printf("\n调入队列为:"); 
	for(i=0;i<K+1;i++) 
		printf("%3d",queue[i]); 
	printf("\n缺页次数为：%6d\n缺页率：%16.6f",K+1,(float)(K+1)/N); 
}

void main()
{
	int a[150];
	int i;
	char s;
	
	printf("请输入物理块数：");
	scanf("%d",&M);

	printf("请输入所要访问的页面数：");
	scanf("%d",&N);
	srand(time(NULL));
	for(i=0;i<N;i++)
	{
		a[i]=rand()%10;     /*随机生成要访问的页面流*/
	}
	printf("所要访问的页面号序列为：");
	for(i=0;i<N;i++)
		printf("%d ",a[i]);
	
	printf("\n");
	printf("页面置换步骤如下：\n");
	while(1)
    {
		printf("\n\n///");
		printf("\nPlease select  1:FIFO算法\n               2:LRU算法\n               3:Optimal算法\n               4:退出\n");
		scanf("%s",&s);
		switch(s)
		{
		     case '1':FIFOMain(a);break;
		     case '2':LruMain(a); break;
			 case '3':OptimalMain(a); break;
		     case '4':exit(0); break;
		}
	}
}
蕾蕾昔
关注
利用C语言实现页面置换算法
braylon_zhang的博客
12-14 1万+
操作系统实验 页面置换算法（FIFO、LRU、OPT） 概念： 1.最佳置换算法（OPT）（理想置换算法）：从主存中移出永远不再需要的页面；如无这样的页面存在，则选择最长时间不需要访问的页面。于所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。 2.先进先出置换算法（FIFO）：是最简单的页面置换算法。这种算法的基本思想是：当需要淘汰一个页面时，总是选择驻留主存时间最长的页面进行淘汰，即先进入主存的页面先淘汰。其理由是：最早调入主存的页面不再被使用的可能
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语言实现页面置换算法
06-15
C 语言实现页面置换算法，一共实现LRU置换算法 随机置换算法 FIFO置换算法 Clock及改进型置换算法五个算法，可以算平均命中率。VC++6.0上可直接运行
页面置换算法C语言实现（FIFO、LRU）
BAI20010904的博客
05-10 1789
网上资源虽多，但是要想把这两个算法的细节理解的透彻，还得是自己写 1.FIFO #include <stdio.h> #include <stdlib.h> #include <time.h> //主要数据结构 #define total_instrucion 15//总的页面访问次数 #define max_block_num 10//最大内存分配 int Access_Series[total_instrucion];//内存访问序列 char Lack[to
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{...
Linux模拟页面置换算法c语言
05-17
以下是一个简单的Linux模拟页面置换算法的C语言实现： ```c #include #include #define MAX_FRAMES 1000 int main() { int num_pages, num_frames, page_faults = 0; int pages[MAX_FRAMES], frames[MAX_...
lfu算法实现c语言_LFU最少使用算法 C语言 已调试
weixin_39695701的博客
12-22 611
#include"stdio.h"int main(int argc,char *argv[]){int i,j,k,k2,t;int n1;int n2;int pageseq[100];int mempages[10][3];int n3;int n4,w;int replacedPage;printf("总页面:");scanf("%d",&n1);if(n1&lt1){pr...
页面置换算法的实现
ProgramChangesWorld的专栏
11-25 2012
前言  操作系统的实验内容，要求用程序实现页面置换算法，下面我就简单说明书上的三种算法和实现过程。  页面置换算法是指在需要调入页面且内存已满时，确定将要换出页面的算法。常用的算法有最佳置换算法(OPT)，先进先出置换算法(FIFO)，最近最久未使用置换算法(LRU)。最佳置换算法   最佳置换算法(OPT)即选择永不使用或者长时间内不再被访问的页面进行置换。这是一种理想化的算法，具有最好的性能
操作系统实验-页面置换算法C语言实现
05-30
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率： 要求设计主界面以灵活选择某算法，且以下算法都要实现 1）先进先出算法（FIFO） 2）最近最久未使用算法（LRU） 3）最佳置换算法（OPT）
存储管理页面置换算法C语言实现
05-17
OPT算法、FIFO算法、LRU算法、LFU算法的具体实现
页面置换六种算法c语言实现
01-02
opt、FIFO、LRU/LFU、简单clock、改进型clock等算法实现页面置换
页面置换算法（Linux下运行）
01-21
设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率。 1) 最佳置换算法（Optimal） 2) 先进先出法（Fisrt In First Out） 3) 最近最久未使用（Least Recently Used） 4) 最不经常使用法（Least Frequently Used） 5) 最近未使用法（No Used Recently） 其中，命中率＝１－页面失效次数／页地址流长度。试对上述算法的性能加以较：页面个数和命中率间的关系；同样情况下的命中率比较。
置换算法C语言实现
12-05
置换算法C语言实现
页面置换算法（C语言版）FIFO和LRU代码
最新发布
m0_70070803的博客
12-20 1231
void LRU(PageTable pagetable[6],int data[10],int block[3]){//最近最少使用页面置换算法。//首先将数据传输到相应的内存块;
Linux虚拟内存和三种页面置换算法
weixin_44164489的博客
10-12 2693
目录虚拟内存、虚拟内存的页、物理内存的页框、页表请页与交换三种页面置换算法1.为什么要有页面置换算法2.页面置换算法的分类 虚拟内存、虚拟内存的页、物理内存的页框、页表 见博客【Linux】Linux的虚拟内存详解（MMU、页表结构）中的虚拟内存、虚拟内存的页、物理内存的页框、页表。 请页与交换 见博客【Linux】Linux的虚拟内存详解（MMU、页表结构）中的请页与交换。 考虑下面情况：在请页成功之后，内存中已没有空闲物理页框了。这时，系统必须启动所谓的 “交换”机制，即调用相应的内核操作函数，在物
页面转换算法实现(C语言)
codeslogan
08-31 1556
5种页面置换算法的简单实现 页面置换算法 OPT 最佳置换算法 缺点：最佳置换算法是一种理想化算法，具有较好的性能，但是实际上无法实现（无法预知一个进程中的若干页面哪一个最长时间不被访问）； 优点：最佳置换算法可以保证获得最低的缺页率，性能最好 void opt() //最佳转换算法，往后查找 { printf("--------------------------------\n"); printf("现在执行的是最佳置换算法opt：\n"); memset(arr, -1, sizeof(a
【操作系统--页面置换算法】C语言详解--大作业版（附代码）
热门推荐
炼丹笔记
12-25 4万+
该实验为作者OS课程大作业，内容若有问题，望指出，多多交流
操作系统实验（五）：c实现几种页面置换算法
le000426的博客
06-14 871
操作系统实验（五）：c实现几种页面置换算法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值