Microcomputer Architecture (Von Neumann/Princeton)

Definitions:
Processor: ALU + Controller
Computer: processor + memory + I/O
Computer architecture: interconnections of computer
modules
Instruction register: holds a fetched instruction while
processor executes this instruction
Program counter: pointer to next instruction in
memory to get
Condition code register: set of flags that control
processor operations (e.g., conditional branch
execution)

Main disadvantage of von Neumann architecture

Harvard Architecture
ALU
I/O

data bus
read/write
data address bus

Controller
instruction bus
instruction
address bus

Main disadvantages of Harvard architecture

Data
RAM

Instruction
RAM

Two ways to implement controller

1. Finite State Machine (Microcontroller)
2. Micro-programmed Processor (some Pentiums)

Control signals (micro-instruction) for each step of instruction

execution stored in a Micro-ROM on processor chip
Instruction-byte points to corresponding control signal block
in Micro-ROM
When executing instruction, controller reads control signals
out of Micro-ROM one-by-one and send signals to other units
(ALU, memory, etc.)
To minimize size of Micro-ROM, micro-instructions are not
stored consecutively in Micro-ROM; each micro-instruction
contains an address field pointing to the next micro-instruction

CISC and RISC

CISC complex instruction set computer
large instruction set
high-level operations
requires microcode interpreter
some more complex instructions are hard to
take advantage of
examples: Intel 80x86 and IA-32 families
RISC reduced instruction set computer
simple, atomic instructions
small instruction set
directly executed by hardware
rely on highly optimizing compilers
examples:
ARM, DEC Alpha, SUN Sparc
Most microcontrollers

Instruction Set
Group of valid instructions that a processor can
execute (depends on processor)
Can be further divided into subgroups:

Arithmetic operations
add, subtract, multiply, divide, 2s complement op.

Logical operations
AND, OR, XOR, Complement

Load/Store operations:

move data from external memory into processor or vice versa

move data within processor (between registers)
data movement within memory normally not possible
Load: memory
processor
Store: processor
memory

Input/Output operations:
move data from I/O into processor or vice versa
Input: I/O
processor
Output: processor
I/O

Instruction Set
Can be further divided into subgroups:

Branch
Change the order of instruction execution (jump to different
program section)
How? By changing contents of PC
Unconditional branches/jumps
Branch always taken
Conditional branch
Branch taken depending on condition code register flags

Stack operations
To implement dynamic data storage
Can push registers onto the stack and pull them back off

Subroutine operations
To implement function/procedure calls/returns