first commit
This commit is contained in:
commit
a142b0799b
|
|
@ -0,0 +1,116 @@
|
|||
package configuration;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
import javax.xml.parsers.DocumentBuilder;
|
||||
import javax.xml.parsers.DocumentBuilderFactory;
|
||||
|
||||
import org.w3c.dom.Document;
|
||||
import org.w3c.dom.Element;
|
||||
import org.w3c.dom.Node;
|
||||
import org.w3c.dom.NodeList;
|
||||
|
||||
import generic.Misc;
|
||||
|
||||
public class Configuration {
|
||||
public static int ALU_count;
|
||||
public static int ALU_latency;
|
||||
public static int ALU_reciprocal_of_throughput;
|
||||
public static int multiplier_count;
|
||||
public static int multiplier_latency;
|
||||
public static int multiplier_reciprocal_of_throughput;
|
||||
public static int divider_count;
|
||||
public static int divider_latency;
|
||||
public static int divider_reciprocal_of_throughput;
|
||||
|
||||
public static int L1i_numberOfLines;
|
||||
public static int L1i_latency;
|
||||
public static int L1i_associativity;
|
||||
public static String L1i_replacementPolicy;
|
||||
|
||||
public static int L1d_numberOfLines;
|
||||
public static int L1d_latency;
|
||||
public static int L1d_associativity;
|
||||
public static String L1d_replacementPolicy;
|
||||
|
||||
public static int L2_numberOfLines;
|
||||
public static int L2_latency;
|
||||
public static int L2_associativity;
|
||||
public static String L2_replacementPolicy;
|
||||
|
||||
public static int mainMemoryLatency;
|
||||
|
||||
public static void parseConfiguratioFile(String configFileName)
|
||||
{
|
||||
Document doc = null;
|
||||
|
||||
try
|
||||
{
|
||||
File file = new File(configFileName);
|
||||
DocumentBuilderFactory DBFactory = DocumentBuilderFactory.newInstance();
|
||||
DocumentBuilder DBuilder = DBFactory.newDocumentBuilder();
|
||||
doc = DBuilder.parse(file);
|
||||
doc.getDocumentElement().normalize();
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
Misc.printErrorAndExit("Error in reading config file : " + e);
|
||||
}
|
||||
|
||||
NodeList nodeLst = doc.getElementsByTagName("ALU");
|
||||
Element elmnt = (Element) nodeLst.item(0);
|
||||
ALU_count = Integer.parseInt(getImmediateString("Count", elmnt));
|
||||
ALU_latency = Integer.parseInt(getImmediateString("Latency", elmnt));
|
||||
ALU_reciprocal_of_throughput = Integer.parseInt(getImmediateString("ReciprocalOfThroughput", elmnt));
|
||||
|
||||
nodeLst = doc.getElementsByTagName("Multiplier");
|
||||
elmnt = (Element) nodeLst.item(0);
|
||||
multiplier_count = Integer.parseInt(getImmediateString("Count", elmnt));
|
||||
multiplier_latency = Integer.parseInt(getImmediateString("Latency", elmnt));
|
||||
multiplier_reciprocal_of_throughput = Integer.parseInt(getImmediateString("ReciprocalOfThroughput", elmnt));
|
||||
|
||||
nodeLst = doc.getElementsByTagName("Divider");
|
||||
elmnt = (Element) nodeLst.item(0);
|
||||
divider_count = Integer.parseInt(getImmediateString("Count", elmnt));
|
||||
divider_latency = Integer.parseInt(getImmediateString("Latency", elmnt));
|
||||
divider_reciprocal_of_throughput = Integer.parseInt(getImmediateString("ReciprocalOfThroughput", elmnt));
|
||||
|
||||
nodeLst = doc.getElementsByTagName("L1iCache");
|
||||
elmnt = (Element) nodeLst.item(0);
|
||||
L1i_numberOfLines = Integer.parseInt(getImmediateString("NumberOfLines", elmnt));
|
||||
L1i_latency = Integer.parseInt(getImmediateString("Latency", elmnt));
|
||||
L1i_associativity = Integer.parseInt(getImmediateString("Associativity", elmnt));
|
||||
L1i_replacementPolicy = getImmediateString("ReplacementPolicy", elmnt);
|
||||
|
||||
nodeLst = doc.getElementsByTagName("L1dCache");
|
||||
elmnt = (Element) nodeLst.item(0);
|
||||
L1d_numberOfLines = Integer.parseInt(getImmediateString("NumberOfLines", elmnt));
|
||||
L1d_latency = Integer.parseInt(getImmediateString("Latency", elmnt));
|
||||
L1d_associativity = Integer.parseInt(getImmediateString("Associativity", elmnt));
|
||||
L1d_replacementPolicy = getImmediateString("ReplacementPolicy", elmnt);
|
||||
|
||||
nodeLst = doc.getElementsByTagName("L2Cache");
|
||||
elmnt = (Element) nodeLst.item(0);
|
||||
L2_numberOfLines = Integer.parseInt(getImmediateString("NumberOfLines", elmnt));
|
||||
L2_latency = Integer.parseInt(getImmediateString("Latency", elmnt));
|
||||
L2_associativity = Integer.parseInt(getImmediateString("Associativity", elmnt));
|
||||
L2_replacementPolicy = getImmediateString("ReplacementPolicy", elmnt);
|
||||
|
||||
nodeLst = doc.getElementsByTagName("Configuration");
|
||||
elmnt = (Element) nodeLst.item(0);
|
||||
mainMemoryLatency = Integer.parseInt(getImmediateString("MainMemoryLatency", elmnt));
|
||||
}
|
||||
|
||||
private static String getImmediateString(String tagName, Element parent) // Get the immediate string value of a particular tag name under a particular parent tag
|
||||
{
|
||||
NodeList nodeLst = parent.getElementsByTagName(tagName);
|
||||
if (nodeLst.item(0) == null)
|
||||
{
|
||||
Misc.printErrorAndExit("XML Configuration error : Item \"" + tagName + "\" not found inside the \"" + parent.getTagName() + "\" tag in the configuration file!!");
|
||||
}
|
||||
Element NodeElmnt = (Element) nodeLst.item(0);
|
||||
NodeList resultNode = NodeElmnt.getChildNodes();
|
||||
return ((Node) resultNode.item(0)).getNodeValue();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
|
||||
<Configuration>
|
||||
<FunctionalUnits>
|
||||
<ALU>
|
||||
<Count>2</Count>
|
||||
<Latency>1</Latency>
|
||||
<ReciprocalOfThroughput>1</ReciprocalOfThroughput>
|
||||
</ALU>
|
||||
<Multiplier>
|
||||
<Count>1</Count>
|
||||
<Latency>4</Latency>
|
||||
<ReciprocalOfThroughput>1</ReciprocalOfThroughput>
|
||||
</Multiplier>
|
||||
<Divider>
|
||||
<Count>1</Count>
|
||||
<Latency>10</Latency>
|
||||
<ReciprocalOfThroughput>1</ReciprocalOfThroughput>
|
||||
</Divider>
|
||||
</FunctionalUnits>
|
||||
|
||||
<L1iCache>
|
||||
<NumberOfLines>256</NumberOfLines>
|
||||
<Latency>2</Latency>
|
||||
<Associativity>4</Associativity>
|
||||
<ReplacementPolicy>LRU</ReplacementPolicy>
|
||||
</L1iCache>
|
||||
|
||||
<L1dCache>
|
||||
<NumberOfLines>256</NumberOfLines>
|
||||
<Latency>2</Latency>
|
||||
<Associativity>4</Associativity>
|
||||
<ReplacementPolicy>LRU</ReplacementPolicy>
|
||||
</L1dCache>
|
||||
|
||||
<L2Cache>
|
||||
<NumberOfLines>2048</NumberOfLines>
|
||||
<Latency>10</Latency>
|
||||
<Associativity>4</Associativity>
|
||||
<ReplacementPolicy>LRU</ReplacementPolicy>
|
||||
</L2Cache>
|
||||
|
||||
<MainMemoryLatency>40</MainMemoryLatency>
|
||||
</Configuration>
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
package generic;
|
||||
|
||||
public class Instruction {
|
||||
|
||||
public enum OperationType {add, addi, sub, subi, mul, muli, div, divi, and, andi, or, ori, xor, xori, slt, slti, sll, slli, srl, srli, sra, srai, load, store, jmp, beq, bne, blt, bgt, end};
|
||||
|
||||
int programCounter;
|
||||
OperationType operationType;
|
||||
Operand sourceOperand1;
|
||||
Operand sourceOperand2;
|
||||
Operand destinationOperand;
|
||||
|
||||
public int getProgramCounter() {
|
||||
return programCounter;
|
||||
}
|
||||
public void setProgramCounter(int programCounter) {
|
||||
this.programCounter = programCounter;
|
||||
}
|
||||
public OperationType getOperationType() {
|
||||
return operationType;
|
||||
}
|
||||
public void setOperationType(OperationType operationType) {
|
||||
this.operationType = operationType;
|
||||
}
|
||||
public Operand getSourceOperand1() {
|
||||
return sourceOperand1;
|
||||
}
|
||||
public void setSourceOperand1(Operand sourceOperand1) {
|
||||
this.sourceOperand1 = sourceOperand1;
|
||||
}
|
||||
public Operand getSourceOperand2() {
|
||||
return sourceOperand2;
|
||||
}
|
||||
public void setSourceOperand2(Operand sourceOperand2) {
|
||||
this.sourceOperand2 = sourceOperand2;
|
||||
}
|
||||
public Operand getDestinationOperand() {
|
||||
return destinationOperand;
|
||||
}
|
||||
public void setDestinationOperand(Operand destinationOperand) {
|
||||
this.destinationOperand = destinationOperand;
|
||||
}
|
||||
public String toString()
|
||||
{
|
||||
if(sourceOperand1 != null)
|
||||
{
|
||||
if(sourceOperand2 != null)
|
||||
{
|
||||
if(destinationOperand != null)
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\t" + sourceOperand1 + "\t" + sourceOperand2 + "\t" + destinationOperand + "\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\t" + sourceOperand1 + "\t" + sourceOperand2 + "\tnull" + "\n";
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(destinationOperand != null)
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\t" + sourceOperand1 + "\tnull" + "\t" + destinationOperand + "\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\t" + sourceOperand1 + "\tnull" + "\tnull" + "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(sourceOperand2 != null)
|
||||
{
|
||||
if(destinationOperand != null)
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\tnull" + "\t" + sourceOperand2 + "\t" + destinationOperand + "\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\tnull" + "\t" + sourceOperand2 + "\tnull" + "\n";
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(destinationOperand != null)
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\tnull" + "\tnull" + "\t" + destinationOperand + "\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
return "PC="+ programCounter + "\t" + operationType + "\tnull" + "\tnull" + "\tnull" + "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
package generic;
|
||||
|
||||
public class Misc {
|
||||
|
||||
public static void printErrorAndExit(String message)
|
||||
{
|
||||
System.err.println(message);
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
package generic;
|
||||
|
||||
public class Operand {
|
||||
|
||||
public enum OperandType {Register, Immediate, Label};
|
||||
|
||||
OperandType operandType;
|
||||
int value;
|
||||
String labelValue; //only applicable for Label type;
|
||||
//Note that Label type is only applicable for functional emulation of assembly file
|
||||
|
||||
public OperandType getOperandType() {
|
||||
return operandType;
|
||||
}
|
||||
public void setOperandType(OperandType operandType) {
|
||||
this.operandType = operandType;
|
||||
}
|
||||
public int getValue() {
|
||||
return value;
|
||||
}
|
||||
public void setValue(int value) {
|
||||
this.value = value;
|
||||
}
|
||||
public String getLabelValue() {
|
||||
return labelValue;
|
||||
}
|
||||
public void setLabelValue(String labelValue) {
|
||||
this.labelValue = labelValue;
|
||||
}
|
||||
public String toString()
|
||||
{
|
||||
if(operandType == OperandType.Register || operandType == OperandType.Immediate)
|
||||
{
|
||||
return "[" + operandType.toString() + ":" + value + "]";
|
||||
}
|
||||
else
|
||||
{
|
||||
return "[" + operandType.toString() + ":" + labelValue + "]";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
package generic;
|
||||
|
||||
import processor.Clock;
|
||||
import processor.Processor;
|
||||
|
||||
public class Simulator {
|
||||
|
||||
static Processor processor;
|
||||
static boolean simulationComplete;
|
||||
|
||||
public static void setupSimulation(String assemblyProgramFile, Processor p)
|
||||
{
|
||||
Simulator.processor = p;
|
||||
loadProgram(assemblyProgramFile);
|
||||
|
||||
simulationComplete = false;
|
||||
}
|
||||
|
||||
static void loadProgram(String assemblyProgramFile)
|
||||
{
|
||||
/*
|
||||
* TODO
|
||||
* 1. load the program into memory according to the program layout described
|
||||
* in the ISA specification
|
||||
* 2. set PC to the address of the first instruction in the main
|
||||
* 3. set the following registers:
|
||||
* x0 = 0
|
||||
* x1 = 65535
|
||||
* x2 = 65535
|
||||
*/
|
||||
}
|
||||
|
||||
public static void simulate()
|
||||
{
|
||||
while(simulationComplete == false)
|
||||
{
|
||||
processor.getIFUnit().performIF();
|
||||
Clock.incrementClock();
|
||||
processor.getOFUnit().performOF();
|
||||
Clock.incrementClock();
|
||||
processor.getEXUnit().performEX();
|
||||
Clock.incrementClock();
|
||||
processor.getMAUnit().performMA();
|
||||
Clock.incrementClock();
|
||||
processor.getRWUnit().performRW();
|
||||
Clock.incrementClock();
|
||||
}
|
||||
|
||||
// TODO
|
||||
// set statistics
|
||||
}
|
||||
|
||||
public static void setSimulationComplete(boolean value)
|
||||
{
|
||||
simulationComplete = value;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
package generic;
|
||||
|
||||
import java.io.PrintWriter;
|
||||
|
||||
public class Statistics {
|
||||
|
||||
// TODO add your statistics here
|
||||
static int numberOfInstructions;
|
||||
static int numberOfCycles;
|
||||
|
||||
|
||||
public static void printStatistics(String statFile)
|
||||
{
|
||||
try
|
||||
{
|
||||
PrintWriter writer = new PrintWriter(statFile);
|
||||
|
||||
writer.println("Number of instructions executed = " + numberOfInstructions);
|
||||
writer.println("Number of cycles taken = " + numberOfCycles);
|
||||
|
||||
// TODO add code here to print statistics in the output file
|
||||
|
||||
writer.close();
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
Misc.printErrorAndExit(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
// TODO write functions to update statistics
|
||||
public void setNumberOfInstructions(int numberOfInstructions) {
|
||||
Statistics.numberOfInstructions = numberOfInstructions;
|
||||
}
|
||||
|
||||
public void setNumberOfCycles(int numberOfCycles) {
|
||||
Statistics.numberOfCycles = numberOfCycles;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package main;
|
||||
import java.util.ArrayList;
|
||||
|
||||
import configuration.Configuration;
|
||||
import generic.Misc;
|
||||
import generic.Statistics;
|
||||
import processor.Processor;
|
||||
import processor.memorysystem.MainMemory;
|
||||
import processor.pipeline.RegisterFile;
|
||||
import generic.Simulator;
|
||||
|
||||
public class Main {
|
||||
|
||||
public static void main(String[] args) {
|
||||
if(args.length != 3)
|
||||
{
|
||||
Misc.printErrorAndExit("usage: java -jar <path-to-jar-file> <path-to-config-file> <path-to-stat-file> <path-to-object-file>\n");
|
||||
}
|
||||
|
||||
Configuration.parseConfiguratioFile(args[0]);
|
||||
|
||||
Processor processor = new Processor();
|
||||
|
||||
Simulator.setupSimulation(args[2], processor);
|
||||
Simulator.simulate();
|
||||
|
||||
processor.printState(0, 30); // ((0, 0) refers to the range of main memory addresses we wish to print. this is an empty set.
|
||||
|
||||
Statistics.printStatistics(args[1]);
|
||||
|
||||
System.out.println("Hash of the Processor State = "+getHashCode(processor.getRegisterFile(), processor.getMainMemory()));
|
||||
}
|
||||
|
||||
static int getHashCode(RegisterFile registerState, MainMemory memoryState) {
|
||||
ArrayList<Integer> hash = new ArrayList<Integer>();
|
||||
|
||||
hash.add(registerState.getProgramCounter());
|
||||
|
||||
for(int i=0;i<32;i++) {
|
||||
hash.add(registerState.getValue(i));
|
||||
}
|
||||
|
||||
for(int i=0;i<65536;i++) {
|
||||
hash.add(memoryState.getWord(i));
|
||||
}
|
||||
|
||||
return hash.hashCode();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
package processor;
|
||||
|
||||
public class Clock {
|
||||
static long currentTime = 0;
|
||||
|
||||
public static void incrementClock()
|
||||
{
|
||||
currentTime++;
|
||||
}
|
||||
|
||||
public static long getCurrentTime()
|
||||
{
|
||||
return currentTime;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
package processor;
|
||||
|
||||
import processor.memorysystem.MainMemory;
|
||||
import processor.pipeline.EX_IF_LatchType;
|
||||
import processor.pipeline.EX_MA_LatchType;
|
||||
import processor.pipeline.Execute;
|
||||
import processor.pipeline.IF_EnableLatchType;
|
||||
import processor.pipeline.IF_OF_LatchType;
|
||||
import processor.pipeline.InstructionFetch;
|
||||
import processor.pipeline.MA_RW_LatchType;
|
||||
import processor.pipeline.MemoryAccess;
|
||||
import processor.pipeline.OF_EX_LatchType;
|
||||
import processor.pipeline.OperandFetch;
|
||||
import processor.pipeline.RegisterFile;
|
||||
import processor.pipeline.RegisterWrite;
|
||||
|
||||
public class Processor {
|
||||
|
||||
RegisterFile registerFile;
|
||||
MainMemory mainMemory;
|
||||
|
||||
IF_EnableLatchType IF_EnableLatch;
|
||||
IF_OF_LatchType IF_OF_Latch;
|
||||
OF_EX_LatchType OF_EX_Latch;
|
||||
EX_MA_LatchType EX_MA_Latch;
|
||||
EX_IF_LatchType EX_IF_Latch;
|
||||
MA_RW_LatchType MA_RW_Latch;
|
||||
|
||||
InstructionFetch IFUnit;
|
||||
OperandFetch OFUnit;
|
||||
Execute EXUnit;
|
||||
MemoryAccess MAUnit;
|
||||
RegisterWrite RWUnit;
|
||||
|
||||
public Processor()
|
||||
{
|
||||
registerFile = new RegisterFile();
|
||||
mainMemory = new MainMemory();
|
||||
|
||||
IF_EnableLatch = new IF_EnableLatchType();
|
||||
IF_OF_Latch = new IF_OF_LatchType();
|
||||
OF_EX_Latch = new OF_EX_LatchType();
|
||||
EX_MA_Latch = new EX_MA_LatchType();
|
||||
EX_IF_Latch = new EX_IF_LatchType();
|
||||
MA_RW_Latch = new MA_RW_LatchType();
|
||||
|
||||
IFUnit = new InstructionFetch(this, IF_EnableLatch, IF_OF_Latch, EX_IF_Latch);
|
||||
OFUnit = new OperandFetch(this, IF_OF_Latch, OF_EX_Latch);
|
||||
EXUnit = new Execute(this, OF_EX_Latch, EX_MA_Latch, EX_IF_Latch);
|
||||
MAUnit = new MemoryAccess(this, EX_MA_Latch, MA_RW_Latch);
|
||||
RWUnit = new RegisterWrite(this, MA_RW_Latch, IF_EnableLatch);
|
||||
}
|
||||
|
||||
public void printState(int memoryStartingAddress, int memoryEndingAddress)
|
||||
{
|
||||
System.out.println(registerFile.getContentsAsString());
|
||||
|
||||
System.out.println(mainMemory.getContentsAsString(memoryStartingAddress, memoryEndingAddress));
|
||||
}
|
||||
|
||||
public RegisterFile getRegisterFile() {
|
||||
return registerFile;
|
||||
}
|
||||
|
||||
public void setRegisterFile(RegisterFile registerFile) {
|
||||
this.registerFile = registerFile;
|
||||
}
|
||||
|
||||
public MainMemory getMainMemory() {
|
||||
return mainMemory;
|
||||
}
|
||||
|
||||
public void setMainMemory(MainMemory mainMemory) {
|
||||
this.mainMemory = mainMemory;
|
||||
}
|
||||
|
||||
public InstructionFetch getIFUnit() {
|
||||
return IFUnit;
|
||||
}
|
||||
|
||||
public OperandFetch getOFUnit() {
|
||||
return OFUnit;
|
||||
}
|
||||
|
||||
public Execute getEXUnit() {
|
||||
return EXUnit;
|
||||
}
|
||||
|
||||
public MemoryAccess getMAUnit() {
|
||||
return MAUnit;
|
||||
}
|
||||
|
||||
public RegisterWrite getRWUnit() {
|
||||
return RWUnit;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
package processor.memorysystem;
|
||||
|
||||
public class MainMemory {
|
||||
int[] memory;
|
||||
|
||||
public MainMemory()
|
||||
{
|
||||
memory = new int[65536];
|
||||
}
|
||||
|
||||
public int getWord(int address)
|
||||
{
|
||||
return memory[address];
|
||||
}
|
||||
|
||||
public void setWord(int address, int value)
|
||||
{
|
||||
memory[address] = value;
|
||||
}
|
||||
|
||||
public String getContentsAsString(int startingAddress, int endingAddress)
|
||||
{
|
||||
if(startingAddress == endingAddress)
|
||||
return "";
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append("\nMain Memory Contents:\n\n");
|
||||
for(int i = startingAddress; i <= endingAddress; i++)
|
||||
{
|
||||
sb.append(i + "\t\t: " + memory[i] + "\n");
|
||||
}
|
||||
sb.append("\n");
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
package processor.pipeline;
|
||||
|
||||
public class EX_IF_LatchType {
|
||||
|
||||
public EX_IF_LatchType()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package processor.pipeline;
|
||||
|
||||
public class EX_MA_LatchType {
|
||||
|
||||
boolean MA_enable;
|
||||
|
||||
public EX_MA_LatchType()
|
||||
{
|
||||
MA_enable = false;
|
||||
}
|
||||
|
||||
public boolean isMA_enable() {
|
||||
return MA_enable;
|
||||
}
|
||||
|
||||
public void setMA_enable(boolean mA_enable) {
|
||||
MA_enable = mA_enable;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
package processor.pipeline;
|
||||
|
||||
import processor.Processor;
|
||||
|
||||
public class Execute {
|
||||
Processor containingProcessor;
|
||||
OF_EX_LatchType OF_EX_Latch;
|
||||
EX_MA_LatchType EX_MA_Latch;
|
||||
EX_IF_LatchType EX_IF_Latch;
|
||||
|
||||
public Execute(Processor containingProcessor, OF_EX_LatchType oF_EX_Latch, EX_MA_LatchType eX_MA_Latch, EX_IF_LatchType eX_IF_Latch)
|
||||
{
|
||||
this.containingProcessor = containingProcessor;
|
||||
this.OF_EX_Latch = oF_EX_Latch;
|
||||
this.EX_MA_Latch = eX_MA_Latch;
|
||||
this.EX_IF_Latch = eX_IF_Latch;
|
||||
}
|
||||
|
||||
public void performEX()
|
||||
{
|
||||
//TODO
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package processor.pipeline;
|
||||
|
||||
public class IF_EnableLatchType {
|
||||
|
||||
boolean IF_enable;
|
||||
|
||||
public IF_EnableLatchType()
|
||||
{
|
||||
IF_enable = true;
|
||||
}
|
||||
|
||||
public boolean isIF_enable() {
|
||||
return IF_enable;
|
||||
}
|
||||
|
||||
public void setIF_enable(boolean iF_enable) {
|
||||
IF_enable = iF_enable;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
package processor.pipeline;
|
||||
|
||||
public class IF_OF_LatchType {
|
||||
|
||||
boolean OF_enable;
|
||||
int instruction;
|
||||
|
||||
public IF_OF_LatchType()
|
||||
{
|
||||
OF_enable = false;
|
||||
}
|
||||
|
||||
public boolean isOF_enable() {
|
||||
return OF_enable;
|
||||
}
|
||||
|
||||
public void setOF_enable(boolean oF_enable) {
|
||||
OF_enable = oF_enable;
|
||||
}
|
||||
|
||||
public int getInstruction() {
|
||||
return instruction;
|
||||
}
|
||||
|
||||
public void setInstruction(int instruction) {
|
||||
this.instruction = instruction;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
package processor.pipeline;
|
||||
|
||||
import processor.Processor;
|
||||
|
||||
public class InstructionFetch {
|
||||
|
||||
Processor containingProcessor;
|
||||
IF_EnableLatchType IF_EnableLatch;
|
||||
IF_OF_LatchType IF_OF_Latch;
|
||||
EX_IF_LatchType EX_IF_Latch;
|
||||
|
||||
public InstructionFetch(Processor containingProcessor, IF_EnableLatchType iF_EnableLatch, IF_OF_LatchType iF_OF_Latch, EX_IF_LatchType eX_IF_Latch)
|
||||
{
|
||||
this.containingProcessor = containingProcessor;
|
||||
this.IF_EnableLatch = iF_EnableLatch;
|
||||
this.IF_OF_Latch = iF_OF_Latch;
|
||||
this.EX_IF_Latch = eX_IF_Latch;
|
||||
}
|
||||
|
||||
public void performIF()
|
||||
{
|
||||
if(IF_EnableLatch.isIF_enable())
|
||||
{
|
||||
int currentPC = containingProcessor.getRegisterFile().getProgramCounter();
|
||||
int newInstruction = containingProcessor.getMainMemory().getWord(currentPC);
|
||||
IF_OF_Latch.setInstruction(newInstruction);
|
||||
containingProcessor.getRegisterFile().setProgramCounter(currentPC + 1);
|
||||
|
||||
IF_EnableLatch.setIF_enable(false);
|
||||
IF_OF_Latch.setOF_enable(true);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package processor.pipeline;
|
||||
|
||||
public class MA_RW_LatchType {
|
||||
|
||||
boolean RW_enable;
|
||||
|
||||
public MA_RW_LatchType()
|
||||
{
|
||||
RW_enable = false;
|
||||
}
|
||||
|
||||
public boolean isRW_enable() {
|
||||
return RW_enable;
|
||||
}
|
||||
|
||||
public void setRW_enable(boolean rW_enable) {
|
||||
RW_enable = rW_enable;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
package processor.pipeline;
|
||||
|
||||
import processor.Processor;
|
||||
|
||||
public class MemoryAccess {
|
||||
Processor containingProcessor;
|
||||
EX_MA_LatchType EX_MA_Latch;
|
||||
MA_RW_LatchType MA_RW_Latch;
|
||||
|
||||
public MemoryAccess(Processor containingProcessor, EX_MA_LatchType eX_MA_Latch, MA_RW_LatchType mA_RW_Latch)
|
||||
{
|
||||
this.containingProcessor = containingProcessor;
|
||||
this.EX_MA_Latch = eX_MA_Latch;
|
||||
this.MA_RW_Latch = mA_RW_Latch;
|
||||
}
|
||||
|
||||
public void performMA()
|
||||
{
|
||||
//TODO
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package processor.pipeline;
|
||||
|
||||
public class OF_EX_LatchType {
|
||||
|
||||
boolean EX_enable;
|
||||
|
||||
public OF_EX_LatchType()
|
||||
{
|
||||
EX_enable = false;
|
||||
}
|
||||
|
||||
public boolean isEX_enable() {
|
||||
return EX_enable;
|
||||
}
|
||||
|
||||
public void setEX_enable(boolean eX_enable) {
|
||||
EX_enable = eX_enable;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
package processor.pipeline;
|
||||
|
||||
import processor.Processor;
|
||||
|
||||
public class OperandFetch {
|
||||
Processor containingProcessor;
|
||||
IF_OF_LatchType IF_OF_Latch;
|
||||
OF_EX_LatchType OF_EX_Latch;
|
||||
|
||||
public OperandFetch(Processor containingProcessor, IF_OF_LatchType iF_OF_Latch, OF_EX_LatchType oF_EX_Latch)
|
||||
{
|
||||
this.containingProcessor = containingProcessor;
|
||||
this.IF_OF_Latch = iF_OF_Latch;
|
||||
this.OF_EX_Latch = oF_EX_Latch;
|
||||
}
|
||||
|
||||
public void performOF()
|
||||
{
|
||||
if(IF_OF_Latch.isOF_enable())
|
||||
{
|
||||
//TODO
|
||||
|
||||
IF_OF_Latch.setOF_enable(false);
|
||||
OF_EX_Latch.setEX_enable(true);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
package processor.pipeline;
|
||||
|
||||
public class RegisterFile {
|
||||
int[] registerFile;
|
||||
int programCounter;
|
||||
|
||||
public RegisterFile()
|
||||
{
|
||||
registerFile = new int[32];
|
||||
registerFile[0]=0; //%xo is always 0 [RISC V]
|
||||
}
|
||||
|
||||
public int getValue(int registerNumber)
|
||||
{
|
||||
return registerFile[registerNumber];
|
||||
}
|
||||
|
||||
public void setValue(int registerNumber, int value)
|
||||
{
|
||||
registerFile[registerNumber] = value;
|
||||
}
|
||||
|
||||
public int getProgramCounter()
|
||||
{
|
||||
return programCounter;
|
||||
}
|
||||
|
||||
public void setProgramCounter(int programCounter)
|
||||
{
|
||||
this.programCounter = programCounter;
|
||||
}
|
||||
|
||||
public void incrementProgramCounter()
|
||||
{
|
||||
this.programCounter++;
|
||||
}
|
||||
|
||||
public String getContentsAsString()
|
||||
{
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append("\nRegister File Contents:\n\n");
|
||||
sb.append("PC" + "\t: " + programCounter + "\n\n");
|
||||
|
||||
sb.append("x" + 0 + "\t: " + registerFile[0]+ "\n"); //%xo is always 0 [RISC V]
|
||||
for(int i = 1; i < 32; i++)
|
||||
{
|
||||
sb.append("x" + i + "\t: " + registerFile[i] + "\n");
|
||||
}
|
||||
sb.append("\n");
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
package processor.pipeline;
|
||||
|
||||
import generic.Simulator;
|
||||
import processor.Processor;
|
||||
|
||||
public class RegisterWrite {
|
||||
Processor containingProcessor;
|
||||
MA_RW_LatchType MA_RW_Latch;
|
||||
IF_EnableLatchType IF_EnableLatch;
|
||||
|
||||
public RegisterWrite(Processor containingProcessor, MA_RW_LatchType mA_RW_Latch, IF_EnableLatchType iF_EnableLatch)
|
||||
{
|
||||
this.containingProcessor = containingProcessor;
|
||||
this.MA_RW_Latch = mA_RW_Latch;
|
||||
this.IF_EnableLatch = iF_EnableLatch;
|
||||
}
|
||||
|
||||
public void performRW()
|
||||
{
|
||||
if(MA_RW_Latch.isRW_enable())
|
||||
{
|
||||
//TODO
|
||||
|
||||
// if instruction being processed is an end instruction, remember to call Simulator.setSimulationComplete(true);
|
||||
|
||||
MA_RW_Latch.setRW_enable(false);
|
||||
IF_EnableLatch.setIF_enable(true);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue