Construction du chemin de données

Fonctionnalité du chemin de données

 Chemin de données simplifié pour les instructions :
 chargement/rangement : lw, sw
 arith. et logique : add, addu, sub, subu, and,
or, xor, nor, slt, sltu
 arith. et logique immédiate : addi, addiu, andi,
ori, xori, slti, sltiu
 de contrôle de flux : beq, j
 Schéma d'exécution :
 Fetch : lecture et mise à jour de registre d'adresse RAM
de l'instruction courante
 Decode : décodage de l'instruction (et lecture des
registres)
Fetch
 Execute : exécution de l'instruction PC = PC+4

Exec Decode
Vue simplifiée
 Deux types d'unités :
 Combinatoires (UAL, logique de contrôle)
 Séquentielles : bancs de registres, mémoires

Write Data
Instruction Read Address
Memory Register
Reg Addr Data Data
PC Address Instruction File ALU Memory Read Data
Reg Addr Read
Write Data
Data
Reg Addr

 Hyp : opération traitée en 1 seul cycle

 Mémoire instructions – mémoire de données
(modèle Harvard)
Recherche d'instruction (Fetch)
 Deux étapes
 Lire l'instruction dans la mémoire
 Mettre à jour le registre PC

clock Add

4
Fetch
PC = PC+4 Instruction
Memory
Exec Decode Read
PC Instruction
Address

 PC est mis à jour à chaque top horloge (pas besoin de

signal d'écriture)
 La lecture est une action « combinatoire » (pas besoin
de signal de contrôle)
Décodage (Decode)
 Décodage effectué par l'unité de contrôle :
 entrée : opcode
 sortie : signaux vers banc de registres, UAL, ...

Control
Unit
Fetch
PC = PC+4

Exec Decode Read Addr 1

Register Read
Read Addr 2 Data 1
Instruction
File
Write Addr Read
Data 2
Write Data
 Exécution (Execute) Instruction de type R
 add, sub, slt, and, or
31 25 20 15 10 5 0
R-type: op rs rt rd shamt funct

 exécuter l'op (op et funct) sur les opérandes rs et rt

 stocker le résultat dans rd
RegWrite ALU control

Read Addr 1
Fetch Read
Register
PC = PC+4 Read Addr 2 Data 1 overflow
Instruction
File ALU zero
Write Addr Read
Exec Decode
Data 2
Write Data

 Banc de registre pas mis à jour à chaque instruction (e.g.

sw), signal spécifique (écriture sur front descendant sinon
conflit avec la lecture)
Exécution : Instructions Load et Store

31 25 20 15 0
I-Type: op rs rt address offset

 Ex : lw $t1, 4($t0)
  sw  $t0, 12($sp)
 additionne le contenu d'un registre (rs) à une
constante 16 bits :
- registre de base (rs) lu après décodage
- extension de la constante à 32 bits
 store : lecture dans le banc de registres, écriture en
mémoire
 load : lecture mémoire, écriture dans le banc de
registres
Exécution : Instructions Load et Store

31 25 20 15 0
I-Type: op rs rt address offset

 Ex : lw $t1, 4($t0)
  sw  $t0, 12($sp)
 additionne le contenu d'un registre (rs) à une
constante 16 bits :
- registre de base (rs) lu après décodage
- extension de la constante à 32 bits
 store : lecture dans le banc de registres, écriture en
mémoire
 load : lecture mémoire, écriture dans le banc de
registres
Instructions Load et Store

RegWrite ALU control MemWrite

overflow
Read Addr 1 $t0 zero
Register Read Address
Read Addr 2 Data 1
Instruction Data
File ALU Memory Read Data
Write Addr Read
Data 2 Write Data
Write Data

Sign MemRead
16 Extend 32

Read data 1 : @ $t0

4 sur 16 bits -> 4 sur 32 bits
lw $t1, 4($t0) ALU control : addition
MemRead = 1
Write addr = @ $t1
RegWrite = 1
Instruction Branch

31 25 20 15 0
I-Type: op rs rt address offset

 compare les registres rs et rt (test flag zero )

 calcul de l'adresse destination (relative à PC) :

(PC+4) + extension(offset) << 2
 Instruction Branch

Add Branch
Add target
4 Shift address
left 2

ALU control
PC

Read Addr 1 zero (to branch

Read $t0 control logic)
Register
Read Addr 2 Data 1
Instruction
File
ALU
Write Addr Read $t1
Data 2
Write Data

Sign
16 Extend 32
beq $t0, $t1, 8
(if ($t0-$t1 == 0) PC += 8)
Instruction Jump

31 25 0
J-Type: op jump target address

récupération des 4 bits

de poids forts de PC+4
=> code < 2^28
Add

4
4
Jump
Instruction
Shift address
Memory
left 2 28
Read
PC Instruction
Address 26
Assemblage des composants
 ajoutdes lignes de contrôle
 Fetch, decode et execute en un seul cycle :
 chaque ressource utilisée une seule fois (ex :
séparation des mémoires)
 multiplexeur

 temps de cycle réglé sur l'instruction la plus

longue
Fetch, Decode, Execute

Add
RegWrite ALU control MemWrite
4
ovf
zero
Instruction Read Addr 1
Register Read Address
Memory
Read Addr 2 Data 1 Data
Read File
PC Instruction Memory Read Data
Address ALU
Write Addr Read
Data 2 Write Data
Write Data

MemRead
Sign
16 Extend 32
Ajout de mutlipexeurs

Add
RegWrite ALUSrc ALU control MemWrite MemtoReg
4
ovf
zero
Instruction Read Addr 1
Register Read Address
Memory
Read Addr 2 Data 1 Data
Read File
PC Instruction Memory Read Data
Address ALU
Write Addr Read
Data 2 Write Data
Write Data

MemRead
Sign
16 Extend 32
Ajout de l'horloge
System Clock

clock cycle

RegWrite MemWrite

Add
ALUSrc ALU control MemtoReg
4
ovf
zero
Read Addr 1
Instruction Read Address
Memory Register
Read Addr 2 Data 1 Data
Read File
PC Instruction Memory Read Data
Address ALU
Write Addr Read
Data 2 Write Data
Write Data

MemRead
Sign
16 Extend 32
Ajout de l'unité de branchement

Add

RegWrite ALUSrc ALU control MemWrite MemtoReg

ovf
zero
Read Addr 1
Instruction Read Address
Memory Register
Read Addr 2 Data 1 Data
Read File
PC Instruction Memory Read Data
Address ALU
Write Addr Read
Data 2 Write Data
Write Data

MemRead
Sign
16 Extend 32
Ajout de l'unité de branchement

Add
Add
4 Shift
left 2 PCSrc
RegWrite ALUSrc ALU control MemWrite MemtoReg
ovf
zero
Read Addr 1
Instruction Read Address
Memory Register
Read Addr 2 Data 1 Data
Read File
PC Instruction Memory Read Data
Address ALU
Write Addr Read
Data 2 Write Data
Write Data

MemRead
Sign
16 Extend 32
 Ajout de l'unité de contrôle
0
Add
Add 1
4 Shift
left 2 PCSrc
ALUOp Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr 1
Instruction
Register Read Address
Memory Instr[20-16] Read Addr 2 Data 1 zero
Data
Read
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
ALU control
Opérations UAL
 Code op de l'UAL

Entrées op Fonction
UAL
0000 and
0001 or
0010 xor
0011 nor
0110 add
1110 subtract
1111 set on less than
 Circuit : ALU control
 entrées : funct (dans le code op) + bits ALUOp (de l'unité de
contrôle)
 sorties : ALUcontrol bits
Instr op funct ALUOp action ALUcontrol
lw xxxxxx 00 add 0110
sw xxxxxx 00 add 0110
beq xxxxxx 01 subtract 1110
add 100000 10 add 0110
subt 100010 10 subtract 1110
and 100100 10 and 0000
or 100101 10 or 0001
xor 100110 10 xor 0010
nor 100111 10 nor 0011
slt 101010 10 slt 1111
 ALU Control : circuit combinatoire

Instr[3]

Instr[2]

Instr[1]

Instr[0]

ALUOp1

ALUOp0

ALUcontrol3

ALUcontrol2

ALUcontrol1

ALUcontrol0
Conception de l'unité de contrôle
 R-type Instruction Data/Control Flow
0
Add
Add 1
4 Shift
left 2 PCSrc
ALUOp Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr 1
Instruction
Register Read Address
Memory Instr[20-16] Read Addr 2 Data 1 zero
Data
Read
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
 R-type Instruction Data/Control Flow
0
Add
Add 1
4 Shift
left 2 PCSrc
ALUOp Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr
Instruction
Register Read
1 Address
Memory Instr[20-16] Read Addr 2 Data 1 zero
Data
Read
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
 Store Word Instruction Data/Control Flow
0
Add
Add 1
4 Shift
left 2 PCSrc
ALUOp Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr 1
Instruction
Register Read Address
Memory Instr[20-16] Read Addr 2 Data 1 zero
Data
Read
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
 Store Word Instruction Data/Control Flow
0
Add
Add 1
4 Shift
left 2 PCSrc
ALUOp Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr 1
Instruction
Register Read Address
Memory Instr[20-16] Read Addr 2 Data 1 zero
Data
Read
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
 Load Word Instruction Data/Control Flow
0
Add
Add 1
4 Shift
left 2 PCSrc
ALUOp Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr 1
Instruction
Register Read Address
Memory Instr[20-16] Read Addr 2 Data 1 zero
Data
Read
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
 Branch Instruction Data/Control Flow
0
Add
Add 1
4 Shift
left 2 PCSrc
ALUOp Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr 1
Instruction
Register Read Address
Memory Instr[20-16] Read Addr 2 Data 1 zero
Data
Read
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
 Unité de contrôle
Instr RegDst ALUSrc MemReg RegWr MemRd MemWr Branch ALUOp

R-
type
000000

lw
100011

sw
101011

beq
000100

 entrée : uniquement code op de l'instruction

 sorties : les différents signaux pour les circuits
Unité de contrôle : table de vérité
Instr RegDst ALUSrc MemReg RegWr MemRd MemWr Branch ALUOp
R-type 1 0 0 1 0 0 0 10
000000

lw 0 1 1 1 1 0 0 00
100011

sw X 1 X 0 0 1 0 00
101011

beq X 0 X 0 0 0 1 01
000100
 Unité de contrôle : table de vérité

Instr[31]

Instr[30]

Instr[29]

Instr[28]

Instr[27]

Instr[26]
R-type lw sw beq
RegDst

ALUSrc
MemtoReg
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOp0
Ajoutons les instructions de saut
 Jump :
 remplace les 28 bits de poids faible de PC par les 26
bits indiqués dans l'adresse décalée de 2 bits à gauche
31 0
J-Type: op jump target address

Add

4
4
Jump
Instruction
Shift address
Memory
left 2 28
Read
PC Instruction
Address 26
 Ajout de jump
Instr[25-0] 1
Shift 28 32
26 left 2 0
PC+4[31-28]
Add 0
Add 1
4 Shift
Jump left 2 PCSrc
ALUOp
Branch
MemRead
Instr[31-26] Control MemtoReg
Unit MemWrite
ALUSrc

RegWrite
RegDst
ovf
Instr[25-21] Read Addr 1
Instruction Read Address
Memory Register
Instr[20-16] Read Addr 2 Data 1 zero
Read Data
PC Instr[31-0] 0 File
ALU Memory Read Data 1
Address Write Addr
1 Read 0
Instr[15 Data 2 Write Data 0
Write Data
-11] 1

Instr[15-0] Sign ALU

16 Extend 32 control

Instr[5-0]
 Unité de contrôle
Instr RegDst ALUSrc MemReg RegWr MemRd MemWr Branch ALUOp Jump
R-type 1 0 0 1 0 0 0 10 0
000000

lw 0 1 1 1 1 0 0 00 0
100011

sw X 1 X 0 0 1 0 00 0
101011

beq X 0 X 0 0 0 1 01 0
000100

j X X X 0 0 0 X X 1
000010
Utilisation du chemin de données
Les instructions n'utilisent pas toutes les mêmes
parties du chemin de données :

 format
R / branch : pas d'accès à la mémoire de
données

 store : pas d'écriture de registre

 toutes les instructions ne stabilisent pas leurs

circuits utiles dans le même temps => gain de
temps grâce à une exécution multicycles