lru算法实验报告
LRU页面置换算法的设计实验报告
return-1;
}
intfindReplace(intBsize)
{//查找应予置换的页面
intpos = 0;
for(inti=0; i<Bsize; i++)
if(block[i].timer >= block[pos].timer)
for(i=0;i<20;i++)
{
QString[i] = rand()%10 ;
}
cout<<"页面号引用串: ";
for(i=0;i<20;i++)
{
cout<<QString[i]<<" ";
}
cout<<endl<<"------------------------------------------------------"<<endl;
四、实验结果（含程序、数据记录及分析和实验总结等）
#include<iostream>
#include<string>
#include<stdlib.h>
#include<ctime>
usingnamespacestd;
constintBsize=10;
constintPsize=20;
structp
Bsize = 3;
Init(QString,Bsize);
cout<<"LRU算法结果如下:<<endl;
LRU算法 与CLOCK算法
实验报告课程名称操作系统实验项目名______LRU算法模拟班级与班级代码实验室名称（或课室）专业任课教师学号：姓名：实验日期：2012 年 5 月20 日制姓名实验报告成绩评语：指导教师（签名）年月日说明：指导教师评分后，学年论文交院（系）办公室保存。
实验八 LRU算法模拟一、实验目的（1）模拟实现LRU算法。
（2）模拟实现Clock算法。
（3）比较分析LRU算法、Clock算法。
二、实验内容（1）算法实现。
（2）拟定测试数据对算法的正确性进行测试。
（3）对比分析LRU算法和Clock算法各自的优缺点。
三、实验环境硬件要求：P4 2.0G 1G内存60G硬盘以上电脑软件要求：C、C++编程环境，Java编程环境四、实验步骤1.LRU算法（1）预备知识最近最久未使用(LRU)的页面置换算法，是根据页面调入内存后的使用情况进行决策的。
由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t ，当须淘汰一个页面时，选择现有页面中其t 值最大的，即最近最久未使用的页面予以淘汰。
（2）LRU 的实现（需要“堆栈”支持）可利用一个特殊的栈来保存当前使用的各个页面的页面号。
每当进程访问某页面时，便将该页面的页面号从栈中移出，将它压入栈顶。
因此，栈顶始终是最新被访问页面的编号，而栈底则是最近最久未使用页面的页面号。
假定现有一进程所访问的页面序列为：4，7，0，7，1，0，1，2，1，2，6随着进程的访问，栈中页面号的变化情况如图所示。
在访问页面6时发生了缺页，此时页面4是最近最久未被访问的页，应将它置换出去。
（2）具体的操作代码及其结果如下：#include<stdio.h> #include<iostream>#define num 20 #define max 65535 typedef struct PB{4771012126int page;//当前页面号int seq_num;//对于页面最近一次被访问的序列号int fg;}Pb;int k;int seek(int seq[],int i,Pb a[],int k);int test1(int seq_i,int Pn,Pb a[]);int test2(Pb a[],int Pn);int LRU(int seq[],int i,int Pn,Pb pb[]);//页块中的页面的最近最久未使用位置int seek(int seq[],int i,Pb a[],int k){int flag=0;for(int j=i-1;j>=0;j--){if(a[k].page==seq[j]){flag=1;return j;break;}}if(flag==0)return -1;}//检测当前页面在不在内存中，如果在内存中，返回所在页块号；如果不在，返回-1int test1(int seq_i,int Pn,Pb a[]){int flag=0;for(int j=0;j<Pn;j++){if(a[j].page==seq_i){flag=1;return j;break;}}if(flag==0)return -1;}//检测有没有空页块，如果有空页块，返回页块号；如果没有，返回-1 int test2(Pb a[],int Pn){int flag=0;for(int j=0;j<Pn;j++){if(a[j].page==-1){flag=1;return j;break;}}if(flag==0)return -1;}int LRU(int seq[],int i,int Pn,Pb pb[]){int temp[20];int j;for(k=0;k<Pn;k++){temp[k]=seek(seq,i,pb,k);pb[k].fg=seek(seq,i,pb,k);}for(k=1;k<Pn;k++){int lastX=1;int tem;for(j=0;j<Pn-k;j++){if(temp[j]>temp[j+1]){tem=temp[j];temp[j]=temp[j+1];temp[j+1]=tem;lastX=0;}}if(lastX==1) break;}for(k=0;k<Pn;k++){if(pb[k].fg==temp[0]){printf("%d ",pb[k].page);return k;break;}}}void PCB(){Pb pb[10];//最多只允许0-9共10个页块号int Pn;int an=0;int seq[100];int i;float ar;printf("请输入页块数Pn：\n");scanf("%d",&Pn);printf("请输入%d位长的页面访问序列seq[%d]：\n",num,num); for(i=0;i<num;i++){scanf("%d",&seq[i]);}for(i=0;i<10;i++){pb[i].page=-1;pb[i].seq_num=-1;pb[i].fg=max;}printf("淘汰页面号依次为：\n");for(i=0;i<num;i++){//做20次int a,b;a=test1(seq[i],Pn,pb);b=test2(pb,Pn);if(a==-1){//不在内存中if(b!=-1){//没满pb[b].page=seq[i];pb[b].seq_num=i;an++;}else{//满了k=LRU(seq,i,Pn,pb);pb[k].page=seq[i];pb[k].seq_num=i;an++;}}}ar=(float)an/(float)num;printf("\n缺页次数为：%d\n缺页率为%f\n",an,ar);}void main(){PCB();}(2)运行调试，输出结果：程序完成后，进行调试编译，在弹出的框中输入页块数Pn，回车，然后输入20位长的页面访问序列seq[20],回车，实验结果将显示出该组数据的淘汰页面号、缺页次数和缺页率。
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现FIFO、LRU和Clock算法。
二、实验原理页面置换算法是操作系统中用到的一种算法，其作用是在内存不够用时，选择牺牲已经在内存中的一些页，腾出更多的空间给新的内容。
本次实验主要实现了FIFO、LRU和Clock算法。
1、FIFO算法FIFO算法是最简单的页面置换算法，它采用先进先出的原则，即最先进入内存的页面应该最早被替换出去。
该算法的实现非常简单，只需要维护一个队列即可。
当需要置换页面时，选择队列的第一个页面进行替换即可。
2、LRU算法LRU算法是Least Recently Used的缩写，即最近最少使用算法。
该算法的核心思想是选择最久没有被使用的页面进行替换。
为了实现该算法，需要维护记录页面使用时间的链表、栈或队列等结构。
3、Clock算法Clock算法也叫做二次机会算法，是一种改良的FIFO算法。
它是基于FIFO算法的思想，并且每个页面都设置了一个使用位（use bit），用于记录该页面是否被使用过。
当需要置换一个页面时，检查该页面的使用位，如果该页面的使用位为1，则将该页面的使用位设置为0并移到队列的末尾，表示该页面有“二次机会”继续待在内存中；如果该页面的使用位为0，则选择该页面进行替换。
三、实验过程本次实验采用Python语言实现页面置换算法，并使用样例进行测试。
1、FIFO算法实现FIFO算法的实现非常简单，只需要用一个队列来维护已经在内存中的页面，当需要置换页面时，选择队列的第一个元素即可。
代码如下：```pythonfrom collections import dequeclass FIFO:def __init__(self, frame_num):self.frame_num = frame_numself.frames = deque(maxlen=frame_num)def access(self, page):if page in self.frames:return Falseif len(self.frames) >= self.frame_num:self.frames.popleft()self.frames.append(page)return True```2、LRU算法实现LRU算法的实现需要维护一个记录页面使用时间的链表或队列。
lru算法实验报告
lru算法实验报告LRU算法实验报告摘要：本实验旨在通过实验和数据分析，验证LRU（Least Recently Used）算法在缓存替换策略中的有效性和性能表现。
通过模拟不同的缓存大小和访问模式，我们对LRU算法进行了测试，并分析了其命中率、缺失率以及性能表现。
1. 算法介绍LRU算法是一种常用的缓存替换策略，它根据数据的最近访问时间来进行替换决策。
当缓存空间不足时，LRU算法会淘汰最长时间未被访问的数据，以保证缓存中的数据是最近被使用的。
LRU算法的实现通常使用链表或者哈希表来记录数据的访问顺序，并且在每次访问数据时更新其在链表或哈希表中的位置。
2. 实验设计为了验证LRU算法的有效性和性能表现，我们设计了以下实验：- 实验一：不同缓存大小下的LRU算法性能对比- 实验二：不同访问模式下的LRU算法性能对比在实验一中，我们分别使用LRU算法对不同大小的缓存进行测试，并记录其命中率和缺失率。
在实验二中，我们模拟了随机访问、顺序访问和局部性访问等不同访问模式，并对比LRU算法的性能表现。
3. 实验结果实验结果显示，随着缓存大小的增加，LRU算法的命中率呈现出逐渐增加的趋势，而缺失率则相应减少。
在不同的访问模式下，LRU算法的性能表现也有所差异，其中局部性访问模式下LRU算法表现最佳，而随机访问模式下表现最差。
4. 结论与讨论通过实验结果的分析，我们得出结论：LRU算法在缓存替换策略中具有较好的性能表现，尤其适用于局部性访问模式。
然而，随着数据规模的增大和访问模式的复杂化，LRU算法的性能也会受到一定的影响。
因此，在实际应用中，我们需要根据具体情况选择合适的缓存替换策略，或者结合其他算法进行优化。
总之，本实验验证了LRU算法在缓存替换策略中的有效性和性能表现，为进一步研究和应用LRU算法提供了参考和借鉴。
同时，我们也意识到LRU算法在特定情况下可能存在一定的局限性，需要进一步优化和改进。
LRU算法-与CLOCK算法
实验报告课程名称操作系统实验项目名______LRU算法模拟班级与班级代码实验室名称（或课室）专业任课教师学号：姓名：实验日期：2012 年 5 月20 日制姓名实验报告成绩评语：指导教师（签名）年月日说明：指导教师评分后，学年论文交院（系）办公室保存。
实验八LRU算法模拟一、实验目的（1）模拟实现LRU算法。
（2）模拟实现Clock算法。
（3）比较分析LRU算法、Clock算法。
二、实验内容（1）算法实现。
（2）拟定测试数据对算法的正确性进行测试。
（3）对比分析LRU算法和Clock算法各自的优缺点。
三、实验环境硬件要求：P4 2.0G 1G内存60G硬盘以上电脑软件要求：C、C++编程环境，Java编程环境四、实验步骤1.LRU算法（1）预备知识最近最久未使用(LRU)的页面置换算法，是根据页面调入内存后的使用情况进行决策的。
由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t ，当须淘汰一个页面时，选择现有页面中其t 值最大的，即最近最久未使用的页面予以淘汰。
（2）LRU 的实现（需要“堆栈”支持）可利用一个特殊的栈来保存当前使用的各个页面的页面号。
每当进程访问某页面时，便将该页面的页面号从栈中移出，将它压入栈顶。
因此，栈顶始终是最新被访问页面的编号，而栈底则是最近最久未使用页面的页面号。
假定现有一进程所访问的页面序列为：4，7，0，7，1，0，1，2，1，2，6随着进程的访问，栈中页面号的变化情况如图所示。
在访问页面6时发生了缺页，此时页面4是最近最久未被访问的页，应将它置换出去。
（2）具体的操作代码及其结果如下：#include<stdio.h> #include<iostream>#define num 204771012126#define max 65535typedef struct PB{int page;//当前页面号int seq_num;//对于页面最近一次被访问的序列号int fg;}Pb;int k;int seek(int seq[],int i,Pb a[],int k);int test1(int seq_i,int Pn,Pb a[]);int test2(Pb a[],int Pn);int LRU(int seq[],int i,int Pn,Pb pb[]);//页块中的页面的最近最久未使用位置int seek(int seq[],int i,Pb a[],int k){int flag=0;for(int j=i-1;j>=0;j--){if(a[k].page==seq[j]){flag=1;return j;break;}}if(flag==0)return -1;}//检测当前页面在不在内存中，如果在内存中，返回所在页块号；如果不在，返回-1int test1(int seq_i,int Pn,Pb a[]){int flag=0;for(int j=0;j<Pn;j++){if(a[j].page==seq_i){flag=1;return j;break;}}if(flag==0)return -1;}//检测有没有空页块，如果有空页块，返回页块号；如果没有，返回-1int test2(Pb a[],int Pn){int flag=0;for(int j=0;j<Pn;j++){if(a[j].page==-1){flag=1;return j;break;}}if(flag==0)return -1;}int LRU(int seq[],int i,int Pn,Pb pb[]) {int temp[20];int j;for(k=0;k<Pn;k++){temp[k]=seek(seq,i,pb,k);pb[k].fg=seek(seq,i,pb,k);}for(k=1;k<Pn;k++){int lastX=1;int tem;for(j=0;j<Pn-k;j++){if(temp[j]>temp[j+1]){tem=temp[j];temp[j]=temp[j+1];temp[j+1]=tem;lastX=0;}}if(lastX==1) break;}for(k=0;k<Pn;k++){if(pb[k].fg==temp[0]){printf("%d ",pb[k].page);return k;break;}}}void PCB(){Pb pb[10];//最多只允许0-9共10个页块号int Pn;int an=0;int seq[100];int i;float ar;printf("请输入页块数Pn：\n");scanf("%d",&Pn);printf("请输入%d位长的页面访问序列seq[%d]：\n",num,num); for(i=0;i<num;i++){scanf("%d",&seq[i]);}for(i=0;i<10;i++){pb[i].page=-1;pb[i].seq_num=-1;pb[i].fg=max;}printf("淘汰页面号依次为：\n");for(i=0;i<num;i++){//做20次int a,b;a=test1(seq[i],Pn,pb);b=test2(pb,Pn);if(a==-1){//不在内存中if(b!=-1){//没满pb[b].page=seq[i];pb[b].seq_num=i;an++;}else{//满了k=LRU(seq,i,Pn,pb);pb[k].page=seq[i];pb[k].seq_num=i;an++;}}}ar=(float)an/(float)num;printf("\n缺页次数为：%d\n缺页率为%f\n",an,ar);}void main(){PCB();}(2)运行调试，输出结果：程序完成后，进行调试编译，在弹出的框中输入页块数Pn，回车，然后输入20位长的页面访问序列seq[20],回车，实验结果将显示出该组数据的淘汰页面号、缺页次数和缺页率。
页面置换算法实验报告
页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程，了解不同算法的优缺点，掌握算法的实现方法，以及对算法的性能进行评估。
二、实验原理页面置换算法是操作系统中的一个重要概念，它是为了解决内存不足的问题而产生的。
当系统中的进程需要使用内存时，如果内存已经被占满，就需要将一些页面从内存中置换出去，以便为新的页面腾出空间。
页面置换算法就是用来决定哪些页面应该被置换出去的算法。
常见的页面置换算法有以下几种：1. 最佳置换算法（OPT）最佳置换算法是一种理论上的最优算法，它总是选择最长时间内不会被访问的页面进行置换。
但是，由于无法预测未来的页面访问情况，因此最佳置换算法无法在实际中使用。
2. 先进先出置换算法（FIFO）先进先出置换算法是一种简单的置换算法，它总是选择最先进入内存的页面进行置换。
但是，这种算法容易出现“抖动”现象，即频繁地将页面置换出去，然后再将其置换回来。
3. 最近最久未使用置换算法（LRU）最近最久未使用置换算法是一种比较常用的置换算法，它总是选择最长时间未被访问的页面进行置换。
这种算法可以避免“抖动”现象，但是实现起来比较复杂。
4. 时钟置换算法（Clock）时钟置换算法是一种改进的FIFO算法，它通过维护一个环形链表来实现页面置换。
当需要置换页面时，算法会从当前位置开始扫描链表，如果找到一个未被访问的页面，则将其置换出去。
如果扫描一圈后都没有找到未被访问的页面，则将当前位置的页面置换出去。
三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序，可以模拟上述四种算法的过程，并输出算法的性能指标。
程序的主要流程如下：1. 读取输入文件，获取页面访问序列和内存大小等参数。
2. 根据选择的算法，初始化相应的数据结构。
3. 遍历页面访问序列，模拟页面置换的过程。
4. 输出算法的性能指标，包括缺页率、页面置换次数等。
下面分别介绍四种算法的实现方法。
1. 最佳置换算法（OPT）最佳置换算法需要预测未来的页面访问情况，因此需要遍历整个页面访问序列，找到最长时间内不会被访问的页面。
组相联映射lru算法
组相联映射lru算法组相联映射LRU算法LRU（Least Recently Used）算法是一种常用的缓存替换算法，用于解决缓存中数据的替换问题。
在计算机系统中，缓存是一种高速存储器，用于临时存储经常访问的数据，以提高系统的性能。
而LRU算法通过维护一个固定大小的缓存空间，当缓存空间已满时，选择最近最少被访问的数据进行替换，以保证缓存中的数据始终是最常用的数据。
组相联映射是一种常用的缓存映射方式，它将缓存空间划分为多个组，每个组中包含多个缓存行。
每个缓存行中存储的是一个数据块，同时还包含一个标记位，用于表示该缓存行是否已被占用。
当需要访问一个数据时，首先根据数据的地址计算出所在的组，然后再在该组中查找是否存在所需的数据块。
如果存在，则表示命中缓存，直接使用该数据块；如果不存在，则需要从主存中加载数据块到缓存中，并且选择一个合适的缓存行进行替换。
LRU算法在组相联映射中的实现需要维护一个最近使用列表（LRU List），用于记录每个缓存行的访问顺序。
每当一个缓存行被访问时，就将其移动到最近使用列表的顶部，表示最近被使用过。
当需要替换一个缓存行时，就选择最近使用列表底部的缓存行进行替换，因为它们是最近最少被使用的。
下面以一个具体的例子来说明组相联映射LRU算法的实现过程。
假设有一个4路组相联映射的缓存，每个组中包含2个缓存行，共有8个缓存行。
初始状态下，缓存为空。
1. 访问地址0x1000，属于组0。
由于缓存为空，需要从主存中加载数据块到缓存中，并选择一个缓存行进行替换。
在这里选择第一个缓存行，并将数据块存储在该缓存行中。
2. 访问地址0x2000，属于组1。
同样地，需要从主存中加载数据块到缓存中，并选择一个缓存行进行替换。
在这里选择第一个缓存行，并将数据块存储在该缓存行中。
3. 访问地址0x3000，属于组2。
同样地，需要从主存中加载数据块到缓存中，并选择一个缓存行进行替换。
在这里选择第一个缓存行，并将数据块存储在该缓存行中。
页面淘汰算法实验报告
操作系统实验报告课题：页面淘汰算法专业：班级：学号：姓名：年月日目录一实验目的 (3)二实验要求 (3)三背景知识 (3)四总体设计 (4)五详细设计 (7)六运行结果分析 (9)七心得体会 (13)八参考文献 (14)附：源代码 (15)一、实验目的本实验主要对操作系统中请求分页式内存管理及其应用的一些关键算法进行模拟。
学生通过设计与实现Clock算法，能够加强对相应理论的理解，并对了解操作系统内部的基本处理原理与过程也有很多益处。
利用简单的数据结构，模拟实现操作系统中的页面置换机制，通过写程序模拟实现上述三种内存页面置换算法，使学生进一步掌握内存页面置换的方法。
对操作系统中内存的管理有一个实践上的认识。
1、用C语言编写OPT、FIFO、LRU三种置换算法。
2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
二、实验要求●设计随机页面序号产生程序，并说明随机的性能和其性能可能对算法的影响●编写页面淘汰算法(FIFO、OPT、LRU)●结果数据的显示或提取●结果数据的分析几点说明：●设计并绘制算法流程，附加说明所需的数据结构●如何标记时间的先后、最久的将来、最久未被使用●描述Clock算法的基本原理、必要的数据结构、算法执行流程图、编码实现。
1）初始化：输入作业可占用的总页框数，初始化置空。
2）输入请求序列：输入一个作业页号访问请求序列，依次占用相应页框，直至全部占用；3）Clock算法：当页框全部占用后，对于后续新的页号访问请求，执行Clock 算法，淘汰1个页面后装入新的页号。
4）显示当前分配淘汰序列：显示淘汰的页号序列。
三、背景知识：在操作系统当中，在进程运行过程中，若其访问的页面不在内存中而需把他们调入内存，但内存已无空闲空间时，为了保证该进程能够正常的运行，系统必须从内存中调出一页程序或数据送到磁盘的兑换区中，但是应该是哪个页面被调出，需根据一定的算法来确定。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二模拟LRU页面置换算法
一、实验目的
1）用C或C++模拟LRU页面置换算法
2）掌握LRU页面置换算法的调度过程
二、实验内容
设计一个虚拟存储系统，编写程序模拟LUR页面置换算法，通过程序输出淘汰的页面并计算出命中率：示列：
随机输入页面访问串：
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1
随机输入内存驻留集大小：3 （驻留集初始状态为空）
三、实验要求
要求访问页面号、驻留集都是随机输入，驻留集初始状态下为空。
实验代码：
#include<iostream>
using namespace std;
int judge(int q[],int rear,int front,int num)
{
for(int i = rear; i < front; i++)
{
if(q[i] == num)
{
return i;
}
}
return -1;
}
void f(int q[],int rear,int t)
{
for(int i = t; i > rear; i--)
{
q[i] = q[i-1];
}
}
void show(int q[],int rear,int front)
{
for(int i = rear; i <= front; i++)
cout << q[i] << " ";
cout << endl;
}
void deal(int a[],int n,int m)
{
int rear = 0;
int front = -1;
int q[m];
int temp = 0;
int count = 0;
for(int i = 0; i < n; i++)
{
int t = judge(q,rear,front,a[i]);
q[++front]=a[i];
if(temp < m)
{
if(t != -1)
{
f(q,rear,t);
cout << a[i] << "命中" << endl; rear++;
count++;
}
else
{
temp++;
}
}
else
{
if(t != -1)
{
f(q,rear,t);
cout << a[i] << "命中" << endl; rear++;
count++;
}
else
{
cout << q[rear] << "淘汰" << endl;
rear++;
}
}
}
cout << "命中率为：" << count << "/" << n;
}
int main()
{
int n;
int m;
cout << "请输入要访问的页面序列个数:";
cin >> n ;
cout << "请输入驻留值的大小:";
cin >> m;
int a[n];
cout << "请输入要访问的" << n << "个页面序列" << endl; for(int i = 0; i < n;i++)
{
cin >> a[i];
}
deal(a,n,m);
}
运行结果：。