最佳算法置换算法

‘壹’ 最佳置换算法怎么算的

算法是未来最远的数据置换出去，由于未来不可预测，所有最佳算法是理论值，实际不可实现，研究它是为了让实际其他的算法和它作比较并判断其性能这个串最佳是要置换8次，再没有任何算法小于8次了7 0 12 0 12 0 32 4 32 4 12 5 12 0 13 0 1

‘贰’ 关于最佳置换算法

表格中的“缺页否”是说读取当前页面时是否需要向内存中读入新的物理页。比如对于第一个需要读取的页面4，本来内存中没有存储这个页面，因此出现一次缺页，但将页面4的内容读入物理页0。一共读取了12个页面，缺页次数为6，因此缺页率是6/12。

‘叁’ 最佳置换算法opt

1 4 6 5 3 4 5 2 5 4 3 5 1 2 4 1 1 1 1 5 5 5 5 2 2 2 2 2 1 1 1 1 u 4 4 4 3 3 3 3 5 5 5 5 5 2 2 2 u u 6 6 6 4 4 4 4 4 3 3 3 3 4 4 * * * * * * u * * u * * * * * u 星表示发生缺页中断 可见本过程有13次缺页中断 (共16次) u表示空格

不好意思...

‘肆’ OPT页面置换算法最优性证明。

1常见的置换算法

1．最佳置换算法（OPT）（理想置换算法）：所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。2．先进先出置换算法（FIFO）：优先淘汰最早进入的页面，亦即在内存中驻留时间最久的页面。3．最近最久未使用（LRU）算法：选择最近最长时间未访问过的页面予以淘汰。4．Clock置换算法（LRU算法的近似实现）：给每一帧关联一个附加位，称为使用位。5．最少使用（LFU）置换算法6．工作集算法7 . 工作集时钟算法8. 老化算法（非常类似LRU的有效算法）9. NRU(最近未使用）算法10. 第二次机会算法2操作系统页面置换算法代码#include <stdio.h>^[1]#include <stdlib.h>#include <unistd.h> #define TRUE 1#define FALSE 0#define INVALID -1#define NUL 0#define total_instruction 320 /*指令流长*/#define total_vp 32 /*虚页长*/#define clear_period 50 /*清零周期*/typedef struct{ /*页面结构*/int pn,pfn,counter,time;}pl_type;pl_type pl[total_vp]; /*页面结构数组*/struct pfc_struct{ /*页面控制结构*/int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;int diseffect,a[total_instruction];int page[total_instruction], offset[total_instruction];void initialize(int);void FIFO(int);void LRU(int);void NUR(int);int main(){int S,i;srand((int)getpid());S=(int)rand()%390;for(i=0;i<total_instruction;i+=1) /*产生指令队列*/{a[i]=S; /*任选一指令访问点*/a[i+1]=a[i]+1; /*顺序执行一条指令*/a[i+2]=(int)rand()%390; /*执行前地址指令m’*/a[i+3]=a[i+2]+1; /*执行后地址指令*/S=(int)rand()%390;}for(i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/{page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++) /*用户内存工作区从4个页面到32个页面*/{printf("%2d page frames",i);FIFO(i);LRU(i);NUR(i);printf(" ");}return 0;}void FIFO(int total_pf) /*FIFO(First in First out)ALGORITHM*//*用户进程的内存页面数*/{int i;pfc_type *p, *t;initialize(total_pf); /*初始化相关页面控制用数据结构*/busypf_head=busypf_tail=NUL; /*忙页面队列头，对列尾链接*/for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect+=1; /*失效次数*/if(freepf_head==NUL) /*无空闲页面*/{p=busypf_head->next;pl[busypf_head->pn].pfn=INVALID; /*释放忙页面队列中的第一个页面*/freepf_head=busypf_head;freepf_head->next=NUL;busypf_head=p;}p=freepf_head->next; /*按方式调新页面入内存页面*/freepf_head->next=NUL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NUL)busypf_head=busypf_tail=freepf_head;else{busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%6.4F",1-(float)diseffect/320);}void LRU(int total_pf){int min,minj,i,j,present_time;initialize(total_pf);present_time=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect++;if(freepf_head==NUL) /*无空闲页面*/{min=32767;for(j=0;j<total_vp;j++)if(min>pl[j].time&&pl[j].pfn!=INVALID){min=pl[j].time;minj=j;}freepf_head=&pfc[pl[minj].pfn];pl[minj].pfn=INVALID;pl[minj].time=-1;freepf_head->next=NUL;}pl[page[i]].pfn=freepf_head->pfn;pl[page[i]].time=present_time;freepf_head=freepf_head->next;}elsepl[page[i]].time=present_time;present_time++;}printf("LRU:%6.4f",1-(float)diseffect/320);}void NUR(int total_pf){int i,j,dp,cont_flag,old_dp;pfc_type *t;initialize(total_pf);dp=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect++;if(freepf_head==NUL) /*无空闲页面*/{cont_flag=TRUE;old_dp=dp;while(cont_flag)if(pl[dp].counter==0&&pl[dp].pfn!=INVALID)cont_flag=FALSE;else{dp++;if(dp==total_vp)dp=0;if(dp==old_dp)for(j=0;j<total_vp;j++)pl[j].counter=0;}freepf_head=&pfc[pl[dp].pfn];pl[dp].pfn=INVALID;freepf_head->next=NUL;}pl[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}elsepl[page[i]].counter=1;if(i%clear_period==0)for(j=0;j<total_vp;j++)pl[j].counter=0;}printf("NUR:%6.4f",1-(float)diseffect/320);}void initialize(int total_pf) /*初始化相关数据结构*//*用户进程的内存页面数*/{int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; /*置页面控制结构中的页号，页面为空*/pl[i].counter=0;pl[i].time=-1; /*页面控制结构中的访问次数为0，时间为-1*/}for(i=1;i<total_pf;i++){pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;/*建立pfc[i-1]和pfc[i]之间的连接*/}pfc[total_pf-1].next=NUL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; /*页面队列的头指针为pfc[0]*/}/*说明：本程序在Linux的gcc下和c-free下编译运行通过*/【http://wenku..com/link?url=o_】
不知道能不能打开-是复制的 但也辛苦半天 忘采纳~

‘伍’ 请分别给出三种不同的页面置换算法,并简要说明他们的优缺点

[fifo.rar]
-
操作系统中内存页面的先进先出的替换算法fifo
[先进先出页面算法程序.rar]
-
分别实现最佳置换算法(optimal)、先进先出(fifo)页面置换算法和最近最久未使用（LRU）置换算法，并给出各算法缺页次数和缺页率。
[0022.rar]
-
模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断
[Change.rar]
-
用java实现操作系统的页面置换
其中包括
最佳置换算法(Optimal)、先进先出算法（First-in,
First-out）
、最近最久不用的页面置换算法（LeastRecently
Used
Replacement）三种算法的实现
[M_Management.rar]
-
操作系统中内存管理页面置换算法的模拟程序，采用的是LRU置换算法
[detail_of_44b0x_TCPIP.rar]
-
TCPIP
程序包加载到44b0x
的ADS1.2工程文件的说明书。说名了加载过程的细节和如何处理演示程序和代码。演示代码已经上传，大家可以搜索
[.rar]
-
java操作系统页面置换算法：
（1）进先出的算法（fifo）
（2）最近最少使用的算法（LRU）
（3）最佳淘汰算法(OPT)
（4）最少访问页面算法(LFU)
（注：由本人改成改进型Clock算法）
（5）最近最不经常使用算法(NUR)

‘陆’ 最佳页面置换算法的算法描述

当产生缺页中断时，利用相应的淘汰页面的算法选择需要淘汰的页面。
页面置换算法在淘汰页面时的算法：
输入：页面号引用串P1,P2...Pn；
输出：淘汰页面Pt
实现：
1、如果页框中的某个页面P以后永不使用，则该页面为淘汰页面Pt。
2、如果每个P都会再次被访问，那么其中最长未来时间内不再被访问的页面为淘汰页面Pt。

‘柒’ 最佳页面置换算法的举例

假定系统为耨进程分配的物理块数为3，访问以下页面：4,2,96,2,6,9,4,9,2.采用最佳置换算法时的置换图。

‘捌’ 操作系统最佳置换算法程序，不知道哪里有错误，求帮忙看下

/*
最优置换算法（OPT）是指，其所选择的被淘汰页面，将是以后永不使用的，或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，
因而该算法是无法实现的，但可以利用该算法去评价其它算法。
*/

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

#defineM4
#defineN17

typedefstructpage
{
	intnum;//记录页面号
	inttime;//记录调入内存时间
}Page;

Pageb[M];//物理块个数
intc[M][N];//保存内存状态
intqueue[50];//记录调入队列
inttimes;//计数

voidinit(Page*b,intc[M][N])//内存初始化
{
	inti,j;
	for(i=0;i<N;i++)
	{
		b[i].num=-1;
		b[i].time=N-i-1;
	}
	for(i=0;i<M;i++)
	{
		for(j=0;j<N;j++)
		{
			c[i][j]=-1;
		}
	}
}
intGetOpt(inta[N],Page*b,inte)//取最近最久未使用的页面
{
	inti,j;
	intopt=-1;
	inttag=0;
	for(i=0;i<M;i++)
	{
		for(j=e;j<N;j++)
		{
			if(b[i].num==a[j])
			{
				b[i].time=j;
				break;
			}
			elseif(j==N-1)
			{
				b[i].time=j;
			}
		}
		if(b[i].time>opt)
		{
			opt=b[i].time;
			tag=i;
		}
	}
	returntag;
}
intjudge(intnum,Page*b)//判断页面是否已在内存中
{
	inti;
	for(i=0;i<M;i++)
	{
		if(num==b[i].num)
		{
			returni;
		}
	}
	return-1;
}
voidOPT(intnum,inta[N],Page*b,inte)
{
	inti,v;
	v=judge(num,b);
	if(v>=0)
	{
		b[v].time=0;
		for(i=0;i<M;i++)
		{
			if(i!=v)
				b[i].time++;
		}
	}
	else
	{
		queue[++times]=num;
		v=GetOpt(a,b,e);
		b[v].num=num;
		b[v].time=0;
		for(i=0;i<M;i++)
		{
			if(i!=v)b[i].time++;
		}
	}

}
intmain()
{
	inta[N]={1,2,3,4,1,2,5,1,2,3,4,5};
	inti,j;
	times=-1;
	init(b,c);
	for(i=0;i<N;i++)
	{
		OPT(a[i],a,b,i);
		c[0][i]=a[i];
		//记录当前的内存单元中的页面
		for(j=0;j<M;j++)
			c[j][i]=b[j].num;
	}
	for(j=0;j<N;j++)
		printf("%2d",a[j]);
	printf("
");
	for(i=0;i<M;i++)
	{
		for(j=0;j<N;j++)
		{
			if(c[i][j]==-1)printf("%2c",32);
			elseprintf("%2d",c[i][j]);
		}
		printf("
");
	}
	printf("
调入队列为：");
	for(i=0;i<times;i++)
		printf("%3d",queue[i]);
	printf("
缺页次数为:%6d
缺页率为:%16.6f
",times+1,(float)(times+1)/N);
}

我替你修改了几个地方，你自己对比一下代码吧。

你的代码基本正确，只是有两处小错误。

另外，queue的单词拼写不正确，我也替你改了。

程序运行结果如图:

‘玖’ 采用首次适应算法和最优置换算法,对内存的分配和回收速度会造成什么不同的影响

首次适应分配算法(FF):
对空闲分区表记录的要求是按地址递增的顺序排列的，每次分配时，总是从第1条记录开始顺序查找空闲分区表，找到第一个能满足作业长度要求的空闲区，分割这个空闲区，一部分分配给作业，另一部分仍为空闲区。
最佳置换算法（OPT):
选择以后永不使用或在最长时间内不再被访问的内存页面予以淘汰。

‘拾’ 最佳页面置换算法的介绍

最佳页面置换算法是Belady于1966年提出的一种理论上的算法。是一种保证最少的缺页率的理想化算法。