精华内容
下载资源
问答
  • LRU页面置换算法

    2021-05-01 21:52:52
    LRU页面置换算法 文章目录LRU页面置换算法前言一、LRU算法介绍二、代码1.源程序2.运行结果 前言 LRU页面置换算法是虚拟存储器中使用的算法,通过选取最近最少使用的页面换出 一、LRU算法介绍 LRU(最近最少使用)...

    LRU页面置换算法


    前言

    LRU页面置换算法是虚拟存储器中使用的算法,通过选取最近最少使用的页面换出


    一、LRU算法介绍

    LRU(最近最少使用)页面置换算法是根据过去使用次数来预测将来的页面使用情况,具体过程如下:
    当发生缺页而分配给进程的物理块耗尽时,需要将所需页面置换入内存,被换出的页面是最近最少被使用的页面。具体的实现方法为为每个内存中的页面配置一个移位寄存器,每过一段时间(如10ms)将其中的数字右移。当该页面被访问时,将最高位置一,这样,最近被访问的页面寄存器中的数字是最大的,需要换出页面时,只需选取数值最小的页面换出;另一种方法是为每个进程配置一个栈,页面进入内存时将其压入栈中,当访问内存中的页面时,将其重新压入栈顶,如此最近被访问的页面就在栈顶,需要置换页面时,只需将栈底的页面置换出即可。下面代码使用的是第一种方法。

    二、代码

    1.源程序

    #include <iostream>
    #include <vector>
    using namespace std;
    
    typedef struct
    {
        unsigned visit;
        ///int block = ;
        int state;
        int pageId;
    }PageItem,*itemp;
    
    itemp initItem(int pageId)
    {
        itemp aItemp = new PageItem;
        aItemp->visit = 0b0;
        aItemp->state = 0;
        aItemp->pageId = pageId;
        return aItemp;
    }
    
    void moveright(itemp items[],int num)
    {
        for(int i=0;i<num;i++)
            items[i]->visit = (items[i]->visit)>>1;
    }
    void LRU(itemp items[],int num,int pageId,vector<int>& blocks)
    {
        int id = 0;
        unsigned visit = 0xFFFFFFFF;
        for(int i=0;i<num;i++)
        {
            if(visit>items[i]->visit && items[i]->state==1)
            {
                visit = items[i]->visit;
                id = items[i]->pageId;
            }
        }
        for(int i=0;i<num;i++)
        {
            if(items[i]->pageId==id)
            {
                items[i]->visit = 0b0;
                items[i]->state = 0;
            }
            if(items[i]->pageId==pageId)
                items[i]->state = 1;
        }
        for(vector<int>::iterator i=blocks.begin();i!=blocks.end();i++)
        {
            if(*i==id)
            {
                *i = pageId;
                break;
            }
        }
    }
    
    int main()
    {
        int invoke = 0;
        int blocknum = 0;
        int next = 0;
        int blockTaken = 0;
        vector<int> blocks(0);
        itemp items[8] = {};
        for(int i=0;i<8;i++)
            items[i] = initItem(i);
        ///PageTable table(5,items);
        cout << "为此进程分配的物理块个数:";
        cin >> blocknum;
        cout << "调用页面的次数:";
        cin >> invoke;
        for(int i=0;i<invoke;i++)
        {
            cout << "下次要调用的页面是:";
            cin >> next;
            bool in = false;
            for(vector<int>::iterator i=blocks.begin();i!=blocks.end();i++)
            {
                if(next == *i)
                {
                    in = true;
                    break;
                }
            }
            if(in)
            {
                cout << "页面在内存中\n";
            }
            else if(blockTaken<blocknum)
            {
            	//页面不在内存中并且物理块还未耗尽
                blocks.push_back(next);
                cout << "页面载入内存,当前物理块:";
                for(vector<int>::iterator i=blocks.begin();i!=blocks.end();i++)
                    cout << *i << '\t';
                cout << endl;
                items[next]->state = 1;
                blockTaken++;
            }
            else if(blockTaken>=blocknum)
            {
                cout << "物理块满,调用LRU页面置换算法\n";
                cout << "当前物理块分配为:";
                for(vector<int>::iterator i=blocks.begin();i!=blocks.end();i++)
                    cout << *i << '\t';
                LRU(items,5,next,blocks); //物理块耗尽,使用LRU算法置换页面
                cout << endl << "置换后物理块分为:";
                for(vector<int>::iterator i=blocks.begin();i!=blocks.end();i++)
                    cout << *i << '\t';
                cout << endl;
            }
    
            items[next]->visit+=0b10000000000000000000000000000000;
            moveright(items,8);
        }
        return 0;
    }
    

    2.运行结果

    在这里插入图片描述

    以上是我对LRU算法的理解,如有谬误,欢迎斧正。
    	
    
    展开全文
  • lru 页面置换算法

    2012-05-10 11:10:22
    opt lru fifo 页面置换算法 lru 页面置换算法
  • LRU 页面置换算法

    千次阅读 2019-06-09 19:45:59
    LRU是Least Recently Used的缩写,即最近最少使用,常用于页面置换算法,是为虚拟页式存储管理服务的。 为了尽量减少与理想算法的差距,产生了各种精妙的算法,最少使用页面置换算法便是其中一个。LRU算法的提出,是...

    LRU的简单实现
    LRU是Least Recently Used的缩写,即最近最少使用,常用于页面置换算法,是为虚拟页式存储管理服务的。
    为了尽量减少与理想算法的差距,产生了各种精妙的算法,最少使用页面置换算法便是其中一个。LRU算法的提出,是基于这样一个事实:在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。反过来说,已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。这个,就是著名的局部性原理–比内存速度还要快的cache,也是基于同样的原理运行的。因此,我们只需要在每次调换时,找到最近最久未使用的那个页面调出内存。这就是LRU算法的全部内容。
    在这里插入图片描述
    在这里插入图片描述

    #include<iostream>
    #define N 3
    using namespace std;
    int main()
    {
        int ym[]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
        int lru[N]={1,0,7};
        int len[N]={0,0,0};
        int allchagetimes=0;
         for(int t=0;t<N;t++)
           {
               cout<<lru[t]<<"  ";
           }
           cout<<endl;
    
       for(int i=3;i<20;i++)
       {
           int flag=0;
           int j=0;
           int sum=0;
           for(;j<N;j++)
           {
               if(ym[i]==lru[j])
               {
                   flag=1;
                   break;
               }
               else if(ym[i]!=lru[j])
               {
                   sum++;
                   if(sum==3)
                   {
                       flag=0;
                       break;
                   }
               }
    
    
           }
    
           if(flag==1)
           {
               int temp=lru[0];
             if(j==0)
             {
    
             }
             else if(j==1)
             {
                lru[0]=lru[j];
    
                 lru[2]=lru[2];
                 lru[1]=temp;
             }
    
             else if(j==2)
             {
                 lru[0]=lru[j];
    
                 lru[2]=lru[1];
                 lru[1]=temp;
    
             }
    
           }
           else if(flag==0)
           {
               allchagetimes++;
               lru[2]=lru[1];
               lru[1]=lru[0];
               lru[0]=ym[i];
    
    
           }
    
           for(int t=0;t<N;t++)
           {
               cout<<lru[t]<<"  ";
           }
           cout<<endl;
       }
    
       cout<<"缺页"<<allchagetimes+3 <<"次,置换"<<allchagetimes<<"次"<<endl;
    
    }
    
    

    在这里插入图片描述

    展开全文
  • ☝☝☝软件工程考研独家平台撰稿| 康康哥编辑| 丽丽姐本文由懂计算机、软件工程的博士师哥原创双日练:NO.20200812系统为某进程分配了 4 个页框...( )A 2B 3C 4D 8本题考查:LRU页面置换算法。基本思想:这种算法的...
    ☝☝☝ 软件工程考研独家平台

    撰稿 | 康康哥

    编辑 | 丽丽姐

    本文由懂计算机、软件工程的博士师哥原创

    dfd884e916ce6d7866928cd2c91d13bd.png

    双日练:NO.20200812

    1a4ac217de7175bc894d20a3282783e2.png

    系统为某进程分配了 4 个页框,该进程已访问的页号序列为 2,0,2,9,3,4,2,8,2,3,8,4,5。若进程要访问的下一页的页号为 7,依据 LRU 算法,应淘汰页的页号是?( )

    A 2

    B 3

    C 4

    D 8

    本题考查:LRU页面置换算法。

    基本思想:

    这种算法的基本思想是:利用局部性原理,根据一个作业在执行过程中过去的页面访问历史来推测未来的行为。

    它认为,过去一段时间里不曾被访问过的页面,在最近的将来可能也不会再被访问。

    所以,这种算法的实质是:当需要淘汰一个页面时,总是选择在最近一段时间内最久不用的页面予以淘汰。

    由于窗口为4,上一个含有4张页号的序列为3,8,4,5

    页面自上次被访问以来所经历的时间t中,4的t最大,也就是最久没被访问。

    故选C。

    357835b0b015ad0d8818d8c4dac22bd1.png软工博士带你飞
    考软工 · 看CS优化狮86b4c99e4777c2f05ac30a5794f9440a.pngac12c8a98b4fce8f9af71a14da754afa.png
    展开全文
  • LRU页面置换算法模拟 - 最近最久未使用置换算法 - 课程设计 LRU 页面置换算法模拟 - 最近最久未使用置换算法 | 课程设计 | 计算机数据库课程设计 一设计目的 1用 C 语言实现最近最久未使用 LRU置换算法 2了解内存...
  • lru页面置换算法

    2011-12-04 10:30:31
    操作系统的页面置换算法的详细代码,是dos系统下的模拟实验算法
  • 基于linux C模拟FIFI和LRU页面置换算法
  • FIFO、OPT、LRU页面置换算法实验代码和截图
  • LRU页面置换算法实现

    2014-05-09 18:34:35
    LRU页面置换算法实现 一请求分页存储系统,进程P共有5页,访问串为3,2,1,0,3,2,4,3,2,1,0,4,试采用LRU算法和LFU算法分析,当分配页面数为3时,发生的缺页中断次数
  • 操作系统LRU页面置换算法
  • 页而之后算法模拟 课程名称操作系统 课程号 学院系 专业 班级 学生姓名 学号 实验地点 实验日期 LRU页面置换算法模拟 实验目的 1 掌握页式管理基本原理 2 掌握LRU页而宜换算法 实验内容 1 按照最近最久未使用页而...
  • LRU页面置换算法,使用Java语言编写,使用策略模式,可以方便的换成其他页面置换算法!相当好!
  • 使用栈实现LRU页面置换算法的代码 LRU页面置换算法可以使用基于计数器,或者基于栈两种方式进行实现 基于计数器 若有不当之处,请您指出,您的指点是我的荣幸 代码实现 import java.util.Scanner; /** * LRU页面...

    前言

    使用栈实现LRU页面置换算法的代码
    LRU页面置换算法可以使用基于计数器,或者基于栈两种方式进行实现
    基于计数器
    若有不当之处,请您指出,您的指点是我的荣幸

    代码实现

    这里使用双向链表来实现栈

    
    import java.util.Scanner;
    
    /**
     * LRU页面置换算法--基于栈
     */
    
    public class LRUStack {
    
    
        public static void main(String[] args) {
    
            //当链表未达到指定长度时,用来表示链表的长度
            int length = 0;
    
            //表示缺页错误次数
            int pageFault=0;
    
            //先创建一个头结点
            StackSlot head = new StackSlot(null, -1, null);
    
            //表示每次页面进来时,若需要创建节点,该变量作为中转节点
            StackSlot nowNode = null;
    
            //表示头结点后的第一个节点
            StackSlot firstNode=null;
    
            //表示最后一个节点
            StackSlot lastNode=null;
    
            //当需要进行链表节点的变换的时候,以此作为中转
            StackSlot tempNode=null;
    
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入页面的数量");
            //定义页面数量
            int num=sc.nextInt();
    
            System.out.println("请输入栈的深度");
            //定义栈的深度(其实也就是帧数组的长度)
            int frame=sc.nextInt();
    
            //创建页面数组
            int[] pageArr=new int[num];
            System.out.println("请输入页面序列");
    
            //初始化页面数组
            // 1,2,3,4,3,5,3,8,4,7,2,1,0,9,12,33,2,1,6,2,1
            for(int i=0;i<num;i++){
                pageArr[i]=sc.nextInt();
            }
    
            //构建一个链表
            for (int i = 0; i < num; i++) {
    
                //此时链表未达到指定长度
                if(length==0){
                    //第一个节点
    
                    //新建链表
                    nowNode=new StackSlot(head,pageArr[i],null);
                    //链接
                    head.next=nowNode;
                    //链表长度+1
                    length++;
                    //缺页错误次数+1
                    pageFault++;
                }else if(length==1){
                    //此时链表有了一个节点
    
                    //判断链表中是否有相同页码的页
                    tempNode=hasSame(head,pageArr[i]);
                    //如果没有相同页码的页
                    if(tempNode==null){
                        //如果没有页码相同的页
    
                        lastNode=getLast(head);
                        //新建一个节点
                        nowNode=new StackSlot(lastNode,pageArr[i],null);
                        //链接到链表末尾
                        lastNode.next=nowNode;
                        length++;
                        pageFault++;
                    }
                }else if(length<frame){
                    //此时链表中已经有两个或两个以上的节点,但是未满
                    //查看是否有页码相同的页,若有就将该节点返回
                    tempNode=hasSame(head,pageArr[i]);
                    //获取最后一个节点
                    lastNode=getLast(head);
    
                    //如果没有页码相同的页
                    if(tempNode==null){
                        //如果链表中没有页码相同的页
    
                        //新建一个节点
                        nowNode=new StackSlot(lastNode,pageArr[i],null);
                        //拿到最后一个节点
                        lastNode.next=nowNode;
                        //链表长度+1
                        length++;
                        pageFault++;
                    }else{
                        //如果有相同页码的页
                        //如果页码相同的页不是末尾节点的话
                        if(tempNode.page!=lastNode.page){
    
                            //将该节点从链表中删除
                            tempNode.pre.next=tempNode.next;
                            tempNode.next.pre=tempNode.pre;
    
                            //将该节点链接到末尾
                            lastNode.next=tempNode;
                            tempNode.pre=lastNode;
                            tempNode.next=null;
                        }
                    }
                }else{
                    //此时链表已经达到指定长度了,接下来发生缺页错误将进行页面的置换
    
                    //检验链表中是否有相同页码的页
                    tempNode=hasSame(head,pageArr[i]);
                    //拿到最后一个节点
                    lastNode=getLast(head);
                    //如果没有页码相同的页,就要淘汰掉头结点后的第一个节点
                    if(tempNode==null){
                        //拿到原先的头结点之后的第一个节点
                        firstNode=getFirst(head);
    
                        //新建一个节点
                        nowNode=new StackSlot(lastNode,pageArr[i],null);
    
    
                        //淘汰第一个节点
                        head.next=firstNode.next;
                        firstNode.next.pre=head;
    
                        //将新建节点链接到末尾
                        lastNode.next=nowNode;
    
                        //缺页错误次数+1
                        pageFault++;
    
                    }else{
                        //如果已经有了相同的页,将该页调到末尾去!
                        //将该节点从链表中删除
                        tempNode.pre.next=tempNode.next;
                        tempNode.next.pre=tempNode.pre;
    
                        //链接到末尾
                        lastNode.next=tempNode;
                        tempNode.pre=lastNode;
                        tempNode.next=null;
                    }
                }
            }
    
            //打印链表
            myPrint(head,pageFault);
    
        }
    
        //查看当前链表中是否已经有此页
        public static StackSlot hasSame(StackSlot head, int page) {
            while (head!= null) {
                if (head.page == page) {
                    //如果已经有相同的页面在帧数组当中就返回
                    return head;
                }
                head = head.next;
            }
            //没有就返回null
            return null;
        }
    
        //进行链表的变换的时候,需要将节点链接到最后,所以需要获得最后一个节点
        public static StackSlot getLast(StackSlot head){
            while(head.next!=null){
                head=head.next;
            }
            return head;
        }
    
        //获取头结点后的第一个节点
        public static StackSlot getFirst(StackSlot head){
            return head.next;
        }
    
        //打印链表
        public static void myPrint(StackSlot head,int pageFault){
            head=head.next;
            System.out.print("页面序列-->{ ");
            while(head!=null){
                System.out.print(head.page+" ");
                head=head.next;
            }
            System.out.println("}");
            System.out.println("缺页次数-->"+pageFault);
        }
    
    }
    
    
    /**
     * 这个栈是由双向链表实现的
     */
    class StackSlot {
        //指向前一个节点的地址
        StackSlot pre;
        //页码
        int page;
        //指向下一个节点的地址
        StackSlot next;
    
        public StackSlot(StackSlot pre, int page, StackSlot next) {
            this.pre = pre;
            this.next = next;
            this.page = page;
        }
    
    
    }
    
    
    展开全文
  • 主要实现主存空间的分配和回收、存储保护。主要是对用户区的管理。存储管理采用请求分页式存储管理方式。该系统的页面置换算法必须包括先进先出页面置换算法、最近最少使用LRU页面置换算法、最佳置换算法。
  • 模拟实现FIFO和LRU页面置换算法:代码
  • ### 什么是LRU页面置换算法 LRU(Least Recently Used),是页面置换算法的一种,它的主要思想是当用于缓存页面的地址块已满时,选择最久未使用的页面删除,然后用将新请求的页面加入缓存。 例如:请求为 {1,2, 0, 3...
  • LRU页面置换算法的源代码,以及可执行程序
  • 模拟LRU页面置换算法

    千次阅读 2012-06-16 19:07:13
    实验二 模拟LRU页面置换算法   一、 实验目的 1) 用C或C++模拟LRU页面置换算法 2) 掌握LRU页面置换算法的调度过程 二、 实验内容 设计一个虚拟存储系统,编写程序模拟LUR页面置换算法,通过程序输出...
  • LRU页面置换算法C++代码 常见的缓存算法: LRU:(least recently used) 最近最少使用,思想是如果一个数据刚被访问过,那么将来被访问的几率也更高 LFU:(least frequently used) 最少经常使用,思想是如果一个...
  • 功能与目标硬盘的读写要比内存慢一到两个数量级,所以要尽可能减少页面的换进换出次数有一些需要常驻内存,比如操作系统实验设置与评价方法如何分析比较最优页面置换算法(OPT,optimal)理想状态下我们想要替换很长一...
  • LRU页面置换算法模拟

    2015-12-03 20:18:47
    用C语言编写的模拟LRU置换算法,界面较为简易,多多指教。
  • 操作系统LRU页面置换算法 C语言程序 数组实现 简单,清晰且实用,
  • 使用LRU算法实现页面置换算法LRU算法基于一种假设,长期不使用的数据,在未来的使用性也不大。因此,当数据占用内存达到一定的阙值时,我们要移除最近最少使用的数据。LRU算法中,使用了一种有趣的数据结构,叫做...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,745
精华内容 698
关键字:

lru页面置换算法