cache—主存—辅存三级调度模拟

近日，在体系结构的课程中，老师留了一个上机作业，为cache—主存—辅存三级调度模拟，要求如下：

实现三级存储体系的模拟调度程序

描述：CPU在cache访问数据块，若命中给出对应的cache实地址，若不命中在主存中查找，如果找到调入到cache中，若是cache已满使用LRU算法进行替换，采用写回法保持cache与主存的一致性。若是没有命中在辅存中查找，找到之后调入到主存，并更新cache。

实验要求：

（1）主存的容量可以更改

（2）分配给程序的页面数可以更改

（3）Cache采用组相连映像，cache大小、组数、组内块数均可以更改

（4）地址流可以采用输入的方式给出

（5）辅存部分可以不用实现

（6）要求有图形化的用户界面，上述参数均可以直接输入。

（7）显示执行程序时数据块以及页面的替换过程

（8）编程语言：选取自己熟悉的高级语言

百度了很久，没有找到Cache组相联映像的LRU替换算法，以下只是自己的一点想法与思路，若有不足，欢迎指正。

程序运行界面如下：

　　

　点击确定后：

　　

第0组Cache块中各个块的使用情况为：
T1时刻 1
T2时刻 1
T3时刻 1 4
T4时刻 4 1
T5时刻 4 1
T6时刻 4 1
T7时刻 1 0
T8时刻 0 1
T9时刻 0 1
T10时刻 1 5
T11时刻 5 4
T12时刻 5 4
T13时刻 5 4
T14时刻 5 4
T15时刻 5 4

第1组Cache块中各个块的使用情况为：
T2时刻 2
T3时刻 2
T4时刻 2
T5时刻 2 3
T6时刻 3 7
T7时刻 3 7
T8时刻 3 7
T9时刻 7 2
T10时刻 7 2
T11时刻 7 2
T12时刻 2 6
T13时刻 2 6
T14时刻 6 7
T15时刻 7 2

下面是Cache类的代码，主要实现Cache的LRU替换算法，使用LinkedHashMap本身自带的特性实现的LRU算法

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 模拟Catch块中的LRU替换算法
 * 此处使用java中LinkedHashMap,利用其自身特性，对removeEldestEntry()方法进行重写
 * @author SUIXUE
 *
 */
public class Cache {
    
    public  int cacheSize = 2;
    
    public Cache(){
        
    }
    
    public Cache(int cacheSize){
        this.cacheSize = cacheSize;
    }
    
    //此处的写法避免了新建类，也无需继承
    Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>((int) Math.ceil(cacheSize / 0.75f) + 1, 0.75f, true) {
        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        @Override
        protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > cacheSize;
        }
    };
    
    /**
     * 重写toString()方法
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<Integer, Integer> entry : this.map.entrySet()) {
            sb.append(String.format("%s   ", entry.getKey()));
        }
        return sb.toString();
    }
    
    /**
     * 此处的主要目的是在Cache中采用组相联映像时，在输出结果时同时显示当前时间
     * @param addr
     * @return
     */
    public String display(int[] addr){
        StringBuilder sb = new StringBuilder();
        int index =15-addr.length+1;
        for(int i = 0; i < addr.length;i++){
            this.map.put(addr[i], 0);
            sb.append("T").append(index++).append("时刻   ").append(this.toString()+"\n");
        }
        return sb.toString();
    }
}

下面是主界面的代码

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

/**
 * MainFrame类： 继承JFrame，同时实现接口ActionListener
 * 
 * @author SUIXUE
 * 
 */
public class MainFrame extends JFrame implements ActionListener {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private int memory = 0;
    private int page = 0;
    private int memoryQuNum = 0;

    public int cacheSizeNum = 16;
    public int cacheGroupNum = 2;
    public int cacheBlockNumber = 2;

    private int cacheNum = cacheGroupNum * cacheBlockNumber;
    private int memoryBlockNum = 0;
    public int[] addr = new int[] {1,2,4,1,3,7,0,1,2,5,4,6,4,7,2};//默认的地址流，可以在界面文本框中更改

    public Cache[] cache;// 将cache的每组看做一个cache块
    public ArrayList<Integer>[] cacheAddrs;// 每组都有对应的地址流

    /**
     * 初始化Cache分组(本方法是将每个分组看做一个单独独立的Cache块)
     */
    public void initCache() {
        for (int i = 0; i < cache.length; i++) {
            cache[i] = new Cache(cacheBlockNumber);
        }
    }

    /**
     * 初始化地址流
     * 将用户输入的地址流，通过分析，分别对应进入不同的Cache分组中
     */
    public void initAddrs() {
        for (int i = 0; i < cacheAddrs.length; i++) {
            cacheAddrs[i] = new ArrayList<>();
        }
        for (int i = 0; i < addr.length; i++) {
            int temp = addr[i] % this.cacheNum;// 7%4 = 3
            int groupNum = temp / this.cacheBlockNumber;// 3/2 = 1
            
            ArrayList<Integer> arrayList = cacheAddrs[groupNum];
            arrayList.add(addr[i]);// 向各组添加地址流
            
            //当当前地址不对其他组进行影响时，其他组中的Cache地址流其实等同于该时刻仍是它上一次的地址
            if(i != 0){
                for(int j = 0; j < cacheGroupNum;j++){
                    if(j != groupNum && cacheAddrs[j].size()>0){
                        cacheAddrs[j].add(cacheAddrs[j].get(cacheAddrs[j].size()-1));
                    }
                }
            }
        }
    }

    private JPanel mainPanel;

    /**
     * 左侧面板
     */
    private JPanel originalPanel;

    // 主存大小
    private JPanel memoryPanel;
    private JLabel memorySizeLabel;
    private JTextField memorySize;

    // 页面数
    private JPanel pagePanel;
    private JLabel pageNumLabel;
    private JTextField pageNum;

    // cache
    private JPanel cachePanel;

    // cache大小
    private JPanel cacheSizePanel;
    private JLabel cacheSizeLabel;
    private JTextField cacheSize;

    // 组数
    private JPanel cacheGroupSizePanel;
    private JLabel cacheGroupSizeLabel;
    private JTextField cacheGroupSize;

    // 组内块数
    private JPanel cacheBlockNumPanel;
    private JLabel cacheBlockNumLabel;
    private JTextField cacheBlockNum;

    // 按钮
    private JPanel button;
    private JPanel addrPanel;
    private JTextField addrText;
    private JLabel addrLabel;
    private JButton affirm;

    /**
     * 右侧面板
     */
    private JScrollPane scrollPanel;
    private JPanel resultPanel;

    private JLabel display;

    // 右侧转换结果显示框
    private JTextArea resultArea;

    /**
     * 构造函数
     */
    public MainFrame() {
        initComponent();
    }

    // 初始各组件
    private void initComponent() {

        // 设置布局
        mainPanel = new JPanel();
        mainPanel.setLayout(new GridLayout(1, 2));

        // --------左侧面板---------------
        originalPanel = new JPanel();
        originalPanel.setLayout(new BorderLayout());

        // -------主存面板----------------
        memoryPanel = new JPanel();
        memorySizeLabel = new JLabel("主存容量");
        memorySize = new JTextField(10);
        memorySize.setHorizontalAlignment(JTextField.RIGHT);
        memorySize.setText("32");
        JLabel unitLabel = new JLabel("KB");
        memoryPanel.add(memorySizeLabel, BorderLayout.WEST);
        memoryPanel.add(memorySize, BorderLayout.CENTER);
        memoryPanel.add(unitLabel, BorderLayout.EAST);

        // ---------页面大小面板----------------
        pagePanel = new JPanel();
        pageNumLabel = new JLabel("页面大小");
        pageNum = new JTextField(10);
        pageNum.setHorizontalAlignment(JTextField.RIGHT);
        pageNum.setText("3");
        JLabel unitLabel1 = new JLabel("页");
        pagePanel.add(pageNumLabel, BorderLayout.WEST);
        pagePanel.add(pageNum, BorderLayout.CENTER);
        pagePanel.add(unitLabel1, BorderLayout.EAST);

        JPanel tempPanel = new JPanel();
        tempPanel.setLayout(new GridLayout(2, 1));
        tempPanel.add(memoryPanel);
        tempPanel.add(pagePanel);

        // -----------cache面板---------------
        cachePanel = new JPanel();
        cachePanel.setLayout(new GridLayout(3, 1));
        cachePanel.setBorder(BorderFactory.createTitledBorder("cache"));

        cacheSizeLabel = new JLabel("cahce大小");
        cacheSize = new JTextField(10);
        cacheSize.setHorizontalAlignment(JTextField.RIGHT);
        cacheSize.setText("16");
        JLabel unitLabel2 = new JLabel("KB");
        cacheSizePanel = new JPanel();
        cacheSizePanel.add(cacheSizeLabel, BorderLayout.WEST);
        cacheSizePanel.add(cacheSize, BorderLayout.CENTER);
        cacheSizePanel.add(unitLabel2, BorderLayout.EAST);

        cacheGroupSizeLabel = new JLabel("cahce组数");
        cacheGroupSize = new JTextField(10);
        cacheGroupSize.setHorizontalAlignment(JTextField.RIGHT);
        cacheGroupSize.setText("2");
        JLabel unitLabel3 = new JLabel("组");
        cacheGroupSizePanel = new JPanel();
        cacheGroupSizePanel.add(cacheGroupSizeLabel, BorderLayout.WEST);
        cacheGroupSizePanel.add(cacheGroupSize, BorderLayout.CENTER);
        cacheGroupSizePanel.add(unitLabel3, BorderLayout.EAST);

        cacheBlockNumLabel = new JLabel("组内块数   ");
        cacheBlockNum = new JTextField(10);
        cacheBlockNum.setHorizontalAlignment(JTextField.RIGHT);
        cacheBlockNum.setText("2");
        JLabel unitLabel4 = new JLabel("块");
        cacheBlockNumPanel = new JPanel();
        cacheBlockNumPanel.add(cacheBlockNumLabel, BorderLayout.WEST);
        cacheBlockNumPanel.add(cacheBlockNum, BorderLayout.CENTER);
        cacheBlockNumPanel.add(unitLabel4, BorderLayout.EAST);

        cachePanel.add(cacheSizePanel);
        cachePanel.add(cacheGroupSizePanel);
        cachePanel.add(cacheBlockNumPanel);

        button = new JPanel();
        button.setLayout(new GridLayout(2,1));
        
        addrLabel = new JLabel("块地址流   ");
        addrText = new JTextField(20);
        addrText.setHorizontalAlignment(JTextField.RIGHT);
        addrText.setText("1 2 4 1 3 7 0 1 2 5 4 6 4 7 2");
        addrPanel = new JPanel();
        addrPanel.add(addrLabel,BorderLayout.WEST);
        addrPanel.add(addrText,BorderLayout.CENTER);
        
        JPanel affirmPanel = new JPanel();
        affirm = new JButton("确定");
        affirmPanel.add(affirm,BorderLayout.CENTER);
        
        button.add(addrPanel);
        button.add(affirmPanel);
        affirm.addActionListener(this);

        originalPanel.add(tempPanel, BorderLayout.NORTH);
        originalPanel.add(cachePanel, BorderLayout.CENTER);
        originalPanel.add(button, BorderLayout.SOUTH);

        // --------右侧面板---------------
        resultPanel = new JPanel();
        resultPanel.setLayout(new BorderLayout());

        display = new JLabel("Cache中各个块的使用情况");

        resultArea = new JTextArea();
        resultArea.setEditable(false);
        resultArea.setBorder(BorderFactory.createTitledBorder("RESULT"));

        scrollPanel = new JScrollPane(resultArea);

        resultPanel.add(display, BorderLayout.NORTH);
        resultPanel.add(scrollPanel, BorderLayout.CENTER);

        // -------------------------------------------------------
        mainPanel.add(originalPanel);
        mainPanel.add(resultPanel);
        mainPanel.setBorder(BorderFactory.createTitledBorder("三级调度模拟"));

        this.add(mainPanel);
        this.setTitle("小可爱的三级调度模拟");
        this.setSize(750, 350);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setResizable(false);
        this.setLocationRelativeTo(null);
        this.setVisible(true);

    }

    @Override
    public void actionPerformed(ActionEvent e) {

        try {
            this.memory = Integer.valueOf(memorySize.getText());
            this.page = Integer.valueOf(pageNum.getText());
            this.cacheSizeNum = Integer.valueOf(cacheSize.getText());
            this.cacheGroupNum = Integer.valueOf(cacheGroupSize.getText());
            this.cacheBlockNumber = Integer.valueOf(cacheBlockNum.getText());
            this.cacheNum = cacheGroupNum * cacheBlockNumber;
            this.memoryQuNum = this.memory / this.cacheSizeNum;
            this.memoryBlockNum = this.memoryQuNum * this.cacheNum;
            
            cache = new Cache[cacheGroupNum];
            cacheAddrs = new ArrayList[cacheGroupNum];
            
            String addrString = this.addrText.getText();
            String[] addrItems = addrString.split(" ");
            
            for(int i=0;i<addrItems.length;i++){
                this.addr[i]=Integer.parseInt(addrItems[i]);
            }

            this.initCache();
            this.initAddrs();

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < this.cache.length; i++) {
                sb.append("第").append(i).append("组Cache块中各个块的使用情况为：\n");
                int[] addrTemp = new int[cacheAddrs[i].size()];
                for (int j = 0; j < this.cacheAddrs[i].size(); j++) {
                    addrTemp[j] = ((Integer) this.cacheAddrs[i].get(j))
                            .intValue();
                }
                sb.append(this.cache[i].display(addrTemp)).append("\n");
            }
            resultArea.setText(sb.toString());
        } catch (Exception ex) {
            JOptionPane.showMessageDialog(null, "所有输入均为正整数！\n地址流输入只能用一个空格隔开", "Sorry",
                    JOptionPane.INFORMATION_MESSAGE);
            memorySize.setText("32");
            pageNum.setText("3");
            cacheSize.setText("16");
            cacheGroupSize.setText("2");
            cacheBlockNum.setText("2");
            addrText.setText("1 2 4 1 3 7 0 1 2 5 4 6 4 7 2");
        }

    }

    /**
     * main 方法
     * 
     * @param args
     */
    public static void main(String[] args) {
        new MainFrame();
    }
}

在解决Cache的组相联映像中，我主要采用的方法是将地址流随Cache分组而进行分组，只有特定的主存块才能进入到特定的Cache组中。针对每一组的Cache进行基本的Cache的LRU替换算法（Cache类中）