页面置换算法C语言实现(FIFO,OPT,LRU)

最新推荐文章于 2024-06-13 09:32:57 发布
最新推荐文章于 2024-06-13 09:32:57 发布
阅读量2.5k 收藏 22
点赞数
文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50019806/article/details/125100346
版权 
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

#define NUM_OF_INSTRUSTIONS 320

void generate_instrustions(__u_int* instrustions,__u_int* original_page_address_flow)
{
  __u_int page_no = 0;
  for(size_t i = 0;i < NUM_OF_INSTRUSTIONS;i += 4) {
    __u_int begin;
    do
    {
      begin = (__u_int)rand() % NUM_OF_INSTRUSTIONS;
    } while (begin == 319);
    instrustions[i] = begin + 1;
    original_page_address_flow[i] = (begin + 1) / 10;
    __u_int before;
    do
    {
      before = (__u_int)rand() % ((begin + 1) + 1) + 0;
    } while (before > 317);
    instrustions[i + 1] = before;
    original_page_address_flow[i + 1] = before / 10;
    instrustions[i + 2] = before + 1;
    original_page_address_flow[i + 2] = (before + 1) / 10;
    __u_int after = (__u_int)rand() % (319 - (before + 2) + 1) + (before + 2);
    instrustions[i + 3] = after;
    original_page_address_flow[i + 3] = after / 10;
  }
}

__u_int merge(__u_int* original_page_address_flow,__u_int* page_address_flow)
{
  __u_int num_of_page_address_flow = 0;
  for(size_t i = 0;i < NUM_OF_INSTRUSTIONS;++i) {
    if(i == 0) {
      page_address_flow[num_of_page_address_flow] = original_page_address_flow[i];
      ++num_of_page_address_flow;
    }
    else {
      if(original_page_address_flow[i] != original_page_address_flow[i - 1]) {
        page_address_flow[num_of_page_address_flow] = original_page_address_flow[i];
        ++num_of_page_address_flow;
      }
    }
  }
  return num_of_page_address_flow;
}

void print_current_state(__u_int* array,__u_int length)
{
  for(__u_int i = 0;i < length;++i) {
    printf("%d ",array[i]);
  }
  printf("\n");
}

void fifo_algorithm(__u_int num_of_blocks,__u_int* page_address_flow,__u_int num_of_page_address_flow)
{
  assert(num_of_blocks);
  __u_int num_of_interrupt = 0;
  __u_int current_index = 0;
  __u_int blocks[num_of_blocks];
  memset((void*)blocks,-1,sizeof(blocks));
  for(__u_int i = 0;i < num_of_page_address_flow;++i) {
    printf("Current page address flow:%d\n",page_address_flow[i]);
    int find = 0;
    for(__u_int j = 0;j < num_of_blocks;++j) {
      if(blocks[j] == page_address_flow[i]) {
        find = 1;
        break;
      }
    } 
    if(!find) {
      ++num_of_interrupt;
      blocks[current_index] = page_address_flow[i];
      current_index = (++current_index) % num_of_blocks;
      print_current_state(blocks,num_of_blocks);
    }
  }
  printf("Number of page missing interrupts:%d\n",num_of_interrupt);
  float page_fault_rate = num_of_interrupt / (float)num_of_page_address_flow;
  printf("Page falut rate:%f\n",page_fault_rate);
}

void opt_algorithm(__u_int num_of_blocks,__u_int* page_address_flow,__u_int num_of_page_address_flow)
{
  assert(num_of_blocks);
  __u_int num_of_interrupt = 0;
  __u_int blocks[num_of_blocks];
  memset((void*)blocks,-1,sizeof(blocks));
  for(__u_int i = 0;i < num_of_page_address_flow;++i) { 
    printf("Current page address flow:%d\n",page_address_flow[i]);
    int find = 0;
    for(__u_int j = 0;j < num_of_blocks;++j) {
      if(blocks[j] == page_address_flow[i]) {
        find = 1;
        break;
      }
    }
    if(!find) {
      ++num_of_interrupt;
      __u_int distance[num_of_blocks];
      for(__u_int j = 0;j < num_of_blocks;++j) {
        distance[j] = __UINT16_MAX__;
      }
      for(__u_int j = i + 1;j < num_of_page_address_flow;++j) {
        for(__u_int n = 0;n < num_of_blocks;++n) {
          if(page_address_flow[j] == blocks[n] && distance[n] > j) {
            distance[n] = j;
            break;
          }
        }
      }
      __u_int target_index = 0;
      __u_int max_distance = distance[target_index];
      for(__u_int j = 0;j < num_of_blocks;++j) {
        if(distance[j] == __UINT16_MAX__) {
          target_index = j;
          break;
        }
        if(distance[j] > max_distance) {
          target_index = j;
          max_distance = distance[j];
        }
      }
      blocks[target_index] = page_address_flow[i];
      print_current_state(blocks,num_of_blocks);
    }
  }
  printf("Number of page missing interrupts:%d\n",num_of_interrupt);
  float page_fault_rate = num_of_interrupt / (float)num_of_page_address_flow;
  printf("Page falut rate:%f\n",page_fault_rate);
}

void lru_algorithm(__u_int num_of_blocks,__u_int* page_address_flow,__u_int num_of_page_address_flow)
{
  assert(num_of_blocks);
  __u_int num_of_interrupt = 0;
  __u_int blocks[num_of_blocks];
  memset((void*)blocks,-1,sizeof(blocks));
  int interval[num_of_blocks];
  for(__u_int i = 0;i < num_of_blocks;++i)
    interval[i] = __UINT16_MAX__;
  for(__u_int i = 0;i < num_of_page_address_flow;++i) {
    printf("Current page address flow:%d\n",page_address_flow[i]);
    int find = 0;
    for(__u_int j = 0;j < num_of_blocks;++j) {
      if(page_address_flow[i] == blocks[j]) {
        find = 1;
        interval[j] = 0;
        break;
      }
    }
    if(!find) {
      ++num_of_interrupt;
      __u_int target_index = 0;
      __u_int max_interval = interval[target_index];
      for(__u_int j = 0;j < num_of_blocks;++j) {
        if(interval[j] > max_interval) {
          target_index = j;
          max_interval = interval[j];
        }
      }
      blocks[target_index] = page_address_flow[i];
      interval[target_index] = 0;
      print_current_state(blocks,num_of_blocks);
    }
    for(__u_int j = 0;j < num_of_blocks;++j) {
      if(interval[j] != __UINT16_MAX__)
        ++interval[j];
    }
  }
  printf("Number of page missing interrupts:%d\n",num_of_interrupt);
  float page_fault_rate = num_of_interrupt / (float)num_of_page_address_flow;
  printf("Page falut rate:%f\n",page_fault_rate);
}

int main(void)
{
  srand((unsigned int)time(NULL));
  __u_int instrustions[NUM_OF_INSTRUSTIONS];
  memset((void*)instrustions,0,sizeof(instrustions));
  __u_int original_page_address_flow[NUM_OF_INSTRUSTIONS];
  memset((void*)original_page_address_flow,0,sizeof(original_page_address_flow));
  generate_instrustions(instrustions,original_page_address_flow);
  __u_int page_address_flow[NUM_OF_INSTRUSTIONS];
  memset((void*)page_address_flow,-1,sizeof(page_address_flow));
  __u_int num_of_page_address_flow = merge(original_page_address_flow,page_address_flow);
  printf("The number of page address flow:%d\n",num_of_page_address_flow);
  __u_int num_of_blocks;
  scanf("%d",&num_of_blocks);
  fifo_algorithm(num_of_blocks,page_address_flow,num_of_page_address_flow);
  opt_algorithm(num_of_blocks,page_address_flow,num_of_page_address_flow);
  lru_algorithm(num_of_blocks,page_address_flow,num_of_page_address_flow);
  return 0;
}

采用如下规则生成指令集：
A：50%的指令是顺序执行的
B：25%的指令是均匀分布在前地址部分
C：25%的指令是均匀分布在后地址部分
具体的实施方法是：
A：在[0，319]的指令地址之间随机选取一起点m
B：顺序执行一条指令，即执行地址为m+1的指令
C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’
D：顺序执行一条指令，其地址为m’+1
E：在后地址[m’+2，319]中随机选取一条指令并执行
F：重复步骤A-E，直到320次指令

页面大小为1K，用户虚存容量为32K

（OPT算法应该写得过于冗余了，封装一个struct Page应该会更好

ZiiProgramming
关注
  • 0
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
页面置换算法（FIFO，LRU，最佳，Clock)
王浩烽的专栏
12-19 1万+
页面置换算法（FIFO，LRU，最佳，Clock) #includeusing namespace std;void Print(int bc[],int blockCount){ for(int i=0;i<blockCount;i++) { cout<<bc[i]<<" "; } cout<<endl;}bool Travel(int bc
实现页面置换的算法（OPT，FIFO，LRU）Java版
m0_54853420的博客
06-22 2534
定义：OPT（最佳置换算法）：从主存中移出永远不再需要的页面，如果没有这样的页面存在，那就选择最长时间不需要访问的页面，来保证最低的缺页率。 FIFO算法 定义：该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 LRU算法 定义：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 最后合在一起，测试一下，代码如下： 测试结果如下： 实验测试结果的表格版： OPT： FIFO： LR
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现算法比较的程序输出，比如：缺页率和页面置换次数等。 3.采用固定分配局部置换，且可以在程序中实现块数重新分配。 具有抖动判断和Belady异常判断机制 根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,置换次数,命中率的结果; 3.进行虚拟存储算法设计分析。
页面置换算法（OPT,FIFO,LRU）
最新发布
woyvxuetongzai52的博客
06-13 362
【代码】页面置换算法（OPT,FIFO,LRU）
【操作系统--页面置换算法】C语言详解--大作业版（附代码）
热门推荐
炼丹笔记
12-25 4万+
该实验为作者OS课程大作业，内容若有问题，望指出，多多交流
操作系统：页面置换算法
weixin_50551204的博客
03-25 2786
（一）实验目的 （二）实验要求及内容 首先，生成一个随机的页面引用串，其中页码的范围为0~9。 将这个随机页面引用串应用到每个算法，记录每个算法引起的缺页次数，列出每次页面置换的换出页序号，计算缺页率。 系统分配给用户的页面帧的数量可选：3~7，具体分配策略可自行定义。 假设采用请求分页（按需调页）。 （三）代码 #include <stdio.h> #include<time.h> //初始化队列 void initializeList(int list[], i
操作系统实验(四)——页面置换算法(附C语言代码)
qq_56699753的博客
08-05 1260
操作系统实验代码 使用Dev-C++运行
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
流苏的博客
06-15 1万+
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
C语言数组方法实现OPT和FIFO页面置换算法
智慧包的博客
02-07 4224
上学期操作系统实训中的内容，当时百度的代码基本都用了链表，自己数据结构学的又不太好，感觉直接用百度的代码太过高级，自己就用C语言纯数组实现了这些算法，代码简单，符合自己的水平。 先进先出置换算法（FIFO） #include<stdio.h> void doit(int a[],int b[]){ //实现先进先出置换算法的方法 int i,j,k,z,temp; for(i=0...
利用C语言实现页面置换算法
braylon_zhang的博客
12-14 1万+
操作系统实验 页面置换算法（FIFO、LRU、OPT） 概念： 1.最佳置换算法（OPT）（理想置换算法）：从主存中移出永远不再需要的页面；如无这样的页面存在，则选择最长时间不需要访问的页面。于所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。 2.先进先出置换算法（FIFO）：是最简单的页面置换算法。这种算法的基本思想是：当需要淘汰一个页面时，总是选择驻留主存时间最长的页面进行淘汰，即先进入主存的页面先淘汰。其理由是：最早调入主存的页面不再被使用的可能
操作系统页面置换算法之最佳(OPT)置换算法（C语言实现）
CuriosityCAX的博客
12-09 9585
最佳(OPT)置换算法 #include <iostream> int accessPage[20] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 }; int flagOPT[3] = { -1,-1,-1 }; // 用来在OPT算法中标记三个物理块是否有页面；-1：物理块中没有页面；1：物理块中有页面；0：物理块中的页面会在随后的页面访问中被访问 int physicalBlock[3] = { -1,-1,-1 }; // 3个物
FIFO、OPT、LRU页面置换算法实验代码和截图
12-24
FIFO、OPT、LRU页面置换算法实验代码和截图
最佳值换算法c语言,页面置换算法---最佳置换算法（OPT）
weixin_39650994的博客
05-23 2581
最佳置换算法(OPT)什么是OPT最佳置换算法，其所选择的被淘汰的页面将是以后永不使用的，或是在最长(未来)时间内不再被访问的页面。采用最佳置换算法通常可保证最低的缺页率。但是人们目前还无法与之，一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但是可以利用该算法取评价其他的算法。算法思想举例如下：我们将页面队列存在一个Vector动态数组中。我们可以从...
最佳（Optimal）置换算法 C语言实现
weixin_45761769的博客
12-16 5850
广东工业大学 操作系统实验 实验内容 假设每个页面中可存放10条指令，分配给作业的内存块数为4。用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页
C语言模拟OS虚拟内存页面置换算法OPT+FIFO+LRU
weixin_43363243的博客
05-29 3902
在进程运行过程中，若所要访问的页面不在内存，而需把它调入内存，但内存已无空闲区间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据送到磁盘空间的对换区中。将那个页面换出，需要根据一定的算法来确定。这就是页面置换算法。 最佳(Optimal)置换算法，选择的淘汰页将是以后永久不使用的，或许是在最长时间内不再访问的页面。这种算法可以保证最低的缺页率，但该算法真实情况下无法实现，可以作为评价其他算法的标准。 先进先出(FIFO)页面置换算法，总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页
页面置换算法（FIFO,OPT,LRU)
充满焦虑的大学生
05-20 1万+
先进先出页面置换算法（First In First Out，FIFO）是一种简单的页面置换算法，它依据页面进入主存储器的先后顺序进行页面置换。FIFO算法是一种非常直观的页面置换算法，它将最早进入主存储器的页面作为最先置换的页面。具体来说，FIFO算法维护一个先进先出的页面队列，当一个页面需要调入主存储器时，它被加入队列的末尾。当需要置换页面时，FIFO算法选择队列头部的页面进行置换。这样，最先进入主存储器的页面总是最先被置换出去，而最后进入主存储器的页面总是保留在主存储器中。
操作系统 FIFO算法 LRU算法 OPT算法(C++)
Authur_gyc
05-26 6110
题目 实验三 请求调页存储管理方式的模拟 1．实验目的 通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求调页系统的原理和实现过程的理解。 2．实验内容 （1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。 （2）用c语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。如果4个
C++编写的页面淘汰算法OPT的代码
weixin_43947759的博客
01-24 1072
把开发过程常用的一些代码片段记录起来，如下代码是关于C++编写的页面淘汰算法OPT的代码，应该是对各位朋友有些用。 看访问序列中接下来页面中最近访问的位置是哪，然后比较大小。 #include #include using namespace std; int main() { cout<<“页面访问序列如下：”<<endl; for(int i = 0;i < 19;i++){ cout<<setw(3)<<page[i]; } discard(
c语言指opt算法实现,Sunday算法c语言版实现
weixin_42114645的博客
05-23 641
一、BF算法BF算法是普通的模式匹配算法，其基本思想就是将目标串的第一个字符与模式串的第一个字符进行匹配。若相等，则继续比较第二个字符；若不相等，则比较目标串的第二个字符和模式串的第一个字符。依次比较下去，直到得出最后的匹配结果。示例代码：static int bf(const char *src, const char *des){int i, pos;int len_s, len_d;if(s...
C语言实现操作系统页面置换算法：FIFO, LRU与OPT
课程要求学生实现FIFO（先进先出）和LRU（最近最久未使用）两种基础算法，以及更复杂的OPT（最佳置换）和LFU（最不经常使用）算法。这些算法的设计目的是模拟进程在运行时如何根据内存使用情况选择合适的页面进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值