/*
    DrMIPS - Educational MIPS simulator
    Copyright (C) 2013-2015 Bruno Nova <[email protected]>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package brunonova.drmips.simulator;

import brunonova.drmips.simulator.components.*;
import brunonova.drmips.simulator.exceptions.*;
import brunonova.drmips.simulator.util.Dimension;
import brunonova.drmips.simulator.util.Point;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

/**
 * Class that represents and manipulates a simulated MIPS CPU.
 *
 * @author Bruno Nova
 */
public class CPU {
	/** The path to the CPU files, with the trailing slash. */
	public static final String FILENAME_PATH = "cpu/";
	/** The file extension of the CPU files. */
	public static final String FILENAME_EXTENSION = "cpu";
	/** The regular expression to validate register names. */
	public static final String REGNAME_REGEX = "^[a-zA-Z][a-zA-Z\\d]*$";
	/** The prefix char of the registers. */
	public static final char REGISTER_PREFIX = '$';
	/** The extra margin added to the width of the graphical CPU's size. */
	public static final int RIGHT_MARGIN = 10;
	/** The extra margin added to the height of the graphical CPU's size. */
	public static final int BOTTOM_MARGIN = 10;
	/** The unit used in latencies. */
	public static final String LATENCY_UNIT = "ps";
	/** The exponent (e), that multiplied by 10 and the latency gives the real latency in seconds (ps * 10 ^ e). */
	public static final int LATENCY_EXPONENT = -12;
	/** The number of clock cycles executed in <tt>executeAll()</tt> after which it throws an exception. */
	public static final int EXECUTE_ALL_LIMIT_CYCLES = 1000;

	/** The file of the CPU. */
	private File file = null;
	/** The components that the CPU contains. */
	private Map<String, Component> components;
	/** The components that are synchronous (convenience list). */
	private List<Component> synchronousComponents;
	/** The names of the registers (without the prefix). */
	private List<String> registerNames = null;
	/** The loaded instruction set. */
	private InstructionSet instructionSet = null;
	/** The assembler for this CPU. */
	private Assembler assembler = null;
	/** The Program Counter (set automatically in <tt>addComponent()</tt>. */
	private PC pc = null;
	/** The register bank (set automatically in <tt>addComponent()</tt>. */
	private RegBank regbank = null;
	/** The instruction memory (set automatically in <tt>addComponent()</tt>. */
	private InstructionMemory instructionMemory = null;
	/** The control unit (set automatically in <tt>addComponent()</tt>. */
	private ControlUnit controlUnit = null;
	/** The ALU controller (set automatically in <tt>addComponent()</tt>. */
	private ALUControl aluControl = null;
	/** The ALU (set automatically in <tt>addComponent()</tt>. */
	private ALU alu = null;
	/** The data memory (set automatically in <tt>addComponent()</tt>. */
	private DataMemory dataMemory = null;
	/** The forwarding unit (set automatically in <tt>addComponent()</tt>. */
	private ForwardingUnit forwardingUnit = null;
	/** The hazard detection unit (set automatically in <tt>addComponent()</tt>. */
	private HazardDetectionUnit hazardDetectionUnit = null;
	/** The IF/ID register, if the CPU is pipelined. */
	private PipelineRegister ifIdReg = null;
	/** The ID/EX register, if the CPU is pipelined. */
	private PipelineRegister idExReg = null;
	/** The EX/MEM register, if the CPU is pipelined. */
	private PipelineRegister exMemReg = null;
	/** The MEM/WB register, if the CPU is pipelined. */
	private PipelineRegister memWbReg = null;

	/** Clock period in LATENCY_UNIT unit. */
	private int clockPeriod;
	/** Clock frequency in Hz. */
	private double clockFrequency;
	/** Number of executed cycles. */
	private int executedCycles = 0;
	/** Number of executed instructions. */
	private int executedInstructions = 0;
	/** Number of forwards. */
	private int forwards = 0;
	/** Number of stalls. */
	private int stalls = 0;
	/** Whether the latencies and critical path should depend on the current instruction. */
	private boolean performanceInstructionDependent = false;
	/** Breakpoint addr . */
	private int breakpointAddr = -1;

	/**
	 * Constructor that should by called by other constructors.
	 */
	protected CPU() {
		components = new TreeMap<>();
		synchronousComponents = new LinkedList<>();
		assembler = new Assembler(this);
	}

	/**
	 * Constructor that should by called by other constructors.
	 * @param file The file of the CPU.
	 */
	protected CPU(File file) {
		this();
		setFile(file);
	}

	/**
	 * Creates a CPU from a JSON file.
	 * <p><b>Don't forget to call <tt>setPerformanceInstructionDependent()</tt> on the CPU!</b></p>.
	 * @param path Path to the JSON file.
	 * @return CPU created from the file.
	 * @throws IOException If the file doesn't exist or an I/O error occurs.
	 * @throws JSONException If the JSON file is malformed.
	 * @throws InvalidCPUException If the CPU is invalid or incomplete
	 * @throws ArrayIndexOutOfBoundsException If an array index is invalid somewhere (like an invalid register).
	 * @throws InvalidInstructionSetException If the instruction set is invalid.
	 * @throws NumberFormatException If an opcode is not a number.
	 */
	public static CPU createFromJSONFile(String path) throws IOException, JSONException, InvalidCPUException, ArrayIndexOutOfBoundsException, InvalidInstructionSetException, NumberFormatException {
		CPU cpu = new CPU(new File(path));
		BufferedReader reader = null;
		String file = "", line, parentPath = ".";

		// Read file to String
		try {
			File f = new File(path);
			parentPath = f.getParentFile().getAbsolutePath();
			reader = new BufferedReader(new InputStreamReader(new FileInputStream(f), "UTF8"));
			while((line = reader.readLine()) != null)
				file += line + "\n";
			reader.close();
		}
		catch(IOException e) {
			throw e;
		}
		finally {
			if(reader != null) reader.close();
		}

		// Parse the JSON file
		JSONObject json = new JSONObject(file);
		parseJSONComponents(cpu, json.getJSONObject("components"), parentPath);
		cpu.checkRequiredComponents();
		if(cpu.hasForwardingUnit()) cpu.forwardingUnit.setRegbank(cpu.getRegBank());
		if(cpu.hasHazardDetectionUnit()) cpu.hazardDetectionUnit.setRegbank(cpu.getRegBank());
		if(json.has("reg_names")) parseJSONRegNames(cpu, json.getJSONArray("reg_names"));
		cpu.instructionSet = new InstructionSet(parentPath + File.separator + json.getString("instructions"));
		cpu.controlUnit.setControl(cpu.getInstructionSet().getControl(), cpu.getInstructionSet().getOpCodeSize());
		if(cpu.hasALUControl()) cpu.aluControl.setControlALU(cpu.getInstructionSet().getControlALU());
		if(cpu.hasALU()) cpu.alu.setControlALU(cpu.getInstructionSet().getControlALU());
		parseJSONWires(cpu, json.getJSONArray("wires"));
		cpu.determineControlPath();

		for(Component c: cpu.getComponents()) // "execute" all components (initialize all outputs/inputs)
			c.execute();

		cpu.calculatePerformance();

		return cpu;
	}

	private void checkRequiredComponents() throws InvalidCPUException {
		if(pc == null) throw new InvalidCPUException("The program counter is required!");
		if(regbank == null) throw new InvalidCPUException("The register bank is required!");
		if(instructionMemory == null) throw new InvalidCPUException("The instruction memory is required!");
		if(controlUnit == null) throw new InvalidCPUException("The control unit is required!");

		// Check number of pipeline registers (must be 0 or 4)
		int count = 0;
		for(Component c: getComponents())
			if(c instanceof PipelineRegister) count++;
		if(count > 0 && count != 4)
			throw new InvalidCPUException("Pipelined CPUs must have exactly 4 pipeline registers (5 stages)!");
	}

	/**
	 * Calculates the latency in each component and input and determines the critical path of the CPU and of the instruction (if instruction dependent).
	 */
	public final void calculatePerformance() {
		// CPU performance
		calculateAccumulatedLatencies(false);
		determineClockPeriodAndFrequency();
		if(isPerformanceInstructionDependent()) // instruction performance?
			calculateAccumulatedLatencies(true);
		determineCriticalPath();
	}

	/**
	 * Calculates the latency in each component and input and determines the critical path of the instruction.
	 */
	protected final void calculateInstructionPerformance() {
		if(isPerformanceInstructionDependent()) {
			calculateAccumulatedLatencies(true);
			determineCriticalPath();
		}
	}

	/**
	 * Calculates the accumulated latencies of all components.
	 * @param instructionDependent If <tt>true</tt>, the latencies will depend on the current instruction.
	 */
	protected final void calculateAccumulatedLatencies(boolean instructionDependent) {
		for(Component c: getComponents()) // reset latencies and critical path
			c.resetPerformance();

		for(Component c: synchronousComponents) // calculate latencies
			c.updateAccumulatedLatency(instructionDependent);
	}

	/**
	 * Resets the latencies of all the components to their original latencies.
	 */
	public final void resetLatencies() {
		for(Component c: getComponents())
			c.resetLatency();
		calculatePerformance();
	}

	/**
	 * Sets the latencies of all components to 0 (zero).
	 */
	public final void removeLatencies() {
		for(Component c: getComponents())
			c.setLatency(0);
		calculatePerformance();
	}

	/**
	 * Returns the highest accumulated latency.
	 * @return Highest accumulated latency.
	 */
	private int findHighestAccumulatedLatency() {
		int maxLatency = 0;
		for(Component c: getComponents()) {
			if(c.getAccumulatedLatency() > maxLatency)
				maxLatency = c.getAccumulatedLatency();
			for(Input i: c.getInputs()) {
				if(i.getAccumulatedLatency() > maxLatency)
					maxLatency = i.getAccumulatedLatency();
			}
		}
		return maxLatency;
	}

	/**
	 * Returns the input(s) with the highest accumulated latency.
	 * @param instructionDependent Whether the result should depend on the current instruction-
	 * @return Input(s) with the highest accumulated latency.
	 */
	private List<Input> findHighetsAccumulatedLatencyInputs(boolean instructionDependent) {
		List<Input> maxIns = new LinkedList<>();
		int maxLatency = -1;
		Collection<Component> comps = isPerformanceInstructionDependent() ? synchronousComponents : components.values();
		for(Component c: comps) {
			if(!isPerformanceInstructionDependent() || ((Synchronous)c).isWritingState()) {
				for(Input in: c.getInputs()) {
					if(in.isConnected()) {
						if(in.getAccumulatedLatency() > maxLatency) {
							maxIns.clear();
							maxIns.add(in);
							maxLatency = in.getAccumulatedLatency();
						}
						else if(in.getAccumulatedLatency() == maxLatency)
							maxIns.add(in);
					}
				}
			}
		}
		if(maxIns.isEmpty() && instructionDependent) // no inputs for instruction? Fallback to use all inputs
			return findHighetsAccumulatedLatencyInputs(false);
		else
			return maxIns;
	}

	/**
	 * Determines the clock period and frequency, setting the respective variables.
	 */
	private void determineClockPeriodAndFrequency() {
		clockPeriod = findHighestAccumulatedLatency();
		if(clockPeriod > 0)
			clockFrequency = 1.0 / (clockPeriod * Math.pow(10, LATENCY_EXPONENT));
		else
			clockFrequency = 0;
	}

	/**
	 * Returns the clock period in the LATENCY_UNIT unit.
	 * @return Clock period of the CPU.
	 */
	public int getClockPeriod() {
		return clockPeriod;
	}

	/**
	 * Returns the clock frequency in Hz.
	 * @return Clock frequency in Hz.
	 */
	public double getClockFrequencyInHz() {
		return clockFrequency;
	}

	/**
	 * Returns the clock frequency in MHz.
	 * @return Clock frequency in MHz.
	 */
	public double getClockFrequencyInMHz() {
		return clockFrequency / Math.pow(10, 6);
	}

	/**
	 * Returns the clock frequency in GHz.
	 * @return Clock frequency in GHz.
	 */
	public double getClockFrequencyInGHz() {
		return clockFrequency / Math.pow(10, 9);
	}

	/**
	 * Returns the clock frequency as string in an adequate unit.
	 * @return Clock frequency as string with adequate unit.
	 */
	public String getClockFrequencyInAdequateUnit() {
		double mhz, ghz;
		if((ghz = getClockFrequencyInGHz()) >= 1.0)
			return String.format("%.2f", ghz) + " GHz";
		else if((mhz = getClockFrequencyInMHz()) >= 1.0)
			return String.format("%.2f", mhz) + " MHz";
		else
			return String.format("%.2f", getClockFrequencyInHz()) + " Hz";
	}

	/**
	 * Returns the number of executed clock cycles.
	 * @return Number of executed cycles.
	 */
	public int getNumberOfExecutedCycles() {
		return executedCycles;
	}

	/**
	 * Returns the number of executed instructions.
	 * @return Number of executed instructions.
	 */
	public int getNumberOfExecutedInstructions() {
		return executedInstructions;
	}

	/**
	 * Returns the CPI.
	 * @return Cycles Per Instruction.
	 */
	public double getCPI() {
		if(getNumberOfExecutedInstructions() > 0)
			return (double)getNumberOfExecutedCycles() / (double)getNumberOfExecutedInstructions();
		else
			return 0.0;
	}

	/**
	 * Returns the CPI as a formatted string.
	 * @return CPI as string.
	 */
	public String getCPIAsString() {
		return String.format("%.2f", getCPI());
	}

	/**
	 * Returns the amount of time spent executing the program.
	 * @return Execution time (in LATENCY_UNIT unit).
	 */
	public long getExecutionTime() {
		return (long)getNumberOfExecutedCycles() * (long)getClockPeriod();
	}

	/**
	 * Returns the number of forwards.
	 * @return Number of forwards.
	 */
	public int getNumberOfForwards() {
		return forwards;
	}

	/**
	 * Returns the number of stalls.
	 * @return Number of stalls.
	 */
	public int getNumberOfStalls() {
		return stalls;
	}

	/**
	 * Returns whether the latencies and critical path depend on the current instruction.
	 * @return <tt>true</tt> if the performance depends on the current instruction.
	 */
	public boolean isPerformanceInstructionDependent() {
		return performanceInstructionDependent;
	}

	/**
	 * Resets the statistics to zero.
	 */
	protected void resetStatistics() {
		executedCycles = 0;
		executedInstructions = 0;
		forwards = 0;
		stalls = 0;
	}

	/**
	 * Determines the CPU's critical path
	 */
	private void determineCriticalPath() {
		List<Input> maxIns = findHighetsAccumulatedLatencyInputs(isPerformanceInstructionDependent());

		if(!maxIns.isEmpty()) {
			for(Input in: maxIns) {
				in.getConnectedOutput().setInCriticalPath(true);
				determineCriticalPath(in.getConnectedOutput().getComponent());
			}
		}
	}

	/**
	 * Determines the critical path up to the specified component (recursively).
	 * @param c The component.
	 */
	private void determineCriticalPath(Component component) {
		int lat = component.getAccumulatedLatency() - component.getLatency();
		for(Input i: component.getInputs()) {
			if(i.canChangeComponentAccumulatedLatency() && i.getAccumulatedLatency() == lat
				&& i.isConnected() && !i.getConnectedOutput().isInCriticalPath()) {
				i.getConnectedOutput().setInCriticalPath(true);
				determineCriticalPath(i.getConnectedOutput().getComponent());
			}
		}
	}

	/**
	 * Sets whether the latencies and critical path should depend on the current instruction.
	 * <p><b>This method should be called after loading a CPU.</b></p>
	 * @param instructionDependent Whether the performance should depend on the current instruction.
	 */
	public void setPerformanceInstructionDependent(boolean instructionDependent) {
		if(performanceInstructionDependent != instructionDependent) {
			performanceInstructionDependent = instructionDependent;
			calculateAccumulatedLatencies(performanceInstructionDependent);
			determineCriticalPath();
		}
	}

	/**
	 * Updates the list of components and wires that are in the control path.
	 */
	public final void determineControlPath() {
		controlUnit.setInControlPath();
		if(alu != null) alu.getZero().setInControlPath();
		if(aluControl != null) aluControl.setInControlPath();
		if(forwardingUnit != null) forwardingUnit.setInControlPath();
		if(hazardDetectionUnit != null) hazardDetectionUnit.setInControlPath();
	}

	/**
	 * Returns whether the CPU is pipelined.
	 * @return <tt>True</tt> if the CPU is pipelined.
	 */
	public boolean isPipeline() {
		return ifIdReg != null;
	}

	/**
	 * Sets the file of the CPU.
	 * @param file The file.
	 */
	public final void setFile(File file) {
		this.file = file;
	}

	/**
	 * Returns the file of the CPU.
	 * @return The file of the CPU.
	 */
	public final File getFile() {
		return file;
	}

	/**
	 * Returns the graphical size of the CPU.
	 * <p>The size is calculated here, so avoid calling this method repeteadly!</p>
	 * @return Size of the graphical CPU.
	 */
	public Dimension getSize() {
		int x, y, width, height;
		width = height = 0;

		for(Component c: getComponents()) { // check each component's position + size and output wires points
			// Component's position + size
			x = c.getPosition().x + c.getSize().width;
			y = c.getPosition().y + c.getSize().height;
			if(x > width) width = x;
			if(y > height) height = y;

			// Component's outputs points
			for(Output o: c.getOutputs()) {
				if(o.isConnected()) {
					o.getPosition();
					if(o.getPosition() != null) { // start point
						x = o.getPosition().x;
						y = o.getPosition().y;
						if(x > width) width = x;
						if(y > height) height = y;
					}
					if(o.getConnectedInput().getPosition() != null) { // end point
						x = o.getConnectedInput().getPosition().x;
						y = o.getConnectedInput().getPosition().y;
						if(x > width) width = x;
						if(y > height) height = y;
					}
					for(Point p: o.getIntermediatePoints()) { // intermediate points
						if(p.x > width) width = p.x;
						if(p.y > height) height = p.y;
					}
				}
			}
		}

		return new Dimension(width + RIGHT_MARGIN, height + BOTTOM_MARGIN);
	}

	/**
	 * Assembles the given code and updates the CPU's instruction and data memory-
	 * @param code The code to assemble.
	 * @throws SyntaxErrorException If the code has a syntax error.
	 */
	public void assembleCode(String code) throws SyntaxErrorException {
		getAssembler().assembleCode(code);
	}

	/**
	 * Loads the given assembled instructions into the instruction memory and
	 * starts the simulation.
	 * @param instructions Program's list of assembled instructions.
	 */
	protected void loadProgram(List<AssembledInstruction> instructions) {
		getInstructionMemory().setInstructions(instructions); // load instructions to memory
		clearPreviousCycles(); // clear all components' saved states
		setPCAddress(0); // reset PC
		if(isPipeline()) { // clears the current instruction index in the pipeline registers
			getIfIdReg().setCurrentInstructionIndex(-1);
			getIdExReg().setCurrentInstructionIndex(-1);
			getExMemReg().setCurrentInstructionIndex(-1);
			getMemWbReg().setCurrentInstructionIndex(-1);
		}
		resetStatistics();

		calculateInstructionPerformance(); // Refresh critical path
	}

	/**
	 * Returns whether the currently loaded program has finished executing.
	 * @return <tt>True</tt> it the program has finished.
	 */
	public boolean isProgramFinished() {
		if(isPipeline())
			return pc.getCurrentInstructionIndex() == -1 && ifIdReg.getCurrentInstructionIndex() == -1
				&& idExReg.getCurrentInstructionIndex() == -1 && exMemReg.getCurrentInstructionIndex() == -1
				&& memWbReg.getCurrentInstructionIndex() == -1;
		else
			return pc.getCurrentInstructionIndex() == -1;
	}

	/**
	 * Executes the currently loaded program until the end.
	 * Or until we hit the breakpoint
	 * @throws InfiniteLoopException If the <tt>EXECUTE_ALL_LIMIT_CYCLES</tt> limit has been reached (possible infinite loop).
	 */
	public void executeAll() throws InfiniteLoopException {
		int cycles = 0;
		while(!isProgramFinished()) {
			if(cycles++ > EXECUTE_ALL_LIMIT_CYCLES) // prevent possible infinite cycles
				throw new InfiniteLoopException();
			executeCycle();

			// check if we have hit the breakpoint
			if (getPC().getAddress().getValue() == breakpointAddr)
			{
				break;
			}
		}
	}

	/**
	 * Sets the breakpoint address.
	 */
	public void setBreakpointAddr(int addr) {
		breakpointAddr = addr;
	}

	/**
	 * "Executes" a clock cycle (a step).
	 */
	public void executeCycle() {
		executedCycles++;
		if(!isPipeline() || memWbReg.getCurrentInstructionIndex() >= 0)
			executedInstructions++;
		if(hasForwardingUnit()) {
			if(getForwardingUnit().getForwardA().getValue() != 0) forwards++;
			if(getForwardingUnit().getForwardB().getValue() != 0) forwards++;
		}
		if(hasHazardDetectionUnit() && getHazardDetectionUnit().getStall().getValue() != 0)
			stalls++;

		saveCycleState();
		for(Component c: synchronousComponents) // execute synchronous actions without propagating output changes
			((Synchronous)c).executeSynchronous();

		// Store index(es) of the instruction(s) being executed
		int index = getPC().getAddress().getValue() / (Data.DATA_SIZE / 8);
		if(index < 0 || index >= getInstructionMemory().getNumberOfInstructions())
			index = -1;
		if(isPipeline()) { // save other instructions in pipeline
			updatePipelineRegisterCurrentInstruction(memWbReg, exMemReg.getCurrentInstructionIndex());
			updatePipelineRegisterCurrentInstruction(exMemReg, idExReg.getCurrentInstructionIndex());
			updatePipelineRegisterCurrentInstruction(idExReg, ifIdReg.getCurrentInstructionIndex());
			updatePipelineRegisterCurrentInstruction(ifIdReg, pc.getCurrentInstructionIndex());
		}
		getPC().setCurrentInstructionIndex(index);

		for(Component c: synchronousComponents) // execute normal actions, propagating output changes
			c.execute();
		for(Component c: getComponents()) // "execute" all components, just to be safe
			c.execute();

		calculateInstructionPerformance(); // Refresh critical path
	}

	/**
	 * Updates the current instruction index stored in the specified pipeline register.
	 * @param reg The pipeline register to update.
	 * @param previousIndex The index of the instruction in the previous stage.
	 */
	private void updatePipelineRegisterCurrentInstruction(PipelineRegister reg, int previousIndex) {
		if(reg.getFlush().getValue() == 1)
				reg.setCurrentInstructionIndex(-1);
			else if(reg.getWrite().getValue() == 1)
				reg.setCurrentInstructionIndex(previousIndex);
	}

	/**
	 * Updates the program counter to a new address.
	 * <p>This method also changes the current instruction index to a correct value,
	 * so call this method instead of <tt>getPC().setAddress()</tt>!</p>
	 * @param address The new address.
	 */
	public void setPCAddress(int address) {
		getPC().setAddress(address); // reset PC
		int index = address / (Data.DATA_SIZE / 8);
		if(index >= 0 && index < getInstructionMemory().getNumberOfInstructions())
			getPC().setCurrentInstructionIndex(index);
		else
			getPC().setCurrentInstructionIndex(-1);
	}

	/**
	 * Saves the state of the current cycle.
	 */
	public void saveCycleState() {
		for(Component c: synchronousComponents)
			((Synchronous)c).pushState();
	}

	/**
	 * Performs a "step back" in the execution if possible (if <tt>hasPreviousCycle() == true</tt>).
	 */
	public void restorePreviousCycle() {
		if(hasPreviousCycle()) {
			for(Component c: synchronousComponents) // restore previous states
				((Synchronous)c).popState();
			for(Component c: synchronousComponents) // execute normal actions, propagating output changes
				c.execute();
			for(Component c: getComponents()) // "execute" all components
				c.execute();

			executedCycles--;
			if(!isPipeline() || memWbReg.getCurrentInstructionIndex() >= 0)
				executedInstructions--;
			if(hasForwardingUnit()) {
				if(getForwardingUnit().getForwardA().getValue() != 0) forwards--;
				if(getForwardingUnit().getForwardB().getValue() != 0) forwards--;
			}
			if(hasHazardDetectionUnit() && getHazardDetectionUnit().getStall().getValue() != 0)
				stalls--;

			calculateInstructionPerformance(); // Refresh critical path
		}
	}

	/**
	 * Returns whether there was a previous cycle executed.
	 * @return <tt>True</tt> if a "step back" is possible (<tt>getPc().hasSavedStates() == true</tt>).
	 */
	public boolean hasPreviousCycle() {
		if(pc != null)
			return pc.hasSavedStates();
		else
			return false;
	}

	/**
	 * Removes all the saved previous cycles.
	 */
	public void clearPreviousCycles() {
		for(Component c: synchronousComponents)
			((Synchronous)c).clearSavedStates();
	}

	/**
	 * Resets the states of the CPU's components to the first cycle.
	 */
	public void resetToFirstCycle() {
		if(hasPreviousCycle()) {
			for(Component c: synchronousComponents) // restore first state
				((Synchronous)c).resetFirstState();
			for(Component c: synchronousComponents) // execute normal actions, propagating output changes
				c.execute();
			for(Component c: getComponents()) // "execute" all components
				c.execute();
			resetStatistics();

			calculateInstructionPerformance(); // Refresh critical path
		}
	}

	/**
	 * Resets the stored data of the CPU to zeros (register bank and data memory).
	 */
	public void resetData() {
		regbank.reset();
		if(hasDataMemory()) dataMemory.reset();
		if(hasALU() && alu instanceof ExtendedALU) ((ExtendedALU)alu).reset();
	}

	/**
	 * Connects the given output to the given input.
	 * @param output Output to connect from.
	 * @param input Input to connect to.
	 * @return The resulting output.
	 * @throws InvalidCPUException If the output or the input are already connected or have different sizes.
	 */
	protected Output connectComponents(Output output, Input input) throws InvalidCPUException {
		output.connectTo(input);
		return output;
	}

	/**
	 * Connects the given output to the given input.
	 * @param outCompId The identifier of the output component.
	 * @param outId The identifier of the output of the output component.
	 * @param inCompId The identifier of the input component.
	 * @param inId The identifier of the input of the input component.
	 * @return The resulting output.
	 * @throws InvalidCPUException If the output or the input are already connected or have different sizes or don't exist.
	 */
	protected Output connectComponents(String outCompId, String outId, String inCompId, String inId) throws InvalidCPUException {
		Component out = getComponent(outCompId);
		Component in = getComponent(inCompId);
		if(out == null) throw new InvalidCPUException("Unknown ID " + outCompId + "!");
		if(in == null) throw new InvalidCPUException("Unknown ID " + inCompId + "!");

		Output o = out.getOutput(outId);
		Input i = in.getInput(inId);
		if(o == null) throw new InvalidCPUException("Unknown ID " + outId + "!");
		if(i == null) throw new InvalidCPUException("Unknown ID " + inId + "!");

		o.connectTo(i);
		return o;
	}

	/**
	 * Returns whether a component with the specified identifier exists.
	 * @param id Component identifier.
	 * @return <tt>true</tt> if the component exists.
	 */
	public final boolean hasComponent(String id) {
		return components.containsKey(id);
	}

	/**
	 * Returns the component with the specified identifier.
	 * @param id Component identifier.
	 * @return The desired component, or <tt>null</tt> if it doesn't exist.
	 */
	public final Component getComponent(String id) {
		return components.get(id);
	}

	/**
	 * Returns an array with all the coponents.
	 * @return Array with all components.
	 */
	public Component[] getComponents() {
		Component[] c = new Component[components.size()];
		return components.values().toArray(c);
	}

	/**
	 * Adds the specified component to the CPU.
	 * @param component The component to add.
	 * @throws InvalidCPUException If the new component makes the CPU invalid.
	 */
	protected final void addComponent(Component component) throws InvalidCPUException {
		if(hasComponent(component.getId())) throw new InvalidCPUException("Duplicated ID " + component.getId() + "!");
		components.put(component.getId(), component);
		if(component instanceof Synchronous)
			synchronousComponents.add(component);
		if(component instanceof PC) {
			if(pc != null) throw new InvalidCPUException("Only one program counter allowed!");
			pc = (PC)component;
		}
		else if(component instanceof RegBank) {
			if(regbank != null) throw new InvalidCPUException("Only one register bank allowed!");
			regbank = (RegBank)component;
		}
		else if(component instanceof InstructionMemory) {
			if(instructionMemory != null) throw new InvalidCPUException("Only one instruction memory allowed!");
			instructionMemory = (InstructionMemory)component;
		}
		else if(component instanceof ControlUnit) {
			if(controlUnit != null) throw new InvalidCPUException("Only one control unit allowed!");
			controlUnit = (ControlUnit)component;
		}
		else if(component instanceof ALUControl) {
			if(aluControl != null) throw new InvalidCPUException("Only one ALU control allowed!");
			aluControl = (ALUControl)component;
		}
		else if(component instanceof ALU) {
			if(alu != null) throw new InvalidCPUException("Only one ALU allowed!");
			alu = (ALU)component;
		}
		else if(component instanceof DataMemory) {
			if(dataMemory != null) throw new InvalidCPUException("Only one data memory allowed!");
			dataMemory = (DataMemory)component;
		}
		else if(component instanceof ForwardingUnit) {
			if(forwardingUnit != null) throw new InvalidCPUException("Only one forwarding unit allowed!");
			forwardingUnit = (ForwardingUnit)component;
		}
		else if(component instanceof HazardDetectionUnit) {
			if(hazardDetectionUnit != null) throw new InvalidCPUException("Only one hazard detection unit allowed!");
			hazardDetectionUnit = (HazardDetectionUnit)component;
		}
		else if(component instanceof PipelineRegister) {
			String id = component.getId().trim().toUpperCase();
			switch (id) {
				case "IF/ID":
					if(ifIdReg != null) throw new InvalidCPUException("Only one IF/ID pipeline register allowed!");
					ifIdReg = (PipelineRegister)component;
					break;
				case "ID/EX":
					if(idExReg != null) throw new InvalidCPUException("Only one ID/EX pipeline register allowed!");
					idExReg = (PipelineRegister)component;
					break;
				case "EX/MEM":
					if(exMemReg != null) throw new InvalidCPUException("Only one EX/MEM pipeline register allowed!");
					exMemReg = (PipelineRegister)component;
					break;
				case "MEM/WB":
					if(memWbReg != null) throw new InvalidCPUException("Only one MEM/WB pipeline register allowed!");
					memWbReg = (PipelineRegister)component;
					break;
				default:
					throw new InvalidCPUException("A pipeline register's identifier must be one of {IF/ID, ID/EX, EX/MEM, MEM/WB}!");
			}
		}
	}

	/**
	 * Returns the loaded instruction set.
	 * @return Loaded instruction set.
	 */
	public final InstructionSet getInstructionSet() {
		return instructionSet;
	}

	/**
	 * Returns the Program Counter.
	 * @return Program Counter.
	 */
	public final PC getPC() {
		return pc;
	}

	/**
	 * Returns the register bank.
	 * @return Register bank.
	 */
	public final RegBank getRegBank() {
		return regbank;
	}

	/**
	 * Returns the instruction memory.
	 * @return Instruction memory.
	 */
	public final InstructionMemory getInstructionMemory() {
		return instructionMemory;
	}

	/**
	 * Returns the control unit.
	 * @return Control unit.
	 */
	public final ControlUnit getControlUnit() {
		return controlUnit;
	}

	/**
	 * Returns the ALU control.
	 * @return ALU control.
	 */
	public final ALUControl getALUControl() {
		return aluControl;
	}

	/**
	 * Returns whether the CPU contains an ALU control.
	 * @return <tt>True</tt> if an ALU control exists.
	 */
	public final boolean hasALUControl() {
		return aluControl != null;
	}

	/**
	 * Returns the ALU.
	 * @return ALu.
	 */
	public final ALU getALU() {
		return alu;
	}

	/**
	 * Returns whether the CPU contains an ALU.
	 * @return <tt>True</tt> if an ALU exists.
	 */
	public final boolean hasALU() {
		return alu != null;
	}

	/**
	 * Returns the data memory.
	 * @return Data memory.
	 */
	public final DataMemory getDataMemory() {
		return dataMemory;
	}

	/**
	 * Returns whether the CPU contains data memory.
	 * @return <tt>True</tt> if a data memory exists.
	 */
	public final boolean hasDataMemory() {
		return dataMemory != null;
	}

	/**
	 * Returns the forwarding unit.
	 * @return Forwarding unit.
	 */
	public final ForwardingUnit getForwardingUnit() {
		return forwardingUnit;
	}

	/**
	 * Returns whether the CPU contains a forwarding unit.
	 * @return <tt>True</tt> if a forwarding unit exists.
	 */
	public final boolean hasForwardingUnit() {
		return forwardingUnit != null;
	}

	/**
	 * Returns the hazard detection unit.
	 * @return Hazard detection unit.
	 */
	public final HazardDetectionUnit getHazardDetectionUnit() {
		return hazardDetectionUnit;
	}

	/**
	 * Returns whether the CPU contains a hazard detection unit.
	 * @return <tt>True</tt> if a hazard detection unit exists.
	 */
	public final boolean hasHazardDetectionUnit() {
		return hazardDetectionUnit != null;
	}

	/**
	 * Returns the IF/ID pipeline register.
	 * @return IF/ID pipeline register, or <tt>null</tt> if not pipeline.
	 */
	public final PipelineRegister getIfIdReg() {
		return ifIdReg;
	}

	/**
	 * Returns the ID/EX pipeline register.
	 * @return ID/EX pipeline register, or <tt>null</tt> if not pipeline.
	 */
	public final PipelineRegister getIdExReg() {
		return idExReg;
	}

	/**
	 * Returns the EX/MEM pipeline register.
	 * @return EX/MEM pipeline register, or <tt>null</tt> if not pipeline.
	 */
	public final PipelineRegister getExMemReg() {
		return exMemReg;
	}

	/**
	 * Returns the MEM/WB pipeline register.
	 * @return MEM/WB pipeline register, or <tt>null</tt> if not pipeline.
	 */
	public final PipelineRegister getMemWbReg() {
		return memWbReg;
	}

	/**
	 * Returns the index/address of the register with the specified name.
	 * @param name Name of the register (with prefix).
	 * @return The index of the register, or -1 if it doesn't exist.
	 */
	public int getRegisterIndex(String name) {
		name = name.trim().toLowerCase();
		if(name.length() < 2 || name.charAt(0) != REGISTER_PREFIX)
			return -1;
		name = name.substring(1);
		try {
			int index = Integer.parseInt(name);
			// Numeric name (like $0)
			if(index >= 0 && index < regbank.getNumberOfRegisters())
				return index;
			else
				return -1;
		}
		catch(NumberFormatException e) {
			// Register name (like $zero)
			if(registerNames != null)
				return registerNames.indexOf(name);
			else
				return -1;
		}
	}

	/**
	 * Returns the name of the register with the specified index/address.
	 * @param index The index of the register.
	 * @return The name of the register (with prefix).
	 * @throws IndexOutOfBoundsException If the register with the given index doesn't exist.
	 */
	public String getRegisterName(int index) throws IndexOutOfBoundsException {
		if(registerNames != null)
			return REGISTER_PREFIX + registerNames.get(index);
		else
			return REGISTER_PREFIX + "" + index;
	}

	/**
	 * Returns whether a register with the given name exists.
	 * @param name Name of the register (with prefix).
	 * @return <tt>true</tt> if the register exists.
	 */
	public boolean hasRegister(String name) {
		return getRegisterIndex(name) != -1;
	}

	/**
	 * Returns the assembler for this CPU.
	 * @return The assembler for this CPU.
	 */
	public Assembler getAssembler() {
		return assembler;
	}

	/**
	 * Parses and creates the components from the given JSON array.
	 * @param cpu The CPU to add the components to.
	 * @param components JSONObject that contains the components array.
	 * @param parentPath Path to the cpu file's parent directory.
	 * @throws JSONException If the JSON file is malformed.
	 * @throws InvalidCPUException If the CPU is invalid or incomplete.
	 */
	private static void parseJSONComponents(CPU cpu, JSONObject components, String parentPath) throws JSONException, InvalidCPUException {
		JSONObject json;
		String type, id;
		Class cl;
		Component comp;

		// ClassLoader to load the built-in components
		ClassLoader loader = CPU.class.getClassLoader();

		// ClassLoader to load custom components
		File parentDir = new File(parentPath + File.separator);
		ClassLoader customLoader;
		try {
			URL[] urls = new URL[] {parentDir.toURI().toURL()};
			customLoader = new URLClassLoader(urls);
		} catch(Exception ex) {
			customLoader = null;
		}

		// Parse the components
		Iterator<String> i = components.keys();
		while(i.hasNext()) {
			id = i.next();
			json = components.getJSONObject(id);
			type = json.getString("type");

			// Load the class with the name specified by "type"
			try {
				// Search in the built-in classes first
				cl = loader.loadClass("brunonova.drmips.simulator.components." + type);
			} catch(ClassNotFoundException ex) {
				// Search in the custom components second
				if(customLoader != null) {
					try {
						cl = customLoader.loadClass(type);
					} catch(ClassNotFoundException ex2) {
						ex2.initCause(ex);
						throw new InvalidCPUException("Unknown component type " + type + "!", ex2);
					}
				} else {
					throw new InvalidCPUException("Unknown component type " + type + "!", ex);
				}
			}

			// Create the component with the (String, JSONObject) contructor
			// and add it to the CPU
			try {
				comp = (Component)cl.asSubclass(Component.class)
				                    .getConstructor(String.class, JSONObject.class)
				                    .newInstance(id, json);
				cpu.addComponent(comp);
			} catch(ClassCastException ex) {
				throw new InvalidCPUException("The " + type + " class is not a subclass of Component!", ex);
			} catch(NoSuchMethodException ex) {
				throw new InvalidCPUException("The " + type + " class is missing the (String, JSONObject) constructor!", ex);
			} catch(InvocationTargetException ex) {
				Throwable target = ex.getCause();
				if(target instanceof InvalidCPUException) {
					throw (InvalidCPUException)target;
				} else if(target instanceof JSONException) {
					throw (JSONException)target;
				} else {
					throw new InvalidCPUException("Failed to create the component " + id + "!", ex);
				}
			} catch(InstantiationException | IllegalAccessException | IllegalArgumentException ex) {
				throw new InvalidCPUException("Failed to create the component " + id + "!", ex);
			}
		}
	}

	/**
	 * Parses wires from the given JSON array and connects the components.
	 * @param cpu The CPU to add wires to.
	 * @param wires JSONArray that contains the wires array.
	 * @throws JSONException If the JSON file is malformed.
	 * @throws InvalidCPUException If the output or the input are already connected or have different sizes or doesn't exist.
	 */
	private static void parseJSONWires(CPU cpu, JSONArray wires) throws JSONException, InvalidCPUException {
		JSONObject wire, point, start, end;
		JSONArray points;
		Output out;

		for(int i = 0; i < wires.length(); i++) {
			wire = wires.getJSONObject(i);
			out = cpu.connectComponents(wire.getString("from"), wire.getString("out"),
				wire.getString("to"), wire.getString("in"));
			points = wire.optJSONArray("points");
			if(points != null) {
				for(int x = 0; x < points.length(); x++) {
					point = points.getJSONObject(x);
					out.addIntermediatePoint(new Point(point.getInt("x"), point.getInt("y")));
				}
			}
			if((start = wire.optJSONObject("start")) != null)
				out.setPosition(new Point(start.getInt("x"), start.getInt("y")));
			if((end = wire.optJSONObject("end")) != null)
				out.getConnectedInput().setPosition(new Point(end.getInt("x"), end.getInt("y")));
		}
	}

	/**
	 * Parses and sets the identifiers of the registers.
	 * @param cpu The CPU to set the registers informations.
	 * @param regs JSONArray that contains the registers.
	 * @throws JSONException If the JSON file is malformed.
	 * @throws InvalidCPUException If not all registers are specified or a register is invalid.
	 */
	private static void parseJSONRegNames(CPU cpu, JSONArray regs) throws JSONException, InvalidCPUException {
		if(regs.length() != cpu.getRegBank().getNumberOfRegisters())
			throw new InvalidCPUException("Not all registers have been specified in the registers block!");
		cpu.registerNames = new ArrayList<>(cpu.getRegBank().getNumberOfRegisters());
		String id;

		for(int i = 0; i < regs.length(); i++) {
			id = regs.getString(i).trim().toLowerCase();

			if(id.isEmpty())
				throw new InvalidCPUException("Invalid name " + id + "!");
			if(!id.matches(REGNAME_REGEX)) // has only letters and digits and starts with a letter?
				throw new InvalidCPUException("Invalid name " + id + "!");
			if(cpu.hasRegister(REGISTER_PREFIX + id))
				throw new InvalidCPUException("Invalid name " + id + "!");

			cpu.registerNames.add(id);
		}
	}
}