1 / 80

The Minimal Instruction Set Computer (MISC) in Java

The Minimal Instruction Set Computer (MISC) in Java. Note: This is the same set of overheads that is used to introduce MISC in CS 320. This version of the overheads has an additional section at the end. That section describes the programming project for CS 304 which is based on MISC.

bikita
Download Presentation

The Minimal Instruction Set Computer (MISC) in Java

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. The Minimal Instruction Set Computer (MISC) in Java

  2. Note: • This is the same set of overheads that is used to introduce MISC in CS 320. • This version of the overheads has an additional section at the end. • That section describes the programming project for CS 304 which is based on MISC.

  3. Part 1. MISC

  4. MISC is a Java simulation of a simple CPU • The architecture makes use of 4 byte words • In the simulation the contents of a register as well as the contents of a byte in memory are modeled by an object containing a character array of 8 bytes

  5. Each bit is then modeled by the presence of either the character ‘1’ or the character ‘0’ in a particular position in one of these 8 byte arrays. • The registers are packaged together in an array named “reg”. • The index of the array identifies the particular register.

  6. Registers: • register name decimal index binary code • identification in reg array of index • unusedreg[0] "00000000" • general purpose • Areg[1] "00000001" • Breg[2] "00000010" • Creg[3] "00000011" • Dreg[4] "00000100"

  7. Registers, cont’d.: • register name decimal index binary code • identification in reg array of index • memory offsets • codeoffsetreg[5] "00000101" • dataoffsetreg[6] "00000110" • unused1 reg[7] "00000111" • unused2 reg[8] "00001000" • unused3 reg[9] "00001001" • flag reg[10] "00001010"

  8. Registers, cont’d.: • register name decimal index binary code • identification in reg array of index • control unit registers • instruction reg[11] "00001011" • operand1 reg[12] "00001100" • operand2 reg[13] "00001101" • extra reg[14] "00001110" • ALU registers • aluinreg1 reg[15] "00001111" • aluinreg2 reg[16] "00010000" • aluoutregreg[17] "00010001"

  9. The memory is also implemented in the simulation as an array • Each element of the array is a machine word • The index of the array represents the offset into the memory, counting by 4 byte words. • Memory: array name memory[]

  10. General Remarks on Machine Instruction Execution • The general rules for both move and arithmetic instructions are these: • A register or a memory variable can be a destination. • A constant, a register, or a memory variable can be a source. • Memory to memory operations are not allowed.

  11. After a program is loaded the machine takes control of execution • This is done by means of a call from the Osystem to the takeControl() method of the Machine • The machine steps through the contents of the code segment until it encounters an empty (“00000000”) instruction byte

  12. Execution starts with the value 0 in the code offset register • The machine takes the contents of 4 contiguous bytes of memory starting at the address in the code offset register • It puts those bytes into the instruction, reg[11]; operand1, reg[12]; operand2, reg[13]; and extra register, reg[14], respectively • After the retrieval of each instruction and before its execution, the code offset is incremented for the next retrieval.

  13. The Machine Instruction Set • The MOVE Instruction • assembly instruction method in simulation machine instruction • MOVE register, registervoid moveDestRegSrcReg() “10000001” • MOVE memory, register void moveToMemFromReg() “10000010” • MOVE register, memory void movetoregfrommem() “10000011” • MOVE memory, constant void movetomemfromconst() “10000100” • MOVE register, constant void movetoregfromconst() “10000101”

  14. The ADD Instruction • assembly instruction method in simulation machine instruction • ADD register, register void addDestRegSrcReg() “10000110” • ADD memory, register void addToMemFromReg() “10000111” • ADD register, memory void addToRegFromMem() “10001000” • ADD memory, constant void addToMemFromConst() “10001001” • ADD register, constant void addToRegFromConst() “10001010”

  15. The SUB Instruction • assembly instruction method in simulation machine instruction • SUB register, register void subDestRegSrcReg() “10001011” • SUB memory, register void subFromMemSrcReg() “10001100” • SUB register, memory void subFromRegSrcMem() “10001101” • SUB memory, constant void subFromMemSrcConst() “10001110” • SUB register, constant void subFromRegSrcConst() “10001111”

  16. The JUMP Instruction • assembly instruction method in simulation machine instruction • JMP unsigned integer void jumpUnconditional() “10010000” • JPOS unsigned integer void jumpOnPositive() “10010001” • JNEG unsigned integer void jumpOnNegative() “10010010” • JZERO unsigned integer void jumpOnZero() “10010011” • JOVER unsigned integer void jumpOnOverflow() “10010100” • The unsigned integer parameter in operand1 is to be interpreted as an offset into code memory • It has to be treated as unsigned, and in order to work correctly it has to fall on a 4 byte instruction boundary

  17. General Remarks on the Form of Machine Language • In a line of executable machine language code the instruction comes first, followed by the destination operand, followed by the source operand • This is followed by an extra space which does not yet have a designated use • If the line of code contains a data declaration rather than an instruction, the first item will be the initial value of the data item, and the remaining three spaces will be unused

  18. A program can take a maximum of 32 lines. • The program will be loaded at offset 0, the data portion first, the program code itself second • Words 0-7 are reserved for data variables • That means that a single program can have a maximum of 8 memory variables • If there are not 8 variables, the unneeded words will be filled with 0’s

  19. The code segment of a machine language program begins at offset 8 • Jump instructions in the code will have to be written with operands incremented by 8.

  20. The source file signals termination with a row of asterisks • When the source program is loaded, the asterisks aren’t loaded. • What is placed in memory instead is a line of 0’s.

  21. Inside the machine, the takeControl() method stops if it encounters an instruction which is all zeros • This means that in memory, a program has to be followed by at least one word where the first byte is zeros • If need be, this will be the 32nd line, meaning a maximum of 31 lines for a program, or up to 8 variables and up to 23 lines of code

  22. An Example Machine Language Program • The example is a machine language program that sums the first 10 integers • The machine language alone with artificial line breaks and segment labels follows • The *’s are used on input to detect the end of the program.

  23. data segment • 00001011000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000

  24. code segment • 10000101000001000000000100000000 • 10000111000000010000010000000000 • 10001010000001000000000100000000 • 10000011000000110000000000000000 • 10001011000000110000010000000000 • 10010001000010010000000000000000 • ********************************

  25. The Example Program Data Segment with Assembly Language Guide • /.DATA/// • This is a directive, not an instruction • 00001011 00000000 00000000 00000000 • /LOOPLIM/X0B// • loop limit data variable, offset 0, value 11 • 00000000 00000000 00000000 00000000 • /ACCUM/X00// • accum data variable, offset 1, value 0

  26. General comments on data variables • Registers can only contain 8 bits, so memory variables are limited to 8 bits • Memory variables have to occur on word boundaries in order to be addressable • Therefore, 3 bytes are wasted for every variable

  27. The Example Program Code Segment with Assembly Language Guide • Only the live code is shown below. • Memory would be filled with 6 additional lines of 4 groups of 8 zeros • These are not shown.

  28. /.CODE/// • This is a directive, not an instruction • 10000101 00000100 00000001 00000000 • /MOVE/D/X01/ • move reg D, const 1 • MISC method: movetoregfromconst4, 1

  29. /.LABEL/LOOPTOP// • This is a directive, labeling a line in the code which can be jumped to • 10000111 00000001 00000100 00000000 • /ADD/ACCUM/D/ • add data offset 1, reg D • MISC method: addtomemfromreg 1, 4

  30. 10001010 00000100 00000001 00000000 • /ADD/D/X01/ • add reg D, 1 • MISC method: addtoregfromconst4, 1 • 10000011 00000011 00000000 00000000 • /MOVE/C/LOOPLIM/ • move reg C, data offset 0 • MISC method: movetoregfrommem3, 0

  31. 10001011 00000011 00000100 00000000 • /SUB/C/D/ • sub reg C, reg D • MISC method: subtractdestregsrcreg3, 4

  32. 10010001 00001001 00000000 00000000   • /JPOS/LOOPTOP// • Since space is reserved for 8 variables, the first instruction comes at word 8. • The label looptop designates the 9th word, or line. • jump on positive to “LABEL” • MISC method: jumponpositive 9 • /.END/// • This is a directive, not an instruction.

  33. Running the Simulation and Using the Operating System Commands • Altogether, the simulation consists of 6 java files: • MachineByte.java, MachineWord.java, Machine.java, Osystem.java, MachineOSProgram.java, and MyTerminalIO.java • Assuming all of the files are in the same directory, compiling and running MachineOSProgram.java will set MISC in motion • When it is running, it presents a simple command line prompt in a DOS window. • The operating system has only 3 commands, rpf, dmc, and exit

  34. rpf • = run program file • Upon entering this command the user is prompted for the name of the program (machine language) file to run. • Note that machine language files have to be simple text files and that when prompted for the file the O/S expects a name with the .txt extension • It will seemingly “accept” files without the extension, but it will not work correctly

  35. dmc • = dump memory contents • Upon entering this command the user is prompted for the name of the output file to create • In this file the system will put the contents of the memory after a program run • Notice that this operating system in effect has no I/O capabilities. • You only know what the program did by looking at the memory contents afterwards. • Note that the output file specified should also be a text file with a .txt extension.

  36. exit • = quit or end the simulation. (Technically this isn’t even really a command…) • Note that a text file named “showfile” should show up in the directory where you run the simulation. • This is caused by a call to the showStuff() method in the simulation code. • It is a debugging tool • Even if things are so messed up that you can’t successfully use dmc, you can still see simulation results • A call to showStuff() can be placed at various locations in the simulation code to capture and output the machine’s contents at that point.

  37. A Summary of the Structure of the Java Simulation by Class, Constructor, and Method • Listed below are the component classes that make up the simulation • Complete html documentation for the simulation code is available • In this summary, important information is emphasized without exhaustively commenting on all aspects of the classes or mentioning all instance variables, constructors, or methods of the classes.

  38. MachineByte • This is a container for an array of 8 characters • Each character is either a 1 or a 0, so this represents a byte in the machine simulation

  39. MachineWord • This is a container for an array of 4 MachineByteobjects • In the machine architecture 1 addressable word equals 4 bytes

  40. Machine • This is the heart of the simulation and its contents can be broken down into several categories • As explained in greater detail above, the hardware of the machine, its registers and memory, are simulated by elements of arrays of the necessary type • These are declared and constructed in Machine

  41. Machine has a general purpose method that may be useful for debugging, showStuff() • This shows the complete contents of the machine, including the registers • This method exists “on the side” and can be used to figure out what is going on with the simulation • It is not intended for use as part of your solution to a programming assignment, except as a debugging tool

  42. Machine has some special purpose methods, which do not support general machine language instructions • Instead, they are used by the Osystem to do I/O. • They are: • loadWordToOffset() • getWordFromOffset()

  43. Machine has some methods which contain the logic for executing a machine language program. • These are: • totalReset() • resetOffsets() • takeControl()

  44. takeControl() is the most fundamental of the execution methods • It is called by the Osystem after a program is loaded

  45. takeControl() contains the built-in logic of • incrementing the codeoffset register • checking the contents of that location in memory • and executing the method that implements the machine language instruction corresponding to the binary code found there

  46. Machine has methods that implement the machine language move, add, subtract, and jump instructions • It also has some helper methods that support arithmetic • One method helps with integer arithmetic when the machine contents are in binary form • Another method sets the flag register to agree with the outcome of an arithmetic operation

  47. Osystem • This has a constructor in which a copy of the Machine is constructed • It also contains two methods: • runProgramFile() • dumpMemoryContents() • runProgramFile() loads a program from an external file and turns execution over to the machine • dumpMemoryContents() stores the current contents of the machine’s memory into an external file

  48. MachineOSProgram • This is a program containing a main() method • It is the simulation driver • In it a copy of the Osystem is constructed • The rest of the program is basically a loop which prompts and checks to see whether the user is entering Osystem commands and file names to go with them • It also supports an exit command, which is not an Osystem command, but is simply the input which causes the MachineOSProgram to stop looping.

  49. MyTerminalIO • This is just my implementation of a simple class that supports input to a program running in a command prompt.

  50. Part 2. Programming Project

More Related