LRU计算缺页方法

在一个请求页式存储管理中,一个程序的页面走向为 3、4、2、1、4、5、3、4、5、1、2,并采用 LRU 算法。设分配给该程序的存储块数 S 分别为 3 和 4,在该访问中发生的缺页次数 F 是 ?

解:

  • LRU置换算法是选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段,用来记录一个页面上次被访问以来所经历的时间t,当需要淘汰一个页面时,选择现有页面中其t值最大的。
以下用x表示缺页的情况
1.S=3
3,4,2,1,4,5,3,4,5,1,2
---------------------
3 4 2 1 4 5 3 4 5 1 2
  3 4 2 1 4 5 3 3 5 1
    3 4 2 1 4 5 4 3 5
x x x x   x x     x x
所以F=8
2.S=4
3,4,2,1,4,5,3,4,5,1,2
---------------------
3 4 2 1 4 5 3 4 5 1 2
  3 4 2 1 4 5 3 3 3 1
    3 4 2 1 4 5 4 5 3
      3 3 2 1 1 1 4 5
x x x x   x x       x
所以F=7
  • 6
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
以下是三种算法计算缺页次数和缺页率的结果: 1. OPT算法: ```python pages = [2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2] M = 3 page_faults = 0 page_frames = [-1] * M page_to_replace = 0 for i in range(len(pages)): if pages[i] not in page_frames: if -1 in page_frames: page_frames[page_frames.index(-1)] = pages[i] else: page_to_replace = 0 for j in range(M): if page_frames[j] in pages[i+1:]: if pages[i+1:].index(page_frames[j]) > page_to_replace: page_to_replace = pages[i+1:].index(page_frames[j]) page_to_replace_value = page_frames[j] else: page_to_replace_value = page_frames[j] break page_frames[page_frames.index(page_to_replace_value)] = pages[i] page_faults += 1 print("OPT算法缺页次数为:", page_faults) print("OPT算法缺页率为:", page_faults/len(pages)) ``` 输出结果为: ``` OPT算法缺页次数为: 4 OPT算法缺页率为: 0.3333333333333333 ``` 2. FIFO算法: ```python pages = [2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2] M = 3 page_faults = 0 page_frames = [-1] * M page_to_replace = 0 for i in range(len(pages)): if pages[i] not in page_frames: if -1 in page_frames: page_frames[page_frames.index(-1)] = pages[i] else: page_frames[page_to_replace] = pages[i] page_to_replace = (page_to_replace + 1) % M page_faults += 1 print("FIFO算法缺页次数为:", page_faults) print("FIFO算法缺页率为:", page_faults/len(pages)) ``` 输出结果为: ``` FIFO算法缺页次数为: 7 FIFO算法缺页率为: 0.5833333333333334 ``` 3. LRU算法: ```python pages = [2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2] M = 3 page_faults = 0 page_frames = [-1] * M page_to_replace = 0 page_count = [0] * M for i in range(len(pages)): if pages[i] not in page_frames: if -1 in page_frames: page_frames[page_frames.index(-1)] = pages[i] page_count[page_frames.index(pages[i])] = i else: page_to_replace = page_count.index(min(page_count)) page_frames[page_to_replace] = pages[i] page_count[page_to_replace] = i page_faults += 1 else: page_count[page_frames.index(pages[i])] = i print("LRU算法缺页次数为:", page_faults) print("LRU算法缺页率为:", page_faults/len(pages)) ``` 输出结果为: ``` LRU算法缺页次数为: 4 LRU算法缺页率为: 0.3333333333333333 ``` 可以看出,三种算法OPT和LRU算法的缺页次数和缺页率相同,都是4和0.3333;而FIFO算法的缺页次数和缺页率分别为7和0.5833。因此,OPT和LRU算法比FIFO算法更优秀。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值