精华内容
下载资源
问答
  • c++实现操作系统请求调页功能 分别有FIFO LRU 和OPT 算法
  • 操作系统OPT FIFO LRU

    2009-12-21 09:11:44
    操作系统 OPT FIFO LRU 算法,有详细注释
  • 页面置换 先进先出 FIFO LRU 已经运行测试过了,下载后可以直接运算
  • C语言 操作系统 请求分页 OPT FIFO LRU算法
  • 存储管理详细实验报告和cpp文件,含FIFOLRU的比较,实验报告都是我一个一个字敲进去的。
  • 第 PAGE 8 页 共 NUMPAGES13 页 操作系统原理 上机作业报告 作业 页 面 淘 汰 算 法 作业编号 6 题目 页面淘汰/置换算法 作业要求 题目要求通过模拟...针对一个页框根据实验数据以OPT算法为参考研究FIFO页面淘汰算法LRU
  • 1 FIFO算法(先进先出) 2 2 最近最久未使用算法(LRU算法)基本思想 2 二 程序设计 2 1 数据结构设计 2 2 函数设计 3 3 流程图 5 1 FIFO算法设计流程图 5 2 LRU 算法设计流程图: 6 三 代码 8 四 结果分析 12 五 ...
  • vc++ 6.0实现页面替换算法FIFOLRU,界面优美,实现了功能。
  • 操作系统实验的作业,做完了,给大家分享分享
  • } public static void LRU(int len , int page[]){ int block[] = new int[len]; double hit = 0; int key = 0; int m=0; for(int i =0;i;i++){ if(m>=block.length) { for(int j=0;j;j++){ if(block[j]==page[i]){...
        
        public static void OPT(int len ,int page[]){
          int block[] = new int[len];
          double hit = 0;
          int key = 0;
          int m =0;
          for(int i =0;i<page.length;i++){
              if(m>=block.length){
                for(int j=0;j<block.length;j++) {
                  if(block[j]==page[i]){
                      hit++;
                      System.out.println("命中");
                      key = 1;
                      break;
                  }
               }
                 if(key==1) 
               {
                   key = 0;
                   continue;
               }
                 else{
                     int temp[] =  new int[block.length];
                     Arrays.fill(temp, page.length);
                     for(int f=0;f<block.length;f++){
                         for(int k=i;k<page.length;k++){
                             if(block[f]==page[k]){
                               temp[f] = k;
                               break;
                             }
                     }
                    }
                     int tag=0;
                     for(int u=0;u<temp.length;u++){
                       if(temp[u]>temp[tag]) tag = u;
                     }
                     System.out.println(block[tag]+"->"+page[i]);
                     block[tag]=page[i];
               }
                   
              }
              else {
                for(int j=0;j<m;j++) {
                  if(block[j]==page[i]){
                      hit++;
                      System.out.println("命中");
                      key = 1;
                      break;
                  }
               }
               if(key==1) 
                {
                    key = 0;
                    continue;
                }
                else {System.out.println("*null->"+page[i]);block[m]=page[i];m++;}
                }
          
        }
        System.out.println("命中率= "+hit/page.length);
      }
    
     public static void LRU(int len , int page[]){
            int block[] = new int[len];
            double hit = 0;
            int key = 0;
            int m=0;
            for(int i =0;i<page.length;i++){
               if(m>=block.length) {
                  for(int j=0;j<block.length;j++){
                     if(block[j]==page[i]){
                        hit++;
                        System.out.println("命中");
                        int temp = block[j];
                        for(int v=j;v<block.length-1;v++) block[v]=block[v+1];
                        block[block.length-1]=temp;
                        key = 1;
                        break;
                       }
                    }
    
                    if(key==1) 
                         {
                             key = 0;
                             continue;
                         }
                         else{
                               System.out.println(block[0]+"->"+page[i]);
                               for(int j=0;j<block.length-1;j++) block[j]=block[j+1];
                               block[block.length-1]=page[i];
                         }      
                    
                }
                else {
                  for(int j=0;j<m;j++) {
                    if(block[j]==page[i]){
                        hit++;
                        System.out.println("命中");
                        key = 1;
                        break;
                    }
                 }
                 if(key==1) 
                  {
                      key = 0;
                      continue;
                  }
                  else {System.out.println("*null->"+page[i]);block[m]=page[i];m++;}
                  }
              }
                System.out.println("命中率= "+hit/page.length);
        }
    
    
      public static void FIFO(int len,int page[]){
              int block[] = new int[len];
              double hit=0;
              int key=0;
              int m =0;
              for(int i =0;i<page.length;i++){
                  if(m>=block.length) {
                       for(int j=0;j<block.length;j++) {
                           if(block[j]==page[i]){
                               hit++;
                               System.out.println("命中");
                               key = 1;
                               break;
                           }
                        }
                        if(key==1) 
                         {
                             key = 0;
                             continue;
                         }
                         else{
                               System.out.println(block[0]+"->"+page[i]);
                               for(int j=0;j<block.length-1;j++) block[j]=block[j+1];
                               block[block.length-1]=page[i];
                        }
    
                       }
                    else {
                      for(int j=0;j<m;j++) {
                        if(block[j]==page[i]){
                            hit++;
                            System.out.println("命中");
                            key = 1;
                            break;
                        }
                     }
                     if(key==1) 
                      {
                          key = 0;
                          continue;
                      }
                      else {System.out.println("*null->"+page[i]);block[m]=page[i];m++;}
                      }
              }
    
              System.out.println("命中率= "+hit/page.length);
        }
    

    测试代码请自行编写 ,这里OPT算法中用了一个额外的数组用来标记接下来页面中该数据出现的位置,然后通过这个标记值判断替换哪个,是我自己想出来觉得还不错的一个方法,没有标注注释,请谅解,不明白的可以评论区发言,我会抽时间看的。

    展开全文
  • Microsoft Visual Studio 2005.net开发 C#编写 操作系统内存调度FIFO算法 LRU算法 OPTIMAL算法 适用于操作系统课程设计
  • 设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率: 要求设计主界面以灵活选择某算法,且以下算法...1、先进先出算法(FIFO) 2、最近最久未使用算法(LRU) 3、最佳置换算法(OPT)
  • 自己写的 希望有错提出来 期中那个OPT写的不是很好,希望可以多多指教
  • String str2=JOptionPane.showInputDialog("1FIFO算法\n2LRU算法\3退出\n"); int s=Integer.parseInt(str2); if(s==1){ tmp.fifo(); } else if(s==2){ tmp.lru(); } else{ ...
    </pre><pre name="code" class="java">import javax.swing.JOptionPane;
    public class yemian {
    	 private static final int job_size=240800;
    	 private static int psy_size[];
    	 private static int psy_rep;
    	 private static int kuai_ge=0;
    	 private static int psy_wei[];
    	 public yemian(){
    		 psy_size=new int[3];
    		 psy_wei=new int[3];
    		 psy_rep=0;
    		 for(int i=0;i<3;i++)
    			 psy_size[i]=-1;
    		 for(int i=0;i<3;i++)
    			 psy_wei[i]=0;
    	 }
    	 public void menuA(){
    		 System.out.println("物理块的使用情况");
    		 System.out.println("物理块号 , 页面号");
    		 for(int i=0;i<psy_size.length;i++){
    			 System.out.println("  "+i+"       "+psy_size[i]);
    		 } 
    	 }
    	 public void menuB(){
    		 System.out.println("物理块的使用情况");
    		 System.out.println("物理块号 , 页面号, 最近访问次数");
    		 for(int i=0;i<psy_size.length;i++){
    			 System.out.println("  "+i+"      "+psy_size[i]+"     "+psy_wei[i]);
    		 } 
    	 }
    	 public void fifo(){
    		 while(true){
    			 int i;
    			 int kuai_pos = 0;
    			 String log=JOptionPane.showInputDialog("请输入逻辑地址(-1 exit)");
    			 int log_add=Integer.parseInt(log);
    			 if(log_add >= job_size){
    				 System.out.println("逻辑地址访问越界!");
    			 }
    			 else if(log_add == -1){
    				break; 
    			 }
    			 else{
    				 int page_pos=log_add/1024;          //页面位置
    				 int page_psy=log_add%1024;
    		         for(i=0;i<psy_size.length;i++){
    		        	 if(psy_size[i]==page_pos){
    		        		 kuai_pos=i;                 //查找物理块中是否存在该页面
    		        		 break;
    		        	 }
    		         }
    		         if(i==3){
    		        	 System.out.println("page "+page_pos+" 不存在物理块中 已经调入 ");
    		        	 psy_size[kuai_ge]=page_pos;
    		        	 kuai_pos=kuai_ge;               //kuai_pos位置
    		        	 kuai_ge++;
    		        	 kuai_ge%=3;  	                 //fifo记录位置
    		         }
    		         else{
    		        	 System.out.println("page "+page_pos+" 存在物理块中");
    		         }  
    			 }
    			 menuA();
    			 System.out.println("块号  "+kuai_pos+" 物理地址"+(kuai_pos*1024+log_add%1024));
    			 
    		 }
    	 }
    	 public void lru(){
    		 while(true){
    			 int i;
    			 int kuai_pos=0;
    			 int pos=0;
    			 int kuai_ge=Integer.MAX_VALUE;
    			 String log=JOptionPane.showInputDialog("请输入逻辑地址(-1 exit)");
    			 int log_add=Integer.parseInt(log);
    			 if(log_add >= job_size){
    				 System.out.println("逻辑地址访问越界!");
    			 }
    			 else if(log_add == -1){
    				break; 
    			 }
    			 else{
    				 int page_pos=log_add/1024;          //页面位置
    				 int page_psy=log_add%1024;
    				 for(i=0;i<psy_size.length;i++){
    		        	 if(psy_size[i]==page_pos){
    		        		 kuai_pos=i;                 //查找物理块中是否存在该页面
    		        		 break;
    		        	 }
    		         }
    				 if(i==3){
    		        	 System.out.println("page "+page_pos+" 不存在物理块中 已经调入 ");		        	 
    		        	 for(int j=0;j<psy_wei.length;j++){
    		        		 if(kuai_ge > psy_wei[j] ){         //找到最小值
    		        			 pos=j;
    		        			 kuai_ge=psy_wei[j];
    		        		 }
    		        	 }
    		        	 psy_size[pos]=page_pos;
    		        	 psy_wei[pos]=1;
    		        	 kuai_pos=pos;
    				 }
    		         else{
    			        	System.out.println("page "+page_pos+" 存在物理块中");
    			        	psy_wei[i]++;
    			        	kuai_pos=i;
    			      }	 
    		        }
    			 menuB();
    			 System.out.println("块号  "+pos+" 物理地址"+(kuai_pos*1024+log_add%1024));  
    			 } 
    		 } 
    
    	 
    	 public static void main(String[] args) {
    		yemian tmp=new yemian();
    		System.out.println("物理块大小1kb 作业大小20kb");
    		System.out.println("物理块共有三块");
    		while(true){
    			String str2=JOptionPane.showInputDialog("1FIFO算法\n2LRU算法\3退出\n");
    			int s=Integer.parseInt(str2);
    			if(s==1){
    				tmp.fifo();		
    			}
    			else if(s==2){
    				tmp.lru();
    			}
    			else{
    				System.exit(0);
    			}
    		}
    	}
    }
    

    展开全文
  • 缓存是稀缺资源,通常可看做queue map。加入缓存 即入队,失效缓存 即出队,缓存容量即队列长度。...1. FIFO:First In First Out,先进先出。 2. LRU:Least Recently Used,最近最少使用。缓存命中

       

       缓存是稀缺资源,通常可看做queue或者map。对于queue,加入缓存 即入队,失效缓存 即出队,缓存容量即队列长度。 


       队列满时,数据A要加入缓存,必须先在缓存池中淘汰某一缓存。


      于是有了缓存淘汰策略,主要包括下属三种:


    1. FIFO:First In First Out,先进先出。


    2. LRU:Least Recently Used,最近最少使用。缓存命中时 会将命中缓存放置到队尾。


    3. LFU:Least Frequently Used,最不经常使用。需要记录每个缓存的命中次数,淘汰缓存时失效命中次数最小的缓存。


    展开全文
  • 共四种:FIFO\LRU\LFU\OPT 。在VC环境下运行完全成功。 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。本实验目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储...
  • 实验四 页式虚拟存储管理中地址转换和页式中断 FIFO 一实验目的 深入了解页式存储管理如何实现地址转换进一步认识页式虚拟存储管理中如何处理缺页中断以及页面置换算法 二实验主要内容 编写程序完成页式虚拟存储管理...
  • 只是个比较好的代码 我用了感觉不错 所以推荐了
  • 内存给进程分配物理块,页面需放入物理块中。当要访问的页面在物理块中,表示命中;否则,需要将物理块中的某页面置换出来,将...FIFO:先进先出 页面置换算法 当物理块已满,而当前访问的页面不在物理块中,则将...

    内存给进程分配物理块,页面需放入物理块中。当要访问的页面在物理块中,表示命中;否则,需要将物理块中的某页面置换出来,将当前页面放进去即置换。

    缺页率=(页面置换次数+物理块数)/访问的页面总数

    一般我们将内存中的初始物理块置为0,将页面依次累加放入,即将物理块数合并进页面置换次数中。

    FIFO:先进先出 页面置换算法   

             当物理块已满,而当前访问的页面不在物理块中,则将最先进入物理块的页面置换出来。

             小窍门:新加入的页面永远放最上面,从下面出的永远是最先加入的页面。

    LRU:最近最少使用页面置换算法(节省容量不大的内存为最多的进程提供资源)

              当物理块已满,而当前访问的页面不在物理块中,则比较分析此时物理块中的页面,在访问队列中的位置离当前页面越近表示最近被访问过,越远表示最近最少使用,就将那个页面置换掉,此时要访问的页面替补上。

    ORT:最优/最佳置换算法(未来最长时间不会被使用)

              当物理块已满,而当前访问的页面不在物理块中,则比较分析此时物理块中的页面,在访问队列中的位置离当前页面越远表示接下来最长时间不会被使用,就将那个页面置换掉,此时要访问的页面替补上。最后一个页面要替换就直接替换页面在前面序列中离它最近的即可。

     

    展开全文
  • 先进先出页面置换算法(FIFO) 最近最久未使用页面置换算法(LRU) 最佳置换页面置换算法(OPT) 专题:设计一个虚拟存储区和内存工作区,编程序演示以上三种算法的具体实现过程,并计算访问命中率。演示页面置换...
  • vector<int >::iterator flag = find(fifo.begin(),fifo.end(),PageOrder[i]); if (flag==fifo.end()) { l++; if (fifo.size()) { //头插入 fifo.push_back(PageOrder[i]); } else{ ...
  • * 维护两种淘汰策略(FIFO LRU)的高速缓存 * * @author DPn!ce date 2018 07 12 上午 10:19 */ public class FastCache, V> { private final static Logger log = Logger.getLogger(FastCache.class); /** * ...
  • FIFO算法: 最先进宫的妃子, 皇帝已经约会过了, 很久远了, 皇帝可能不会再约会了, 所以驱逐出宫, 换成新的漂亮妃子, 那么在皇帝看来, 就有了1001个妃子, 如此不断置换, 是可以达到3000个妃子的。...
  • 页面置换算法OPT+FIFO+LRU+clock

    热门讨论 2012-12-31 12:06:40
    C语言 页面置换算法 OPT FIFO LRU clock
  • 页面替换 opt fifo lru clock,实验代码+实验报告

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,144
精华内容 9,657
关键字:

fifolru