最佳(Optimal)置换算法模拟

定义

       最佳(Optimal)置换算法是指，其所选择的被淘汰页面，将是以后永不使用的，或许是在最长(未来)时间内不再被访问的页面。采用最佳置换算法，通常可保证获得最低的缺页率。但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但可以利用该算法去评价其它算法。

算法过程

       现举例说明如下。

       假定系统为某进程分配了三个物理块，并考虑有以下的页面号引用串：

       7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1

       进程运行时，先将7，0，1 三个页面装入内存。以后，当进程要访问页面2 时，将会产生缺页中断。此时OS根据最佳置换算法，将选择页面7 予以淘汰。这是因为页面0 将作为第5 个被访问的页面，页面1 是第14 个被访问的页面，而页面7 则要在第18 次页面访问时才需调入。下次访问页面0时，因它已在内存而不必产生缺页中断。当进程访问页面3时，又将引起页面1 被淘汰；因为，它在现有的1，2，0 三个页面中，将是以后最晚才被访问的。下图所示出了采用最佳置换算法时的置换图。由图可看出，采用最佳置换算法发生了6 次页面置换。

利用最佳页面置换算法时的置换图

最佳(Optimal)置换算法模拟源代码

package pageturning;

import java.util.ArrayList;
import java.util.List;


public class Optimal {
	/**
	 * 内存块的个数
	 */
	public static final int N = 3;
	/**
	 * 内存块数组
	 */
	private Object[] array = new Object[N];
	//内存块中元素的个数
	private int size;
	//元素i未来longest[i]个单位时间后将被使用
	private int[] longest = new int[N];
		
	//private Object[] procList;
	public Optimal() {
	}
	/**
	 * 判断内存区是否为空
	 * @return
	 */
	public boolean isEmpty() {
		if(size == 0) {
			return true;
		} else {
			return false;
		}
	}
	/**
	 * 判断内存区是否达到最大值
	 * @return
	 */
	public boolean isOutOfBoundary() {
		if(size >=N) {
			return true;
		} else {
			return false;
		}
	}
	/**
	 * 查找元素o在数组中的位置
	 * @param o
	 * @return
	 */
	public int indexOfElement(Object o) {
		for(int i=0; i<N; i++) { 
			if(o == array[i]) {
				return i;
			}
		}
		return -1;
	}	
	/**
	 * 找出未来最久的时间会被调用的元素的序号
	 * @param k 开始调用时的下标
	 * @param procList 整个进程对列的调用过程
	 * @return
	 */
	private int findTransIndex(final int k, final Object[] procList) {
		int transIndex = 0;
		int longest2 = 0;
		for(int j=0; j<size; j++) {
			longest[j] = Integer.MAX_VALUE;
		}
		for(int i=k+1; i<procList.length; i++) {
			for(int j=0; j<size; j++) {				
				if(procList[i] ==  array[j]) {
					if(longest[j] == Integer.MAX_VALUE) {
						longest[j] = i;
						if(longest2 < longest[j])
							transIndex = j;
					}
				} 
			}
		}
		for(int j=0; j<size; j++) {
			if(longest[j] == Integer.MAX_VALUE) {
				transIndex = j;
				break;
			}
		}
		return transIndex;
	}
	/**
	 * 有新的数据o需要申请内存
	 * @return 移出内存区的数据
	 */
	public Object push(Object[] procList, int k) {
		int t = -1; 
		if(!isOutOfBoundary() && indexOfElement(procList[k]) == -1){
			array[size] = procList[k];
			size ++;
		} else if(!isOutOfBoundary() && indexOfElement(procList[k]) != -1) { 
			t = indexOfElement(procList[k]);
		} else if(isOutOfBoundary() && indexOfElement(procList[k]) == -1){
			int transIndex = findTransIndex(k, procList);
			array[transIndex] = procList[k];
			t = transIndex;
		} else if(isOutOfBoundary() && indexOfElement(procList[k]) != -1){
			
		} 
		if( -1 == t) {
			return null;
		} else {
			return array[t];
		}
	}
	/**
	 * 输出内存区中的各数据
	 */
	public void showMemoryBlock() {
		for(int i=0; i<size; i++) {
			System.out.print(array[i] + "        ");
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Integer iter[] = {7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
		Optimal optimal = new Optimal();
		for(int i=0; i<iter.length; i++) {
			optimal.push(iter, i);
			optimal.showMemoryBlock();
			System.out.println();
		}
	}

}

输入 7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1时，结果如下：

7        
7        0        
7        0        1        
2        0        1        
2        0        1        
2        0        3        
2        0        3        
2        4        3        
2        4        3        
2        4        3        
2        0        3        
2        0        3        
2        0        3        
2        0        1        
2        0        1        
2        0        1        
2        0        1        
7        0        1        
7        0        1        
7        0        1