操作系统实验三——页面替换算法的比较研究

最新推荐文章于 2025-08-05 19:50:13 发布
原创 最新推荐文章于 2025-08-05 19:50:13 发布 · 3.7k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #stream #数据结构 #null #测试 #存储

本文介绍了一个关于页面替换算法的实验，通过模拟不同指令跳转率下各种算法的缺页率表现，包括最佳替换、FIFO、LRU、CLOCK及随机替换算法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在本实验中，引用串的长度为100000个，生成方法为按照给定的指令跳转率随即生成，指令跳转率由调用函数给出。由于指令的跳转率对最终的各种替换算法的缺页率有明显的影响，所以，在实验中，我用一组不同的跳转率来测试在不同指令跳转条件下不同算法的缺页率。

另外，实验中使用的内存的页面数为10，虚拟存储器中的页面总是为100。

 

以下是程序中定义的一些数据结构和函数原形：

#define STREAM_LEN 100000

#define MAX_PAGE_NO 100

#define WORK_PAGES 10

 

typedef enum {BEST_REP, FIFO_REP, LRU_REP, CLOCK_REP, RAND_REP} REP;

 

void best_rep(int *stream, int pos, int *memory);

void fifo_rep(int *stream, int pos, int *memory);

void lru_rep(int *stream, int pos, int *memory);

void clock_rep(int *stream, int pos, int *memory);

void rand_rep(int *stream, int pos, int *memory);

 

各种替换算法如课本中所述，再次不再重复。

page_stream.cpp

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "page_stream.h"

void generateStream(int stream[], int stream_len, double jumpRate, int maxPageNo, int workPages) {
 srand((unsigned)time(NULL));
 int startPageRange = maxPageNo - workPages + 1;

 int startPage = getStartPage(startPageRange);
 int position = 0;
 while (true) {
  position = genSubStr(stream, position, startPage);
  if (position == stream_len)
   break;
  if (genRate() < jumpRate)
   startPage = getStartPage(startPageRange);
 }

 return;
}

int getStartPage(int range) {
 return (rand() % (range + 1));
}

double genRate() {
 return ((double)rand())/RAND_MAX;
}

int genSubStr(int stream[], int startPosition, int startPage) {
 for (int i = 0; i < 10; i++) {
  stream[startPosition + i] = startPage + (rand()%10);
 }

 return startPosition + i;
}

replace_fun.cpp

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "replace_fun.h"

bool in_mem(int page, int *memory) {
 for (int i = 0; i < WORK_PAGES; i++) {
  if (memory[i] == page) {
   return true;
  }
 }

 return false;
}

void replacePage(int *stream, int *memory, REP rep, int pos) {
 switch (rep) {
 case BEST_REP:
  best_rep(stream, pos, memory);
  break;
 case FIFO_REP:
  fifo_rep(stream, pos, memory);
  break;
 case LRU_REP:
  lru_rep(stream, pos, memory);
  break;
 case CLOCK_REP:
  clock_rep(stream, pos, memory);
  break;
 case RAND_REP:
  srand((unsigned)time(NULL));
  rand_rep(stream, pos, memory);
  break;
 }
}

static int lruAid[WORK_PAGES] = {0};
void updateLRU(int *memory, int page) {
 for (int i = 0; i < WORK_PAGES; i++) {
  lruAid[i]++;
 }
 for (i = 0; i < WORK_PAGES; i++) {
  if (memory[i] == page) {
   lruAid[i] = 0;
   break;
  }
 }

 return;
}

static int clockAid[WORK_PAGES] = {0};
void updateClock(int *memory, int page) {
 for (int i = 0; i < WORK_PAGES; i++) {
  if (memory[i] == page) {
   clockAid[i] = 1;
   break;
  }
 }

 return;
}

double run(int *stream, int *memory, REP rep) {
 int pos = 0;
 int replaceTimes = 0;
 for (pos = 0; pos < STREAM_LEN;) {
  if (in_mem(stream[pos], memory)) {
   if (rep == LRU_REP) {
    updateLRU(memory, stream[pos]);
   }
   else if (rep == CLOCK_REP) {
    updateClock(memory, stream[pos]);
   }
   pos++;
   continue;
  }
  else {
   replacePage(stream, memory, rep, pos);
   replaceTimes++;
  }
 }
 
 return ((double)replaceTimes)/STREAM_LEN;
}

bool check(int *memTemp, int check_page, int replace_page, int *memory) {
 int k = 0;
 for (int i = 0; i < WORK_PAGES; i++) {
  if (memTemp[i] == -1) {
   k++;
  }
  if (memTemp[i] == check_page) {
   memTemp[i] = -1;
   k++;
  }
 }
 if (k == WORK_PAGES-1) {
  for (int i = 0; i < WORK_PAGES; i++) {
   if (memTemp[i] != -1)
    break;
  }
  memory[i] = replace_page;
  return true;
 }

 return false;
}

void best_rep(int *stream, int pos, int *memory) {
 int temp[WORK_PAGES];
 for (int i = 0; i < WORK_PAGES; i++) {
  temp[i] = memory[i];
 }

 int posTemp = pos + 1;
 bool hasReplaced = false;
 while (posTemp != STREAM_LEN) {
  hasReplaced = check(temp, stream[posTemp], stream[pos], memory);
  if (hasReplaced)
   break;
  else
   posTemp++;
 }
 if (!hasReplaced) {
  for (int i = 0; i < WORK_PAGES; i++) {
   if (temp[i] != -1)
    break;
  }
  memory[i] = stream[pos];
 }

 return;
}

void fifo_rep(int *stream, int pos, int *memory) {
 static int oldest = -1;
 memory[(oldest ++) % WORK_PAGES] = stream[pos];

 return;
}

void lru_rep(int *stream, int pos, int *memory) {
 int k = 0, temp = -1;
 for (int i = 0; i < WORK_PAGES; i++) {
  if (lruAid[i] > temp) {
   temp = lruAid[i];
   k = i;
  }
 }

 memory[k] = stream[pos];
 lruAid[k] = 0;

 return;
}

static int clockPointer = 0;
void clock_rep(int *stream, int pos, int *memory) {
 while (true) {
  if (clockAid[clockPointer] == 1) {
   clockAid[clockPointer] = 0;
   clockPointer = (clockPointer + 1) % WORK_PAGES;
  }
  else if (clockAid[clockPointer] == 0) {
   break;
  }
 }

 memory[clockPointer] = stream[pos];
 
 return;
}

void rand_rep(int *stream, int pos, int *memory) {
 memory[rand()%WORK_PAGES] = stream[pos];

 return;
}

main.cpp

#include <stdio.h>
#include <memory.h>
#include "page_stream.h"
#include "main.h"
#include "replace_fun.h"

main() {
 int stream[STREAM_LEN];
 int memory[WORK_PAGES];
 double jumpRate;

 jumpRate = 0.4;
 memset(memory, -1, WORK_PAGES);
 generateStream(stream, STREAM_LEN, jumpRate, MAX_PAGE_NO, WORK_PAGES);
 int i = 0, j = 0;
 do {
  if (!in_mem(stream[j], memory)) {
   memory[i++] = stream[j++];
  }
  else {
   j++;
  }
 } while (i < WORK_PAGES);

 printf("指令跳转率为%f时：/n/n", jumpRate);
 printf("最佳替换算法缺页率：/n");
 printf("%f/n", run(stream, memory, BEST_REP));
 printf("随机替换算法缺页率：/n");
 printf("%f/n", run(stream, memory, RAND_REP));
 printf("先进先出替换算法缺页率：/n");
 printf("%f/n", run(stream, memory, FIFO_REP));
 printf("最近最久未使用替换算法缺页率：/n");
 printf("%f/n", run(stream, memory, LRU_REP));
 printf("CLOCK替换算法缺页率：/n");
 printf("%f/n", run(stream, memory, CLOCK_REP));

 return 0;
}

ffee
关注
虚拟内存页面置换算法的模拟与实现
qq_45977332的博客
07-08 3941
实验内容 (1)假设每个页面中可存放 10 条指令，分配给一作业的内存块（页框）数为 4。 (2)用 C 语言模拟一作业的执行过程，该作业共有 320 条指令，即它的地址空间为 32 页，目前 它的所有页都还未调入内存。在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。如果所访问的指令还未装入内存，则发生缺页，此时须记录缺页的次数，并将相应 页调入内存;如果 4 个内存块中均已装入该作业，则需进行页面置换;最后显示其物理地址，并转下 一条指令。在所有 320 条指令执行完毕
几种页面置换算法的比较（word文档）
03-31
通过VC程序来实现请求调页式存储管理的几种基本页面置换算法，并通过对页面、页表、地址转换和页面置换过程的模拟，来比较页面置换的几种算法的效率，从而得出OPT算法在同等条件下缺页率最小，而LRU和FIFO算法的缺页率基本相同
页面置换算法的模拟与比较
kilig_CSM的博客
06-13 1001
综合来看，这三种算法各有优劣，适用于不同的场景和需求。OPT 算法是理论上的最优算法，但实际应用受限；FIFO 算法简单但可能导致 Belady’s anomaly；LRU 算法相对较好地平衡了性能和复杂性，常用于实际系统中。在选择算法时，需要考虑内存容量、页面访问模式以及算法的实现复杂性等因素。
存储管理页面置换算法模拟实现及比较
qq_44808056的博客
07-03 6520
存储管理页面置换算法模拟实现及比较 1、目的 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。页式管理中页面置换算法，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 2、学年设计内容 （1）通过随机数产生一个指令序列，共320条指令。 指令的地址按下述原则生成： ①一半的指令是顺序执行的； ②四分之一的指令是均匀分布在前地址部分； ③四分之一的指令是均匀分布在前地址部分。 具体的实施办法是： ① 在[0，319]之间选一起点m； ② 顺序执行一条指令，即m+
页面置换算法的模拟实现及命中率对比
12-13
一、课程设计目的 通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储技术的特点，掌握请 求页式存储管理中的页面置换算法。 容 二、课程设计内容 模拟实现 OPT（最佳置换）、FIFO 和 LRU 算法，并计算缺页率。 示 三、要求及提示 本题目必须单人完成。 1、首先用随机数生成函数产生一个“指令将要访问的地址序列”，然后将地址序列变换 成相应的页地址流（即页访问序列），再计算不同算法下的命中率。 2、通过随机数产生一个地址序列，共产生 400 条。其中 50%的地址访问是顺序执行的， 另外 50%就是非顺序执行。且地址在前半部地址空间和后半部地址空间均匀分布。具体产 生方法如下： 1) 在前半部地址空间，即[0，199]中随机选一数 m，记录到地址流数组中（这是 非顺序执行）； 2) 接着“顺序执行一条指令”，即执行地址为 m+1 的指令，把 m+1 记录下来； 3) 在后半部地址空间，[200，399]中随机选一数 m’，作为新指令地址； 4) 顺序执行一条指令，其地址为 m’+1； 5) 重复步骤 1~4，直到产生 400 个指令地址。 3、将指令地址流变换成页地址（页号）流，简化假设为： 1) 页面大小为 1K（这里 K 只是表示一个单位，不必是 1024B）； 2) 用户虚存容量为 40K； 3) 用户内存容量为 4 个页框到 40 个页框； 6 4) 用户虚存中，每 K 存放 10 条指令，所以那 400 条指令访问地址所对应的页地 址（页号）流为：指令访问地址为[0，9]的地址为第 0 页；指令访问地址为[10， 19]的地址为第 1 页；……。按这种方式，把 400 条指令组织进“40 页”，并 将“要访问的页号序列”记录到页地址流数组中。 4、循环运行，使用户内存容量从 4 页框到 40 页框。计算每个内存容量下不同页面置换 算法的命中率。输出结果可以为： 页框数 OPT 缺页率 FIFO 缺页率 LRU 缺页率 [4] OPT：0.5566 FIFO：0.4455 LRU：0.5500 [5] OPT：0.6644 FIFO：0.5544 LRU：0.5588 …… …… …… …… [39] OPT：0.9000 FIFO：0.9000 LRU：0.9000 [40] OPT：1.0000 FIFO：1.0000 LRU：1.0000 注 1：在某一次实验中，可能 FIFO 比 LRU 性能更好，但足够多次的实验表明 LRU 的平均性能比 FIFO 更好。 注 2：计算缺页率时，以页框填满之前和之后的总缺页次数计算。
东南大学操作系统实验——实现LRU算法及其近似算法
06-30
在本实验中，学生将深入理解操作系统的内存管理机制，特别是LRU（Least Recently Used，最近最少使用）页面置换算法。LRU算法是一种常见的虚拟内存管理策略，它根据页面的使用历史来决定替换哪个页面。当内存中的...
《操作系统实验2——规划书》.rar_操作系统 代码_操作系统实验
09-21
在《操作系统实验2——规划书》.doc中，你可能会找到关于实验目标、步骤、预期结果和评估标准的详细信息。实验报告通常要求你阐述所采用的存储管理策略，分析其性能，并对比不同策略的影响。此外，你可能还需要设计...
操作系统实验——内存管理之页面置换算法
12-15
在这个实验中，我们将探讨内存管理中的一个重要概念——页面置换算法。页面置换算法是解决虚拟内存中缺页问题的关键技术，当物理内存不足时，它会选择将部分内存中的页面移出到磁盘的对换区，为新进来的页面腾出空间...
基于C语言的操作系统实验——内存管理.zip
04-21
在基于C语言的操作系统实验中，内存管理是一个关键领域，它涉及到如何有效地分配、使用和回收内存，以确保系统的高效运行。这个实验将帮助我们深入理解内存管理的基本原理和实现机制。 在C语言中，内存主要分为四个...
操作系统-页面置换算法的模拟实现及命中率对比
12-25
实验报告 内涵代码（1）、通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储 术的特点，掌握请求页式存储管理中的页面置换算法。 （2）、课程设计内容 模拟实现OPT（最佳置换）、FIFO和LRU算法，并计算命中率。 （3） 、课程设计要求：
操作系统实验：页面置换算法的模拟实现及命中率对比.rar
06-28
本资源使用Java实现了页面置换算法OPT、FIFO、LRU的模拟实现以及FIFO和LRU的命中率对比，内容包括Java源项目、jar包和bat文件。该资源的文字版信息请访问博客《操作系统实验：页面置换算法的模拟实现及命中率对比（学习笔记）》（https://blog.youkuaiyun.com/weixin_40589192/article/details/106997447）。
操作系统：模拟页面替换算法
12-23
（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响 。 （2）实现对FIFO，LRU算法的模拟
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
热门推荐
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
页面置换实验
NeutronShip的博客
04-11 343
设计结构体存放页面调度顺序串及内存块，分别模拟FIFO置换调度算法、LRU置换调度算法以及OPT置换调度算法进行页面调度，分别打印输出3种置换算法调度后的内存块状态结果，在缺页的列对应输出缺页标志，计算缺页次数及缺页率。
南邮 | 操作系统实验三：存储管理
Wonz
02-09 5264
理解操作系统存储管理原理。 研读Linux 内存管理所用到的文件include/linux/mm.h,主要包括两个数据结构：mem_map、free_area。 在Linux 下，用malloc（）函数实现cat或copy命令。 例程1 申请内存、使用内存以及释放一块内存 #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; //exi...
南邮操作系统——实验3——存储管理
qq_43808588的博客
01-19 2479
实验目的 1、理解操作系统存储管理原理 操作系统的发展使得系统完成了大部分的内存管理工作。对于程序员而言，这些内存管理的过程完全透明不可见。因此，程序员开发时从不关心系统如何为自己分配内存，而且永远认为系统可以分配给程序所需要的内存。在程序开发时，程序员真正需要做的就是：申请内存、使用内存、释放内存，其他一概无需过问。 2、研读Linux 内存管理所用到的文件include/linux/mm...
贝叶斯分类算法详解：从数学原理到实践应用
最新发布
weixin_73958875的博客
08-05 722
本文系统介绍了贝叶斯分类算法及其应用。首先阐述了贝叶斯定理的数学原理，包括朴素贝叶斯的特征独立性假设及其三种主要实现形式（高斯、多项式和伯努利贝叶斯）。然后详细解析了Scikit-learn中贝叶斯分类器的API参数和使用方法，包括关键参数调优建议。最后通过垃圾邮件分类案例展示了实际应用流程，并分析了贝叶斯算法在计算效率、内存消耗等方面的优势，以及特征独立性假设带来的局限性。全文为读者提供了从理论到实践的完整贝叶斯分类器应用指南。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值