A Web-Based Little Man Computer Simulator

Transcription

1 A Web-Based Little Man Computer Simulator William Yurcik Larry Brumbaugh Department of Applied Computer Science Illinois State University Normal, IL t50 USA {wjyurci, Abstract This paper describes a web-based simulation tool which can be used to teach introductory computer organization based on the conceptual paradigm of a Little Man Computer. Specifically we share examples how this tool can be used to improve student comprehension of the interaction between computer architecture, assembly language, and the operating system. 1 Introduction Students taking introductory courses in computer organization and assembly language often find fundamental concepts difficult to comprehend. With this in mind we have developed a tool that represents a working model of a general computer. There are other computer system simulators, as documented in [2,4], but we believe our simulator is unique in that it is focused on beginning students while providing flexibility and extensibility to more advanced topics. Our simulation tool is based on the Little Man Computer (LMC) Model first introduced by Stuart Madnick of MIT in 1965 and further developed by Irv Englander of Bentley College in a popular computer organization textbook [1]. We have found this model operates in a manner very similar to actual computers, helping students to understand the basics of internal computer operations. Our LMC simulation was developed using Java and has been made available on the web ( along with comprehensive on-line documentation. We have received feedback from users (teachers and students) worldwide and welcome positive criticism to help continue improvement of this tool [5]. 2 The Little Man Computer Architectural Model The LMC paradigm consists of a walled mailroom, 100 mailboxes numbered 00 through 99, a calculator, a twodigit location counter, an input basket, and an output basket. Each mailbox is designed to hold a single slip of paper upon which is written a three-digit decimal number. Note that each mailbox has a unique address and the contents of each mailbox is different from the address. The calculator can be used for input/output, temporarily store numbers, and to add and subtract. The two-digit location counter is used to increment the count each time the Little Man executes an instruction. The location counter has a reset located outside of the mailroom. Finally there is the "Little Man" himself, depicted as a cartoon character, who performs tasks within the walled mailroom. Other than the reset switch for the location counter, the only communication a user has with the Little Man is via slips of paper with three-digit numbers put into the input basket or retrieved from the output basket. FIGURE I THE LITTLE MAN COMPUTER PARADIGM B Liltle Waged Magroom Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page, To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. SIGCSE /01 Charlotte, NC, USA 2001 ACM ISBN /01/0002.-$5.00 It should be observed that the LMC is a direct implementation of a yon Neumann architecture. The calculator corresponds to the ALU, mailboxes correspond 204

2 to memory, the location counter corresponds to the PC, the I/O corresponds to input/output baskets, and the Little Man himself corresponds to the control unit. Both data and instructions are stored in the mailboxes. There is no distinction between data and instructions except when a specific operation is taking place. It is important for students to visualize the exact steps performed by the Little Man because they reflect the steps performed in a real CPU when executing an instruction. It should also be noted that the analogy is not perfect. In a real computer, memory (mailboxes) is actually separated both physically and functionally from the central processing unit (CPU). In a most computers, generalpurpose registers (accumulators) are available to temporarily hold data being processed. In LMC, the calculator display panel loosely serves the purpose of an aceurnulator. The path of Little Man performing tasks is loosely equivalent to computer bus connections but does not allow for data to be on different buses simultaneously (Little Man can not be in two places at once). Clock timing and interrupts are not part of the LMC paradigm. Lastly, the LMC instruction set is based on the decimal system and a real CPU operates in binary. We make this numbering system trade-off to simplify understanding of computer architecture while rigorously covering binary/octal/ hexadecimal representations elsewhere in the course SKIP SKN - skip next line if calculator value is negative SKZ - skip next line if calculator value is zero SKI' - skip next line if calculator is positive JUMP- goto address NOTE: XX represents a two-digit mailbox address 4 The Little Man Computer Simulator SKN SKZ SKP JMP XX LMC was developed using Java JDK1.2 and is embedded in an applet so as to provide ubiquitous access to users over the Internet without the need for JDK1.2 to be installed locally. Another advantage of using this approach is that the applet is loaded in a separate window allowing the user to run the application as well as look at the HTML documentation in other windows. To enable control of the LMC simulation, multiple threads were implemented: one thread for executing the program and a second thread listening for a user interrupt to halt the program. FIGURE II TIIE LrrrLE MAN COMPUTER SIMULATOR 3 LMC Instruction Set The Little Man performs tasks by following simple instructions which are described by three-digit numbers. The LMC instruction set is fundamentally similar to the instruction sets of many different computers. In fact, the LMC instructions - data movement, arithmetic, and branching - are central to the instruction set of every computer. In a LMC instruction, the first digit describes the operation (opcode) and the last two digits specify the mailbox address to be acted upon (operand). The instructions provide a way to move data between the inbox, outbox, calculator, and mailboxes. There are also instructions that cause Little Man to stop (HALT) and branch conditionally(skip)/unconditionally (JUMP). opcoae Description TABLE I LMC INSTRUCTION SET LOAD contents of mailbox address into calculator STORE contents of calculator into mailbox address ADD contents of mailbox address to calculator SUBtract mailbox address contents from calculator INPUT value from inbox into calculator OUTPUT value from calculator into outbox HALT - LMC stops (coffee break) Mnemonic LDA XX STA XX ADD XX SUB XX IN OUT HLT The LMC simulator has the following two main components: An editor where the user can write programs and save/retrieve them An single-step assembler that translates assembly language to machine code. Our LMC simulation visually shows a one-pass assembly process (mnemonic assembler source code to machine code) and load process (moving machine code into mailboxes). In the edit mode users can write source code (which is automatically checked for syntax errors) or load source code from an existing file. For the programmer's convenience, three different execution modes are provided: (1) Burst Mode, where all instructions in the program are executed until a HALT instruction is encountered or an abend occurs; (2) Step Into, which executes one instruction 205

3 at a time; and (3) Step Over, which is similar to Step Into except for SKIP instructions. For SKIP instructions, if the condition is met the program executes the next instruction and then waits for user interaction. Debugging break points can be set for all three execution modes. A flag register indicates error conditions and is set/reset for corresponding overflow/underflow conditions and zero/negative/positive values within the calculator. 5 Using LMC in the Classroom Most students taking the computer organization and architecture course have not programmed in an assembler language. All their coding experience is in a high level language (C, C++, Java, etc.). Hence, some class time (usually one period) is spent describing and illustrating basic assembler language programming with LMC. The LMC equivalents of high level language instructions such as looping, IF-THEN-ELSE and I/O operations are identified. Some of the most common syntax and logic errors that occur with LMC programming are described. Following this, if a computer lab is available, it is worthwhile to let the students write several small programs, which they enter and run. Several larger sample programs are placed on a server and students copy them. The students make simple modifications and additions to the programs and then try to successfully run them. Students quickly become familiar with providing Input, using the LMC editor to enter their code, stepping through a program and working with the various LMC controls. 5.1 Programming Assignments Writing a program that performs integer multiplication and division illustrates how significant processing can be done using only the basic LMC instructions. It also shows how difficult this can be and the convenience of having actual multiplication and division instructions available. Multiplication is implemented using repeated addition. To calculate A'B, add A to itself a total of B times, or add B to itself A times. To improve efficiency, some students preface their addition by determining the smaller input value (say A) and calculate B+B+B Compare the calculation of 479*0 and 0*479. Division is performed using repeated subtraction and both a quotient and remainder are calculated. A Loader program processes 'user' programs as input. The Loader program reads an application program from the LMC Input and stores it in an unoccupied portion of memory. After the Loader copies the entire program into memory, it transfers control to the initial statement in the loaded program and it starts executing. This is an excellent illustration of the yon Neumann architecture showing that both data and executing instructions are stored in memory. Initially, the Loader processes the application program as 'data'. Later, the same data is accessed as executable instructions. The LMC editor holds the Loader program. The application program and all its data are placed in the Input. Optionally, the editor can contain both programs and the Loader could transfer the application to a different location in memory. As an extension of this, when an application finishes it transfers control back to the Loader which loads a second (or several) application(s) into memory. In addition, the present program can occupy the same memory locations formerly used by the previous program. A stream of programs can be executed in this manner. The only limitation is the size of the Input. The Loader program provides a good working example that illustrates several basic operating system concepts. 5.2 Addressing Modes Addressing modes provide a programmer with additional flexibility and convenience without significantly altering the fundamental simplicity of LMC. The Madaick LMC paradigm is limited to direct, absolute addressing but we have extended our LMC simulation to include other addressing modes. Students fred these addressing modes allow them to understand how data structures such as arrays and linked lists using pointers (learned in previous algorithm courses) can be implemented. The current implementation of LMC supports four types of addressing. Here c(address) means the value stored at the location. Absolute Addressing ADD 95 e(95)+e(ace)..->e(aee) Indirect Addressing ADD *95 c(x)+e(ace).->e(aee) (a pointer) where e(95)=x Immediate Addressing ADD #95 95+e(Aee)->e(Aee) Relative Addressing ADD t95 c(c(pc)+95)+e(aee)--~c(aec) Absolute addressing uses the LMC mailbox directly without performing any calculations or conversions with it. With indirect addressing the address included with the instruction identifies the actual address that the instruction will use. The value at the instruction address is an address (pointer) rather than a 'data' value. With immediate addressing, the data value is stored inside the instruction and no additional memory location is accessed. Immediate addressing allows faster execution and can be a considerable convenience to the programmer when incrementing or decrementing a counter or to clear a memory location. Immediate addressing is used in the code on the left below and its absolute address counterpart is shown on the right. ADD #1 SUB #1 oradd #-1 LDA #0 ADD 90 ~- increment by 1 SUB 90 <- decrement by 1 LDA 91 ~ clear 90 DAT an additional memory access 91 DAT 0 ~- required with absolute addressing 206

4 Relative addressing provides additional processing power and programmer convenience. The program counter (PC) contains the address of the currently executing instruction. With relative addressing the PC functions like a base register and the address within the instruction is a displacement ftom the PC value. This allows instructions to be written with a relative rather than an absolute value. The instruction "JMP!+3" transfers control to the third instruction following the current one. Coding "JMP!+0" creates an infinite loop that an interrupt will eventually end. Initial LMC programming uses absolute addresses almost exclusively. Absolute addresses are calculated and then recalculated as instructions are moved, added, and deleted. Relative addressing simplifies some of this process. By using entirely relative and immediate addressing, relocatable programs can be written. Wherever the program is loaded in memory, it works the same. R is not dependent upon accessing data at specific absolute locations. Base displacement addressing is not implemented in the current LMC. This requires an additional register not currently included in the latest version of LMC. 5.3 Creating Data Structures ARer writing several LMC programs, students are ready to incorporate data structures into their program. Without using data structures, most LMC programs are relatively simple. The basic LMC instruction set allows both arrays and linked lists to be created. An array is uniquely identified as a contiguous area in memory that has (a) a beginning location, (b) a total length or number of elements in the array, and (c) the size of an array element, that is usually one memory location, but can be two or more locations. FIGURE III A LOOP IS CODED TO LOAD VALUES INTO THE ARRAY. IN <start location> STA 99 IN <end of array> STA 98 IN <size of clement> STA 97 graft of array end of array {an element is one memory Inesttinn~ After an array is created, standard processing functions can be implemented, including finding the largest (smallest) element in the array, the location where the largest (smallest) element is stored, the sum of the elements in the array, whether a particular value occurs in the array and how many times it occurs, and processing the elements at opposite ends of the array. A standard LMC looping structure is used for most array processing. Prior to beginning processing an array with N elements, load N into the accumulator and subtract 1. The N array elements are processed with subscript values of N- 1, N , 0. When the subscript becomes negative, the loop is terminated. A SKI' instruction (skip if value is greater than or equal to zero) controls processing. Linked lists are a special type of array where each element in the array consists of two consecutive memory addresses. The low memory address contains the data value and the second holds the address of the next location in the linked list. A tree is a further generalization with three memory locations, a data value and two pointers. However, the small amount of memory available with LMC limits the scope of linked list and tree processing. 5.4 Impure Code and Pure Code Another illustration of the von Neumarm architecture involves writing a program whose executable instructions are modified while the program runs. Such code is sometimes said to be impure or noureentrant. During execution, the program code is different than the code at the beginning of execution. Most programs modify data, not their own instructions. In the impure code shown in Figure IV every element in an array is set to zero. FIGURE IV "PURE" VERSUS "IMPURE" CODE Mailbox/Instruction/Address (A) 03 LDA 99 load data value, which is a store instruction 04 STA 05 place the store instruction in location 5 05 DAT 000 a 0 is stored in an array element 06 LDA 99 the value in 99 is loaded into the accumulator 07 ADD # 1 the accumulator value is incremented by 1 08 STA 99 the value is stored in location JMP 05 control transfers to location DAT 240 d~aa value and store value in location 40 Mailbox/Instruction/Address (B) 04 LDA 00 load 0 in the accumulator 05 STA *85 store 0 at location contained in location LDA 85 as in code the value that serves as the array 07 ADD #1 subscript is incremented by I 08 STA 85 09JMP DAT 40 control transfers to location 05 data value and also location 40 in memory The impure code shown in Figure IV(A) can be modified in several ways to create comparable pure code. Several techniques are possible. Figure IV(B) uses indirect addresses. 5.5 Operating System Concepts LMC also introduces fundamental Operating Systems (OS) concepts in several different ways. While Englander discusses a "Little Man multitasking OS" or MINOS in [I], we prefer to focus only on a single-task OS since it can be illustrated with the LMC simulator. With the major 207

5 difference between single-tasking and multi-tasking OSs being context-switching in response to interrupts, interrupts are not currently supported in our LMC simulator. First, students understand that the external reset for the LMC location counter is similar to the bootstrap process of a real computer accessing a predetermined address in ROM to load the OS kernel. Second, students realize the LMC is a one-trick pony in that it only executes a single program and stops. A real computer would have an operating system allocating resources between different processes and would not stop and require rebooting after the execution of each program. Third, visualizing the fetchexecute cycle with the use of highlighted colors demonstrates the clustering "concept of locality" upon which virtual memory and caching is based. Lastly, students learn to appreciate the OS fimction to maximize available memory space for applications to both load and execute. We have already discussed the use of a Loader program showing how an OS may relocate programs within memory under the dynamic computer conditions at load ttirne. We can illustrate variable memory partitioning algorithms such as best-fit, f~t-fit, largest fit, and worst fit and then visually compare the fragmentation results. A visualization of external fi'agmentation highlights the relationship between scheduling and memory management - available memory limits the number and rate at which user processes can be scheduled for CPU execution with the main tradeoff being blocking (no execution) versus delay (response time). 6 Future LMC Enhancements One planned significant enhancement is index register/displacement addressing. This will provide an important addressing method. It requires an index register. Including one or more General Purpose Registers is also being considered. Register-to-Register addressing could be used with many of the instructions. Another enhancement is to take an individual instruction and decompose the steps (microcode) that comprise its fetch/execute cycle. This will require at least three additional registers: Memory Address Register (MAR), Memory Data Register (MDR), and Instruction Register (If). Depending on the addressing mode used, the Fetch/Execute cycle will change. 7 Summary We have presented a web-based simulation of a general computer architecture based on the LMC paradigm of Stuart Madnick/Irv Englander and showed how LMC can be used as the central tool for Computer Architecture and Assembly Language Education (CAALE). We feel that the use of interactive simulation is a powerful tool to enable CAALE active learning and report our teaching techniques here with the hope that others will use LMC and provide us feedback. With the success of this LMC simulation of a general computer architecture, we have embarked on simulating more complex computer architectures modeled on real CPUs. Specifically we want students to visualize different ways of implementing the von Neumann architecture based on cost/speed tradeoffs. We have a prototype 8085 CPLI simulator in beta test and a VAX11 CPU simulator under development. See the following URL for future contributions: 8 Acknowledgments The following students are especially acknowledged since they were instrumental in the development of this LMC simulation: Anita Knap who programmed the fwst LMC prototype, Rahul Gedupudi who programmed this second version of LMC simulation as a Masters Project [3] and continues to maintain and provide upgrades, and lastly all the students with ACS 254 classes at Illinois State University during the Fall 1999/Spring 2000/Fall 2000 semesters who learned along with us the value of active learning using interactive simulation. We would also like to thank the anonymous reviewers whose insightful comments greatly improved this paper. References [1] Englander, I., The Architecture of Hardware and Systems Software: An Information Technology Approach second edition, John Wiley & Sons (2000). [2] Cassel, L., Kumar, D. et. al. Distributed Expertise for Teaching Computer Organization & Architecture, ITiCSE 2000 Working Group Report [to appear in the ACM SIGCSE Bulletin], (July 2000). [3] Gedupudi, R., Simulation of Little Man Computer, Masters Degree Project Documentation, Department of Applied Computer Science, Illinois State University, (February 29, 2000). [4] Yehezkel, C., Yurcik, W., and Pearson, M. Teaching Computer Architecture with a Computer-Aided Learning Environment: State-of-the-Art Simulators, Proceedings of the 2001 International ConJbrence on Simulation and Multimedia in Engineering Education (ICSEE), Society for Computer Simulation (SCS) Press, (January 2001). [5] Yurcik, W., Vila J., and Brnrnhaugh L., An Interactive Web-Based Simulation of a General Computer Architecture, Proceedings of IEEE International Conference on Engineering and Computer Education, (August 2000). 208