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

    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和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次
    
    

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

    计算机操作系统–缺页中断与越界中断

    缺页中断

    通俗点讲就是在利用逻辑地址计算物理地址时,在得出的页号合法,却不在页表内时,由操作系统引发的中断

    越界中断

    和缺页中断类似,在判断合法时,若为非法,则发生越界中断

    合法

    用数组举例,在定义一个**数组 a【10】后,我们可以访问的地址是0~9的元素。若访问10或者10以后的则是超出了定义的界限,是非法的操作

    举个例子
    某虚拟存储器的用户空间共有32 个页面,每页1KB,主存16KB。假定某时刻系统为用户的第0、1、2、3页分配的物理块号为5、10、4、7,而该用户作业的长度为6页
    逻辑地址103CH的页号为4,页号合法,但该页未装入内存,故产生缺页中断
    逻辑地址1A5CH的页号为6,为非法页号,所以产生越界中断

    展开全文
  • 计算三种缺页中断的缺页数,缺页率和命中率 FIFO,LRU,OPT */ #include #include #include #include #include /* ** 默认页表大小为3 */ #define PAGETABLELENGTH 3 //输出函数,四个参数,缺页数,缺页率和...
    /*
       计算三种缺页中断的缺页数,缺页率和命中率
       FIFO,LRU,OPT
    */
    
    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    #include<time.h>
    #include<string.h>
    
    
    /*
    ** 默认页表大小为3
    */
    #define PAGETABLELENGTH 3
    
    
    //输出函数,四个参数,缺页数,缺页率和命中率,算法名称
    //无返回值
    void output( int pageFault, double pageFaultRate, double hitProbability , char *name)
    {
    	printf("\n=====================\n%s:\n",name);
       printf("缺页数是: %d\n",pageFault);
       printf("缺页率是: %2.2lf%\n",pageFaultRate*100);
       printf("命中率是: %2.2lf%\n",hitProbability*100);
    }
    
    //判断是否命中 
    int pageHited(int *arr,int begin, int length, int equNum)
    {
    	for(int i=begin;i<length;++i)
    	{
    		if(arr[i]==equNum)
    			return i;
    	}
    	return -1;
    }
    
    void arrayInit( int *arr, int length)
    {
    	for(int i=0;i<length;++i)
    		arr[i] = 0;
    }
    
    //FIFO
    //参数是一个指针以及数组长度
    //无返回参数
    //输出,缺页数,缺页率和命中率
    void fifo( const int *const arr, int length)
    {
    	
    	int pageTable[PAGETABLELENGTH];
    	int hitCount = 0;
    	int firstIn = 0;
    	int pageCount = 0;
    
    	arrayInit(pageTable, PAGETABLELENGTH);
    
    	for(int i=0; i< length; ++i)
    	{
    		//判断是否命中
    		int hit = pageHited( pageTable, 0, pageCount, arr[i]);
    		
    		if(hit!=-1)
    		{
    			++hitCount;
    		}
    		else
    		{
    			//page已经填满
    		   if(pageCount== PAGETABLELENGTH)
    		   {
    				pageTable[firstIn] = arr[i];
    				firstIn = (++firstIn)%PAGETABLELENGTH;
    		   }
    	     	//pagetable未填满
    			else
    			{
    			   pageTable[pageCount] = arr[i];
    			   pageCount++;
    			}
    		}
    	}
    
    	output(length-hitCount,(length-hitCount)/(double)length, (double)hitCount/length, "FIFO" );
    } 
    
    //LRU
    //参数是一个指针以及数组长度
    //无返回参数
    //输出,缺页数,缺页率和命中率
    void lru( const int *const arr, int length)
    {
    	int hitCount = 0;
    	int pageTable[PAGETABLELENGTH];
    	//记录page元素里最近使用的位置
    	int pageLastUsed[PAGETABLELENGTH];
    	int pageCount = 0;
    
    	arrayInit(pageTable, PAGETABLELENGTH);
    	arrayInit(pageLastUsed, PAGETABLELENGTH);
    
    	for(int i=0;i<length;++i)
    	{
    		int hit = pageHited(pageTable,0,pageCount,arr[i]);
    		if(hit!=-1)
    		{
    			++hitCount;
    			pageLastUsed[hit] = i;
    		}
    		else
    		{
    	    	if(pageCount==PAGETABLELENGTH)
    			{
    				int min = 0;
    				for(int plu = 1; plu<PAGETABLELENGTH; ++plu)
    				{
    					min = pageLastUsed[min] < pageLastUsed[plu]?min:plu;
    				}
    				pageTable[min] = arr[i];
    			}
    			else
    			{
    				pageTable[pageCount] = arr[i];
    				pageLastUsed[pageCount++] = i;
    			}
    		}
    	}
    
    	output(length-hitCount,(length-hitCount)/(double)length, (double)hitCount/length ,"LRU");
    
    }
    
    //OPT
    //参数是一个指针以及数组长度
    //无返回参数
    //输出,缺页数,缺页率和命中率
    void opt( int *arr, int length)
    {
    	int hitCount = 0;
    	int pageTable[PAGETABLELENGTH];
    	int pageFuture[PAGETABLELENGTH];
    	int pageCount = 0;
    
    	arrayInit(pageTable,PAGETABLELENGTH);
    	arrayInit(pageFuture,PAGETABLELENGTH);
    
    	for(int i=0; i<length; ++i)
    	{
    		int hit = pageHited(pageTable, 0, pageCount, arr[i]);
    		if(hit!=-1)
    		{
    			++hitCount;
    		}
    		else
    		{
    			//table 满 ,计算在最近的将来谁不会被用到
    		     if(pageCount == PAGETABLELENGTH)
    			 {
    		    	for(int pi=0; pi<pageCount; ++pi)
    				{
    					int find = pageHited(arr,i+1,length,pageTable[pi]);
    					if(find!=-1)
    					{
    						pageFuture[pi] = find;
    					}
    				    else
    					{
    			   		   pageFuture[pi] = length+1;
    					}
    				}
    				
    			    int max = 0;
    			    for(int pii=1; pii<pageCount; ++pii)
    				{
    				    max = pageFuture[max] > pageFuture[pii]? max:pii;
    				}  	
    		    	pageTable[max] = arr[i];
    			 }
    			 //table未满
    		     else
    			 {
    			     pageTable[pageCount++] = arr[i];
    			 }
    		}
    	}
    
    	output(length-hitCount,(length-hitCount)/(double)length, (double)hitCount/length,"OPT");
    }
    
    //参数是一个int型指针,数组长度
    //随机生成一个长度为11-20的数组,代表着页的执行顺序,
    //数字大小为1-9,随机生成,返回数组head指针
    int* productRandomArray( int *length)
    {
    	//随机数种子
    	srand(int(time(0)));
    	*length =  rand()%10+11;
    	
    	//数组长度
    	int *head = (int *)malloc(sizeof(int)*(*length));
        if(head ==NULL)
    	{
    		printf("malloc error!\n");
    		return NULL;
    	}
    
    	//数组赋值
    	for(int i=0;i<(*length);++i)
    	{
    		head[i] = rand()%9+1;
    	}
    	return head;
    }
    
    
    int main()
    {
    	int length;
    	int *head;
    	head = productRandomArray(&length);
    	if(head == NULL)
    		return -1;
    
    
    	printf("=====================Table 大小设置为 3 ==========================\n");
    	printf("====== 实验发现在大多数情况下FIFO 和 LRU 的命中率是一样的 ========\n");
    	printf("======================实验数据是随机生成的========================\n");
    
    	for(int i=0;i<length;i++)
    		printf("%d ",head[i]);
    	
    	//fifo
    	fifo(head,length);
    	//lru
    	lru(head, length);
    	//opt
    	opt(head, length);
    
    	getchar();
    	getchar();
    	return 0;
    }

    展开全文
  • 缺页率的计算: 缺页率 = (页面置换次数+分配给该进程的...换页错误:Page Fault,其实应该翻译成缺页异常或缺页中断,并非是错误,而是存在虚拟内存情况下的内存未命中,是非常常见的现象。内存分块,进程分页...
  • 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來命中,則...
  • 如未出现越界,则根据页表寄存器中的页表的起始地址的页号计算出此页在表项中的位置,得到此页的物理块号,将此物理块号装入物理地址寄存器中。于此同时,将有效地址(逻辑地址)寄存器中页内地址直接装入物理地址...
  • 输入缺页次数页面流: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來命中,則內...
  • 页表的创建 kmalloc内存使用了umapped内存,直接对地址偏移即可寻址物理内存,这里不考虑。 考虑用户态内存和vmalloc,都用到了虚拟...首先,X64内核是4级页表,根据X64对线性地址的划分,可以计算出0x00007F88F16...
  • 缺页中断 什么是缺页中断: 进程线性地址空间里的页面不必常驻内存,在执行一条指令时,如果发现他要访问的页没有在内存中(存在位为0),那么停止该指令的执行,并产生一个页不存在异常,对应的故障处理程序可通过...
  • 缺页率的计算

    千次阅读 2011-06-27 21:55:51
    什么是缺页中断: 缺页中断就是要访问的页不在主存,需要操作系统将其调入主存后再进行访问。 缺页率:在进行内存访问时,若所访问的页已在主存,则称此次访问成功;若所访问的页不在主存,则称此次访问失败,并产生...
  • 段地址转换与分页地址转换的过程基本相同,其过程如图所示(1)CPU计算出来的有效地址分为两部分:段号s和段内地址d。(2)系统将该进程段表地址寄存器中的内容B(表示段表的内存地址)与段号s相加,得到查找该进程段表中...
  • 页面置换算法与缺页计算

    千次阅读 2019-12-04 20:58:41
    前言 页面置换算法 页面置换算法是页式虚拟存储器中的管理算法。在进程运行过程中,若其所要访问的页面不在内存,则需要把他们调入内存,单内存已无空间时,为了保证该进程能正常运行...缺页中断(页缺失)是和页面...
  • 当访问虚拟内存时,会访问MMU(内存管理单元)去匹配对应的物理地址(比如图5的0,1,2),而如果虚拟内存的页并不存在于物理内存中(如图5的3,4),会产生缺页中断,从磁盘中取得缺的页放入内存,如果内存已满,还会根据...
  • 一道题引发的思考——不同算法下缺页数的计算 题目如下: 一进程刚获得三个主存块的使用权,若该进程访问页面的次序是{...缺页中断就是要访问的页不在主存,需要操作系统将其调入主存后再进行访问。 页面...
  • 假定分配给该作业的页数为3且作业初始时未装载页面,那么采用FIFO调度算法产生的缺页中断数为多少,采用LRU调度算法产生的缺页中断数为多少?  FIFO算法:(First In First Out),先进先出,一般看到这类思想,首先...
  • 1. 此例中共200行,150列,因为每个页面存放150个变量,故按列访问,...由于矩阵A按行序存放,故列行共产生缺页中断200*150次。 2. 分析下列程序共300行,每个页面存放300变量,存放与访问皆为行,故缺页200次 ...
  • 操作系统的缺页

    2020-11-30 22:25:09
    在中国电信笔试题目中遇到了两道计算缺页率的题目,但是忘记了怎么计算,在...缺页中断:就是要访问的页不在主存,需要操作系统将其调入主存后再进行访问。在这个时候,被内存映射的文件实际上成了一个分页交换文件。
  • 如果作业Ji执行过程中总的内存访问次数为A, 成功访问的次数为S,不成功的访问次数为F(产生缺页中断的次数), 则: A=S+F 缺页率: p=F/A 假设: 存取内存的时间 = Tms 交换页的时间 = Lms (既然交换了,那就...
  • 当再运行这个程序时,会发生很多的模块缺失即硬缺页,则操作系统产生很多硬中断,进行模块的装载,则程序的响应自然会变慢。 打开任务管理器,点击内存,最下面打开资源监视器,点击内存,可以看到各个进程硬中断...
  • CPU的组成 内存的组成 内存的硬件结构 内存的物理地址编码 内存的寻址 内存管理:分段 什么是内存分段 为什么发明了分段式内存管理 分段内存管理是如何实现的 ...中断: 缺页中断 什么是缺页中...
  • 目的:在缺页中断发生时,假如需要调入新的页面...思路:缺页中断发生时,对保存在内存中的每一个逻辑页面,计算在他下一次访问之前还需等待多长时间,从中选择等待时间最长的那个,作为被置换 这是理想情况,需要...
  • 页面置换算法 功能:当缺页中断发生,需要调入新的页面内存已满时,选择内存中哪个...基本思路: 当一个缺页中断发生时,对于保存在内存当中的每一个逻辑页面,计算在它的下一次访问之前,还需等待多长时间,从中...
  • 页面置换算法: ...最优页面置换算法:当发生缺页中断时,对于保存在物理内存中的每一个逻辑页面,计算下一次访问之前还需等待多长时间,从中选择时间最长的,作为被置换的页(理想情况,可以作为评判...
  • 总结《深入理解计算机系统》:异常控制流1,计算机中的异常处理机制:处理器设计人员(如被零除、缺页,存储器访问违例等)以及操作系统开发人员(如系统调用以及来自外部的IO设备信号等)为每种类型的异常分配了一...
  • 操作系统中经常涉及到缺页中断计算请求分页时间问题。通过前面的学习所总结的有效时间考虑因素: 首先访问页面所在的位置 【1】 访问的页在主存中,并且访问的页表也在快表中,那么有效时间=查找快表的时间+根据...
  • 页面置换算法

    2020-01-06 20:54:43
    下面主要介绍FIFO(先进先出算法)、OPT(理想型淘汰算法)、LRU(最近最久未使用算法),计算缺页率及缺页次数。 题目:在一个请求分页系统中。假定系统分给一个作业的物理块数...访问过程中发生缺页中断的次数就是缺页次...
  • Warning: 本系列基调:好读书,不求甚解! 术业有专攻,我们不去开发操作系统,也不使用汇编语言,没必要太深究原理. 了解计算机底层知识,是为了更好的... 缺页中断(异常)ZGC(Zero paused Garbage Collection)CPU如何区分 ...

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

缺页中断计算