1. Computer Organization
CSC 235
Computer Organization

2. Computer Organizaton Top_Level Structure The von-Neumann Machine
Microprocessors
Machine Architecture Types
Stack Machine
Accumulator Machine
Load/Store Machine
Register/Memory Machine
Assemblers

3. Top Level Structure Input/Output Main Memory
Central Processing Unit (CPU)
System Interconnection (Bus)

4. Structure - Top Level Computer Peripherals Central Main Processing
Unit
Main
Memory
Computer
Systems
Interconnection
Input
Output
Communication
lines

5. Structure - The CPU CPU Arithmetic Computer and Registers Logic Unit
I/O
System
Bus
CPU
Internal CPU
Interconnection
Memory
Control
Unit

6. von Neumann Machine

7. The von Neumann Machine
Stored Program concept
Main memory storing programs and data
ALU operating on binary data
Control unit interpreting instructions from memory and executing (asynchronous, no “clock”)
Input and output equipment operated by control unit
Princeton Institute for Advanced Studies
IAS
Completed 1952

8. Structure of von Neumann machine
Arithmetic and Logic Unit
Input
Output
Equipment
Main
Memory
Program Control Unit

9. IAS - details 1000 x 40 bit words Binary number
2 x 20 bit instructions
Set of registers (storage in CPU)
Memory Buffer Register (general purpose data register)
Memory Address Register
Instruction Register (opcode)
Instruction Buffer Register (next instruction)
Program Counter
Accumulator
Multiplier Quotient

10. Structure of IAS - detail
Central Processing Unit
Arithmetic and Logic Unit
Accumulator MQ
Arithmetic & Logic Circuits
Input
Output
Equipment
MBR
Instructions
& Data
Main
Memory
IBR PC
MAR IR
Control
Circuits
Address
Program Control Unit

11. The execution cycle PC = 0; // program counter initialized Do {
INSTRUCTION = MEMORY[PC];
PC++;
DECODE(INSTRUCTION);
FETCH(OPERANDS);
EXECUTE;
STORE(RESULTS);
} WHILE (INSTRUCTION != HALT)

12. Microprocessors IAS machine Modern computers vacuum tubes
Transistors (since the early 1970’s)
VLSI (very large scale integration)
Complexity increasing at a constant rate
Moore’s Law

13. Intel 8008 (1971)

14. Intel 8008 Block Diagram
8 bits
3100 Transistors
1971

15. Microprocessor Evolution

18. Machine Architecture Types
Stack Machine
Accumulator Machine
Load/Store Machine
Register/Memory Machine

19. The Stack Machine Stack holds instruction operands
All operations use the top of Stack.
Operands are on top of stack
Operation pops its operands from the top of stack.
Operation is performed
The result is pushed back on the top of stack (see next slide).

21. x = a + b; Push a; // fetch a from memory and push it onto stack
Push b; // fetch b from memory and push it onto stack
Add // pop top two values from
top of stack, add them and
push result onto stack
Store x // pop top value off stack and put it in memory location for x

22. Accumulator Machines
One operand is in the special register called the accumulator
The other operand (if any) is found in memory
The operation is performed and the result is left in the accumulator

23. x = a + b; Load a; // fetch a from memory and put in accumulator
add b; // fetch b from memory and and add it to the accumulator
leaving the answer in the accumulator
Store x // copy accumulator to memory location for x

24. Load/Store Machines Each operand is in a register
The operation is performed using the appropriate registers
The result is put in a register
Often used in RISC machines
Reduced Instruction Set Computers

25. Load/Store Machines Power PC (Apple/IBM) ARM MIPS
SPARC (Sun Microsystems)

26. Load/Store Example x = a + b
move a, r0 // r0 = a
move b, r1 // r1 = b
add r0, r1 // r1 = r0 + r1
move r1, x // x = r1

27. Register/Memory Machine
Operands may by in registers, in memory, or in a combination
The result may be put in either a register or a memory location
Often used in CISC machines
Complex Instruction Set Computers

28. Register/Memory Machines
IBM System/360
VAX
Motorola 68000
Intel 80x86

29. Register/Memory Example x = a + b
move r0, a // r0 = a
add r0, b // r0= a + b
move x, r0 // x= r0

30. Assemblers All code/data is in binary Hard for humans to understand
Assemblers allow mnemonics to be used
Assemblers allow names for memory locations
Assemblers allow labels to used on instructions
Different machines have different assemblers
Single machine can have different assemblers
This is the case for x86 on Windows and Unix!