LRU算法 与CLOCK算法
操作系统页面置换算法（opt,lru,fifo,clock）实现
操作系统页⾯置换算法（opt,lru,fifo,clock ）实现选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种（以下来⾃操作系统课本）。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的，因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串： 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时，先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时，产⽣缺页中断，根据最佳置换算法，选择第18次访问才需调⼊的页⾯7予以淘汰。
然后，访问页⾯0时，因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推，如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到，发⽣缺页中断的次数为9，页⾯置换的次数为6。
图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。
该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。
图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例，⾤⽤FIFO 算法进⾏页⾯置换。
进程访问页⾯2时，把最早进⼊内存的页⾯7换出。
然后访问页⾯3时，再把2, 0, 1中最先进⼊内存的页换出。
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现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算法的实现需要维护一个记录页面使用时间的链表或队列。
clock替换算法
Clock 替换算法（也称为时钟置换算法）是一种用于虚拟内存管理的页面替换策略。
它的目的是在需要为新页面在内存中分配空间时选择合适的页面进行替换。
Clock 算法是LRU（最近最少使用）算法的一种近似实现，通常用于操作系统的页面置换。
Clock 算法的命名来源于它的数据结构类似于一个时钟，页面按顺序排列成一个圆形队列。
Clock 算法采用以下方法进行操作：
1. 它维护一个指针，指向有序队列中的一个页面，该指针初次指向第一个页面。
2. 当需要替换某个页面时，算法检查当前指针所指向的页面。
3. 如果该页面的访问位（accessed bit）为 0，则选择该页面进行替换。
4. 如果访问位为 1，则将访问位设置为 0，并将指针移动到下一个页面。
5. 重复步骤 2-4，直到找到一个访问位为 0 的页面。
在这个过程中，访问位表示页面自上次访问以来是否被访问过。
如果页面被访问，其访问位将设置为 1；否则，访问位保持为 0。
Clock 算法使用这个信息来尝试近似 LRU 策略——即选择最近最少使用的页面进行替换。
通过这种方法，Clock 算法可以在较低的开销下实现合适的页面替换。
值得注意的是，虽然 Clock 算法尝试近似 LRU 策略，但它并不能完全等同于 LRU。
Clock 算法可能会产生较差的近似结果，尤其是在页面访问模式较为复杂时。
然而，由于其相对较低的实现成本，Clock 算法在许多操作系统中被用作默认的页面替换策略。
常用的页面调度算法
常用的页面调度算法一、引言在计算机科学中，页面调度算法是操作系统中的一种重要机制，用于管理计算机内存中的页面。
页面调度算法的目标是尽可能地提高内存的利用率，减少页面置换的次数，从而提高系统的性能和响应速度。
常用的页面调度算法有先进先出（FIFO）、最近最久未使用（LRU）和时钟（Clock）算法等。
本文将介绍这些常用的页面调度算法，并分析它们的优缺点及适用场景。
二、先进先出（FIFO）算法先进先出算法是最简单的页面调度算法之一。
它的原理是将最早进入内存的页面置换出去，即先进先出。
当内存空间不足时，操作系统将最早进入内存的页面替换出去，腾出空间给新的页面。
这种算法简单易实现，但是它没有考虑页面的使用频率和重要性，可能导致常用的页面被频繁替换，影响系统的性能。
三、最近最久未使用（LRU）算法最近最久未使用算法是一种常用的页面调度算法。
它的原理是根据页面的使用情况来进行页面置换。
当需要替换页面时，操作系统选择最近最久未使用的页面进行置换。
这种算法考虑了页面的使用频率，可以有效地提高内存的利用率。
然而，LRU算法的实现比较复杂，需要维护一个页面访问的时间戳列表，当页面被访问时，需要更新时间戳列表，这会带来额外的开销。
四、时钟（Clock）算法时钟算法是一种简化的页面调度算法，它是基于LRU算法的改进。
时钟算法使用一个循环链表来保存内存中的页面，并维护一个指针指向当前页面。
当需要替换页面时，时钟算法从当前页面开始顺时针扫描链表，找到一个未被访问的页面进行置换。
如果当前页面已被访问，则将访问位清零，并将指针指向下一个页面。
这种算法简化了LRU算法的实现，并且可以在O(1)的时间内完成页面置换操作。
五、比较和总结先进先出算法简单易实现，但没有考虑页面的使用频率和重要性；最近最久未使用算法考虑了页面的使用频率，可以提高内存的利用率，但实现较复杂；时钟算法是一种简化的LRU算法，可以在O(1)的时间内完成页面置换操作。
实验四操作系统存储管理实验报告
实验四操作系统存储管理实验报告一、实验目的本次实验的主要目的是深入理解操作系统中存储管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收、页面置换算法等关键概念，并能够分析和解决存储管理中可能出现的问题。
二、实验环境本次实验在装有 Windows 操作系统的计算机上进行，使用了 Visual Studio 等编程工具和相关的调试环境。
三、实验内容（一）内存分配与回收算法实现1、首次适应算法首次适应算法从内存的起始位置开始查找，找到第一个能够满足需求的空闲分区进行分配。
在实现过程中，我们通过建立一个空闲分区链表来管理内存空间，每次分配时从表头开始查找。
2、最佳适应算法最佳适应算法会选择能够满足需求且大小最小的空闲分区进行分配。
为了实现该算法，在空闲分区链表中，分区按照大小从小到大的顺序排列，这样在查找时能够快速找到最合适的分区。
3、最坏适应算法最坏适应算法则选择最大的空闲分区进行分配。
同样通过对空闲分区链表的排序和查找来实现。
（二）页面置换算法模拟1、先进先出（FIFO）页面置换算法FIFO 算法按照页面进入内存的先后顺序进行置换，即先进入内存的页面先被置换出去。
在模拟过程中，使用一个队列来记录页面的进入顺序。
2、最近最久未使用（LRU）页面置换算法LRU 算法根据页面最近被使用的时间来决定置换顺序，最近最久未使用的页面将被置换。
通过为每个页面设置一个时间戳来记录其最近使用的时间，从而实现置换策略。
3、时钟（Clock）页面置换算法Clock 算法使用一个环形链表来模拟内存中的页面，通过指针的移动和页面的访问标志来决定置换页面。
四、实验步骤（一）内存分配与回收算法的实现步骤1、初始化内存空间，创建空闲分区链表，并为每个分区设置起始地址、大小和状态等信息。
2、对于首次适应算法，从链表表头开始遍历，找到第一个大小满足需求的空闲分区，进行分配，并修改分区的状态和大小。
3、对于最佳适应算法，在遍历链表时，选择大小最接近需求的空闲分区进行分配，并对链表进行相应的调整。
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],回车，实验结果将显示出该组数据的淘汰页面号、缺页次数和缺页率。
页面置换算法实验报告
页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中，页面置换算法是一种重要的内存管理策略。
当物理内存不足以容纳所有需要运行的进程时，操作系统需要根据一定的算法将部分页面从内存中换出，以便为新的页面腾出空间。
本实验旨在通过实际操作，对比不同的页面置换算法在不同场景下的性能表现。
二、实验背景在计算机系统中，每个进程都有自己的虚拟内存空间，而物理内存空间是有限的。
当进程需要访问某个页面时，如果该页面不在物理内存中，就会发生缺页中断，操作系统需要根据页面置换算法选择一个页面将其换出，然后将需要访问的页面换入。
常见的页面置换算法有先进先出（FIFO）、最近最久未使用（LRU）、时钟（Clock）等。
三、实验目的本实验旨在通过模拟不同的页面置换算法，比较它们在不同情况下的缺页率和效率。
通过实验结果，评估各个算法在不同场景下的优劣，为实际系统的内存管理提供参考。
四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较：FIFO、LRU和Clock。
我们使用C++编程语言模拟了一个简单的内存管理系统，并通过产生不同的访存序列来模拟不同的场景。
实验中，我们设置了不同的物理内存大小，访存序列长度和页面大小，以模拟不同的系统环境。
五、实验结果与分析在实验中，我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。
通过统计不同算法的缺页率和运行时间，得出以下结论：1. FIFO算法FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。
实验结果表明，FIFO算法在缺页率方面表现一般，特别是在访存序列具有局部性的情况下，其性能明显下降。
这是因为FIFO算法无法区分不同页面的重要性，可能会将经常使用的页面换出，导致缺页率升高。
2. LRU算法LRU算法是一种基于页面访问时间的置换算法，它认为最近被访问的页面很可能在未来会被再次访问。
实验结果表明，LRU算法在缺页率方面表现较好，特别是在访存序列具有较强的局部性时，其性能明显优于FIFO算法。
页面置换算法实验报告
页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程，了解不同算法的优缺点，掌握算法的实现方法，以及对算法的性能进行评估。
二、实验原理页面置换算法是操作系统中的一个重要概念，它是为了解决内存不足的问题而产生的。
当系统中的进程需要使用内存时，如果内存已经被占满，就需要将一些页面从内存中置换出去，以便为新的页面腾出空间。
页面置换算法就是用来决定哪些页面应该被置换出去的算法。
常见的页面置换算法有以下几种：1. 最佳置换算法（OPT）最佳置换算法是一种理论上的最优算法，它总是选择最长时间内不会被访问的页面进行置换。
但是，由于无法预测未来的页面访问情况，因此最佳置换算法无法在实际中使用。
2. 先进先出置换算法（FIFO）先进先出置换算法是一种简单的置换算法，它总是选择最先进入内存的页面进行置换。
但是，这种算法容易出现“抖动”现象，即频繁地将页面置换出去，然后再将其置换回来。
3. 最近最久未使用置换算法（LRU）最近最久未使用置换算法是一种比较常用的置换算法，它总是选择最长时间未被访问的页面进行置换。
这种算法可以避免“抖动”现象，但是实现起来比较复杂。
4. 时钟置换算法（Clock）时钟置换算法是一种改进的FIFO算法，它通过维护一个环形链表来实现页面置换。
当需要置换页面时，算法会从当前位置开始扫描链表，如果找到一个未被访问的页面，则将其置换出去。
如果扫描一圈后都没有找到未被访问的页面，则将当前位置的页面置换出去。
三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序，可以模拟上述四种算法的过程，并输出算法的性能指标。
程序的主要流程如下：1. 读取输入文件，获取页面访问序列和内存大小等参数。
2. 根据选择的算法，初始化相应的数据结构。
3. 遍历页面访问序列，模拟页面置换的过程。
4. 输出算法的性能指标，包括缺页率、页面置换次数等。
下面分别介绍四种算法的实现方法。
1. 最佳置换算法（OPT）最佳置换算法需要预测未来的页面访问情况，因此需要遍历整个页面访问序列，找到最长时间内不会被访问的页面。
页面淘汰算法
页面淘汰算法一、什么是页面淘汰算法？页面淘汰算法是指在计算机系统中，为了减少内存的使用，将一些不常用的页面从内存中移除，以便为其他需要更多内存的程序腾出空间。
页面淘汰算法根据不同的策略选择要移除的页面，以最大化系统性能和资源利用率。
二、常见的页面淘汰算法有哪些？1. 最近最少使用算法（LRU）LRU算法是一种基于时间局部性原理的页面置换算法。
它认为如果一个页面最近被访问过，那么它可能在不久的将来也会被访问。
因此，LRU算法选择最近最少使用的页面进行淘汰。
2. 先进先出算法（FIFO）FIFO算法是一种简单而直观的页面置换策略。
它按照进入内存时间顺序进行淘汰，即先进入内存的页面先被淘汰。
3. 时钟置换算法（Clock）时钟置换算法是一种改进版FIFO算法。
它通过维护一个“指针”，指向最老的未被访问过的页面，并将该指针逐个往后移动。
当需要淘汰一个页面时，如果该页已被访问过，则将其标记为“未访问过”并继续移动指针，直到找到一个“未访问过”的页面为止。
4. 最不经常使用算法（LFU）LFU算法是一种基于统计局部性原理的页面置换算法。
它认为如果一个页面在一段时间内被访问的频率很低，那么它在未来也很少被访问。
因此，LFU算法选择最不经常使用的页面进行淘汰。
5. 随机置换算法（Random）随机置换算法是一种简单而随意的页面置换策略。
它随机选择一个页面进行淘汰，没有任何规则可言。
三、如何选择合适的页面淘汰算法？选择合适的页面淘汰算法需要考虑以下几个方面：1. 系统负载情况如果系统负载较重，应该选择效率较高、实现简单的置换算法，如FIFO和Clock；如果系统负载较轻，则可以选择效果更好但实现更复杂的LRU和LFU算法。
2. 计算资源不同的置换算法对计算资源的要求不同。
LRU和LFU需要记录每个页面最近或最少被访问的时间或次数，因此需要更多计算资源；而FIFO 和Random则只需要记录页面进入内存的时间或随机数，计算资源要求较低。
页面淘汰算法实验报告
操作系统实验报告课题：页面淘汰算法专业：班级：学号：姓名：年月日目录一实验目的 (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. 熟悉虚拟存储器的工作过程，包括地址转换、页面调入/调出等；4. 通过实验加深对虚存管理技术的理解和应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 虚拟存储器管理模拟程序：自行编写三、实验内容1. 虚存管理概述1.1 虚存管理的概念：虚存管理是操作系统内存管理的一个重要组成部分，通过虚拟存储技术，使得应用程序可以使用比实际物理内存更大的存储空间。
1.2 虚存管理的原理：虚存管理通过将程序的逻辑地址空间划分为若干个页面，并将这些页面映射到物理内存的页面中，实现逻辑地址空间与物理内存的映射。
2. 页面置换算法2.1 先进先出（FIFO）算法：FIFO算法是最简单的页面置换算法，按照页面进入内存的顺序进行置换。
2.2 最近最久未使用（LRU）算法：LRU算法将最近最久未使用的页面置换出内存。
2.3 Clock算法：Clock算法是对LRU算法的改进，通过使用一个指针来指示下一个要被置换的页面。
3. 虚拟存储器工作过程3.1 地址转换：当应用程序访问逻辑地址时，CPU将产生一个虚拟地址，操作系统通过地址转换将虚拟地址转换为物理地址。
3.2 页面调入/调出：当访问的页面不在内存中时，操作系统需要将一个页面从内存中调出，并将需要访问的页面调入内存。
4. 实验步骤4.1 编写模拟程序：编写一个模拟虚拟存储器管理的程序，实现页面置换算法、地址转换等功能。
4.2 生成指令地址流：产生一个需要访问的指令地址流，包括顺序执行的指令、均匀分布在前地址部分的指令、均匀分布在后地址部分的指令。
4.3 运行模拟程序：运行模拟程序，观察页面置换过程、地址转换过程以及内存使用情况。
4.4 分析实验结果：分析实验结果，比较不同页面置换算法的性能，分析虚拟存储器在内存使用上的优势。
操作系统实验报告三存储器管理实验
操作系统实验报告三存储器管理实验操作系统实验报告三：存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收的算法，以及页面置换算法的工作过程和性能特点，从而提高对操作系统资源管理的认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容1、内存分配与回收算法实现首次适应算法（First Fit）最佳适应算法（Best Fit）最坏适应算法（Worst Fit）2、页面置换算法模拟先进先出页面置换算法（FIFO）最近最久未使用页面置换算法（LRU）时钟页面置换算法（Clock）四、实验原理1、内存分配与回收算法首次适应算法：从内存的起始位置开始，依次查找空闲分区，将第一个能够满足需求的空闲分区分配给进程。
最佳适应算法：在所有空闲分区中，选择能够满足需求且大小最小的空闲分区进行分配。
最坏适应算法：选择空闲分区中最大的分区进行分配。
2、页面置换算法先进先出页面置换算法：选择最早进入内存的页面进行置换。
最近最久未使用页面置换算法：选择最近最长时间未被访问的页面进行置换。
时钟页面置换算法：给每个页面设置一个访问位，在页面置换时，从指针指向的页面开始扫描，选择第一个访问位为0 的页面进行置换。
五、实验步骤1、内存分配与回收算法实现定义内存分区结构体，包括分区起始地址、大小、是否已分配等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
编写测试程序，创建多个进程，并使用不同的算法为其分配内存，观察内存分配情况和空闲分区的变化。
2、页面置换算法模拟定义页面结构体，包括页面号、访问位等信息。
实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。
编写测试程序，模拟页面的调入和调出过程，计算不同算法下的缺页率，比较算法的性能。
LRU算法与CLOCK算法
LRU算法与CLOCK算法LRU算法是基于页面访问的历史记录的算法。
它的思想是，如果一个页面最近被访问过，那么它在未来一段时间内很可能会被再次访问，因此应该保留在内存中。
而如果一个页面很长时间没有被访问过，那么它在未来也不太可能会被访问，因此可以置换出去。
LRU算法维护一个页面访问历史的队列，每当一个页面被访问时，就将它放到队列的末尾。
当需要置换页面时，选择队列头部的页面进行置换。
这种算法的优点是能够充分利用页面的访问局部性，缺点是需要维护一个较大的队列，当队列过大时，会消耗较多的内存资源。
CLOCK算法则是基于一个“时钟”指针的算法。
它维护一个环形链表，每个节点表示一个页面。
每当需要访问一个页面时，算法检查链表中的节点是否被访问过，如果被访问过，则将对应的访问位设置为1；如果没有被访问过，则将页面置换出去，并且将链表节点设置为下一个节点。
这样，算法通过循环扫描链表，不断地置换页面，直到找到一个未被访问过的页面。
CLOCK算法的优点是，因为没有维护额外的队列，所以不会消耗额外的内存资源。
但是，它不能够准确地反映页面的历史访问情况，因此可能会导致一些频繁访问的页面被错误地置换出去。
从性能上来看，两种算法各有优劣。
LRU算法相对来说能够更好地利用页面的访问局部性，因此在访问模式较为连续的情况下，它通常会有较好的效果。
但是，当访问模式发生变化时，例如从顺序访问变为随机访问，LRU算法可能会导致频繁的页面置换，从而增加开销。
而CLOCK算法虽然不能准确地根据页面的访问情况进行置换，但是它的性能更加稳定，适用于不同类型的访问模式。
在实际应用中，可以根据具体的场景和需求选择合适的页面置换算法。
如果访问模式较为连续且对内存资源有一定要求，可以选择LRU算法；如果访问模式较为随机或者对内存资源有限要求，可以选择CLOCK算法。
此外，还可以综合使用两种算法，根据实际情况进行动态调整。
当然，还有其他的页面置换算法，如FIFO算法、LFU算法等，每种算法都有各自的特点和适用场景。
操作系统虚拟存储与页面置换算法
操作系统虚拟存储与页面置换算法随着计算机技术的发展和应用的广泛，操作系统成为了现代计算机应用必不可少的基础软件之一。
操作系统虚拟存储与页面置换算法是操作系统中重要的概念和机制。
本文将介绍什么是操作系统中的虚拟存储以及页面置换算法，并探讨它们在提升计算机性能和优化内存管理方面的作用。
一、虚拟存储的概念与作用在计算机系统中，虚拟存储是一种将物理内存（RAM）和磁盘存储进行结合的技术。
它通过将物理内存和辅助存储（如硬盘）建立联系，将大于物理内存容量的程序或数据存放在磁盘上。
虚拟存储实现了对大型程序和数据的支持，同时能够优化内存的使用效率。
虚拟存储的基本原理是将虚拟地址空间划分为固定大小的页（Page）或块（Block），与物理内存中的页框（Page Frame）相对应。
当程序执行时，仅有部分页被加载到物理内存，其余部分保留在磁盘上。
虚拟地址空间的划分和管理由操作系统负责。
虚拟存储的作用主要有以下几个方面：1. 提供了对大型程序和数据的支持，使得计算机能够运行更加复杂和庞大的应用程序。
2. 通过将不常使用的页置换到磁盘上，释放物理内存空间，使得内存的使用更加高效。
3. 提高了程序的运行速度，因为虚拟存储可以将常用的页保持在物理内存中，减少了访问磁盘的次数。
二、页面置换算法的原理与分类页面置换算法是虚拟存储中的重要算法，它决定了操作系统在虚拟存储中置换页面时的策略。
常见的页面置换算法有以下几种：1. 最佳置换算法（OPT）最佳置换算法是一种理论上的最优算法，它根据未来一段时间内页面的访问情况，选择最长时间内不再访问的页面进行置换。
然而，最佳置换算法需要预测未来页面访问，实际上无法得知未来的访问序列，因此该算法无法在实际中完美应用。
2. 先进先出算法（FIFO）先进先出算法是最简单的页面置换算法，它按照页面进入物理内存的顺序进行置换。
当物理内存空间不足时，替换最早进入的页面。
但是，FIFO算法无法考虑页面的访问频率和重要性，可能导致较高的缺页率。
缺页中断处理过程和页面置换算法
缺页中断处理过程和页面置换算法是计算机内存管理中的重要概念。
缺页中断是指当程序访问的页面不在内存中时，产生的一种异常。
页面置换算法则是用于在内存中找不到空闲页面时，选择哪个页面将其移出内存，以便为新的页面腾出空间。
下面将详细介绍缺页中断处理过程和页面置换算法的原理及实现。
一、缺页中断处理过程当程序访问一个页面时，首先会检查页表，页表是一个记录了虚拟页号与物理页号映射的数据结构。
如果所要访问的页面在内存中，则直接使用；如果页面不在内存中，则会产生缺页中断。
缺页中断处理过程如下：1. 当发生缺页中断时，CPU会停止当前正在执行的指令，并将控制权交给操作系统。
2. 操作系统收到缺页中断请求后，会查找该页面在磁盘中的位置，并读取该页面数据到内存中。
3. 在内存中找到空闲的页面，将读取的页面数据写入该空闲页面。
4. 更新页表，将虚拟页号与物理页号的映射关系记录到页表中。
5. 重新启动CPU，继续执行之前被中断的指令。
二、页面置换算法当内存中没有空闲页面时，需要选择一个页面将其移出内存，为新的页面腾出空间。
页面置换算法就是用来确定哪个页面被替换的规则。
下面介绍几种常见的页面置换算法：1. 先进先出（FIFO）算法：FIFO算法选择最早进入内存的页面进行替换。
实现时可以使用一个队列来记录每个页面进入内存的时间，当需要替换页面时，选择队列头部的页面进行替换。
FIFO算法简单易实现，但性能较差，可能导致常用页面被频繁替换。
2. 最近最少用（LRU）算法：LRU算法选择最久未使用的页面进行替换。
实现时需要维护一个使用频率的链表，当发生缺页中断时，选择链表头部的页面进行替换。
LRU算法理论上较优，但实现复杂，需要维护链表和访问计数。
3. 最佳置换（OPT）算法：OPT算法选择未来最长时间内不再被访问的页面进行替换。
这是一个理想化的算法，实际中无法实现，但可以用来评估其他算法的性能。
4. 时钟（CLOCK）算法：CLOCK算法结合了FIFO算法和LRU算法的特点，选择距离当前时间最近且最久未使用的页面进行替换。
请求分页系统OPT-LRU-FIFO-CLOCK示例
在一个请求分页系统中，假如系统分配一个作业的物理块数为3，且此作业的页面走向为2 ,3 , 2 ,1 ,5 ,2 ,4 ,5 , 3 2 5 2则OPT,LRU,FIFO,CLOCK算法的页面置换次数为？1.首先是OPT算法的求解过程：2 3 2 1 5 2 4 5 3 2 5 2页面走向2 2 2 2 2 2 4 4 4 2 2 2物理块13 3 3 3 3 3 3 3 3 3 3物理块21 5 5 5 5 5 5 5 5物理块3是是否是是否是否否是否否是否缺页是否否否否否是否是否否是否否置换由表中可知缺页次数为6，置换次数为3.OPT通常可保证获得的最低的缺页率，可以利用此算法去评价其他的页面置换算法。
OPT置换算法是一种理想算法，因为人们还无法预知哪一个页面在未来最长时间不再被访问。
2.下面是LRU 页面置换算法求解过程：2 3 2 1 5 2 4 5 3 2 5 2页面走向2 2 2 2 2 2 2 23 3 3 3物理块13 3 3 5 5 5 5 5 5 5 5物理块21 1 1 4 4 42 2 2物理块3是是否是是否是否是是否否是否缺页是否否否否否是否是否是是否否置换由表中可知缺页次数为7，置换次数为4.LRU置换算法是选择最近最久未使用的页面予以淘汰。
LRU需要寄存器或栈的硬件支持。
3.下面是FIFO 页面置换算法求解过程： 页面走向 2 3 2 1 5 2 4 5 3 2 5 2 物理块1 2 2 2 2 5 5 5 5 3 3 3 3 物理块2 3 3 3 3 2 2 2 2 2 5 5 物理块31 1 1 4 4 4 4 42 是否缺页 是 是 否 是 是 是 是 否 是 否 是 是 是否置换否 否否否是是是否是否是是由上表可知：缺页次数为9次，页面置换次数为6次。
FIFO 总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
4.下面是CLOCK 页面置换算法求解过程：（括号内的0,1表示访问标记。
cache缓存淘汰算法--LRU算法
缓存淘汰算法--LRU算法1. LRU1.1. 原理LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。
1.2. 实现最常见的实现是使用一个链表保存缓存数据，详细算法实现如下：1. 新数据插入到链表头部；2. 每当缓存命中（即缓存数据被访问），则将数据移到链表头部；3. 当链表满的时候，将链表尾部的数据丢弃。
1.3. 分析【命中率】当存在热点数据时，LRU的效率很好，但偶发性的、周期性的批量操作会导致LRU命中率急剧下降，缓存污染情况比较严重。
【复杂度】实现简单。
【代价】命中时需要遍历链表，找到命中的数据块索引，然后需要将数据移到头部。
2. LRU-K2.1. 原理LRU-K中的K代表最近使用的次数，因此LRU可以认为是LRU-1。
LRU-K的主要目的是为了解决LRU算法“缓存污染”的问题，其核心思想是将“最近使用过1次”的判断标准扩展为“最近使用过K次”。
2.2. 实现相比LRU，LRU-K需要多维护一个队列，用于记录所有缓存数据被访问的历史。
只有当数据的访问次数达到K次的时候，才将数据放入缓存。
当需要淘汰数据时，LRU-K会淘汰第K次访问时间距当前时间最大的数据。
详细实现如下：1. 数据第一次被访问，加入到访问历史列表；2. 如果数据在访问历史列表里后没有达到K次访问，则按照一定规则（FIFO，LRU）淘汰；3. 当访问历史队列中的数据访问次数达到K次后，将数据索引从历史队列删除，将数据移到缓存队列中，并缓存此数据，缓存队列重新按照时间排序；4. 缓存数据队列中被再次访问后，重新排序；5. 需要淘汰数据时，淘汰缓存队列中排在末尾的数据，即：淘汰“倒数第K次访问离现在最久”的数据。
LRU-K具有LRU的优点，同时能够避免LRU的缺点，实际应用中LRU-2是综合各种因素后最优的选择，LRU-3或者更大的K值命中率会高，但适应性差，需要大量的数据访问才能将历史访问记录清除掉。
巡回置换算法实验结论
巡回置换算法实验结论巡回置换算法是一种常见的页面置换算法，被广泛应用于操作系统中的虚拟存储管理中，用于优化页面的访问效率。
该算法以首次使用最远（Furthest In Use）的页面为置换对象，通过淘汰最长时间未被访问的页面，以提高整体访问效率。
在巡回置换算法的实验中，我们对比了三种不同的页面置换算法，分别是先进先出算法（FIFO）、最近最少使用算法（LRU）和巡回置换算法（CLOCK），通过模拟虚拟存储管理中的页面置换情况，观察和分析了三种算法的性能表现。
实验结果如下：首先，对于随机访问的情况（Random Access），我们发现巡回置换算法的性能要优于FIFO算法，但略逊于LRU算法。
这是因为巡回置换算法相较于FIFO算法，能够更好地应对随机性的访问模式，通过选择使用时间最长的页面进行置换，避免了过多未被访问的页面进入内存，降低了缺页率。
然而，与LRU算法相比，巡回置换算法的性能略有不足，因为LRU算法能够更准确地判断页面的使用频率，倾向于保留长时间内未使用的页面，同时淘汰不常使用的页面，因此在随机访问的场景下相对更为优秀。
其次，在局部性访问的情况下（Locality Access），我们发现巡回置换算法的性能相比FIFO算法和LRU算法，都有一定程度的提升。
这是因为局部性原理指出，在程序的执行中，会出现时间上的局部性和空间上的局部性。
巡回置换算法能够更好地利用时间上的局部性，保留使用时间更长的页面，从而提高命中率，减少了缺页次数。
与此相比，FIFO算法只根据页面的进入先后进行置换，无法有效地利用程序执行的局部性特征；而LRU算法需要维护页面的访问顺序，消耗较大的计算资源。
最后，在算法开销（Algorithm Overhead）方面，巡回置换算法的开销相对较低。
FIFO算法的开销主要集中在更新页面队列的操作，需要频繁地调整队列中页面的顺序；LRU算法的开销则在于维护每个页面的访问时间戳，需要不断地更新时间戳信息。
clock页面置换算法例题详解(一)
clock页面置换算法例题详解(一)时钟页面置换算法例题引言•页面置换算法是操作系统中的重要概念之一，它用于管理计算机的内存空间，提高系统的效率和性能。
•时钟页面置换算法是一种常用的页面置换算法，本文将详细解释该算法，并给出一个例题的实现过程和步骤。
时钟页面置换算法概述•时钟页面置换算法也被称为最近未使用（LRU）页面置换算法的近似算法。
•该算法基于钟表的原理，维护一个类似于指针的数据结构，用于标记内存中的页面是否被访问。
•当需要置换页面时，算法会依次扫描指针指向的页面，判断其是否被访问过。
如果页面未被访问，则置换该页面，否则将其访问位重置为0。
•这样，算法可以根据页面的访问情况进行页面置换，提高系统的性能和效率。
时钟页面置换算法的实现步骤1.初始化时钟指针指向内存中的第一个页面。
2.当需要置换页面时，根据指针指向的页面的访问位进行判断。
3.如果访问位为0，则置换该页面，并将指针指向下一个页面。
4.如果访问位为1，则将访问位重置为0，并将指针指向下一个页面。
5.重复步骤2-4，直到找到一个访问位为0的页面进行置换。
时钟页面置换算法的例题假设系统中有5个页面，并且页面的访问情况如下表所示：页面 A B C D E访问位 1 0 1 0 1现在需要置换一个页面，请根据时钟页面置换算法进行置换。
1.初始化时钟指针指向页面A。
2.根据指针指向的页面A的访问位为1，将访问位重置为0，并将指针指向下一个页面B。
3.根据指针指向的页面B的访问位为0，将页面B置换，并将指针指向下一个页面C。
4.根据指针指向的页面C的访问位为1，将访问位重置为0，并将指针指向下一个页面D。
5.根据指针指向的页面D的访问位为0，将页面D置换，并将指针指向下一个页面E。
6.根据指针指向的页面E的访问位为1，将访问位重置为0，并将指针指向下一个页面A。
7.根据指针指向的页面A的访问位为0，将页面A置换。
根据以上步骤，最终置换的页面为页面B。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告课程名称操作系统实验项目名______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],回车，实验结果将显示出该组数据的淘汰页面号、缺页次数和缺页率。
注：实验结果中，输入的数据为：[12560 36536 56042 70435]。
LRU算法编译后的结果如下：（3）编译时出现的错误：调试时出错情况有三类：1）低级错误。
编写时字母写错，‘}’或‘；’丢失，等；2）警告错误。
使用指针错误，或定义的指针没有使用等；3）匹配错误。
在编译子程序时出现类型不匹配，以及一些语法错误等。
2、CLOCK算法（1）预备知识当采用简单Clock算法时，只需为每页设置一位访问位，再将内存中的所有页面都通过链接指针链接成一个循环队列。
当某页被访问时，其访问位被置1。
置换算法在选择一页淘汰时，只需检查页的访问位。
如果是0，就选择该页换出；若为1，则重新将它置0，暂不换出，而给该页第二次驻留内存的机会，再按照FIFO算法检查下一个页面。
当检查到队列中的最后一个页面时，若其访问位仍为1，则再返回到队首去检查第一个页面。
下图展示了该算法的流程和示例。
由于该算法是循环地检查各页面的使用情况，故称为Clock 算法。
但因该算法只有一位访问位，只能用它表示该页是否已经使用过，而置换时是将未使用过的页面换出去，故又把该算法称为最近未用算法NRU(Not Recently Used)。
(2)具体的操作代码如下：#include"StdAfx.h"#include<stdio.h>#include <time.h>#include <stdlib.h>#define M 3 //内存物理块数#define N 20 //虚拟内存尺寸int P; //工作集的起始位置int nin; //记录缺页次数//用于CLOCK算法的页面定义typedef struct page_clock{int num;int visit;替换指针}Page_clock;//用于改进的CLOCK算法的页面定义typedef struct page{int num; //页面号int visit; //是否访问int modify; //是否修改}Page;Page_clock b_clock[M]; //内存单元数ClockPage b[M]; //updating_clockint opt[M]; //optint ran[M]; //random replacementint fifo[M]; //FIFOint c[M][N]; //存储每个阶段状态//访问序列随机生成e个，e是工作集中包含的页数，m是工作集移动率void generate_list(int *list, int e, int m, int t){int i, j = 0, q =P, r;srand((unsigned)time(NULL));while (j < e){for (i = j;i < j + m;i++){if (i == e)break;list[i] = (q + rand() % e) % N; /*保证在虚拟内存的页号内*/ }j = i;r = rand() % 100;if (r < t)q = rand() % N;elseq = (q + 1) % N;}}//随机生产是否被修改的情况，prop(0...100)，prop/100的概率未被修改void generate_modify(int *mo, int e, int prop){int i, t;for (i = 0;i < e;i++){t = rand() % 100;if (t > prop)mo[i] = 0;elsemo[i] = 1;}}//格式输出void print_format(int e){int i;printf(" ");for (i = 1;i < e;i++)printf(" ");printf(" \n");}//结果输出void print(int e,int *a){int j, i;print_format(e);for(j = 0;j < e;j++){printf(" %2d ",a[j]); //读入内存顺序}printf(" \n");printf("置换过程：");print_format(e);for(i = 0;i < M;i++){for(j = 0;j < e;j++){if(c[i][j] == -1)printf(" %c ",' ');elseprintf(" %2d ",c[i][j]);}printf(" \n");}print_format(e);}//Clock算法初始化void Init_Clock(Page_clock *b_clock){nin = 0;int i, j;for(i = 0;i < M;i++){b_clock[i].num = -1;b_clock[i].visit = 0;}for(i = 0;i < M;i++){for(j = 0;j < N;j++){c[i][j] = -1;}}}//改进的Clock算法初始化void Init_updatingClock(Page *b) {nin = 0;int i, j;for(i = 0;i < M;i++){b[i].num = -1;b[i].visit = 0;b[i].modify = 0;}for(i = 0;i < M;i++){for(j = 0;j < N;j++){c[i][j] = -1;}}}//Clock算法void Clock(int fold,Page_clock *b_clock) {int i, val = -1, p = 0; //p为查询指针for (i = 0;i < M;i++){if (fold == b_clock[i].num)val = i;}//页面在内存中if (val >= 0){b_clock[val].visit = 1;for(i = 0;i < M;i++){if (i != val){b_clock[i].visit = 0;}}}else{nin++;//初始化内存for (i = 0;i < M;i++){if (b_clock[i].num == -1){val = i;break;}}while (val < 0){if (b_clock[p].visit == 0)val = p;elseb_clock[p].visit = 0;p = (p + 1) % M;}b_clock[val].num = fold;b_clock[val].visit = 1;for(i = 0;i < M;i++){if (i != val){b_clock[i].visit = 0;}}}}//改进的Clock算法void Updating_Clock(int fold,int modiff, Page *b) { int i, p = -1; //p是查询指针int val = -1;//找是否在内存中for(i = 0;i < M;i++){if (fold == b[i].num)val = i;}if (val >= 0){b[val].visit = 1; //被访问b[val].modify = modiff;for(i = 0;i < M;i++){if (i != val){b[i].visit = 0;}}}else{nin++;//初始化内存for (i = 0;i < M;i++){if (b[i].num == -1){val = i;break;}}while (val < 0){//第一步扫描for (i = 0;i < M;i++){p = (p + 1) % M;if ((b[p].modify == 0) && (b[p].visit == 0)){val = p;break;}}//第二步扫描if (val < 0){for (i = 0;i < M;i++){p = (p + 1) % M;if ((b[p].modify == 1) && (b[p].visit == 0)){val = p;break;}else{b[p].visit = 0;}}}}//找到后，其他设置为未访问b[val].num = fold;b[val].modify = modiff;b[val].visit = 1;for(i = 0;i < M;i++){if (i != val){b[i].visit = 0;}}}}//主程序void main(){int a[N];int mo[N];int i,j;//产生随机访问串及是否修改串P = 1;int e, m, prop, t;printf("请输入工作集中包含的页数e和工作集移动率m:\n");scanf("%d %d",&e,&m);t = 50;generate_list(a, e, m, t);printf("请输入页面被修改的概率(*100):\n");scanf("%d",&prop);generate_modify(mo, e, prop);//Clock算法实现Init_Clock(b_clock);for(i = 0;i < e;i++){Clock(a[i],b_clock);for(j = 0;j < M;j++){c[j][i] = b_clock[j].num;}}printf("Clock算法的内存状态为：\n");print(e, a);nin = nin - M;printf("缺页次数为：%d\n缺页率：%.2f\n",nin,nin * 1.0 / e);printf("\n");//改进的Clock算法实现Init_updatingClock(b);for(i = 0;i < e;i++){Updating_Clock(a[i], mo[i], b);for(j = 0;j < M;j++){c[j][i] = b[j].num;}}printf("改进的Clock算法的内存状态为：\n");print(e, a);for(j = 0;j < e;j++){printf(" %2d ",mo[j]); //是否修改序列串}printf(" \n");print_format(e);nin = nin - M;printf("缺页次数为：%d\n缺页率：%.2f\n",nin,nin * 1.0 / e);printf("\n");}Clock算法实验运行结果:五、实验分析（1）页块数可变，LRU算法结果正确。