Menu
Home
People
Places
Arts
History
Plants & Animals
Science
Life & Culture
Technology
Reference.org
Little man computer
open-in-new
<h2 id="execution-cycle">Execution cycle</h2> <p class="note">See also: <a href="/facts/Instruction_cycle/uYmJEfHK">Instruction cycle</a></p> <p>To execute a program, the little man performs these steps: </p> <ol><li>Check the Program Counter for the mailbox number that contains a program instruction (i.e. zero at the start of the program)</li> <li>Fetch the instruction from the mailbox with that number. Each instruction contains two fields: An opcode (indicating the operation to perform) and the address field (indicating where to find the data to perform the operation on).</li> <li>Increment the Program Counter (so that it contains the mailbox number of the next instruction)</li> <li>Decode the instruction. If the instruction uses data stored in another mailbox then use the address field to find the mailbox number for the data it will work on, e.g. "get data from mailbox 42")</li> <li>Fetch the data (from the input, accumulator, or mailbox with the address determined in step 4)</li> <li>Execute the instruction based on the opcode given</li> <li>Branch or store the result (in the output, accumulator, or mailbox with the address determined in step 4)</li> <li>Return to the Program Counter to repeat the cycle or halt</li></ol> <h2 id="commands">Commands</h2> <p>While the LMC does reflect the actual workings of <a href="/facts/Binary_numeral_system/a6JDSRPs">binary</a> processors, the simplicity of <a href="/facts/Decimal/7omfVNIM">decimal</a> numbers was chosen to minimize the complexity for students who may not be comfortable working in binary/<a href="/facts/Hexadecimal/02ohQW22">hexadecimal</a>. </p> <h3>Instructions</h3> <p>Some LMC simulators are programmed directly using 3-digit numeric instructions and some use 3-letter mnemonic codes and labels. In either case, the instruction set is deliberately very limited (typically about ten instructions) to simplify understanding. If the LMC uses mnemonic codes and labels then these are converted into 3-digit numeric instructions when the program is assembled. </p><p>The table below shows a typical numeric instruction set and the equivalent mnemonic codes. </p> Instructions<table><tbody><tr><th>Numeric code</th><th>Mnemonic code</th><th>Instruction</th><th>Description</th></tr><tr><td>1xx</td><td>ADD</td><td>ADD</td><td>Add the value stored in mailbox xx to whatever value is currently on the accumulator (calculator).Note: the contents of the mailbox are not changed, and the actions of the accumulator (calculator) are not defined for add instructions that cause sums larger than 3 digits. Similarly to SUBTRACT, one could set the negative flag on overflow.</td></tr><tr><td>2xx</td><td>SUB</td><td>SUBTRACT</td><td>Subtract the value stored in mailbox xx from whatever value is currently on the accumulator (calculator).Note: the contents of the mailbox are not changed, and the actions of the accumulator are not defined for subtract instructions that cause negative results - however, a negative flag will be set so that 7xx (BRZ) and 8xx (BRP) can be used properly.</td></tr><tr><td>3xx</td><td>STA</td><td>STORE</td><td>Store the contents of the accumulator in mailbox xx (destructive).Note: the contents of the accumulator (calculator) are not changed (non-destructive), but contents of mailbox are replaced regardless of what was in there (destructive)</td></tr><tr><td>5xx</td><td>LDA</td><td>LOAD</td><td>Load the value from mailbox xx (non-destructive) and enter it in the accumulator (destructive).</td></tr><tr><td>6xx</td><td>BRA</td><td><a href="/facts/Branch_(computer_science)/obBGrnor">BRANCH ALWAYS</a>(unconditional)</td><td>Set the program counter to the given address (value xx). That is, the value in mailbox xx will be the next instruction executed.</td></tr><tr><td>7xx</td><td>BRZ</td><td>BRANCH IF ZERO (<a href="/facts/Conditional_(programming)/8gDQTqUD">conditional</a>)</td><td>If the accumulator (calculator) contains the value 000, set the program counter to the value xx. Otherwise, do nothing. Whether the negative flag is taken into account is undefined. When a SUBTRACT underflows the accumulator, this flag is set, after which the accumulator is undefined, potentially zero, causing behavior of BRZ to be undefined on underflow. Suggested behavior would be to branch if accumulator is zero and negative flag is not set.Note: since the program is stored in memory, data and program instructions all have the same address/location format.</td></tr><tr><td>8xx</td><td>BRP</td><td>BRANCH IF POSITIVE (conditional)</td><td>If the accumulator (calculator) is 0 or positive, set the program counter to the value xx. Otherwise, do nothing. As LMC memory cells can only hold values between 0 and 999, this instruction depends solely on the negative flag set by an underflow on SUBTRACT and potentially on an overflow on ADD (undefined).Note: since the program is stored in memory, data and program instructions all have the same address/location format.</td></tr><tr><td>901</td><td>INP</td><td>INPUT</td><td>Go to the INBOX, fetch the value from the user, and put it in the accumulator (calculator)Note: this will overwrite whatever value was in the accumulator (destructive)</td></tr><tr><td>902</td><td>OUT</td><td>OUTPUT</td><td>Copy the value from the accumulator (calculator) to the OUTBOX.Note: the contents of the accumulator are not changed (non-destructive).</td></tr><tr><td>000</td><td>HLT/COB</td><td>HALT/COFFEE BREAK</td><td>Stop working/end the program.</td></tr><tr><td></td><td>DAT</td><td>DATA</td><td>This is an <a href="/facts/Assembly_language/7XuV0cla">assembler</a> instruction which reseerves a mailbox for storing data. It can be given a number to store at the start of the program, for example DAT 984 will store the value 984 into a mailbox at the address of the DAT instruction. DAT can also be used in conjunction with labels to declare variables.</td></tr></tbody></table> <h3>Examples</h3> <h4>Using numeric instruction codes</h4> <p>This program (instruction 901 to instruction 000) is written just using numeric codes. The program takes two numbers as input and outputs the difference. Notice that execution starts at Mailbox 00 and finishes at Mailbox 07. The disadvantages of programming the LMC using numeric instruction codes are discussed below. </p> <table><tbody><tr><th>Mailbox</th><th>Numeric code</th><th>Operation</th><th>Comments</th></tr><tr><td>00</td><td>901</td><td>Accumulator = Inbox</td><td>INPUT the first number, enter into calculator (erasing whatever was there)</td></tr><tr><td>01</td><td>308</td><td>Mailbox 08 = Accumulator</td><td>STORE the calculator's current value (to prepare for the next step…)</td></tr><tr><td>02</td><td>901</td><td>Accumulator = Inbox</td><td>INPUT the second number, enter into calculator (erasing whatever was there)</td></tr><tr><td>03</td><td>309</td><td>Mailbox 09 = Accumulator</td><td>STORE the calculator's current value (again, to prepare for the next step…)</td></tr><tr><td>04</td><td>508</td><td>Accumulator = Mailbox 08</td><td>(Now that both INPUT values are STORED in Mailboxes 08 and 09…)<p>LOAD the first value back into the calculator (erasing whatever was there)</p></td></tr><tr><td>05</td><td>209</td><td>Accumulator = Accumulator - Mailbox 09</td><td>SUBTRACT the second number from the calculator's current value (which was just set to the first number)</td></tr><tr><td>06</td><td>902</td><td>Outbox = Accumulator</td><td>OUTPUT the calculator's result to the OUTBOX</td></tr><tr><td>07</td><td>000</td><td>Stop</td><td>HALT the LMC</td></tr></tbody></table> <h4>Using mnemonics and labels</h4> <p><a href="/facts/Assembly_language/7XuV0cla">Assembly language</a> is a low-level programming language that uses mnemonics and labels instead of numeric instruction codes. Although the LMC only uses a limited set of mnemonics, the convenience of using a <a href="/facts/Mnemonic/6HfDn0ks">mnemonic</a> for each instruction is made apparent from the assembly language of the same program shown below - the programmer is no longer required to memorize a set of anonymous numeric codes and can now program with a set of more memorable mnemonic codes. If the mnemonic is an instruction that involves a memory address (<i>either a branch instruction or loading/saving data</i>) then a label is used to name the memory address. </p> INP STA FIRST INP STA SECOND LDA FIRST SUB SECOND OUT HLT FIRST DAT SECOND DAT <h2 id="labels">Labels</h2> <p>Without labels the programmer is required to manually calculate mailbox (<i>memory</i>) addresses. In the numeric code example, if a new instruction was to be inserted before the final HLT instruction then that HLT instruction would move from address 07 to address 08 (address labelling starts at address location 00). Suppose the user entered 600 as the first input. The instruction 308 would mean that this value would be stored at address location 08 and overwrite the 000 (HLT) instruction. Since 600 means "branch to mailbox address 00" the program, instead of halting, would get stuck in an endless loop. </p><p>To work around this difficulty, most assembly languages (<i>including the LMC</i>) combine the mnemonics with <a href="/facts/Label_(programming_language)/DT6KU8R5">labels</a>. A label is simply a word that is used to either name a memory address where an instruction or data is stored, or to refer to that address in an instruction. </p><p>When a program is assembled: </p> <ul><li>A label to the left of an instruction mnemonic is converted to the memory address the instruction or data is stored at. i.e. loopstart INP</li> <li>A label to the right of an instruction mnemonic takes on the value of the memory address referred to above. i.e. BRA loopstart</li> <li>A label combined with a DAT statement works as a variable, it labels the memory address that the data is stored at. i.e. one DAT 1 or number1 DAT</li></ul> <p>In the <a href="/facts/Assembly_language/7XuV0cla">assembly language</a> example which uses mnemonics and labels, if a new instruction was inserted before the final HLT instruction then the address location labelled FIRST would now be at memory location 09 rather than 08 and the STA FIRST instruction would be converted to 309 (STA 09) rather than 308 (STA 08) when the program was assembled. </p><p>Labels are therefore used to: </p> <ul><li>identify a particular instruction as a target for a BRANCH instruction.</li> <li>identify a memory location as a named variable (using DAT) and optionally load data into the program at assembly time for use by the program (this use is not obvious until one considers that there is no way of adding 1 to a counter. One could ask the user to input 1 at the beginning, but it would be better to have this loaded at the time of assembly using one DAT 1)</li></ul> <h3>Example</h3> <p>The program below will take a user input, and count down to zero. </p> INP OUT // Initialize output LOOP BRZ QUIT // Label this memory address as LOOP. If the accumulator value is 0, jump to the memory address labeled // QUIT SUB ONE // Subtract the value stored at address ONE from the accumulator OUT BRA LOOP // Jump (unconditionally) to the memory address labeled LOOP QUIT HLT // Label this memory address as QUIT ONE DAT 1 // Store the value 1 in this memory address, and label it ONE (variable declaration) <p>The program below will take a user input, square it, output the answer and then repeat. Entering a zero will end the program. (<i>Note: an input that results in a value greater than 999 will have undefined behaviour due to the 3 digit number limit of the LMC</i>). </p> START LDA ZERO // Initialize for multiple program run STA RESULT STA COUNT INP // User provided input BRZ END // Branch to program END if input = 0 STA VALUE // Store input as VALUE LOOP LDA RESULT // Load the RESULT ADD VALUE // Add VALUE, the user provided input, to RESULT STA RESULT // Store the new RESULT LDA COUNT // Load the COUNT ADD ONE // Add ONE to the COUNT STA COUNT // Store the new COUNT SUB VALUE // Subtract the user provided input VALUE from COUNT BRZ ENDLOOP // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP BRA LOOP // Branch to LOOP to continue adding VALUE to RESULT ENDLOOP LDA RESULT // Load RESULT OUT // Output RESULT BRA START // Branch to the START to initialize and get another input VALUE END HLT // HALT - a zero was entered so done! RESULT DAT // Computed result (defaults to 0) COUNT DAT // Counter (defaults to 0) ONE DAT 1 // Constant, value of 1 VALUE DAT // User provided input, the value to be squared (defaults to 0) ZERO DAT // Constant, value of 0 (defaults to 0) <p><i>Note: If there is no data after a DAT statement then the default value 0 is stored in the memory address.</i> </p><p>In the example above, [BRZ ENDLOOP] depends on undefined behaviour, as COUNT-VALUE can be negative, after which the ACCUMULATOR value is undefined, resulting in BRZ either branching or not (ACCUMULATOR may be zero, or wrapped around). To make the code compatible with the specification, replace: </p> ... LDA COUNT // Load the COUNT ADD ONE // Add ONE to the COUNT STA COUNT // Store the new COUNT SUB VALUE // Subtract the user provided input VALUE from COUNT BRZ ENDLOOP // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP ... <p>with the following version, which evaluates VALUE-COUNT instead of COUNT-VALUE, making sure the accumulator never underflows: </p> ... LDA COUNT // Load the COUNT ADD ONE // Add ONE to the COUNT STA COUNT // Store the new COUNT LDA VALUE // Load the VALUE SUB COUNT // Subtract COUNT from the user provided input VALUE BRZ ENDLOOP // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP ... <p>Another example is a <a href="/facts/Quine_(computing)/noybHw3h">quine</a>, printing its own machine code (printing source is impossible because letters cannot be output): </p> LOAD LDA 0 // Load position 0 into the accumulator. This line will be modified on each loop to load the next lines into the accumulator OUT // Output the accumulator's value. The accumulator's value will be the line that was just loaded SUB ONE // Subtract 1 from the value in the accumulator. This is so we can do the BRZ in the next step to see if we are on the last line in the program BRZ ONE // If the previous subtraction has made the accumulator 0 (which means we had the value 001 in the accumulator), then branch to position ONE LDA LOAD // Load the LOAD position into the accumulator, this is in preparation to increment the address digits for this position ADD ONE // Increment the position digits for the LOAD line. The value currently in the accumulator would, if read as an instruction, load the next line into the accumulator, compared to the last line loaded STA LOAD // Store the newly incremented LOAD line back in the LOAD position BRA LOAD // Return to the beginning of the loop ONE DAT 1 // The variable ONE. If read as an instruction, this will be interpreted as HLT/COB and will end the program <p>This quine works using <a href="/facts/Self-modifying_code/sbdqYrRp">self-modifying code</a>. Position 0 is incremented by one in each iteration, outputting that line's code, until the code it is outputting is 1, at which point it branches to the ONE position. The value at the ONE position has 0 as opcode, so it is interpreted as a HALT/COB instruction. </p> <h2 id="see-also">See also</h2> <ul><li><a href="/facts/CARDboard_Illustrative_Aid_to_Computation/S095BMIj">CARDboard Illustrative Aid to Computation</a>, another instructional model</li> <li><a href="/facts/TIS-100/oK07tIxt">TIS-100 (video game)</a></li> <li>Hack computer, another educational abstract computer</li> <li><a href="/facts/Human_Resource_Machine/8VfjNv4Y">Human Resource Machine</a>, a computer game heavily influenced by the LMC</li> <li><a href="/facts/WDR_paper_computer/NvYgmUAJ">WDR paper computer</a></li> <li><a href="/facts/Digi-Comp_I/6YnccLXT">Digi-Comp I</a></li> <li><a href="https://littlemanstackmachine.org/index.html">The Little Man Stack Machine</a>, an expansion on the LMC with dedicated stack instructions.</li> <li>Peter Higginson's <a href="https://peterhigginson.co.uk/lmc/?F5=04-Nov-23_07:49:02">online LMC emulator</a>.</li></ul> <h2 id="external-links">External links</h2> <ul><li><a href="http://www.povinelli.org/teaching/eece2710/lmc.html">Richard J. Povinelli:Teaching:Introduction to Computer Hardware and Software:Little Man Computer</a></li> <li><a href="http://elearning.algonquincollege.com/coursemat/dat2343/lectures.f03/12-LMC.htm">The "Little Man" Computer</a></li></ul> <h3>Simulators</h3> <h4>Online</h4> <ul><li><a href="https://peterhigginson.co.uk/LMC/">Peter Higginson's LMC Simulator</a></li> <li><a href="https://blog.paulhankin.net/lmc/lmc.html">Paul Hankin's LMC Simulator</a></li> <li><a href="https://www.101computing.net/LMC/">by 101computing</a></li> <li><a href="https://pbrinkmeier.github.io/lmc-emulator/">P. Brinkmeier's LMC Simulator</a></li> <li><a href="https://wellingborough.github.io/LMC/LMC0.3.html">Wellingborough LMC Simulator</a></li> <li><a href="https://trincot.github.io/lmc.html">Trincot's LMC Simulator</a></li></ul> <h2 id="references">References</h2> <ol> <li id="fn:1"><p>"Little Man Computer". Illinois State University. May 1, 2000. Archived from the original on February 27, 2009. Retrieved March 8, 2009. <a href="https://web.archive.org/web/20090227005033/http://www.acs.ilstu.edu/faculty/javila/lmc/" target="_blank">https://web.archive.org/web/20090227005033/http://www.acs.ilstu.edu/faculty/javila/lmc/</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li> <li id="fn:2"><p>Yurcik, W.; Osborne, H. (2001). "A crowd of Little Man Computers: Visual computer simulator teaching tools". Proceedings of the 2001 Winter Simulation Conference (Cat. No.01CH37304). Vol. 2. p. 1632. doi:10.1109/WSC.2001.977496. ISBN 0-7803-7307-3. S2CID 18907923. <a href="0-7803-7307-3" target="_blank">0-7803-7307-3</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li> <li id="fn:3"><p>Yurcik, W.; Brumbaugh, L. (2001). "A web-based little man computer simulator". Proceedings of the thirty-second SIGCSE technical symposium on Computer Science Education - SIGCSE '01. p. 204. doi:10.1145/364447.364585. ISBN 1581133294. S2CID 14794750. <a href="1581133294" target="_blank">1581133294</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li> <li id="fn:4"><p>Osborne, H.; Yurcik, W. (2002). "The educational range of visual simulations of the Little Man Computer architecture paradigm". 32nd Annual Frontiers in Education. pp. S4G–S19. doi:10.1109/FIE.2002.1158742. ISBN 0-7803-7444-4. S2CID 10324295. <a href="0-7803-7444-4" target="_blank">0-7803-7444-4</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li> </ol>