精华内容
下载资源
问答
  • 2020-12-31 09:16:38

    【简答题】OS作为接口,通过哪几种方式实现?

    【简答题】并发与并行有什么区别?

    【判断题】请求分页式系统中,以页为单位管理用户的虚空间,以段为单位管理内存空间

    【简答题】微内核是否是完整的OS?

    【单选题】下列选项中,能引起外部中断的事件是

    【其它】包装设计一物多用的设计简图

    【简答题】同步机制应遵循哪四个规则?

    【单选题】( )调度算法总是从等待访问者中挑选时间最短的那个请求先执行。

    【单选题】信号量机制属于什么类型?

    【单选题】CPU与接口之间采用中断方式,是为了()。

    【简答题】引入线程这个单位的目的是什么?

    【单选题】利用信号量实现进程互斥,应让信号量mutex的值为

    【单选题】DMA的I/O控制方式的特点是()。

    【其它】汇总出10条以上不同的信息。

    【简答题】进程控制块的组织方式有哪几种?

    【其它】案例分析题 获得1996年戛纳广告节金狮奖的一则电视广告: 一位躺在摇篮里的婴儿,一会儿哭,一会儿笑。当摇篮悠起来,靠近窗口的时候,婴儿就高兴地露出笑脸;当摇篮悠下来的时候,婴儿就哇哇地哭。这一简单的过程反复持续了多次。广告的最后,把镜头从婴儿的角度对准窗外,窗外是黄色的麦当劳标志。 问题: (1) 请为此广告拟写一句广告词并简要说明创意,要求能充分表达主题,有一定的新颖性。 (2) 试分析此广告的广告主题 (3) 一般来讲,在广告中要使用婴儿或儿童形象,应注意哪些问题?

    【简答题】共享有哪几种?

    【单选题】( ) 不是页面置换常用算法

    【判断题】虚拟存储器时物理上扩充内存容量

    【单选题】虚拟存储器管理系统的基础是程序的()理论

    【简答题】课程设计说明书

    【其它】P186 第1、2、3题

    【单选题】关于虚拟存储器以下说法错误的是()

    【简答题】OS发展目标是什么?其中最主要目标是什么?

    【单选题】虚拟存储器功能的管理方法不包括( )

    【单选题】发生中断请求的条件是()

    【简答题】OS作为资源管理者,有哪几种资源需要管理?

    【简答题】前趋图是作什么用的?

    【简答题】访问临界资源分哪四步?

    【单选题】单核CPU能否实现并发

    【单选题】主机和外设不能并行工作的方式是()。

    【简答题】某请求页式存储系统采用最近最久未使用(LRU)页面置换算法.一个作业的页面走向是0,1,2,3,1,4,3,1,0,3,4,5,分配给该作业的存储块数M为3,且每次只能调入一项,则访问过程中发生的置换页面的次数为?

    【单选题】在请求分页系统中,页表中的外存始地址的作用是( )

    【简答题】虚拟有什么实现方式?

    【简答题】地址映射是什么地址对应什么地址?

    【单选题】操作系统中的SPOOLing技术,实质是将()转化为共享设备的技术。

    【简答题】进程的三种基本状态是什么?

    【判断题】为提高请求分页系统中内存的利用率,允许用户使用不同大小的页面

    【单选题】实现虚拟存储器的目的是()

    【其它】产品设计类的设计说明

    【其它】1.品牌 2.产品包装 3.广告 举例:旺仔牛奶 18周作业.docx

    【单选题】整型信号量不满足同步机制中的哪个规则?

    【单选题】把作业地址空间使用的逻辑地址变成内存物理地址为()

    【单选题】在请求分页系统中,若逻辑地址中的页号超过页表寄存器中的页表长度,则会引起( )

    【单选题】虚拟存储器的最大容量( )

    【简答题】单用户多任务、多用户多任务OS举例。

    【其它】调研20份截图

    【简答题】什么是设备无关性?

    【简答题】批处理系统最主要的缺点是什么?

    【简答题】SPOOLing系统的特点是什么?

    更多相关内容
  • 创建请求页表,通过编程模拟缺页中断和地址变换,实现请求功能和页面置换功能。
  • 内容:设计页表结构,编制一个请求分页的仿真程序,通过指令访问随机的虚页。通过页面映射,判断是否命中当前工作集中的实。如果没有命中,则从自由队列获得一空闲内存;如果工作集中的实总数已满,则采用某...
  • 实验ppt
  • 实验八:请求分页系统页面淘汰算法 内容:设计页表结构,编制一请求分页的仿真程序,通过指令访问随机的虚页。通过页面映射,判断是否命中当前工作集中的实。如果没有命中,则从自由队列获得一空闲内存;...
  • C++编写的请求分页储存管理的置换算法模拟程序,模拟OPT,FIFO和LRU算法。可以输入序列也可以随机生成访问序列。可以输出整个调度的流程(表),缺页次数和缺页率。
  • 此次实训过程,我先是完成了FIFO、LRU、OPT、Clock四算法的实现,之后结合Java的Swing图形化界面,将算法融入到图形化界面,并且可以进行序列长度和运行时间的初始化,紧接着,可以将序列和物理块进行随机...
  • 利用键盘输入本模拟系统的物理块的大小,作业的页表的块号;完成逻辑地址转换成相应的物理地址的过程。 1、建立一张位示图,用来模拟内存的分配情况,利用随机数产生一组0和1的数对应内存的使用情况。 2、输入块...
  • 2.能够模拟内存的分页式分配和回收过程,可查看内存分配位示图和进程页表; 3.可根据内存分配状态进行地址转换。 4.能够模拟基于虚拟存储器的内存分配和回收过程,可查看交换空间位示图和扩 展的页表; 5.虚拟...
  • 文章目录一、 题目要求二、程序功能及设计... [0,M-1]随机选取M1,访问M1; D. 顺序访问M1+1; E. [M1+2,32k-2]随机选取M2,访问M2; F. 顺序访问M2+1; G. 重复 A—F,直到执行320次指令。 2. 指令序列变换


    一、 题目要求

    1.通过如下方法产生一指令序列,共320条指令。
    A. 在[1,32k-2]的指令地址之间随机选取一起点M,访问M;
    B. 顺序访问M+1;
    C. 在[0,M-1]中随机选取M1,访问M1;
    D. 顺序访问M1+1;
    E. 在[M1+2,32k-2]中随机选取M2,访问M2;
    F. 顺序访问M2+1;
    G. 重复 A—F,直到执行320次指令。
    2. 指令序列变换成页地址流设:(1)页面大小为1K;
    (2)用户虚存容量为32K。
    3. 计算并输出下述各种算法在不同内存页块(页块个数范围:8-32)下的命中率。
    A. 先进先出(FIFO)页面置换算法
    B. 最近最久未使用(LRU)页面置换算法
    C. 最佳(Optimal)页面置换算法
    (命中率=1-页面失效次数/页地址流长度)

    二、程序功能及设计思路

    程序功能:能随机产生指令序列,并实现三种置换算法。
    设计思路:指令序列通过srand函数生成种子实现。
    先进先出(FIFO)页面置换算法,比较简单,如果当前页块中没有当前调入的页面,则直接将最早进来的页面淘汰。通过vector自带的erase()和push_back()即可实现。
    最近最久未使用(LRU)页面置换算法 ,需要将停留在页块中时间最久的页面淘汰。于是创建了一个PAGE结构体,结构体中含有页名和停留在页块中的时间两变量。每次添加新的页面时,停留在页块中的时间+1。如果添加的页面在页块中已经存在,则将该页面时间清零,否则则找出停留在页块中时间最大的页面,将其淘汰,添加新的页面。
    最佳(Optimal)页面置换算法,该算法选择的被淘汰页面,将是以后永远不使用的,或许是在最长(未来)时间内不再被访问的页面,所以每次新的页面调入时,记录并比较停留在页块中页面再次调入页块的时间,选出时间最大的淘汰。

    三、数据结构及算法设计

    (1)设计:数据结构

    页面描述

    struct PAGE {
        int id;//页号
        int time;//自上次被访问以来所经历的时间t
    };
    
    

    (2)算法设计
    产生指令序列

    void generate() {
        int cnt = 0;
        srand(time(0));
        bool CF = 1;
        while (CF) {
            int M = rand() % max_add + 1;//在[1,32K-2]的指令地址之间随机选取一起点M
            ins[cnt++] = M;
            if (cnt >= N) { break; }
            ins[cnt++] = M + 1;//顺序访问M+1
            if (cnt >= N) { break; }
            int M1 = rand() % M;
            ins[cnt++] = M1;
            if (cnt >= N) { break; }
            ins[cnt++] = M1 + 1;//顺序访问M1+1
            if (cnt >= N) { break; }
            int M2 = rand() % (max_add - M1 - 1) + (M1 + 2);// 在[M1+2,32K-2]中随机选取M2
            ins[cnt++] = M2;
            if (cnt >= N)break;
            ins[cnt++] = M2 + 1;//顺序访问M2+1
            if (cnt >= N)break;
        }
        for (int i = 0; i < N; i++) {
            ins[i] = ins[i] / 1024;//得到页号
        }
    }
    
    

    先进先出(FIFO)页面置换算法

    double FIFO(int page) {
        double hit_num = 0;
        double unhit_num = 0;
        vector<int>temp;
        for (int i = 0; i < page; i++) {
            temp.push_back(-1);
        }
        for (int i = 0; i < N; i++) {
            vector<int>::iterator it = find(temp.begin(), temp.end(), ins[i]);
            if (it == temp.end()) {
                temp.erase(temp.begin());
                temp.push_back(ins[i]);
                unhit_num++;
            }//未命中
            else {
                hit_num++;
            }
        }
        return 100 * (1 - unhit_num / N);
    }
    
    

    最近最久未使用(LRU)页面置换算法

    double LRU(int page) {
        double hit_num = 0;
        double unhit_num = 0;
        vector<PAGE>temp;
        for (int i = 0; i < page; i++) {
            temp.push_back(PAGE{ -1,0 });
        }
        vector<PAGE>::iterator it;
        for (int i = 0; i < N; i++) {
            for (it = temp.begin(); it != temp.end(); it++) {
                it->time++;
            }
            bool flag = false;
            for (it = temp.begin(); it != temp.end(); it++) {
                if (it->id == ins[i]) {
                    flag = true;
                    it->time = 0;
                    hit_num++;
                    break;
                }   
            }
            if (!flag) {
                //找到一个最大的
                vector<node>::iterator max_it = temp.begin();
                for (it = temp.begin(); it != temp.end(); it++) {
                    if (it->time > max_it->time) {
                        max_it = it;
                    }
                }
                temp.erase(max_it);
                unhit_num++;
                temp.push_back(node{ ins[i],0 });
            }
        }
        return 100 * (1 - unhit_num / N);
    }
    
    

    最佳(Optimal)页面置换算法

    double OPT(int page) {
        vector<int>temp;
        double hit_num = 0;
        double unhit_num = 0;
        for (int i = 0; i < page; i++) {
            temp.push_back(-1);//初始化
        }
        for (int i = 0; i < N; i++) {
            vector<int>::iterator it = find(temp.begin(), temp.end(), ins[i]);
            if (it == temp.end()) {//如果没找到
                unhit_num++;
                int maxtime = -1;
                vector<int>::iterator ans;
                for (it = temp.begin(); it != temp.end(); it++) {
    
                    int cur = 0x3f3f3f3f;
                    for (int j = i + 1; j < N; j++) {
                        if (ins[j] == *it) {
                            cur = j;
                            break;
                        }
                    }
                    if (cur > maxtime) { //找到之后最长时间未使用的
                        maxtime = cur;
                        ans = it;
                    }
                }
                temp.erase(ans);
                temp.push_back(ins[i]);
    
            }
            else {
                hit_num++;
            }
        }
        return 100*(1-unhit_num/N);
    }
    
    

    四、程序运行情况

    在这里插入图片描述

    五、遇到的困难及解决办法、实习心得或良好建议

    遇到的困难:在计算命中率时总是出现不合理的结果,例如-1200,或者各种高于100的数字。
    解决办法:将定义为全局变量的unhit_time当作局部变量放入三个算法中,并逐步调试发现LRU中unhit_time++的时机不对,应该放在erase()那一块。
    实习心得:这次实验难度并不高,但是考查的是对三种置换算法的理解。我课堂上并没能好好掌握该部分知识点,通过反复阅读ppt和做相关例题,终于明白了各种置换算法的实现步骤,学习能力得到提高。

    展开全文
  • 通过实现一操作系统的内存管理的模拟系统,观察内存空闲分区管理、内存分配和回收过程,了解内存管理技术等特点,掌握内存管理的分配、回收和置换算法,加深对请求页系统的原理和实现过程的理解。
  • 例:已知 进程页面走向如下: 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1 供该进程使用的内存块数为3, 采用 请求 策略。 (1) 画出访问各时内存块中页号情况 (2) 求缺页率...


    由于本人java学艺不精,这两种算法均采用最基础的for循环来实现。等本小媛再修炼修炼,会对此代码进行优化,大家敬请期待。

    FIFO先进先出算法

     算法原理:

     

    • 要淘汰内存某页时,选择 最先进入内存的页 淘汰。
    • 例:已知 进程页面走向如下:    7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1    供该进程使用的内存块数为3, 采用 请求 调页    策略。
    •   (1) 画出访问各页时内存块中页号情况   (2) 求缺页率

     

    • 缺页率的计算:当CPU进入内存找某页时发现没有,需要重新调入,属于一次缺页。

    代码实现:

    代码实现分为两部分:part1:先从外部调入进程页直到内存块满;part2:当内存块满了之后,若要调入新的进程页号,则需根据先进先出原则淘汰内存块中的页号。

    part1:当第一个页号调入内存时,由于内存块内为空,可直接调入。从第二个页号调入时,就要与之前已经调入内存块的页号进行对比。如果某页之前已被调入进内存块,则不需要再调入。非缺页记录变量加一;如果某页之前未被调用过,则此时被调入进内存块。

    part2:当内存块被填满之后,在调用下一个进程页时,与内存块中已有的页号进行对比,如果之前已被调入,则不需要被再次调入。非缺页变量加一;如果之前未被调用,则需淘汰内存块中现有的页号,根据先进先出原则,在数组中i值最小的,是最早进入内存块的,i值大的是最晚进入内存块的。所以在淘汰进程页时,可以从i=0;开始淘汰,直到淘汰到i=number;

    		     int yes=0;
    		     int [] block=new int [number];//blcok数组是用来存放内存块内数据的,在这里先往内存块内存放数据,将内存块填满
    		     block[0]=page[0];//最开始的时候,block里面是空的,所以可以直接进程页号可直接调入内存块中
    		     for(int i=1;i<number;i++){//for循环将进程页号调入数组
    		    	 boolean o=false;
    		    	for(int m=0;m<i;m++){//本层循环来判断内存中是否已经存在要使用的进程的页号
    		    	if (block[m]==page[i]){
    		    		yes++;//如果内存块中存在要调用的页号,则非缺页次数加一
    		    		o=true;}
    		    	}
    		    	while(o){
    		    		for(int j=0;j<i-1;j++){//输出此时内存块中的页号情况,由于此时内存块中并未赋新值,所以内存块中的情况依旧是上一轮循环后的结果。
    			    		System.out.print(block[j]+" ");
    		    		}
    		    		break;
    		    	}
    		    	while(!o){
    		    		block[i]=page[i];//如果内存中不存在要调用的页号,则将新页号调入内存块
    		    		for(int j=0;j<i;j++){
    			    		System.out.print(block[j]+" ");
    			    	
    		    		}
    		    		break;
    		    	}
    		    	System.out.println();
    		}
    		   
    		int s=0;
    		int n=0;
    		for(int i=number;i<p;i++){//内存块被装满后
    			boolean e=false;
    			for(int j=0;j<number;j++){
    				if (page[i]==block[j]){
    					e=true;
    					n++;}//非缺页变量
    				
    				}
    		if(e){
    			for(int m=0;m<number;m++){//输出此时内存块中的已有页号
    				System.out.print(block[m]+" ");
    				
    				}
    		}
    		else{
    					
    					block[s]=page[i];//数组中的页号从block[0]到block[number]
    					s++;
    					if(s==number){
    						s=0;//当到达数组最大值后,s再变为0,新的一轮淘汰开始
    					}
    					for(int m=0;m<number;m++){
    						System.out.print(block[m]+" ");
    						
    				}
    			}
    		System.out.println();
    		}
    		System.out.println("缺页次数:"+(p-n-yes)+"次");//非缺页次数由n和yes两部分组成
    	
    		double g=(p-n-yes)/(double)p;
    		System.out.print("缺页率:");
    		System.out.println(String.format("%.2f",g));

    LRU算法  最近最久未使用置换法 ( LRU= Least Recently Used )

    算法思想:

    需要淘汰页面时,选择内存中最近一段时间里最久没有使用过 页面淘汰。

     

    通常会使用一个 栈 来保存在内存中的页面的页号。当一个页面被访问时,其对应的页号要放在栈顶,当要淘汰页面时,栈底页号对应的页面即为要淘汰的页面(即最近最久未被访问的页面)。

    由于我不会用代码表示栈,所以我还是用了数组。用i=0;表示栈底。i=number;表示栈顶。嘻嘻嘻

    代码实现:依旧是分成两个部分;part1:先填满内存块;part2:对内存块内的页号进行淘汰。

    此算法难点是,当要调入的页号已经在内存块内时,需要将此页号的位置放到栈顶,也就是数组=number的位置,并将数组内的其他页号向栈底推,也就是向i=0;的方向推。

    		int yes2=0;
    		int y=0;
    	     int [] block2=new int [number];//block2数组来存放内存块内的页号。方法与FIFO相同
    	     block2[0]=page[0];
    	     for(int i=1;i<number;i++){
    	    	 boolean o=false;
    	    	for(int m=0;m<i;m++){
    	    	if (block2[m]==page[i]){//如果页号已经在内存块内
    	    	        yes2++;//非缺页变量加一
    	    		o=true;
    	    		y=m;
    			int z=block2[y];//当页号已在内存块中时,将此页号提到栈顶,其余页号往栈底推
    			for(int f=y+1;f<i;f++){
    				block2[f-1]=block2[f];
    			}
    			block2[i-1]=z;
    			break;
    	    		}
    	    	}
    	    	while(o){
    	    		
    	    		for(int j=0;j<i-1;j++){
    		    		System.out.print(block2[j]+" ");
    	    		}
    	    		break;
    	    	}
    	    	while(!o){
    	    		block2[i]=page[i];
    	    		for(int j=0;j<i;j++){
    		    		System.out.print(block2[j]+" ");
    		    	
    	    		}
    	    		break;
    	    	}
    	    	System.out.println();
    	}
    
    	int n2=0;
    	int b;
    	for(int i=number;i<p;i++){//内存块已满,淘汰页号算法
    		boolean e2=false;
    		for(int j=0;j<number;j++){
    			if (page[i]==block2[j]){
    				e2=true;
    				n2++;
    				b=j;
    				int z=block2[b];
    				for(int f=b+1;f<number;f++){
    					block2[f-1]=block2[f];
    					}
    				block2[number-1]=z;
    				break;
    				}
    			
    			}
    	if(e2){
    		
    		for(int m=0;m<number;m++){
    		
    			System.out.print(block2[m]+" ");
    			
    			}
    	}
    	else{
    				for(int h=1;h<number;h++){
    					block2[h-1]=block2[h];
    				}
    				block2[number-1]=page[i];
    			
    				for(int m=0;m<number;m++){
    					System.out.print(block2[m]+" ");
    					
    			}
    		}
    	System.out.println();
    	}
    	System.out.println("缺页次数:"+(p-n2-yes2)+"次");
    	
    	double g2=(p-n2-yes2)/(double)p;
    	System.out.print("缺页率:");
    	System.out.println(String.format("%.2f",g2));

    最后整体代码我也放到这里啦 (此代码只适合进程页号不小于内存块的情况,本人觉得如果进程页号小于内存块也就没有太大的必要性去研究了)

    import java.util.Scanner;
    
    
    public class Fal {
    
    	public static void main(String[] args) {
    		Scanner in=new Scanner (System.in);
    		System.out.print("请输入内存块数:");
    		int number=in.nextInt();
    		System.out.print("请输入进程页数:");
    		int p=in.nextInt();
    		System.out.print("请输入页面走向:");
    		int [] page=new int [p];//用page数组存储页面走向
    		for(int i=0;i<p;i++){
    			page[i]=in.nextInt();
    	}
    		System.out.print("页面走向为:");
    		for(int i=0;i<p;i++){
    			System.out.print(page[i]+" ");	
    		}
    		System.out.println();
    		
    		
    	
    		
    			System.out.println(" FIFO页面置换算法");	//从这儿开始是FIFO算法
    			System.out.println("各物理块中的页号情况");	
    			
    		     int yes=0;
    		     int [] block=new int [number];//blcok数组是用来存放内存块内数据的,在这里先往内存块内存放数据,将内存块填满
    		     block[0]=page[0];//最开始的时候,block里面是空的,所以可以直接进程页号可直接调入内存块中
    		     System.out.println(block[0]);
    		     int x=1;
    	
    		     for(int i=1;i<number;i++){//for循环将进程页号调入数组
    		    	 boolean o=false;
    		    	
    		    	 
    		    	for(int m=0;m<i;m++){//本层循环来判断内存中是否已经存在要使用的进程的页号
    		    	if (block[m]==page[i]){
    		    		yes++;//如果内存块中存在要调用的页号,则非缺页次数加一
    		    		o=true;}
    		    	}
    		    	while(o){
    		    		for(int j=0;j<x;j++){//输出此时内存块中的页号情况,由于此时内存块中并未赋新值,所以内存块中的情况依旧是上一轮循环后的结果。
    			    		System.out.print(block[j]+" ");
    		    		}
    		    		break;
    		    	}
    		    	while(!o){
    		    		block[i]=page[i];//如果内存中不存在要调用的页号,则将新页号调入内存块
    		    		x++;//x用来统计已调入的页号个数,如果调入了新的页号,则x++;方便输出。
    		    		for(int j=0;j<x;j++){
    			    		System.out.print(block[j]+" ");
    			    	
    		    		}
    		    		break;
    		    	}
    		    	System.out.println();
    		}
    		     
    		   
    		int s=0;
    		int n=0;
    		for(int i=number;i<p;i++){//内存块被装满后
    			boolean e=false;
    			for(int j=0;j<number;j++){
    				if (page[i]==block[j]){
    					e=true;
    					n++;}//非缺页变量
    				
    				}
    		if(e){
    			for(int m=0;m<number;m++){//输出此时内存块中的已有页号
    				System.out.print(block[m]+" ");
    				
    				}
    		}
    		else{
    					
    					block[s]=page[i];//数组中的页号从block[0]到block[number]
    					s++;
    					if(s==number){
    						s=0;//当到达数组最大值后,s再变为0,新的一轮淘汰开始
    					}
    					for(int m=0;m<number;m++){
    						System.out.print(block[m]+" ");
    						
    				}
    			}
    		System.out.println();
    		}
    		     
    		     
    		System.out.println("缺页次数:"+(p-n-yes)+"次");//非缺页次数由n和yes两部分组成
    	
    		double g=(p-n-yes)/(double)p;
    		System.out.print("缺页率:");
    		System.out.println(String.format("%.2f",g));
    		     
    		    
    		System.out.println("_________________________________");
    		System.out.println("  LRU 页面置换算法");
    		System.out.println("采用栈保存的方法");
    		    
    		int yes2=0;
    		int y=0;
    	     int [] block2=new int [number];//block2数组来存放内存块内的页号。方法与FIFO相同
    	     block2[0]=page[0];
    	     System.out.println(block[0]);
    	     x=1;
    	     for(int i=1;i<number;i++){
    	    	 boolean o=false;
    	    	for(int m=0;m<i;m++){
    	    	if (block2[m]==page[i]){//如果页号已经在内存块内
    	    		yes2++;//非缺页变量加一
    	    		o=true;
    	    		y=m;
    				int z=block2[y];//当页号已在内存块中时,将此页号提到栈顶,其余页号往栈底推
    				for(int f=y+1;f<x;f++){
    					block2[f-1]=block2[f];
    					}
    				block2[x-1]=z;
    				break;
    	    		}
    	    	}
    	    	while(o){
    	    		
    	    		for(int j=0;j<x;j++){
    		    		System.out.print(block2[j]+" ");
    	    		}
    	    		break;
    	    	}
    	    	while(!o){
    	    		block2[i]=page[i];
    	    		x++;
    	    		for(int j=0;j<x;j++){
    		    		System.out.print(block2[j]+" ");
    		    	
    	    		}
    	    		break;
    	    	}
    	    	System.out.println();
    	}
    
    	int n2=0;
    	int b;
    	for(int i=number;i<p;i++){//内存块已满,淘汰页号算法
    		boolean e2=false;
    		for(int j=0;j<number;j++){
    			if (page[i]==block2[j]){
    				e2=true;
    				n2++;
    				b=j;
    				int z=block2[b];
    				for(int f=b+1;f<number;f++){
    					block2[f-1]=block2[f];
    					}
    				block2[number-1]=z;
    				break;
    				}
    			
    			}
    	if(e2){
    		
    		for(int m=0;m<number;m++){
    		
    			System.out.print(block2[m]+" ");
    			
    			}
    	}
    	else{
    				for(int h=1;h<number;h++){
    					block2[h-1]=block2[h];
    				}
    				block2[number-1]=page[i];
    			
    				for(int m=0;m<number;m++){
    					System.out.print(block2[m]+" ");
    					
    			}
    		}
    	System.out.println();
    	}
    	System.out.println("缺页次数:"+(p-n2-yes2)+"次");
    	
    	double g2=(p-n2-yes2)/(double)p;
    	System.out.print("缺页率:");
    	System.out.println(String.format("%.2f",g2));
    		
    	}
    		
    
    }
    
    

     

    本代码重复性高,且十分繁琐。但是由于本小媛技术不精,现在的能力也只能写成这样了,此后,等本小媛修炼一番,会对次代码进行优化。欢迎路过的各位大佬们,批评指点。

     

     

    展开全文
  • 回顾几种分配策略: 固定分区分配 ...一进程占用的物理页面总数是限定的,当需要置换时,即总数已经用完,新进来一页面,本进程就需要出去一老的页面。所谓,朋友圈就那么大,有人进来自然需要...

    回顾几种分配策略:

    • 固定分区分配
    • 动态分区分配
    • 伙伴系统
    • 可重定位分区分配

    页面置换策略:

    • 全局置换
    • 局部置换

    其中,关于分区分配策略已经很熟悉了,需要特别说明的是页面置换策略。这是我们在课本上不太强调的。

    局部置换只置换本进程内的物理页面。一个进程占用的物理页面总数是限定的,当需要置换时,即总数已经用完,新进来一个页面,本进程就需要出去一个老的页面。所谓,朋友圈就那么大,有人进来自然需要有人出去。但是需要注意的是,如果分配给你的总数还没用完,自然是不用置换的,那是最初的红利时期,竞争还不激烈,先到先得。

    全局置换指的是进程缺页时,可能置换的是内存中所有可换出的物理页面。即要换进的是A进程的页面,出去的可以是B进程的页面,因此分配给进程的页面总数是动态变化的。

    这两种总的置换策略下有各自的方法:

    • 局部置换:

      • 最优算法
      • 先进先出算法(有Belady异常)
      • Least Recently Used(最近最久未使用算法)
      • 时钟算法
      • 最不常用算法(Least Frequently Used)算法
    • 全局置换:

      • 工作集算法
      • 缺页率算法

    (2015.30) 请求分页系统中,页面分配策略和页面置换策略不能组合使用的是: C C C

    A. 可变分配,全局置换
    B. 可变分配,局部置换
    C. 固定分配,全局置换
    D. 固定分配,局部置换

    分析
    固定分配:将内存用户空间划分为多个固定大小的区域,在每个分区中只装入一个作业。
    划分分区的方法有两种:

    • 分区大小相等
    • 分区大小不等

    内存分配方法:按照分区大小建立分区使用表。记录每个分区的起始地址,大小和状态。

    因此,固定分配不可能实现跨越进程的页面分配,个人自扫门前雪类型。

    动态分区分配:根据进程的实际需要,动态地为之分配内存空间。
    这句话不可以简单跳过,根据的是进程的需要,进程是动态的,是一次静态程序的执行过程。

    为了实现这个,需要建立空闲分区表和空闲分区链。空闲分区表自然也是记录分区区号,分区起始地址和大小等。分区可以是离散的,因此需要链表来维护分区之间的关系。

    分配内存:根据某种分配算法(首次适应,循环首次适应,最佳适应,最坏适应,快速适应等),从空闲分区链中找到需要的分区,根据一个算式:
    m.size−u.size≤sizem.size−u.size≤size,其中m.size是每个空闲分区的大小,u.size是请求的分区大小,size是规定的不可再切割的剩余分区的大小。即,如果分配完以后,剩余部分小于size这条线了,那么就把整个分区给你,否则,你只能拿到你所需要的。也即是超过一定量的交易额是大客户,待遇要好于小客户。

    从这个过程中我们可以看到,空闲分区没有属于哪个进程的概念,即大家是吃大锅饭的。则在实现分页系统时,可以实现全局分配。局部分配是基础配置,自然不必多说。

    因此,C项是无法组合在一起使用的。

    转载自:https://blog.csdn.net/u011240016/article/details/53128209

    展开全文
  • 操作系统实验3实现请求分页系统中页面置换算法【最新】.doc
  • 题目描述:请求分页系统中的置换算法 1.通过如下方法产生一指令序列,共 320 条指令。 A. [1,32k-2]的指令地址之间随机选取一起点M,访问 M; B. 顺序访问M+1; C. [0,M-1]随机选取M1,访问 M1; D. 顺序...
  • 虚拟存储器与请求分页系统详解

    千次阅读 2022-03-15 14:44:55
    驻留性:作业装入内存后,便一直驻留内存,直至作业运行结束 问题:一次性及驻留性程序运行时是否是必须的? 2、程序运行的局部性原理 3、虚拟存储器的定义 基于局部性原理,应用程序运行前,没有必要...
  • 模拟一作业的执行过程,该作业有320条指令,即它的地址空间为32,目前所有还没有调入内存。 1.2 功能描述 - 模拟过程,如果所访问指令内存,则显示其物理地址,并转到下一条指令;如果没有内存...
  • 操作系统请求分页

    2017-12-04 21:27:41
    为了简单起见。页面淘汰算法采用 FIFO页面淘汰算法,并且淘汰一时,判断它是否被改写过,如果被修改过,将它写回到辅存。
  • 请求分页系统是建立基本分页基础上的,为了能支持虚拟存储器功能,而增加了请求调功能和页面置换功能。 相应地,每次调入和换出的基本单位都是长度固定的页面。因此,请求分页便称为目前最常用的一种实现虚拟...
  • OS- -请求分页系统、请求分段系统和请求段式系统(一) 文章目录OS- -请求分页系统、请求分段系统和请求段式系统(一)一、内存管理的概念二、内存空间的扩充覆盖与交换三、内存空间的分配和回收连续分配管理方式非...
  • 请求分页管理方式及页面分配策略

    千次阅读 2021-08-30 21:10:15
    一、请求分页管理方式 请求分页 存储管理与基本分页存储管理的主要区别: ①、程序执行过程,当所访问的信息不内存时,由操作系统负责将所需信息从外存调入内存【操作系统...在请求分页系统中,每当要访问的
  • 模拟请求分页系统中的地址变换过程 创建请求页表,通过编程模拟缺页中断和地址变换,实现请求调功能和页面置换功能。 环境 JDK8+eclipse 步骤 (一)请求页表及快表的创建 0 1 2 3 4 5 页号 物理块号 状态...
  • 1) 实现请求分页存储管理方式的页面置换算法:近期最少使用算法(LFU) 2) 内存物理块数固定为15,对多作业采用可变分配全局置换的策略分配物理块 3) 作业数量与作业大小(10-20)可界面进行设置 4) 所有...
  • c++ 请求分页系统 数据结构完善
  • 【单选题】一分段存储管理系统中,逻辑地址长度为32位,其中段号占11位,则段长最大____字节。【单选题】分页式虚拟存储管理系统中,一般来说页面的大小与可能产生缺页中断的次数_____。【单选题】对式管理页表的...
  • 请求分页虚拟存储管理技术是把作业地址空间的全部信息存放磁盘上。当作业被选中运行时,先把作业的开始几装入主存并启动运行。为此为作业建立页表时,应说明哪些主存,哪些主存。
  • 请求分页存储管理系统设计与实现可课程设计

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,328
精华内容 40,931
关键字:

在请求分页系统中16个页