精华内容
下载资源
问答
  • 缺页中断

    2019-09-24 05:19:30
    缺页中断缺页中断就是要访问的页不在主存,需要操作系统将其调入主存后再进行访问。在这个时候,被内存映射的文件实际上成了一个分页交换文件。  中断:是指计算机在执行程序的过程中,当出现异常情况或特殊请求...

      缺页中断:缺页中断就是要访问的页不在主存,需要操作系统将其调入主存后再进行访问。在这个时候,被内存映射的文件实际上成了一个分页交换文件。

      中断:是指计算机在执行程序的过程中,当出现异常情况或特殊请求时,计算机停止现行程序的运行,转向对这些异常情况或特殊请求的处理,处理结束后再返回现行程序的间断处,继续执行原程序。

      缺页中断的顺序:缺页中断发生时的事件顺序如下:

      1)硬件陷入内核,在内核堆栈中保存程序计数器。大多数机器将当前指令的各种状态信息保存在特殊的CPU寄存器中。

      2)启动一个汇编代码例程保存通用寄存器和其他易失的信息,以免被操作系统破坏。这个例程将操作系统作为一个函数来调用。

      3)当操作系统发现一个缺页中断时,尝试发现需要哪个虚拟页面。通常一个硬件寄存器包含了这一信息,如果没有的话,操作系统必须检索程序计数器,取出这条指令,用软件分析这条指令,看看它在缺页中断时正在做什么。

     

      4) 一旦知道了发生缺页中断的虚拟地址,操作系统检查这个地址是否有效,并检查存取与保护是否一致。如果  不一致,向进程发出一个信号或杀掉该进程。如果地址有效且没有保护错误发生,系统则检查是否有空闲页框。如果没有空闲页框,执行页面置换算法寻找一个页面来淘汰。

     

      5) 如果选择的页框"脏"了,安排该页写回磁盘,并发生一次上下文切换,挂起产生缺页中断的进程,让其他进程运行直至磁盘传输结束。无论如何,该页框被标记为忙,以免因为其他原因而被其他进程占用。

     

      6) 一旦页框"干净"后(无论是立刻还是在写回磁盘后),操作系统查找所需页面在磁盘上的地址,通过磁盘操作将其装入。该页面被装入后,产生缺页中断的进程仍然被挂起,并且如果有其他可运行的用户进程,则选择另一个用户进程运行。

     

      7) 当磁盘中断发生时,表明该页已经被装入,页表已经更新可以反映它的位置,页框也被标记为正常状态。

     

      8) 恢复发生缺页中断指令以前的状态,程序计数器重新指向这条指令。

     

      9) 调度引发缺页中断的进程,操作系统返回调用它的汇编语言例程。

     

      10) 该例程恢复寄存器和其他状态信息

     

      缺页率:

    在进行内存访问时,若所访问的页已在主存,则称此次访问成功;若所访问的页不在主存,则称此次访问失败,并产生缺页中断。若程序P在运行过程中访问页面的总次数为S,其中产生缺页中断的访问次数为F,则其缺页率为:F/s.

    例1. 已知页面走向为1、2、1、3、1、2、4、2、1、3、4,且开始执行时主存中没有页面。若只给该作业分配2个物理块,当采用FIFO页面淘汰算法时缺页率为多少?假定现有一种淘汰算法,该算法淘汰页面的策略为当需要淘汰页面时,就把刚使用过的页面作为淘汰对象,试问就相同的页面走向,缺页率又为多少?

    解:根据所给页面走向,采用FIFO淘汰算法的页面置换情况如下:这里的页面走向,即为系统要调用的页号。

     

    页面走向    1     2      1     3      1      2      4     2     1     3    4

    物理块1    1      1             3      3       2     2            1     1    4

    物理块2            2             2      1       1     4            4     3    3

    缺页        缺     缺           缺     缺     缺   缺          缺    缺   缺

     

        从上述页面置换图可以看出:页面引用次数为11次,缺页次数为9次,所以缺页率为9/11。

    若采用后一种页面淘汰策略,其页面置换情况如下:

     

     

     

    页面走向    1     2      1     3      1      2      4     2     1     3    4

    物理块1     1      1            3      1             1      1          3    4

    物理块2             2            2      2             4      2          2    2

    缺页:        缺     缺          缺    缺           缺     缺        缺   缺

     

    从上述页面置换图可以看出:页面引用次数为11次,缺页次数为8次,所以缺页率为8/11。

     

    转载于:https://www.cnblogs.com/haciont/p/4618893.html

    展开全文
  • 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及选择页面调度算法处理缺页中断

    模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及选择页面调度算法处理缺页中断

    (下面代码有问题,并不是内存自己要满才启动FIFO算法的,而是内存只分配给进程7个页框,页框满了就是所谓的内存紧张,可能,有空再改改 )

    # -*- coding: utf-8 -*-
    """
    Created on Sun Nov 10 19:03:55 2019
    
    @author: MyPC
    """
    
    
    # 实验三:模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用
    # FIFO算法实现分页管理的缺页中断。
    # 要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。
    
    import copy
    PAGE_MEMORY = 7  #此参数无用,只是表示页表长度为7
    
    #Memory_occpuied=[1,5,8,9] # 内存设为0-9,初始化1,5,8,9已被占用
    Memory_occpuied=[0,1,2,3,4,6,5,8,9] # 让内存空间紧张,从而启用FIFO置换算法
    Memory_FREE=[]
    
    
     
    #################### FIFO置换算法 #############################
     
    def FIFO(pages_,table_pages_):
        pages=copy.deepcopy(pages_)
        table_pages=copy.deepcopy(table_pages_)
        #初始化当前存在内存中的页
        table_list=[table_pages[0]['memoryPageNum'],
                    table_pages[1]['memoryPageNum'],
                    table_pages[2]['memoryPageNum'],
                    table_pages[3]['memoryPageNum']
                    ]
        print('')
        print('页面请求序列为 0 1 2 3 0 6 4 5 1 2 4 6')
        print('############ FIFO ################')      
        for p in pages:
            if p['PageNum']>=7: # 其实没必要,输入数据没有越界存在
                print("越界错误");break;
            i=p['PageNum']
            if table_pages[i]['label']==1: # 判断页号是否在内存中
                print('命中,形成绝对地址:%d'%(128 * table_pages[i]['memoryPageNum']+p['offset']))
                print("页表状况:",table_pages)
            else:
                print("*%d发生缺页中断"%(p['PageNum']))
                print("修改%d页标志位为1"%(p['PageNum']))
                table_pages[i]['label']=1 # 标志位为1,放入内存
                # 检测是否有空闲块
                if len(Memory_occpuied)==10:  #当内存满时,启用FIFO算法
                   
                   # 内存中淘汰页表中存在内存中的第一个               
                   Memory_occpuied.remove(table_list[0])
                   
                   # 页表中增加新的内存地址,在这之前找出了空闲块地址
                   Memory=[0,1,2,3,4,5,6,7,8,9]  # 内存块地址容量
                   for x in Memory_occpuied:   # 找空闲块
                        Memory.remove(x)
                   Memory_FREE=Memory  # 得到空闲块
                   free_block=Memory_FREE[0] # 取所有空闲块的第一块  
                   table_list.remove(table_list[0]) # 去除(换出)页表中最先存在内存中的页
                   table_list.append(free_block) # 加入,中断页(p['PageNum'])新的空闲块地址
                   
                   #修改一下页表中的内存块地址
                   table_pages[p['PageNum']]['memoryPageNum']=free_block
    
                   
                   Memory_occpuied.append(free_block)    # 加入已占据的内存
                   #table_pages[i]['memoryPageNum']=free_block  # 内存空闲块号放入页表中
                   print("页表状况:",table_pages)
                   print("页表中在内存中的页的内存地",table_list)
                   print("内存状况:",Memory_occpuied)
                   
                   
                else:
                    # 将空闲内存块地址放入页表
                    Memory=[0,1,2,3,4,5,6,7,8,9]  # 内存块地址容量
                    for x in Memory_occpuied:   # 找空闲块
                        Memory.remove(x)
                    Memory_FREE=Memory  # 得到空闲块
                    free_block=Memory_FREE[0] # 取所有空闲块的第一块  ..
                    table_list.append(free_block)
                    
                    #修改一下页表中的内存块地址
                    table_pages[p['PageNum']]['memoryPageNum']=free_block
                     # 加入已占据的内存
                    Memory_occpuied.append(free_block)   
                    
                 
                    
                    print("页表中在内存中的页的内存地址:",table_list)
                    print("内存状况:",Memory_occpuied)
                #    Memory_occpuied.append(p['memoryPageNum'])
                #  print("调入主存的页:",Memory)            
                
                #占据内存哪一个空闲块
    #            Memory=[0,1,2,3,4,5,6,7,8,9]  # 内存块地址容量
    #            for x in Memory_occpuied:   # 找空闲块
    #                Memory.remove(x)
    #            Memory_FREE=Memory  # 得到空闲块
    #            Memory_occpuied.append(Memory_FREE[0]) # 取所有空闲块的第一块
    #            table_pages[i]['memoryPageNum']=Memory_FREE[0]
    #            
    
              
    #    print('绝对地址:')      
    #    print('调入主存的页',)      
       
     
    
     
    def normal(pages_,table_pages_):
        pages=copy.deepcopy(pages_)
        table_pages=copy.deepcopy(table_pages_)
       # table_list=[table_pages[0],table_pages[1],table_pages[2],table_pages[3]]
         # 用于只输出一个中断
        print('')
        print('页面请求序列为 0 1 2 3 0 6 4 5 1 2 4 6')
        print('############ NORMAL ################')
        for p in pages:
            for t_p in table_pages:
                if p['PageNum']==t_p['PageNum']:
                    if t_p['label']==1:   # label为1,表示在内存中
                      print('命中,形成绝对地址:%d'%(128 * t_p['memoryPageNum']+p['offset']))
                    else:
                      print("*%d发生缺页中断"%(p['PageNum']))
    
    #            elif t_p['memoryPageNum']<0:
    #                   print("*%d发生缺页中断"%(p['PageNum']))
    #          
    def normal_1(pages_,table_pages_):
        pages=copy.deepcopy(pages_)
        table_pages=copy.deepcopy(table_pages_)
        
         # 用于只输出一个中断
        print('')
        print('页面请求序列为 0 1 2 3 0 6 4 5 1 2 4 6')
        print('############ NORMAL ################')
        for p in pages:
            if p['PageNum']>=7: # 其实没必要,输入数据没有越界存在
                print("越界错误");break;
            i=p['PageNum']
            table_pages[i]
            if table_pages[i]['label']==1: # 判断页号是否在内存中
                print('命中,形成绝对地址:%d'%(128 * table_pages[i]['memoryPageNum']+p['offset']))
            else:
                print("*%d发生缺页中断"%(p['PageNum']))
    #        
    #        for t_p in table_pages:
    #            if p['PageNum']==t_p['PageNum']:
    #                if t_p['label']==1:   # label为1,表示在内存中
    #                  print('命中,形成绝对地址:%d'%(128 * t_p['memoryPageNum']+p['offset']))
    #                else:
    #                  print("*%d发生缺页中断"%(p['PageNum']))
    
    #            elif t_p['memoryPageNum']<0:
    #                   print("*%d发生缺页中断"%(p['PageNum']))
    #                
              
     
    def init(pages):
        for p in pages:
            p['operator']="op" # 初始化操作
     
     
    if __name__ == '__main__':
        
        PAGE_TABLE=[
            {'PageNum': 0,'label':1,'memoryPageNum':5,'diskLocation':11},{'PageNum': 1,'label':1,'memoryPageNum':8,'diskLocation':12},
            {'PageNum': 2,'label':1,'memoryPageNum':9,'diskLocation':13},{'PageNum': 3,'label':1,'memoryPageNum':1,'diskLocation':21},
            {'PageNum': 4,'label':0,'memoryPageNum':-1,'diskLocation':22},{'PageNum': 5,'label':0,'memoryPageNum':-1,'diskLocation':23},
            {'PageNum': 6,'label':0,'memoryPageNum':-1,'diskLocation':121}
        ]
        
        pages = [
            {'PageNum': 0,'offset':70},{'PageNum': 1,'offset':50},
            {'PageNum': 2,'offset':15},{'PageNum': 3,'offset':21},
            {'PageNum': 0,'offset':56},{'PageNum': 6,'offset':40},
            {'PageNum': 4,'offset':53},{'PageNum': 5,'offset':23},
            {'PageNum': 1,'offset':37},{'PageNum': 2,'offset':78},
            {'PageNum': 4,'offset':1},{'PageNum': 6,'offset':84},
        ]
     
        init(pages)  # 基本没意义,初始化操作,可在控制台输入 pages进行查看
      #  normal_1(pages,PAGE_TABLE)
        FIFO(pages,PAGE_TABLE)
        normal_1(pages,PAGE_TABLE)
    
    展开全文
  • 缺页中断处理算法

    千次阅读 2018-01-22 10:42:40
    缺页中断:在请求分页系统中,可以通过查询页表中的状态位来确定所要访问的页面是否存在于内存中。每当所要访问的页面不在内存是,会产生一次缺页中断,此时操作系统会根据页表中的外存地址在外存中找到所缺的一页,...

    缺页中断:在请求分页系统中,可以通过查询页表中的状态位来确定所要访问的页面是否存在于内存中。每当所要访问的页面不在内存是,会产生一次缺页中断,此时操作系统会根据页表中的外存地址在外存中找到所缺的一页,将其调入内存。

    缺页本身是一种中断,与一般的中断一样,需要经过4个处理步骤:

    1、保护CPU现场

    2、分析中断原因

    3、转入缺页中断处理程序进行处理

    4、恢复CPU现场,继续执行

    但是缺页中断是由于所要访问的页面不存在于内存时,由硬件所产生的一种特殊的中断,因此,与一般的中断存在区别:

    1、在指令执行期间产生和处理缺页中断信号

    2、一条指令在执行期间,可能产生多次缺页中断

    3、缺页中断返回是,执行产生中断的一条指令,而一般的中断返回是,执行下一条指    令。

     

    最佳(Optimal)置换算法是指其所选择的淘汰页面,将是以后永不使用的,或许是在最长(未来)时间内不再被访问的页面。采用最佳置换算法,通常可保证获得最低的缺页率。但由于人们目前还无法预知一个进程在内存的若干个页面中,哪个页面是未来最长时间内不再被访问的,因而该算法是无法实现的,但可以利用该算法去评价其他算法。 

     

     

    先进先出(FIFO)置换算法是最简单的页面置换算法。这种算法的基本思想:当需要淘汰一个页面是,总是选择主流驻村时间最长的页面进行淘汰,即先进入主存的页面先淘汰。其理由是最早调入主存的页面不在被使用的可能性最大。该算法会淘汰经常访问的页面,不直营进程实际运行的规律,目前已很少使用。

     

    个人认为第二张表比较好理解。

     


     

     

    Belady异常:一般来说,分配给进程的物理块越多,运行时的缺页次数应该越少,使用FIFO是,存在相反情况,分配4个物理块的缺页竟然比3个物理块的缺页次数还多。不过LRUOPT算法永远不会出现Belady异常。

     

     

     

     

    最近最久未使用(LRU)置换算法:利用局部性原理,根据一个作业在执行过程中过去的页面访问历史来推测未来的行为。它认为过去一段时间里不曾被访问过的页面,在最近的将来可能也不会再被访问。所以,这种算法的实质是当需要淘汰一个页面时,总选择在最近一段时间内最久不用的页面予以淘汰。LRU算法普遍地适用于各种类型的程序,但是系统要时时刻刻对各页的访问历史情况加以记录和更新,开销太大,因此LRU算法必须要有硬件支持。

     

    个人认为第二张表比较好理解。

     

     


     

     

     

    时钟(CLOCK)置换算法

    LRU算法的新能接近于OPT,但是实现起来比较困难,且开销大;FIFO算法实现简单,但性能差。所以操作系统的设计者尝试了很多算法,试图用比较小的开销接近LRU的性能,这类算法都是CLOCK算法的变体。

    简单的CLOCK算法是给每一帧关联一个附加位,称为使用位。当某一页首次装入主存时,该帧的使用位设置为1;当该页随后再被访问到时,它的使用位也被置为1。对于页替换算法,用于替换的候选帧集合看做一个循环缓冲区,并且有一个指针与之相关联。当某一页被替换时,该指针被设置成指向缓冲区中的下一帧。当需要替换一页时,操作系统扫描缓冲区,以查找使用位被置为0的一帧。每当遇到一个使用位为1的帧时,操作系统就将该位重新置为0;如果在这个过程开始时,缓冲区中所有帧的使用位均为0,则选择遇到的第一个帧替换;如果所有帧的使用位均为1,则指针在缓冲区中完整地循环一周,把所有使用位都置为0,并且停留在最初的位置上,替换该帧中的页。由于该算法循环地检查各页面的情况,故称为CLOCK算法,又称为最近未用(Not Recently Used, NRU)算法

    CLOCK算法的性能比较接近LRU,而通过增加使用的位数目,可以使得CLOCK算法更加高效。在使用位的基础上再增加一个修改位,则得到改进型的CLOCK置换算法。这样,每一帧都处于以下四种情况之一:

    1、最近未被访问,也未被修改(u=0, m=0

    2、最近被访问,但未被修改(u=1, m=0

    3、最近未被访问,但被修改(u=0, m=1

    4、最近被访问,被修改(u=1, m=1

    算法执行如下操作步骤:

    1、从指针的当前位置开始,扫描帧缓冲区。在这次扫描过程中,对使用为不做任何修改。选择遇到的第一个帧(u=0, m=0)用于替换。

    2、如果第一步失败,则重新扫描,查找(u=0, m=1)的帧。选择遇到的第一个这样的帧用于替换。在这个扫描过程中,对每个跳过的帧,把它的使用位设置成0

    3、如果第二步失败,指针将回到它的最初位置,并且集合中所有帧的使用位均为0.重复第一步,并且如果有必要,重复第二步。这样将可以找到供替换的帧。

     

    改进型的CLOCK算法由于简单CLOCK算法之处在于替换时首选没有变化的页。由于修改的页在被替换之前必须写回。

     

     

     

     

                  

    时钟置换算法(CLOCK例题:

     

     一个作业的物理块数为3,此作业的页面走向为:3,4,2,6,4,3,7,4,3,6,3,4,8,4,6

    内存及控制信息

    输入串

    指针移动情况及帧替换信息

    是否缺页?

    内存

    访问位

    指针

    3

    内存中没有3,需要找到一个帧放入3,
    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移

     

    0

     

    0

     

     

    0

     

    内存

    访问位

    指针

    4

    内存中没有4,需要找到一个帧放入4,
    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移

    3

    1

     

     

    0

     

    0

     

    内存

    访问位

    指针

    2

    内存中没有2,需要找到一个帧放入2,
    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移

    3

    1

     

    4

    1

     

     

    0

    内存

    访问位

    指针

    6

    内存中没有6,需要找到一个帧放入6,
    指针所指的位置的访问位为1,
    将其变成0,再下移

    3

    1

    4

    1

     

    2

    1

     

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移

    3

    0

     

    4

    1

    2

    1

     

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移(回到开头)

    3

    0

     

    4

    0

     

    2

    1

    内存

    访问位

    指针

    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移

    3

    0

    4

    0

     

    2

    0

     

    内存

    访问位

    指针

    4

    内存中有4,于是4所在帧的访问位变为1,
    指针下移

    ×

    6

    1

     

    4

    0

    2

    0

     

    内存

    访问位

    指针

    3

    内存中没有3,需要找到一个帧放入3,
    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移

    6

    1

     

    4

    1

     

    2

    0

    内存

    访问位

    指针

    7

    内存中没有7,需要找到一个帧放入7,
    指针所指的位置的访问位为1,
    将其变成0,再下移

    6

    1

    4

    1

     

    3

    1

     

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移

    6

    0

     

    4

    1

    3

    1

     

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移(回到开头)

    6

    0

     

    4

    0

     

    3

    1

    内存

    访问位

    指针

    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移

    6

    0

    4

    0

     

    3

    0

     

    内存

    访问位

    指针

    4

    内存中有4,于是4所在帧的访问位变为1,
    指针下移

    ×

    7

    1

     

    4

    0

    3

    0

     

    内存

    访问位

    指针

    3

    内存中有3,于是3所在帧的访问位变为1,
    指针下移(回到开头)

    ×

    7

    1

     

    4

    1

     

    3

    0

    内存

    访问位

    指针

    6

    内存中没有6,需要找到一个帧放入6,
    指针所指的位置的访问位为1,
    将其变成0,再下移

    7

    1

    4

    1

     

    3

    1

     

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移

    7

    0

     

    4

    1

    3

    1

     

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移(回到开头)

    7

    0

     

    4

    0

     

    3

    1

    内存

    访问位

    指针

    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移

    7

    0

    4

    0

     

    3

    0

     

    内存

    访问位

    指针

    3

    内存中有3,于是3所在帧的访问位变为1,
    指针下移

    ×

    6

    1

     

    4

    0

    3

    0

     

    内存

    访问位

    指针

    4

    内存中有4,于是4所在帧的访问位变为1,
    指针下移

    ×

    6

    1

    4

    0

     

    3

    1

     

    内存

    访问位

    指针

    8

    内存中没有8,需要找到一个帧放入8,
    指针所指的位置的访问位为1,
    将其变成0,再下移(回到开头)

    6

    1

     

    4

    1

     

    3

    1

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移

    6

    1

    4

    1

     

    3

    0

     

    内存

    访问位

    指针

    指针所指的位置的访问位仍为1,
    将其变成0,再下移

    6

    0

     

    4

    1

    3

    0

     

    内存

    访问位

    指针

    指针所指的位置恰好有访问位为0的,
    于是就淘汰这个帧,指针下移(回到开头)

    6

    0

     

    4

    0

     

    3

    0

    内存

    访问位

    指针

    4

    内存中有4,于是4所在帧的访问位变为1,
    指针下移

    ×

    6

    0

    4

    0

     

    8

    1

     

    内存

    访问位

    指针

    6

    内存中有6,于是6所在帧的访问位变为1,
    指针下移

    ×

    6

    0

     

    4

    1

     

    8

    1

    内存

    访问位

    指针

    结束

    完成

    缺页8次

    6

    1

     

    4

    1

    8

    1

     

     

    展开全文
  • FIFO和LRU计算缺页中断

    千次阅读 2015-03-15 19:50:23
    在一个请求分页面管理中,一个程序的页面走向为1、2、3、4、1、2、5、1、2、3、4、5。 当内存块数量为3时,试问使用 (1)FIFO页面置换算法...(开始时没有装入页面)时的缺页中断次数是多少() FIFO: 页 4 1 2 5 1 2

    本文参考一点击
    参考二点击
    在一个请求分页面管理中,一个程序的页面走向为1、2、3、4、1、2、5、1、2、3、4、5。
    当内存块数量为3时,试问使用
    (1)FIFO页面置换算法
    (2)LRU页面置换算法
    (开始时没有装入页面)时的缺页中断次数是多少()
    FIFO:
    页    4        1           2          5          1           2          3           4         5
    内存  423      413         412        512        no          no         532         534       no
    LRU:
    页     4       1           2          5          1          2           3          4          5
    内存   423     413         412        512        no         no          312        342        345
    
    
    (缺页发生  也就是需要进行交换,初始装入内存的三个页是不发生缺页的 所以从4开始)
    上面是装入的页面   下面是装入后内存的状态 (no代表不缺页)
    
    FIFO是先进先出,总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面进行淘汰。(此算法是基于内存块的顺序, 按访问的时间先后顺序链接成一个队列,并设置一个指针,该指针始终指向“最老“的页面。LRU 是更新最长未使用的页面,这个算法是根据页面值来交换的。
        也就是新装入的页面值如果在内存块里面有,就会更新这个页面的某个标记状态(标记其多久未使用,其实就是个变量,很容易实现)
    显然一直到5都是和FIFO算法是一样的,为什么呢,因为前几页都是缺页的,并没有改变标记变量,所以就先装入,则距今未使用时间最长,则先交换的原则啦
        开始需要  1(5后面那个) 那么内存目前状态时 512, 1是在内存中的不发生缺页,所以更新标记变量(标明 1刚被使用过)。
    然后需要 2   内存中依然存在,则更新2的 标记变量,现在内存中仍然是 512 ,但是标记变量已经变了, 2最新,1次之,5最久(最久未使用),所以下次交换就先换 5,内存变为 321 。现在 3最新,2次之,1最久,下次缺页就换1。
        思路就是这样啦,由于我也是刚学,可能分析中也有错误,如果发现,请见谅。希望有帮助http://zhidao.baidu.com/link?url=T9qi3oc38yEsYUtDHztLSVq7F2EgSdzJ9gI-cgXkBc4MW6g8RTF88xLQM9Fq7D-r2JX0by2Xx6uLJL0xDjCO_q
    
    
        在一个虚拟存储管理系统中,假如系统分配给一个作业的内存物理块数是3,并且此作业的页面使用顺序为2,3,2,1,5,2,4,5,3,2,5,2,若采用FIFO和LRU置换算法,其产生的缺页次数分别为( )和( ) 。

    答案是这样的:
    题目中当采用FIFO时,其页面调度过程如下:
    2  3  2  1  5  2  4  5  3  2  5  2 
    ――――――――――――――
    2        2  2  2  5  5  5  5  3  3  3  3
    3  3  3  3  2  2  2  2  2  5  5
    1  1  1  4  4  4  4  4  2
    可知缺页次数为9。同样若采用LRU算法,可计算其缺页次数为7。
    关于这个建议你看下操作系统的相关知识.

    以下给出我的算法:

    FIFO:

    当前所需:
    2  3  2  1  5  2  4  5  3  2  5  2
    ----------------------
    当前内存:
    2  2  2  2  5  5  5  5  3  3  3  3
        3  3  3  3  2  2  2  2  2  5  5
                1  1  1  4  4  4  4  4  2
    ---------------------
    是否缺页:
    *  *      *  *  *  *      *      *  *     

    (FIFO)=9次


    LRU:

    当前所需:
    2  3  2  1  5  2  4  5  3  2  5  2
    ----------------------
    当前内存:
    2  2  3  3  2  1  5  2  4  5  3  3
        3  2  2  1  5  2  4  5  3  2  5
                1  5  2  4  5  3  2  5  2
    ---------------------
    是否缺页:
    *  *      *  *      *      *  *                           

    (LRU)=7次
    
    

    展开全文
  • 计算机操作系统–缺页中断与越界中断 缺页中断 通俗点讲就是在利用逻辑地址计算物理地址时,在得出的页号合法,却不在页表内时,由操作系统引发的中断 越界中断 和缺页中断类似,在判断合法时,若为非法,则发生越界...
  • 操作系统之缺页中断

    千次阅读 2018-10-03 18:28:47
    用最近最少用(LRU)页面调度算法处理缺页中断 1.实验目的 加深对于存储管理的了解,掌握虚拟存储器的实验原理;观察和了解重要的页面置换算法的置换过程. 2.实验原理及相关提示 在分页式虚拟存储系统中,当硬件发出...
  • 缺页中断与页面置换理论

    千次阅读 2020-07-01 15:55:42
    缺页中断与页面置换理论 1.缺页中断缺页中断就是要访问的页不在主存,需要操作系统将其调入主存后再进行访问,在这个时候,被内存映射的文件实际上成了一个分页交换文件。 2.缺页失: 又名硬错误、硬中断、分页...
  • 缺页中断与页面置换算法

    千次阅读 2019-04-06 17:42:26
    缺页中断 页面置换算法: LRU算法 缺页中断 缺页:如果进程被调度,该进程需要使用的外存页(数据)不存在于数据块中,这个现象就叫做缺页。如果这个数据此时不在,就会将这个数据从加入到数据块首部。缺页本身...
  • 缺页中断&页缺失

    2021-07-23 15:45:49
    缺页中断就是要访问的页不在主存,需要操作系统将其调入主存后再进行访问。在这个时候,被内存映射的文件实际上成了一个分页交换文件。 页缺失 页缺失(缺页中断)指的是当软件试图访问已映射在虚拟地址空间中,...
  • 计算三种缺页中断的缺页数,缺页率和命中率 FIFO,LRU,OPT */ #include #include #include #include #include /* ** 默认页表大小为3 */ #define PAGETABLELENGTH 3 //输出函数,四个参数,缺页数,缺页率和...
  • 缺页中断算法(FIFO,LRU)

    千次阅读 2018-09-19 09:30:04
    1. 缺页中断  在请求分页系统中,可以通过查询页表中的状态位来确定所要访问的页面是否存在于内存中。每当所要访问的页面不在内存时,会产生一次缺页中断,此时操作系统会根据页表中的外存地址在外存中找到所缺的...
  • 缺页率的计算: 缺页率 = (页面置换次数+分配给该进程的...换页错误:Page Fault,其实应该翻译成缺页异常或缺页中断,并非是错误,而是存在虚拟内存情况下的内存未命中,是非常常见的现象。内存分块,进程分页...
  • 缺页中断——FIFO、LRU、OPT这三种置换算法

    万次阅读 多人点赞 2016-04-21 10:07:23
    FIFO、LRU、OPT这三种置换算法的缺页次数2缺页中断 在请求分页系统中,可以通过查询页表中的状态位类确定所要访问的页面是否存在于内存中。每当所要访问的压面不在内存时,会产生一次缺页中断,此时操作系统会根据...
  • 缺页中断发生在系统对虚拟地址转换成物理地址的过程中。如果对应的页目录或者页表项没有对应有效的物理内存,则会发生缺页中断。 系统在初始化的时候注册了缺页中断的处理函数。中断号是14。 // 缺页和写保护异常...
  • 缺页中断的定义

    2021-05-30 19:36:34
    是指计算机在执行程序的过程中,当出现异常情况或特殊请求时,计算机停止现行程序的运行,转向对这些异常情况或特殊请求的处理,处理结束后再返回现行程序的间断处,继续执行原程序。 ...
  • 内存常识之缺页中断

    2018-02-03 15:07:04
    什么是缺页中断:  进程线性地址空间里的页面不必常驻内存,在执行一条指令时,如果发现他要访问的页没有在内存中(存在位为0),那么停止该指令的执行,并产生一个页不存在异常,对应的故障处理程序可通过从外...
  • OpenEuler20.03 统计缺页中断次数 本文参考Centos7实现缺页中断具体步骤 下载解压linux-4.19.90版本linux内核 下载linux-4.19.90.tar.xz压缩包发送到/usr/src目录下(可以用filezilla) 进入/usr/src目录解压缩 tar -...
  • Linux——缺页中断与内存置换算法,你想知道的都在这里!缺页中断页面置换算法缺页次数一、先进先出(FIFO)二.最近最久未使用(LRU)三、最佳置换算法(OPT) 缺页中断 缺页中断就是要访问的页不在主存,需要操作...
  • LRU和FIFO算法计算缺页中断O(∩_∩)O啊2010-04-07 00:33今天做完了软件设计师的操作系统部分,,,用了几个钟( ⊙ o ⊙ )啊!,有个问题还没有解决... 虚拟存储管理系统,置换算法产生的缺页次数...就是这题 啊,...
  • 输入缺页次数页面流: 0 1 2 3 2 1 3 2 5 2 3 6 2 1 4 2 FIFO 分析:012發別調入內存, 則內存:012(3次缺頁)調入3逃汰最先進入的0,則內存:123(4次缺頁)調入2來命中,則內存:123(內存中有2不缺頁)調入1來命中,則...
  • 版权声明:本文为博主原创文章,转载请注明作者和出处。... ... 缺页中断  在请求分页系统中,可以通过查询页表中的状态位来确定所要访问的页面是否存在于内...
  • 用先进先出(FIFO)页面调度算法处理缺页中断。 (1) 在分页式虚拟存储系统中,当硬件发出“缺页中断”后,引出操作系统来处理这个中断事件。如果主存中已经没有空闲块,则可用FIFO页面调度算法把该作业中最先进入...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,485
精华内容 4,194
关键字:

缺页中断计算