Professional Documents
Culture Documents
Single Cycle Processor PPT by Svnit
Single Cycle Processor PPT by Svnit
Single Cycle Processor PPT by Svnit
rs rt rd shamt R-Format
op funct
6 bits 5 bits 5 bits 16 bits
op rs rt offset I-Format
6 bits 26 bits
J-Format
op address
Implementing MIPS:
the Fetch/Execute Cycle
High-level abstract view of fetch/execute implementation
use the program counter (PC) to read instruction address
fetch the instruction from memory and increment PC
use fields of the instruction to select registers to read
execute depending on the instruction
repeat…
Processor Implementation Styles
Single Cycle
Perform each instruction in 1 clock cycle
Clock cycle must be long enough for slowest instruction
Multi-Cycle
Break fetch/execute cycle into multiple steps
Perform 1 step in each clock cycle
Pipelined
Single Vs. Multi-Cycle Processor Machine
1 cycle 4 cycles
Load Load
1 cycle 3 cycles
Add Add
1 cycle 2 cycles
Beq Beq
Time for a load, add, and beq = 60 ns 45 ns
• In the Single cycle implementation, every instruction
requires one cycle to complete, so cycle time = time taken for
the slowest instruction
• If the execution was broken into multiple (faster)
cycles, the shorter instructions can finish sooner
12
Processor Implementation Styles
Single Cycle
Perform each instruction in 1 clock cycle
Clock cycle must be long enough for slowest instruction
Disadvantage: only as fast as the slowest instruction
Multi-Cycle
Break fetch/execute cycle into multiple steps
Perform 1 step in each clock cycle
Advantage: each instruction uses only as many cycles as it needs
Pipelined
Execute each instruction in multiple steps
Perform 1 step / instruction in each clock cycle
Processor Implementation Styles
Unpipelined Start and finish a job before moving to the next
Jobs
Time
A B C
A B C Break the job into smaller stages
A B C
A B C
Pipelined
Processor Implementation Styles
Single Cycle
Perform each instruction in 1 clock cycle
Clock cycle must be long enough for slowest instruction
Disadvantage: only as fast as the slowest instruction
Multi-Cycle
Break fetch/execute cycle into multiple steps
Perform 1 step in each clock cycle
Advantage: each instruction uses only as many cycles as it needs
Pipelined
Execute each instruction in multiple steps
Perform 1 step / instruction in each clock cycle
Process multiple instructions in parallel
Functional Elements
Two types of functional elements in the hardware:
Elements that operate on data
Called combinational elements
Clock cycle
State Elements
Contain data in internal storage, e.g., registers and memory
All state elements together define the state of the machine
Flipflops and latches are 1-bit state elements, equivalently,
they are 1-bit memories
The output(s) of a flipflop or latch always depends on the bit
value stored, i.e., its state, and can be called 1/0 or high/low or
true/false
The input to a flipflop or latch can change its state depending
on whether it is clocked or not…
Basic memory unit
Set-Reset (SR-) latch Made from two cross-coupled nand gates
(unclocked) When both Sbar and Rbar are 1, then either one
of the following two states is stable:
Think of Sbar as S, the inverse of set (which a) Q = 1 & Qbar = 0
sets Q to 1), and Rbar as R, the inverse of reset. b) Q = 0 & Qbar = 1
Sbar and the latch will continue in the current stable
(set) n1 Q state.
Sbar X
r1 Q
n1
clk clkbar
a
Rbar r2 n2 Qbar
Y
Clocked D-latch
State can change only when clock is high
Only single data input (compare SR-latch)
No problem with non-deterministic behavior
D Dbar X
a2
r1 Q
n1
clk clkbar
a1
r2 n2 Qbar
Y
sbar
cbar s
clear
q
clkbar
clk
r qbar
rbar
d
Logi Sim
All components that we have discussed – and shall discuss – can
be fabricated using Logi Sim
State Elements on the Datapath:
Register File
Registers are implemented with arrays of D-flipflops
Clock
Read register
5 bits number 1 Read
data 1 32 bits
5 bits Read register
number 2
Register file
5 bits Write
register
Read 32 bits
Write data 2
32 bits data Write
Control signal
Register file with two read ports and one write port
State Elements on the Datapath:
Register File
Port implementation: Clock
Clock
Write
Read register C
number 1 0
Register 0
Register 0 1 D
Register 1 M n-to-1 C
Register number
u Read data 1 decoder Register 1
Register n – 1 x D
n– 1
Register n n
Read register
number 2
C
Register n – 1
M D
u Read data 2 C
x Register n
Register data D
Instruction
address
PC
Instruction Add Sum
Instruction
memory
Instruction
address
PC
Instruction Add Sum
Instruction
memory
Instruction
address
PC
Instruction Add Sum
Instruction
memory
Instruction
address
PC Add
Instruction Add Sum
Instruction 4
memory
Read
PC address
a. Instruction memory b. Program counter c. Adder
Instruction
Datapath
Animating the Datapath
PC
ADDR
Memory
RD Instruction
Datapath: R-Type Instruction
Datapath
Datapath: R-Type Instruction
Datapath
Datapath: R-Type Instruction
Datapath
Animating the Datapath
add rd, rs, rt
Instruction
op rs rt rd shamt funct R[rd] <- R[rs] + R[rt];
5 5 5 Operation
3
RN1 RN2 WN
RD1
Register File ALU Zero
WD
RD2
RegWrite
Datapath: Load/Store Instruction
3 ALU operation
Read
MemWrite register 1 MemWrite
Read
data 1
Read
Instruction register 2 Zero
Registers ALU ALU
Address Read Write Read
result Address
data 16 32 register data
Sign Read
Write data 2
extend Data
Write Data data
data memory memory
RegWrite Write
data
16 32
Sign MemRead
MemRead
extend
Specify:
Opcode, two registers, target address
Format:
op rs rt constant or address
16 bit Address ?
Recall: Branch Addressing
16 bits is too small a reach in a 232 address space
Solution:
Principle of locality
Most branch targets are near branch
Forward or backward Direction
Use PC (= program counter), called PC-relative addressing
based on Principle of Locality
PC-relative addressing
Target address = PC + offset × 4
PC already incremented by 4 by this time
Datapath: Branch Instruction
PC + 4 from instruction datapath
16 32
Sign
extend
Datapath
Animating the Datapath
Data is either
from ALU (R-type)
or memory (load) Combining the datapaths for R-type instructions
and load/stores using two multiplexors
Animating the Datapath:
R-type Instruction
Instruction add rd,rs,rt
32 16 5 5 5 Operation
3
RN1 RN2 WN
RD1
Register File ALU Zero
WD
M MemWrite
RD2 U ADDR MemtoReg
RegWrite X
Data
E Memory RD M
X U
16 32 ALUSrc X
T WD
N MemRead
D
Animating the Datapath:
Load Instruction
Instruction lw rt,offset(rs)
32 16 5 5 5 Operation
3
RN1 RN2 WN
RD1
Register File ALU Zero
WD
M MemWrite
RD2 U ADDR MemtoReg
RegWrite X
Data
E Memory RD M
X U
16 32 ALUSrc X
T WD
N MemRead
D
Animating the Datapath:
Store Instruction
Instruction sw rt,offset(rs)
32 16 5 5 5 Operation
3
RN1 RN2 WN
RD1
Register File ALU Zero
WD
M MemWrite
RD2 U ADDR MemtoReg
RegWrite X
Data
E Memory RD M
X U
16 32 ALUSrc X
T WD
N MemRead
D
MIPS Datapath II: Single-Cycle
Read Registers
ALU operation
register 1 3 MemWrite
PC Read
Read Read MemtoReg
address
register 2 data 1 ALUSrc Zero
Instruction ALU ALU
Write Read Address Read
register data 2 M result data
u M
Instruction Write x u
memory Data x
data memory
Write
RegWrite data
16 Sign 32 MemRead
extend
Separate instruction memory
as instruction and data read
occur in the same clock cycle
Adding instruction fetch
MIPS Datapath III: Single-Cycle
PCSrc New multiplexor
M
Add u
x
4 Add ALU
result
Shift
left 2 Extra adder needed as both
adders operate in each cycle
Registers
Read 3 ALU operation
MemWrite
Read register 1 ALUSrc
PC Read
address Read data 1 MemtoReg
register 2 Zero
Instruction ALU ALU
Write Read Address Read
register M result data
data 2 u M
Instruction u
memory Write x Data x
data memory
Write
RegWrite data
16 32
Sign
extend MemRead
Instruction address is either
PC+4 or branch target address
PC <<2 PCSrc
Instruction
ADDR RD
32 16 5 5 5 Operation
Instruction 3
Memory RN1 RN2 WN
RD1
Register File ALU Zero
WD
M MemWrite
RD2 U ADDR MemtoReg
RegWrite X
Data
E Memory RD M
U
16 X 32 ALUSrc X
T WD
N MemRead
add rd, rs, rt D
Datapath Executing lw
ADD
M
ADD
ADD U
4 X
PC <<2 PCSrc
Instruction
ADDR RD
32 16 5 5 5 Operation
Instruction 3
Memory RN1 RN2 WN
RD1
Register File ALU Zero
WD
M MemWrite
RD2 U ADDR MemtoReg
RegWrite X
Data
E Memory RD M
U
16 X 32 ALUSrc X
T WD
N MemRead
lw rt,offset(rs) D
Datapath Executing sw
ADD
M
ADD
ADD U
4 X
PC <<2 PCSrc
Instruction
ADDR RD
32 16 5 5 5 Operation
Instruction 3
Memory RN1 RN2 WN
RD1
Register File ALU Zero
WD
M MemWrite
RD2 U ADDR MemtoReg
RegWrite X
Data
E Memory RD M
U
16 X 32 ALUSrc X
T WD
N
sw rt,offset(rs) D
MemRead
Datapath Executing beq
ADD
M
ADD
ADD U
4 X
PC <<2 PCSrc
Instruction
ADDR RD
32 16 5 5 5 Operation
Instruction 3
Memory RN1 RN2 WN
RD1
Register File ALU Zero
WD
M MemWrite
RD2 U ADDR MemtoReg
RegWrite X
Data
E Memory RD M
U
16 X 32 ALUSrc X
T WD
N
beq r1,r2,offset D
MemRead
Control
1
Add M
u
x
4 ALU 0
Add result
New multiplexor RegWrite Shift
left 2
ALUOp
Adding control to the MIPS Datapath III (and a new multiplexor to select field to
specify destination register)
Control Signals
Signal Name Effect when deasserted Effect when asserted
RegDst The register destination number for the The register destination number for the
Write register comes from the rt field (bits 20-16) Write register comes from the rd field (bits 15-11)
PCSrc The PC is replaced by the output of the adder The PC is replaced by the output of the adder
that computes the value of PC + 4 that computes the branch target
MemRead None Data memory contents designated by the address
input are put on the first Read data output
Instruction [5 0]
MIPS datapath with the control unit: input to control is the 6-bit instruction
opcode field, output is seven 1-bit signals and the 2-bit ALUOp signal
PCSrc cannot be
set directly from the
0
M
u opcode: zero test
x
ALU
Add result 1
outcome is required
Add Shift PCSrc
RegDst left 2
4 Branch
MemRead
Instruction [31 26] MemtoReg
Control
ALUOp
MemWrite
ALUSrc
RegWrite
ALU
control
Determining control signals for the MIPS datapath based on instruction opcode
Memto- Reg Mem Mem
Instruction RegDst ALUSrc Reg Write Read Write Branch ALUOp1 ALUOp0
R-format 1 0 0 1 0 0 0 1 0
lw 0 1 1 1 1 0 0 0 0
sw X 1 X 0 0 1 0 0 0
beq X 0 X 0 0 0 1 0 1
Control Signals:
R-Type Instruction
ADD
0
M
ADD
ADD U
4 rs rt rd X
Control signals
N
D
0 MemRead 0
shown in blue 0
Control Signals:
lw Instruction
ADD
0
M
ADD
ADD U
4 rs rt rd X
Control signals
N
D
1 MemRead 0
shown in blue 1
Control Signals:
sw Instruction
ADD
0
M
ADD
ADD U
4 rs rt rd X
Control signals
N
D
1 MemRead 0
shown in blue 0
Control Signals:
beq Instruction
ADD
0
M
ADD
ADD U
4 rs rt rd X
Control signals
N
D
0 MemRead 0
shown in blue 0
Datapath with Control III
Jump opcode address
31-26 25-0
Composing jump New multiplexor with additional
target address control bit Jump
Instruction [5– 0]
MIPS datapath extended to jumps: control unit generates new Jump control bit
Datapath Executing j
R-Type Instruction Steps
add $t1, $t2, $t3
1. Fetch instruction and increment PC
2. Read two source registers from the register file
3. ALU operates on the two register operands
4. Write result to register
R-type Instruction: Step 1
add $t1, $t2, $t3 (active = bold)
0
M
u
x
Add ALU 1
result
Add Shift
RegDst left 2
4 Branch
MemRead
Instruction [31– 26] MemtoReg
Control ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [5– 0]
Instruction [5– 0]
Instruction [5 0]
Instruction [5 0]
Instruction [15– 0] 16 32
Sign
extend ALU
control
Instruction [5– 0]
Branch Instruction Steps
beq $t1, $t2, offset
1. Fetch instruction and increment PC
2. Read two register ($t1 and $t2) from the register file
3. ALU performs a subtract on the data values from the
register file; the value of PC+4 is added to the sign-
extended lower 16 bits (offset) of the instruction shifted
left by two to give the branch target address
4. The Zero result from the ALU is used to decide which
adder result (from step 1 or 3) to store in the PC
Branch Instruction
beq $t1, $t2, offset
0
M
u
x
ALU
Add result 1
Add
Shift
RegDst left 2
4 Branch
MemRead
Instruction [31– 26] MemtoReg
Control
ALUOp
MemWrite
ALUSrc
RegWrite
Instruction [5– 0]
ALU Control
Plan to control ALU:
Main control sends a 2-bit ALUOp control field to the ALU control.
Based on ALUOp and funct field of instruction
The ALU control generates the 3-bit ALU control field
110 sub 6
111 slt
Instruction
funct field
ALU must perform
add for load/stores (ALUOp 00)
sub for branches (ALUOp 01)
one of and, or, add, sub, slt for R-type instructions, depending on the
instruction’s 6-bit funct field (ALUOp 10)
Setting ALU Control Bits
Instruction AluOp Instruction Funct Field Desired ALU control
opcode operation ALU action input
LW 00 load word xxxxxx add 010
SW 00 store word xxxxxx add 010
Branch eq 01 branch eq xxxxxx subtract 110
R-type 10 add 100000 add 010
R-type 10 subtract 100010 subtract 110
R-type 10 AND 100100 and 000
R-type 10 OR 100101 or 001
R-type 10 set on less 101010 set on less 111
ALUOp Funct field Operation
ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0
0 0 X X X X X X 010
0 1 X X X X X X 110
1 X X X 0 0 0 0 010
1 X X X 0 0 1 0 110
1 X X X 0 1 0 0 000
1 X X X 0 1 0 1 001
1 X X X 1 0 1 0 111
Truth table for ALU control bits
Implementation: ALU Control Block
ALUOp Funct field Operation
ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0
0 0 X X X X X X 010
0 1 X X X X X X 110
1 X X X 0 0 0 0 010
1 X X X 0 0 1 0 110
1 X X X 0 1 0 0 000
1 X X X 0 1 0 1 001
1 X X X 1 0 1 0 111
ALUOp
Truth table for ALU control bits ALU control block
ALUOp0
ALUOp1
Operation2
F3
Operation
F2 Operation1
F (5– 0)
F1
Operation0
F0
Signal R- lw sw beq
Op3
Op2
name format Op1
Op5 0 1 1 0 Op0
Op4 0 0 0 0
Inputs
Op3 0 0 1 0 Outputs
Op2 0 0 0 1 R-format Iw sw beq
RegDst
Op1 0 1 1 0 ALUSrc
Op0 0 1 1 0 MemtoReg
RegDst 1 0 x x RegWrite
ALUSrc 0 1 1 0 MemRead
MemtoReg 0 1 x x MemWrite
Outputs
RegWrite 1 1 0 0 Branch
MemRead 0 1 0 0 ALUOp1
MemWrite 0 0 1 0 ALUOpO
One solution:
a variable-period clock with different cycle times for each
instruction class
unfeasible, as implementing a variable-speed clock is technically
difficult
Another solution:
use a smaller cycle time…
…have different instructions take different numbers of cycles
by breaking instructions into steps and fitting each step into one
cycle
feasible: multicyle approach!
Next
Multi Cycle
Implementing MIPS:
the Fetch/Execute Cycle
High-level abstract view of fetch/execute implementation
use the program counter (PC) to read instruction address
fetch the instruction from memory and increment PC
use fields of the instruction to select registers to read
execute depending on the instruction
repeat…
Data
Register #
PC Address Instruction Registers ALU Address
Register #
Instruction
memory Data
Register # memory
Data