精华内容
下载资源
问答
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断。
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断.------很好用的程序和源代码
  • 实验五:模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用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)


    展开全文
  • 第一题:模拟分页式存储管理中硬件的地址转换和产生缺页中断。 第二题:用先进先出(FIFO)页面调度算法处理缺页中断。
  • 1.模拟分页式存储管理中硬件的地址转换和产生缺页中断。 2.用先进先出(FIFO)页面调度算法处理缺页中断。
  • ![图片说明](https://img-ask.csdn.net/upload/201711/29/1511938778_606453.png) 希望能给出流程图和全部代码
  • 先说下什么是页(页面)...在第4章存储器管理,学习了分页式存储管理方式(是为了解决内存的碎片问题) 在第5章虚拟存储器,学习了请求分页式管理方式(除了解决碎片问题外,又“扩充”了内存的大小(虚拟)) 在...

    先说下什么是页(页面):就是将用户的程序的的地址空间分成固定大小的区域,称为”页“,或者”页面“

    之后将这些页离散的放进内存中,这样解决了内存的碎片问题

    记得老师上课说了下这两个概念不能混,现在区分下:

    在第4章存储器管理,学习了分页式存储管理方式(是为了解决内存的碎片问题)

    在第5章虚拟存储器,学习了请求分页式管理方式(除了解决碎片问题外,又“扩充”了内存的大小(虚拟))

    在这里为了使得固定数目的内存来运行较多的进程,增加了调页功能和页面置换功能。

    (在这可以看书或者笔记上的例题更好理解)

    请求分页式存储管理需要一些硬件设备的支持:

    1.请求页表机构

    页号,物理块号,状态位(该页是否调入内存),访问字段(用于选择换出页),修改位(换出页是否要重写到外存),外存地址(换入页的地址)

    2.缺页中断机构(这个是请求分页式存储管理特有的)

    3.地址转换机构

     

     

    就这些吧。

    转载于:https://www.cnblogs.com/ldphoebe/p/4845007.html

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

    2020-04-23 09:31:29
    分页式存储管理内容回顾课后习题内容解答 内容回顾 课后习题 内容 若在一分页存储管理系统,某作业的页表如下所示,已知页面大小为1024字节,试将逻辑地址1011、2148、4000、5012转化为相应的物理地址。 页号...

    内容回顾

    在这里插入图片描述

    课后习题

    内容

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

    页号 块号
    0 2
    1 3
    2 1
    3 6

    解答

    按照地址转换的流程,将逻辑地址1011转化为物理地址:

    1. 页号P=1011/1024=0P = 1011 / 1024 = 0
    2. 查页表可知块号B为2;
    3. 偏移量W=1011W = 1011 % 1024 = 1011
    4. 故物理地址为:1024B+W=10242+1011=30591024*B+W = 1024*2+1011 = 3059

    第四步乘1024是因为块和页面大小相同,页面是要刚好放入一个块的。

    同理,其他的计算过程一样。

    逻辑地址 页号 块号 偏移量 物理地址
    1011 0 2 1011 3059
    2148 2 1 100 1124
    4000 3 6 928 7072
    5012 4(页号越界) 找不到,该逻辑地址非法 916
    展开全文
  • 这是操作系统中请求分页式存储管理中的页面置换算法,有先进先出算法,OPT置换算法,LRu置换算法。
  • 通过编写分页式存储管理的模拟程序,加深对页式存储管理方式的理解,熟悉逻辑地址到物理地址的转换过程,掌握虚拟存储管理中的页面调度算法,认识分页式虚拟存储系统中缺页中断的处理过程。 二、实验内容 1、设计一...

    操作系统实验四 请求分页式存储管理

    题目描述:
    一、实验目的
    通过编写分页式存储管理的模拟程序,加深对页式存储管理方式的理解,熟悉逻辑地址到物理地址的转换过程,掌握虚拟存储管理中的页面调度算法,认识分页式虚拟存储系统中缺页中断的处理过程。
    二、实验内容
    1、设计一个分页式虚拟存储系统,用程序模拟实现,假设页面大小为1K,每个进程分配三个块。
    2、页面调度分别采用FIFO调度算法和LRU算法(堆栈法)。(选中页面直接交换。)
    3、假设当前作业的页表如下:
    在这里插入图片描述
    4、假设逻辑指令格式为:
    操作符 页号1 页内地址1 页号2 页内地址2
    例如 表示将页面1内地址为011单元的内容和页面2中地址为051的单元的内容相加,
    如:(1011H)+(1200H)。
    现有指令序列如下:
    在这里插入图片描述
    5、编写模拟程序,执行上述指令,若当前页面不在内存,则使用页面调度算法,交换相应页。
    6、要求每执行上述指令流中的一条逻辑指令,输出相应的物理指令,若页表有修改,则显示修改后的页表。
    FIFO结果
    队列内容
    在这里插入图片描述
    在这里插入图片描述

    LRU结果
    栈内部内容:第三个为栈顶第一个为栈低
    在这里插入图片描述
    在这里插入图片描述

    三、实验思路
    (1)初始化:
    ①初始化页表:自定义页表项数据结构,所有页表项构成一个数组。页表项数据结构中包含所提供的页表信息。从文件中读取页表信息并写入该数组。
    ②初始化指令表:自定义指令数据结构,所有指令构成一个数组,该数组表示指令表。
    指令数据结构中包含所提供的单条指令信息。从文件中读取指令表信息并写入该数组。
    (2)FIFO算法:
    该算法总是换出最先进入内存的页面,就是要选择当前在内存中驻留时间最久的页面换出。因此可以设置一个队列来保存当前进入内存的页面页号,表示当前内存分配情况。并给它们设置驻留时间。
    根据题目给的页表信息,可以看出该进程所分配到的内存块已经存满了,存的是0,1,2号页。可以初始化当前内存分配情况队列,我这里按照这些页在页表中的逻辑地址将它们保存到队列中,即初始化队列为:0,1,2。并将它们的驻留时间设置为0。又因为每个进程分配到的内存块为3,所以用一个三行二列的二维数组来表示该队列,每一行的第一个元素保存页号,第二个元素保存对应的驻留时间。
    我这里设置的FIFO函数只有一个参数,传入的是待查找的页码。因此该算法要完成以下功能:
    ①判断该页是否在内存中,由serach_page()实现
    ②找出在内存中驻留时间最长的页面,由search_max()实现
    ③如果该页没有在内存中,在页表中查找该页的逻辑地址,在页表中找出驻留时间最长页面的逻辑地址交换两个页面的标志,磁盘地址,内存块号。并在队列中换出的页面位置上写入换入页面的信息,驻留时间设为0,其他的驻留时间+1。输出更新后的页表信息。
    ④将此时的队列信息写入队列信息总表以便程序运行完之后查看。
    (这个总表队对应于上述示例图片的FIFO队列,表总共8行,对应4条指令的8个操作页面。所以说是每找一个页面就要写入一条队列信息。)
    代码:

    void FIFO(int pnum)
    {
    	if (!serach_page(pnum))
    	{
    		int a, b, c;
    		int max = serach_max();
    		for (int i = 0;i < 3;i++)
    		{
    			if (in_s[i][1] == max)
    			{
    				c = in_s[i][0];
    				break;
    			}
    		}
    		for (int i = 0;i < 6;i++)
    		{
    			if (p[i].pnum == c)
    			{
    				a = i;break;
    			}
    		}
    		for (int i = 0;i < 6;i++)
    		{
    			if (p[i].pnum == pnum)
    			{
    				b = i;break;
    			}
    		}
    		p[a].flag = 0;
    		p[b].flag = 1;
    		p[a].add = p[b].add;
    		p[b].add = -1;
    		p[b].cnum = p[a].cnum;
    		p[a].cnum = -1;
    		int e;
    		for (int i = 0;i < 3;i++)
    		{
    			if (in_s[i][0] == c)
    			{
    				e = i;
    				break;
    			}
    		}
    		in_s[e][0] = pnum;
    		in_s[e][1] = 0;
    		cout << "发生第" << ++cnumber << "次缺页,更新后的页表为:" << endl;
    		display_p();
    	}
    	int p = 0;
    	for (int i = 0;i < 3;i++)
    		in_FIFO[f][p++] = in_s[i][0];
    	f++;
    }
    

    (3)LRU算法:
    用一个特殊的栈来保存当前内存分配情况。当需要某一页且该页在内存中,就将该页从栈中取出,并压入栈顶。如果此时栈满,且需要的页面不在内存中,应该移出栈底页,将要换入的页面压入栈顶。因为这里涉及到不同于栈的操作,且调用的页要成为栈顶,所以可以用双向链表实现该栈,以便经常行的存取。
    初始化栈,根据题意应该是0,1,2,其中0为栈底,2为栈顶。
    同样,我这里设置的LRU函数也是只有一个参数,用来传入待查找的页码。因此该算法要完成以下功能:
    ①判断该页是否在内存中,由serach_page2实现。(与FIFO中不同的是这里从栈中查找)
    ②如果当前栈满,且发生缺页,将栈底元素移出栈,该元素即为换出页面的页码,并在页表中找到该换出和换入页面的逻辑位置,交换两页面的部分信息。输出更新后的页表信息。
    ③如果没有发生缺页,将该页从栈中移出,并压入栈顶。
    ④将此时的栈信息写入总栈内容表。
    代码:

    void LRU(int pnum)
    {
    	if (search_page2(pnum))//页面在主存中
    	{
    		LRU_stack* q = p_stack->next;
    		while (q)//找到该页所对应的链栈的位置
    		{
    			if (q->pnum == pnum)
    				break;
    			q = q->next;
    		}
    		if (q->next == NULL)
    		{
    			q = p_stack->next;
    			int k = 0;
    			while (q)
    			{
    				in_LRU[f][k++] = q->pnum;
    				q = q->next;
    			}
    			f++;
    		}
    		else
    		{
    			LRU_stack* d = p_stack->next;
    			while (d->next)//找到栈顶指针
    				d = d->next;
    			//在链栈中交换两个页面的位置,并不改变页表。
    			q->prew->next = q->next;
    			q->next->prew = q->prew;
    			q->prew = d;
    			d->next = q;
    			q->next = NULL;
    			//将当前链栈信息写入LRU
    			q = p_stack->next;
    			int k = 0;
    			while (q)
    			{
    				in_LRU[f][k++] = q->pnum;
    				q = q->next;
    			}
    			f++;
    		}
    	}
    	else//页面不在主存中
    	{
    		int onum;
    		int a, b;//分别保存 换出的页 和 换入的页 在页表中的相对位置
    		for (int i = 0;i < 6;i++)//找出换入页相对位置
    		{
    			if (p[i].pnum == pnum)
    			{
    				b = i;
    				break;
    			}
    		}
    		onum = p_stack->next->pnum;
    		for (int i = 0;i < 6;i++)//找出换出页相对位置
    		{
    			if (p[i].pnum == onum)
    			{
    				a = i;
    				break;
    			}
    		}
    		//修改页表
    		p[a].flag = 0;
    		p[b].flag = 1;
    		p[a].add = p[b].add;
    		p[b].add = -1;
    		p[b].cnum = p[a].cnum;
    		p[a].cnum = -1;
    		cout << "发生第" << ++cnumber << "次缺页,更新后的页表为:" << endl;
    		display_p();
    		LRU_stack* q = p_stack->next;
    		LRU_stack* d = p_stack->next;
    		while (d->next)//找到栈顶指针
    			d = d->next;
    		q->prew->next = q->next;
    		q->next->prew = q->prew;
    		q->prew = d;
    		d->next = q;
    		q->next = NULL;
    		q->pnum = pnum;
    		q = p_stack->next;
    		int k = 0;
    		while (q)
    		{
    			in_LRU[f][k++] = q->pnum;
    			q = q->next;
    		}
    		f++;
    	}
    }
    

    实验结果:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 实现分页式存储地址转换过程,在此基础上实现请求分页的地址转换。实现请求页式地址转换出现的缺页现象,用到的FIFO、LRU、OPT置换算法。
  • 通过本实验帮助同学理解在分页式存储管理中怎样实现虚拟存储管理。 三. 实验题目 第—题:模拟分页式存储管理中硬件的地址转换和产生缺页中断。 第二题:用先进先出(FIFO) 运行环境:Microsoft Visual Studio 2005
  • 分页式存储管理系统

    千次阅读 2012-12-02 21:03:04
    分页式存储管理系统,内存的大小为64KB,被分成16块,块号为0、1、2、…、15。设某进程有3页,其页号为0、1、2,被分别装入内存的2、4、7,问:该进程的大小为多少字节?写出该进程每一页在内存的起始地址。逻辑地址...
  • 操作系统 中分页式存储管理算法的源代码 C语言编写
  • 【操作系统】分页式存储管理习题

    千次阅读 2020-12-30 10:51:31
    操作系统——分页式存储管理习题习题一习题二参考链接 习题一 在一分页存储管理系统,逻辑地址长度为16位,页面大小为4096字节,现有一逻辑地址为2F6A(H),且第0,1,2页依次存放在物理块5,10,11,问相应的...
  • 模拟分页式存储管理中硬件的地址转换和产生缺页中断,然后分别用LRU、FIFO、改进型的CLOCK算法实现分页管理的缺页中断。 要求:显示每个页面在内存中的绝对地址,页表信息、列出缺页情况等。 #include #include #...
  • 分页式储存管理用户程序的逻辑地址空间被划分为若干个固定大小的地址空间,称为“页”,内存物理地址空间也分成相对应的若干个物理块,页和块的大小相等,可将用户程序的任一页放在任一块,实现离散分配 。...
  • 分页式存储管理允许把进程分配到不相邻的分区。首先将进程的逻辑地址空间划分为大小相等的块,且块相对比较小,每个块称为一页(Page),由页号和页内地址组成; 其次,将内存空间也划分为同样大小的块,每个块...
  • 操作系统课程源代码,高效,凝练,C语言实现。
  • 1、实现分页式存储管理地址转换过程,将逻辑地址转换成物理地址。 2、在此基础上实现请求分页的地址转换;实现请求页式地址转换出现的缺页现象,用到的先进先出、最近最久未使用、最佳置换算法。掌握内存的分配...
  • 一、分页存储管理 1、基本概念(页面和物理块) 将一个进程的逻辑地址空间划分成若干大小相等的部分,每一部分称为页或页面(页面的大小通常是2的次幂,大约在512B~4MB之间);同样,将内存空间也划分为与页面大小...
  • 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及用先进先出(FIFO)页面调度算法处理缺页中断。 用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程。(题目四) 包含详细实验报告·
  • 分页式和段式存储管理

    千次阅读 2016-06-18 19:06:00
    分页式和段式存储管理  (2014-05-27 22:49:05) 转载▼  在操作系统引入分页和分段管理之前,操作系统采用的是分区管理,就是将内存分成多个连续的地址空间,如果允许将一个进程分散到许多不连续的...
  • 基本分页存储管理方式 离散分配内存: 作业规定大小划分成小份;内存也按同样大小划分成小份 作业的任一小份可分散放入内存任意未使用的小份 分页方式下,内存的使用率高,浪费少。但不是绝对没有碎片(进程的最后一...
  • 分页存储存储管理方式详解

    千次阅读 多人点赞 2020-04-22 21:38:18
    分页存储存储管理方式详解离散分配方式分页储存管理方式页面与页表页面物理块逻辑地址结构页表快表(TLB,Translation Look aside Buffer)一级页表的缺陷两级多级页表反置页表反置页表的提出基于反置页表的地址转换...
  • 还支持请求调页的存储管理方式。 当进程在运行需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求(向CPU发出缺中断),由系统将其所需页面调入内存。这种页面调入方式叫请求调页。 2. 页.....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,080
精华内容 15,232
关键字:

分页式存储管理中