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

原创 2006年06月02日 09:50:00

在本实验中,引用串的长度为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;
}

操作系统实验--页面替换算法

操作系统实验4–页面替换算法基本数据结构 变量名 意义 pageNum 总页面数 rsLen 引用串长度 frameNum 物理内存长度 rs[] 保存引用串的数...
  • sinat_26599509
  • sinat_26599509
  • 2016年05月26日 07:00
  • 1154

[操作系统] 页面置换算法(一)

页面置换算法(一) 最优页面置换算法 最近未使用页面置换算法 先进先出置换算法 第二次机会页面置换算法 时钟页面置换算法 最近最少使用页面置换算法 LRU...
  • github_37129174
  • github_37129174
  • 2017年12月02日 17:44
  • 131

操作系统实验存储管理

实验三  存储管理(3学时) 一、实验目的 (1)加深对存储管理的作用和工作原理的理解。 (2)进一步认识主存空间的分配和回收方法。 (3)进一步认识虚拟存储器的工作原理。 二...
  • dt28707
  • dt28707
  • 2012年12月08日 14:53
  • 2416

哈工大操作系统试验3 进程运行轨迹的跟踪与统计

程序只可以通过stat_log.py的简单检查。 实验报告大体写了一下。 //===========================================================...
  • wangyi_lin
  • wangyi_lin
  • 2011年11月06日 22:29
  • 10034

操作系统实验七之内存页面置换算法实验

vmrp.h /* * Filename : vmrp.h * copyright : (C) 2006 by 张鸿烈 * Function : 声明虚拟内存页置换类 */ #include #i...
  • u010467643
  • u010467643
  • 2014年05月26日 23:53
  • 1889

页面替换算法

来自http://59.64.80.152/vod/2739346/content/003003004001/default.htm   目前。在虚拟存储器常用的页面替换算法有如下几种: 1、 随机...
  • vincent2610
  • vincent2610
  • 2014年03月09日 15:31
  • 1876

页面置换算法 FIFO和LRU 及各自的命中率

(1) 先进先出算法FIFO:该算法的实质是选择作业中在主存驻留时间最长的一页淘汰,这种算法容易实现,例如分配一个作业的存储块数为m,则只需建立一张m个元素的队列表Q(0)、Q(1)、…、Q(m-1)...
  • hmh86
  • hmh86
  • 2016年12月16日 11:30
  • 1872

操作系统实验六之死锁问题实验

实验要求 在两个城市南北方向之间存在一条铁路,多列火车可以分别从两个城市的车站 排队等待进入车道向对方城市行驶,该铁路在同一时间,只能允许在同一方向上行 车,如果同时有相向的火车行驶将会撞车。请模拟...
  • u010467643
  • u010467643
  • 2014年05月26日 23:47
  • 1501

Linux操作系统实验(3)(模拟实现请求分页虚存页面替换算法)

数据结构: typedef struct _Page{ // 页面 int pageID; //页号 }Page; typedef struct _PageQueue{ //页面队列...
  • fly_tzf
  • fly_tzf
  • 2017年07月01日 10:35
  • 467

操作系统:基于页面置换算法的缓存原理详解(上)

作为一个学计算机的一定听过缓存(注意这里是缓存,不是缓冲)。比如我们在登录网页时,网页就可以缓存一些用户信息;比如我们在写界面代码的时候,可能就会遇到界面的绘制是基于一些缓存算法的。所以,了解一下缓存...
  • u013761665
  • u013761665
  • 2016年01月07日 13:05
  • 2668
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:操作系统实验三——页面替换算法的比较研究
举报原因:
原因补充:

(最多只允许输入30个字)