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