如题所述
第1个回答 2013-01-28
实验7的存储管理---------常用页面置换算法模拟
实验的目的
请求页面的存储管理，实现由几个基本的页面置换算法模拟懂得他们的特点主虚拟存储的虚拟存储技术，要求几个基本的页面内存管理页面置换算法的基本思路和实施过程中，并比较它们的效率。
实验内容
设计一个虚拟存储区和内存工作区，访问的命中率和使用下面的算法。
1，最好的出算法（OPT）
2，先入先出（FIFO）算法
3，近期最最近使用算法（LRU）</ 4，最不经常
5算法（LFU），最近未使用算法（NUR）
命中率= 1 - 页码的故障/页地址流长度
实验准备
基本上按照实验内容设计的实验方案。首先，与srand（）函数和rand（）函数被定义，并产生一个指令序列，然后转换成相应的页地址流的指令序列，以及对于不同的算法来计算相应的命中率。
（1）的指令序列的一个随机数发生器，共320条指令。的基础上产生的：
A：50％的指令是顺序
B：25％的指令是均匀地分布到以前的地址部分
C：25％的指令的下一条指令的地址实施的具体方法是均匀分布的地址部分的
：
答：[0319]指令地址之间随机选择的点m
B：为了执行一个指令，即执行地址后，的m +1的指令
C：随机选择一个指令并执行的第一个地址，[0，1米]，指令的地址的m'
D：在该命令执行的指令，地址为M'+1
E：随机选择地址[M'2319]指令并执行，直到320指令
F：重复步骤AE（2）指令序列被转换成页地址流
集：在页面大小为1K;
用户内存容量为4-32
用户虚拟内存容量为32K。
用户的虚拟内存设置每个便利店10个指令存储在虚拟内存中的虚拟内存地址320指令：
0 - 指令9 0页（对应的虚拟内存地址为[0,9]） /> 10 - 19个指令1（对应的虚拟内存地址为[10,19]）
............... .....................
310 - 319指令[310319]）
以上，使用说明，可以组成32 31（对应的虚拟内存地址。
实验指导，
UNIX的虚拟存储系统，以提高内存利用率，提供内部和外部的存款交流机制;内存空间的分配和回收，以页为单位，一个进程只需部分（或页面）可运行内存;支持按需分页的内存管理。
的过程正在运行时，当你需要的程序和数据访问的一部分，并发现他们的网页是不是在内存中，则立刻要求（发行丢失中断的CPU），和系统所需的页面到内存中。这被称为按需分页的分页模式。
按需分页的核心配置，为实现四个数据结构：页表，页帧号，访问位，位有效位保护位。
二，
页面置换算法时的信号，CPU接收到缺页中断处理程序先保存现场，分析中断原因，并转移到一个页面故障处理程序程序找到页表的物理块号的页面是通过外部的内存，如果内存是不完整的，以适应新的页面，然后启动磁盘I / O到内存中的缺页，然后页表。如果内存已满，受到某种选择的替换算法从内存中准备换出，是否重新写入磁盘，然后由的页表缺页之位转移到的页表。页表的物理地址来访问数据，去访问内存中的数据。整个页面的加载过程对用户是透明的。页面置换算法
1，最好的替代算法（optimal）
2，先入先出法（先出的最前一页）
3，最近最最近使用的（最近最少使用） /> 4，最常用的方法（最常用）
5，未使用的法案“（没有最近使用过的）
参考方案：
定义真正的1
＃FALSE 0
的定义无效-1
定义NULL 0
定义total_instruction 320 / *指令流的长度* /
定义total_vp 32 / *虚拟页长* /
的定义clear_period的50 / *清除为0周期* /
typedef结构/ *页面结构* /
{
诠释PN，PFN，计数器，时间;
} pl_type
pl_type PL [total_vp]; / *页面结构数组* /
结构pfc_struct {/ *页面控制结构* /
INT PN，PFN
结构pfc_struct *下;
};
typedef结构pfc_struct pfc_type;
pfc_type PFC [total_vp]，* freepf_head， * busypf_head，* busypf_tail;
诠释diseffect，[total_instruction];
诠释页[total_instruction]，偏移[total_instruction];
诠释初始化（INT） ;
诠释FIFO（INT）;
LRU（INT）;
LFU（INT）;
诠释NUR（INT）;
诠释OPT（国际） ;
廉政的main（）
{
int类型，I，J;
，srand函数（10 * GETPID（））; / *每个运行进程的ID，可以用作一个队列初始化随机数“种子”* /
为s =（浮子）319 *的rand（）/ 32767/32767/2 1; / /
为（i = 0;我<total_instruction; + = 4）/ *生成一个命令队列* /
{
（ 319）
{
printf的（“我==％D，错误，S ==％e\ n“，I，S）;
出口（0）;
}
一个[i] = S / *申请指令接入点米* /
一个[i +1] = [] +1; / *顺序执行指令* /
一个[i +2] =（）一[I] * RAND（）/ 32767/32767/2; / *指令之前执行地址m * /
一个[i +3] = [+2] + 1; / *顺序执行指令* /
=（）（318-A [I +2）* RAND（）/ 32767/32767/2 + A [I +2 +2;
>（（[I +2]> 318）| |（319））
printf的（“[％D +2]，号码是：％d和s ==％D \ “我，一个[i +2]）;
}
（i = 0; <total_instruction，我+ +）/ *网页地址的指令序列被转换成流* /
{
页[I] = A [I] / 10;的
偏移[I] = A [i]的10％;
}
（I = 4; <= 32; i + +）/ *用户内存工作区从四页至32页* /
{
printf的（“ - ％2D页面帧--- \ n“，I）;
FIFO（I）;
LRU（I）;
LFU（I）;
NUR（I）;
OPT（I）;
}
返回0;
}
整数的初始化（total_pf）/ *初始化相关的数据结构* / BR />诠释total_pf; / *用户进程的内存页面数* /
{;
diseffect = 0;
（i = 0; <total_vp; + +）
{
PL [I] PN =;
PL [I]。PFN =无效; / *的主页的控制结构中的页号，页是空* /
PL [I]。计数器= 0;
PL [I]。时间= -1; / *的时间-1访问页面中的控制结构* / />}
为（i = 0;我total_pf-1; + +）
{
PFC [我]。下=＆PFC [i +1] PFC [I]。之间的联系PFN = I;
} / *建立PFC [I-1]和PFC [I] * /
PFC [total_pf-1] = NULL;
> PFC [total_pf-1]。PFN = total_pf-1;
freepf_head =＆PFC [0]; / *空页面队列的头指针PFC [0] * /
返回0;
}
整数FIFO（total_pf）的/ * FIFO算法* /
诠释total_pf; / *用户进程的内存页面数* / /> {
INT I，J，
pfc_type * P的
初始化（total_pf）的; / *初始化的相关页面控制数据结构* /
busypf_head高= busypf_tail = NULL; / *繁忙的队列的头部，的队列尾部链接* /
为（i = 0; <total_instruction，我+ +）
{
（PL [页[我]。PFN ==无效）/ *页故障* /
{
diseffect到+ = 1; / *失败* /
（freepf_head = = NULL）/ *没有空闲页* /
{
P = busypf_head下;
PL [busypf_head - > PN]。PFN =无效;
freepf_head = busypf_head; / *释放忙页面队列的第一页* /
freepf_head - > = NULL;
busypf_head = P;
}
P = freepf_head - >; / *调在FIFO方式的新页到内存页* /
freepf_head - >下一个= NULL;
freepf_head - > PN =页[我];
PL [页[我]。PFN = freepf_head - > PFN;
（busypf_tail == NULL）
busypf_head = busypf_tail = freepf_head;
其他
{
busypf_tail - >下一个= freepf_head / *空闲页，以减少* /
busypf_tail freepf_head;
}
freepf_head = P;
}
}
printf的（“FIFO： ％6.4f \ n“，1 - （浮动）diseffect/320）。
返回0;
}
诠释的LRU（total_pf） / *最最近使用算法* /
诠释total_pf的;
{
诠释分钟，minj，我J，present_time;
初始化（total_pf）的;
present_time = 0;
为（i = 0; <total_instruction，我+ +）
{
（PL [页[我]。PFN ==无效） / *页故障* /
{
diseffect + +;
（freepf_head == NULL）/ *没有空闲页* /
{
分钟= 32767;
（J = 0; J <total_vp; + +）/ *找出最短的时间* /
（分> PL [J] &&的PL [J]。PFN！ =无效）
{
分钟=的PL [J]。时间;
minj = J;
}
freepf_head =＆PFC [PL minj]。PFN ] / /释放出一个单位
PL [minj PFN =无效;
PL [minj。时间= -1;
freepf_head - > = NULL;
} BR /> PL [页[我]。PFN = freepf_head-> PFN; / /释放页，而不是有效
PL [页[我]时间= present_time
freepf_head = freepf_head - >下一步; / /减少一个免费的网页
}
其他
PL [页[我] = present_time / /命中的单位增加了不少的访问
present_time + +;
}
printf的（“LRU：％6.4f \ n”，1 - （浮动）diseffect/320）;
返回0;
>}
诠释NUR（total_pf）/ *最近未使用的算法/
诠释total_pf;
{IJ，DP，cont_flag old_dp;
pfc_type * T在
初始化（total_pf）的;
DP = 0;
（i = 0; <total_instruction，我+ +）
{如果（ PL [页[我]的PFN ==无效）/ *页故障* /
{diseffect + +;
（freepf_head == NULL）/ *空闲页* /
{cont_flag = TRUE;
old_dp = DP;
（cont_flag）
（PL [DP]。计数器== 0 && PL [DP]。PFN =无效）
> cont_flag = FALSE;
其他
{
DP + +;
（DP == total_vp）
DP = 0;
（DP = old_dp）
（J = 0; J <total_vp; + +）
PL [J]。计数器= 0;
}
freepf_head =＆PFC [PL [ DP]。PFN];
PL [DP]。PFN =无效;
freepf_head - >下一个= NULL;
}
PL [页[我]。PFN = freepf_head - > PFN
freepf_head = freepf_head - >下;
}
其他
PL [页[我]。计数器= 1;
（％clear_period == 0）
（J = 0; J <total_vp; + +）
PL [J]。计数器= 0;
}
printf的（“NUR：％ 6.4f \ n“，1 - （浮动）diseffect/320）;
返回0;
} >
诠释的OPT（total_pf）/ *最佳置换算法* /
的int total_pf;
{I，J，D，max，maxpage等区[total_vp];
pfc_type * T;
初始化（total_pf）的; ...... />（i = 0; <total_instruction，我+ +）
{/ / printf的（“OPT 1，I =％d条\ n”，I）/ / I = 86，I = 176，206，250，220,221; 192193194; 258，274,275,276,277,278;
（PL [页[我]。PFN ==无效）/ *页错误* / {
，diseffect + +的
（freepf_head == NULL）/ *空闲页* /
{（J = 0; J <total_vp; J + +）
（PL [ J]。PFN！=无效）区[J] = 32767; / *最大距离* /
其他区的研究[J] = 0;
D = 1;
（J =我+1; <total_instruction; + +）
{
（PL [页[J]。PFN =无效）
区[页[J]] = D;
D + +;
}
最大= -??1;
为（J = 0; <total_vp; + +）
（最大<区[ J]）
{
最大=区[J];
maxpage = J;
}
freepf_head =＆PFC [PL [maxpage]。PFN]; BR /> freepf_head - >下一个= NULL;
PL [maxpage]。PFN =无效;
}
PL [页[我]。PFN = freepf_head - > PFN;
> freepf_head = freepf_head - >下;
}
}
输出（OPT：％6.4f \ n“，1 - （浮动）diseffect / 320）;
/> 0;
}
int的LFU（total_pf）的/最不常用的更换方法* /
诠释total_pf;
{
INT I，J，分，minpage;
pfc_type * T;
初始化（total_pf）的;
（i = 0; <total_instruction，我+ +）
{ （PL [页[我]。PFN ==无效）/ *页故障* /
{diseffect + +;
（freepf_head == NULL）/ *没有免费的页面* / BR /> {分钟= 32767;
为（J = 0; J <total_vp; + +）
{（MIN> PL [J]。计数器&& PL [J]。PFN！ INVALID）
{
分钟= PL [J]。计数器;
minpage = J;
}
的PL [J]。计数器= 0;
}
freepf_head =＆PFC [PL [minpage]。PFN];
PL [minpage]。PFN =无效;
freepf_head - >下一个= NULL;
}
> PL [页[我]。PFN freepf_head - > PFN; / /空闲页改变有效
PL [页[我]计数器+ +;
freepf_head freepf_head - >; / /减少一个免费的网页
}
其他
PL [页[我]计数器+ +;
}
printf的（“LFU： ％6.4f \ n“，1 - （浮动）diseffect/320）;
返回0;
}
4个运行结果
页的FRAM
FIFO：0.7312
LRU：0.7094
LFU：0.5531
NUR：0.7688
OPT：0.9750
5页的FRAM
...... ..... ...
1，分析的几种算法的命中率，OPT最高，其次NUR相对较高，而最低的FIFO与LRU LFU几乎是相同的。然而，每个页面执行的结果将是不同的。
2的OPT算法过程中可能出现执行错误
五思想
为什么将OPT的执行错误发生？
实验的目的
请求页面的存储管理，实现由几个基本的页面置换算法模拟懂得他们的特点主虚拟存储的虚拟存储技术，要求几个基本的页面内存管理页面置换算法的基本思路和实施过程中，并比较它们的效率。
实验内容
设计一个虚拟存储区和内存工作区，访问的命中率和使用下面的算法。
1，最好的出算法（OPT）
2，先入先出（FIFO）算法
3，近期最最近使用算法（LRU）</ 4，最不经常
5算法（LFU），最近未使用算法（NUR）
命中率= 1 - 页码的故障/页地址流长度
实验准备
基本上按照实验内容设计的实验方案。首先，与srand（）函数和rand（）函数被定义，并产生一个指令序列，然后转换成相应的页地址流的指令序列，以及对于不同的算法来计算相应的命中率。
（1）的指令序列的一个随机数发生器，共320条指令。的基础上产生的：
A：50％的指令是顺序
B：25％的指令是均匀地分布到以前的地址部分
C：25％的指令的下一条指令的地址实施的具体方法是均匀分布的地址部分的
：
答：[0319]指令地址之间随机选择的点m
B：为了执行一个指令，即执行地址后，的m +1的指令
C：随机选择一个指令并执行的第一个地址，[0，1米]，指令的地址的m'
D：在该命令执行的指令，地址为M'+1
E：随机选择地址[M'2319]指令并执行，直到320指令
F：重复步骤AE（2）指令序列被转换成页地址流
集：在页面大小为1K;
用户内存容量为4-32
用户虚拟内存容量为32K。
用户的虚拟内存设置每个便利店10个指令存储在虚拟内存中的虚拟内存地址320指令：
0 - 指令9 0页（对应的虚拟内存地址为[0,9]） /> 10 - 19个指令1（对应的虚拟内存地址为[10,19]）
............... .....................
310 - 319指令[310319]）
以上，使用说明，可以组成32 31（对应的虚拟内存地址。
实验指导，
UNIX的虚拟存储系统，以提高内存利用率，提供内部和外部的存款交流机制;内存空间的分配和回收，以页为单位，一个进程只需部分（或页面）可运行内存;支持按需分页的内存管理。
的过程正在运行时，当你需要的程序和数据访问的一部分，并发现他们的网页是不是在内存中，则立刻要求（发行丢失中断的CPU），和系统所需的页面到内存中。这被称为按需分页的分页模式。
按需分页的核心配置，为实现四个数据结构：页表，页帧号，访问位，位有效位保护位。
二，
页面置换算法时的信号，CPU接收到缺页中断处理程序先保存现场，分析中断原因，并转移到一个页面故障处理程序程序找到页表的物理块号的页面是通过外部的内存，如果内存是不完整的，以适应新的页面，然后启动磁盘I / O到内存中的缺页，然后页表。如果内存已满，受到某种选择的替换算法从内存中准备换出，是否重新写入磁盘，然后由的页表缺页之位转移到的页表。页表的物理地址来访问数据，去访问内存中的数据。整个页面的加载过程对用户是透明的。页面置换算法
1，最好的替代算法（optimal）
2，先入先出法（先出的最前一页）
3，最近最最近使用的（最近最少使用） /> 4，最常用的方法（最常用）
5，未使用的法案“（没有最近使用过的）
参考方案：
定义真正的1
＃FALSE 0
的定义无效-1
定义NULL 0
定义total_instruction 320 / *指令流的长度* /
定义total_vp 32 / *虚拟页长* /
的定义clear_period的50 / *清除为0周期* /
typedef结构/ *页面结构* /
{
诠释PN，PFN，计数器，时间;
} pl_type
pl_type PL [total_vp]; / *页面结构数组* /
结构pfc_struct {/ *页面控制结构* /
INT PN，PFN
结构pfc_struct *下;
};
typedef结构pfc_struct pfc_type;
pfc_type PFC [total_vp]，* freepf_head， * busypf_head，* busypf_tail;
诠释diseffect，[total_instruction];
诠释页[total_instruction]，偏移[total_instruction];
诠释初始化（INT） ;
诠释FIFO（INT）;
LRU（INT）;
LFU（INT）;
诠释NUR（INT）;
诠释OPT（国际） ;
廉政的main（）
{
int类型，I，J;
，srand函数（10 * GETPID（））; / *每个运行进程的ID，可以用作一个队列初始化随机数“种子”* /
为s =（浮子）319 *的rand（）/ 32767/32767/2 1; / /
为（i = 0;我<total_instruction; + = 4）/ *生成一个命令队列* /
{
（ 319）
{
printf的（“我==％D，错误，S ==％e\ n“，I，S）;
出口（0）;
}
一个[i] = S / *申请指令接入点米* /
一个[i +1] = [] +1; / *顺序执行指令* /
一个[i +2] =（）一[I] * RAND（）/ 32767/32767/2; / *指令之前执行地址m * /
一个[i +3] = [+2] + 1; / *顺序执行指令* /
=（）（318-A [I +2）* RAND（）/ 32767/32767/2 + A [I +2 +2;
>（（[I +2]> 318）| |（319））
printf的（“[％D +2]，号码是：％d和s ==％D \ “我，一个[i +2]）;
}
（i = 0; <total_instruction，我+ +）/ *网页地址的指令序列被转换成流* /
{
页[I] = A [I] / 10;的
偏移[I] = A [i]的10％;
}
（I = 4; <= 32; i + +）/ *用户内存工作区从四页至32页* /
{
printf的（“ - ％2D页面帧--- \ n“，I）;
FIFO（I）;
LRU（I）;
LFU（I）;
NUR（I）;
OPT（I）;
}
返回0;
}
整数的初始化（total_pf）/ *初始化相关的数据结构* / BR />诠释total_pf; / *用户进程的内存页面数* /
{;
diseffect = 0;
（i = 0; <total_vp; + +）
{
PL [I] PN =;
PL [I]。PFN =无效; / *的主页的控制结构中的页号，页是空* /
PL [I]。计数器= 0;
PL [I]。时间= -1; / *的时间-1访问页面中的控制结构* / />}
为（i = 0;我total_pf-1; + +）
{
PFC [我]。下=＆PFC [i +1] PFC [I]。之间的联系PFN = I;
} / *建立PFC [I-1]和PFC [I] * /
PFC [total_pf-1] = NULL;
> PFC [total_pf-1]。PFN = total_pf-1;
freepf_head =＆PFC [0]; / *空页面队列的头指针PFC [0] * /
返回0;
}
整数FIFO（total_pf）的/ * FIFO算法* /
诠释total_pf; / *用户进程的内存页面数* / /> {
INT I，J，
pfc_type * P的
初始化（total_pf）的; / *初始化的相关页面控制数据结构* /
busypf_head高= busypf_tail = NULL; / *繁忙的队列的头部，的队列尾部链接* /
为（i = 0; <total_instruction，我+ +）
{
（PL [页[我]。PFN ==无效）/ *页故障* /
{
diseffect到+ = 1; / *失败* /
（freepf_head = = NULL）/ *没有空闲页* /
{
P = busypf_head下;
PL [busypf_head - > PN]。PFN =无效;
freepf_head = busypf_head; / *释放忙页面队列的第一页* /
freepf_head - > = NULL;
busypf_head = P;
}
P = freepf_head - >; / *调在FIFO方式的新页到内存页* /
freepf_head - >下一个= NULL;
freepf_head - > PN =页[我];
PL [页[我]。PFN = freepf_head - > PFN;
（busypf_tail == NULL）
busypf_head = busypf_tail = freepf_head;
其他
{
busypf_tail - >下一个= freepf_head / *空闲页，以减少* /
busypf_tail freepf_head;
}
freepf_head = P;
}
}
printf的（“FIFO： ％6.4f \ n“，1 - （浮动）diseffect/320）。
返回0;
}
诠释的LRU（total_pf） / *最最近使用算法* /
诠释total_pf的;
{
诠释分钟，minj，我J，present_time;
初始化（total_pf）的;
present_time = 0;
为（i = 0; <total_instruction，我+ +）
{
（PL [页[我]。PFN ==无效） / *页故障* /
{
diseffect + +;
（freepf_head == NULL）/ *没有空闲页* /
{
分钟= 32767;
（J = 0; J <total_vp; + +）/ *找出最短的时间* /
（分> PL [J] &&的PL [J]。PFN！ =无效）
{
分钟=的PL [J]。时间;
minj = J;
}
freepf_head =＆PFC [PL minj]。PFN ] / /释放出一个单位
PL [minj PFN =无效;
PL [minj。时间= -1;
freepf_head - > = NULL;
} BR /> PL [页[我]。PFN = freepf_head-> PFN; / /释放页，而不是有效
PL [页[我]时间= present_time
freepf_head = freepf_head - >下一步; / /减少一个免费的网页
}
其他
PL [页[我] = present_time / /命中的单位增加了不少的访问
present_time + +;
}
printf的（“LRU：％6.4f \ n”，1 - （浮动）diseffect/320）;
返回0;
>}
诠释NUR（total_pf）/ *最近未使用的算法/
诠释total_pf;
{IJ，DP，cont_flag old_dp;
pfc_type * T在
初始化（total_pf）的;
DP = 0;
（i = 0; <total_instruction，我+ +）
{如果（ PL [页[我]的PFN ==无效）/ *页故障* /
{diseffect + +;
（freepf_head == NULL）/ *空闲页* /
{cont_flag = TRUE;
old_dp = DP;
（cont_flag）
（PL [DP]。计数器== 0 && PL [DP]。PFN =无效）
> cont_flag = FALSE;
其他
{
DP + +;
（DP == total_vp）
DP = 0;
（DP = old_dp）
（J = 0; J <total_vp; + +）
PL [J]。计数器= 0;
}
freepf_head =＆PFC [PL [ DP]。PFN];
PL [DP]。PFN =无效;
freepf_head - >下一个= NULL;
}
PL [页[我]。PFN = freepf_head - > PFN
freepf_head = freepf_head - >下;
}
其他
PL [页[我]。计数器= 1;
（％clear_period == 0）
（J = 0; J <total_vp; + +）
PL [J]。计数器= 0;
}
printf的（“NUR：％ 6.4f \ n“，1 - （浮动）diseffect/320）;
返回0;
} >
诠释的OPT（total_pf）/ *最佳置换算法* /
的int total_pf;
{I，J，D，max，maxpage等区[total_vp];
pfc_type * T;
初始化（total_pf）的; ...... />（i = 0; <total_instruction，我+ +）
{/ / printf的（“OPT 1，I =％d条\ n”，I）/ / I = 86，I = 176，206，250，220,221; 192193194; 258，274,275,276,277,278;
（PL [页[我]。PFN ==无效）/ *页错误* / {
，diseffect + +的
（freepf_head == NULL）/ *空闲页* /
{（J = 0; J <total_vp; J + +）
（PL [ J]。PFN！=无效）区[J] = 32767; / *最大距离* /
其他区的研究[J] = 0;
D = 1;
（J =我+1; <total_instruction; + +）
{
（PL [页[J]。PFN =无效）
区[页[J]] = D;
D + +;
}
最大= -??1;
为（J = 0; <total_vp; + +）
（最大<区[ J]）
{
最大=区[J];
maxpage = J;
}
freepf_head =＆PFC [PL [maxpage]。PFN]; BR /> freepf_head - >下一个= NULL;
PL [maxpage]。PFN =无效;
}
PL [页[我]。PFN = freepf_head - > PFN;
> freepf_head = freepf_head - >下;
}
}
输出（OPT：％6.4f \ n“，1 - （浮动）diseffect / 320）;
/> 0;
}
int的LFU（total_pf）的/最不常用的更换方法* /
诠释total_pf;
{
INT I，J，分，minpage;
pfc_type * T;
初始化（total_pf）的;
（i = 0; <total_instruction，我+ +）
{ （PL [页[我]。PFN ==无效）/ *页故障* /
{diseffect + +;
（freepf_head == NULL）/ *没有免费的页面* / BR /> {分钟= 32767;
为（J = 0; J <total_vp; + +）
{（MIN> PL [J]。计数器&& PL [J]。PFN！ INVALID）
{
分钟= PL [J]。计数器;
minpage = J;
}
的PL [J]。计数器= 0;
}
freepf_head =＆PFC [PL [minpage]。PFN];
PL [minpage]。PFN =无效;
freepf_head - >下一个= NULL;
}
> PL [页[我]。PFN freepf_head - > PFN; / /空闲页改变有效
PL [页[我]计数器+ +;
freepf_head freepf_head - >; / /减少一个免费的网页
}
其他
PL [页[我]计数器+ +;
}
printf的（“LFU： ％6.4f \ n“，1 - （浮动）diseffect/320）;
返回0;
}
4个运行结果
页的FRAM
FIFO：0.7312
LRU：0.7094
LFU：0.5531
NUR：0.7688
OPT：0.9750
5页的FRAM
...... ..... ...
1，分析的几种算法的命中率，OPT最高，其次NUR相对较高，而最低的FIFO与LRU LFU几乎是相同的。然而，每个页面执行的结果将是不同的。
2的OPT算法过程中可能出现执行错误
五思想
为什么将OPT的执行错误发生？
