首页 > 试题广场 >

页面走向:4 3 2 1 4 3 5 4 3 2 1 5 4

[单选题]
页面走向:4 3 2 1 4 3 5 4 3 2 1 5 4,当分配的内存物理快数4(开始为装入),采用LRU淘汰算法,产生多少次缺页?
  • 8
  • 9
  • 10
  • 12
4 3 2 1 4 3 5 4 3 2 1 5 4
缺页的是加粗加下划线的数字,答案是9次

发表于 2015-01-22 19:06:58 回复(0)
更多回答
LRU:最近最少使用淘汰算法.
就像排队,被叫到但是队中没有就缺了,被叫到的队中有则不缺,再把其放在队尾,继续叫号。
缺页为:
4              缺1
4  3          缺1
4  3  2      缺1
4  3  2  1  缺1
3  2  1  4  不缺
2  1  4  3  不缺
1  4  3  5  缺1
1  3  5  4  不缺
1  5  4  3  不缺
5  4  3  2  缺1
4  3  2  1  缺1
3  2  1  5  缺1
2  1  5  4  缺1
发表于 2015-04-08 10:17:28 回复(3)

红色部分即为缺页部分。
过程 大致如下
  1. 刚开始,内存物理块中都没有页面号为 4,3,2,1 的页面。所以,缺页次数为 4 ,然后,依次将这 4 个页面全部调入。
  2. 接着,当页面走向到 4,3 处时,因为前面已经把 4 3 对应的页面调入到内存物理块中了,所以不会导致缺页。
  3. 而到了页面号为5的页面时,因为4个内存物理块中没有5号页面,此时,缺页次数加1。操作系统会选择上次访问时间距当前时间最远的页淘汰,于是2号页面被淘汰。5号页面替换2号页面的位置。
  4. 由此类推,最终置换序列如上图。
编辑于 2017-05-12 17:19:23 回复(1)
import java.util.Scanner;

public class Main {
    
    public static final int MAX_TASK_NUM = 100; 

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        Scanner scan = new Scanner(System.in);
        while(scan.hasNext())
        {
            int ***Blocks = scan.nextInt();
            int[] taskPages = new int [MAX_TASK_NUM];
            int i = 0;
            int page = scan.nextInt();
            while(page != -1)    // 输入结束标志
            {
                taskPages[i++] = page;
                page = scan.nextInt();
            }
            System.out.println(LRU.calMissingPages(***Blocks, i, taskPages));
            
        }
        scan.close();
    }

}

class LRU {

    public static int  calMissingPages(int ***Blocks, int taskNum, int taskPages[])
    {
        int[] *** = new int [***Blocks];  // 缓存
        ***[0] = taskPages[0];           // 预处理,先将第一个作业页面放入缓存
        int ***Pages = 1;                // 已缓存的页面数
        int missingNum = 1;                // 缺页次数
        boolean missingFlag;              // 缺页标志
        for(int i = 1; i < taskNum; i++)
        {
            missingFlag = true;
            for(int j = 0; j < ***Pages; j++)
            {
                if(***[j] == taskPages[i])   // 命中
                {
                    missingFlag = false;
                    int t = ***[j];
                    for(int k = j + 1; k < ***Pages; k++)
                        ***[k - 1] = ***[k];
                    ***[***Pages - 1] = t;
                    break;
                }
            }
            if(missingFlag)            // 未命中
            {
                missingNum++;
                if(***Pages == ***Blocks)   // 缓存已满
                {
                    for(int k = 1; k < ***Pages; k++)
                        ***[k - 1] = ***[k];
                    ***[***Pages - 1] = taskPages[i];
                }
                else    // 缓存未满
                {
                    ***[***Pages] = taskPages[i];
                    ***Pages++;
                }
            }
        }
        return missingNum;
    }
}

发表于 2016-06-15 19:55:03 回复(0)
队头时间使用时间最早,队尾是当前被使用的。被使用的需要移动或者插入到队尾
发表于 2017-05-05 13:18:14 回复(0)