2
COMPUTER SYSTEMS
ORGANIZATION
1
Central processing unit (CPU)
Control
unit
Arithmetic
logical unit
(ALU)
Registers
Main
memory
Disk Printer
Bus
I/O devices
…
…
Figure 2-1. The organization of a simple computer with one
CPU and two I/O devices.
A + B
A + B
A
A
B
B
Registers
ALU input register
ALU output register
ALU
ALU input bus

private static void execute(int type, int data){ ... }
}
Figure 2-3. An interpreter for a simple computer (written in Java).
(a)
(b)
S1:
S2:
S3:
S4:
S5:
1
2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7
1 2 3 4 5 6
1 2 3 4 5
123456789
Time
…
S1 S2 S3 S4 S5
Instruction
fetch
unit
Instruction
decode
unit
Operand
fetch
unit
Instruction

execution
unit
Write
back
unit
Figure 2-5. (a) Dual five-stage pipelines with a common in-
struction fetch unit.
S2 S3 S5
Instruction
decode
unit
Operand
fetch
unit
LOAD
Write
back
unit
S1
Instruction
fetch
unit
S4
Floating
point
STORE
ALU
ALU
Figure 2-6. A superscalar processor with five functional units.
Control unit

9
10
11
Address
0
Address
1
2
3
4
5
6
7
0
1
2
3
4
5
16 bits
(b)
12 bits
(a)
8 bits
Figure 2-9. Three ways of organizing a 96-bit memory.

Computer Bits/cell

Burroughs B1700 1

































2
6
10
14
3
7
11
15
32-bit word
Little endian
Byte
3
(b)
7
11
15
2
6
10
14
1
5
9
13
0
4
8
12
32-bit word
Figure 2-11. (a) Big endian memory. (b) Little endian memory.

I M
S4M I T
H80 0 0
0120 0 21
0160 1 4
Figure 2-12. (a) A personnel record for a big endian machine.
(b) The same record for a little endian machine. (c) The result
of transferring the record from a big endian to a little endian.
(d) The result of byte-swapping (c).

Word size Check bits Total size Percent overhead

8 4 12 50

16 5 21 31

32 6 38 19

64 7 71 11

128 8 136 6

256 9 265 4

512 10 522 2































Figure 2-13. Number of check bits for a code that can correct
a single error.
B
A
C

0
2
1
3
0
4
1
5
1
6
1
7
0
8
0
9
0
10
0
11
0
12
1
13
0
14
1
15
1
16