C语言实现FIFO算法与LRU算法

在操作系统中,当程序在运行过程中,若其所要访问的页面不再内存中而需要把他们调入内存,但内存已无空闲空间时,为了保证该进程能正常运行,系统必须从内存调出一页程序或数据送磁盘的兑换区中。但哪一个页面调出,须根据一定的算法确定。通常,把选择换出页面的算法称为页面置换算法(Page-Replacement
Algorithms).置换算法的好坏将直接影响到系统的性能。

1) 先进先出(FIFO)页面置换算法

该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单,只需把一个进程调入内存,按先后顺序排成一个队列,并设置一个指针,称为替换指针,使他总能指向最老的页面。但该算法与进程与实际运行的规律不相适应,效率最差。

2) 最近最久为使用(LRU)算法

LRU算法是根据页面调入内存后的使用情况进行决策的。就是利用“最近的过去”作为“最近的将来”的近似,因此是将最近最久未使用的页面予以淘汰。该算法赋予每一个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间t,当淘汰一个页面时,选择现有页面中t值最大的,及最近最久为使用的页面予以淘汰。

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

#include <stdio.h>

#define PAGES 12  /*页面引用页数*/

#define M 3      /*当前分配给改作业的物理块数*/

//#define M 4

/*页面引用串*/

int page[PAGES] =  {4,3,2,1,4,3,5,4,3,2,1,5};

int rel[M][PAGES];   /*存储结果数组*/

/*内存物理块结构体*/

typedef
struct{

  int
pnum;     /*该块中所存的页面号*/

  int
tm;       /*从最近一次调入所经历的时间*/

}PBlock;

/*初始化物理块数组*/

void
init(PBlock *pb)

{

  int
i,j;

  //pb = (PBlock*)malloc(sizeof(PBlock)*M);

  for(i=0;i<M;i++){

    pb[i].pnum = -1;

    pb[i].tm
= -1;

    for(j=0;j<PAGES;j++){

      rel[i][j] = -1;

    }

  }

}

/*打印结果数组*/

void
printRelArr(int
rel[M][PAGES])

{

  int
i,j;

  for(i=0;i<M;i++){

    for(j=0;j<PAGES;j++){

      if(rel[i][j]==-1)

        printf("_ ");

      else

        printf("%d ",rel[i][j]);

    }

    printf("\n");

  }

}

/*打印一维数组*/

void
printArr1(int
*arr,int
n)

{

    int
i;

    for(i=0;i<n;i++){

      printf("%d ",arr[i]);

    }

    printf("\n");

}

/*查看页面号为num的页面是否在内存块中,存在返回1*/

int
in_mem(int
num,PBlock *pb,int
m)

{

  int
i;

  int
b = 0;

  for(i=0;i<m;i++){

      if(pb[i].pnum == num){

        b = 1;

        break;

      }

  }

  return
b;

}

/*FIFO 算法的实现,无需考虑时间*/

int
fifo(PBlock *pb,int
m)

{

  int
lps=0;   /*缺页次数*/

  double
lpp;   /*缺页率*/

  int
p = 0;    /*替换指针*/

  int
index =0;  /*页面号索引*/

  while(index<PAGES){

      if(!in_mem(page[index],pb,M)){    //如果该页面不在物理块中

        pb[p].pnum = page[index];        /*将该页面放入物理块中*/

        p = (p+1)%M;                     /*替换指针移动*/

        lps++;                           /*却也次数加 1*/

        for(int
i=0;i<M;i++){

          rel[i][index] = pb[i].pnum;

        }

      }

      index++;

  }

  printf("FIFO算法所得缺页次数为 %d\n",lps);

  lpp = (double)lps/PAGES;

  printf("FIFO算法缺页率为 %0.4lf \n",lpp);

  printf("页面号序列为:\n");

  printArr1(page,PAGES);

  printf("结果数列为:\n");

  printRelArr(rel);

  return
0;

}

/*获得最近最久的块*/

int
getP(PBlock *pb,int
p)

{

  int
i;

  bool
out = true//

  for(i=0;i<M;i++){

    if(pb[i].tm
== -1){

      p = i;

      out = false;

      break;

    }

  }

  if(out){

    for(i=0;i<M;i++){

      if(pb[i].tm>pb[p].tm)

        p = i;

    }

  }

  return
p;

}

int
getEQnum(int
num,PBlock *pb)

{

  int
i;

  int
in = -1;

  for(i=0;i<M;i++){

    if(pb[i].pnum == num){

      in = i;

      break;

    }

  }

  return
in;

}

/*LRU算法*/

void
lru(PBlock *pb,int
m)

{

  int
lps=0;   /*缺页次数*/

  double
lpp;   /*缺页率*/

  int
p = 0;    /*替换指针*/

  int
index =0;  /*页面号索引*/

  while(index<PAGES){

      if(!in_mem(page[index],pb,m)){   /*如果页面不在物理块中*/

        p = getP(pb,p);

        pb[p].pnum = page[index];

        pb[p].tm
= 0;

        lps++;

        for(int
i=0;i<M;i++){

          rel[i][index] = pb[i].pnum;

        }

      }else{                         /*如果页面在物理块中*/

        int
in = getEQnum(page[index],pb);  /*获取该页面在物理块中的索引*/

          pb[in].tm
= 0;

      }

      int
i;

      for(i=0;i<M;i++){

          if(i!=p&&pb[i].tm!=-1){

            pb[i].tm++;

          }

      }

      index++;

  }

  printf("LRU算法所得缺页次数为 %d \n",lps);

  lpp = 1.0*lps/PAGES;

  printf("LRU算法缺页率为: %0.4lf\n",lpp);

  printf("页面号序列为:\n");

  printArr1(page,PAGES);

  printf("LRU结果数组为:\n");

  printRelArr(rel);

}

int
main()

{

    //printArr(rel);

  PBlock pb[M];

  init(pb);

  fifo(pb,M);

  init(pb);

  lru(pb,M);

  return
0;

}

C语言实现FIFO算法与LRU算法

时间: 2024-10-11 05:32:49

C语言实现FIFO算法与LRU算法的相关文章

【算法】—— LRU算法

LRU原理 LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”. 实现1 最常见的实现是使用一个链表保存缓存数据,详细算法实现如下:  1. 新数据插入到链表头部: 2. 每当缓存命中(即缓存数据被访问),则将数据移到链表头部: 3. 当链表满的时候,将链表尾部的数据丢弃. 分析 [命中率] 当存在热点数据时,LRU的效率很好,但偶发性的.周期性的批量操作会导致LRU命中率急剧下

【算法】LRU算法

缓存一般存放的都是热点数据,而热点数据又是利用LRU(最近最久未用算法)对不断访问的数据筛选淘汰出来的. 出于对这个算法的好奇就查了下资料. LRU算法四种实现方式介绍 缓存淘汰算法 原文地址:https://www.cnblogs.com/2YSP/p/10424376.html

FIFO算法与LRU算法的C++实现

#include <bits/stdc++.h> using namespace std; /** * FIFO算法的实现:其实是可以采用双端队列,然后限制一下 * 双端队列的长度,根据我的限制应该是4.对于查询是否出现 * 在这个队列里面,我们可以采用一个数组标记是否有存在. * * 测试数据如下 16 4 0 1 2 4 3 4 5 1 2 5 1 2 3 4 5 6 * **/ struct FIFO{ int len, m;///长度, len - 总访问数; m - 分配的物理块数

FIFO调度算法和LRU算法

一.理论 FIFO:先进先出调度算法 LRU:最近最久未使用调度算法 两者都是缓存调度算法,经常用作内存的页面置换算法. 打一个比方,帮助你理解.你有很多的书,比如说10000本.由于你的书实在太多了,你只能放在地下室里面.你看书的时候不会在地下室看书,而是在书房看书.每次,你想看书都必须跑到地下室去找出来你想看的书,然后抱回来放到书桌上,之后才开始看.还有就是,有一些书你会反复的看,今天看了也许过几天又要看.总之,你自己是不知道你哪天会需要看哪本书的.你的老师每天下课的时候会给你布置一个书单,

LRU算法原理解析

LRU是Least Recently Used的缩写,即最近最少使用,常用于页面置换算法,是为虚拟页式存储管理服务的. 现代操作系统提供了一种对主存的抽象概念虚拟内存,来对主存进行更好地管理.他将主存看成是一个存储在磁盘上的地址空间的高速缓存,在主存中只保存活动区域,并根据需要在主存和磁盘之间来回传送数据.虚拟内存被组织为存放在磁盘上的N个连续的字节组成的数组,每个字节都有唯一的虚拟地址,作为到数组的索引.虚拟内存被分割为大小固定的数据块虚拟页(Virtual Page,VP),这些数据块作为主

使用java.util.LinkedList模拟实现内存页面置换算法--LRU算法

一,LRU算法介绍 LRU算法是最近最少未使用算法.当内存缺页时,总是优先选出距离当前最久未使用的页面换出,并把当前的缺页换入.该算法可用栈模拟实现. 栈顶总是保存当前最近访问的页面号,栈底则总是保存最久未访问的页面号.对于下一个页面,有两种情况: ①命中,则需要:更新栈顶元素.即将当前命中的页面号放到栈顶. ②未命中,这里还需要考虑栈是否满了.1)若栈未满,直接将未命中的页面号放到栈顶即可.2)栈已经满了,则需要选中一页换出(栈底元素是最久未访问的页面),然后再将新页面放入栈顶. 二,代码实现

操作系统页面置换算法(opt,lru,fifo,clock)实现

#include <iostream> #include<map> #include<set> #include <algorithm> #include<cstdio> #include<cstring> #include<cmath> #define N 200 using namespace std; int page[N];//页面引用号 int block[N];//物理块,内存 int dist[N][N];/

页面置换算法(最佳置换算法、FIFO置换算法、LRU置换算法、LFU置换算法)

页面置换产生的原因是:分页请求式存储管理(它是实现虚拟存储管理的方法之一,其中一个特性是多次性-->多次将页面换入或换出内存) 效果最好的页面置换算法:最佳置换算法 比较常用的页面置换算法有:FIFO置换算法.LRU置换算法.LFU置换算法 最佳置换算法:不可能实现-->是衡量其他置换算法的方法. FIFO置换算法:先进先出置换算法,淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰.(实现简单) LRU置换算法:最近最久未使用置换算法,该算法赋予每个页面一个访问字段,用来记录一

缓存算法:LRU、LFU、FIFO

  LRU全称是Least Recently Used,即最近最久未使用的意思.如果一个数据在最近一段时间没有被访问到,那么在将来它被访问的可能性也很小.也就是说,当限定的空间已存满数据时,应当把最久没有被访问到的数据淘汰. LFU(Least Frequently Used)最近最少使用算法.它是基于"如果一个数据在最近一段时间内使用次数很少,那么在将来一段时间内被使用的可能性也很小"的思路.注意LFU和LRU算法的不同之处,LRU的淘汰规则是基于访问时间,而LFU是基于访问次数的.