added statistics

Co-authored-by: SriRam Mudragada <iam-msr@users.noreply.github.com>

.vscode/launch.json

@@ -9,7 +9,7 @@
             "name": "Launch Current File",
             "request": "launch",
             "mainClass": "${file}",
-            "args": ["assignment-4/src/configuration/config.xml", "assignment-4/src/hello.txt", "assignment-4/supporting_files/test_cases/descending.out"]
+            "args": ["assignment-1/src/descending.asm", "descending.out"]
         },
         {
             "type": "java",

assignment-2/.vscode/launch.json

@@ -0,0 +1,22 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "java",
+            "name": "Launch Current File",
+            "request": "launch",
+            "mainClass": "${file}",
+            "args": ["../assignment-1/src/descending.asm", "descending.out"]
+        },
+        {
+            "type": "java",
+            "name": "Launch Main",
+            "request": "launch",
+            "mainClass": "main.Main",
+            "projectName": "assignment-2_d93382a2"
+        }
+    ]
+}

assignment-2/200010024_200010033-1/src/1.asm

@@ -0,0 +1,9 @@
+	.data
+a:
+	10
+b:
+	20
+	.text
+main:
+	load %x0, $a, %x4
+	end

assignment-2/200010024_200010033-1/src/configuration/Configuration.java

@@ -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();
+	}
+}

assignment-2/200010024_200010033-1/src/configuration/config.xml

@@ -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>

assignment-2/200010024_200010033-1/src/generic/.cph/.Simulator.java_74fc5dae77a3b9a48197eb148ed1e37a.prob

@@ -0,0 +1 @@
+{"name":"Local: Simulator","url":"c:\\Users\\karth\\OneDrive\\Desktop\\new\\src\\generic\\Simulator.java","tests":[{"id":1662603879409,"input":"","output":""},{"id":1662603899098,"input":"","output":""}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"c:\\Users\\karth\\OneDrive\\Desktop\\new\\src\\generic\\Simulator.java","group":"local","local":true}

assignment-2/200010024_200010033-1/src/generic/Instruction.java

@@ -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";
+				}
+			}
+		}
+	}
+}

assignment-2/200010024_200010033-1/src/generic/Misc.java

@@ -0,0 +1,10 @@
+package generic;
+
+public class Misc {
+	
+	public static void printErrorAndExit(String message)
+	{
+		System.err.println(message);
+		System.exit(1);
+	}
+}

assignment-2/200010024_200010033-1/src/generic/Operand.java

@@ -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 + "]";
+		}
+	}
+}

assignment-2/200010024_200010033-1/src/generic/ParsedProgram.java

@@ -0,0 +1,268 @@
+package generic;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Scanner;
+import java.util.regex.Pattern;
+import generic.Instruction.OperationType;
+import generic.Operand.OperandType;
+
+public class ParsedProgram {
+	static ArrayList<Instruction> code = new ArrayList<Instruction>();
+	static int mainFunctionAddress;
+	static int firstCodeAddress;
+	static ArrayList<Integer> data = new ArrayList<Integer>();
+	
+	public static void setMainFunctionAddress(int addr)
+	{
+		mainFunctionAddress = addr;
+	}
+	
+	public static void setFirstCodeAddress(int addr)
+	{
+		firstCodeAddress = addr;
+	}
+	
+	public static Instruction getInstructionAt(int programCounter)
+	{
+		return code.get(programCounter - firstCodeAddress);
+	}
+	
+	
+	static HashMap<String, Integer> symtab = new HashMap<String,Integer>();
+	
+
+	public static int parseDataSection(String assemblyProgramFile)
+	{
+		FileInputStream inputStream = null;
+		try
+		{
+			inputStream = new FileInputStream(assemblyProgramFile);
+		}
+		catch(FileNotFoundException e) {
+			Misc.printErrorAndExit(e.toString());
+		}
+		
+		Scanner sc=new Scanner(inputStream);
+		int address = 0;							//Store data staring from 1st memory location. At 0th location we denote the start of the code section.
+		
+				
+		while(sc.hasNextLine()) //TODO 3 loops?
+		{			
+			String line=sc.nextLine();
+				
+			if(line.contains(".data"))										//Processing the .data section
+			{
+				line=sc.next();
+					
+				do
+				{
+					if(Pattern.matches("[a-zA-Z]+([0-9]*)(:)", line))
+					{
+						ParsedProgram.symtab.put(line.replaceAll("[^a-zA-Z]",""), address);//TODO removed statements that were adding data to the code arraylist
+																							
+						while(Pattern.matches("-?\\d+", line=sc.next()))
+						{
+							data.add(Integer.parseInt(line));
+							address++;
+							
+						}
+					}
+				}while(!line.contains(".text"));
+				
+				break;
+			}
+		}
+		
+		sc.close();
+		
+		setFirstCodeAddress(address);
+					
+		return address;
+	}	
+	
+	public static void parseCodeSection(String assemblyProgramFile, int firstCodeAddress)
+	{
+		FileInputStream inputStream = null;
+		try
+		{
+			inputStream = new FileInputStream(assemblyProgramFile);
+		}
+		catch(FileNotFoundException e) {
+			Misc.printErrorAndExit(e.toString());
+		}
+		
+		Scanner sc=new Scanner(inputStream);
+		int address = firstCodeAddress;
+		
+		while(sc.hasNextLine())
+		{
+			String line=sc.nextLine();
+			if(line.contains(".text"))
+			{
+				break;				
+			}
+		}
+		
+		while(sc.hasNextLine())
+		{
+			String line;
+			if(Pattern.matches("[a-zA-Z]+([0-9]*)(:)", line=sc.nextLine()))
+			{
+				ParsedProgram.symtab.put(line.replaceAll(":",""), address);
+				if(line.replaceAll(":","").compareTo("main") == 0)
+				{
+					ParsedProgram.setMainFunctionAddress(address);
+				}
+			}
+			else
+			{
+				ParsedProgram.code.add(address-firstCodeAddress, getInstructionFromString(line, address));
+				address++;
+			}
+		}
+		sc.close();
+	}
+	
+	private static Instruction getInstructionFromString(String line, int address)
+	{
+		Instruction newInstruction = new Instruction();
+		newInstruction.setProgramCounter(address);
+		
+		Scanner sc = new Scanner(line);
+		newInstruction.setOperationType(OperationType.valueOf(sc.next()));
+		
+		switch(newInstruction.getOperationType())
+		{
+			//R3I type
+			case add : 
+			case sub : 
+			case mul : 
+			case div : 
+			case and : 
+			case or : 
+			case xor : 
+			case slt : 
+			case sll : 
+			case srl : 
+			case sra :	{
+							newInstruction.setSourceOperand1(getRegisterOperandFromString(sc.next()));
+							newInstruction.setSourceOperand2(getRegisterOperandFromString(sc.next()));
+							newInstruction.setDestinationOperand(getRegisterOperandFromString(sc.next()));
+							break;
+						} 
+			
+			//R2I type
+			case addi :
+			case subi :
+			case muli :
+			case divi : 
+			case andi : 
+			case ori : 
+			case xori : 
+			case slti : 
+			case slli : 
+			case srli : 
+			case srai :
+			case load :
+			case store :	{
+								newInstruction.setSourceOperand1(getRegisterOperandFromString(sc.next()));
+								String str = sc.next();
+								if(Pattern.matches("-?\\d+(,)",str))
+								{
+									//absolute immediate
+									newInstruction.setSourceOperand2(getImmediateOperandFromString(str));
+								}
+								else
+								{
+									//label / symbol
+									newInstruction.setSourceOperand2(getLabelOperandFromString(str));
+								}
+								newInstruction.setDestinationOperand(getRegisterOperandFromString(sc.next()));
+								break;
+							} 
+			
+			case beq : 
+			case bne : 
+			case blt : 
+			case bgt : 	{
+							newInstruction.setSourceOperand1(getRegisterOperandFromString(sc.next()));
+							newInstruction.setSourceOperand2(getRegisterOperandFromString(sc.next()));
+							String str = sc.next();
+							if(Pattern.matches("[0-9]+(,)",str))
+							{
+								//absolute immediate
+								newInstruction.setDestinationOperand(getImmediateOperandFromString(str));
+							}
+							else
+							{
+								//label / symbol
+								newInstruction.setDestinationOperand(getLabelOperandFromString(str));
+							}
+							break;
+						}
+			
+			//RI type :
+			case jmp :		{
+								String str = sc.next();
+								if(Pattern.matches("[0-9]+(,)",str))
+								{
+									//absolute immediate
+									newInstruction.setDestinationOperand(getImmediateOperandFromString(str));
+								}
+								else if(Pattern.matches("%x([0-9]{1,2})",str)) {
+									newInstruction.setDestinationOperand(getRegisterOperandFromString(str));
+								}
+								else
+								{
+									//label / symbol
+									newInstruction.setDestinationOperand(getLabelOperandFromString(str));
+								}
+								break;
+							}
+			
+			case end :	break;
+				
+			default: Misc.printErrorAndExit("unknown instruction!!");
+		}
+		
+		sc.close();
+		
+		return newInstruction;		
+	}
+	
+	private static Operand getRegisterOperandFromString(String str)
+	{
+		Operand operand = new Operand();
+		operand.setOperandType(OperandType.Register);
+		operand.setValue(Integer.parseInt(str.replaceAll("[^0-9]", "")));
+		return operand;
+	}
+	
+	private static Operand getImmediateOperandFromString(String str)
+	{
+		Operand operand = new Operand();
+		operand.setOperandType(OperandType.Immediate);
+		operand.setValue(Integer.parseInt(str.replaceAll("[^-?\\d+]","")));
+		return operand;
+	}
+	
+	private static Operand getLabelOperandFromString(String str)
+	{
+		Operand operand = new Operand();
+		operand.setOperandType(OperandType.Label);
+		operand.setLabelValue(str.replaceAll("[$,]", ""));
+		return operand;
+	}
+	
+	static void printState()
+	{
+		System.out.println("Symbol Table :");
+		System.out.println(Arrays.asList(symtab));
+		System.out.println("\nParsed instructions :");
+		System.out.println(Arrays.asList(code));
+	}
+}

assignment-2/200010024_200010033-1/src/generic/Simulator.java

@@ -0,0 +1,153 @@
+package generic;
+
+import java.io.FileInputStream;
+import generic.Operand.OperandType;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.io.ByteArrayInputStream;
+import java.nio.ByteBuffer;
+
+public class Simulator {
+		
+	static FileInputStream inputcodeStream = null;
+
+	public static Map<String, String> map = new HashMap<>() {
+		{
+			put("add", "00000");
+			put("sub", "00010");
+			put("mul", "00100");
+			put("div", "00110");
+			put("and", "01000");
+			put("or", "01010");
+			put("xor", "01100");
+			put("slt", "01110");
+			put("sll", "10000");
+			put("srl", "10010");
+			put("sra", "10100");
+			put("beq", "11001");
+			put("bne", "11010");
+			put("blt", "11011");
+			put("bgt", "11100");
+			put("load", "10110");
+			put("store", "10111");
+			put("jmp", "11000");
+			put("addi", "00001");
+			put("subi", "00011");
+			put("muli", "00101");
+			put("divi", "00111");
+			put("andi", "01001");
+			put("ori", "01011");
+			put("xori", "01101");
+			put("slti", "01111");
+			put("slli", "10001");
+			put("srli", "10011");
+			put("srai", "10101");
+			put("end", "11101");
+
+		}
+	};
+	private static String toBinaryOfSpecificPrecision(int num, int lenOfTargetString) {
+		String binary = String.format("%" + lenOfTargetString + "s", Integer.toBinaryString(num)).replace(' ', '0');
+		return binary;
+	}
+	private static String convert_1(Operand inst, int precision) {
+		
+		return toBinaryOfSpecificPrecision(inst.getValue(), precision);
+		
+	}
+	private static String convert(Operand inst, int precision) {
+		if (inst == null)
+			return toBinaryOfSpecificPrecision(0, precision);
+
+		if (inst.getOperandType() == Operand.OperandType.Label)
+			return toBinaryOfSpecificPrecision(ParsedProgram.symtab.get(inst.getLabelValue()), precision);
+
+		return toBinaryOfSpecificPrecision(inst.getValue(), precision);
+		
+	}
+	public static void setupSimulation(String assemblyProgramFile)
+	{	
+		int firstCodeAddress = ParsedProgram.parseDataSection(assemblyProgramFile);
+		ParsedProgram.parseCodeSection(assemblyProgramFile, firstCodeAddress);
+		ParsedProgram.printState();
+	}
+	
+	public static void assemble(String objectProgramFile)
+	{
+		
+		FileOutputStream file;
+		try {
+			file = new FileOutputStream(objectProgramFile);
+			//write the firstCodeAddress to the file
+			file.write(ByteBuffer.allocate(4).putInt(ParsedProgram.firstCodeAddress).array());
+			//write the data to the file
+			for (var value : ParsedProgram.data) {
+				byte[] dataValue = ByteBuffer.allocate(4).putInt(value).array();
+				file.write(dataValue);
+			}
+			//assemble one instruction at a time, and write to the file
+			for (var instruction : ParsedProgram.code) {
+				String line = "";
+				String optype=(instruction.operationType).toString();
+				line += map.get(optype);
+				// int op = Integer.parseInt(line, 2);
+				int op=Integer.parseInt(map.get(optype),2);
+				int pc = instruction.getProgramCounter();
+				
+				if (op <= 20 && op % 2 == 0) {
+					// R3 Type
+					line += convert_1(instruction.getSourceOperand1(), 5);
+					line += convert_1(instruction.getSourceOperand2(), 5);
+					line += convert_1(instruction.getDestinationOperand(), 5);
+					line += toBinaryOfSpecificPrecision(0, 12);
+					
+				}
+				else if (op == 29) {
+					line += toBinaryOfSpecificPrecision(0, 27);
+				}
+				else if (op == 24) {
+					// RI Type
+					if (instruction.destinationOperand.getOperandType() == Operand.OperandType.Register) {
+						line += convert(instruction.getDestinationOperand(), 5);
+						line += toBinaryOfSpecificPrecision(0, 22);
+					} else {
+						line += toBinaryOfSpecificPrecision(0, 5);
+						int value = Integer.parseInt(convert(instruction.getDestinationOperand(), 5), 2) - pc;
+						String bin = toBinaryOfSpecificPrecision(value, 22);
+						line += bin.substring(bin.length() - 22);
+					}
+				}
+				else {
+					// R2I Type
+					if (op >= 25 && op <= 28) {
+						int value = Integer.parseInt(convert(instruction.getDestinationOperand(), 5), 2) - pc;
+						line += convert(instruction.getSourceOperand1(), 5);
+						line += convert(instruction.getSourceOperand2(), 5);
+						String bin = toBinaryOfSpecificPrecision(value, 17);
+						line += bin.substring(bin.length() - 17);
+					} else {
+						line += convert(instruction.getSourceOperand1(), 5);
+						line += convert(instruction.getDestinationOperand(), 5);
+						line += convert(instruction.getSourceOperand2(), 17);
+					}
+				}
+				int instInteger = (int) Long.parseLong(line, 2);
+				byte[] instBinary = ByteBuffer.allocate(4).putInt(instInteger).array();
+				file.write(instBinary);
+			}
+			file.close();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

assignment-2/200010024_200010033-1/src/generic/Statistics.java

@@ -0,0 +1,13 @@
+package generic;
+
+public class Statistics {
+	
+	// TODO add your statistics here
+	
+	// TODO write functions to update statistics
+
+	public static void printStatistics(String statFile)
+	{
+		// TODO add code here to print statistics in the output file
+	}
+}

assignment-2/200010024_200010033-1/src/main/Main.java

@@ -0,0 +1,19 @@
+package main;
+import configuration.Configuration;
+import generic.Misc;
+import generic.Statistics;
+import generic.Simulator;
+
+public class Main {
+
+	public static void main(String[] args) {
+		if(args.length != 2)
+		{
+			Misc.printErrorAndExit("usage: java -jar <path-to-jar-file> <path-to-assembly-program> <path-to-object-file>\n");
+		}		
+		
+		Simulator.setupSimulation(args[0]);
+		Simulator.assemble(args[1]);
+	}
+
+}

assignment-2/bin/1.asm

@@ -0,0 +1,9 @@
+	.data
+a:
+	10
+b:
+	20
+	.text
+main:
+	load %x0, $a, %x4
+	end

assignment-2/bin/configuration/config.xml

@@ -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>

assignment-2/bin/generic/.cph/.Simulator.java_74fc5dae77a3b9a48197eb148ed1e37a.prob

@@ -0,0 +1 @@
+{"name":"Local: Simulator","url":"c:\\Users\\karth\\OneDrive\\Desktop\\new\\src\\generic\\Simulator.java","tests":[{"id":1662603879409,"input":"","output":""},{"id":1662603899098,"input":"","output":""}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"c:\\Users\\karth\\OneDrive\\Desktop\\new\\src\\generic\\Simulator.java","group":"local","local":true}

assignment-2/build.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- WARNING: Eclipse auto-generated file.
+              Any modifications will be overwritten.
+              To include a user specific buildfile here, simply create one in the same
+              directory with the processing instruction <?eclipse.ant.import?>
+              as the first entry and export the buildfile again. --><project basedir="." default="build" name="CustomISAAssembler">
+    <property environment="env"/>
+    <property name="debuglevel" value="source,lines,vars"/>
+    <property name="target" value="1.8"/>
+    <property name="source" value="1.8"/>
+    <path id="CustomISAAssembler.classpath">
+        <pathelement location="bin"/>
+    </path>
+    <target name="init">
+        <mkdir dir="bin"/>
+        <copy includeemptydirs="false" todir="bin">
+            <fileset dir="src">
+                <exclude name="**/*.launch"/>
+                <exclude name="**/*.java"/>
+            </fileset>
+        </copy>
+    </target>
+    <target name="clean">
+        <delete dir="bin"/>
+    </target>
+    <target depends="clean" name="cleanall"/>
+    <target depends="build-subprojects,build-project" name="build"/>
+    <target name="build-subprojects"/>
+    <target depends="init" name="build-project">
+        <echo message="${ant.project.name}: ${ant.file}"/>
+        <javac debug="true" debuglevel="${debuglevel}" destdir="bin" includeantruntime="false" source="${source}" target="${target}">
+            <src path="src"/>
+            <classpath refid="CustomISAAssembler.classpath"/>
+        </javac>
+    </target>
+    <target name="make-jar" depends="build">
+        <mkdir dir="jars"/>
+        <jar destfile="jars/assembler.jar" basedir="bin">
+            <manifest>
+                <attribute name="Main-Class" value="main.Main"/>
+            </manifest>
+        </jar>
+    </target>
+</project>

assignment-2/supporting_files/bin/1.asm

@@ -0,0 +1,9 @@
+	.data
+a:
+	10
+b:
+	20
+	.text
+main:
+	load %x0, $a, %x4
+	end

assignment-2/supporting_files/src/1.asm

@@ -0,0 +1,9 @@
+	.data
+a:
+	10
+b:
+	20
+	.text
+main:
+	load %x0, $a, %x4
+	end

assignment-2/supporting_files/src/generic/Simulator.java

@@ -1,89 +1,68 @@
 package generic;
 
 import java.io.FileInputStream;
+import generic.Operand.OperandType;
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
-import java.io.BufferedOutputStream;
-import java.nio.ByteBuffer;
 import java.io.IOException;
-import java.util.Arrays;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
-import java.util.Stack;
-
+import java.util.Scanner;
+import java.io.ByteArrayInputStream;
+import java.nio.ByteBuffer;
 
 public class Simulator {
 		
 	static FileInputStream inputcodeStream = null;
-	public static Map<Instruction.OperationType, String> mapping = new HashMap<Instruction.OperationType, String>();
-	static {
-		mapping.put(Instruction.OperationType.add, "00000");
-		mapping.put(Instruction.OperationType.addi, "00001");
-		mapping.put(Instruction.OperationType.sub, "00010");
-		mapping.put(Instruction.OperationType.subi, "00011");
-		mapping.put(Instruction.OperationType.mul, "00100");
-		mapping.put(Instruction.OperationType.muli, "00101");
-		mapping.put(Instruction.OperationType.div, "00110");
-		mapping.put(Instruction.OperationType.divi, "00111");
-		mapping.put(Instruction.OperationType.and, "01000");
-		mapping.put(Instruction.OperationType.andi, "01001");
-		mapping.put(Instruction.OperationType.or, "01010");
-		mapping.put(Instruction.OperationType.ori, "01011");
-		mapping.put(Instruction.OperationType.xor, "01100");
-		mapping.put(Instruction.OperationType.xori, "01101");
-		mapping.put(Instruction.OperationType.slt, "01110");
-		mapping.put(Instruction.OperationType.slti, "01111");
-		mapping.put(Instruction.OperationType.sll, "10000");
-		mapping.put(Instruction.OperationType.slli, "10001");
-		mapping.put(Instruction.OperationType.srl, "10010");
-		mapping.put(Instruction.OperationType.srli, "10011");
-		mapping.put(Instruction.OperationType.sra, "10100");
-		mapping.put(Instruction.OperationType.srai, "10101");
-		mapping.put(Instruction.OperationType.load, "10110");
-		mapping.put(Instruction.OperationType.end, "11101");
-		mapping.put(Instruction.OperationType.beq, "11001");
-		mapping.put(Instruction.OperationType.jmp, "11000");
-		mapping.put(Instruction.OperationType.bne, "11010");
-		mapping.put(Instruction.OperationType.blt, "11011");
-		mapping.put(Instruction.OperationType.bgt, "11100");
+
+	public static Map<String, String> map = new HashMap<>() {
+		{
+			put("add", "00000");
+			put("sub", "00010");
+			put("mul", "00100");
+			put("div", "00110");
+			put("and", "01000");
+			put("or", "01010");
+			put("xor", "01100");
+			put("slt", "01110");
+			put("sll", "10000");
+			put("srl", "10010");
+			put("sra", "10100");
+			put("beq", "11001");
+			put("bne", "11010");
+			put("blt", "11011");
+			put("bgt", "11100");
+			put("load", "10110");
+			put("store", "10111");
+			put("jmp", "11000");
+			put("addi", "00001");
+			put("subi", "00011");
+			put("muli", "00101");
+			put("divi", "00111");
+			put("andi", "01001");
+			put("ori", "01011");
+			put("xori", "01101");
+			put("slti", "01111");
+			put("slli", "10001");
+			put("srli", "10011");
+			put("srai", "10101");
+			put("end", "11101");
+
 		}
-
-
-	public static void setupSimulation(String assemblyProgramFile) {
-		int firstCodeAddress = ParsedProgram.parseDataSection(assemblyProgramFile);
-		ParsedProgram.parseCodeSection(assemblyProgramFile, firstCodeAddress);
-		ParsedProgram.printState();
-	}
-	
+	};
 	private static String toBinaryOfSpecificPrecision(int num, int lenOfTargetString) {
 		String binary = String.format("%" + lenOfTargetString + "s", Integer.toBinaryString(num)).replace(' ', '0');
 		return binary;
 	}
+	private static String convert_1(Operand inst, int precision) {
+		
+		return toBinaryOfSpecificPrecision(inst.getValue(), precision);
 		
-	private static int toSignedInteger(String binary) {
-		int n = 32 - binary.length();
-        char[] sign_ext = new char[n];
-        Arrays.fill(sign_ext, binary.charAt(0));
-        int signedInteger = (int) Long.parseLong(new String(sign_ext) + binary, 2);
-        return signedInteger;
 	}
-	
-	private static String toBinaryString(int n) {
-		// Remove this conditional statement
-		// if (n >= 0) return String.valueOf(n);
-
-		Stack<Integer> bits = new Stack<>();
-		do {
-			bits.push(n % 2);
-			n /= 2;
-		} while (n != 0);
-
-		StringBuilder builder = new StringBuilder();
-		while (!bits.isEmpty()) {
-			builder.append(bits.pop());
-		}
-		return " " + builder.toString();
-	}
-
 	private static String convert(Operand inst, int precision) {
 		if (inst == null)
 			return toBinaryOfSpecificPrecision(0, precision);
@@ -91,106 +70,84 @@ public class Simulator {
 		if (inst.getOperandType() == Operand.OperandType.Label)
 			return toBinaryOfSpecificPrecision(ParsedProgram.symtab.get(inst.getLabelValue()), precision);
 
-		// write logic for converting to binary/ hex
 		return toBinaryOfSpecificPrecision(inst.getValue(), precision);
-		// check if inst is a label, in that case, use its value 
-		// return String.valueOf(inst.getValue());
+		
+	}
+	public static void setupSimulation(String assemblyProgramFile)
+	{	
+		int firstCodeAddress = ParsedProgram.parseDataSection(assemblyProgramFile);
+		ParsedProgram.parseCodeSection(assemblyProgramFile, firstCodeAddress);
+		ParsedProgram.printState();
 	}
 	
-	public static void assemble(String objectProgramFile) {
+	public static void assemble(String objectProgramFile)
+	{
+		
 		FileOutputStream file;
 		try {
-			//1. open the objectProgramFile in binary mode
 			file = new FileOutputStream(objectProgramFile);
-			BufferedOutputStream bfile = new BufferedOutputStream(file);
-
-			//2. write the firstCodeAddress to the file
-			byte[] addressCode = ByteBuffer.allocate(4).putInt(ParsedProgram.firstCodeAddress).array();
-			bfile.write(addressCode);
-
-			//3. write the data to the file
-			for (int value: ParsedProgram.data) {
+			//write the firstCodeAddress to the file
+			file.write(ByteBuffer.allocate(4).putInt(ParsedProgram.firstCodeAddress).array());
+			//write the data to the file
+			for (var value : ParsedProgram.data) {
 				byte[] dataValue = ByteBuffer.allocate(4).putInt(value).array();
-				bfile.write(dataValue);
+				file.write(dataValue);
 			}
+			//assemble one instruction at a time, and write to the file
+			for (var instruction : ParsedProgram.code) {
+				String line = "";
+				String optype=(instruction.operationType).toString();
+				line += map.get(optype);
+				// int op = Integer.parseInt(line, 2);
+				int op=Integer.parseInt(map.get(optype),2);
+				int pc = instruction.getProgramCounter();
 				
-			//4. assemble one instruction at a time, and write to the file
-			for (Instruction inst: ParsedProgram.code) {
-				/**
-				 * inst.getSourceOperand().getValue() will be passed to a function as f()
-				 * that will change decimal to binary and then will return the string
-				 * form of the binary. It will also check if the value is a label,
-				 * in case it is a label, it would call ParsedProgram.symtab.get()
-				 * to get the address corresponding to the label
-				 */
-				String binaryRep = "";
-
-				// print operation type, use toBinaryString() instead of convert()
-				// file.write(mapping.get(inst.getOperationType()));
-				binaryRep += mapping.get(inst.getOperationType());
-				int opCode = Integer.parseInt(binaryRep, 2);
-				// System.out.println(inst.getOperationType() + " " + mapping.get(inst.getOperationType()));
-				// System.out.println(mapping);
-				// System.out.println(inst.getProgramCounter());
-				int pc = inst.getProgramCounter();
-				
-				if (opCode <= 20 && opCode % 2 == 0) {
+				if (op <= 20 && op % 2 == 0) {
 					// R3 Type
-					binaryRep += convert(inst.getSourceOperand1(), 5);
-					binaryRep += convert(inst.getSourceOperand2(), 5);
-					binaryRep += convert(inst.getDestinationOperand(), 5);
-					binaryRep += toBinaryOfSpecificPrecision(0, 12);
+					line += convert_1(instruction.getSourceOperand1(), 5);
+					line += convert_1(instruction.getSourceOperand2(), 5);
+					line += convert_1(instruction.getDestinationOperand(), 5);
+					line += toBinaryOfSpecificPrecision(0, 12);
+					
 				}
-				else if (opCode == 24) {
+				else if (op == 29) {
+					line += toBinaryOfSpecificPrecision(0, 27);
+				}
+				else if (op == 24) {
 					// RI Type
-					if (inst.destinationOperand.getOperandType() == Operand.OperandType.Register) {
-						binaryRep += convert(inst.getDestinationOperand(), 5);
-						binaryRep += toBinaryOfSpecificPrecision(0, 22);
-					}
-					else {						
-						binaryRep += toBinaryOfSpecificPrecision(0, 5);
-						int value = Integer.parseInt(convert(inst.getDestinationOperand(), 5), 2) - pc;
+					if (instruction.destinationOperand.getOperandType() == Operand.OperandType.Register) {
+						line += convert(instruction.getDestinationOperand(), 5);
+						line += toBinaryOfSpecificPrecision(0, 22);
+					} else {
+						line += toBinaryOfSpecificPrecision(0, 5);
+						int value = Integer.parseInt(convert(instruction.getDestinationOperand(), 5), 2) - pc;
 						String bin = toBinaryOfSpecificPrecision(value, 22);
-						binaryRep += bin.substring(bin.length() - 22);
+						line += bin.substring(bin.length() - 22);
 					}
 				}
-				else if (opCode == 29) {
-					binaryRep += toBinaryOfSpecificPrecision(0, 27);
-				}
 				else {
 					// R2I Type
-					if (opCode >= 25 && opCode <= 28) {
-						int value = Integer.parseInt(convert(inst.getDestinationOperand(), 5), 2) - pc;
-						binaryRep += convert(inst.getSourceOperand1(), 5);
-						binaryRep += convert(inst.getSourceOperand2(), 5);
+					if (op >= 25 && op <= 28) {
+						int value = Integer.parseInt(convert(instruction.getDestinationOperand(), 5), 2) - pc;
+						line += convert(instruction.getSourceOperand1(), 5);
+						line += convert(instruction.getSourceOperand2(), 5);
 						String bin = toBinaryOfSpecificPrecision(value, 17);
-						binaryRep += bin.substring(bin.length() - 17);
-					}
-					else {						
-						binaryRep += convert(inst.getSourceOperand1(), 5);
-						binaryRep += convert(inst.getDestinationOperand(), 5);
-						binaryRep += convert(inst.getSourceOperand2(), 17);
+						line += bin.substring(bin.length() - 17);
+					} else {
+						line += convert(instruction.getSourceOperand1(), 5);
+						line += convert(instruction.getDestinationOperand(), 5);
+						line += convert(instruction.getSourceOperand2(), 17);
 					}
 				}
-				int instInteger = (int) Long.parseLong(binaryRep, 2);
+				int instInteger = (int) Long.parseLong(line, 2);
 				byte[] instBinary = ByteBuffer.allocate(4).putInt(instInteger).array();
-				bfile.write(instBinary);
-
-				// System.out.println(instInteger);
-				// if (inst.getSourceOperand1() != null)
-				// 	file.write(convert(inst.getSourceOperand1()));
-				// if (inst.getSourceOperand2() != null)
-				// 	file.write(convert(inst.getSourceOperand2()));
-				// if (inst.getDestinationOperand() != null)
-				// 	file.write(convert(inst.getDestinationOperand()));
-				// file.write(inst.toString());
+				file.write(instBinary);
 			}
-
-			//5. close the file
-			bfile.close();
+			file.close();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}
 }
-

assignment-4/bin/hello.txt

@@ -1,2 +1,4 @@
-Number of instructions executed = 16
-Number of cycles taken = 16
+Number of instructions executed = 421
+Number of cycles taken = 992
+Number of data hazards = 441
+Number of control hazards = 63

assignment-4/src/generic/Simulator.java

@@ -70,13 +70,9 @@ public class Simulator {
 			processor.getOFUnit().performOF();
 			processor.getIFUnit().performIF();
 			Clock.incrementClock();
-
-			Statistics.setNumberOfInstructions(Statistics.getNumberOfInstructions() + 1);
+			// Statistics.setNumberOfInstructions(Statistics.getNumberOfInstructions() + 1);
 			Statistics.setNumberOfCycles(Statistics.getNumberOfCycles() + 1);
 		}
-		
-		// TODO
-		// set statistics
 	}
 	
 	public static void setSimulationComplete(boolean value)

assignment-4/src/generic/Statistics.java

@@ -7,7 +7,8 @@ public class Statistics {
 	// TODO add your statistics here
 	static int numberOfInstructions;
 	static int numberOfCycles;
-	
+	static int datahazards;
+	static int controlhazards;
 
 	public static void printStatistics(String statFile)
 	{
@@ -17,6 +18,8 @@ public class Statistics {
 			
 			writer.println("Number of instructions executed = " + numberOfInstructions);
 			writer.println("Number of cycles taken = " + numberOfCycles);
+			writer.println("Number of data hazards = " + datahazards);
+			writer.println("Number of control hazards = " + controlhazards);
 			
 			// TODO add code here to print statistics in the output file
 			
@@ -45,4 +48,21 @@ public class Statistics {
 		Statistics.numberOfCycles = numberOfCycles;
 	}
 
+	public static int getDatahazards() {
+		return datahazards;
+	}
+
+	public static void setDatahazards(int datahazards) {
+		Statistics.datahazards = datahazards;
+	}
+
+	public static int getControlhazards() {
+		return controlhazards;
+	}
+
+	public static void setControlhazards(int controlhazards) {
+		Statistics.controlhazards = controlhazards;
+	}
+
+
 }

assignment-4/src/hello.txt

@@ -1,2 +1,4 @@
-Number of instructions executed = 55
-Number of cycles taken = 55
+Number of instructions executed = 5
+Number of cycles taken = 14
+Number of data hazards = 3
+Number of control hazards = 2

assignment-4/src/processor/pipeline/Execute.java

@@ -2,6 +2,7 @@ package processor.pipeline;
 import processor.Processor;
 
 import generic.Instruction;
+import generic.Statistics;
 import generic.Instruction.OperationType;
 import generic.Operand.OperandType;
 
@@ -36,6 +37,7 @@ public class Execute {
 			OperationType alu_op = OF_EX_Latch.getInstruction().getOperationType();
 			System.out.println("ALU OP: " + alu_op);
 			boolean noma = false;
+			Statistics.setNumberOfInstructions(Statistics.getNumberOfInstructions() + 1);
 			switch(alu_op)
 			{
 				case add: alu_result = op1 + op2; break;
@@ -174,6 +176,8 @@ public class Execute {
 			if(!noma)
 			{
 				EX_MA_Latch.setMA_enable(true);
+			}else{
+				Statistics.setControlhazards(Statistics.getControlhazards()+2); // stall 2 cycles
 			}
 		}
 	}

assignment-4/src/processor/pipeline/OperandFetch.java

@@ -9,6 +9,7 @@ import processor.Processor;
 import generic.Instruction.OperationType;
 import generic.Operand.OperandType;
 import generic.Operand;
+import generic.Statistics;
 
 public class OperandFetch {
 	Processor containingProcessor;
@@ -154,26 +155,13 @@ public class OperandFetch {
 				}
 			}
 			else if (Arrays.stream(R1I_type_operators).anyMatch(x -> x == opcode)) {
-				if(opcode != 24){
+				if(opcode != 24){ // end
 					Operand rd = new Operand();
 					rd.setOperandType(Operand.OperandType.Register);
 					rd.setValue(Integer.parseInt(bin_instr.substring(5, 10), 2));
 	
 					instr.setDestinationOperand(rd);
-	
-					int imm = Integer.parseInt(bin_instr.substring(10, 32), 2);
-					if (bin_instr.charAt(10)=='1'){
-						imm = -1*twoscompliment(bin_instr.substring(10, 32));
-						System.out.println(bin_instr);
-					}
-					// if (checkdatahazard(new int[] { rd.getValue() })) {
-					// 	noDataHazard = false;
-					// }else{
-					// containingProcessor.getRegisterFile().setProgramCounter(containingProcessor.getRegisterFile().getProgramCounter()-1);
 					OF_EX_Latch.setInstruction(instr);
-					// OF_EX_Latch.setImm(imm);
-					// isEnd = true;
-					// }
 				}
 				else{ // opcode == 24 jmp
 					Operand op = new Operand();
@@ -205,6 +193,7 @@ public class OperandFetch {
 			if(!noDataHazard){
 				IF_EnableLatch.setFreeze(true);
 				System.out.println("\n\nData Hazard - Interlock\n\n");
+				Statistics.setDatahazards(Statistics.getDatahazards() + 1);
 			}
 		}
 		else if (!Proceed) {