1

nPC_sel
PC Suiv.
PC
Lecture
op

Instruction
fun

Lecture
Registres

Cond=
ExtOp
Ext
Contrôle
Principal

ALUctr
ALU

ALUSrc
MemRd
Accès MemWr
ALU

Mémoire
Contrôle

Mem Ecrit RegDst

Donn. Regs. RegWr
MemWr

Rangement Résultat
Chapitre 6: Conception d ’un processeur Multi-Cycle

Introduction: Vue Simplifiée du processeur Mono-Cycle

Introduction
Par définition, dans un modèle à cycle unique, le cycle d’horloge
doit avoir la même durée pour toutes les instructions. Le cycle
d’horloge est défini par le chemin le plus long dans la machine.
Par conséquences :
1- Les performances d’une mise en oeuvre à cycle unique ne sont pas bonnes, car
certains types d’instruction pourraient être effectués en un cycle d’horloge plus
court.
2- De plus, chaque unité fonctionnelle ne peut être utilisée qu’une fois par cycle ;
par conséquent, certaines unités doivent être dupliquées, ce qui augmente le coût de
la mise en oeuvre.
Nous allons éviter ces problèmes en utilisant une technique de mise
en oeuvre qui a un cycle de base plus court et qui requièrent
plusieurs cycles d’horloge par instruction. Cette mise en oeuvre est
appelée mise en oeuvre multicycle.
Longueur requise par chaque type
d’instruction
On suppose que le temps d’opérations pour les principales unités
fonctionnelles vaut :
Unités mémoire : 10ns
UAL et additionneurs : 10 ns
Banc de registres (lecture ou écriture) : 5ns
Ce qu’il faut redire d’un cycle unique
Temps des chemins critiques

40

chargement d’un mot

Ce qu’il faut redire d’un cycle
unique
Temps des chemins critiques

35
40 Rangement d’un mot

chargement d’un mot

Ce qu’il faut redire d’un cycle
unique
Temps des chemins critiques

30
Opération de format R
35
40 Rangement d’un mot

chargement d’un mot

Ce qu’il faut redire d’un cycle
unique
Temps des chemins critiques

25
Branchement
30
Opération de format R
35
40 Rangement d’un mot

chargement d’un mot

Ce qu’il faut redire d’un cycle
unique
Temps des chemins critiques

10
Saut
25
Branchement
30
Opération de format R
35
40 Rangement d’un mot

chargement d’un mot

 Ce qu’il faut redire d’un cycle
unique
Temps des chemins critiques

10
25

30
35
40 Cycle d’horloge

•le cycle d’horloge doit avoir la même durée pour toutes les
instructions. Le cycle d’horloge est défini par le chemin le plus
long dans la machine, ici 40 ns.
Ce qu’il faut redire d’un cycle
unique
Temps des chemins critiques

10
25

30
35
Inactivité
40 Cycle d’horloge
Ce qu’il faut redire d’un cycle
unique
Temps des chemins critiques

10
25

30
35
40
 Mise en oeuvre multicycle
Nous allons éviter la perte :
1 de temps
2 de matériel
en utilisant une technique de mise en oeuvre qui a un cycle de base plus court et qui
requièrent plusieurs cycles d’horloge par instruction.
Cette mise en oeuvre est appelée mise en oeuvre multicycle.
 Les caractéristiques d’une oeuvre
multicycle
Chaque étape de l’exécution prendra un cycle d’horloge
Les exécutions seront donc exécutées en des nombres de cycles
différents.
Avec une telle mise en oeuvre, une unité fonctionnelle peut être
utilisée plusieurs fois par instruction, tant qu’il s’agit de cycles
d’horloge différents. Ceci réduit la quantité de matériel nécessaire.
 Réduction Temps Instruction
 Insertion de registres intermédiaires
 Même travail fait dans plusieurs cycles rapides, au lieu de un seul cycle lent

Registre PC Registre

Logique Logique
combinatoire combinatoire A

=> Registre

Logique
combinatoire B
Registre
Mémoire ou banc de registre
Registre
14
15
 Basic Idea of Multi Cycle Data Path

16
 Instruction Execution
Cycl Action Register Transfers RTL
e
1 Fetch instruction IR ← Memory[PC] , PC ← PC + 4
Decode instruction
Generate control signals
Fetch registers
A ← Reg[Rs], B ← Reg[Rt]
2 Compute branch address in
ALUOut ← (PC + sign-
advance extend(IR[15-0]) << 2)
Jump completion (case of a jump)
Case 1: Execute R-type ALU
ALUOut = A op B;
Case 2: Execute I-type ALU
ALUOut = A + sign-
3 Case 3: Compute load/store extend(IR[15-0]);
address
if (A == B) PC = ALUOut
Case 4: Branch completion
Case 1: Write ALU result for R-
type Reg[Rd] ← ALUout
Case 2: Write ALU result for I- Reg[Rt] ← ALUout
4
type MDR ← Memory[ALUout]
Case 3: Access memory for load Memory[ALUout] ← B
Case 4: Access memory for store
5 Load instruction completion Reg[Rt] ← MDR
 Multicycle Execution Step (1):
Instruction Fetch
IR = Memory[PC];
PC = PC + 4;

I Instruction I
R
5 5 5 Operation
3
PC MemWrite RN1 RN2 WN
ADDR RD1 A Zero
Registers
Memory M ALU
RD D WD ALU

PC + 4 WD
R
RD2 B 4 OUT

MemRead RegWrite
 Multicycle Control Step (1):
Fetch
IR = Memory[PC];
PC = PC + 4;
IRWrite

1
I Instruction I jmpaddr 28 32
R I[25:0] <<2 CONCAT
5
PCWr* rs rt rd
2
1 IorD
32 5 5
0
MUX
1 RegDst
1U
M

5 ALUSrcA X
PC 0 0 RN1 RN2 WN
Operation
0 0
3
0M
U
MemWrite
ADDR M
X 0M
U
010 PCSource
1X
D 1M Registers RD1 A 1X Zero
Memory U WD ALU
RD R 0X ALU
WD RD2 B 0
OUT 0
MemRead MemtoReg 4 1M
U
2X
3
RegWrite
X E
1 immediate 16
0 X 32 ALUSrcB
T <<2
N
D 1
Multicycle Execution Step (2):
Instruction Decode & Register Fetch
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])
ALUOut = (PC + sign-extend(IR[15-0]) << 2)

I Instruction I
R Branch
5 5 5 Reg[rs] Operation
3
Target
PC MemWrite RN1 RN2 WN Address
ADDR RD1 A Zero
Registers
Memory M ALU
RD D WD ALU
OUT
PC + 4 WD
R B
RD2
MemRead RegWrite
Reg[rt]
Multicycle Control Step (2):
Instruction Decode & Register Fetch
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])
ALUOut = (PC + sign-extend(IR[15-0]) << 2);
0IRWrite

I 28 32
0 R
Instruction I
5
jmpaddr
I[25:0] <<2 CONCAT
PCWr* rs rt rd
X 0 1 RegDst 0 2
IorD 0 32 5 5 MUX
5 X ALUSrcA 010 1U
M

X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U ADDR M U PCSource
1X Registers 1X Zero
Memory
RD
D
R
1M
U WD
RD1 A
ALU X
0X ALU
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
X 2X
3
RegWrite
0 0 E
16 X 32
ALUSrcB
immediate
T <<2 3
N
D
 Multicycle Control Step (3):
Execute R-type ALU
ALUOut = A op B;
0
IRWrite

I Instruction I jmpaddr 28 32
0 R 5 I[25:0] <<2 CONCAT
PCWr* rs rt rd
X 32
0 1 RegDst 1 2
IorD 0 5 5 MUX
5 X ALUSrcA ??? 1U
M

X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U ADDR M U PCSource
1X
D 1M Registers RD1 A 1X Zero
Memory
RD R U
0X
WD ALU X
ALU
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
X 2X
3
RegWrite
0 0 E
16 X 32
ALUSrcB
immediate
T
N
<<2 0
D
 Multicycle Execution Step (4):
ALU Instruction (R-Type)
Reg[IR[15:11]] = ALUOUT

I Instruction I
R
5 5 5 Operation
Reg[rs]
3
R-Type
PC MemWrite RN1 RN2 WN
Result
ADDR RD1 A Zero
Registers
Memory M ALU
RD D WD ALU
OUT
PC + 4 R
WD RD2 B
MemRead RegWrite
Reg[rt]
 Multicycle Control Step (4):
ALU Instruction (R-Type)
Reg[IR[15:11]] = ALUOut; (Reg[Rd] =
ALUOut) 0
IRWrite

I Instruction I jmpaddr 28 32
0 R 5 I[25:0] <<2 CONCAT
PCWr* rs rt rd
X 32 5 5
0
MUX
1 RegDst
X
2
M
IorD
0 5 1 ALUSrcA
XXX
1U
X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U
1X
ADDR M Registers U PCSource
1X Zero
Memory D 0 M RD1 A
RD R 1
U
X
WD ALU
ALU
X
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
2X
1 RegWrite
3

0 1 E
ALUSrcB
immediate 16 X 32
T <<2
N X
D
 Multicycle Execution Step (3):
Compute load/store address
ALUOut = A + sign-extend(IR[15-0]);

I Instruction I
R
5 5 5 Operation
Reg[rs] Mem.
3
PC MemWrite RN1 RN2 WN Address
ADDR RD1 A Zero
Registers
Memory M ALU
RD D WD ALU
OUT
PC + 4 WD
R B
RD2
MemRead RegWrite
Reg[rt]
 Multicycle Control Step (3):
Compute load/store address
ALUOut = A + sign-extend(IR[15-0]);
0
IRWrite

I Instruction I jmpaddr 28 32
0
PCWr*
R
rs rt
5
rd
I[25:0] <<2 CONCAT

X 32 5 5
0
MUX
1 RegDst
1
2
M
IorD 0 5 X ALUSrcA 010 1U
X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U
1X
ADDR M Registers U PCSource
D 1M RD1 A 1X Zero
Memory
RD R U
0X
WD ALU
ALU
X
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
2X
X RegWrite 3
0 0 E
16 X 32
ALUSrcB
immediate
T
N
<<2 2
D
 Multicycle Execution Step (4):
Memory Access - Read (lw)
MDR = Memory[ALUOut];

I Instruction I
R
5 5 5 Operation Mem.
Reg[rs]
3 Address
PC MemWrite RN1 RN2 WN
ADDR RD1 A Zero
Registers
Memory M ALU
RD D WD ALU
OUT
PC + 4 R
WD RD2 B
MemRead RegWrite
Mem. Reg[rt]
Data
 Multicycle Control Step (4):
Memory Access - Read (lw)
MDR = Memory[ALUOut];
IRWrite 0

I Instruction I jmpaddr 28 32
0 R
5 I[25:0] <<2 CONCAT
PCWr* rs rt rd
1 32
0 1 RegDst
X 2
IorD 0 5 5 MUX
5 X ALUSrcA XXX 1U
M

X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U
1X
ADDR M Registers U PCSource
D 1M RD1 A 1X Zero
Memory
RD R U
0X
WD ALU X
ALU
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
X RegWrite
2X
3
1 0 E
16 X 32
ALUSrcB
immediate
T
N
<<2 X
D
 Multicycle Execution Steps (5)
Memory Read Completion (lw)
Reg[IR[20-16]] = MDR;
IRWrite 0

I Instruction I jmpaddr 28 32
0 R 5 I[25:0] <<2 CONCAT
PCWr* rs rt rd
X 32
0 1 RegDst
X 2
IorD 0 5 5 MUX
5 0 ALUSrcA XXX 1U
M

X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U ADDR M U PCSource
1X
D 0 Registers RD1 A 1X Zero
Memory
RD R 1
M
U
X
WD ALU X
ALU
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
2X
0 RegWrite 3
0
immediate 16
1 E
X 32
ALUSrcB
T
N
<<2 X
D
 Multicycle Execution Step (5):
Memory Read Completion (lw)
Reg[IR[20-16]] = MDR;

I Instruction I
R
5 5 5 Operation
Reg[rs]
3
Mem.
PC MemWrite RN1 RN2 WN
ADDR
Address
RD1 A Zero
Registers
Memory M ALU
RD D WD ALU
OUT
PC + 4 R
WD RD2 B
MemRead RegWrite
Mem. Reg[rt]
Data
 Multicycle Execution Step (4):
Memory Access - Write (sw)
Memory[ALUOut] = B;

I Instruction I
R
5 5 5 Operation
Reg[rs]
3
PC MemWrite RN1 RN2 WN
ADDR RD1 A Zero
Registers
Memory M ALU
RD D WD ALU
OUT
PC + 4 R
WD RD2 B
MemRead RegWrite
Reg[rt]
 Multicycle Execution Steps (4)
Memory Access - Write (sw)
Memory[ALUOut] = B;
IRWrite 0

I Instruction I jmpaddr 28 32
0
PCWr*
R
rs rt
5
rd
I[25:0] <<2 CONCAT

1 32
0 1 RegDst
X
2
M
IorD 1 5 5 MUX
5 X ALUSrcA XXX 1U
X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U ADDR M U PCSource
1X
D 1M Registers RD1 A 1X Zero
Memory U WD ALU X
RD R 0X ALU
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
2X
X RegWrite 3
0 0 E
16 X 32
ALUSrcB
immediate
T
N
<<2 X
D
 Multicycle Control Step (3):
Branch completion Beq
if (A == B) PC = ALUOut;
0
IRWrite

1 if I Instruction I jmpaddr 28 32
Zero=1 R 5 I[25:0] <<2 CONCAT
PCWr* rs rt rd
X 32
0 1 RegDst 1 2
IorD 0 5 5 MUX
5 X ALUSrcA 011 1U
M

X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U ADDR M U PCSource
1X
D 1M Registers RD1 A 1X Zero
Memory
RD R U
0X
WD ALU 1
ALU
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
X 2X
3
RegWrite
0 0 E
16 X 32
ALUSrcB
immediate
T
N
<<2 0
D
 Multicycle Execution Step (3):
Jump Instruction
PC = PC[31-28] concat (IR[25-0] << 2)

I Instruction I
R
5 5 5 Operation
Branch
Reg[rs]
3 Target
PC MemWrite RN1 RN2 WN
ADDR
Address
Registers
RD1 A Zero
Memory M ALU
RD D WD ALU
Jump R OUT
WD RD2 B
Address MemRead RegWrite
Reg[rt]
 Multicycle Execution Step (3):
Jump Instruction
PC = PC[21-28] concat (IR[25-0] << 2);
0
IRWrite

I Instruction I jmpaddr 28 32
1
PCWr*
R
rs rt
5
rd
I[25:0] <<2 CONCAT

X 32
0 1 RegDst
X
2
M
IorD 0 5 5 MUX
5 X ALUSrcA XXX 1U
X
PC Operation 0
MemWrite RN1 RN2 WN 3
0M 0M
U
1X
ADDR M Registers U PCSource
D 1M RD1 A 1X Zero
Memory U WD ALU 2
RD R 0X ALU
OUT
WD RD2 B 0
MemRead MemtoReg 4 1M
U
2X
X RegWrite 3
0 0 E
16 X 32
ALUSrcB
immediate
T
N
<<2 X
D
 Control Signals
Signal Effect when ‘0’ Effect when ‘1’
RegDst Destination register = Rt Destination register = Rd
RegWrite None Register(RW) ← BusW
16-bit immediate is sign-
ExtOp 16-bit immediate is zero-extended
extended
1st ALU operand is PC (upper 30-
ALUSrcA 1st ALU operand is the A register
bit)
ALUSrcB 2nd ALU operand is the B register 2nd ALU input is extended-imm16
MemRead None MemData ← Memory[address]
MemWrite None Memory[address] ← Data_in
MemtoRe
BusW = ALUout BusW = MDR
g
IorD Memory Address = PC Memory Address = ALUout
IRWrite None IR ← MemData
PCWrite None PC ← NextPC
Valu
Signal Effect
e
00 NextPC = PC[31:2] + 1 (increment upper 30 bits of PC)
NextPC = ALUout = PC[31:2] + 1 + sign-extend(imm16) (for
PCSource 01
36
branch)
10 NextPC = PC[31:28], imm26 (for jump)
 Modèle du Contrôle
 Un état spécifiant les points de contrôle pour les Transferts de Registres.
 Transfert prend place au moment ou on quitte l ’état (front descendant).

Conditions (op, Cond=)

Logique état Etat X

suivant
Transferts de registres
Points de contrôle
Etat Courant
Dépend des entrées

Logique Sorties

Points de contrôle

37