python 实现LRU置换算法和先进先出置换算法

于 2022-11-14 20:51:00 发布
阅读量1k 收藏 13
点赞数
CC 4.0 BY-SA版权
分类专栏： 操作系统 文章标签： python 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37040743/article/details/127855174
这篇博客详细介绍了LRU（最近最少使用）和FIFO（先进先出）两种页面替换算法的原理，并通过Python代码进行了实现。作者首先解释了两种算法的工作方式，然后展示了如何在内存满时进行页面置换。在代码部分，分别定义了两个类`ALU`，用于模拟这两种算法，最后通过实例运行展示了不同阶段的缺页次数，从而对比了两种算法的性能。

LRU就是在内存中寻找，需要的页面，没有找到，就插入内存，内存满了，就把内存中最长时间没有使用的页面置换。

先进先出置换算法就是在内存中找，没有找到，就插入内存，内存满了，最先进入内存的页面，出内存，将需要的页面插入末尾。

图解请去找百度。

代码：

LRU：

import numpy as np
import random

class ALU:
    App_cishu=0#申请次数
    absent_page=0#缺页
    def __init__(self,memory_page,time,page):
        self.memory_page=memory_page#内存
        self.page=page#页面
        self.time=time#每个页面停留时间
        

    def inter_dui(self):#第一次入队，内存未满
        i=0#页面下标
        
        while(True):
            self.App_cishu=self.App_cishu+1#申请次数
            app_num=random.randint(1,31)#属于前5000次，申请1-30
            #print("申请使用%d号页面"%app_num)
            if app_num in self.memory_page:
                #在内存中找到了该页号，该时间置零，其他时间必须加一，因为如果碰巧每一次都找到了，最终所有停留时间相同 且内存满了的情况。                 
                index=np.where(self.memory_page==app_num)
                self.time[index]=0 #访问过程中，在内存中找到了，停留时间重置为零
                for c in range (i):#为了与后续的满内存置换，此处使用先置零再加一
                    self.time[c]=self.time[c]+1 
               #print("%d页面已在内存"%app_num)
            else:#没找到，外存调入，每个存在页面的时间加+1
               #print("%d页面不存在内存,将执行置换调入"%app_num)
                self.memory_page[i]=app_num
                i=i+1
                self.absent_page=self.absent_page+1
                for c in range (i):#入队的页面停留时间+1
                    self.time[c]=self.time[c]+1         
                if (i==30):#内存满，退出
                    break

    def Appreciate(self,cishu,x,y):#入队完成后，开始调用此函数开始置换,x,y申请的页面号范围
        for i in range(cishu):
            self.App_cishu=self.App_cishu+1
            app_num=random.randint(x,y)#申请
            #print("申请使用%d号页面"%app_num)
            if app_num in self.memory_page:  #找到

                #print("%d页面已在内存"%app_num)
                index=np.where(self.memory_page==app_num)
                self.time[index]=0# 停留时间重置为零    
                for c in range (30):
                    self.time[c]=self.time[c]+1 
            else:#没找到，开始置换
                self.absent_page=self.absent_page+1#缺页+1
                #print("%d页面不存在内存,将执行置换"%app_num)
                index=np.where(self.time==max(self.time))
                self.memory_page[index]=app_num
                self.time[index]=0#还是先置零再加一
                for c in range (30):
                    self.time[c]=self.time[c]+1 

    def show_memory(self):#内存展示       
        print(self.memory_page,"\n",self.time)
    def show_queye(self):
        print("申请次数",self.App_cishu)
        print("缺页：",self.absent_page)
        print("缺页率：",self.absent_page/self.App_cishu)
    
    def diaoyong(self):
        ALU.inter_dui(self)
        ALU.Appreciate(self,5000-self.App_cishu,1,30)
        #ALU.show_queye(self)
        ALU.Appreciate(self,40000,30,51)
        print("前45000次，缺页",self.absent_page)
        ALU.Appreciate(self,5000,51,101)
        print("前50000次，缺页",self.absent_page)

memory_page=np.array(np.zeros(30))#内存
time=np.zeros(30)#停留时间
page=[i for i in range (1,101)]#页面号

a=ALU(memory_page,time,page)
a.diaoyong()
a.show_queye()

先进先出置换算法：

import numpy as np
import random

class ALU:
    App_cishu=0#申请次数
    absent_page=0#缺页
    def __init__(self,memory_page):
        self.memory_page=memory_page#内存
               
    def inter_dui(self):#第一次入队，内存未满
        i=0#页面下标        
        while(True):
            self.App_cishu=self.App_cishu+1#申请次数
            app_num=random.randint(1,31)#属于前5000次，申请1-30
            #print("申请使用%d号页面"%app_num)
            if app_num in self.memory_page:
                #在内存中找到了该页号，跳过               
                continue
                #print("%d页面已在内存"%app_num)
            else:#没找到，外存调入，每个存在页面的时间加+1
               #print("%d页面不存在内存,将执行置换调入"%app_num)
                self.memory_page[i]=app_num
                i=i+1
                self.absent_page=self.absent_page+1      
                if (i==len(self.memory_page)):#内存满，退出
                    break
            #print("满内存之前的缺页",self.absent_page)

    def Appreciate(self,cishu,x,y):#入队完成后，开始调用此函数开始置换,x,y申请的页面号范围
        for i in range(cishu):
            self.App_cishu=self.App_cishu+1
            app_num=random.randint(x,y)#申请
            #print("申请使用%d号页面"%app_num)
            if app_num in self.memory_page:  #找到
                #print("%d页面已在内存"%app_num)
                continue
            else:#没找到，开始置换
                self.absent_page=self.absent_page+1#缺页+1
                #print("%d页面不存在内存,将执行置换"%app_num)
                for c in range(len(self.memory_page)-1):#队列前移，在末尾调入内存
                    self.memory_page[c]=self.memory_page[c+1]
                self.memory_page[len(self.memory_page)-1]=app_num#末尾调入

    def show_memory(self):#内存展示       
        print(self.memory_page,"\n",self.time)
    def show_queye(self):
        print("总申请次数",self.App_cishu)
        print("缺页：",self.absent_page)
        print("缺页率：",self.absent_page/self.App_cishu)
    def diaoyong(self):
        ALU.inter_dui(self)
        
        ALU.Appreciate(self,5000-self.App_cishu,1,30)
        print("前5000次，缺页",self.absent_page)
        ALU.Appreciate(self,40000,30,51)
        print("前45000次，缺页",self.absent_page)
        ALU.Appreciate(self,5000,51,101)
        print("前50000次，缺页",self.absent_page)
memory_page=np.array(np.zeros(30))#内存
a=ALU(memory_page)
a.diaoyong()
a.show_queye()

Python LRU（least recently used）算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-13 1257
它的基本思想是将最近最少使用的数据淘汰，以确保缓存中总是保存着最有可能被访问的数据。它的基本思想是将最近最少使用的数据淘汰，以确保缓存中总是保存着最有可能被访问的数据。它的基本思想是将最近最少使用的数据淘汰，以确保缓存中总是保存着最有可能被访问的数据。它的基本思想是将最近最少使用的数据淘汰，以确保缓存中总是保存着最有可能被访问的数据。它的基本思想是将最近最少使用的数据淘汰，以确保缓存中总是保存着最有可能被访问的数据。它的基本思想是将最近最少使用的数据淘汰，以确保缓存中总是保存着最有可能被访问的数据。
实现LRU缓存置换算法（Python）
热门推荐
HenryLei的博客
08-13 4万+
关于LRU算法 如下图，假设缓存4个子块，（）表示使用的字块，[]表示淘汰的字块。 使用双向链表实现LRU 淘汰缓存时，把链表尾部的节点淘汰。 具体实现 （代码中引入的双向链表-->https://blog.csdn.net/huanglei305/article/details/99422314） # -*- encoding=utf-8 -*- from com...
先进先出置换算法
01-05
先进先出置换算法，当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。
先进先出页面置换算法
05-18
先进先出页面置换算法 #include<iostream> using namespace std; int pagenum=0; //内存的页面数 int total=0; //要访问的叶面总数 int lacknumber=0; //缺页的总数 float rate=0; //缺页率 void main() { int i; int j=0; int array[20]; for( i=0;i<20;i++) {array[i]=-1;} int seque[20]={0}; cout<<"请输入内存的页面数:"; cin>>pagenum; cout<<"请输入页面的访问顺序(输入-1结束):\n";
Python实现页面置换算法（FIFO && LRU）
qq_48520394的博客
12-06 2703
最近老师布置的操作系统实验，用Python实现了一下。下面是具体的数据结构，虽然是用C的思想描述，但区别不大。 1．算法中涉及的数据结构说明 如果采用C语言实现，本设计考虑使用C语言的结构体来描述页表结构和实页的使用情况。 页表结构如下： VirtualPage RealPage State EnterTime AccessTime 其中VirtualPage表示虚页号（因为共10个虚页，所以
python算法（基础）----队列（先进先出，FIFO）
狼性书生
05-25 9159
队列被构造为在队尾添加项的有序集 合，并且从队首移除。队列保持 FIFO 排序属性。 队列操作如下。 Queue() 创建一个空的新队列。 它不需要参数，并返回一个空队列。 equeue(item) 将新项添加到队尾。 它需要 item 作为参数，并不返回任何内容。 dequeue() 从队首移除项。它不需要参数并返回 item。 队列被修改 isEmpty() 查看队列是否为空。它不需要...
计算机操作系统面置换算法最佳（OPT）置换、先进先出（FIFO）置换和最近最久未使用（LRU）置换算法（python源码）
最新发布
03-23
python模拟最佳（OPT）置换、先进先出（FIFO）置换和最近最久未使用（LRU）置换算法
python实现LRU算法
大帅的博客
08-23 4029
LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。 python中有一个标准库的类的OrderedDict，该类有以下两个方法用来实现LRU算法就十分简单： popitem(last=True)：有序字典的 popitem() 方法移除并返回一个 (key, value) 键值对。 如果 last 值为真，则按 LIFO 后进先出的顺序返回键值对，否则就按 FIFO 先进先出的顺序返回
Python实现LRU算法的2种方法
12-23
在Python中，我们可以使用多种方式来实现LRU算法。 一种简便的方法是利用`collections.OrderedDict`，因为它能够保持元素插入的顺序。下面是一个基于`OrderedDict`实现的LRU缓存类： ```python from collections ...
python先进先出Queue
小船的专栏
01-01 3419
操作系统程序设计-（-编程描述页面置换算法——先进先出算法 ）
06-02
操作系统中编程描述页面置换算法——先进先出算法。 一、目的和要求 给出页面访问的顺序与分配给作业的主存块数，使用队列作为数据结构编写算法，实现统计缺页次数与页面置换操作，用C语言编程并用文档形式给出算法分析与实现过程。 二、具体设计思路 1、输入当前要调用的页面号a[i] 2、判断该页面是否已在队列内， （1）若在队列内，不执行任何操作 （2）若不在队列内。则执行以下操作 判断队列是否已满 （1）若队列未满，直接把该页面号a[i]存入队列 （2）若队列已满，删除并返回队头元素，然后把该页面号a[i]存入队列 3、输出置换次数，依次输出置换出的页面 三、程序设计 #define SIZE 4 //SIZE等于分配的内存块数加1 #define N 5 //可输入的页面数 #define OVERFLOW -2 #include #include //----------------------------------------------- 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
先进先出（FIFO）页面置换算法
02-20
这是 我在今年的操作系统的课程设计的题目。代码的经过了老师的BT检测，绝对可用。编写简单，易懂。欢迎下载，交流！
先进先出页面置换算法FIFO
06-21
1.动态输入进入内存的页面总数，系统分配的物理块数，依次进入内存的页面号。 2.用数组储存放入内存的页面，在分配内存页面数小于进程页面数时，最先运行的m个页面放入内存； 3.这时有需要处理新的页面，则将与原来的内存数组中的m个页面进行比较，当内存中不存在新页面号时调出最先进入的页面号；当内存中存在新页面号时不作任何调动，一直进行直至用户输入的页面号全部执行完毕，最后输出置换的次数，以及置换率。
用c语言模拟先进先出页面置换算法
12-04
这是一个用c语言模拟先进先出页面置换算法的代码，可以任意输入页面数，物理块数与页面序列，然后进行置换后的排序。
模拟先进先出（FIFO）页面置换算法
06-18
使用c++语言编写的模拟实现先进先出页面置换算法，定义了一个FIFO类，FIFO类有一个str数组来存放页面走向；一个base数组表示物理块；一个int型变量来存放最先进入物理块的下标。这是个比较简单的代码，
先进先出置换算法（Java实现）
微风轻轻吹拂的博客
12-02 2237
代码部分 import java.util.ArrayList; import java.util.List; public class Homework { //创建一个长度为3的集合,其功能相当于有三个物理块 private List wulikuai = new ArrayList(3); //用于统计没有缺页的数量 private Integer count = 0; /** * 将访问页添加到物理块中 */ priva.
页面置换算法--先进先出页面置换
winneryy的博客
12-09 2888
#include "stdio.h" #include "stdlib.h" typedef struct item { int num; //页号 int time; //等待时间，LRU算法会用到这个属性 }Pro; int pageNum; //系统分配给作业的主存中的页面数 int memoryNum; //可用内存页面数 void print(Pro *page1); //打印当前主存中的页面 int Search(int num1, Pro *memory1); .
操作系统 FIFO算法 LRU算法 OPT算法(C++)
Authur_gyc
05-26 6327
题目 实验三 请求调页存储管理方式的模拟 1．实验目的 通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求调页系统的原理和实现过程的理解。 2．实验内容 （1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。 （2）用c语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。如果4个
Python实现OPT、FIFO和LRU页面置换算法
最佳置换算法（OPT）、先进先出置换算法（FIFO）以及最近最久未使用置换算法（LRU），并提供了基于Python语言的实现源码，这使得学习者能够通过编程实践深入理解这些算法的工作原理和性能差异。 首先来看**最佳置换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

箫毒赵药师

嘿嘿嘿

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值