1 / 62

The Minimal Instruction Set Computer (MISC) in Java: Demonstration of Operating System Concepts

The Minimal Instruction Set Computer (MISC) in Java: Demonstration of Operating System Concepts. Kirk Scott Computer Science The University of Alaska Anchorage. Overall Plan of Overheads. These overheads fall into 3 sections: 1. An explanation of MISC in general

britanni-guerrero
Download Presentation

The Minimal Instruction Set Computer (MISC) in Java: Demonstration of Operating System Concepts

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 Operating System Concepts Kirk Scott Computer Science The University of Alaska Anchorage

  2. Overall Plan of Overheads • These overheads fall into 3 sections: • 1. An explanation of MISC in general • 2. Modifications to MISC • 3. What is the Point of This?

  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. 2. Modifications to MISC • MISC can be modified to illustrate these operating system concepts: • Memory allocation • Absolute code • Relative code • Concurrency and scheduling

  40. By default, programs in MISC are loaded and executed at address 0 in memory • The following overhead shows a dmc file after running the example program

  41. memory contents • 00001011000000000000000000000000 • 00110111000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 10000101000001000000000100000000 • 10000111000000010000010000000000 • 10001010000001000000000100000000 • 10000011000000110000000000000000 • 10001011000000110000010000000000 • 10010001000010010000000000000000 • 00000000000000000000000000000000 • …

  42. Modifications to MISC Which Illustrate Operating System Concepts • Here are three possible modifications to MISC: • 1. Load machine programs at addresses other than 0 • Modify relative code to absolute code for a non-zero address • 2. Load machine programs at addresses other than 0 with dynamic address checking • Load relative code and modify the simulation to check memory accesses

  43. 3. Load and run more than one machine program at a time • This builds on modification 2 • Memory accesses for each loaded program have to be correctly handled • Execution of multiple programs also involves scheduling

  44. Modification 1 • Support program loading at an address other than 0 • Alter the machine program code at load time • Memory address references are changed to correspond with the load address • The loaded program is absolute code for the new address • The following overhead shows a dmc file after running the example program with these modifications

  45. memory contents • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • … • 00001011000000000000000000000000 • 00110111000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 10000101000001000000000100000000 • 10000111001000010000010000000000 • 10001010000001000000000100000000 • 10000011000000110010000000000000 • 10001011000000110000010000000000 • 10010001001010010000000000000000 • 00000000000000000000000000000000 • …

  46. Modification 2 • Support program loading at an address other than 0 • Do not alter the machine program code at load time • A machine language program is loaded to an address other than 0 • The machine code is relative code

  47. Each time the running machine program wants to do a memory access, it returns the relative address in the machine code to the operating system • The operating system checks to see if it’s within range

  48. The operating system adds the memory access to the base address where the program was loaded • The operating system passes this absolute address back to the machine for program memory access • The following overhead shows a dmc file after running the example program with these modifications • It looks no different from the previous modification

  49. memory contents • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • … • 00001011000000000000000000000000 • 00110111000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 00000000000000000000000000000000 • 10000101000001000000000100000000 • 10000111001000010000010000000000 • 10001010000001000000000100000000 • 10000011000000110010000000000000 • 10001011000000110000010000000000 • 10010001001010010000000000000000 • 00000000000000000000000000000000 • …

  50. Modification 3 • Modify MISC to load and run more than one machine language program concurrently • Round robin scheduling can be implemented • Instead of time-slicing, use instruction counts • Switch between from one machine program to another when it has executed a fixed number of instructions • Note that threading of command prompt input is necessary to accomplish this

More Related