Chapter 5. Basic Computer Organization and Design

Table of Contents

5.1. Instruction Codes
5.1.1. Computer Instructions
5.1.2. Stored Program Organization
5.2. Registers of the Basic Computer
5.2.1. Registers Overview
5.2.2. Internal BUS Structure
5.3. Computer Instructions
5.4. Timing and Control
5.5. Instruction Cycle
5.5.1. Instruction Fetch and Decode
5.5.2. Determining the Instruction Type
5.5.3. Register-reference Execute Phase
5.6. Memory-Reference Execute Phase
5.6.1. AND
5.6.2. BSA
5.6.3. ISZ
5.7. Input-Output and Interrupt
5.7.1. Hardware Summary
5.7.2. I/O Operations
5.7.3. Software Polling
5.7.4. Interrupts
5.8. Complete Computer Description
5.9. Design of Basic Computer
5.10. Design of Accumulator Logic
5.11. Homework

This chapter presents the design of a basic but complete CPU with a much simpler design than any real-world processors available. The basic computer design represents all of the major concepts in CPU design without overwhelming students with the complexity of a modern commercial CPU. Some highlights of popular commercial CPU designs will be covered later in the semester.


This chapter should provide graduate students with a clear idea on how to proceed with the CPU design process.

5.1. Instruction Codes

5.1.1. Computer Instructions

Computer instructions are the basic components of a machine language program. They are also known as macrooperations, since each one is comprised of a sequences of microoperations.

Each instruction initiates a sequence of microoperations that fetch operands from registers or memory, possibly perform arithmetic, logic, or shift operations, and store results in registers or memory.

Instructions are encoded as binary instruction codes. Each instruction code contains of a operation code, or opcode, which designates the overall purpose of the instruction (e.g. add, subtract, move, input, etc.). The number of bits allocated for the opcode determined how many different instructions the architecture supports.

In addition to the opcode, many instructions also contain one or more operands, which indicate where in registers or memory the data required for the operation is located. For example, and add instruction requires two operands, and a not instruction requires one.

	     15    12 11          6 5          0
	    | Opcode |  Operand    |  Operand   |

The opcode and operands are most often encoded as unsigned binary numbers in order to minimize the number of bits used to store them. For example, a 4-bit opcode encoded as a binary number could represent up to 16 different operations.

The control unit is responsible for decoding the opcode and operand bits in the instruction register, and then generating the control signals necessary to drive all other hardware in the CPU to perform the sequence of microoperations that comprise the instruction.

Figure 5.1. CPU Block Diagram

CPU Block Diagram

5.1.2. Stored Program Organization Von Neumann and Harvard Architectures

In the Von Neumann architecture, machine instructions and data are stored in the same RAM during program execution.

Book figure 5-1:

A Harvard architecture CPU, in contrast, stored the program and the data in separate memory units. For example, many microcontrollers store the program in Flash memory and the data in traditional, volatile RAM. Operand-based Architecture Classification

Architectures are also classified according to how instructions access memory and process data:

  • Memory-to-memory: Most instructions can access memory for any operand. The VAX architecture from Digital Equipment Corporation is an example.
    		    addl3   x, y, sum     # x, y, and sum are memory addresses
  • Register-memory: Instructions allow only one operand to be a memory address, while the other(s) must be CPU registers. The x86 architecture is an example.
    		    movl    eax, x
    		    addl    eax, y
    		    movl    sum, eax
  • Load-store: Only load and store instructions can access memory. All others must use CPU registers for all operands. The MIPS processor, originally from Digital Equipment Corporation is an example.
    		    lw      $t0, x
    		    lw      $t1, y
    		    add     $t0, $t0, $t1
    		    sw      $t0, sum
  • Accumulator-based: One special register, called the accumulator (AC), is an implied operand for most operations. The Zylog Z80 is an example.
    		    load    x   # AC ← x
    		    add     y   # AC ← AC + y
    		    store   sum # sum ←- AC
   Designing an Instruction Code

Machine instruction codes may all be the same length (e.g. MIPS processor), or codes for different instructions may be different lengths (e.g. x86, VAX processors).

Suppose all instruction codes of a hypothetical accumulator-based CPU are exactly 16 bits. A simple instruction code format could consist of a 4-bit operation code (opcode) and a 12-bit memory address.

		 15    12 11           0
		| Opcode | Address      |

This would allow for how many different instructions? How much memory?

Suppose a program contains two variables, x and y. The variable x represents address 0x010 and y represents address 0x012. A segment of the list file, which shows machine code and assembly code side-by-side, might appear as follows:

		0 010   add     x
		1 012   sub     y

We see that the opcode for add is 000 (0x0) and the opcode for sub is 001 (0x1).

The format above represents memory-reference instructions, which act on an operand from memory and the accumulator. Not all operations require a second operand, so some instructions could act on the accumulator alone. In this case, address bits can be used for other purposes. For example:

		clr     # AC = 0
		neg     # AC = -AC
		not     # AC = AC'
		inc     # AC = AC + 1

One or more patterns in the 4-bit opcode can be used to signify that the other 12 bits specify an operation instead of an address. This reduces the number of memory-reference instructions possible, but increases the overall instruction count.

		0XXX    add XXX
		1XXX    sub XXX
		F000    clr
		F001    neg
		F002    not
		F003    inc

How many memory-reference instructions can this CPU have?

How many non-memory-reference instructions can this CPU have?

As a second example, suppose a load-store architecture computer has 2-operand instructions, 32 registers, 1 megabyte of byte-addressable memory, 4 addressing modes, 50 register-reference instructions, and 6 load-store instructions. What would the instruction code look like for register-reference instructions? What would the instruction code look like for memory-reference instructions?

Solution: Since there are 50 register-reference instructions, we will need 6 bits for the opcode. (6 bits allows for up to 26 unique opcodes.) With 32 registers, we will need 5 bits to specify each register, so the instruction code format will be 16 bits:

		| opcode |  reg1  |  reg2  |
		     6        5        5

For 6 load-store opcodes, we need 3 bits. 4 addressing modes requires 2 bits to go with the address. A possible instruction code format is as follows:

		| opcode | reg | mode | address |
		     3      5      4       20

As a third example, suppose a register-memory architecture has 8 registers, a 64k memory capacity, 100 instructions, and 6 addressing modes. Design an instruction code format for memory-reference instructions.

Solution: To represent 100 instructions, we will need 7 bits for the opcode. We'll need 16 bits for a memory address for 64k memory, 3 bits to represent one of 8 registers, and 3 bits to cover all 6 addressing modes for the memory operand. One possible instruction format is shown below. Since this adds up to 19 bits, we would likely use 24 bits for the instruction code to make it fit well into byte-addressable memory. The additional bits could be used to support more opcodes and/or addressing modes.

		| opcode | reg | mode | address |
		    7       3      3       16

Suppose a direct address in assembly language is represented by a label, as in x below, and an indirect address by a label in parentheses, as in (ptr) below.

		mov     x, r3
		add     (ptr), r3

If the opcode for mov is 00000001, add is 0000010, the mode bits for direct addressing are 100, and the bits for indirect addressing are 101, the address x is 0x00F0, and ptr is 0x00F2, the instruction codes for the two instructions above would be:

		0000001 011 100 0000000011110000
		0000010 011 101 0000000011110010

Design an instruction code format for a memory-to-memory architecture with 16 registers, a 4 gigabyte memory capacity, 250 instructions, and 16 addressing modes. Assume that there are anywhere from 0 to 3 operands per instruction, and each operand may be in a register or in memory. Some Common Addressing Modes

  • Direct: Instruction code contains address of operand
    		    0 005   AC = AC + contents of address 5
    * 1 memory-reference beyond fetching instruction
  • Immediate: Instruction code contains operand
    		    1 005   AC = AC + 5
    * No memory-reference after fetching instruction
  • Indirect: Instruction code contains address of address of operand
    		    2 005   AC = AC + contents of address stored at address 5
    * 2 memory-references after fetching instruction

Effective address = actual address of the data in memory.

Table 5.1. Effective Address by Addressing Mode

ModeEffective Address
ImmediateAddress of the instruction itself
DirectAddress contained in the instruction code
IndirectAddress at the address in the instruction code Basic Computer Instruction Format

The Basic Computer has a 16-bit instruction code similar to the examples described above. It supports direct and indirect addressing modes.

How many bits are required to specify the addressing mode?

		 15 14 12 11      0
		| I | OP | ADDRESS |
		I = 0: direct
		I = 1: indirect

Book figure 5-2: