Hykilpikonna
386 lines
13 KiB
Java
386 lines
13 KiB
Java
/*
|
|
Copyright (c) 2009, Ingo Kofler, ITEC, Klagenfurt University, Austria
|
|
|
|
Developed by Ingo Kofler (ingo.kofler@itec.uni-klu.ac.at)
|
|
Based on the Instruction Counter tool by Felipe Lessa (felipe.lessa@gmail.com)
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining
|
|
a copy of this software and associated documentation files (the
|
|
"Software"), to deal in the Software without restriction, including
|
|
without limitation the rights to use, copy, modify, merge, publish,
|
|
distribute, sublicense, and/or sell copies of the Software, and to
|
|
permit persons to whom the Software is furnished to do so, subject
|
|
to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be
|
|
included in all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
|
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
|
|
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
(MIT license, http://www.opensource.org/licenses/mit-license.html)
|
|
*/
|
|
package mars.tools;
|
|
|
|
import mars.ProgramStatement;
|
|
import mars.mips.hardware.AccessNotice;
|
|
import mars.mips.hardware.AddressErrorException;
|
|
import mars.mips.hardware.Memory;
|
|
import mars.mips.hardware.MemoryAccessNotice;
|
|
|
|
import javax.swing.*;
|
|
import java.awt.*;
|
|
import java.util.Observable;
|
|
|
|
|
|
/**
|
|
* A MARS tool for obtaining instruction statistics by instruction category.
|
|
* <p>
|
|
* The code of this tools is initially based on the Instruction counter tool by Felipe Lassa.
|
|
*
|
|
* @author Ingo Kofler <ingo.kofler@itec.uni-klu.ac.at>
|
|
*/
|
|
// @SuppressWarnings("serial")
|
|
public class InstructionStatistics extends AbstractMarsToolAndApplication
|
|
{
|
|
|
|
/** number of instruction categories used by this tool */
|
|
private static final int MAX_CATEGORY = 5;
|
|
|
|
/** constant for ALU instructions category */
|
|
private static final int CATEGORY_ALU = 0;
|
|
|
|
/** constant for jump instructions category */
|
|
private static final int CATEGORY_JUMP = 1;
|
|
|
|
/** constant for branch instructions category */
|
|
private static final int CATEGORY_BRANCH = 2;
|
|
|
|
/** constant for memory instructions category */
|
|
private static final int CATEGORY_MEM = 3;
|
|
|
|
/** constant for any other instruction category */
|
|
private static final int CATEGORY_OTHER = 4;
|
|
|
|
/** name of the tool */
|
|
private static final String NAME = "Instruction Statistics";
|
|
|
|
/** version and author information of the tool */
|
|
private static final String VERSION = "Version 1.0 (Ingo Kofler)";
|
|
|
|
/** heading of the tool */
|
|
private static final String HEADING = "";
|
|
|
|
/**
|
|
* The last address we saw. We ignore it because the only way for a program to execute twice the same instruction is
|
|
* to enter an infinite loop, which is not insteresting in the POV of counting instructions.
|
|
*/
|
|
protected int lastAddress = -1;
|
|
|
|
/** text field for visualizing the total number of instructions processed */
|
|
private JTextField m_tfTotalCounter;
|
|
|
|
/** array of text field - one for each instruction category */
|
|
private JTextField[] m_tfCounters;
|
|
|
|
/** array of progress pars - one for each instruction category */
|
|
private JProgressBar[] m_pbCounters;
|
|
|
|
/** counter for the total number of instructions processed */
|
|
private int m_totalCounter = 0;
|
|
|
|
/** array of counter variables - one for each instruction category */
|
|
private final int[] m_counters = new int[MAX_CATEGORY];
|
|
|
|
|
|
// From Felipe Lessa's instruction counter. Prevent double-counting of instructions
|
|
// which happens because 2 read events are generated.
|
|
|
|
/** names of the instruction categories as array */
|
|
private final String[] m_categoryLabels = {"ALU", "Jump", "Branch", "Memory", "Other"};
|
|
|
|
/**
|
|
* Simple constructor, likely used to run a stand-alone enhanced instruction counter.
|
|
*
|
|
* @param title String containing title for title bar
|
|
* @param heading String containing text for heading shown in upper part of window.
|
|
*/
|
|
public InstructionStatistics(String title, String heading)
|
|
{
|
|
super(title, heading);
|
|
}
|
|
|
|
|
|
/**
|
|
* Simple construction, likely used by the MARS Tools menu mechanism.
|
|
*/
|
|
public InstructionStatistics()
|
|
{
|
|
super(InstructionStatistics.NAME + ", " + InstructionStatistics.VERSION, InstructionStatistics.HEADING);
|
|
}
|
|
|
|
|
|
/**
|
|
* returns the name of the tool
|
|
*
|
|
* @return the tools's name
|
|
*/
|
|
public String getName()
|
|
{
|
|
return NAME;
|
|
}
|
|
|
|
|
|
/**
|
|
* creates the display area for the tool as required by the API
|
|
*
|
|
* @return a panel that holds the GUI of the tool
|
|
*/
|
|
protected JComponent buildMainDisplayArea()
|
|
{
|
|
|
|
// Create GUI elements for the tool
|
|
JPanel panel = new JPanel(new GridBagLayout());
|
|
|
|
m_tfTotalCounter = new JTextField("0", 10);
|
|
m_tfTotalCounter.setEditable(false);
|
|
|
|
m_tfCounters = new JTextField[MAX_CATEGORY];
|
|
m_pbCounters = new JProgressBar[MAX_CATEGORY];
|
|
|
|
// for each category a text field and a progress bar is created
|
|
for (int i = 0; i < InstructionStatistics.MAX_CATEGORY; i++)
|
|
{
|
|
m_tfCounters[i] = new JTextField("0", 10);
|
|
m_tfCounters[i].setEditable(false);
|
|
m_pbCounters[i] = new JProgressBar(JProgressBar.HORIZONTAL);
|
|
m_pbCounters[i].setStringPainted(true);
|
|
}
|
|
|
|
GridBagConstraints c = new GridBagConstraints();
|
|
c.anchor = GridBagConstraints.LINE_START;
|
|
c.gridheight = c.gridwidth = 1;
|
|
|
|
// create the label and text field for the total instruction counter
|
|
c.gridx = 2;
|
|
c.gridy = 1;
|
|
c.insets = new Insets(0, 0, 17, 0);
|
|
panel.add(new JLabel("Total: "), c);
|
|
c.gridx = 3;
|
|
panel.add(m_tfTotalCounter, c);
|
|
|
|
c.insets = new Insets(3, 3, 3, 3);
|
|
|
|
// create label, text field and progress bar for each category
|
|
for (int i = 0; i < InstructionStatistics.MAX_CATEGORY; i++)
|
|
{
|
|
c.gridy++;
|
|
c.gridx = 2;
|
|
panel.add(new JLabel(m_categoryLabels[i] + ": "), c);
|
|
c.gridx = 3;
|
|
panel.add(m_tfCounters[i], c);
|
|
c.gridx = 4;
|
|
panel.add(m_pbCounters[i], c);
|
|
}
|
|
|
|
return panel;
|
|
}
|
|
|
|
|
|
/**
|
|
* registers the tool as observer for the text segment of the MIPS program
|
|
*/
|
|
protected void addAsObserver()
|
|
{
|
|
addAsObserver(Memory.textBaseAddress, Memory.textLimitAddress);
|
|
}
|
|
|
|
|
|
/**
|
|
* decodes the instruction and determines the category of the instruction.
|
|
* <p>
|
|
* The instruction is decoded by extracting the operation and function code of the 32-bit instruction. Only the most
|
|
* relevant instructions are decoded and categorized.
|
|
*
|
|
* @param stmt the instruction to decode
|
|
* @return the category of the instruction
|
|
* @see InstructionStatistics#CATEGORY_ALU
|
|
* @see InstructionStatistics#CATEGORY_JUMP
|
|
* @see InstructionStatistics#CATEGORY_BRANCH
|
|
* @see InstructionStatistics#CATEGORY_MEM
|
|
* @see InstructionStatistics#CATEGORY_OTHER
|
|
*/
|
|
protected int getInstructionCategory(ProgramStatement stmt)
|
|
{
|
|
|
|
int opCode = stmt.getBinaryStatement() >>> (32 - 6);
|
|
int funct = stmt.getBinaryStatement() & 0x1F;
|
|
|
|
if (opCode == 0x00)
|
|
{
|
|
if (funct == 0x00)
|
|
{
|
|
return InstructionStatistics.CATEGORY_ALU; // sll
|
|
}
|
|
if (0x02 <= funct && funct <= 0x07)
|
|
{
|
|
return InstructionStatistics.CATEGORY_ALU; // srl, sra, sllv, srlv, srav
|
|
}
|
|
if (funct == 0x08 || funct == 0x09)
|
|
{
|
|
return InstructionStatistics.CATEGORY_JUMP; // jr, jalr
|
|
}
|
|
if (0x10 <= funct && funct <= 0x2F)
|
|
{
|
|
return InstructionStatistics.CATEGORY_ALU; // mfhi, mthi, mflo, mtlo, mult, multu, div, divu, add, addu, sub, subu, and, or, xor, nor, slt, sltu
|
|
}
|
|
return InstructionStatistics.CATEGORY_OTHER;
|
|
}
|
|
if (opCode == 0x01)
|
|
{
|
|
if (0x00 <= funct && funct <= 0x07)
|
|
{
|
|
return InstructionStatistics.CATEGORY_BRANCH; // bltz, bgez, bltzl, bgezl
|
|
}
|
|
if (0x10 <= funct && funct <= 0x13)
|
|
{
|
|
return InstructionStatistics.CATEGORY_BRANCH; // bltzal, bgezal, bltzall, bgczall
|
|
}
|
|
return InstructionStatistics.CATEGORY_OTHER;
|
|
}
|
|
if (opCode == 0x02 || opCode == 0x03)
|
|
{
|
|
return InstructionStatistics.CATEGORY_JUMP; // j, jal
|
|
}
|
|
if (0x04 <= opCode && opCode <= 0x07)
|
|
{
|
|
return InstructionStatistics.CATEGORY_BRANCH; // beq, bne, blez, bgtz
|
|
}
|
|
if (0x08 <= opCode && opCode <= 0x0F)
|
|
{
|
|
return InstructionStatistics.CATEGORY_ALU; // addi, addiu, slti, sltiu, andi, ori, xori, lui
|
|
}
|
|
if (0x14 <= opCode && opCode <= 0x17)
|
|
{
|
|
return InstructionStatistics.CATEGORY_BRANCH; // beql, bnel, blezl, bgtzl
|
|
}
|
|
if (0x20 <= opCode && opCode <= 0x26)
|
|
{
|
|
return InstructionStatistics.CATEGORY_MEM; // lb, lh, lwl, lw, lbu, lhu, lwr
|
|
}
|
|
if (0x28 <= opCode && opCode <= 0x2E)
|
|
{
|
|
return InstructionStatistics.CATEGORY_MEM; // sb, sh, swl, sw, swr
|
|
}
|
|
|
|
return InstructionStatistics.CATEGORY_OTHER;
|
|
}
|
|
|
|
|
|
/**
|
|
* method that is called each time the MIPS simulator accesses the text segment. Before an instruction is executed
|
|
* by the simulator, the instruction is fetched from the program memory. This memory access is observed and the
|
|
* corresponding instruction is decoded and categorized by the tool. According to the category the counter values
|
|
* are increased and the display gets updated.
|
|
*
|
|
* @param resource the observed resource
|
|
* @param notice signals the type of access (memory, register etc.)
|
|
*/
|
|
protected void processMIPSUpdate(Observable resource, AccessNotice notice)
|
|
{
|
|
|
|
if (!notice.accessIsFromMIPS())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// check for a read access in the text segment
|
|
if (notice.getAccessType() == AccessNotice.READ && notice instanceof MemoryAccessNotice)
|
|
{
|
|
|
|
// now it is safe to make a cast of the notice
|
|
MemoryAccessNotice memAccNotice = (MemoryAccessNotice) notice;
|
|
|
|
// The next three statments are from Felipe Lessa's instruction counter. Prevents double-counting.
|
|
int a = memAccNotice.getAddress();
|
|
if (a == lastAddress)
|
|
{
|
|
return;
|
|
}
|
|
lastAddress = a;
|
|
|
|
try
|
|
{
|
|
|
|
// access the statement in the text segment without notifying other tools etc.
|
|
ProgramStatement stmt = Memory.getInstance().getStatement(memAccNotice.getAddress());
|
|
|
|
// necessary to handle possible null pointers at the end of the program
|
|
// (e.g., if the simulator tries to execute the next instruction after the last instruction in the text segment)
|
|
if (stmt != null)
|
|
{
|
|
int category = getInstructionCategory(stmt);
|
|
|
|
m_totalCounter++;
|
|
m_counters[category]++;
|
|
updateDisplay();
|
|
}
|
|
}
|
|
catch (AddressErrorException e)
|
|
{
|
|
// silently ignore these exceptions
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* performs initialization tasks of the counters before the GUI is created.
|
|
*/
|
|
protected void initializePreGUI()
|
|
{
|
|
m_totalCounter = 0;
|
|
lastAddress = -1; // from Felipe Lessa's instruction counter tool
|
|
for (int i = 0; i < InstructionStatistics.MAX_CATEGORY; i++)
|
|
{
|
|
m_counters[i] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* resets the counter values of the tool and updates the display.
|
|
*/
|
|
protected void reset()
|
|
{
|
|
m_totalCounter = 0;
|
|
lastAddress = -1; // from Felipe Lessa's instruction counter tool
|
|
for (int i = 0; i < InstructionStatistics.MAX_CATEGORY; i++)
|
|
{
|
|
m_counters[i] = 0;
|
|
}
|
|
updateDisplay();
|
|
}
|
|
|
|
|
|
/**
|
|
* updates the text fields and progress bars according to the current counter values.
|
|
*/
|
|
protected void updateDisplay()
|
|
{
|
|
m_tfTotalCounter.setText(String.valueOf(m_totalCounter));
|
|
|
|
for (int i = 0; i < InstructionStatistics.MAX_CATEGORY; i++)
|
|
{
|
|
m_tfCounters[i].setText(String.valueOf(m_counters[i]));
|
|
m_pbCounters[i].setMaximum(m_totalCounter);
|
|
m_pbCounters[i].setValue(m_counters[i]);
|
|
}
|
|
}
|
|
}
|