Basic Computer Organization

Purpose of This Chapter

• In this chapter we introduce a basic
computer and show how its operation can
be specified with register transfer
statements.
 Instruction Codes

A process is controlled by a program

– A program is a set of instructions that
specify the operations, data, and the
control sequence
– An instruction is stored in binary code that
specifies a sequence of microoperations
– Instruction codes together with data are
stored in memory (Stored Program
Concept)
 Program statements and
computer instructions

Computer instruction

Field specifying the Field specifying the data

operation to be executed To be operated on
 Instruction code format
• Instruction code format with two parts :
Op. Code + Address
– Op. Code : specify 16 possible operations(4 bits)
– Address : specify the address of an operand(12 bits)
– If an operation in an instruction code does not need
an operand from memory, the rest of the bits in the
instruction(address field) can be used for other
purpose

15 12 11 0 15 12 11 0

Op. Code Address data

instruction Not an instruction

 Components of Instructions
• Operations (opcodes)
• Number of operands (Number of data locations)

opcode: add value in src1 to

value in src2 and place the add r1,r2,r3
result in dst.
opcode src1 src2 dst
ADD R1, R2, R3 R1  R2 + R3

• Instruction encodings
 Number of Operands per
instruction
• No Operands HALT NOP

• 1 operand NOT R4 R4  R4

• 2 operands ADD R1, R2 R1  R1 + R2

• 3 operands ADD R1, R2, R3 R1  R2 + R3

• > 3 operands MADD R4,R1,R2,R3 R4  R1+(R2*R3)

• Each specify one operation and 1,2, 3 or 4 data locations.

 Instructions are read from memory as
words

• Instructions can be formatted to fit in one or more

memory words.
• An instruction may contain
– An opcode + data (immediate operand)
– An opcode + the address of data (direct addressing)
– An opcode + an address where the address of the data
is found (indirect addressing)
– Data only (location has no instructions)
– An opcode only (register-reference or input/output
instruction)
 Building A Basic Computer!
The basic computer instructions are
1. Memory
stored in the memory
address contents
The size of each memory word is 16 bits.
Each instruction occupy one word. 0000000000000001 0101010101010101
0000000000000010 1010101010101010
0000000000000011 1100110011001100
2. Program Counter
0000000000000100 0011001100110011
PC 000000000001
0000000000000101 0101010101010011
0000000000000110 1010101010101010
0000000000000111 1100110011001100
3. Instruction Register 0000000000001000 0011001100110011

IR 0101
010101010101
 The address register is connected to the
memory
+1
The Program Counter points to PC
the next address of the program
000000000010
00000001

1. Program Counter Increments

by units of addresses AR 000000000010
2. The next address is put on
the bus and is loaded into the
Direct access to
Address Register
Memory
3. The Bits of the AR are wired
directly to the RAM Address
lines to enable loading the
memory into the Instruction R. IR 1010101010101010
 Direct address

Occurs When the Operand Part Contains the Address of

Needed Data.

1. Address part of IR is placed on the bus and loaded

back into the AR

2. Address is selected in memory and its Data placed on

the bus to be loaded into the Data Register to be used
for requested instructions
Direct address
 Indirect address

Occurs When the Operand Contains the Address of the Address

of Needed Data.

1. Address part of IR is placed on the bus and loaded back

into the AR

2. Address is selected in memory and placed on the bus to

be loaded Back into the AR

3. New Address is selected in memory and placed on the bus

to be loaded into the DR to use later
Indirect address
 Effective address:
• Effective address: Address where an
operand is physically located

Effective address: 457 Effective address: 1350

 Direct and Indirect addressing example

Addressing
Mode
Mano’s Computer Figure 5-4 s0 s1 s2
Bus
Memory Unit
7
4096x16
Address
WRITE READ
AR 1
LD INR CLR
PC 2
LD INR CLR
DR 3
LD INR CLR

Adder E
& Logic
AC 4
LD INR CLR

INPR

IR 5
LD
TR 6
LD INR CLR
OUTR
Clock
LD
16-bit common bus
Computer System Architecture, Mano, Copyright (C) 1993 Prentice-Hall, Inc.
 Computer Registers
–Accumulator(AC) : takes input from ALU
»The ALU takes input from DR, AC and INPR :
»ADD DR to AC, AND DR to AC
–Note) Input register is not connected to the bus.
–The input register is connected only to the ALU
 5-2 Computer Registers
• Data Register(DR) : hold the operand(Data) read from memory

• Accumulator Register(AC) : general purpose processing register

• Instruction Register(IR) : hold the instruction read from memory

• Temporary Register(TR) : hold a temporary data during processing

• Address Register(AR) : hold a memory address, 12 bit width

• Program Counter (PC): hold the address of the instruction

• Input Register (INPR): Hold input Character

• Output Register(OUTR) Hold output Character

 5-2 Computer Registers
• Program Counter(PC) :
• hold the address of the next instruction to be read from mem
ory after the current instruction is executed
• Instruction words are read and executed in sequence unless
a branch instruction is encountered
• A branch instruction calls for a transfer to a nonconsecutive i
nstruction in the program
• The address part of a branch instruction is transferred to PC
to become the address of the next instruction
• To read instruction, memory read cycle is initiated, and PC is
incremented by one(next instruction fetch)
 5-2 Computer Registers

• Input Register(INPR) : receive an 8-bit

character from an input device
• Output Register(OUTR) : hold an 8-bit
character for an output device
 5-2 Computer Registers

Register Number Register Register

symbol of bits name Function-----------------------
DR 16 Data register Holds memory operands
AR 12 Address register Holds address for memory
AC 16 Accumulator Processor register
IR 16 Instruction register Holds instruction code
PC 12 Program counter Holds address of instruction
TR 16 Temporary register Holds temporary data
INPR 8 Input register Holds input character
OUTR 8 Output register Holds output character
 Mano’s Computer: each instruction
occupies one Memory Words
15 12 11 0

• 4-bit opcode Bits 15-12

• How many possible instructions?
– 24=16
• This leaves 12 bits for the address
– How many words of memory?
– 212 = 22•210 = 4K = 4096 16-bit words
 Mano's simple Computer:
Instructions 0
15 12 11

Any bits other than 0111 and

I 1111 are called memory
reference instructions
000 AND 100 BUN
001 ADD (Branch Unconditional)
010 LDA 101 BSA
(Load Accumulator) (Branch and Store Address)
011 STA 110 ISZ
(Store Accumulator) (Increment and Skip if Zero)
 Hex Code
Symbol I=0 I=1 Description
AND 0xxx 8xxx And memory word to AC
ADD 1xxx 9xxx Add memory word to AC
LDA 2xxx Axxx Load memory word to AC
STA 3xxx Bxxx Store content of AC in memory
BUN 4xxx Cxxx Branch unconditionally
BSA 5xxx Dxxx Branch and Save return address
ISZ 6xxx Exxx Increment and skip if zero
CLA 7800 Clear AC
CLE 7400 Clear E
CMS 7200 Complement AC
CME m 7100 e Comp
CIR 7080 Circulate right AC and E
CIL 7040 Circulate left AC and E
INC 7020 Increment AC
SPA 7010 Skip next instruction if AC positive
SNA 7008 Skip next instruction if AC negative
SZA 7004 Skip next instruction if AC zero
SZE 7002 Skip next instruction if E is 0
HLT 7001 Halt computer
INP F800 Input character to AC
OUT F400 Output character from AC
SKI F200 Skip on input flag
SKO F100 Skip on output flag
ION F080 Interrup
IOF F040 Inter
 5-3. Computer Instruction
•
– 3 Instruction Code Formats : Fig. 5-5 Hex Code
Symbol I= 0 I= 1 Description
• Memory-reference instruction AND 0xxx 8xxx And memory word to AC
ADD 1xxx 9xxx Add memory word to AC
–Opcode = 000  110 LDA 2xxx Axxx Load memory word to AC
STA 3xxx Bxxx Store content of AC in memory
»I=0 : 0xxx ~ 6xxx, I=1: 8xxx ~Exxx BUN 4xxx Cxxx Branch unconditionally
I=0 : Direct, 15 14 12 11 0 BSA 5xxx Dxxx Branch and Save return address
I=1 : Indirect ISZ 6xxx Exxx Increment and skip if zero
I Opcode Address CLA 7800 Clear AC
CLE 7400 Clear E
CMS 7200 Complement AC
»Register-reference instruction CME m 7100 e Comp
CIR 7080 Circulate right AC and E
–7xxx (7800 ~ 7001) : CLA, CMA, CIL 7040 Circulate left AC and E
15 14 12 11 0 INC 7020 Increment AC
SPA 7010 Skip next instruction if AC positive
0 1 1 1 Register Operation
SNA 7008 Skip next instruction if AC negative
SZA 7004 Skip next instruction if AC zero

–Input-Output instruction SZE

HLT
7002
7001
Skip next instruction if E is 0
Halt computer
–Fxxx(F800 ~ F040) : INP, OUT, ION, SKI, INP
OUT
F800
F400
Input character to AC
Output character from AC
SKI F200 Skip on input flag
15 14 12 11 0
SKO F100 Skip on output flag
1 1 1 1 I/O Operation ION F080 Interrup
IOF F040 Inter
 Common Bus System
 The basic computer has eight registers, a
memory unit, and a control unit.

• Paths must be provided to transfer information

from one register to another and between
memory and registers

• A more efficient scheme for transferring

information in a system with many registers is to
use a common bus.
Mano’s Computer Figure 5-4 s0 s1 s2
Bus
Memory Unit
7
4096x16
Address
WRITE READ
AR 1
LD INR CLR
PC 2
LD INR CLR
DR 3
LD INR CLR

Adder E
& Logic
AC 4
LD INR CLR

INPR

IR 5
LD
TR 6
LD INR CLR
OUTR
Clock
LD
16-bit common bus
Computer System Architecture, Mano, Copyright (C) 1993 Prentice-Hall, Inc.
 Common Bus System
– The connection of the registers and memory of the
basic computer to a common bus system :

– The outputs of seven registers and memory are connected to

the common bus
– The specific output is selected by mux(S0, S1, S2) :
» Memory(7), AR(1), PC(2), DR(3), AC(4), IR(5), TR(6)
» When LD(Load Input) is enable, the particular register
receives the data from the bus
– Control Input : LD, INC, CLR, Write, Read
 COMMON BUS SYSTEM
• Control variables: the bus is controlled
by

• 1- Selection switches for selecting the

source of information and
• 2- Enable switches at the destination
device to accept the information.
 Selection variables
• Selection variables: select a register or the
memory whose output is used as an input to the
common bus.

• To select one device out of 8, we need 3 select

variables.
• For example, if S2S1S0 = 011, the output of DR
is selected as an output of the common bus.
 Load input
Load input (LD): Enables the input of a
register to download bits form the
common bus. When LD = 1 for a register,
the data on the common bus is read into
the register during the next clock pulse
transition.

> Increment input (INR): Increments the content of a register.

> Clear input (CLR): Clear the content of a register to zero.
 Incompatibility in register sizes

• • When the contents of AR or PC (12 bits) are

applied to the 16-bit common bus, the four
most significant bits are set to zero. When AR
or PC receives information from the bus, only
the 12 least significant bits are transferred to
the register.
12 least significant bits

12 bits
 Mano’s Example of Basic Computer (Section 5.9)
The basic computer consists of a
9 Registers Memory: 4096x16 bits 4096 words of 16 bits memory unit

SC 4 bits AR,PC 12 bits DR,AC, IR,TR 16 bits OUTR,INPR 8 bits

Seven Flip-Flops

I(1 bit) S(1 bit) E(1 bit) R(1 bit) IEN(1 bit) FGI(1 bit) FGO(1 bit)
Adder and Logic circuit
ALU Nine registers : AR,
connected to the AC input
Control Logic Gates: 16 bits PC(12bits each), DR, AC,
IR, TR(16 bits each),
Signals to control the
Control Unit OUTR, INPR(8 bit each),
the nine registers’ inputs
and SC(4bits)
memory read and write Logic gates
Seven F/Fs : I, S, E, R,
F/Fs set, clear, or
3x8 DEC, 4x16 DEC IEN, FGI, and FGO (1 bit
complement
each)
S2 S1 S0 bus selection BUS: 8x1 MUX A 16-bit common bus
the AC ,ALU circuit
Two decoders: 3 x 8(opcode) 16 bits
and 4 x 16 timing decoder
 IR and TR

• The instruction register, IR, can only be

loaded; it cannot be incremented nor cleared.
Its output is used to generate Di’s and Ti’s
control signals.
• TR is a temporary register. The CPU uses
this register to store intermediate results of
operations. It is not accessible by the external
programs. It is loaded, incremented and
cleared like the other registers.
 Operations involve AC and DR Registers
Accumulator(AC) : s2
s1 B us

Main Register M e m o r y u n it
4096× 16 A d d re s s
s0
7

Microoperation : clear W r it e Read

AC, shift AC AR
1
LD IN R C LR

PC 2
Data Register : ADD LD IN R C LR

DR to AC, AND DR to D R
3

AC
LD IN R C LR

Adder E
and AC 4
lo g ic
LD IN R C LR

3) INPR: Input device

IN P R

IR 5
LD

TR
6
LD IN R C LR

O U TR

C lo c k
LD
1 6 - b it c o m m o n b u s
 Computer Instruction
3 Instruction Code Formats :
1-Register-reference instruction
–7xxx (7800 ~ 7001) :
CLA, CMA, ….
15 14 12 11 0

0 1 1 1 Register Operation

2-Input-Output instruction
–Fxxx(F800 ~ F040) :
INP, OUT, ION, SKI, ….
15 14 12 11 0

1 1 1 1 I/O Operation

3-Memory-reference instruction
Opcode = 000  110
I=0 : 0xxx ~ 6xxx, I=1: 8xxx
~Exxx
15 14 12 11 0
I=0 : Direct,
I=1 : Indirect I Opcode Address
 CONTROL UNIT HARDWARE (Hardwired)
• Inputs to the control unit come from IR where an instruction is stored.
• A hardwired control is implemented in the example computer using:
> A 3x8 decoder to decode opcode bits 12-14 into signals D0, ..., D7;

A flip-flop (I) to store the addressing mode bit in IR

A 4-bit binary
sequence counter A digital circuit
(SC) to count with inputs
D0, ..., D7,
from 0 to 15 to
T0, ..., T15, I,
achieve time and address bits
sequencing; in IR (11-0)
> A 4x16 decoder to generate
to decode the control outputs
supplied to
output of the control inputs and
counter into 16 select signals of
timing signals, registers , bus.
T0, ..., T15
 5.5 Instruction Cycle
• A computer goes through the following
instruction cycle repeatedly:
do
1. Fetch an instruction from memory
2. Decode the instruction
3. Read the effective address from memory if
the instruction has an indirect address
4. Execute the instruction until a HALT
instruction is encountered
Instruction and Interrupt cycles

Interrupt Cycle

Instruction cycle

Interrupts Enabled
Interrupts Disabled
Fetch,
Fetch,decode
decode Execute
Execute Interrupt
Interrupt
START
START Next
Next
Instruction Instruction
Instruction cycle
cycle
Instruction

HALT
HALT
 Instruction Fetch
– Instruction Fetch : T0, T1

• T0 = 1
–1) Place the content of PC onto the bus by making the bus
selection inputs S2S1S0=010
–2) Transfer the content of the bus to AR by enabling the LD
input of AR
T0 : A R  P C Continue
T1 : IR  M [ A R ], P C  P C  1 indefinitely unless
HALT instruction
is encountered

– T1 = 1
• 1) Enable the read input memory
• 2) Place the content of memory onto the bus by making S 2S1S0= 111
• 3) Transfer the content of the bus to IR by enable the LD input of IR
• 4) Increment PC by enabling the INR input of PC
Mano’s Computer Figure 5-4 s0 s1 s2
Bus
Memory Unit
7
4096x16
Address
WRITE READ
AR 1
LD INR CLR
PC 2
LD INR CLR
DR 3
LD INR CLR

Adder E
& Logic
AC 4
LD INR CLR

INPR

IR 5
LD
TR 6
LD INR CLR
OUTR
Clock
LD
16-bit common bus
Computer System Architecture, Mano, Copyright (C) 1993 Prentice-Hall, Inc.
 Instruction Cycle
• At T3, microoperations which take place depend on the type of instruction.
The four different paths are symbolized as follows,

• When D7`T3 = 1 (At T3 & IR(12-14) ¹ 111), the execution of memory-

reference instructions takes place with the next timing variable T4.

Control function Microoperation

D7`IT3: AR M[AR], indirect memory

transfer
D7`I`T3: Nothing, direct memory transfer
D7I`T3: Execute a register-reference
instruction
D7IT3: Execute an I/O instruction
 Address transfer between PC and AR
T0: Since only AR is connected to the address inputs of memory,
the address of instruction is transferred from PC to AR.
1. Place the content of PC onto the bus by making the bus
selection inputs S2S1S0 = 010.
2. Transfer the content of the bus to AR by enabling the LD input
of AR ( AR PC).
 Data transfer between Memory and IR
T1: The instruction read from memory is
placed in IR. At the same time, PC is
incremented to the address of the next
instruction.
1. Enable ‘read input’ of the memory.
2. Place the content of memory onto the
bus using the bus selection inputs
S2S1S0 = 111. (Note that the address
lines are always connected to AR, and
the next instruction address has been
already placed in AR.)
3. Transfer the content of the bus to IR
by enabling LD input to IR
(IR M[AR]).
4. Increment PC by enabling the INR
input of PC ( PC PC + 1 ).
 Decoding at T2
T2: The operation code in IR is
decoded; the indirect bit is
transferred to I; the address
part of the instruction is
transferred to AR.
REGISTER-REFERENCE INSTRUCTIONS
• The 12 register-reference instructions are recognized by I = 0 and
D7 = 1 (IR(12-14) = 111). Each operation is designated by the
presence of 1 in one of the bits in IR(0-11). Therefore D7I`T3 r =
1 is common to all register-transfer instructions.
 For example
• B7 = 080 (in hexadecimal)., In binary this is
equivalent to: 0000 1000 0000 (CIR)
• B6 = 040 (in hexadecimal)., In binary this is
equivalent to: 0000 0100 0000 (CIL)
 For example
• B3 = 008 (in hexadecimal)., In binary this
is equivalent to: 0000 0000 1000
(Complement E)
• B4 = 010 (Bi=bit in position i =4) in binary
is 0000 0001 0000 (skip if positive)
5.6 Memory Reference Instructions
• Opcode (000 - 110) or the decoded output Di (i = 0, ..., 6) are used
to select one memory-reference operation out of 7.
 Memory Reference
Instructions
• Since the data stored in memory cannot be
processed directly (the memory unit is not
connected to the ALU), the actual execution in
the bus system require a sequence of
microoperations.

• (Note that T0-T2 for fetch an instruction; T3 for

AR  M[AR] if indirect memory addressing.
 AND to AC
–Accumulator(AC) : takes input from ALU
»The ALU takes input from DR, AC and INPR :
»ADD DR to AC, AND DR to AC
–Note) Input register is not connected to the bus.
–The input register is connected only to the ALU
 AND to AC
• AND to AC: Logical AND operation between AC and the
memory word specified by AR.
• (Note that T0-T2 for fetch an instruction; T3 for AR 
M[AR] if indirect memory addressing.

• Need 2 more cycles for the AND logical operation since

only DR is connected to ALU.)
• D0T4: DR  M[AR]
• D0T5: AC  AC ˆ DR, SC  0
– SC – start counter
 ADD to AC
• ADD to AC: Arithmetic addition operation
between AC and the memory word
specified by AR.
• D1T4: DR  M[AR]
• D1T5: AC  AC + DR, SC  0
 Load to AC
• LDA: Load to AC.
• (Need 2 cycles since AC input is not
connected to the bus.)

• D2T4: DR  M[AR]
• D2T5: AC  DR, SC  0
 Store AC
• STA: Store AC.
• D3T4: M[AR]  AC, SC  0
• BUN: Branch unconditionally. Transfers
the program to the instruction specified by
AR. (Note that the branch target must be
in AR beforehand.)
• D4T4: PC  AR, SC  0
 Branch unconditionally
• BUN: Branch unconditionally. Transfers
the program to the instruction specified by
AR. (Note that the branch target must be
in AR beforehand.)

• D4T4: PC  AR, SC  0
Branch and save return address
• This instructioin is useful for branching to a
position of the program called a subprogram

• BSA: Branch and save return address. Branch

to address AR and save PC address.
• • BSA is used to implement a subroutine call.
The indirect BUN instruction at the end of the
subroutine performs the subroutine return.
Branch and save return address
Branch and save return address
• Note that the above microoperations
require 2 cycles.
• D5T4: M[AR]  PC, AR  AR + 1
(increment, INR AR)

• D5T5: PC  AR, SC  0
 Increment and skip if zero
• ISZ: Increment and skip if zero.

• Programmer usually stores a negative number in

the memory word (in two’s complement form).
• As this negative number is repeatedly
incremented by one, it eventually reaches zero.
At that time PC is incremented by one in order to
skip the next instruction.
 Increment and skip if zero
• increment: M[AR] M[AR] + 1, if (M[AR] + 1 =
0) then PC  PC + 1

• increment and skip if zero requires 3 cycles.

– D6T4: DR  M[AR]
– D6T5: DR  DR + 1
– D6T6: M[AR]  DR, if DR=0 then
PC  PC + 1, SC  0
• • The ISZ instructions is used to implement a
loop.
 Computer Instruction
3 Instruction Code Formats :
1-Register-reference instruction
–7xxx (7800 ~ 7001) :
CLA, CMA, ….
15 14 12 11 0

0 1 1 1 Register Operation

2-Input-Output instruction
–Fxxx(F800 ~ F040) :
INP, OUT, ION, SKI, ….
15 14 12 11 0

1 1 1 1 I/O Operation

3-Memory-reference instruction
Opcode = 000  110
I=0 : 0xxx ~ 6xxx, I=1: 8xxx
~Exxx
15 14 12 11 0
I=0 : Direct,
I=1 : Indirect I Opcode Address
 5.7 IO and Interrupt
• Input-Output Configuration :

– Input Register(INPR), Output Register(OUTR)

• These two registers communicate with a

communication interface serially and with the AC in
parallel
• Each quantity of information has eight bits of an
alphanumeric code
 IO and Interrupt
• Input Flag(FGI), Output Flag(FGO)

– FGI : set when INPR has information, clear

when INPR is empty

– FGO : set when operation is completed, clear

when output device is active (for example a
printer is in the process of printing)
 IO instructions
• These instructions are executed with the
clock transition associated with timing
signal T3
• For these instructions, D7=1 and I=1
• The control function is distinguished by
one of the bits in IR(6-11)
 Program Interrupt
• Program Interrupt
– Two I/O Transfer Modes
• 1) Programmed I/O
• 2) Interrupt-initiated I/O (FGI FGO)

• IEN: interrupt enable flip-flop

• R: interrupt flip-flop
 T 0 'T 1 'T 2 ' ( I E N ) ( F G I  F G O ) : R  1
In s t r u c t io n c y c le =0 =1 In t e rru p t c y c le
R

F e tc h a n d d e c o d e
S to re re tu rn a d d re s s
in s tr u c t io n
in lo c a t io n 0
M [0] PC

=0
E x e c u te IE N
in s t r u c t io n
=1
B r a n c h t o lo c a t io n 1
PC 1
=1
F G I

=0

=1 IE N 0
F G O R 0

=0

R 1
 Program Interrupt

• Demonstration of the interrupt cycle :

– The memory location at address 0 is the
place for storing the return address
– Interrupt Branch to memory location 1
– Interrupt cycle IEN=0 0 256(return address)
PC = 1 0 BUN 1120
Main Program
Interrupt 255
Here 256

Save Return RT 0 : AR  0 , TR  P C 1120 Interrupt

Address(PC) at 0 Service Routine
RT1 : M [ A R ]  TR , P C  0
Jump to 1(PC=1) 1 BUN 0
RT 2 : P C  P C  1, IE N  0 , R  0 , SC  0
Complete computer design
Mano's Computer: RTL
Design of control signals
 Design for logic control for the registers

• Example Address register (AR)

• The controls are: Load, Increment, Clear

• We must specify the logic for each on

 AR control continue
• The control to AR is with any instruction
have AR
AR control continue
AC control
AC control
• Same logic control will be applied to all
other registers and memory control bins
 Control of Bus Selection
• We need each bus selection combination to select one item to
appear on the bus
• For example to select the AR to appear on the bus search the RTL
table for all instructions that have AR as source
• We will find:

• Which can be grouped together as

• Same for memory will give

• These controls and others can be encoded
to form the selections S2S1S0
• The whole variables are summarized in
the table below