Chapitre 3 : Conception de processeur MIPS mono_cycle

Les cinq composants classiques d’un Calculateur

Contrôle Entrées

Mémoire
Chapitre 3: CONCEPTION DE PROCESSEUR Chemin de Sorties
MIPS MONOCYCLE données

Objectif: Implémentation et Conception (chemin de données +contrôle) d’un processeur

mono-cycle:
- Un cycle d’horloge par instruction
- Long temps d’exécution

Page : 42

Comment concevoir un processeur (étape par étape)?

Fonctionnalité du chemin de données
• Objectif: Créer un chemin de données qui nous permet d’exécuter l’ensemble des
instructions MIPS.
• Chaque instruction est donnée en fonction des transferts des registres. (ADD Type I
$1,$2,$3)
Type R
• Le chemin de données doit permettre le transfert des informations entre les
registres. Type I
• Le chemin de données inclut la mémoires programme. Type J
• 2. Choix d’un ensemble de composants nécessaires (UAL MUX, Banc de Type I
Registre…) pour le chemin de données et établissement de la méthodologie
horloge.
• 3. Assemblage des différents composants pour la satisfaction des besoins.
• 4. Déterminer les points de contrôles nécessaires pour effectuer le transfert des
registres.
• 5. Assemblage de la logique de contrôle. (séquenceur)

Page : 43 Page : 44
 Composants du chemin de données
Etape 1
•1/2Adder A 32

Adder
Somme
32
• Choix d’un ensemble de composants B
32
nécessaires (UAL MUX, Banc de Registre…)
pour le chemin de données et établissement Select Éléments logique combinatoire
(blocks de base)
de la méthodologie horloge. •MUX A
32

MUX
Y
32
B
32

OP

A
32
•UAL

ALU
Résultat
32
B
32
Page : 46

Éléments mémoires : Registre, banc de registre Élément mémoire: Mémoire idéale

• Registre Write Enable Address

Write Enable • Mémoire (idéale)
–Similaire à une bascule D sauf que:
– Un seul bus d’entrées : Data In Data In DataOut
• N-bit entrées et N-bit sorties Data In Data Out – Un seul bus de sortie : Data Out 32 32
• Entrée de validation d’écriture N N • Le mot mémoire est sélectionner par : Clk

–Write Enable (écriture validée) – L’adresse qui choisie la sortie sur Data Out.
• (0): La sortie (Data Out) ne peut être Clk – Write Enable = 1: adresse sélectionne le mot mémoire ou l’entrée
Data In sera écrite.
changée.
• Clock input (CLK)
• (1): La sortie peut devenir celle de
– CLK Entrée est un facteur utilisée seulement dans le cas d’écriture.
l’entrée (Data In).
RW RA RB
– Durant l’opération de lecture, La mémoire fonctionne comme un
Write Enable block logique combinatoire.
•Banc de registre 5 5 5
• Adresse valide => Data Out valide après « temps d’accès ».
busA
RA or RB valide => busA or busB busW 32
valide après « temps d’accès » 32 32-bit
32 Registres
Clk busB
Page : 47 32 Page : 48
 Etape 2 Implémentation matérielle de la Phase de recherche d’instruction
(FETCH)

Au moment du front de l’horloge, cette phase

Assemblage des différents passe par deux étapes :
Etape 1 : lire le format d’instruction logée

composants pour la dans la mémoire de programme

correspondant à une valeur d’adresse
courante de PC (Counter Program). Pour cela,
satisfaction des besoins. nous avons besoin d’une mémoire de
programme de type ROM

Etape 2 : faire la mise à jour de la valeur

d’adresse PC afin de préparer l’instruction
suivante une fois l’instruction courante vient
d’être achévée.la mise à jour se fait par une
incrémentation de 4 octets de la valeur
d’adresse. Pour cela nous avons besoin d’un
registre à chargement et un additionneur.

Implémentation matérielle de la phase d’exécution d’instruction

(EXECUTE)
Implémentation matérielle de la Phase de décodage d’instruction
(DECOD)
Exécutions d’instructions de type R

Cette étape consiste à envoyer le code

opératoire à l’unité de contrôle ( de bit 26 au
bit 31) afin d’envoyer les signaux de contrôle
au chemin de données ainsi que les numéros
de registres sources et destination pour le cas Prenant l’exemple de l’instruction : add rd,rs,rt, le niveau RTL est donné par : R[rd]<-
des formats R et I afin de lire les contenus des R[rs]+R[rt]
registres sources. Cette lecture est désignée Ainsi, Les deux éléments pour réaliser les instructions de type R comme add sont : le banc de
en niveau RTL par R[rs] et R[rt] registres et L'UAL :
ADD

Mémoire d’instruction

Implémentation matérielle de la phase d’exécution d’instruction
(EXECUTE)
Exécutions d’instructions de type I
1 er exemple : pour l’instruction ORi rt, rs, imm16, le niveau RTL est donné par :
R[rt] <- R[rs] OR ZeroExt[imm16]]
Ainsi, nous avons besoin de plusieurs éléments pour réaliser l’instruction ORI comme add sont : le
banc de registres, L'UAL, registre d’extension par zéro et des multiplexeurs :
Implémentation matérielle de la phase d’exécution d’instruction
(EXECUTE)
Exécutions d’instructions de type I
3 éme exemple : pour l’instruction Sw rt, offset (rs), le niveau RTL est donné
par : Mem[ R[rs] + SignExt[offset16] <- R[rt]]
Implémentation matérielle de la phase d’exécution d’instruction (EXECUTE)
Exécutions d’instructions de type I
2 éme exemple : pour l’instruction Lw rt, offset(rs), le niveau RTL est donné par :
R[rt] <- Mem[R[rs] + SignExt[offset]]
Ainsi, nous avons besoin de plusieurs éléments pour réaliser l’instruction ORI comme add sont : le banc
de registres, L'UAL, mémoire de données, registre d’extension par bit de signe et des multiplexeurs :
Implémentation matérielle de la phase d’exécution d’instruction
(EXECUTE)
Exécutions d’instructions de type I
4 éme exemple : pour l’instruction beq rs, rt, imm16, le niveau RTL est donné par :
Equal <- R[rs] == R[rt] et if (Equal= 1) then PC <- PC + 4 + ( SX(Offset) x 4 )
else PC <- PC + 4
Saut conditionnel (Branch) : Mise à jour PC en cas de saut Implémentation matérielle de la phase d’exécution d’instruction (EXECUTE)

Exécutions d’instructions de type J

Nous intéressons à l’instruction jump, l’instruction j target, le niveau RTL

est donné par : PC ← PC [31-28] II (Target<<2).

Page : 57

Architecture d’un chemin de données Monocycle : Processeur MIPS

monocycle + Mémoires
Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex Banc de Registres
Exemple : ADD rd,rs,rt RTL: R[rd] <= R[rs] ADD R|rt]

Op Regdst 1
jump 0
Branch 0
rs
MemRead 0
rt R[rs]
Aluop Add
R[rt]
rd MemWrite 0
AluSrc 0
RegWrite 0/1
memtoReg 0
Imm16/
offset
Implémentation des instructions Arith et logique Sur Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex SoC monocycle : F-D-Ex
ORI rt,rs,imm16 RTL R[rt]<=R[rs] OR ZEX(imm16)
• Type I : LW rt,imm16(rs) RTL : R[rt] <=M[R[rs]+SignExt(imm16)

Regdst 0
jump 0 Regdst 0
Branch 0 jump 0
MemRead 0 Branch 0
Aluop OR MemRead 1
MemWrite 0 Aluop +
AluSrc 1 MemWrite 0
RegWrite 0/1 AluSrc 1
Memtoreg 0 RegWrite 0/1

Implémentation des instructions Arith et logique Sur Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex SoC monocycle : F-D-Ex
• Type I :
• Type I : instruction SW : M[R[rs]+SignExt(imm16)<=R[rt] instruction Beq rs,rt,imm16 RTL :si R[rs]==R[rt] alors PC=PC+4+SX(imm16)<<2

Regdst 0 Regdst X
jump 0 jump 0
Branch 0 Branch 1
MemRead 0 MemRead 0
Aluop + Aluop sub
MemWrite 1 MemWrite 0
AluSrc 1 AluSrc 0
RegWrite 0 RegWrite 0
 Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex Latences et calcul de Période
• Type J :
j target RTL PC ← PC [31-28] II (IR[25-0]<<2).
• Mémoire : 300ns
• UAL/ADD : 50 ns
• Banc de registres 100 ns
Regdst X
jump 1
• Mux : 2 ns
Branch 0 • Autres blocs négligeables
MemRead 0
• Période minimale T = cumule des Latences de LW
Aluop xxx
MemWrite 0
• Temps d’exécution pour un Processeur MIPS
AluSrc x monocycle :
RegWrite x tex= CPI*T*Nb d’instructions avec CPI=1

Temps d’exécution de chaque instruction

incluant: Fetch-Decod-Execute
instruction Temps d’exécution de chaque instruction

Add rd,rs,rt tx(add)=MI(300)+Mux(2)+BR(100)+Mux(2)+UAL(50)+mux(2)+BR(

100) = 556ns
Ori rt,rs,imm16 tx(ORI)=MI(300)+Mux(2)+BR(100)+Mux(2)+UAL(50)+mux(2)+BR(
100) = 556ns
LW rt,imm16(rs) tx=T = MI(300)+Mux(2)+BR(100)+Mux(2)+UAL(50)
MD(300)+mux(2)+BR(100) = 856ns
SW rt,imm16(rs) tx(SW)=MI(300)+Mux(2)+BR(100)+Mux(2)+UAL(50)+MD(300) =
754ns
Beq rs,rt,imm16 tx(Beq)=MI(300)+BR(100)+Mux(2)+UAL(50)+mux(2)+mux(2)=
456ns
J target tx(j)=MI(300)+Mux(2)+BR(100)+Mux(2)+mux(2)+mux(2)= 408ns

Période de horloge = 856 ns

Temps d’exécution d’un programme formé de 100

instructions =.CPI*N*T= 1*100*856 = 85600ns