精华内容
下载资源
问答
  • 组成原理----存储管理

    千次阅读 热门讨论 2014-10-27 11:57:51
    存储管理的主要目的是解决多个用户使用主存的问题,其存储管理方案主要包括分区存储,分页存储,分段存储,段页式存储,虚拟存储。下面将介绍页,段,段页存储。

            存储管理的主要目的是解决多个用户使用主存的问题,其存储管理方案主要包括分区存储,分页存储,分段存储,段页式存储,虚拟存储。下面将介绍页,段,段页存储。

    分页存储管理

                 分页原理:将进程的地址空间划分成若干个大小相等的区域,称为页。相应的,将主存空间划分成与页相同大小的若干物理块,称为块,在为进程分配主存时,将进程中若干页分别装入多个不相邻接的块中。

            地址结构,由页号和页内地址组成。

    下面用图演示页式虚拟存储器的地址映射过程

    PS:从上图中是通过虚存地址获取实存地址的过程。

    上图表示页表的构成,包括控制位和主存页面号,每个页号有一个目录,包含主存页面地址。


    上图表示通过虚存地址中的逻辑页号与页表基地址的和找到主存中的页面号,由主存页面地址作为实存地址的高字段,与虚存地址的行地址字段相拼接,产生完成的实主存地址。

    段式存储管理

                  在分段存储管理中,作业的地址空间被划分为若干段,每个段式一组完整的逻辑信息,如有主程序段,子程序段,数据段及堆栈段等,每个段都有自己的名字,都是从0开始编址的一段连续的 地址空间,各段长度不等。逻辑地址分为段号和段内地址两部分。
            在段式存储中,为每个段分配一个连续的分区,而进程中的各个段可以离散地分配到主存的不同分区中。在段式存储中为每个进程建立一张段映射表,成为段表。
    下面演示段虚存地址映射过程


     段页式存储管理

                段式页式存储基本原理:先将整个主存划分成大小相等的存储块(页框),将用户程序按程序的逻辑关系分为若干个段,并未每个段赋予一个段名,再将每个段划分成若干页,以页框为单位离散分配。在段页式存储中其地址结构由段号,段内页号和页内地址三部分组成。
           在段页式系统中,为了实现从逻辑地址到物理地址的变换,系统中必须同时配置段表和页表。由于将段中的页进行离散地分配,段表中的内容不再是段的主存地址和段长,而是页表始址和页表长度。
    下面演示段页式虚存的地址转换过程

        上述的图中的注释表示很清楚,所以不再文字赘述,简单的的描述过程,有错误的还请雅正。
    展开全文
  • 地址重定位(二)存储管理方案1.分区存储管理2.分区保护(三)分页存储管理1.纯分页存储管理2.快表3.两级页表机制(四)分段存储管理(五)段页式存储管理1.程序局部性原理2.虚拟存储器的实现3.请求分页管理的实现...


    存储管理的对象是主存存储器简称主存或内存。
    存储管理的主要功能包括主存空间的分配和回收、提高主存的利用率、扩充主存、对主存信息实现有效保护。

    (一)基本概念

    1.存储器的结构

    常用的存储器的结构有“寄存器-主存-外存”结构和“寄存器-缓存-主存-存储组织的功能外存”结构。

    • 虚拟地址,从0号单元开始编址,并顺序分配所有符号名所对应的地址单元,所以它不是主存中的真实地址。
    • 地址空间,源程序经过汇编或编译后再经过链接编辑程序加工形成程序的装配模块,即转换为相对地址编址的模块,它是以0为基址顺序进行编址的。把程序中由相对地址组成的空间称为逻辑地址空间,相对地址空间通过地址再定位机构转换到绝对地址空间。
    • 存储空间,逻辑地址空间(简称地址空间)是逻辑地址的集合,物理地址空间(简称存储空间)是物理地址的合集。

    2.地址重定位

    定义: 是指将逻辑地址变换成主存物理地址的过程。

    地址重定位分为:

    • 静态重定位,是指在程序装入主存时已经完成了逻辑地址到物理地址的变换,在程序的执行期间将不再会发生变化。
      • 优点:无须硬件地址变换机构的支持,它只要求程序本身是可重定位的,只对那些要修改的地址部分具有某种标识,由专门设计的程序完成。
      • 缺点:必须给作业分配一个连续的存储区域,在作业的执行期间不能扩充存储空间,也不能在主存中移动,多个作业也难以共享主存中的同一程序副本和数据。
    • 动态重定位,是指在程序运行期间完成逻辑地址到物理地址的变换。
      • 优点:程序在执行期间可以换入和换出主存,以解决主存空间不足的问题;可以在主存中移动,把主存中的碎片集中起来,以充分利用空间;不必给程序分配连续的主存空间,可以较好地利用较小的主存块;可以实现共享。

    (二)存储管理方案

    存储管理的主要目的是解决多个用户使用主存的问题,其存储管理方案主要包括区分存储管理、分页存储管理、分段存储管理、段页式存储管理及虚拟存储管理。

    1.分区存储管理

    核心思想: 把主存的用户区划分成若干个区域,每个区域分配给一个用户作业使用,并限定它们只能在自己的区域中运行。

    按划分方式不同可分为:

    • 固定分区,是一种静态分区方式,在系统生成时已将主存划分为若干哥分区,每个分区的大小可不等。
    • 可变分区,是一种动态分区方式,存储空间的划分是在作业装入时进行,古分区的个数是可变的,分区的大小刚好等于作业的大小。
      可变分区的请求和释放分区主要有如下四种算法:
      • 最佳适应算法
      • 最差适应算法
      • 首次适应算法
      • 循环首次适应算法
    • 可重定位分区,移动所有已分配好的分区,使之称为连续区域。

    2.分区保护

    目的: 防止未经核准的用户访问分区。

    常用方式:

    • 采用上界/下界寄存器保护
    • 采用基址/限长寄存器保护

    (三)分页存储管理

    1.纯分页存储管理

    • 分页原理
      将一个进程的地址空间划分成若干个大小相等的区域,称为页。
      将主存空间划分成与页相同大小的若干个物理块,称为块或页框。
    • 地址结构
      两部分组成:页号、页内地址
    • 页表
      系统为每个进程建立一张页面映射表,简称页表。

    2.快表

    在地址映射机构中增加一个小容量的联想存储器,联想存储器由一组高速存储器组成,称之为快表,用来保存当前访问频率高的少数活动页的页号及相关信息。

    3.两级页表机制

    将页表进行分页,每个页面的大小与主存物理块的大小相同,并为它们进行编号,可以离散地将各个页面分别存放在不同的物理块中。为此需要建立一张页表,称为外层页表(页表目录),即第一级是页目录表,其中的每个表目是存放某个页表的物理地址;第二级是页表,其中的每个表目所存放的是页的物理块号。

    两级页表的地址变换机构


    (四)分段存储管理

    在分段存储管理方式中,作业的地址空间被划分为若干个段,每个段是一组完整的逻辑信息,例如有主程序段、子程序段、数据段及堆栈段等,每个段都有自己的名字,都是从0开始编址的一段连续的地址空间,各段的长度是不等的。

    逻辑地址由段号(名)和段内地址两部分组成。


    (五)段页式存储管理

    段页式系统的基本原理是先将整个主存划分成大小相等的存储块(页框),将用户程序按程序的逻辑关系分成若干个段,并未每个段赋予一个段名,再将每个段划分成若干页,以页框为单位离散分配。

    在段页式系统中,其地址结构由段号、段内页号和业内地址三部分组成。
    段页式管理的地址结构

    1.程序局部性原理

    程序在执行时将呈现局部性规律,即在一段时间内,程序的执行仅局限于某个部分。相应地,它所访问的存储空间也局限于某个区域内。

    程序的局限性表现在:

    • 时间局限性,指如果程序中的某条指令一旦执行,则不久的将来该指令可能再次被执行;如果某个存储单元被访问,则不久以后该存储单元可能再次被访问。
    • 空间局限性,指一旦程序访问了某个存储单元,则在不久的将来,其附近的存储单元也最有可能被访问。

    2.虚拟存储器的实现

    虚拟存储器的实现有如下三种方式:

    • 请求分页系统,在分页系统的基础上增加了请求调页功能和页面置换功能所形成的页式虚拟存储系统。
    • 请求分段系统,在分段系统的基础上增加了请求调段和分段置换功能所形成的段式虚拟存储系统。
    • 请求段页式系统,在段页式系统的基础上增加了请求调页和页面置换功能所形成的段页式虚拟存储系统。

    3.请求分页管理的实现

    请求分页是在纯分页系统的基础上增加了请求调页功能、页面置换功能所形成的页式虚拟存储系统,是目前常用的一种虚拟存储器的方式。


    (六)虚拟存储管理

    1.程序局部性原理

    局限性表现在时间局限性和空间局限性两个方面。

    2.虚拟存储器的实现

    • 请求分页系统
    • 请求分段系统
    • 请求段页式系统

    3.请求分页管理的实现

    请求分页是在纯分页系统的基础上增加了请求调页功能、页面置换功能所形成的页式虚拟存储系统,它是目前常用的一种虚拟存储器的方式。

    4.页面置换算法

    常用的页面置换算法:

    • 最佳置换算法
    • 先进先出置换算法
    • 最近最少未使用置换算法
    • 最近未用置换算法

    5.工作集

    工作集就是指在某段时间间隔里进程实际要访问的页面的集合。


    展开全文
  • 操作系统基础课存储管理2 一.加速分页过程 虚拟内存和分页技术从原理上实现了多道程序并行的内存管理,但还要考虑几个效率问题: 1, 虚拟地址到物理地址的映射要尽可能快。 2, 虚拟空间很大会造成页表很大...

    操作系统基础课存储管理2

     

    一.加速分页过程

    虚拟内存和分页技术从原理上实现了多道程序并行的内存管理,但还要考虑几个效率问题:

    1,  虚拟地址到物理地址的映射要尽可能快。

    2,  虚拟空间很大会造成页表很大,大页表造成内存开销很大。

    二.转换检测缓冲区TLB

    为加快分页速度,就要减少内存访问次数,一种解决方案是,大多数程序总是对少量的页面进行多次访问,因此只有很少的页表项会被反复读取。而其他页表项很少被访问。具体实现是可以为计算机设置一个小型的硬件设备,将虚拟地址直接映射到物理地址,而不必在访问页表,这种设备就是转换检测缓冲区Translation Lookaside Buffer,也即关联存储器。通常在MMU中,包含少量表项,每个表项纪录一个页面的相关信息,包括虚拟页号,页面修改位等。注意虚拟页号是此种特有的,而真实页表中不一定需要此项

     

    工作过程:当虚拟地址进入MMU进行转换时,先查找TLB中匹配的虚拟页号,如果存在一个有效的匹配,查看其保护位以确定当前操作是否有访问权限,如果不违反保护位,则取出表项中的页框号映射而不必访问内存。如果没有匹配的项,则要进行正常的页表查询,进入内存。然后从TLB中删除一个表项,用新找到的表项替代它,同时将删除表项的信息复制到内存页表对应的页表项中,其实就是修改页表项修改位和访问位(目的是更新页表项实用信息,为页表置换算法提供支持)。

    三.大内存页表

    TLB提高了虚拟地址到物理地址的映射,到虚拟内存的另外一个问题是,如果对于大的内存,虚拟内存可能是更大的地址空间,页表会有更多的表项,16位虚拟地址用4位来索引页表,因此页表共有16项.如果是32位地址,用20位索引,就有2^20个表项,一个巨大的虚拟地址空间。

    像计算机很多地方的处理方式一样,采用多级目录,这里采用多级页表,32位地址被分为10位PT1域,10位PT2域,和12位编移量,PT1域对应顶级页表,PT2域对应二级页表,一起被用于确定物理存储块的基地址,然后在基地址上通过12位偏移量确定相应的存储单元。

    但是事实一个进程或程序并不需要用到全部的地址空间,所以一般只用到顶级页表的三项,进程抽象了内存,所以程序在进程地址空间的存储就类似于前文所诉的,程序正文段位于顶级页表底部,上面是数据段,顶部是堆栈段,空闲区域为扩展备用:

     

    如图,顶级页表中只有没有阴影的三项使用了映射,从上到下分别对应堆栈段,数据段和正文段,其他表项的Present/absent位都被置为0.访问这些项讲产生缺页中断,操作系统准备负责新的映射。

    考虑另一个问题,这样的页表需要多大的空间,顶级页表共2^10=1024个表项,如果每个表项1字节,共1KB,每个表项对应一个二级页表索引,每个二级页表大小和顶级页表大小相同,也是1KB,共1024个二级页表,共1MB,所以共1025KB,可以接受。

    但是如果是64位计算机,使用64位地址空间,除去12位偏移量,用52位映射物理页框,52位就有2^52个虚拟页面,也就是2^52个页表项,即使最小每个页表项1字节,可以计算这样的开销有多大。即使使用多级页表,对大小的帮助也不明显。

    解决的办法是使用倒排页表。针对每一个物理页框建立表项,而不是对虚拟页面。对1GB的RAM,4KB的页,只需2^18项,每项是一个页框和页面的映射,类似键值对。每次访问都查找这样的键值对是否存在。带来的问题是以前查找是使用虚拟地址索引到对应的页面,是随机访问。但如果用这样的键值对,就没有了这样的索引必须从头开始逐个检索,这必然是个耗时的操作。要提高这个速度同样可以使用TLB,但TLB失效时,还是要逐个检索页表,为了避免这个操作,可以使用一个比较好的数据结构--哈希(个人觉得哈希表真是最优雅的数据结构)。根据虚拟页面进行哈希(即对虚拟页面地址),将相同散列值的虚拟页面链接在一起,哈希表长度为2^18(针对1GB内存),这样哈希后每个链表的平均长度为1,减少链式访问次数,尽量随机访问到。

     

    四.页面置换算法Page Replacement Algorithms

    发生缺页中断时,操作系统必须将在内存中的一个页面换出,以便为即将调入的页面腾出空间,如果换出的页面在内存驻留期间已经被修改过(查看其修改位),必须把它写回磁盘(即更新磁盘副本),如果没有没修改过,则磁盘副本依然有效,可以直接从磁盘调入新的页面覆盖之。选择哪个页面换出需要一个策略,如果一个频繁使用的页面被换出,很快就有需要再此换入,应该尽量减少这样的操作。为提高性能,选择最合适的页面换出就需要页面置换算法。

    最优页面置换算法:

    基本思想:内存中的每个页面可能在一个指令后被访问,也可能在很多个指令后才被访问,如果多少个指令之后被访问作为标记标记每一个页面,则在缺页中断发生时,选择那些标记最大的页面淘汰,也就是淘汰那些在很多个指令之后才会被使用或访问的页面。在需要时再将其换回。

    但这个思想是难以实现的,原因在于操作系统无法预先知道某个页面在何时会被访问。

    最近未使用页面置换算法:

    每个页面大都有一个访问位和修改位,简称R位和M位,当一个进程启动时,其所有页面的这两个位都被置为0,运行过程总如果访问到该页面,访问位置1,如果对该页面进行了修改修改位置1,R位被定期(每个时钟中断)的清零,但M位不清零,以便在页面换出时判断是否应该写回磁盘。因此每一个时刻,一个页面根据这两位被分为4个状态:

    第0类:没有被访问,没有被修改

    第1类:没有被访问,已被修改

    第2类:已被访问,没有被修改

    第3类:已被访问,已被修改

    第三类在时钟中断清零后就变成第一类,页面置换算法随机的从编号最小的类中选择一个页面将其换出。

    先进先出页面置换算法:

    将访问过的页面排成一个队列,先访问的页面在队头,后访问的页面在队尾。其实队头的页面是进入内存最久的,而队尾的页面是刚访问的也就是刚进入内存的。缺页中断发生时,淘汰队头的页面,并将换入的页面插入队尾。但这样做可能会淘汰一个队头页面,虽然这个页面最先被访问,但在整个过程中访问很频繁,队列只对页面最早被访问的时间进行了区分,而未考虑页面访问频率,因此会因为换出一些比较重要的页面而引起性能问题。

    第二次机会页面置换算法:

    FIFO算法可能会换出队头经常被使用的页面,对其进行修改:检查最老页面的R位,如果是0,则该页面就是最老有最没用(未使用)的页面,将其换出,如果R位是1,则虽然该页面最老,但老当益壮,经常被使用,因此将此页面放到队尾,并修改R位为0.这是一个比较好的算法,可能的缺陷在于将队头换到队尾的操作。完全可以想到一个更好的数据结构代替这样的队列,即环形队列,队头接队尾,这样就只需修改队头指针就可以了。修改后的算法成为时钟页面置换算法。

    最近最少使用页面置换算法:

    在前面几条指令中频繁使用的页面很可能在后面几条指令中继续被使用,而很久没被使用的页面很可能在未来很长一段时间内也不会被使用。所以当缺页中断发生时,置换未使用时间最长的页面,这就是LRU(Least Recently Used),这个算法的实现非常精彩和巧妙,第一次看到时心情相当兴奋:

     

    假设有4个页面0,1,2,3,访问顺序为0,1,2,3,2,1,0,3,2,3.这些页面被排在4×4的矩阵中,每行代表一个页面。当一个页面a被访问时,将矩阵中对应第a行所有列置1,然后将第a列全部置0,每行中1的个数代表了该页面的活跃程度,所以如图,但0页面一开始被访问是,被置3个1,然后之后三个时间都没有被访问,所以在第三个页面访问时,0页面又全部恢复为0,即最近不活跃。行列的设计非常巧妙,暂时没有想到用一种言语或模型来描述行列之间的微妙关系,只能意会了。

     

    五.分页系统设计问题之局部分配和全局分配策略

    之前讨论的分页,页面置换,以及页面置换算法貌似都是针对一个进程讨论的,那么发生缺页中断时,换出的页面是来自该进程本身还是从内存所有进程中选取呢。

    从内存所有页面中选择淘汰页面是一种全局的算法,而只是从进程自己的地址空间中选取页面是一种局部的算法。称全局置换算法和局部置换算法。

    局部算法可以有效的为每个进程分配固定的内存片段(可以理解为页框),而全局算法在可运行进程之间动态的分配页框,因此各个进程的页框数是动态变化的。

    解释两个名词:

    工作集:一个进程当前使用的所有页面集合。随着进程的运行,进程会加载更多的页面,换入换出操作会使工作集扩展或缩小。

    在全局算法下进程加载新的页面,操作系统选择空闲页框建立映射,工作集增长,局部算法也可以在分配给进程的内存片段中寻找空闲页框而使工作集增长,如果没有空闲页框,执行页面置换算法,不过有无空闲页框,都会产生陷阱,使CPU陷入操作系统,即缺页中断建立新的映射。这是一个系统及的调用,会使当前进程运行速度减慢,即进程抖动,也称颠簸。

    为一个进程分配多少的页框合适,在局部方法中,因为进程的内存片段是固定的,所以进程运行过程中,如果工作集减小,局部方法会有较多页框空闲而浪费资源,工作集满则每次缺页中断都执行换入换出操作。(此处不明白什么原因会导致工作集减小,局部方法应该一开始就为所有的页框执行好映射,即工作集满,然后缺页中断只是换入换出,并不会导致工作集减少。可能是一些像垃圾回收或局部变量失效的操作主动回收不会再使用的页面)。而如果是全局方法,一种好的做法是位进程大小按比例分配页框,同时规定一个最小页框数。所有空闲页框组成一个公用池,同时检测所有进程运行状况,分配在进行运行过程中动态更新。

    这就要有一个动态内存管理机制,一种方法是PFF(page fault frequency)缺页中断率算法,它指出了何时为一个进程分配页面,合适回收分配给该进程的页面。(这里适当的时候回收页面,那么在缺页时只需换入而不用换出,换出在一个之前的时间完成)。缺页中断率为每秒缺页中断的次数除以该进程所分配的页框数(也可以认为是进程使用中的页面数)。缺页中断率会随着分配页框的增大而减小。

     

    六.页面大小

    页面的大小也需要权衡,偏向于选择小页面,好处是首先,产生较少的内部碎片(internal fragmentation),因为大页面而数据小会空闲该页面,而该空闲无法被继续使用。另外,更好的适应各种数据结构和程序,如果程序分段,小页面可以在内存中保留较少的无用程序段。但小页面的缺陷是会加大页表,同时在换入换出是增大磁盘寻道时间。

    从数学上分析,假设进程的大小是s字节,页面大小p字节,每个页表项e字节,那么每个进程需要的是s/p个页项,页表和内部碎片开销为se/p+p/2

    页面比较小时,第一项较大,页面较大时第二项较大,最优解是取中间的某个值,对p求导,求极值。

     

     

     

     

     

     

     

     

     

    转载于:https://www.cnblogs.com/brucemu/archive/2013/06/08/3127848.html

    展开全文
  • 本篇博文为追忆以前写过的算法系列第一篇(20081021) 温故知新 目的: 为了解决内存容量有限与多...分页存储管理是实现虚拟存储的一种方案。通过模拟算法的实验。加深理解,虚拟存储器的基本原理和方法。 要求...

    本篇博文为追忆以前写过的算法系列第一篇(20081021)

    温故知新


    目的: 为了解决内存容量有限与多作业执行的冲突。运用了虚拟存储技术。能从逻辑上对内存进行扩充,达到扩充内存的效果。分页存储管理是实现虚拟存储的一种方案。通过模拟算法的实验。加深理解,虚拟存储器的基本原理和方法。


    要求: 1.请求分页的置换算法(FIFO && RUL算法实现);2.按给定的顺序列,输出页面调度过程包含命中 / 缺页,调入/调出;3.计算缺页率,频率。


    说明

    vp_list[N]        //訪问序列
    bs[M]             //内存块表,M为内存块大小
    struct pt{
    	int pno;       //页号
    	int bno;       //块号
    	int flag;       //状态位,为0时在不内存。为1时在内存
        int order;      //优先序号
    };
    


    算法流程:

    程序:

    /* gujinjin 08/10/20 */
    /* 程序名称:fifo &&LRU */
    /* 程序目的:页面置换算法的FIFO编程实现 */
    
    #include<iostream>
    using namespace std;
    
    #define N 20 //訪问序列数组大小
    #define M 10  //内存块表数组大小
    
    struct pt{
    	int pno;	//页号
    	int bno;	//块号
    	int flag;	//状态位,为0时在不内存,为1时在内存
    	int order;	//优先序列
    };
    
    /*------------------------------------------*/
    /*输入函数*/
    /*------------------------------------------*/
    void input(int *a,int n)
    {
    	for(int i=0;i<n;i++){cin>>*a;a++;}
    }
    
    /*------------------------------------------*/
    /*输出函数*/
    /*------------------------------------------*/
    void output(int *a,int n)
    {
    	for(int i=0;i<n;i++){cout<<*a<<'\t';a++;}
    	cout<<'\n';
    }
    
    /*------------------------------------------*/
    /*算法fifo && LRU函数*/
    /*------------------------------------------*/
    void fifo(int*vp_list,int*bs,int n,int m)
    {
    	pt ptlist[N];//定义结构数组
    	
    
    	int k=0,flag,cn=0,i,j;//cn——统计缺页数
    	for(j=0;j<m;j++)//赋初值
    	{
    		bs[j]=0;
    	}
    
    	for(i=0;i<n;i++)// 訪问序列循环
    	{
    		flag=0;
    		for(j=0;j<m;j++)
    			if(vp_list[i]==bs[j]){flag=1;break;}
    		if(flag==1)//命中
    		{
    			ptlist[i].bno =j+1;
    			ptlist[i].flag =1;
    			ptlist[i].pno =vp_list[i];
    		}
    		else{
    			ptlist[i].flag =0;
    			ptlist[i].pno =vp_list[i];
    
    			bs[k]=vp_list[i];
    			ptlist[i].bno =k+1;
    			k=(k+1)%m;//取模——循环队列
    			cn++;
    		}
    	}
    	cout<<"FIFO算法:\n";
    	cout<<"----------------------------------**\n";
    	cout<<"缺页率为:"<<'\t'<<(float)cn/n<<'\n';
    	cout<<"-------------------------------------------------------------------**\n";
    	cout<<"序列号\n";
    	cout<<"-------------------------------------------------------------------**\n";
    	for(i=0;i<m;i++)
    	{
    		cout<<vp_list[i]<<"\t缺页!\t"<<"直接存入内存块!\n";
    	    cout<<"-------------------------------------------------------------------**\n";
    	}
    	for(i=m;i<n;i++)
    	{
    		if(ptlist[i].flag ==0)
    			cout<<vp_list[i]<<"\t缺页!\t"<<"调出------块号为"<<ptlist[i].bno <<"--页号为"<<ptlist[i].pno <<'\n';
    		else cout<<vp_list[i]<<"\t命中!"<<"\t位置------块号为"<<ptlist[i].bno <<"--页号为"<<ptlist[i].pno <<'\n';;
    		cout<<"-------------------------------------------------------------------**\n";
    	}
    }
    void LRU(int*vp_list,int*bs,int n,int m)
    {  
    	//----------------------------------------------------------------------------------------------**
        pt ptlist_LRU[N];
    	int k=0,flag,cn=0,i,j;//cn——统计缺页数
    	int com;
    	for(j=0;j<m;j++)//赋初值
    	{
    		bs[j]=0;
    	}
    	for(j=0;j<n;j++)ptlist_LRU[j].order =0;
    
    	for(i=0;i<n;i++)// 訪问序列循环
    	{
    		flag=0;
    		for(j=0;j<m;j++)
    			if(vp_list[i]==bs[j]){flag=1;break;}
    		if(flag==1)//命中
    		{
    			ptlist_LRU[i].bno =j+1;
    			ptlist_LRU[i].flag =1;
    			ptlist_LRU[i].pno =vp_list[i];
    			ptlist_LRU[i].order--;
    			com=ptlist_LRU[i].order;
    			for(j=0;j<m;j++)
    				if(ptlist_LRU[j].order <com)
    				{com=ptlist_LRU[j].order;k=ptlist_LRU[j].bno ;}
    		}
    
    		else{
    			ptlist_LRU[i].flag =0;
    			ptlist_LRU[i].pno =vp_list[i];
    
    			bs[k]=vp_list[i];
    			ptlist_LRU[i].bno =k+1;
    
    			if(i<m)k=(k+1)%m;
    			cn++;
    		}
    	}
    	cout<<"LRU*算法:\n";
        cout<<"----------------------------------**\n";
    	cout<<"缺页率为:"<<'\t'<<(float)cn/n<<'\n';
    	cout<<"-------------------------------------------------------------------**\n";
    	cout<<"序列号\n";
    	cout<<"-------------------------------------------------------------------**\n";
    	for(i=0;i<m;i++)
    	{
    		cout<<vp_list[i]<<"\t缺页!\t"<<"直接存入内存块!\n";
    	    cout<<"-------------------------------------------------------------------**\n";
    	}
    	for(i=m;i<n;i++)
    	{
    		if(ptlist_LRU[i].flag ==0)
    			cout<<vp_list[i]<<"\t缺页!\t"<<"调出------块号为"<<ptlist_LRU[i].bno <<"--页号为"<<ptlist_LRU[i].pno <<'\n';
    		else cout<<vp_list[i]<<"\t命中!"<<"\t位置------块号为"<<ptlist_LRU[i].bno <<"--页号为"<<ptlist_LRU[i].pno <<'\n';;
    		cout<<"-------------------------------------------------------------------**\n";
    	}
    }
    	
    /*------------------------------------------*/
    /*主函数*/
    /*------------------------------------------*/
    void main()
    {
    	int vp_list[N],bs[M];//定义訪问序列数组和内存块表数组
    	int n,m,choose;
    	cout<<"输入序列个数:\n";
    	cin>>n;
    	cout<<"输入内存块大小:\n";
    	cin>>m;
    	cout<<"请输入訪问序列:\n";
    	input(vp_list,n);
    	cout<<"选FIFO算法输入1,选LRU*算法输入2:";
    	cin>>choose;
    
    	cout<<"訪问序列:"<<endl;
    	output(vp_list,n);
    	cout<<"**----------------------------------------**";
    	cout<<'\n';
    	if(choose==1)
    	fifo(vp_list,bs,n,m);//调用fifo函数
    	if(choose==2)
    	LRU(vp_list,bs,n,m);
    }

    结果演示:




    

    转载于:https://www.cnblogs.com/ldxsuanfa/p/10770079.html

    展开全文
  • 虚拟存储器管理

    2020-07-11 20:37:40
    设计一个请求页式存储管理方案,编写模拟程序实现具体过程,并计算缺页率(所有内存开始都是空的,凡第一次用到的页面都产生一次缺页中断)。 要求实现下列页面置换算法: (1)先进先出算法(FIFO) (2)最近最久未使用...
  • 事务处理原理 第2版

    热门讨论 2012-12-30 10:49:38
    《事务处理原理(第2版)》为从事于应用程序开发、产品评估、系统设计、数据库管理和产品工程化等工作的各类人员提供了清晰、简明的指导。可帮助读者理解事务处理系统的内部情况,并描述了它们的工作原理以及如何...
  • 4.2.15 分页查询 4.2.16 随机抽取文档 4.3 distinct找出给定键所有不同的值 4.4 group分组 4.4.1 使用完成器 4.4.2 将函数作为键使用 4.5 游标 4.6 存储过程 4.7 本章小结 第5章 Capped集合 ...
  • 同时对系统的开发原理、系统的功能特点和设计方案进行了介绍。 【关键词】ASP.NET ADO.NET 新闻 管理 数据库 随着Internet的普及,越来越多的企业建立了自己的WWW网站,企业通过网站可以展示产品,发布最新动态,与...
  • 文章目录第五章 虚拟存储器引入常规存储管理的问题解决方案:局部性原理虚拟存储器的定义和特征虚拟存储器的基本原理虚拟存储器的定义虚拟存储器的特征虚拟存储器的实现方法请求分页请求分段缺页率抖动页面置换算法...
  • 内容管理、支付中心、用户管理(包括第三方)、微信平台、存储系统、配置中心、日志分析、任务和通知等,支持服务治理、监控和追踪,努力为中小型企业打造全方位J2EE企业级开发解决方案。 组织结构 zheng ├── ...
  • asp.net知识库

    2015-06-18 08:45:45
    可按任意字段排序的分页存储过程(不用临时表的方法,不看全文会后悔) 常用sql存储过程集锦 存储过程中实现类似split功能(charindex) 通过查询系统表得到纵向的表结构 将数据库表中的数据生成Insert脚本的存储过程!!! ...
  • 主干版本,实现简单的权限管理,单点登录方案有CAS和OAuth2.0+JWT两种方案,admin暂时没接单点,oa工程对接cas,cms对接OAuth2.0实现单点登录,微服务只是做了个demo,还没进行项目服务处理,所以并没有merge代码 ...
  • (1)页式存储管理实现原理 基于程序在运行时不需要一开始都装入内存(局部性原理),更不应该把最近较长一段时间内不用的程序装入内存。 (2)页表的作用是将逻辑页号转换为物理块号。 (3)页面...
  • 2005-2009软件设计师历年真题

    千次下载 热门讨论 2010-05-18 19:20:10
     • 存储管理(主存保护、动态连接分配、分段、分页、虚存)  • 设备管理(I/O控制、假脱机)  • 文件管理(文件目录、文件组织、存取方法、存取控制、恢复处理)  • 作业管理(作业调度、作业控制语言(JCL...
  • 数据库开发基础、Microsoft SQLServer基础、SQL语言基础、索引、事务、SQL语言高级技术(空值处理、聚合与分组、数据分页、Union、日期函数、类型转换函数、流控函数、表连接、子查询、存储过程、触发器)、数据库...
  • 1.1.1连接管理与安全性2 1.1.2优化与执行3 1.2并发控制3 1.2.1读写锁4 1.2.2锁粒度4 1.3事务6 1.3.1隔离级别8 1.3.2死锁9 1.3.3事务日志10 1.3.4MySQL中的事务10 1.4多版本并发控制12 1.5MySQL的存储引擎...
  • 2.2.1 解决方案资源管理器 2.2.2 文档窗口 2.2.3 工具箱 2.2.4 错误列表和任务列表 2.2.5 服务器资源管理器 2.3 代码编辑器 2.3.1 添加程序集引用 2.3.2 智能感知和大纲显示 2.3.3 Visual Studio ...
  • 5.4.5 存储过程 77 5.4.6 MySQL Help(帮助文档) 77 第6章 phpMyAdmin 78 6.1 phpMyAdmin的安装与配置 79 6.1.1 安装phpMyAdmin文件 79 6.1.2 配置phpMyAdmin 79 6.1.3 config身份验证模式 80 6.1.4 http和...
  • 此外,本书还提出了大量的解决方案,以使Ext JS满足用户 日益增长的体验需要。  《Ext JS源码分析与开发实例宝典》一书分为4个部分,共17章。快速入门部分讲解Ext JS的背景及体系结构,并通过案例实现让 读者快速...
  • 2_ElasticSearch filter执行原理 bitset机制与caching机制 3_ElasticSearch 基于bool组合多个filter条件来搜索数据 4_ElasticSearch 使用terms搜索多个值 5_ElasticSearch 基于range filter来进行范围过滤 ...
  • 任务83: 项目实战:小型商品进销存管理系统_员工信息查询_实现员工信息统计分析及分页查询 任务84: 项目实战:小型商品进销存管理系统_员工信息查询_实战分组、聚合、过滤与排序 任务85: 项目实战:小型商品进销...
  • 2.2.1 解决方案资源管理器 28 2.2.2 文档窗口 29 2.2.3 工具箱 29 2.2.4 错误列表和任务列表 30 2.2.5 服务器资源管理器 31 2.3 代码编辑器 32 2.3.1 添加程序集引用 33 2.3.2 智能感知和大纲显示 35...
  •  第三部分 存储管理  第九章 内存管理  9. 1 背景  9. 1. 1 地址捆绑  9. 1. 2 逻辑地址空间与物理地址空间  9. 1. 3 动态加载  9. 1. 4 动态链接与共享库  9. 1. 5 覆盖  9. 2 交换  9. 3 连续内存分配 ...
  •  1.3 自动存储管理  1.4 集群就绪服务(CRS)  1.5 服务器生成的警报  1.6 自动工作量仓库(AWR)  1.7 自动数据库诊断监控程序(ADDM)  1.8 SQL调整顾问  1.9 自动共享内存管理(ASMM)  1.10 闪回恢复区  1.11 ...
  • 黑马安卓52期视频教程

    热门讨论 2015-06-24 22:15:48
    07.内存溢出解决方案 08.极光推送 09.极光推送扩展 10.推送原理 day06 01.昨天内容总结&当天内容介绍 02.屏幕适配介绍 03.图片适配&布局适配 04.尺寸适配 05.权重适配&代码适配 06.语音识别 07.语音朗诵 08.聊天...
  • java面试题

    2018-01-01 15:35:15
    4. 说出ArrayList,Vector,LinkedList的存储性能和特性 8 5. EJB是基于哪些技术实现的?并说出SessionBean和EntityBean的区别,StatefulBean和StatelessBean的区别。 9 6. Collection 和 Collections的区别。 9 7. &...
  • 单点登录源码

    2018-01-09 20:56:08
    文件存储系统,提供四种方案: - **阿里云** OSS - **腾讯云** COS - **七牛云** - 本地分布式存储 ![阿里云OSS](project-bootstrap/aliyun-oss-post-callback.png) > zheng-api 服务网关,对外暴露统一规范的...
  • 每个实例都是作者精心筛选的,具有很强的实用性,其中一些实例是开发人员难以找到的解决方案。  本书非常适合Visual Basic项目开发人员、Visual Basic初学者及编程爱好者使用,同时也可以作为培训机构、大中专院校...
  • 每个实例都是作者精心筛选的,具有很强的实用性,其中一些实例是开发人员难以找到的解决方案。  本书非常适合Visual Basic项目开发人员、Visual Basic初学者及编程爱好者使用,同时也可以作为培训机构、大中专院校...
  • 在有状态SessionBean中,用累加器,以对话状态存储起来,创建EJB对象,并将当前的计数器初始化,调用每一个EJB对象的count()方法,保证Bean正常被激活和钝化,EJB对象是用完毕,从内存中清除…… Java Socket 聊天...

空空如也

空空如也

1 2 3
收藏数 42
精华内容 16
关键字:

分页存储管理方案原理