模拟FIFO和LRU算法试验报告

合集下载

页面置换算法实验报告实验心得

页面置换算法实验报告实验心得
页面置换算法是操作系统中用来管理内存的一种重要算法。

在本次实验中，我们通过模拟内存的分配和释放过程，探索了三种典型的页面置换算法：FIFO（先进先出）、LRU（最近最少使用）和OPT（最优置换）。

在实验过程中，我发现FIFO算法虽然简单易懂，但容易产生“抖动”现象，即容易出现频繁的页面置换，导致系统效率低下。

LRU算法则能够有效避免抖动现象，但需要记录每个页面最近一次的使用时间，算法实现较为复杂。

OPT算法是一种理论上的最优算法，但由于需要预测未来的页面使用情况，实际中难以实现。

通过对三种算法的实验数据分析，我发现在不同的内存使用情况下，不同的页面置换算法表现也不同。

例如在内存使用较少的情况下，FIFO算法的效率可能会更高，但在内存使用较多的情况下，LRU算法则能够更好地发挥作用。

因此，在实际应用中，需要根据实际情况选择合适的页面置换算法。

总之，本次页面置换算法的实验让我更加深入地了解了操作系统中内存管理的相关知识，也加深了我对算法选择的理解和实际应用的思考。

模拟FIFO和LRU算法试验报告

实验报告实验名称：模拟FIFO和LRU算法学校：长安大学学院：信息学院班级：24060901姓名：***日期：2012-5-3一、实验题目：先进先出（FIFO）页面置换算法和最近最久未使用（LRU）置换算法程序设计二、实验目的：通过对FIFO，LRU算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。

三、实验设备及环境：1. 硬件设备：PC机一台2. 软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java 等编程语言环境。

四、实验内容及要求：（1）用C/C++语言编程实现对FIFO，LRU算法的模拟。

（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：五、实验方法内容一．算法流程图二．主要模块FIFO功能函数设计：Fifo_replace(void); //构造函数~Fifo_replace(void); //析构函数int findSpace(void); //查找是否有空闲内存int findExist(int curpage); //查找内存中是否有该页面 int findReplace(void); //查找应予置换的页面void display(void); //显示void FIFO(void); //FIFO算法void BlockClear(void); //BLOCK恢复pageInfor *block; //物理块pageInfor *page; //页面号串int memory_state[Bsize][Psize];int s; //缺页统计三．主要代码设计FIFO部分代码#include <iostream.h>#define Bsize 3#define Psize 12struct pageInfor{int content;//页面号int timer;//被访问标记};class Fifo_replace{public:Fifo_replace(void); //构造函数~Fifo_replace(void); //析构函数int findSpace(void); //查找是否有空闲内存int findExist(int curpage); //查找内存中是否有该页面 int findReplace(void); //查找应予置换的页面void display(void); //显示void FIFO(void); //FIFO算法void BlockClear(void); //BLOCK恢复pageInfor *block; //物理块pageInfor *page; //页面号串int memory_state[Bsize][Psize];int s; //缺页统计private:};Fifo_replace::Fifo_replace(void){int QString[12]={4,3,2,1,4,3,5,4,3,2,1,5};s=0;block = new pageInfor[Bsize];for(int i=0; i<Bsize; i++) //初始化Block{block[i].content = -1;block[i].timer = 0;}page = new pageInfor[Psize];for(i=0; i<Psize; i++){page[i].content = QString[i];page[i].timer = 0;}Fifo_replace::~Fifo_replace(){s=0;}int Fifo_replace::findSpace(void){for(int i=0; i<Bsize; i++)if(block[i].content == -1)return i;//找到空闲内存，return -1;}int Fifo_replace::findExist(int curpage){for(int i=0; i<Bsize; i++)if(block[i].content == page[curpage].content) return i;//找到内存中有该页面，返回BLOCK中位置 return -1;}int Fifo_replace::findReplace(void){int pos = 0;for(int i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i;//找到应予置换页面，返回BLOCK中位置 return pos;}void Fifo_replace::display(void){for(int i=0; i<Bsize; i++)if(block[i].content != -1)cout<<block[i].content<<" ";cout<<endl;}void Fifo_replace::FIFO(void)int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){for(int b=0; b<Bsize; b++){memory_state[b][i]=memory_state[b][i-1];}s++;//cout<<"不缺页"<<endl;}else{space = findSpace();if(space != -1){for(int b=0; b<Bsize; b++){memory_state[b][i]=memory_state[b][i-1];}block[space] = page[i];memory_state[space][i]=block[space].content; if(space==1){memory_state[1][0]=0;memory_state[2][0]=0;}else{memory_state[2][1]=0;}//display();}else{for(int b=0; b<Bsize; b++){memory_state[b][i]=memory_state[b][i-1]; }position = findReplace();block[position] = page[i];memory_state[position][i]=block[position].content;//display();}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中所有页面TIMER++}}void Fifo_replace::BlockClear(void){for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}}LRU部分代码实现：#include<stdio.h>#include<conio.h>#define M 4#define N 17#define Myprintfprintf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ ---+---|\n") /*表格控制*/typedef struct page{int num; /*记录页面号*/int time; /*记录调入内存时间*/}Page; /* 页面逻辑结构，结构为方便算法实现设计*/ Page b[M]; /*内存单元数*/int c[M][N]; /*暂保存内存当前的状态：缓冲区*/int queue[100]; /*记录调入队列*/int K; /*调入队列计数变量*//*初始化内存单元、缓冲区*/void Init(Page *b,int c[M][N]){int i,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;}/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/ int GetMax(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 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);if (val>=0)b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}else{queue[++K]=fold;/*记录调入页面*/val=GetMax(b);b[val].num=fold;b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}}/*主程序*/六、实验结果1.执行结果FIFO部分LRU部分：2.结果分析由结果可以看出,使用FIFO算法，总是淘汰最先进入内存的页面，即即选择在内存中驻留时间最久的页面予以淘汰。

操作系统fifo算法模拟实验总结

FIFO算法模拟实验总结操作系统中的页面置换算法是为了有效管理计算机内存空间而设计的。

FIFO （First-In, First-Out）是最简单和最常见的页面置换算法之一。

通过对FIFO算法进行模拟实验，我们可以更好地理解其工作原理，评估其性能，并进一步探讨其局限性和优化方向。

重要观点1.FIFO算法的基本原理：FIFO算法按照页面进入内存的先后顺序进行置换，即最早进入内存的页面将最先被淘汰。

这一原理确保了页面的公平访问，但可能导致较低的缓存命中率。

2.页面置换的开销问题：无论使用哪种页面置换算法，都需要进行页面调度和数据迁移，这涉及到CPU和内存之间频繁的数据传输。

因此，算法的开销也需考虑在内。

3.缺页中断的处理：当CPU请求的页面不在内存中时，会发生缺页中断。

FIFO算法需要将最早进入内存的页面替换出去，为新页面腾出位置来处理缺页中断。

这需要涉及读取磁盘上的页面数据，带来了较高的I/O开销。

4.FIFO算法的局限性：FIFO算法没有考虑页面的重要性和访问频率，只单纯按照进入内存的顺序进行页面置换。

这种简单的先进先出策略可能会导致较低的缓存命中率和较大的开销。

关键发现通过对FIFO算法进行模拟实验，我们得出了一些关键发现：1.FIFO算法的缓存命中率与页面引用模式密切相关。

在连续引用的页面中，若页面较大且请求频繁，FIFO算法的缓存命中率可能会较低。

2.长作业更容易导致缺页中断。

FIFO算法可能更频繁地替换长时间运行的作业所需的页面，因为长作业往往具有更大的作业集。

3.FIFO算法对缓存容量的依赖。

当缓存容量较大时，FIFO算法可以维持较高的命中率。

然而，当缓存容量有限时，FIFO算法的性能可能急剧下降。

进一步思考通过对FIFO算法模拟实验的总结，我们可以进一步思考如下问题：1.如何提高FIFO算法的性能？可以尝试引入更智能的页面置换算法，如LRU（Least Recently Used）算法，根据页面的访问频率和重要性进行置换，以提高缓存命中率。

OPT、FIFO、LRU算法的实现

OPT、FIFO、LRU算法的实现⼀、实验⽬的1. 了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中⼏种基本页⾯置换算法的基本思想和实现过程，并⽐较它们的效率。

2. 了解程序设计技术和内存泄露的原因⼆、实验内容模拟实现请求页式存储管理的⼏种基本页⾯置换算法最佳淘汰算法（OPT）先进先出的算法（FIFO）最近最久未使⽤算法（LRU）三、实验原理1. 虚拟存储系统UNIX中，为了提⾼内存利⽤率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进⾏；⼀个进程只需将其⼀部分（段或页）调⼊内存便可运⾏；还⽀持请求调页的存储管理⽅式。

当进程在运⾏中需要访问某部分程序和数据时，发现其所在页⾯不在内存，就⽴即提出请求（向CPU发出缺中断），由系统将其所需页⾯调⼊内存。

这种页⾯调⼊⽅式叫请求调页。

为实现请求调页，核⼼配置了四种数据结构：页表、页框号、访问位、修改位、有效位、保护位等。

2. 页⾯置换算法当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转⼊缺页中断处理程序。

该程序通过查找页表，得到该页所在外存的物理块号。

如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调⼊内存，然后修改页表。

如果内存已满，则须按某种置换算法从内存中选出⼀页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调⼊，修改页表。

利⽤修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。

整个页⾯的调⼊过程对⽤户是透明的。

最佳淘汰算法（OPT）：选择永不使⽤或在未来最长时间内不再被访问的页⾯予以替换。

先进先出的算法（FIFO）：选择在内存中驻留时间最久的页⾯予以替换。

最近最久未使⽤算法（LRU）：选择过去最长时间未被访问的页⾯予以替换。

3. ⾸先⽤srand( )和rand( )函数定义和产⽣指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。

（1）通过随机数产⽣⼀个指令序列，共320条指令。

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算法在特定情况下可能存在一定的局限性，需要进一步优化和改进。

【免费下载】东北大学操作系统第三次实验报告

命中次数++
被访问次数最少的
进程退出
};
int page_no;
char flag;
struct one_frame M_Frame[frame_num];
int main()
{
int i,j,k,t,m,kk,r1,r2,p1,p2;
int temp1,temp2,temp3;
int diseffect1=0,diseffect2=0;
实验 5：页面置换算法
一、题目：编程实现 FIFO 和 LRU 算法
二、目的：进一步理解父子进程之间的关系；理解内存页面调度的机理；掌握页面置换算法的实现方法；通过实验比较不同调度算法的优劣；培养综合运用所学知识的能力。页面置换算法是虚拟存储管理实现的关键，通过本次试验理解内存页面调度
int k1=0,k2=0,f1=0,f2=0;
float f;
int Access_series[total_instruction];
for(i=0; i<frame_num; i++) M_Frame[i].page_no=-1; printf("页面: ");
for(i=0; i<8; i++)
对全部高中资料试卷电气设备，在安装过程中以及安装结束后进行高中资料试卷调整试验；通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关，系电，力根通保据过护生管高产线中工敷资艺设料高技试中术卷资，配料不置试仅技卷可术要以是求解指，决机对吊组电顶在气层进设配行备置继进不电行规保空范护载高与中带资负料荷试下卷高问总中题体资，配料而置试且时卷可，调保需控障要试各在验类最；管大对路限设习度备题内进到来行位确调。保整在机使管组其路高在敷中正设资常过料工程试况中卷下，安与要全过加，度强并工看且作护尽下关可都于能可管地以路缩正高小常中故工资障作料高；试中对卷资于连料继接试电管卷保口破护处坏进理范行高围整中，核资或对料者定试对值卷某，弯些审扁异核度常与固高校定中对盒资图位料纸置试，.卷保编工护写况层复进防杂行腐设自跨备动接与处地装理线置，弯高尤曲中其半资要径料避标试免高卷错等调误，试高要方中求案资技，料术编试交写5、卷底重电保。要气护管设设装线备备置敷4高、调动设中电试作技资气高，术料课中并3中试、件资且包卷管中料拒含试路调试绝线验敷试卷动槽方设技作、案技术，管以术来架及避等系免多统不项启必方动要式方高，案中为；资解对料决整试高套卷中启突语动然文过停电程机气中。课高因件中此中资，管料电壁试力薄卷高、电中接气资口设料不备试严进卷等行保问调护题试装，工置合作调理并试利且技用进术管行，线过要敷关求设运电技行力术高保。中护线资装缆料置敷试做设卷到原技准则术确：指灵在导活分。。线对对盒于于处调差，试动当过保不程护同中装电高置压中高回资中路料资交试料叉卷试时技卷，术调应问试采题技用，术金作是属为指隔调发板试电进人机行员一隔，变开需压处要器理在组；事在同前发一掌生线握内槽图部内纸故，资障强料时电、，回设需路备要须制进同造行时厂外切家部断出电习具源题高高电中中源资资，料料线试试缆卷卷敷试切设验除完报从毕告而，与采要相用进关高行技中检术资查资料和料试检，卷测并主处且要理了保。解护现装场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况，然后根据规范与规程规定，制定设备调试高中资料试卷方案。

页面置换算法实验报告

页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程，了解不同算法的优缺点，掌握算法的实现方法，以及对算法的性能进行评估。

二、实验原理页面置换算法是操作系统中的一个重要概念，它是为了解决内存不足的问题而产生的。

当系统中的进程需要使用内存时，如果内存已经被占满，就需要将一些页面从内存中置换出去，以便为新的页面腾出空间。

页面置换算法就是用来决定哪些页面应该被置换出去的算法。

常见的页面置换算法有以下几种：1. 最佳置换算法（OPT）最佳置换算法是一种理论上的最优算法，它总是选择最长时间内不会被访问的页面进行置换。

但是，由于无法预测未来的页面访问情况，因此最佳置换算法无法在实际中使用。

2. 先进先出置换算法（FIFO）先进先出置换算法是一种简单的置换算法，它总是选择最先进入内存的页面进行置换。

但是，这种算法容易出现“抖动”现象，即频繁地将页面置换出去，然后再将其置换回来。

3. 最近最久未使用置换算法（LRU）最近最久未使用置换算法是一种比较常用的置换算法，它总是选择最长时间未被访问的页面进行置换。

这种算法可以避免“抖动”现象，但是实现起来比较复杂。

4. 时钟置换算法（Clock）时钟置换算法是一种改进的FIFO算法，它通过维护一个环形链表来实现页面置换。

当需要置换页面时，算法会从当前位置开始扫描链表，如果找到一个未被访问的页面，则将其置换出去。

如果扫描一圈后都没有找到未被访问的页面，则将当前位置的页面置换出去。

三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序，可以模拟上述四种算法的过程，并输出算法的性能指标。

程序的主要流程如下：1. 读取输入文件，获取页面访问序列和内存大小等参数。

2. 根据选择的算法，初始化相应的数据结构。

3. 遍历页面访问序列，模拟页面置换的过程。

4. 输出算法的性能指标，包括缺页率、页面置换次数等。

下面分别介绍四种算法的实现方法。

1. 最佳置换算法（OPT）最佳置换算法需要预测未来的页面访问情况，因此需要遍历整个页面访问序列，找到最长时间内不会被访问的页面。

FIFO LRU OPT页面置换算法的模拟实现(已调试)

操作系统之FIFO、LRU、OPT模拟实现1.FIFO算法#include<stdio.h>int main(int argc, char *argv[]){int i,j,k,k2,t;int n1; //memory page numberint n2; //requested page numberint pageseq[100]; //access page sequenceint mempages[10][2]; //memory pages//mempages[i][0] is page NO, mempages[i][1] is loading sequence No.int n3; //number of loaded pages in memoryint n4; //missing pages countint replacedPage;//Input dataprintf("Input memory page number for each process:");scanf("%d",&n1);if(n1<1){printf("Memory page number error!\n");return 1;}printf("Now, Input page access sequence.\n");printf("Input requested page number firstly:");scanf("%d",&n2);printf("%d pages are waiting for access.\n",n2);for(i=0 ;i<n2; i++){printf("%d-th page is:",i+1);scanf("%d",&t);pageseq[i] = t;}//FIFOn3 = 0;//number of loaded pages in memoryn4 = 0;//missing page count//replace pagesfor(i = 0; i<n2; i++){for(j = 0 ;j<n3; j++){if(mempages[j][0] == pageseq[i]) //page is in memorybreak;}if(j == n3 && n3 < n1) //not found in memory,but there are empty memory pages{mempages[n3][0] = pageseq[i];mempages[n3][1] = i+1;n3++;n4++;}else if(j == n3) //page is not in memory,pick up one for replacement{//find the page with minimal loading sequence No.int minv;minv = mempages[0][1];k2 = 0;for(k=1; k<n3; k++){if(minv > mempages[k][1]){k2 = k;minv = mempages[k][1];}}//replace mempages[k2][0] by pageseq[i]replacedPage = mempages[k2][0];mempages[k2][0] = pageseq[i];mempages[k2][1] = i+1;n4++; //missing page countingprintf("page %d in, page %d out. %d-th missing page.\n",pageseq[i],replacedPage,n4);}else{//page is in memoryprintf("page %d is in memory.\n",pageseq[i]);}}printf("Totally %d missing pages!\n",n4);return 0;}2.LRU#include<stdio.h>int main(int argc, char *argv[]){int i,j,k,k2,t;int n1; //memory page numberint n2; //requested page numberint pageseq[100]; //access page sequenceint mempages[10][2]; //memory pages//mempages[i][0] is page NO, mempages[i][1] is loading sequence No.int n3; //number of loaded pages in memoryint n4; //missing pages countint replacedPage;//Input dataprintf("Input memory page number for each process:");scanf("%d",&n1);if(n1<1){printf("Memory page number error!\n");return 1;}printf("Now, Input page access sequence.\n");printf("Input requested page number firstly:");scanf("%d",&n2);printf("%d pages are waiting for access.\n",n2);for(i=0 ;i<n2; i++){printf("%d-th page is:",i+1);scanf("%d",&t);pageseq[i] = t;}//LRUn3 = 0;//number of loaded pages in memoryn4 = 0;//missing page count//replace pagesfor(i = 0; i<n2; i++){for(j = 0 ;j<n3; j++){if(mempages[j][0] == pageseq[i]) //page is in memory{mempages[j][1]=i+1;break;}}if(j == n3 && n3 < n1) //not found in memory,but there are empty memory pages{mempages[n3][0] = pageseq[i];mempages[n3][1] = i+1;n3++;n4++;}else if(j == n3) //page is not in memory,pick up one for replacement{//find the page with minimal loading sequence No.int minv;minv = mempages[0][1];k2 = 0;for(k=1; k<n3; k++){if(minv > mempages[k][1]){k2 = k;minv = mempages[k][1];}}//replace mempages[k2][0] by pageseq[i]replacedPage = mempages[k2][0];mempages[k2][0] = pageseq[i];mempages[k2][1] = i+1;n4++; //missing page countingprintf("page %d in, page %d out. %d-th missing page.\n",pageseq[i],replacedPage,n4);}else{//page is in memoryprintf("page %d is in memory.\n",pageseq[i]);}}printf("Totally %d missing pages!\n",n4);return 0;}3.OPT#include<stdio.h>int main(int argc, char *argv[]){int i,j,k,k2,t;int n1; //memory page numberint n2; //requested page numberint pageseq[100]; //access page sequenceint mempages[10][2]; //memory pages//mempages[i][0] is page NO, mempages[i][1] is loading sequence No.int n3; //number of loaded pages in memoryint n4; //missing pages countint replacedPage;//Input dataprintf("Input memory page number for each process:");scanf("%d",&n1);if(n1<1){printf("Memory page number error!\n");return 1;}printf("Now, Input page access sequence.\n");printf("Input requested page number firstly:");scanf("%d",&n2);printf("%d pages are waiting for access.\n",n2);for(i=0 ;i<n2; i++){printf("%d-th page is:",i+1);scanf("%d",&t);pageseq[i] = t;}//FIFOn3 = 0;//number of loaded pages in memoryn4 = 0;//missing page count//replace pagesfor(i = 0; i < n2; i++){for(j = 0 ;j < n3; j++){if(mempages[j][0] == pageseq[i]) //page is in memorybreak;}if(j == n3 && n3 < n1) //not found in memory,but there are empty memory pages{mempages[n3][0] = pageseq[i];mempages[n3][1] = i+1;n3++;n4++;}else if(j == n3) //page is not in memory,pick up one for replacement{//find the page with minimal loading sequence No.int max;int t;for(j = 0 ;j < n3; j++){for( t = i+1; t < n2; t++){if( mempages[j][0] == pageseq[t] ){mempages[j][1] = t;break;}}if( t == n2 )mempages[j][1] = n2+1;}//int max;max = mempages[0][1];k2 = 0;for(k=1; k<n3; k++){if( mempages[k][1] > max ){k2 = k;max = mempages[k][1];}}//replace mempages[k2][0] by pageseq[i]replacedPage = mempages[k2][0];mempages[k2][0] = pageseq[i];//mempages[k2][1] = i+1;n4++; //missing page countingprintf("page %d in, page %d out. %d-th missing page.\n",pageseq[i],replacedPage,n4);}else{//page is in memoryprintf("page %d is in memory.\n",pageseq[i]);}}printf("Totally %d missing pages!\n",n4);return 0;}。

操作系统实验报告3

操作系统实验报告——（存储器管理实验）一、实验目的（1）理解内存页面调度的机理（2）掌握几种理论页面置换算法的实现方法（3）了解HASH数据结构的使用（4）通过实验比较几种调度算法的性能优劣页面置换算法是虚拟存储管理实现的关键，通过本次实验理解内存页面调度的机制，在模拟实现FIFO、LRU、NRU和OPT几种经典页面置换算法的基础上，比较各种页面置换算法的效率及优缺点，从而了解虚拟存储实现的过程。

二、实验内容对比以下几种算法的命中率：（1）先进先出算法FIFO（First In First Out）（2）最近最少使用算法LRU（Least Recently Used）（3）最近未使用算法NUR（Never Used Recently）（4）最佳置换算法OPT（Optimal Replacement）三、实验原理1.FIFO算法a)在分配内存页面数（AP）小天进程页面数（PP）时，当然是最先运行的AP个页面放入内存；b)这时又需要处理新的页面，则将原来放的内存中的AP个页中最先进入的调出（FIFO），再将新页面放入；以后如果再有新页面需要调入，则都按上述规则进行。

算法特点：所使用的内存页面构成一个队列。

2.LRU算法（1）当内存分配页面数（AP）小于进程页面数（PP）时，把最先执行的AP个页面放入内存。

（2）当需调页面进入内存，而当前分配的内存页面全部不空闲时，选择将其中最长时间没有用到的那一页调出，以空出内存来放置新调入的页面（LRU）。

算法特点：每个页面都有属性来表示有多长时间未被CPU使用的信息。

3.NUR算法所谓“最近未使用”，首先是要对“近”做一个界定，比如CLEAR_PERIOD=50，便是指在CPU 最近的50次进程页面处理工作中，都没有处理到的页面。

那么可能会有以下几种情况：（1）如果这样的页面只有一个，就将其换出，放入需要处理的新页面。

（2）如果有这样的页面不止一个，就在这些页面中任取一个换出（可以是下标最小的或者最小的），放入需要处理的页面。

实验三页面置换算法

操作系统实验报告班级：姓名：学号：实验三：页面置换算法一、实验目的1、熟悉内存分页管理策略。

2、编写OPT、FIFO、LRU，LFU四种置换算法并模拟实现。

3、锻炼知识的运用能力和实践能力。

二、实验内容设计主界面，输入一串系列模拟页面请求，实现以下算法：1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。

2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。

4) 最不经常使用算法(LFU)三、代码及运行结果分析#include <stdio.h>#include <stdlib.h>int mSIZE;int pSIZE;static int memery[10]={0};static int page[100]={0};static int temp[100][10]={0};void FIFO();void LRU();void OPT();void print(unsigned int t);void read();void mDelay(unsigned int Delay);int main(){int i,k,code;printf("请输入物理块的个数(M<=10)：");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100)："); scanf("%d",&pSIZE);puts("请依次输入页面号引用串：");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);read();do{puts("输入的页面号引用串为：");for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}}printf("---------------------------------------------\n");printf("* 请选择页面置换算法：\t\t\t *\n");printf("* ----------------------------------------- *\n");printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n"); printf("* 3.最佳(OPT) 4.退出*\n");printf("--------------------------------------------\n");printf("请选择操作：[ ]\b\b");scanf("%d",&code);switch(code){case 1:FIFO();break;case 2:LRU();break;case 3:OPT();break;case 4:system("cls");exit(0);default:printf("输入错误，请重新输入：");}printf("按任意键重新选择置换算法：>>>"); getchar();}while (code!=4);getchar();}void read(){int i;for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++) {mDelay((pSIZE+mSIZE)/2);printf(">"); }printf("获取成功，按任意键进入置换算法选择界面：");getchar(); }void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}void print(unsigned int t) {int i,j,k,l;int flag;for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1))) printf("%d\n",page[i]);elseprintf(" %d ",page[i]);}for(j=0;j<mSIZE;j++){for(i=20*k;(i<mSIZE+20*k)&&(i<pSIZE);i++) {if(i>=j)printf(" |%d|",temp[i][j]);elseprintf(" | |");}for(i=mSIZE+20*k;(i<pSIZE)&&(i<20*(k+1));i++) { for(flag=0,l=0;l<mSIZE;l++)if(temp[i][l]==temp[i-1][l])flag++;if(flag==mSIZE)/*页面在物理块中*/printf(" ");elseprintf(" |%d|",temp[i][j]);}if(i%20==0)continue;printf("\n");}}printf("----------------------------------------\n");printf("缺页次数：%d\t\t",t+mSIZE);printf("缺页率：%d/%d\n",t+mSIZE,pSIZE);printf("置换次数：%d\t\t",t);printf("访问命中率：%d%%\n",(pSIZE-(t+mSIZE))*100/pSIZE); printf("----------------------------------------\n");}/*计算过程延迟*/void compute(){int i;printf("正在进行相关计算，请稍候");for(i=1;i<20;i++){mDelay(15);if(i%4==0)printf("\b\b\b\b\b\b \b\b\b\b\b\b"); elseprintf("...");}for(i=0;i++<30;printf("\b"));for(i=0;i++<30;printf(" "));for(i=0;i++<30;printf("\b"));}void FIFO(){int memery[10]={0};int time[10]={0};int i,j,k,m;int max=0;int count=0;for(i=0;i<mSIZE;i++){memery[i]=page[i];time[i]=i;for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++) {for(j=0,k=0;j<mSIZE;j++) {if(memery[j]!=page[i])k++;}if(k==mSIZE){count++;max=time[0]<time[1]?0:1; for(m=2;m<mSIZE;m++) if(time[m]<time[max]) max=m;memery[max]=page[i]; time[max]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}/*最近最久未使用置换算法*/void LRU(){int memery[10]={0};int flag[10]={0}; /*记录页面的访问时间*/ int i,j,k,m;int max=0;int count=0;for(i=0;i<mSIZE;i++){memery[i]=page[i];flag[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;elseflag[j]=i;}if(k==mSIZE){count++;max=flag[0]<flag[1]?0:1;for(m=2;m<mSIZE;m++)if(flag[m]<flag[max])max=m;memery[max]=page[i];flag[max]=i; /*记录该页的访问时间*/temp[i][j]=memery[j]; }else{for(j=0;j<mSIZE;j++) temp[i][j]=memery[j]; }}compute();print(count);}void OPT(){int memery[10]={0}; int next[10]={0};int i,j,k,l,m;int max;int count=0;for(i=0;i<mSIZE;i++) {memery[i]=page[i];temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++) {for(j=0,k=0;j<mSIZE;j++) {if(memery[j]!=page[i])k++;}if(k==mSIZE){count++;for(m=0;m<mSIZE;m++) {for(l=i+1;l<pSIZE;l++)if(memery[m]==page[l]) break;next[m]=l;}max=next[0]>=next[1]?0:1;for(m=2;m<mSIZE;m++) if(next[m]>next[max]) max=m;for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}else {for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}}compute();print(count);}四、实验心得。

巡回置换算法实验结论

巡回置换算法实验结论巡回置换算法是一种常见的页面置换算法，被广泛应用于操作系统中的虚拟存储管理中，用于优化页面的访问效率。

该算法以首次使用最远（Furthest In Use）的页面为置换对象，通过淘汰最长时间未被访问的页面，以提高整体访问效率。

在巡回置换算法的实验中，我们对比了三种不同的页面置换算法，分别是先进先出算法（FIFO）、最近最少使用算法（LRU）和巡回置换算法（CLOCK），通过模拟虚拟存储管理中的页面置换情况，观察和分析了三种算法的性能表现。

实验结果如下：首先，对于随机访问的情况（Random Access），我们发现巡回置换算法的性能要优于FIFO算法，但略逊于LRU算法。

这是因为巡回置换算法相较于FIFO算法，能够更好地应对随机性的访问模式，通过选择使用时间最长的页面进行置换，避免了过多未被访问的页面进入内存，降低了缺页率。

然而，与LRU算法相比，巡回置换算法的性能略有不足，因为LRU算法能够更准确地判断页面的使用频率，倾向于保留长时间内未使用的页面，同时淘汰不常使用的页面，因此在随机访问的场景下相对更为优秀。

其次，在局部性访问的情况下（Locality Access），我们发现巡回置换算法的性能相比FIFO算法和LRU算法，都有一定程度的提升。

这是因为局部性原理指出，在程序的执行中，会出现时间上的局部性和空间上的局部性。

巡回置换算法能够更好地利用时间上的局部性，保留使用时间更长的页面，从而提高命中率，减少了缺页次数。

与此相比，FIFO算法只根据页面的进入先后进行置换，无法有效地利用程序执行的局部性特征；而LRU算法需要维护页面的访问顺序，消耗较大的计算资源。

最后，在算法开销（Algorithm Overhead）方面，巡回置换算法的开销相对较低。

FIFO算法的开销主要集中在更新页面队列的操作，需要频繁地调整队列中页面的顺序；LRU算法的开销则在于维护每个页面的访问时间戳，需要不断地更新时间戳信息。

实验3、FIFO算法模拟

实验三、FIFO LRU算法模拟一、实验目的一个作业有多个进程，处理机只分配固定的主存块供该作业执行。

往往块数小于进程页数，当请求调页程序调进一个块时，可能碰到主存中并没有空闲块的情况，此时就产生了在主存中淘汰哪个块的情况。

本实验要求模拟FIFO算法/二、实验原理此算法的实质是，总是选择在主存中停留最长时间的页面淘汰。

理由是：最早调入主存的页，其不再被访问的可能性最大。

三、实验环境1、pc2、vc++四、程序源代码：#define MAXSIZE 20#include <iostream.h>void main(){int label=0; //标记此页是否已经装入内存int input=0; //用于输入作业号int worknum=0; //记录作业个数int storesize=0; //系统分配的存储块数int interrupt=0; //中断次数int quence[MAXSIZE]; //队列，FIFO算法的主要数据结构int workstep[MAXSIZE]; //用于记录作业走向/*初始化*/for(int i=0;i<MAXSIZE;i++){quence[i]=0;workstep[i]=0;}cout<<"请输入存储区块数：";cin>>storesize;cout<<"请输入作业走向（输入0结束）：\n";for(int j=0;j<MAXSIZE;j++){cout<<"页面号："<<j+1<<” :”;cin>>input;workstep[j]=input;if(input==0){cout<<"输入结束！\n";break;}worknum++;}if(workstep[0]==0){cout<<"未输入任何作业，系统将退出！\n";return;}cout<<"置换情况如下：\n";for(int k=0;k<worknum;k++){label=0;/*看队列中是否有相等的页号或空位置*/for(int l=0;l<storesize;l++){/*是否有相等的页号*/if(quence[l]==workstep[k]){cout<<"内存中有"<<workstep[k]<<"号页面，无须中断！\n";label=1; //标记此页面已装入内存break;}/*是否有空位置*/if(quence[l]==0){quence[l]=workstep[k];cout<<"发生中断,但内存中有空闲区，"<<workstep[k]<<"号页面直接调入！\n";interrupt++;label=1;break;}}/*上述情况都不成立则调出对首，将调入页面插入对尾*/if(label==0){cout<<"发生中断，将"<<quence[0]<<"号页面调出，"<<workstep[k]<<"号装入！\n";interrupt++;for(int m=0;m<storesize;m++){quence[m]=quence[m+1];}quence[storesize-1]=workstep[k];}}cout<<"作业"<<worknum<<"个，"<<"中断"<<interrupt<<"次，"<<"缺页率："<<float(interrupt)/float(worknum)*100<<"%\n";}用高级语言模拟页面置换算法LRU，加深对LRU算法的认识。

页面调度算法实验报告

页面调度算法实验报告引言页面调度算法是操作系统中的重要概念之一，主要用于管理操作系统中的虚拟内存。

虚拟内存是指通过硬盘空间来扩展系统的可用内存空间，将一部分数据放在内存中，将另一部分数据放在硬盘上。

为了高效地管理虚拟内存，需要使用合适的页面调度算法。

在本次实验中，我们将实现三种页面调度算法：先进先出（FIFO），最近最久未使用（LRU），和时钟（Clock）算法。

通过对这些算法的实现和比较，我们将能够更好地理解页面调度算法的原理和效果。

算法介绍1. 先进先出（FIFO）算法：该算法是最简单的页面调度算法之一。

它按照页面进入内存的先后顺序决定删除哪个页面，即最早进入内存的页面被删除。

该算法不考虑页面的使用频率和重要性。

2. 最近最久未使用（LRU）算法：该算法是一种根据页面的使用历史来进行页面调度的算法。

它假设最近一段时间内最久未使用的页面很可能在未来也不会被使用，因此将这些页面优先删除。

3. 时钟（Clock）算法：该算法是一种综合了FIFO算法和LRU算法的页面调度算法。

它使用一个环形链表来存储页面，并使用一个指针指向当前时钟。

当发生页面调度时，指针按照顺时针方向移动，并检查每个页面的访问位。

如果访问位为0，则说明该页面最近未被使用，可以删除；如果访问位为1，则将访问位置为0，表示该页面最近被使用。

实验设计本次实验中，我们将使用python语言实现上述三种页面调度算法，并通过相同的测试数据对它们进行性能比较。

环境配置在开始实验之前，需要安装Python 3.0及以上版本，并确保环境配置正确。

测试数据我们将使用一个虚拟内存大小为4个页面的系统来测试算法的性能。

假设系统会访问一个包含10个页面的访问序列。

访问序列：1, 2, 3, 4, 5, 1, 2, 6, 7, 8实验步骤1. 实现FIFO算法，并对测试数据进行页面调度。

2. 实现LRU算法，并对测试数据进行页面调度。

3. 实现时钟算法，并对测试数据进行页面调度。

页面置换算法实践报告

页面置换算法实践报告页面置换算法（Page Replacement Algorithm）是操作系统中用于管理虚拟内存的重要算法之一。

其目的是在有限的物理内存空间中，将进程所需的页面加载到内存中，并根据一定的策略替换掉不再被使用的页面，以提高内存利用率和系统性能。

在本次实践报告中，我将重点介绍三种常见的页面置换算法：先进先出（FIFO）、最近最久未使用（LRU）和最不经常使用（LFU）。

先进先出（FIFO）算法是最简单的页面置换算法之一。

它根据页面进入内存的先后顺序进行页面置换。

当一个页面需要被替换时，选择最早进入内存的页面进行替换。

虽然FIFO算法的实现简单，但它无法很好地反映页面的使用频率和重要性，容易发生“缺页率抖动”的问题。

缺页率抖动指的是在某些场景下，缺页率会频繁地快速上升，然后又快速下降。

最近最久未使用（LRU）算法是一种基于页面历史访问记录的页面置换算法。

它认为最近被访问过的页面是最有可能在未来被访问的，因此选择最近最久未使用的页面进行替换。

LRU算法可以较为准确地反映页面的使用频率，避免了FIFO算法的缺点。

但由于需要记录页面的访问历史，因此实现相对复杂，需要额外的开销。

最不经常使用（LFU）算法是一种基于页面使用频率的页面置换算法。

它认为使用频率最低的页面是最不重要的，因此选择最不经常使用的页面进行替换。

LFU算法可以较好地反映页面的使用频率，对于一些热点页面和冷门页面的处理较为准确。

但由于需要记录页面的使用次数，因此实现相对复杂，需要额外的开销。

根据实际情况选择合适的页面置换算法对于系统的性能影响非常重要。

一般来说，FIFO算法比较适用于缺页率较低的情况，而LRU算法则适用于需要较高精确度的场景，而LFU算法则适用于需要特别关注页面使用频率的场景。

在实践中，我们可以使用模拟算法来进行页面置换算法的实验。

通过构造不同的页面访问序列，我们可以测试不同算法的效果并进行比较。

在实验过程中，我们可以观察不同算法的缺页率、替换次数、访问延迟等指标，以评估算法的性能。

操作系统fifo算法模拟实验总结

操作系统fifo算法模拟实验总结在操作系统中的FIFO(先进先出)算法是一种重要的数据管理和排序技术,可以让进程或线程在读写数据时按照特定的顺序进行,从而提高数据的效率和可靠性。

本文通过模拟实验验证了操作系统中的FIFO算法的正确性。

实验环境:我们选择了Linux操作系统作为实验环境,使用FIFO算法对一组数据进行了排序。

这组数据的的大小是随机生成的,每个数据文件的大小相等,为100KB。

实验步骤:1. 创建FIFO文件使用Linux的系统命令创建一个新的FIFO文件,文件名和大小都是随机生成的。

```FIFO=FIFO_data.txt # 文件名FIFO_size=1000000 # 文件大小FIFO_num_files=5 # 进程数```2. 进入FIFO文件使用Linux的系统命令进入FIFO文件,可以使用&符号表示“同时进入”多个进程。

```FIFO_entry=FIFO_data.txt&```3. 读取FIFO文件的内容并排序使用Linux的系统命令读取FIFO文件中的数据,并将其存储到一个整数数组中。

然后,使用Linux的排序命令对数据进行排序。

```arr=( 9854).txt( 9855).txt(9856).txt(9857).txtsort -k2,2 -s arr```4. 输出FIFO文件的内容使用Linux的系统命令将FIFO文件的内容输出到标准输出(stdout)中。

```FIFO_entry=FIFO_data.txt>/dev/null```5. 验证FIFO排序结果使用Linux的命令验证FIFO排序结果是否正确。

我们可以使用Linux的管道命令来比较两个文件的大小,如下所示:```ls FIFO_data.txtFIFO_data.txt:total 64-rw-r--r-- 1 user group 64 Feb 18 18:19 mydata.txtls -l /home/user/FIFO_data.txtlrwx------ 1 user group 10 Feb 18 18:19 mydata.txt -> /home/user/FIFO_data.txt```可以看到,FIFO排序后的结果与标准输出中显示的结果一致。

操作系统—页面置换算法实验报告

操作系统—页面置换算法实验报告本报告旨在介绍操作系统中的页面置换算法，包括实验的目的和背景以及页面置换算法的概念和作用。

本实验旨在描述实验环境以及所使用的页面置换算法，包括FIFO、LRU、OPT等。

同时，还会详细介绍实验步骤和设置的参数。

实验环境操作系统：Windows 10编程语言：C++开发环境：Visual。

2019页面置换算法FIFO（First-In-First-Out）算法：按照先进先出的原则置换页面，最早进入内存的页面会被置换出去。

LRU（Least Recently Used）算法：根据页面的使用情况，置换最长时间没有被访问过的页面。

OPT（Optimal）算法：理论上最优的页面置换算法，根据未来一段时间内页面的访问情况，选择最少使用的页面进行置换。

实验步骤创建一个模拟操作系统的C++程序。

设定内存大小、页面大小和页面数等参数。

实现FIFO算法，将其应用于模拟操作系统中的页面置换过程。

实现LRU算法，将其应用于页面置换过程。

实现OPT算法，将其应用于页面置换过程。

运行模拟程序，观察不同页面置换算法的效果。

分析比较不同算法的页面置换结果，评估其优缺点。

参数设置内存大小：512MB页面大小：4KB页面数：128以上是本次实验的实验设计，将通过创建模拟操作系统程序，实现FIFO、LRU和OPT等页面置换算法，并对其结果进行比较和评估。

本实验展示了页面置换算法的不同性能，并分析了各种算法的优缺点。

实验结果表明，不同的页面置换算法对系统性能有显著影响。

以下是对各种算法的性能分析：先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。

优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。

先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。

优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。

页面置换算法实验总结

页面置换算法实验总结
在操作系统中，页面置换算法是为了解决内存不足的问题，当内存中的页面不足时，需要选择一些页面进行置换，将其换出到磁盘上，从而为新的页面腾出空间。

在本次实验中，我实现了三种页面置换算法，分别是FIFO（先进先出）、LRU（最近最少使用）和OPT（最佳置换）。

下面是对这三种算法的总结：
1. FIFO算法：FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。

实验结果显示，FIFO算法在某些情况下可能会导致“抖动”现象，即不断发生页面置换，性能较差。

2. LRU算法：LRU算法是根据页面的使用历史进行置换，将最长时间没有被使用的页面置换出去。

实验结果显示，LRU算法相比于FIFO算法在减少页面抖动方面表现更好，但是实现起来较为复杂，需要维护一个访问历史记录的数据结构。

3. OPT算法：OPT算法是一种理想情况下的页面置换算法，它通过预测未来的页面访问情况来选择最佳的页面进行置换。

实验结果显示，OPT算法在减少页面抖动方面表现最好，但是实现起来较为困难，需要对未来的页面访问情况进行预测。

综上所述，不同的页面置换算法在不同的场景下有着不同的表现。

FIFO算法简单易实现，但性能较差；LRU算法在某些情况下能够较好地减少页面抖动；OPT算法在理论上是最佳的页面置换算法，但实现起来较为困难。

实际中的选择需要根据具体的应用场景
和系统需求来确定。