最佳(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