1 / 65

Kirk Scott Computer Science The University of Alaska Anchorage

The Minimal Instruction Set Computer (MISC) in Java: Demonstration of Graphical User Interface Programming Concepts. Kirk Scott Computer Science The University of Alaska Anchorage. Overall Plan of Overheads. 1. An explanation of MISC in general

vladimir-reyes
Download Presentation

Kirk Scott Computer Science The University of Alaska Anchorage

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:Demonstration of Graphical User InterfaceProgramming Concepts Kirk Scott Computer Science The University of Alaska Anchorage

  2. Overall Plan of Overheads • 1. An explanation of MISC in general • 2. Graphical user interface modifications • 3. Conclusion

  3. 1. An explanation of MISC in general

  4. An Introduction to MISC • MISC is a Java simulation of a simple CPU • The simulation includes a simple machine language • Machine programs can be written in this language

  5. MISC contains a simple operating system • The operating system functions are written in Java as part of the simulation • In MISC, absolute machine code is loaded at memory address 0 and executed there • Program loading and execution in MISC can be modified in several ways

  6. The Basic Structure of MISC • Bytes and registers • Bytes, words, and memory • General remarks on machine instruction execution • Fetch, decode, and execute • The machine language instruction set

  7. The Basic Structure, Continued • General remarks on the form of machine language • An example program • The Java methods comprising the simulation • The command line interface • A summary of the structure of the Java simulation by class, constructor, and method

  8. Bytes and Registers • The MISC architecture makes use of 4 byte words • The contents of a register are modeled by an object containing a character array of 8 bytes

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

  10. 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"

  11. 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"

  12. 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"

  13. Bytes, Words, and Memory • A word in MISC consists of 4 bytes • Memory is implemented as an array of words • The index of the array is the word offset into memory • Memory: array name • memory[]

  14. General Remarks on Machine Instruction Execution • These are the general rules for move and arithmetic instructions • 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

  15. Fetch, Decode, and Execute • A program is loaded to memory location 0 by default • The machine takes control of execution • The machine steps through the program code until it encounters an empty (“00000000”) instruction byte

  16. Execution starts with the value 0 in the code offset register • The next 4 contiguous bytes of code memory are put into the instruction, operand1, operand2, and extra registers • After the retrieval of each instruction the code offset is incremented for the next retrieval

  17. The Machine Language 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”

  18. 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”

  19. 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”

  20. 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”

  21. General Remarks on the Form of Machine Language • The data declarations come first, then the program code • The program will be loaded at offset 0 • Words 0-7 are reserved for data variables and will be filled with 0’s if there are not that many variables • No program, including data, can be longer than 31 lines • The source file signals termination with a row of asterisks

  22. Data Declaration Line • Byte 1: value • Bytes 2-4: unused • Line of Code • Byte 1: instruction • Byte 2: operand 1 • Byte 3: operand 2 • Byte 4: unused

  23. 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.

  24. data segment • 00001011000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000

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

  26. The Example Program Data Segment with Assembly Language Guide • /.DATA/// • 00001011 00000000 00000000 00000000 • /LOOPLIM/X0B// • loop limit offset 0, value 11 • 00000000 00000000 00000000 00000000 • /ACCUM/X00// • accumulator offset 1, value 0

  27. The Example Program Code Segment with Assembly Language Guide • /.CODE/// • 10000101 00000100 00000001 00000000 • /MOVE/D/X01/ • move reg D, const 1 • movetoregfromconst 4, 1 • /.LABEL/LOOPTOP// • 10000111 00000001 00000100 00000000 • /ADD/ACCUM/D/ • (LABEL) add data offset 1, reg D • addtomemfromreg 1, 4

  28. 10001010 00000100 00000001 00000000 • /ADD/D/X01/ • add reg D, 1 • addtoregfromconst 4, 1 • 10000011 00000011 00000000 00000000 • /MOVE/C/LOOPLIM/ • move reg C, data offset 0 • movetoregfrommem 3, 0

  29. 10001011 00000011 00000100 00000000 • /SUB/C/D/ • sub reg C, reg D • subtractdestregsrcreg 3, 4 • 10010001 00001001 00000000 00000000 • /JPOS/LOOPTOP// • Since space is reserved for 8 variables, the first instruction comes at word 8. • jump on positive to “LABEL” • jumponpositive 9 • ******** ******** ******** ******** • /.END///

  30. The Java Files Comprising the Simulation • The simulation consists of 4 java files: • MachineWord.java • Machine.java • Osystem.java • MachineOSProgram.java • MachineOSProgram contains main()

  31. The Command Line Interface • MISC presents these 3 command prompts: • rpf (run program file) • dmc (dump memory contents) • exit

  32. rpf • rpf = run program file • This prompts the user for the machine language program to run • Machine language programs should be text files

  33. dmc • dmc = dump machine contents • This prompts the user for the name of the output file to create • This should be a text file • MISC has no I/O capabilities • You know what a program did by looking at the dmc file

  34. exit • exit = quit the simulation

  35. A Summary of the Structure of the Java Simulation by Class, Constructor, and Method • MachineByte.java • MachineWord.java • Machine.java • This is the heart of the simulation • It contains these critical methods: • totalReset() • resetOffsets() • takeControl()

  36. Osystem.java • This has a constructor in which a copy of the Machine is constructed • It contains these critical methods: • runProgramFile() • dumpMemoryContents()

  37. MachineOSProgram.java • This contains the main() method • It is the simulation driver • In it a copy of the Osystem is constructed • It loops, checking for user input from the command prompt

  38. MyTerminalIO • This presents the command prompt in a graphical user interface

  39. Part 2. Graphical User Interface Modifications

  40. As given so far, the MISC simulation only has a command line interface • The program is an ideal candidate for a graphical user interface • MISC is much easier to use and understand when it is presented visually

  41. This section of the overheads outlines a sequence of 10 steps for developing a visual version of the program • A screenshot of the program will be shown with the first 5 steps implemented • Another screenshot will be shown at the end with all of the steps implemented

  42. Step 1 • Menu • Give the application a frame with a menu • Have the options to do load, run, dump, and exit be menu items with associated listeners • JFileChooser • Use a JFileChooser to handle the information about file names that has to be passed back and forth for the load and dump commands

  43. Step 2 • Editable Registers • Display the register contents of the machine in the graphics frame of the application • The register representations should be capable of both input and output • JTextFields and JLabels • Use JTextFields to represent the registers • Label the registers with JLabels

  44. Step 3 • Stepwise execution • Revise MISC so that one machine language instruction can be executed at a time • Update the registers after the execution of each instruction • JButton • Implement the execution of a single instruction through a button click • (It could also be done as a menu option)

  45. Step 4 • Focus • Add focus to the application • Hitting enter in one register should move the cursor to the next register • Clearing registers • Add a ‘clear’ button that will set the contents of all of the registers to 0 • This should not change the loaded program

  46. Step 5 • Memory • Display the contents of the machine’s memory in the application’s frame • JTextArea and scroll bars • Display the memory using a JTextArea • Memory contents are too large to fit in the frame at the same time • Make sure the JTextArea is contained in scroll bars

  47. Steps 1-5 Screenshot • The screenshot on the next overhead gives some idea of what an implementation of steps 1-5 might look like

  48. Step 6 • Highlight the current instruction • Highlight the instruction in the loaded program that is currently being executed • Do this by changing the background color of that line. • JTextComponent • These JTextComponent methods are relevant: selectAll(), cut(), setCaretPosition(), and moveCaretPosition()

  49. Step 7 • Editable Memory • Make memory editable in the frame • If the program code loaded in the machine is altered, then it is the altered version that should run • The original program file in secondary storage should not be changed

More Related