memory.java

模拟操作系统的存储过程

import java.util.LinkedList;
import java.math.*;
import javax.swing.*;


public class Memory {
	private  int[] esm = new int[10];
	private static int[] order = new int[100];
	private List list;
	private String input , output = "指令序列为:";
	private int max;
	private static int choose;
	
	
	public Memory() //构造函数
	{
		input = JOptionPane.showInputDialog("please input the number of ESM-memory:");//输入内存的大小
		max = Integer.parseInt( input ); // max记录内存的大小
		
		for( int i = 0 ; i < 100 ; i++) //生成指令序列
		{
			order[i] = (int)( 1 + 8*Math.random() );//指令为一个1~9的随机整型数
			if( i % 10 == 0 )
			output += " \n ";
			output += order[i] + "   ";
			
	    }
		for( int j = 0 ; j < 10 ; j++) //初始时将内存中所有元素为零
		esm[j] = 0;
		list = new List();
		
		JOptionPane.showMessageDialog( null , output );//输出指令序列

	}
	
	public float opt() //最佳淘汰算法，返回一浮点数为命中率
	{
		float miss = 0; //初始状态时内存为空，失败次数为内存中的
	    
		for( int i = 0 ; i < 100 ; i++ )
		  {
		    
		    if( !optcompare( order[i] )  ) //判断该指令是否在内存中
		    
		    {
		    	optreplace( order[i] );//如果不在用最佳淘汰算法替
		    	miss++;    // 失败次数加一
		    }
	      }
	    return ( (100-miss)/100 ); // 返回命中率 
     }
     
     public boolean optcompare(  int k ) //判断内存中是否存在k这条指令
     {
     	for( int i = 0 ; i < max ; i++)
     	{
     		if( esm[i] == k )
     		return true;
     	}
     	return false;
     }
     
     public void optreplace( int elem ) //用最佳淘汰策略用elem更换内存中的元素
     {  
        int temp = 0;
     	int[] index = new int[10];//记录内存中的各元素，在未来的指令序列中出现的最近位置
     	for( int m = 0 ; m < 10 ; m++ ) //初始化为零
     	 index[m] = 0;
     	
     	for( int i = 0 ; i < max ; i++ ) //记录未来指令中第一次出现的位置
     	for( int j = 0 ; j < 100 ; j++ )
     	  if( esm[i] == order[j])
     		{
     			index[i] = j;
     		    break;
        	}
        for( int n = 0 ; n < 10 ; n++ ) //进行替换
         {
         	if( index[n] == 0 ) //未来指令中没有这条指令则首先替换它
              {
              	esm[n] = elem;
                break;
               } 
            else
              if( index[n] >= index[n+1] ) //将位置最远的指令替换
                temp = n;
                
             esm[temp] = elem;
          
         }
     		
     }
     
    public float lru() //最近最少使用淘汰算法，返回一浮点数为命中率
    {
    	 float miss = 0;
    	 int laji ,tmp = 0;
    	 
    	 
    	 for( int i = 0 ; i < 100 ; i++ )
		  {
		    
		    if( !( list.lrucompare( order[i] ) ) && list.getSize() == max )
		      //如果该指令不在内存中并且内存已满
		    {
		    	laji = list.removeFromFront();//淘汰内存中的第一个元素
		    	list.insertAtBack( order[i] );//将新指令插入内存中的最后一个位置
		    	miss++;//失败次数加一
		    }
		    else if( list.lrucompare( order[i]) && list.getSize() == max )
		      //如果该指令在内存中，将内存中的该指令转移到内存中的最后一个位置
		    {
		    	
		    	tmp = list.remove( order[i] );
		    	list.insertAtBack( tmp );
		    }
		    else if( list.getSize() < max )
		      //如果内存未满，将指令放入内存
		    {
		    	list.insertAtBack( order[i] );
		    	if( !(list.lrucompare( order[i] ) ) ) //内存中没有该指令
		    	miss++;
		     }
		    
		    
	      }
	    return ( (100-miss)/100 ); //返回命中率 
    }
    

	
	public static void main( String args[] )
	{
		float n = 0;
		String inputchoose;  //记录用户所选淘汰算法
		inputchoose = JOptionPane.showInputDialog( "请输入淘汰算法( 1 代表OPT 2 代表LRU ):" );
		choose = Integer.parseInt( inputchoose );
		
	   Memory app = new Memory();
	   if( choose == 1 )
	   n = app.lru(); //调用最佳淘汰算法
	   if( choose == 2 )
	   n = app.lru(); //调用最近最少使用淘汰算法
	   JOptionPane.showMessageDialog( null , "命中率为:" + n );
	   
	}
	
	
}