Vous êtes sur la page 1sur 28

Chapitre 5 : Conception mono_cycle

Ou somme nous jusqu’à maintenant?

• Les cinq composants classiques d’un ordinateur.


Processeur
Entrées
Contrôle
Mémoire

Ch. Données Sorties

• Objectif: Conception (chemin de données +contrôle) d’un


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

Page : 1
Comment concevoir un processeur (étape par étape)?

1. Analyse de l’ensemble d’instructions pour fixer les besoins en


Chemin de données:
L’objet de chaque instruction est donnée en fonction des
transferts de registres.
Le chemin de données inclut les éléments mémoires .
Le chemin de données doit permettre le transfert des registres.
2. Choix d’un ensemble de composantes nécessaires pour le chemin de
données et établissement de la méthodologie horloge.
3. Assemblage des différentes composantes pour la satisfaction des
besoins.
4. Analyse de l’implémentation de chaque instruction pour déterminer
les points de contrôles nécessaires pour effectuer le transfert des
registres.
5. Assemblage de la logique de contrôle.
Page : 2
Les formats d’instructions MIPS (Rappel)
• Tous les instructions MIPS possède 32 bits. Les trois formats d’ instruction sont :
31 26 21 16 11 6 0
– R-type op rs rt rd decval funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
31 26 21 16 0
– I-type op rs rt immediate
6 bits 5 bits 5 bits 16 bits
31 26 0
– J-type
op target address
6 bits 26 bits
• Les différents champs sont :
– op: Code opération de l’instruction
– rs, rt, rd: Les numéros de registres sources et destination.
– Decval: Valeur de décalage.
– funct: Choix de différentes opérations pour un même code op.
– address / immediate: Adresse ou valeur immédiate
– target address: Adresse de l’instruction de saut.

Page : 3
Étape 1: Un sous ensemble d’instructions MIPS

31 26 21 16 11 6 0
• ADD and SUB
op rs rt rd decval funct
– addU rd, rs, rt 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
– subU rd, rs, rt
• OR Immediate: 31 26 21 16 0
op rs rt immediate
– ori rt, rs, imm16
6 bits 5 bits 5 bits 16 bits
• LOAD et STORE 31 26 21 16 0
– lw rt, rs, imm16 op rs rt immediate
– sw rt, rs, imm16 6 bits 5 bits 5 bits 16 bits
• BRANCH: 31 26 21 16 0
– beq rs, rt, imm16 op rs rt immediate
6 bits 5 bits 5 bits 16 bits

Page : 4
Transfert logique des registres

Toute les instructions commencent par la recherche(Fetch inst.).

op | rs | rt | rd | decval | funct = MEM[ PC ]


op | rs | rt | Imm16 = MEM[ PC ]

Inst. Transfert des registres


ADDU R[rd] <– R[rs] + R[rt]; PC <– PC + 4
SUBU R[rd] <– R[rs] – R[rt]; PC <– PC + 4
ORi R[rt] <– R[rs] + zero_ext(Imm16); PC <– PC + 4
LOAD R[rt] <– MEM[ R[rs] + sign_ext(Imm16)]; PC <– PC + 4
STORE MEM[ R[rs] + sign_ext(Imm16) ] <– R[rt]; PC <– PC + 4

BEQ if ( R[rs] == R[rt] ) then PC <– PC +4+sign_ext(Imm16)] | 00


else PC <– PC + 4

Page : 5
Étape 1:Les besoins pour le transfert des registres
• Mémoire :
– instructions & données
• Registres (32 x 32)
– Lire RS
– Lire RT
– Écrire RT or RD
• PC
• Étendre signe
• Add et Sub registre or du champs immédiate étendu
• Add 4 pour PC

Page : 6
Étape 2:Composants du chemin de données
CarryIn
•Adder A
32

Adder
Somme
32
B Carry
32

Selec Éléments logique


t combinatoire (blocks de base)
•MUX A
32
MUX

Y
32
B
32
O
P
A
32
•UAL
ALU

Résultat
32
B
32
Page : 7
Éléments mémoires : Registre, banc de registre
• Registre
– Similaire à un bistable D sauf que: Write Enable

• N-bit entrées et sorties Data In Data Out


• Entrée de validation d’écriture N N
– Write Enable (écriture validée)
• (0): La sortie (Data Out) ne peut être Clk
changée.
• (1): La sortie peut devenir celle de
l’entrée (Data In).
RW RA RB
•Banc de registre Write Enable 5 5 5
busA
RA or RB valide => busA or busW 32
busB valide après « temps 32 32-bit
d’accès » 32 Registres busB
Clk
32
Page : 8
Élément mémoire: Mémoire idéale

Write Enable Address


• Mémoire (idéale)
– Un seul bus d’entrées : Data In Data In DataOut
– Un seul bus de sortie : Data Out 32 32
• Le mot mémoire est sélectionner par : Clk
– L’adresse qui choisie la sortie sur Data Out.
– Write Enable = 1: adresse sélectionne le mot mémoire ou l’entrée
Data In sera écrite.
• Clock input (CLK)
– CLK pour la synchronisation de l’écriture(fixer le moment
d’écriture) .
– Durant l’opération de lecture, La mémoire fonctionne comme un
block logique combinatoire.
• Adresse valide => Data Out valide après « temps d’accès ».

Page : 9
3a: Rappel sur la recherche (Fetch) d’une instruction

• Pour toutes les opérations RTL.


– Décodage de l’instruction : Mem[PC]
– Maître à jour le PC:
• Code séquentielle: PC <- PC + 4
• Branch et Jump: PC <- « autre chose »

Clk PC

Adresse
Logique suivante

Adresse
Instruction (mot)
Mémoire
d’instructions 32

Chemin de données Mono-Cycle Based on UCB Page : 10


3b: Addition et soustraction
• R[rd] <- R[rs] op R[rt] Exemple: addU rd, rs, rt
– Ra, Rb, et Rw s’obtiennent des champs rs, rt, et rd.
– ALUctr et RegWr: logique de contrôle après le décodage de
l’instruction
31 26 21 16 11 6 0
op rs rt rd decval funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
Rd Rs Rt
RegWr 5 ALUctr
5 5
busA
Rw Ra Rb
busW 32

ALU
32 32-bit Result
32 Registers 32
Clk busB
32

Page : 11
Temps op. Registre-Registre
Clk
Temps propagation du PC
PC Anc. val Nouv. valeur
Temps d’accès dans la mémoire d’instructions
Rs, Rt, Rd, Anc. Val. Nouvelle valeur
Op, Func
Délai logique de contrôle
ALUctr Anc. Val. Nouvelle valeur

RegWr Anc. Val. Nouvelle valeur


Temps d’accès registres
busA, B Anc. Val. Nouvelle valeur
Délai ALU
busW Anc. Val. Nouvelle valeur

Rd Rs Rt
RegWr 5 5 ALUctr Écriture Registre
5
Se fait ici
busA
Rw Ra Rb
busW 32

ALU
32 32-bit Result
32 Registres 32
Clk busB
32

Page : 12
3c: Opérations logiques avec val. immédiate
• R[rt] <- R[rs] op ZeroExt[imm16] ]
31 26 21 16 11 0
op rs rt immediate
6 bits 5 bits 5 bits rd? 16 bits
31 16 15 0
0000000000000000 immediate
16 bits 16 bits
Rd Rt
RegDst
Mux
Rs
RegWr 5 ALUctr
5 5
busA
Rw Ra Rb
busW 32 Résultat
32 32-bit

ALU
32 Registers 32
Clk busB Mux
32
ZeroExt

imm16
16 32
ALUSrc

Page : 13
3d: Opération de chargement

• R[rt] <- Mem[R[rs] + SignExt[imm16]] Exemple: lw rt, rs, imm16


31 26 21 16 11 0
op rs rt immediate
6 bits 5 bits 5 bits rd 16 bits
Rd Rt
RegDst
Mux
Rs
RegWr 5 ALUctr
5 5
busA W_Src
Rw Ra Rb
busW 32

ALU
32 32-bit
32 Registres 32
Clk busB MemWr

Mux
Mux

32
WrEn Adr
Extender

Data In 32
imm16 32 Mémoire
16 32 données
Clk
ALUSrc

ExtOp
Page : 14
3e: Opération de rangement
• Mem[ R[rs] + SignExt[imm16] <- R[rt] ] Exemple: sw rt, rs, imm16
31 26 21 16 0
op rs rt immediate
6 bits 5 bits 5 bits 16 bits
Rd Rt ALUctr MemWr W_Src
RegDst
Mux
Rs Rt
RegWr 5 5 5
busA
Rw Ra Rb
busW 32

ALU
32 32-bit
32 Registres 32
Clk busB

Mux
Mux

32
WrEn Adr
Extender

Data In 32 32
imm16 Mémoire
32
16 données
Clk

ExtOp ALUSrc

Page : 15
3f: Saut conditionnel (Branch)
31 26 21 16 0
op rs rt immediate
6 bits 5 bits 5 bits 16 bits

• beq rs, rt, imm16

– mem[PC] Chercher l’instruction de la mémoire

– Equal <- R[rs] == R[rt] Calculer la condition du saut.

– if (COND eq 0) Calculer l’adresse de la prochaine instruction


• PC <- PC + 4 + ( SignExt(imm16) x 4 )
– else
• PC <- PC + 4

Page : 16
3f: Saut conditionnel (Branch)
• beq rs, rt, imm16 Chemin de données génère le siganl equal
31 26 21 16 0
op rs rt immediate
6 bits 5 bits 5 bits 16 bits
Adresse Inst. equal

nPC_sel Rs Rt
4 RegWr 5 5 5
Adder

32 busA
Rw Ra Rb
busW

Égale?
32 32-bit 32
Mux

Registres
PC

Clk busB
00

32
Adder
PC Ext

imm16
Clk

Page : 17
Assemblage : Chemin de données mono-cycle
Instruction<31:0>

<21:25>

<16:20>

<11:15>
Mémoire

<0:15>
Inst.
Adr
Rs Rt Rd Imm16

nPC_sel RegDst ALUctr MemWr MemtoReg


Equal
Rd Rt
1 0
Rs Rt
4 RegWr 5 5 5
Adder

busA
busW Rw Ra Rb =
32

ALU
32 32-bit
Mux

32 Registres busB 32 0
PC

Mux
Mux
32
00

Adder

Clk 32 WrEn Adr


Extender

1
PC Ext

Clk 1 Data In
imm16 32 Mémoire
imm16

16 données
Clk

ExtOp ALUSrc
Page : 18
Vue simplifiée du chemin critique
• Banc de registres et mémoire idéalisée:
– Le signal CLK est important seulement durant l’opération d’écriture.
– Durant la lecture, même comportement qu’un circuit combinatoire:
• Adresse valide => Sortie valide après le « temps d’accès »
Chemin critique (Load) =
Temps propagation PC +
Mémoire Temps d’accès mémoire instructions +
Instruction Temps d’accès banc de registre +
Instruction
idéale Temps ALU pour addition 32 bits +
Rd Rs Rt Imm Temps d’accès mémoires de données+
5 5 5 16 Temps établissement banc de registre
Instruction
Address
A Data
32
Next Address

Rw Ra Rb Address
32 32 Mémoire

ALU
32 32-bit
PC

données
Registres Data idéale
B
In
Clk Clk
32
Clk

Page : 19
Temps op. Registre-Registre
Clk
Temps propagation du PC
PC Anc. val Nouv. valeur
Temps d’accès dans la mémoire d’instructions
Rs, Rt, Rd, Anc. Val. Nouvelle valeur
Op, Func
Délai logique de contrôle
ALUctr Anc. Val. Nouvelle valeur

RegWr Anc. Val. Nouvelle valeur


Temps d’accès registres
busA, B Anc. Val. Nouvelle valeur
Délai ALU

Address Valeur Anc. Nouv. Valeur


Temps Accés mémoire
busW Valeur Anc. Nouv. Valeur

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 20


Étape 4: Chemin de données et RTL -> Contrôle

Instruction<31:0>

<0:5>

<21:25>

<16:20>

<11:15>
Mémoire

<26:31>

<0:15>
instruction
Adr
Op Fun Rt Rs Rd Imm16

Contrôle

nPC_selRegWr RegDst ExtOp ALUSrc ALUctr MemWr MemtoReg Equal

Chemin de données

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 21


Signification des signaux de contrôle
• nPC_sel: 0 => PC <– PC + 4; 1 => PC <– PC + 4 +
SignExt(Im16) | 00
Mémoire
instruction
Adr
nPC_sel

4
Adder

Mux

PC
00

Adder
PC Ext
imm16

Clk

Page : 22
Signification des signaux de contrôle
• ExtOp: “zéro”, “signe” ° MemWr: Écrire mémoire
• ALUsrc: 0 => regB; 1 => immed ° MemtoReg: 1 => Mem
• ALUctr: “add”, “sub”, “or” ° RegDst: 0 => “rt”; 1 => “rd”
° RegWr: Écrire registre destination
RegDst ALUctr MemWr MemtoReg
Equal
Rd Rt
1 0
Rs Rt
RegWr 5 5 5
busA
Rw Ra Rb =
busW
32

ALU
32 32-bit
32 Registers busB 32 0
0

Mux
32 Mux
Clk 32 WrEn Adr
Extender

1
1 Data In
imm16 32 Data
16 Memory
Clk

ExtOp ALUSrc

Page : 23
Signaux de contrôle

inst Register Transfer


ADD R[rd] <– R[rs] + R[rt]; PC <– PC + 4
ALUsrc = RegB, ALUctr = “add”, RegDst = rd, RegWr, nPC_sel = “+4”
SUB R[rd] <– R[rs] – R[rt]; PC <– PC + 4
ALUsrc = RegB, ALUctr = “sub”, RegDst = rd, RegWr, nPC_sel = “+4”
ORi R[rt] <– R[rs] + zero_ext(Imm16); PC <– PC + 4
ALUsrc = Im, Extop = “Z”, ALUctr = “or”, RegDst = rt, RegWr, nPC_sel = “+4”
LOAD R[rt] <– MEM[ R[rs] + sign_ext(Imm16)]; PC <– PC + 4
ALUsrc = Im, Extop = “Sn”, ALUctr = “add”,
MemtoReg, RegDst = rt, RegWr, nPC_sel = “+4”
STORE MEM[ R[rs] + sign_ext(Imm16)] <– R[rs]; PC <– PC + 4
ALUsrc = Im, Extop = “Sn”, ALUctr = “add”, MemWr, nPC_sel = “+4”
BEQ if ( R[rs] == R[rt] ) then PC <– PC + sign_ext(Imm16)] || 00 else PC <– PC + 4
nPC_sel = EQUAL, ALUctr = “sub”

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 24


Logique pour chaque signal de contrôle

• nPC_sel <= if (OP == BEQ) then EQUAL else 0


• ALUsrc <= if (OP == “000000”) then “regB” else “immed”
• ALUctr <= if (OP == “000000”) then funct
elseif (OP == ORi) then “OR”
elseif (OP == BEQ) then “sub”
else “add”
• ExtOp <= if (OP == ORi) then “zero” else “signe”
• MemWr <= (OP == Store)
• MemtoReg <= (OP == Load)
• RegWr: <= if ((OP == Store) || (OP == BEQ)) then 0 else 1
• RegDst: <= if ((OP == Load) || (OP == ORi)) then 0 else 1

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 25


Exemple: Instruction de chargement (Load)
Instruction<31:0>

<21:25>

<16:20>

<11:15>
Mémoire

<0:15>
instruction
Adr
Rs Rt Rd Imm16

nPC_sel RegDst ALUctr MemWr MemtoReg


rt Rd Rt Equal
add
+4
1 0
Rs Rt
4 RegWr 5 5 5
Adder

busA
0 busW Rw Ra Rb =
00

32

ALU
32 32-bit
Mux

32 Registres busB 32 0
PC

Mux
Mux
32
Adder

1 Clk 32 WrEn Adr


Extender
1
Clk
PC Ext

1 Data In
imm16 32 Mémoire
imm16

16 données
Clk
sign ext
ExtOp ALUSrc
NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 26
Exemple réel d’un chemin de données MIPS

NHA/MMY Chemin de données Mono-Cycle Based on UCB Page : 27


Conclusions
• 5 étapes pour la conception d’un processeur
– 1. Analyse du jeux d’instructions => exigences du chemins de données
– 2. Sélection des composants et établissement de la méthodologie horloge
– 3. Assemblage du chemin de données en vue de satisfaction des exigences
– 4. Analyse de l’implémentation de chaque instruction pour déterminer les
valeurs nécessaires des contrôles.
– 5. Assemblage de la logique de contrôle.
• Contrôle est plus difficile
• MIPS facilite la logique de contrôle
– Mêmes tailles d’instructions
– Registres sources toujours au même endroit dans l’instruction
– Immédiate toujours même place et taille
– Opérations toujours sur registres /immédiate
• Chemin de données mono-cycle => CPI=1, CCT => long
• Partie suivante du cours : implémentation de la logique de contrôle

Page : 28

Vous aimerez peut-être aussi