课程设计 页面置换算法--先进先出算法

淮阴工学院操作系统课程设计报告选题名称:页面置换算法系（院）:管理工程学院专业:信息管理与信息系统班级:信管1131姓名:周夏青、张婷婷学号: 1131807102、1131807103指导教师:陆华奇、邱军林学年学期:2015~ 2016学年第1学期2015 年12 月20 日页面置换算法——先进先出算法一、实验目的“操作系统课程设计”是理解和巩固操作系统基理论、原理和方法的重要实践环节。

主要任务是实现操作系统和相关系统软件的设计，其中涉及进程创建，同步，进程间通信，存储管理，文件系统等操作系统概念。

先进先出算法给出页面访问的顺序与分配给作业的主存块数，使用队列作为数据结构编写算法，实现统计缺页次数与页面置换操，用C语言编程并用文档形式给出算法分析与实现过程。

二、实验要求1、输入当前要调用的页面号a[i]2、判断该页面是否已在队列内，（1）若在队列内，不执行任何操作（2）若不在队列内。

则执行以下操作3、判断队列是否已满（1）若队列未满，直接把该页面号a[i]存入队列（2）若队列已满，删除并返回队头元素，然后把该页面号a[i]存入队列4、输出置换次数，依次输出置换出的页面三、实验内容FIFO算法总是淘汰最先调入主存的页面，即淘汰在主存中驻留时间最长的页面，认为驻留时间最长的页不再使用的可能性较大。

代码如下：#include<stdio.h>#define M 24#define N 4void FIFO(int a[N],int b[M]){int i,j,k;int c[M]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; float s;for(i=0;i<N;i++){a[i]=b[i];for(j=0;j<=i;j++){printf("%d ",a[j]);}printf("\n");}k=N;for(j=N;j<M;j++){for(i=0;i<N;i++)if(b[j]==a[i]){c[j]=1;break;}if(c[j]==1){for(i=0;i<N;i++)printf("%d ",a[i]);}if(c[j]==0){ a[k%N]=b[j];k++;for(i=0;i<N;i++)printf("%d ",a[i]);}printf("\n"); }s=k*1.0/M;printf("中断次数为：%d\n",k);printf("缺页率为：%f\n",s);}void main(){ int a[N]={0,0,0,0};int b[M]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1,5,2,6,4}; FIFO(a,b);}（如图1-2）图 1图 2其运行结果如下：图3若改变置换总次数，其运行如下：（如图4-6）图 4图 5图 6若改变物理块，其运行结果如下：（如图7-9）图7图8图9由结果可以看出,使用FIFO算法，总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面以淘汰。

目录一、课程设计目的及要求 (1)二、相关知识 (1)三、题目分析 (2)四、概要设计 (3)五、代码及流程 (3)六、运行结果 (7)七、设计心得 (8)八、参考文献 (9)一、课程设计目的及要求页面置换算法实验目的：深入掌握内存调度算法的概念原理和实现方法。

设计要求：编写程序实现：1）先进先出页面置换算法（FIFO）2）最近最久未使用页面置换算法（LRU）3）最佳置换页面置换算法（OPT）演示页面置换的三种算法。

二、相关知识2.1 先进先出（FIFO）算法这是最早出现的置换算法。

该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总指向最老的页面。

但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO算法并不能保证这些页面不被淘汰。

2.2 最近最久未使用（LRU）算法FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。

最近最久未使用（LRU）的页面置换算法，是根据页面调入内存后的使用情况进行决策的。

由于无法预测各页将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。

2.3 最佳（Optimal）算法最佳置换算法是由Belady于1966年提出的一种理论上的算法。

其所选择的被淘汰的页面，将是以后永不使用的，或是在最长（未来）时间内不再被访问的页面。

采用最佳置换算法，通常可保证获得最低的缺页率。

但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是将来最长时间内不再访问的，因而该算法时无法实现的，但可以利用该算法评价其他算法。

java页面置换算法课程设计一、课程目标知识目标：1. 理解页面置换算法的基本概念和作用；2. 掌握常见的页面置换算法，如先进先出（FIFO）、最近最少使用（LRU）和最佳置换（OPT）等；3. 学会分析不同置换算法的优缺点和适用场景；4. 了解虚拟内存中的页面置换策略在实际操作系统中的应用。

技能目标：1. 能够运用Java编程语言实现基本的页面置换算法；2. 培养学生运用数据结构和算法解决问题的能力；3. 提高学生的编程实践能力和调试技巧；4. 培养学生通过分析问题，选择合适算法解决实际问题的能力。

情感态度价值观目标：1. 培养学生对计算机操作系统中内存管理知识的兴趣和好奇心；2. 增强学生的团队合作意识，培养协同解决问题的能力；3. 培养学生面对复杂问题时的耐心和毅力，树立克服困难的信心；4. 引导学生认识到技术发展对社会进步的重要性，激发他们的社会责任感。

课程性质：本课程为计算机科学专业高年级的学科核心课程，旨在帮助学生掌握页面置换算法的理论知识，并通过实践提高编程技能。

学生特点：学生已具备一定的编程基础和操作系统知识，具备独立分析和解决问题的能力。

教学要求：结合课程性质和学生特点，注重理论与实践相结合，强调动手实践，鼓励学生思考和探讨。

通过本课程的学习，使学生能够将所学的页面置换算法应用于实际问题的解决，提高其综合素质。

二、教学内容1. 页面置换算法概述- 页面置换算法的定义及作用；- 页面置换算法在操作系统中的应用场景。

2. 常见页面置换算法原理与实现- 先进先出（FIFO）算法；- 最近最少使用（LRU）算法；- 最佳置换（OPT）算法；- 最久未用（MFU）算法。

3. 页面置换算法的性能分析- 不同算法的性能指标（如缺页率、置换次数等）；- 分析各种算法的优缺点及适用场景。

4. Java实现页面置换算法- Java编程环境的搭建；- 使用Java实现上述常见页面置换算法；- 编程实践：编写测试用例，测试并比较不同算法的性能。

列举5种页置换算法
1. 先进先出（First-In-First-Out，FIFO）算法：最早进入内存的页将被替换出去，是最简单的页面置换算法，但也存在缺点，即无法区分页的重要性和频繁使用程度。

2. 最近最久未使用（Least Recently Used，LRU）算法：根据页的最近使用时间来进行置换，即替换最久未被使用的页，相对于FIFO算法，能更好地利用页的使用频率。

3. 最不经常使用（Least Frequently Used，LFU）算法：根据页的使用次数来进行置换，即替换使用次数最少的页，可以更好地适应动态变化的访问模式。

4. 最佳置换（Optimal）算法：根据将来的访问模式进行置换，即替换将来不再使用的页，由于需要预先预测访问模式，实现较为困难。

5. 时钟（Clock）算法：将页的状态标记为是否被访问过，以一个类似时钟的数据结构进行循环检测，置换未被访问过的页。

1)先进先出淘汰算法（FIFO）⏹基本思想：总是淘汰最先调入主存的那一页，或者说在主存中驻留时间最长的那一页（常驻的除外）。

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

比如顺序程序，执行过的指令可能就不再需要了。

⏹特点：实现简单、适合线性访问、对其他情况效率不高。

⏹异常情况：在某些情况下会出现分配给进程的页面数增多，缺页次数反而增加的奇怪现象。

（Belady现象）2)最近最少使用的先淘汰（LRU）⏹基本思想：淘汰的页面是在最近一段时间里较久未被访问的那页。

⏹理由：根据程序局部性原理，那些刚被使用过的页面，可能马上还要被使用，而在较长时间里未被使用的页面，可能不会马上使用到。

3)最近不用的先淘汰（NUR）⏹基本思想：需要在页表中设一“引用位”，当页面被访问时，该位由硬件自动置为1，而由页面管理程序周期地把所有引用位置为0。

⏹优点：比较简单，易于实现。

⏹缺点：周期大小不易确定。

4)最佳淘汰算法（OPT）⏹算法：调入一页而必须淘汰一个旧页时，所淘汰的页应该是以后不再访问的页或距现在最长时间后再访问的页。

⏹特点：不是实际可行的算法，可用来作为衡量各种具体算法的标准，具有理论意义。

例⏹在一个请求分页系统中，假定系统分给一个作业的物理块数为3，并且此作业的页面走向为2，3，2，1，5，2，4，5，3，2，5，2，用FIFO、LRU和OPT计算缺页。

1）使用FIFO算法用FIFO算法，缺页数为9例2）使用LRU算法用FIFO算法，缺页数为7例3）使用OPT算法用FIFO算法，缺页数为6从中可以看到：LRU算法最接近OPT。

这表明LRU是优于FIFO的。

页面置换算法模拟1、设计目的通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储的特点，掌握请求页式存储管理中的页面置换算法。

2、任务及要求2.1 设计任务模拟实现先进先出算法（FIFO）、最近最少使用算法（LRU）、最优页置换算法（OPT），并计算命中率。

2.2 设计要求2.2.1 首先用随机数生成函数产生“指令”序列，然后将指令序列变换成相应的页地址流，再计算不同算法下的命中率。

2.2.2 通过随机数产生一个指令序列，共产生400条。

其中50%的指令是顺序执行的，且25%的指令分布在前半部分地址空间，25%的指令分布在后半部分地址空间。

2.2.3 将指令地址流变换成页地址流2.2.4 循环运行，使用户内存容量从4到40,。

计算每个内存容量下不同页面置换算法的命中率。

3、算法及数据结构3.1算法的总体思想（流程）struct Pro{int num,time;};int a[total_instruction];int page[N];//调用函数int Search(int e,Pro *page1 ){Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++){if(e==page[i].num)return i;}return -1;}void Input(Pro p[total_instruction]){int m,i,m1,m2;srand((unsigned int )time(NULL));m=rand()%400;for(i=0;i<total_instruction;) //产生指令队列{if(m<0||m>399){printf("When i==%d,Error,m==%d\n",i,m);exit(0);}a[i]=m; //任选一指令访问点ma[i+1]=a[i]+1;a[i+2]=a[i]+2; //顺序执行两条指令m1=rand( )%m; //执行前地址指令m1a[i+3]=m1;a[i+4]=m1+1;a[i+5]=m1 + 2;//顺序执行两条指令m2 = rand()%(157-m1)+m1+3;a[i+6]=m2;if( (m2+2) > 159 ){a[i+7] = m2+1;i +=8;}else{a[i+7] = m2+1;a[i+8] = m2+2;i = i+9;}m = rand()%m2;}//forfor(i=0;i<total_instruction;i++) //将指令序列变换成页地址流{p[i].num=a[i]/10;p[i].time = 0;}}3.2先进先出算法（FIFO）模块3.2.1 功能根据页地址流，采用先进先出的算法进行页面置换。

信息与计算科学《操作系统实验》课程设计报告题目: 页面置换方法班级：学号：姓名：时间： 2011/01/05【课设题目】：设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率【课设要求】：要求设计主界面以灵活选择某算法，且以下算法都要实现1）先进先出算法（FIFO）2）最近最久未使用算法（LRU）3）最佳置换算法（OPT）【课设目的】：1、用C语言编写OPT、FIFO、LRU三种置换算法。

2、熟悉内存分页管理策略。

3、了解页面置换的算法。

4、掌握一般常用的调度算法。

5、根据方案是算法得以模拟实现。

【主要思想】：先进先出算法（FIFO）最简单的页面置换算法是先入先出（FIFO）法。

这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。

理由是：最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。

建立一个FIFO队列，收容所有在内存中的页。

被置换页面总是在队列头上进行。

当一个页面被放入内存时，就把它插在队尾上。

这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不高。

因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。

FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。

当然，导致这种异常现象的页面走向实际上是很少见的。

最近最久未使用算法（LRU）FIFO算法和OPT算法之间的主要差别是，FIFO算法利用页面进入内存后的时间长短作为置换依据，而OPT算法的依据是将来使用页面的时间。

如果以最近的过去作为不久将来的近似，那么就可以把过去最长一段时间里不曾被使用的页面置换掉。

它的实质是，当需要置换一页时，选择在最近一段时间里最久没有使用过的页面予以置换。

这种算法就称为最久未使用算法（Least Recently Used，LRU）。

LRU算法是与每个页面最后使用的时间有关的。

操作系统课程设计说明书题目: 页面置换算法程序设计院系：计算机科学与工程专业班级：学号：学生姓名：指导教师：2014年 11月 21 日2014年11月21日安徽理工大学课程设计（论文）成绩评定表目录1 问题描述 (1)2 需求分析 (1)3 概要设计 (1)3.1 设计思路 (1)3.2 功能模块设计 (2)3.3 算法流程图 (2)4 详细设计 (4)4.1 相关知识 (4)4.2 置换算法函数代码设计 (4)4.3 辅助函数代码设计 (10)5 调试分析 (12)6 测试结果 (13)7 设计体会 (15)参考文献 (15)1 问题描述编写程序实现：（1）先进先出页面置换算法（FIFO）（2）最近最久未使用页面置换算法（LRU）（3）最佳置换页面置换算法（OPT）设计一个虚拟存储区和内存工作区，编程序演示以上三种算法的具体实现过程，并计算访问命中率。

演示页面置换的三种算法。

通过随机数产生一个指令序列，将指令序列转换成为页地址流。

计算并输出各种算法在不同内存容量下的命中率。

2 需求分析在地址映射过程中，若在页面中发现所要访问的页面不再内存中，则产生缺页中断。

当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。

而用来选择淘汰哪一页的规则叫做页面置换算法。

在进程运行过程中，若其所要访问的页面不在内存需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。

但应将哪个页面调出，所以需要根据一定的算法来确定。

常用的算法有先进先出置换算法（FIFO）、最近最久未使用置换算法（LRU）和最佳置换算法（OPT），该设计是在VC++6.0环境下用上述三种算法来实现页面置换算法的模拟程序，然后计算访问命中率，并测试结果。

3 概要设计3.1 设计思路选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换： FIFO基本思想：是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。

fifo 页面置换算法页面置换算法是操作系统中一种重要的内存管理技术，用于决定当内存中某个时间点所包含的页面（即帧）数量大于物理内存容量时，应该淘汰哪个页面，以便为新的页面腾出空间。

FIFO （FirstInFirstOut，先进先出）页面置换算法是一种常见的算法，其基本思想是优先淘汰最先进入内存的页面。

一、算法原理FIFO页面置换算法的基本原理是，当需要为新的页面分配内存时，选择最早进入内存的页面进行淘汰。

这种算法的优点是实现简单，缺点是对频繁调用的页面影响较大，因为这些页面最先进入内存，所以被淘汰的可能性也较大。

但是它能够确保被淘汰的页面是最早进入内存的页面，因此它能够提供一定的公平性。

二、算法步骤FIFO页面置换算法的实施步骤如下：1.记录每个页面进入和离开内存的时间；2.当需要为新的页面分配内存时，比较该页面与其最先进入内存的时间；3.优先淘汰最先进入内存的页面；4.将新页面放入空出的帧中。

三、算法优缺点1.优点：a.实现简单，易于实现；b.在许多场景下能提供较好的性能；c.有利于保持页面的有序性。

2.缺点：a.频繁调用的页面被淘汰的可能性较大，可能导致频繁的页面加载和卸载操作；b.对于某些应用场景可能不够高效，因为一些页面可能长时间在内存中占据空间，而不会被频繁使用。

因此需要对其进行优化，以便在减少页面的浪费和提高系统性能之间找到平衡。

四、应用场景FIFO页面置换算法适用于各种操作系统和应用程序，包括但不限于Web服务器、数据库系统、桌面环境等。

它尤其适用于那些对响应速度要求较高且对内存使用效率要求不高的场景。

例如，一些网页浏览、邮件阅读等应用场景，由于页面加载频率较高，FIFO算法可能会影响性能。

五、总结总的来说，FIFO页面置换算法是一种简单易行的内存管理技术，但在实际应用中需要根据具体场景进行优化。

在实际操作中，需要根据应用的特点和需求选择合适的页面置换算法，以提高系统的性能和稳定性。

烟台大学计算机与控制工程学院
计算机操作系统
课程设计报告
题目：页面置换算法
班级计165
姓名王承乾
学号 2
日期2018-7-3
指导教师翟一鸣
实验地点计算机与控制工程学院实验室
一、实验内容
页面置换算法：淘汰掉内存中的某些页为必须进入内存的页面腾出空间的策略。

最优算法（OPT）：从内存中移出以后不再使用的页面，如果没有这样的页面，则选择以后最长时间内不需要访问的页面。

先进先出算法（FIFO）：总是先淘汰那些驻留在内存时间最长的页面，即先进入内存的页面先被置换掉。

最近最久未使用算法（LRU）：当需要置换一页时，选择最近一段时间最久未使用的页面予以淘汰。

设计程序模拟先进先出（FIFO）置换算法，最佳（OPT）置换算法和最近最少用（LRU）置换算法的工作过程。

假设内存中分配给每个进程的最小物理块数为m，在进程运行过程中要访问的页面个数为n，页面访问序列为P1, … ,Pn，分别利用不同的页面置换算法调度进程的页面访问序列，给出页面访问序列的置换过程，计算每种算法缺页次数和缺页率。

程序的设计主要是测试先进先出FIFO，最佳置换OPT和最近最少用LRU页面置换算法的效率以及过程。

二、实验目的
使用系统函数以及c语言的相关语句实现页面置换的三个算法
三、实验环境
开发环境：Windows
编译环境：gcc，g++
开发软件：Codeblocks 16.01。

先进先出（FIFO）页⾯置换算法C语⾔实现、最近最久未使⽤（LRU）页⾯置换算法C语⾔实现1.实现效果2.实现源代码1 #include<iostream>2 #include<process.h>3 #include<stdlib.h>4 #include<ctime>5 #include<conio.h>6 #include<stdio.h>7 #include<string.h>8using namespace std;910#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")/*表格控制*/11#define bsize 4 //物理块⼤⼩12#define psize 16 //进程⼤⼩13void chushihua();//初始化函数14void ymzh();16void changeaddr(struct Page p[], int logaddr);17void dizhizhuanhuan();18void menu();19int wang();2021int yemianliu[32]={0};//全局变量数组,地址流22int p;23struct Page {24int pno;//页号25int flag;//标志位26int cno;//主存号27int modf;//修改位28int addr;//外存地址29 }Page; //全局变量p是⼀共有多少地址流3031 typedef struct pagel32 {33int num; /*记录页⾯号*/34int time; /*记录调⼊内存时间*/35 }Pagel; /*页⾯逻辑结构,⽅便算法实现*/3637 Pagel b[bsize]; /*内存单元数*/38int c[bsize][psize];/*保存内存当前的状态:缓冲区*/39int queue[100];/*记录调⼊队列*/40int k;/*调⼊队列计数变量*/41int phb[bsize]={0};//物理块标号42int pro[psize]={0};//进程序列号43int flag[bsize]={0};//进程等待次数(存放最久未被使⽤的进程标志)*/ 44int i=0,j=0;//i表⽰进程序列号,j表⽰物理块号*/45int m =-1,n =-1;//物理块空闲和进程是否相同判断标志*/46int mmax=-1, maxflag=0;//标记替换物理块进程下标*/47int count =0; //统计页⾯缺页次数4849void chushihua() //初始化函数50 {51int t;52 srand(time(0));//随机产⽣指令序列53 p=12+rand()%32;54 cout<<"地址流序列:";55 cout<<endl;56for(i=0; i<p; i++)57 {58 t=1+rand()%9;59 yemianliu[i]=t;//将随机产⽣的指令数存⼊页⾯流60 }61for (i=p-1;i>=0;i--)62 {63 cout<<yemianliu[i]<<"";64 }65 cout<<endl;66 }67void ymzh()68 {69 chushihua();70 yemianzhihuan();71 }7273void yemianzhihuan()74 {75int a;76 printf("----------------------------------\n");77 printf("☆☆欢迎使⽤分页模拟实验系统☆☆\n");78 printf("----------------------------------");79 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");80 printf("☆☆1.进⼊硬件地址变换算法☆☆\n");81 printf("☆☆------------------------☆☆\n");82 printf("☆☆2.进⼊页⾯置换算法☆☆\n");83 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");84 printf("请输⼊您的选择:");85switch(a)86 {87case1:88 ymzh();89break;90case2:91 wang();92break;93default:94 cout<<"输⼊有误,请重新输⼊!"<<endl;95break;96 }97 }98100int j=logaddr/64;//对应的块号101int k=logaddr%64; //对应的偏移量102int flag=0;103int addr;104for(int i=0;i<8;i++)105 {106if(p[i].pno==j)//找到对应的页号107 {108if(p[i].flag==1)//页⾯标志为1109 {110 addr=p[i].cno*64+k;111 cout<<"物理地址为:"<<addr<<endl;112 cout<<"详细信息:"<<"\t页⾯号:"<<p[i].pno<<"\t 主存号："<<p[i].cno<<"\t偏移量:"<<k<<endl; 113 flag=1;114break;115 }116 }117 }118119if(flag==0)120 cout<<"该页不在主存,产⽣缺页中断"<<endl;121 }122123void dizhizhuanhuan()124 {125int a;126int ins;//指令逻辑地址127struct Page p[8];128 p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;129 p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;130 p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;131 p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;132 p[4].pno=4;p[4].flag=0;p[4].addr=017;133 p[5].pno=5;p[5].flag=0;p[5].addr=025;134 p[6].pno=6;p[6].flag=0;p[6].addr=212;135 p[7].pno=7;p[7].flag=0;p[7].addr=213;136 printf("\t\t\t--------------------------------\n");137 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");138 printf("\t\t\t---------------------------------\n");139 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");140 printf("\t\t\t☆☆1.输⼊指令☆☆\n");141 printf("\t\t\t☆☆------------------------☆☆\n");142 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");143 printf("\t\t\t☆☆------------------------☆☆\n");144 printf("\t\t\t☆☆0.EXIT ☆☆\n");145 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");146while(a!=0)147 {148 cout<<endl<<"请输⼊您的选择:";149 cin>>a;150151 cout<<"页号"<<"标记位"<<"外存地址"<<"主存号"<<endl;152for(int i=0;i<8;i++)153 {154 cout<<p[i].pno<<"\t"<<p[i].flag<<"\t"<<p[i].addr<<"\t";155if(p[i].flag)156 cout<<p[i].cno;157 cout<<endl;158 }159160switch(a)161 {162case0:printf("\t\t\t再见!\t\t\t\n"); break;163case1:164 cout<<"请输⼊指令的逻辑地址:";165 cin>>ins;166 changeaddr(p, ins);break;167case2: system("CLS"); a=wang();break;168default:cout<<"输⼊有误,请重新输⼊!"<<endl;break;169 }170 }171 }172173void menu()174 {175int a;176 printf("\t\t\t--------------------------------\n");177 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");178 printf("\t\t\t---------------------------------\n");179 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");180 printf("\t\t\t☆☆1.输⼊指令☆☆\n");181 printf("\t\t\t☆☆------------------------☆☆\n");182 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");184 printf("\t\t\t☆☆0.EXIT ☆☆\n");185 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n"); 186 printf("请选择所要执⾏的操作:");187 scanf("%d",&a);188switch(a)189 {190case0: printf("\t\t\t-再见!-\t\t\t\n");break;191case1: dizhizhuanhuan (); break;192case2: wang (); break;193default:cout<<"输⼊有误,请重新输⼊!"<<endl;break; 194 }195 }196int main()197 {198 menu();199 }200201//****************随机产⽣序列号函数202int* build()203 {204 printf("随机产⽣⼀个进程序列号为:\n");205int i=0;206for(i=0; i<psize; i++)207 {208 pro[i]=10*rand()/(RAND_MAX+1)+1;209 printf("%d ", pro[i]);210 }211 printf("\n");212return(pro);213 }214215//***************************************查找空闲物理块216int searchpb()217 {218for (j=0;j<bsize; j++)219 {220if(phb[j] == 0)221 {222 m=j;223return m;224break;225 }226 }227return -1;228 }229//************************************查找相同进程230int searchpro()231 {232for(j=0;j< bsize;j++)233 {234if(phb[j] =pro[i])235 {236 n=j;237return j;238 }239 }240return -1;241 }242243//*************************初始化内存244void empty()245 {246for(i=0;i<bsize;i++)247 phb[i]=0;248 count=0; //计数器置零249 } //******先进先出页⾯置换算法250void FIFO()251 {252for( i=0; i<psize; i++)253 {254// m=searchpb();255// n=searchpro();256//找到第⼀个空闲的物理快257for(j=0;j<bsize;j++) {258if(phb[j] == 0){259 m=j;260break;261 }262 }263//找与进程相同的标号264for(j=0;j<bsize;j++) {265if(phb[j] == pro[i]){266 n=j;268 }269270//找flag值最⼤的271for(j=0;j<bsize;j++)272 {273if(flag[j]>maxflag)274 {275 maxflag = flag[j];276 mmax = j;277 }278 }279280if(n == -1)//不存在相同进程281 {282if(m != -1)//存在空闲物理块283 {284 phb[m]=pro[i];//进程号填⼊该空闲物理块285// count++;286 flag[m]=0;287for (j=0;j<=m; j++)288 {289 flag[j]++;290 }291 m=-1;292 }293else//不存在空闲物理块294 {295 phb[mmax] =pro[i];296 flag[mmax] =0;297for (j=0;j<bsize;j++)298 {299 flag[j]++;300 }301 mmax = -1;302 maxflag = 0;303 count++;304 }305 }306else//存在相同的进程307 {308 phb[n] = pro[i];309for(j=0;j<bsize;j++)310 {311 flag[j]++;312 }313 n=-1;314 }315for(j=0;j < bsize;j++)316 {317 printf("%d ", phb[j]);318 }319 printf("\n");320 }321 printf("缺页次数为:%d\n",count);322 printf("缺页率 :%16. 6f",(float)count/psize);323 printf("\n");324 }325/*初始化内存单元、缓冲区*/326void Init(Pagel *b,int c[bsize][psize])327 {328int i,j;329for (i=0;i<psize;i++)330 {331 b[i].num=-1;332 b[i].time=psize-i-1;333 }334for(i=0;i<bsize;i++)335for(j=0;j<psize;j++)336 c[i][j]=-1;337 }338/*取得在内存中停留最久的页⾯,默认状态下为最早调⼊的页⾯*/ 339int GetMax(Pagel *b)340 {341int i;342int max=-1;343int tag=0;344for(i=0;i<bsize;i++)345 {346if(b[i].time>max)347 {348 max=b[i].time;349 tag= i;350 }353 }354355/*判断页⾯是否已在内存中*/356int Equation(int fold, Pagel *b)357 {358int i;359for(i=0;i<bsize;i++)360 {361if(fold==b[i]. num)362return i;363 }364return -1;365 }366/*LRU核⼼部分*/367void Lruu(int fold, Pagel *b)368 {369int i;370int val;371 val=Equation(fold, b);372if (val>=0)373 {374 b[val].time=0;375for(i=0;i<bsize;i++)376if (i!=val)377 b[i].time++;378 }379else380 {381 queue[++k]=fold;/*记录调⼊页⾯*/382 val=GetMax(b);383 b[val].num=fold;384 b[val].time=0;385for (i=0;i<bsize;i++){386387// URLcount++;388if (i!=val)389 b[i].time++;390 }391 }392 }393394void LRU()395 {396int i,j;397 k=0;398 Init(b, c);399for(i=0; i<psize; i++)400 {401 Lruu(pro[i],b);402 c[0][i]=pro[i];403/*记录当前的内存单元中的页⾯*/404for(j=0;j<bsize;j++)405 c[j][i]=b[j].num;406 }407408/*结果输出*/409 printf("内存状态为:\n");410 Myprintf;411for(j=0;j<psize;j++)412 printf("|%2d", pro[j]);413 printf("|\n");414 Myprintf;415416for(i=0;i<bsize;i++)417 {418for(j=0; j<psize; j++)419 {420if(c[i][j]==-1)421 printf("|%2c",32);422else423 printf("|%2d",c[i][j]);424 }425 printf("|\n");426 }427428 Myprintf;429// printf("\n调⼊队列为:");430// for(i=0;i<k;i++)431// printf("%3d", queue[i]);432433 printf("\n缺页次数为:%6d\n 缺页率 :%16. 6f", k+1,(float)(k+1)/psize); 434 }437int wang()438 {439int sel;440do{441 printf("\t\t\t--------------------------------\n");442 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");443 printf("\t\t\t---------------------------------\n");444 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");445 printf("\t\t\t☆☆虚拟内存☆☆\n");446 printf("\t\t\t☆☆------------------------☆☆\n");447 printf("\t\t\t☆☆1.产⽣随机序列☆☆\n");448 printf("\t\t\t☆☆------------------------☆☆\n");449 printf("\t\t\t☆☆2.最近最久未使⽤☆☆\n");450 printf("\t\t\t☆☆------------------------☆☆\n");451 printf("\t\t\t☆☆3.先进先出☆☆\n");452 printf("\t\t\t☆☆------------------------☆☆\n");453 printf("\t\t\t☆☆0.退出☆☆\n");454 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");455 printf("请选择所要执⾏的操作:");456 scanf("%d",&sel);457switch(sel)458 {459case0: printf("\t\t\t再见!t\t\t\n"); break;460case1: build(); break;461case2: printf("最近最久未使⽤\n"); LRU();empty(); printf("\n");break; 462case3: printf("先进先出算法\n"); FIFO();empty();printf("\n");break; 463default:printf("请输⼊正确的选项号!");printf("\n\n");break;464 }465 }while(sel !=0 );466return sel;467 }。

课程设计报告设计题目：页面置换算法班级：科技一班组长学号：组长姓名：指导教师：设计时间：2017年3月设计分工组长学号及姓名：E********叶传军分工：算法设计，整体构架，课程实验报告成绩：95组员1学号及姓名：E********周坚坚分工：界面设计，代码整理，背景制作成绩：96目录摘要............................................................... ４1.设计目的......................................................... ５2.课设要求......................................................... ５3.系统分析......................................................... ６4.系统设计......................................................... ６4.1问题分析.................................................... ６4.2程序整体框图................................................ ７4.3 FIFO算法................................................... ８4.4 LRU算法.................................................... ９4.5 OPT算法.................................................. １０4.6 LFR算法................................................. １１5.功能与测试..................................................... １２6.结论........................................................... １４7.心得体会....................................................... １５８.附录.......................................................... １５摘要随着计算机的普及，人们生活得到极大改善，人们在精神方面也同样需要提高，所以越来越多的人进行着各种各样的学习。

沈阳工程学院操作系统课程设计设计题目：先进先出页面置换算法系别计算机科学与技术班级学生姓名学号指导教师曲乐声、崔妍职称讲师起止日期：2016年6月6日起——至2016年6月10日止沈阳工程学院操作系统课程设计任务书设计题目：请求调页存储管理方式的模拟1系别计算机科学与技术班级学生姓名学号指导教师曲乐声职称讲师课程设计进行地点：信息学院实验室任务下达时间：2016年6月 3日起止日期：2016年6月6日起——至2016年6月10日止系部主任张欣2016年6月2日批准一、设计目的操作系统课程设计是在完成操作系统理论课程学习之后进行的实践性教学。

通过课程设计，综合运用操作系统课程的理论，结合实际，加深对操作系统知识全面、深入地理解，进一步掌握操作系统的基本概念、原理和实现方法，能够模拟操作系统对计算机系统的管理和控制功能，培养学生分析和解决实际问题的能力，并使所学知识得到进一步巩固、深化和扩展。

该页面置换先进先出算法的设计的主要目的是，通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求调页系统的原理和实现过程的理解。

二、设计的主要内容及要求1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。

2）用c语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。

在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。

如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。

在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。

3）置换算法：采用先进先出（FIFO）置换算法。

三、对设计说明书撰写内容、格式、字数的要求1.课程设计说明书（论文）是体现和总结课程设计成果的载体，一般不应少于3000字。

2.学生应撰写的内容为：目录、正文、参考文献等。

《操作系统》课外实践报告项目名称：页面置换算法所在班级：姓名：学号：组长：小组成员：指导教师：支丽平成绩评定：页面置换算法中的先进先出算法一实验目的了解最佳页面置换算法与先进先出FIFO页面置换算法，并掌握其基本原理二实验目标用C++模拟最佳页面置换算法与先进先出FIFO页面置换算法三实验步骤第一步，输入系统为进程分配的物理块数(m<=10)第二步，输入总页面数(n<=30)第三步，输入页面号引用串第四步，系统自动给出演示数据第五步，分析数据第六步，重复一到五步骤四技术难点及解决方案技术难点：如何找到最久页面解决方案：建立一个时间数组，做标记五关键数据和算法流程代码如下：#include "iostream"#include "iomanip" //使用setw()时用到的头文件#include "stdio.h"#include "stdlib.h"#include "conio.h" //使用getchar()时用到的头文件using namespace std;#define Max 30 //某进程调入内存中的最大页面数#define Size 10 //系统为某进程分配的最大物理块数void Init(int Block[],int m) //初始化物理块{ int i;for(i=0;i<m;i++){Block[i]=-1;}}void creat(int Page[],int n) //输入页面串引用号{ int i;for(i=0;i<n;i++){cin>>Page[i];}}void FIFO(int Page[],int Block[],int n,int m){//max_stay:比较当前内存中页面驻留的最久时间,count:统计页面置换次数//get:某物理块是否等待驻入新页面(-1:否)//flag:标记当前序号页面是否已驻入内存(-1:否)//block_num:驻留内存时间最长的页面所在的物理块序号//time[]标记对应序号的物理块中页面驻留时间int i,j,max_stay=0,count=0;int get=-1,flag=-1,block_num=-1;int time[Size];for(i=0;i<m;i++) //初始化time[]{ time[i]=0;}for(i=0;i<n;i++){ for(j=0;j<m;j++) //有空闲物理块时，页面直接驻入内存空闲块{ if(Block[j]==-1){get=j; //物理块j即将(/等待)驻入新页面break;}}for(j=0;j<m;j++) //查找序号相同的页面{ if(Block[j]==Page[i])//物理块j中页面与当前期望调入内存的页面相同{flag=j;break;}}for(j=0;j<m;j++) //找到驻留内存时间最久的页面置换出{if(time[j]>max_stay){max_stay=time[j];block_num=j; //block_num标记当前序号物理块中页面驻留时间最久}}if(flag==-1) //不存在相同页面{ if(get!=-1) //物理块即将(/等待)驻入新页面{Block[get]=Page[i]; //存入页面time[get]=0; //当前物理块重新计时for(j=0;j<=get;j++) //已驻入页面的驻留时间加1{time[j]++;}get=-1;}else //页面调度置换，序号block_num的物理块是驻留时间最久的{Block[block_num]=Page[i];time[block_num]=0;for(j=0;j<Size;j++){time[j]++;}block_num=-1;max_stay=0;count++;}}else //待调入页面与序号flag的物理块中页面相同{for(j=0;j<m;j++){time[j]++;}flag=-1;}for(j=0;j<m;j++) //输出物理块中的页面驻入情况{cout<<setw(3)<<Block[j];}cout<<endl;}if(n>m)count=count+m;cout<<"缺页中断次数为:"<<count<<endl;}void main(){ int n,m,Page[Max],Block[Size];cout<<"*******先进先出FIFO页面置换算法*******"<<endl;cout<<"--------------------------------------"<<endl;cout<<"*******(默认:-1表示物理块空闲)*******"<<endl;cout<<endl<<"请输入系统为进程分配的物理块数(m<=10):";while(1){cin>>m;if(m>Size||m<1){cout<<"警告：输入的数据错误！"<<endl;cout<<"请重新输入物理块数:";}else break;}Init(Block,m);cout<<"请输入总页面数(n<=30):";cin>>n;cout<<"\n请输入页面号引用串:";creat(Page,n);cout<<"FIFO算法过程如下:"<<endl;FIFO(Page,Block,n,m);getchar(); //直接执行exe文件时做停留查看结果之用getchar();}。

C语⾔实现页⾯置换先进先出算法（FIFO）本⽂实例为⼤家分享了C语⾔实现页⾯置换算法的具体代码，供⼤家参考，具体内容如下⼀、设计⽬的加深对请求页式存储管理实现原理的理解，掌握页⾯置换算法中的先进先出算法。

⼆、设计内容设计⼀个程序，有⼀个虚拟存储区和内存⼯作区，实现下述三种算法中的任意两种，计算访问命中率（命中率=1-页⾯失效次数/页地址流长度）。

附加要求：能够显⽰页⾯置换过程。

该系统页地址流长度为320，页⾯失效次数为每次访问相应指令时，该指令对应的页不在内存的次数。

程序⾸先⽤srand()和rand()函数分别进⾏初始化、随机数定义和产⽣指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。

通过随机数产⽣⼀个指令序列。

共320条指令，指令的地址按下述原则⽣成：（1）50%的指令是顺序执⾏的。

（2）25%的指令是均匀分布在前地址部分。

（3）25%的指令是均匀分布在后地址部分。

具体的实施⽅法如下：在【0，319】的指令地址之间随机选取⼀起点m。

顺序执⾏⼀条指令，即执⾏地址为m+1的指令。

在前地址【0,m+1】中随机选取⼀条指令并执⾏，该指令的地址为m'。

顺序执⾏⼀条指令，其地址为m'+1。

在后地址【m'+2,319】中随机选取⼀条指令并执⾏。

重复步骤（1）-（5），直到320次指令。

将指令序列变换为页地址流。

设：页⾯⼤⼩为1KB。

⽤户内存容量4页到32页。

⽤户虚存容量为32KB。

在⽤户虚存中，按每K存放10条指令虚存地址，即320条指令在虚存中的存放⽅式为：第0条～9条指令为第0页（对应虚存地址为【0，9】）。

第10条～19条指令为第1页（对应虚存地址为【10，19】）。

……第310条～319条指令为第31页（对应虚拟地址为【310，319】）。

按以上⽅式，⽤户指令可组成32页。

计算每种算法在不同内存容量下的命中率。

三、程序结构⾸先，⽤srand()和rand()函数分别进⾏初始化、随机数定义和产⽣指令序列；接着，将指令序列变换成相应的页地址流；然后，并针先进先出算法计算出相应的命中率和输出页⾯置换过程。

操作系统之页⾯置换算法（最佳置换OPT，先进先出FIFO，最近最久未使⽤LRU）最近学习操作系统时，实验要求实现常见的三种页⾯置换算法，博主按照书上要求试着编写，实现了案例，并记录在博客随记中，以便后续⾃⼰复习并也给需要的同学分享参考⼀下!⽔平有限，若有错，请悄悄告诉博主！博主好⽴即改正。

最佳置换算法（optimal replacement，OPT）是从内存中选择今后不再访问的页⾯或者在最长⼀段时间后才需要访问的页⾯进⾏淘汰。

如下例⼦：根据页⾯⾛向依次处理，得到最终的置换结果如下图表，整个页⾯缺页次数为7，缺页率为7/12=58%。

1 #include <iostream>2 #include <stdio.h>3 #include <stdlib.h>4#define N 125#define B 36using namespace std;78int pageArr[N]={1,2,3,4,1,2,5,1,2,3,4,5};//页⾯⾛向9int block[B]={0};//物理块3个，其数值是页号10 typedef struct FLAG {11int flags[B];12int counts;13 } FLAG;1415void opt(int pageArr[],int block[]);16int inBlock(int which);17int findFar(int next);18void Replace(int index,int value);19void disPlay();2021int main(void){22 cout << "begin:" <<endl;23 opt(pageArr,block);24 cout << "end!" <<endl;25return0;26 }2728void opt(int pageArr[],int block[]){29int getIndex;30for(int i=0;i<N;i++){31if(i<3){//前3页号#短缺#进队列32 block[i]=pageArr[i];33 printf("缺页：(null)-->%d\n",pageArr[i]);34 }35else {36if(i==3){37 disPlay();3839 }40if(inBlock(pageArr[i])!=-1){//下⼀个页⾯if在物理块中返回index并跳过,反-141 disPlay();4243continue;44 }45 getIndex=findFar(i+1);//从下⼀个页号，找到最远出现的页⾯,替换的下标46if(getIndex==-1){47 cout<<"error,not replace obj!"<<'\t';48 }49else{50 Replace(getIndex,pageArr[i]);//由下标找到上⼀组替换⽬标，⽤第⼆参数替换51 disPlay();5253 }54 }55 }56return;57 }5859//替换block中的物理块60void Replace(int index,int value){61 printf("缺页：%d--被替换为-->%d\n",block[index],value);62 block[index]=value;63return;64 }656667//找到最远出现的页⾯68int findFar(int next){69int index=-1;//error，默认返回不存在的索引70 FLAG myflag;71 myflag.flags[0]=0;72 myflag.flags[1]=0;73 myflag.flags[2]=0;74 myflag.counts=0;75int stop = N-next;76while(stop--){77 index=inBlock(pageArr[next++]);78if(index!=-1){79 myflag.flags[index]=1;80 myflag.counts++;83break;84 }85 }86for(index=0;index<B;index++){87if(myflag.flags[index]==0)88break;89 }90return index;91 }929394//下⼀个页⾯if在物理块中返回index,反-195int inBlock(int which){96//int i=0;97//while(i<B)98// if(block[i++]==which)99// return i-1;100for(int i=0;i<B;i++){101if(block[i]==which)102return i;103 }104return -1;105 }106107//打印⼀元组108void disPlay(){109int i=0;110while(i<B){111 printf("%d\t",block[i++]);112 }113 printf("\n");114return;115 }上⾯是博主使⽤C++（基本是C语法）编写的代码，运⾏结果如下：//////////////////////////////////////////////////////////////////////////begin:缺页：(null)-->1缺页：(null)-->2缺页：(null)-->31 2 3缺页：3--被替换为-->41 2 41 2 41 2 4缺页：4--被替换为-->51 2 51 2 51 2 5缺页：1--被替换为-->33 2 5缺页：3--被替换为-->44 2 54 2 5end!//////////////////////////////////////////////////////////////////////////先进先出算法：先进先出置换算法（first in first out,FIFO）是淘汰最先进⼊内存的页⾯，即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。

1.实验目的加深对于存储管理的了解，掌握虚拟存储器的实验原理；观察和了解重要的页面置换算法的置换过程；练习模拟算法的编程技巧。

2.实验内容利用先进先出置换算法，将页面依次调入主存，并算出缺页中断次数及缺页中断率。

3.设计思路用队列来存储调入主存中的页面号，设置全局变量count来记录缺页中断次数，队列的总长度即为分配的主存的块数，若队列未满则将页面调入，若队列满了，则判断要调入的页面是否已在主存中，若在则无需调入，若不在，则将队首元素出队，依次将后面的元素往前移，将页面插入在队尾。

4.关键代码#include<stdio.h>#define MAXSIZE 100typedef int datatype;typedef struct{datatype a[MAXSIZE];int front;int rear;}sequence_queue;int count=0;//中断次数void init(sequence_queue *sq){sq->front=sq->rear=0;}void insert(sequence_queue *sq,datatype x,int kuaishu){int i,flag=0;if(sq->rear==kuaishu)//主存块数已满{for(i=sq->front;i<sq->rear;i++){if(sq->a[i]==x){printf("主存中已存在该页！");flag=1;}}if(flag==0){for(i=0;i<kuaishu;i++){sq->a[i]=sq->a[i+1];}sq->a[kuaishu-1]=x;count++;}}else{sq->a[sq->rear]=x;sq->rear=sq->rear+1;count++;}}int empty(sequence_queue sq){return (sq.front==sq.rear?1:0);}void display(sequence_queue sq){int i;if(empty(sq)){printf("主存是空的！请调入作业");}else{printf("\n主存中的页面为:");for(i=sq.front;i<sq.rear;i++)printf("%d ",sq.a[i]);}}main(){sequence_queue sq;int kuaishu,sum,i;datatype x;printf("请输入主存块数：");scanf("%d",&kuaishu);printf("\n请输入页面的调度次数:");scanf("%d",&sum);init(&sq);for(i=0;i<sum;i++){printf("\n\n请输入调度的页面号:");scanf("%d",&x);insert(&sq,x,kuaishu);display(sq);}printf("\n\n缺页中断次数=%d",count);printf("\n\n缺页中断率=%d%%\n",(count*100)/sum); }5.运行结果。