精华内容
下载资源
问答
  • 操作系统--分页存储管理中逻辑地址转换为物理地址
    万次阅读 多人点赞
    2019-09-23 06:45:12

    【例1】考虑一个由8个页面,每页有1024个字节组成的逻辑空间,把它装入到有32个物理块的存储器中,问:

      (1)逻辑地址需要多少二进制位表示?

      (2)物理地址需要多少二进制位表示?

     

      它由两个部分组成:前一部分表示该地址所在页面的页号p;后一部分表示页内地址(页内位移)d。页号的地址位数决定了页的多少,假设页号有20位,则地址空间中最多可容纳的页面数为220,即1MB个页面。页内地址位数确定了每页的大小,若页内地址为12位,则每页大小为212,即2KB。

      同理,物理地址中块号的地址位数决定了块的数量。由于页式存储管理内存空间块的大小与页面大小相同,所以物理地址中块内地址与逻辑地址中的页内地址位数相同。

      解因为页面数为8=23,故需要3位二进制数表示。每页有1024个字节,1024=210,于是页内地址需要10位二进制数表示。32个物理块,需要5位二进制数表示(32=25)。

      (1)页的逻辑地址由页号和页内地址组成,所以需要3+10=13位二进制数表示。

      (2)页的物理地址由块号和页内地址的拼接,所以需要5+10=15位二进制数表示。

       

      【例2】若在一分页存储管理系统中,某作业的页表如下所示。已知页面大小为1024字节,试将逻辑地址1011,2148,4000,5012转化为相应的物理地址。

    页号

    块号

    0

    1

    2

    3

    2

    3

    1

    6

      分析页式存储管理的地址结构是一维的,即逻辑地址(或物理地址)只用一个数值即可表示。若给定逻辑地址A,页面的大小为L,则页号p和页内地址d可按照下式求得:

      p=int [A/L]d=A mod L

      其中,int是取整函数(取数值的整数部分),mod是取余函数(取数值的余数部分)。

       

      

       

      页表的作用是实现从页号到物理块号的地址映射。以逻辑地址的页号检索页表,得到该页的物理块号;同时将页内地址d直接送入物理地址寄存器的块内地址字段中。这样物理块号和块内地址拼接成了实际访问内存的地址,从而完成了从逻辑地址到物理地址的转换。

      所以物理地址的计算公式为:

      物理地址=块的大小(即页的大小L)′块号f+页内地址d

      解本题中,为了描述方便,设页号为p,页内位移为d,则:

      (1)对于逻辑地址1011,p=int(1011/1024)=0,d=1011 mod 1024=1011。查页表第0页在第2块,所以物理地址为1024′2+1011=3059。

      (2)对于逻辑地址2148,p=int(2148/1024)=2,d=2148 mod 1024=100。查页表第2页在第1块,所以物理地址为1024+100=1124。

      (3)对于逻辑地址4000,p=int(4000/1024)=3,d=4000 mod 1024=928。查页表第3页在第6块,所以物理地址为1024′6+928=7072。

      (4)对于逻辑地址5012,p=int(5012/1024)=4,d=5012 mod 1024=916。因页号超过页表长度,该逻辑地址非法。

       

      【例3】某虚拟存储器的用户编程空间共32个页面,每页为1KB,内存为16KB。假定某时刻一用户页表中已调入内存的页面的页号和物理块号的对照表如下:

    页号

    物理块号

    0

    5

    1

    10

    2

    4

    3

    7

      则逻辑地址0A5C(H)所对应的物理地址是什么?

      分析页式存储管理的逻辑地址分为两部分:页号和页内地址。

      由已知条件“用户编程空间共32个页面”,可知页号部分占5位;由“每页为1KB”,1K=210,可知内页地址占10位。由“内存为16KB”,可知有16块,块号为4位。

      逻辑地址0A5C(H)所对应的二进制表示形式是:000 1010 0101 1100,根据上面的分析,下划线部分为页内地址,编码“000 10”为页号,表示该逻辑地址对应的页号为2。查页表,得到物理块号是4(十进制),即物理块地址为:01 00 ,拼接块内地址10 0101 1100,得01 0010 0101 1100,即125C(H)。

      解逻辑地址0A5C(H)所对应的物理地址是125C(H)。

    转载于:https://www.cnblogs.com/Kobe10/p/5673520.html

    更多相关内容
  • 4、扩充页表,变成请求的二维页表(增加存在位等)完成地址转换。 5、输入分配给本作业的块数,模拟作业执行的逻辑地址转换成页面调度次序; 6、分别采用OPT、FIFO、LRU置换算法,利用堆栈结构完成页面置换;记录...
  • 实验四 页虚拟存储管理中地址转换和页中断 FIFO 一实验目的 深入了解页式存储管理如何实现地址转换进一步认识页虚拟存储管理中如何处理缺页中断以及页面置换算法 二实验主要内容 编写程序完成页虚拟存储管理...
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断。
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断.------很好用的程序和源代码
  • 在第1部分实验基础上实现进程的分页式内存分配和地址转换过程,并进一步实现请求分页式存储分配和地址转换过程。页面置换算法至少应实现先进先出(FIFO)、最近最久未使用(LRU)等算法。
  • 在计算机系统,为了提高主存利用率,往往把辅助存储器(如磁盘)作为主存储器的扩充,使多道运行的作业的全部逻辑地址空间总和可以超出主存的绝对...通过本实验帮助同学理解在分页式存储管理中怎样实现虚拟存储器。
  • 操作系中分页式管理总的逻辑地址到物理地址的映射转换算法 C语言
  • 4、扩充页表,变成请求的二维页表(增加存在位等)完成地址转换。 5、输入分配给本作业的块数,模拟作业执行的逻辑地址转换成页面调度次序; 6、分别采用OPT、FIFO、LRU置换算法,利用堆栈结构完成页面置换;记录...
  • 模拟分页式虚拟存储管理中地址转换和缺页中断[借鉴].pdf
  • 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及用先进先出(FIFO)页面调度算法处理缺页中断。 用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程。(题目四) 包含详细实验报告·
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断[文].pdf
  • 请求分页虚拟存储管理技术是把作业地址空间的全部信息存放在磁盘上。当作业被选中运行时,先把作业的开始几页装入主存并启动运行。为此在为作业建立页表时,应说明哪些页已在主存,哪些页不在主存。
  • 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及选择页面调度算法处理缺页中断。 二. 实验目的 在计算机系统,为了提高主存利用率,往往把辅助存储器(如磁盘)作为主存储器的扩充,使多道运行的作业的...
  • 存储器管理 1实验内容模拟请求页式存储管理中硬件的地址转换和缺页中断并用先进先出调度算法FIFO处理缺页中断 2要求 指令序列的设定可以执行拟定格式如表3 在完成了FIFO换页策略后可以选做LRU的换页策略并进行比较 ...
  • 实验名称 虚拟页式管理 姓 名 学号 专业班级 实验日期 成 绩 指导教师 实验目的实验原理主要仪器设备实验内容与步骤实验数据记录与处理实验 结果与分析问题建议 实验二 模拟请求页式存储管理硬件的地址转换和缺页...
  • 1.模拟分页式存储管理中硬件的地址转换和产生缺页中断。 2.用先进先出(FIFO)页面调度算法处理缺页中断。
  • 分页式虚拟存储系统是把作业信息的副本存放在磁盘上,当作业被选中时,可把作业的开始几页先装入主存且启动执行。该程序是模拟存储管理地址转换代码
  • 第一题:模拟分页式存储管理中硬件的地址转换和产生缺页中断。 第二题:用先进先出(FIFO)页面调度算法处理缺页中断。
  • 实验五:模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。要求:显示每个页面在内存的绝对地址,页表信息、列出缺页情况等。# 实验五:模拟...

    实验五:模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。

    要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。

    # 实验五:模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用
    # LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。
    # 要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。
    import random
    import copy
    PAGE_MEMORY = 4
    INTERVAL = 1
    
    def time_up(page_list):
        for p in page_list:
            p['time'] += INTERVAL
    
    def print_list(page_list):
        page_num = []
        for p in page_list:
            page_num.append(int(p['No']))
        print('序列为:',end = '')
        print(page_num)
    
    #################### FIFO置换算法 #############################
    
    def FIFO(pages_):
        pages = copy.deepcopy(pages_)
        print('')
        print('页面请求序列为 8 9 10 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1')
        print('############ FIFO ################')
        page_list = []
        for p in pages:
            page_list_data = []
            if len(page_list) < PAGE_MEMORY:
                page_list.append(p)
            else:
                #s = [page_['No'] for page_ in page_list]
                for page_ in page_list:
                    page_list_data.append(page_['No'])
    
                if p['No'] in page_list_data:
                    print('----Remind-----: 新页表%d已经在队列中,绝对地址为%d'%(p['No'],1024 * page_list_data.index(p['No'])))
                else:
                    print('----Remind-----: 新页面%d将替换旧页面%d'%(p['No'],page_list[0]['No']))
                    page_list.remove(page_list[0])
                    page_list.append(p)
        #print("目前的队列为[{0[0]},{0[1]},{0[2]}]".format(page_list))
            print_list( page_list)
    
    #################### LRU置换算法 #############################
    
    def LRU(page_):
        print('')
        print('页面请求序列为 8 9 10 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1')
        print('############ LRU ################')
        pages = copy.deepcopy(page_)
        page_list = []
        for p in pages:
            page_list_data = []
            if len(page_list) < PAGE_MEMORY:
                page_list.append(p)
            else:
                for page_ in page_list:
                    page_list_data.append(page_['No'])
                time_up(page_list)
                if p['No'] in page_list_data:
                    page_list[page_list_data.index(p['No'])]['time'] = 0
                    print('----Remind-----: 页表%d已经在队列中,绝对地址为%d' % (p['No'],1024 * page_list_data.index(p['No'])))
                else:
                    tran = max(page_list, key=lambda t: t['time'])            #原本是应该位置上的元素替换,但是需要占位,于是直接采取了append的方法
                    page_list.remove(tran)
                    page_list.append(p)
                    print('----Remind-----: 新页表%d将替换%d' % (p['No'], tran['No']))
            print_list(page_list)
    
    ####################改进型Clock置换算法#############################
    
    def obsolete_page(page_list):
        while True:
            for page in page_list:
                if page['visited'] == False and page['modified'] == False:
                    return page
            for page_ in page_list:
                if page_['visited'] == False and page_['modified'] == True:
                    return page_
            for _page in page_list:
                _page['visited'] = False
    
    def getIndex(p, page_list):
        i = 0
        for pages_ in page_list:
            if p['No'] == pages_['No']:
                return i
            i += 1
        return 0
    
    def Improved_Clock(pages_):
        pages = copy.deepcopy(pages_)
        print('')
        print('页面请求序列为 8 9 10 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1')
        print('############ Improved_Clock ################')
        page_list = []
        for p in pages:
            page_list_data = []
            if len(page_list) < PAGE_MEMORY:
                page_list.append(p)
            else:
                for page_ in page_list:
                    page_list_data.append(page_['No'])
                if p['No'] not in page_list_data:
                    _page = obsolete_page(page_list)
                    print('----Remind-----: 新页表%d将会替换页表%d' %(_page['No'], p['No']))
                    page_list.remove(_page)
                    page_list.append(p)
                else:
                    print('----Remind-----: 页表%d已存在,绝对地址为%d'%(page_list[getIndex(p,page_list)]['No'],1024*getIndex(p, page_list)))
                    page_list[getIndex(p,page_list)]['visited'] = True
            print_list(page_list)
    
    def init(pages):
        for p in pages:
            p['time'] = 0
            p['visited'] = False
            a = random.random()
            if a<0.5:
                p['modified'] = False
            else:
                p['modified'] = True            #被访问过
    
    if __name__ == '__main__':
        pages = [
            {'No': 8},{'No': 9},{'No': 10},{'No': 7},{'No': 0},{'No': 1},{'No': 2},
            {'No': 0},{'No': 3},{'No': 0},{'No': 4},{'No': 2},{'No': 3},{'No': 0},
            {'No': 3},{'No': 2},{'No': 1},{'No': 2},{'No': 0},{'No': 1},{'No': 7},
            {'No': 0},{'No': 1}
        ]
    
        init(pages)
    
        FIFO(pages)
    
        LRU(pages)
    
        Improved_Clock(pages)


    展开全文
  • 分页式存储管理

    2013-05-25 22:53:33
    实现进程的分页式内存分配和地址转换过程,并进一步实现请求分页式存储分配和地址转换过程。页面置换算法至少应实现先进先出(FIFO)、最近最久未使用(LRU)等算法。
  • 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断选择页面调度算法处理缺页中断.wps
  • 基于C/C++模拟处理机调度、存储管理(动态分区分配、分页存储地址转换)和文件系统 基于C/C++模拟处理机调度、存储管理(动态分区分配、分页存储地址转换)和文件系统 基于C/C++模拟处理机调度、存储管理...
  • 一、连续分配方式缺点 连续分配方式的主要缺点是会形成许多碎片,...基本的分页存储管理方式不具备页面对换功能,也不支持实现虚拟存储器功能,它需要把每个作业全部装入内存后才能运行。 三、页面 分页存储管理是将

    一、连续分配方式缺点

    连续分配方式的主要缺点是会形成许多碎片,尽管我们可以通过紧凑的方法将碎片拼接成可用的大块空间,但这样须付出很大的代价。

    二、离散分配方式

    离散分配方式思想:将进程直接分散地装入到许多不相邻接的分区中。
    1.如果离散分配的基本单位是页----------》分页存储管理方式
    2.如果离散分配的基本单位是段----------》分段存储管理方式
    基本的分页存储管理方式不具备页面对换功能,也不支持实现虚拟存储器功能,它需要把每个作业全部装入内存后才能运行。

    三、页面

    分页存储管理是将一个进程的逻辑地址空间划分为若干个大小相等的片,这些片称之为页面,并编号第0页,第1页。。。同时,我们还把内存空间也划分为与页面大小相同的若干个存储快,称为块或叶框,也进行编号0#,1#…之后我们为进程分配内存时,即是将进程的若干个页分别映射装入到可以不相邻的块中去。由于这里进程的最后一页往往装不满块而会形成不可利用的碎片,我们称之为业内碎片。

    四、页面大小

    很明显,页面大小过小可使得内存碎片变小,减少内存碎片总空间,提高内存利用率,但缺点是:每个进程由此会占用更多页面,导致进程页表过长,占用大量内存(页表也是要耗费内存的),。而且还降低了页面切换的效率。而页面过大,可以减少页表长度,提高页面切换效率,但内存碎片增大。

    在页面大小选择适中,一般为2的幂,通常为512B~8KB。

    五、页面地址结构

    页号(P)+位移量(W)
    位移量W也称呼为页内地址或页内偏移量,对于特定机器,其页面地址结构时确定的,给定逻辑地址空间中的地址A,页面大小L,则页号P=int(A/L)
    页内地址W=A%L
    比如:系统页面大小为1KB,A=2170B,可得
    页号P=A/L=2170/1024=2
    页内地址=A%L=122

    六、页表

    在分页系统里,允许将进程各个页面离散存储在内存的不同物理块中,为了保证进程的正常运行,需要能在内存中找个每个页面所对应的物理块,于是系统得为进程建立一张页面映射表,以方便查找页面对应的地址,这张表叫做页表,进程地址空间内的所有页(0~n)都将通过页表映射到块号,进程执行时,只要通过查找页表,就可知道每页在内存中的物理块号。总而言之,页表作用就是实现从页号到物理块号的地址映射。

    例题:
    例1:
    一分页存储管理系统中逻辑地址长度为16位,页面大小为4KB字节,现有一逻辑地址为2F6AH,且第0,1,2,页依次存放在物理块5,10,11中,则相应的物理地址是多少?
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    例2:
    在这里插入图片描述
    解题过程:

       首先要知道页式存储管理的逻辑地址分为两部分:页号和页内地址。物理地址分为两部分:
    

    关系为:
    逻辑地址= 页号+页内地址

    物理地址= 块号+页内地址;

    **分析:**已知:用户编程空间共32个页面,2ˆ5 = 32 得知页号部分占5位,由“每页为1KB”,1K=210,可知内页地址占10位。

    由“内存为16KB”,2^4=16得知块号占4位。

    逻辑地址0A5C(H)所对应的二进制表示形式是:0000101001011100,后十位1001011100是页内地址,

    00010为为页号,页号化为十进制是2,在对照表中找到2对应的物理块号是11,11转换二进制是1011,即可求出物理地址为10111001011100,化成十六进制为2E5C;

    即则逻辑地址0A5C(H)所对应的物理地址是2E5C;

    例3:
    十进制逻辑地址转物理地址
    在这里插入图片描述
    在这里插入图片描述
    地址转换步骤:
    地址转换步骤
    当逻辑地址为16进制、八进制、二进制时,
    第一步:把逻辑地址转为二进制;

    第二步:按页的大小分离出页号和页内偏移量( 高位部分为页号,低位部分为页内偏移量 )

    第三步:根据题意产生页表;

    第四步:将逻辑地址的页内偏移量直接复制到物理地址的页内偏移量上
    ( 即:逻辑地址的页内偏移量 = 物理地址的页内偏移量 )

    第五步:以逻辑地址的页号查页表,查出物理地址的帧号,再把帧号转为二进制,复制到物理地址的的帧号上,从而得出物理地址。

    当逻辑地址为十进制时,
    第一步:求出逻辑地址的页号 = 逻辑地址 / 页面大小

    第二步:求出页内偏移量 = 逻辑地址 % 页面大小
    (“%”表示取余,只取余数,不取商)

    第三步:根据题意产生页表;

    第四步:以逻辑地址的页号查页表,查出物理地址的帧号

    第五步:求出物理地址 = 帧号 * 页面大小 + 页内偏移

    网易校招笔试题

    对于一个内存地址是32位、内存页是8KB的系统。0X0005F123这个地址的页号与页内偏移分别是多少?

    解法1:
    0X0005F123这个地址对应的十进制是:389411B

    页面大小8KB=8192B

    页号=389411/8192=47页

    页内偏移=389411%8192=0X00001123

    解法2:
    将地址转换为二进制:0X000….0101 111 1 0001 0010 0011

    8KB=2^13,即后13为页内偏移量即0X00001123

    0101111=47

    参考文章:
    分页存储管理方式
    逻辑地址到物理地址的转换

    展开全文
  • 分页式存储管理允许把进程分配到不相邻的分区。首先将进程的逻辑地址空间划分为大小相等的块,且块相对比较小,每个块称为一页(Page),由页号和页内地址组成; 其次,将内存空间也划分为同样大小的块,每个块...

    1.分页式存储管理基本原理:

    分页式存储管理允许把进程分配到不相邻的分区中。首先将进程的逻辑地址空间划分为大小相等的块,且块相对比较小,每个块称为一页(Page),由页号和页内地址组成;

    其次,将内存空间也划分为同样大小的块,每个块称为一页面(PageFrame)。

                                                     页:

    页号

    页内地址

     

     

    假设逻辑地址为A,页面大小为L,则页号和页内地址为:

    页号=A/L

    页内地址=A%L

     

    2.当进程将要运行时,操作系统会为进入内存的每个用户进程建立一张页表,记录进程逻辑地址空间的页号和内存物理地址空间中的页面号一一对应关系。同时系统还会建立一张作业表,将当前运行的作业的页表地址进行登记。

    对应关系如图所示:

    进程运行时,通过查找页表,就可以找到每页对应的物理页面号。页表就是实现从页号到物理块号的地址映射。

    3.地址转换

    地址转换时,先从页表控制寄存器中找到相应的页表,再以页号为索引去检索页表。查找操作由硬件执行。在执行检索之前,先将页号与页表长度进行比较,如果页号大于或等于页表长度,则表示本次所访问的地址已超越进程的地址空间。于是,这一错误将被系统发现并产生一地址越界中断。若未出现越界错误,则将页表始址与页号和页表项长度的乘积相加,便得到该表项在页表中的位置,于是可从中得到该页的物理块号,将之装入物理地址寄存器中。与此同时,再将有效地址寄存器中的页内地址送入物理地址寄存器的块内地址字段中。这样便完成了从逻辑地址物理地址的变换。图示出了分页系统的地址变换机构。

    网易的笔试题:

    23.有用户态进程A,其虚拟内存页为1KB,A占用了64页,内存大写为128KB,A进程将爱子到内存的页面和物理内存块的编号对应关系如下:

    页面编号   物理内存块编号

    0                          4

    1                          9

    2                          5

    3                          8

    请根据以上信息回答如下问题,并给出计算过程:

    1)虚拟地址为015D对应的物理地址是多少?

    2)物理地址为113C对应的虚拟地址为多少?

    3)进程A有一作业长度为8页,试图访问虚拟地址2A3D并保存整型1到该地址对应的物理地址空间,之后又尝试从该地址读取保存的数据,请问A进程这两次内存访问过程能否正常执行?并解释原因。

       解:

       1)虚拟地址为015D对应的物理地址是 :

           1KB=400H  (转换成16进制)

           页号:  015D/400=0

           页内地址:015D%400=15D

           查找页表:0->4

           物理地址:4*400+15D=115D

       2)物理地址为113C对应的虚拟地址为多少?

           就是反过来,物理快号:113C/400 = 4

                          块内地址:113C%400 = 13C

                          虚拟地址:0*400+13C=013C

       3)进程A有一作业长度为8页,试图访问虚拟地址2A3D并保存整型1到该地址对应的物理地址空间,之后又尝试从该地址读取保存的数据,请问A进程这两次内存访问过程能否正常执行?并解释原因。

            不能。  

            页号:2A3D/400 = A

            页内地址:2A3D%400=23D

            A>8,超出进程A的页表长度。

           **第三问不是很确定,如果有错,请指出,谢谢。第三问我也不太懂。

           这个题麻烦的就是16进制的乘除。

    展开全文
  • 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及选择页面调度算法处理缺页中断
  • 深入了解页式存储管理如何实现地址转换;进一步认识页虚拟存储管理中如何处理缺页中断以及页面置换算法。 二、实验内容 设计一个请求页式存储管理方案。并编写模拟程序实现之。产生一个需要访问的指令地址流。它是...
  • 式存储-地址转换访问2次内存,第一次是页表,第二次是真正的物理内存。二级页表,访问3次内存两个例子的形式讲解逻辑地址到物理地址转换:(1)页系统页表: 页号: 0 1 2 3 4 5 块号: 3 5 x 4 1 2每页2KB 计算逻辑...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,052
精华内容 29,220
关键字:

分页式存储管理中的地址转换