Simulation of a very simple computer Solution

Introduction

For this assignment, you will build a complete simulation of a very simple computer. Being simple, our computer only has 100 slots for both memory and instructions and contains just a single register (also known as an accumulator). However, in spite of this, we shall see that our simple computer is fairly capable.

Commands are sent to our computer using words. A word is a four-digit number, e.g. 0000, 0001, 0002, etc. Each word has two components. The first component, contained within the first two digits, indicates the word's operation code (e.g. read, write, etc.). The 3rd and 4th digit represent the 2nd component, which specifies a specific memory address, thereby giving us 100 slots to store words. Execution of a program is guided by an instruction pointer that "points" to the next word to be executed. Unless a JUMP command is encountered, execution continues in linear order, just like a C++ program. Below are all of the possible operations that our simple computer can perform:



Operation Code Explanation



00 – NULL

Does nothing (null instruction).



10 – READ

20 – LOAD

30 – ADD

32 – DIVIDE

40 – JUMP

42 – JUMPZERO

Task

Your task for this
successfully interprets our simple computer's machine code. Second, you must implement an interactive debugger that allows programmers to step through the execution of a program. I illustrate how each of these tasks work in the screenshots below.

Read a word from the command line into a specific location in memory.

Writes a word from a specific location in memory to the command line.

Load a word from a specific memory location into the accumulator register.

Stores a word from the accumulator into a specific location in memory.

Adds a word from a specific location in memory to the word presently in the accumulator. The result is stored in the accumulator.

Divides the value presently stored in the accumulator by the word located in a specific memory location. The result is stored in the accumulator.

Alters the value of the INSTRUCTION POINTER to the specified memory address.

If the accumulator's value is presently zero, alters the value of the INSTRUCTION POINTER to the specified memory address.

11 – WRITE

21 – STORE



31 – SUBTRACT

Subtracts a word located in a specific location in memory from the value presently stored in the accumulator. The result is stored in the accumulator.



33 – MULTIPLY

Multiplies a word located in a specific location in memory by the value presently stored in the accumulator. The result is stored in the accumulator.



41 - JUMPNEG

If the accumulator's value is presently negative, alters the value of the INSTRUCTION POINTER to the specified memory address.



43 – HALT

Indicates the end of a program (execution terminates).

assignment are twofold. First you must write an emulator for our computer that

Sample Output - Loading a Program from a File

Below, I've run the FindLargest code (provided in a section below). This program prompts the user for two integers and displays the largest of the two. In this example, I input the values 3 and 4 and have the value 4 returned to me.

Sample Output - Interactive Console

In these screenshots, I enter the "Find Largest" into the interactive console.









Sample Implementation

My implementation contains a Computer class and several supporting Instruction classes (one for each instruction supported by the Computer). Below are my UML diagrams and an explanation of key functionality:



I use Instruction to represent an instruction supported by the computer. As such, I've created a child class for each instruction (approximately 13 sub classes) and a factory to handle new object creation. Also note that I've created an enum called Operation_t that acts as an easier way to work with operations (i.e. using Read, Write, Load, etc. instead of 10, 11, etc.). Other than that, it's mostly getters and setters with the exception of the virtual execute method:

virtual int execute(int &accumulator, Indexed<Instruction * &memory)

This function executes the given instruction. It's virtual because different instructions will execute differently. For example, store will store the value in the accumulator into the memory address property of the Instruction. My execute method returns the location of the next instruction to the caller.

Computer Class

The Computer class is a little more straightforward. It has a vector of Instructions that act as main memory (note that instructions are stored in memory), a flag to determine if the program has finished (_has_halted), an integer to indicate the next instruction to execute (_instruction_pointer), and a single accumulator. The most interesting aspect of Computer is the executeNextInstruction method:

void executeNextInstruction()

This function uses the instruction pointer to pull out the next Instruction to execute and calls that Instruction's virtual execute method. Note that Computer passes in a reference to both its accumulator and memory to execute(). Also note that I use the integer returned by execute() to update the Computer's instruction pointer.



Sample Programs

To give you a better sense of how our computer executes programs, I've included the following basic programs:

Program #1: Add Two Numbers

The following code will ask the user for two numbers, add them together, and then output the result to the screen.

01 Declare variable B

Read from terminal into A

03 Read from terminal into B

Load A into accumulator

05 Add B to accumulator value

Store accumulator into A

07 Write result (A) to the screen

Program #2: Find Largest

This program will output the largest of two integer values obtained from the user

01 Declare variable B

Read from terminal into A

03 Read from terminal into B

Load A into accumulator

05 Subtract B from accumulator value

07 Write variable A back to the screen

Jump to instruction 10

09 Write variable B back to the screen

Memory Command Location

Comment



00

0000

Declare variable A



0000



02

1000



1001



04

2001



3001



06

2100

1100



08

4300

End of program



Memory Command Location

Comment



00

0000



0000

Declare variable A



02

1000



1001



04

2001

3101



06

4109

Jump to instruction at location 9 if accumulator is negative



1100



08

4010



1101



10

4300

End of program



Program #3: Fibonacci Sequence

This program calculates the Nth Fibonacci number. Note that this program assumes that the user is interested in at least the 3rd Fibonacci number.

Memory Command Comment Location

00 0002 Declare variable A – used to store N-2 value



01 0001 03 0000

05 0001 07 2003

Declare variable B – used to store N-1 value

Declare variable D – used to determine fib value to find

Will always represent the value 1 Load fib value into accumulator



02 0001 Declare variable C – used to store N value



04 0000 Declare variable E – used as a loop counter



06 1003 Get fib value from the user



08 3100 Subtract 2 from accumulator to account for assumption that we are getting at least 3rd fib

number.



09 2103 Store result back into memory

11 2001 Load N-1 value into accumulator



10 4223 While we still have values to calculate...



12 2100 Store accumulator into N-2 value

13 2002

15 3000

Load N value into accumulator

Add N-1 value to accumulator



14 2101 Store accumulator into N-1 value



16 2102 Store accumulator into N value



17 2004 Load counter into accumulator

19 2104 Store updated value back into counter

21 3104 Subtract loop counter

18 3005 Add one to accumulator (i.e. counter)



20 2003 Load fib value into accumulator



22 4010 Jump to start of loop

. 23 1102



. 24 4300



Write current fib value (N) to the screen Program complete.

Header Comment, and Formatting

1. Be sure to modify the file header comment at the top of your script to indicate your name, student ID, completion time, and the names of any individuals that you collaborated with on the assignment.

2. Remember to follow the basic coding style guide. For a list of basic rules, see my website or examine my example files from previous assignments and labs.
Powered by