Chapitre 2: ARCHITECTURE DES JEUX

D’INSTRUCTIONS MIPS (RISC)

Chapitre 2 :MIPS ISA (l’architecture du jeu d’instruction)
 Les opérandes du processeur MIPS
$0 0

$1 Load

…
Processeur
Processeur
$31 Mémoire
Mémoire
MIPS
MIPS
CP

LO Store
HI

Processeur MIPS : ensemble de registres

230 octet mémoire

31 registres 32 bits + $0=0
HI, LO, CP
Banc de registres de processeur MIPS de $0 à $31

µP MIPS
Les opérandes du matériel de l’ordinateur
Big-endian: (haut) de l’octet le plus significatif est l’adresse du mot

Numéro d’octet
0 1 2 3 Motorolla, MIPS, SPARC

Little-endian: (bas) moins significatif est l’adresse du mot

Numéro d’octet
2 1 0
Intel 8086,80386, VAX, Alpha
3

exemple
300 BA FF 300
BA 54 32 FF 54 32
3 2 1 0 32 54
FF BA 303
MSB LSB 303

MIPS 8086
 instructions arithmétiques
Instruction Exemple RTL
add add $1,$2,$3 R[$1] = R[$2] + R[$3]
sous sub $1,$2,$3 R[$1] = R[$2] -R[$3]
add immediate addi $1,$2,100 R[$1] = R[$2] + SigEx(100)
add non signé addu $1,$2,$3 R[$1] = R[$2] + R[$3]
add imm. non sig addiu $1,$2,100 R[$1] = R[$2] + ZeroEx(100)
mul mult $2,$3 Hi, Lo = R[$2] x R[$3]
Mul non signé multu$2,$3 Hi, Lo = R[$2] x R[$3]
div div $2,$3 Lo = R[$2] ÷ R[$3], Lo = quotient
Hi = $2 mod $3 Hi = reste
div non signé divu $2,$3 Lo = R[$2]÷ R[$3],
Hi = $2 mod $3
Move from Hi mfhi $1 R[$1] = Hi
Move from Lo mflo $1 R[$1] = Lo

Add $rd,$rs,$rt Addi $rt,$rs,immediat

5
 Banc de registres : Lecture et exécution
Exemple Add $31,$0,$1

Add $2,$0,$1

SUB $2,$0,$1
+

11111

1
 instructions logiques
Instruction Exemple Signification
and and $1,$2,$3 R[$1] = R[$2] ET R[$3]
or or $1,$2,$3 R[$1] = R[$2] OR R[$3]
xor xor $1,$2,$2 R[$1] = R[$2] XOR R[$2]
nor nor $1,$2,$3 R[$1] = R[$2] NOR R[$3]
and immediat andi $1,$2,10 R[$1] = R[$2] AND ZeroEx(10)
or immediat ori $1,$2,10 R[$1] = R[$2] OR ZeroEx(10)
xor immediat xori $1, $2,10 R[$1] = R[$2] XOR ZeroEx(10)

or $1,$1,$3 xor $2,$1,$1

and $1,$1,$3

……………………………………………………………………………………………………………………..............

6
 instructions logiques
Instruction Exemple Signification

shift left logical sll $1,$2,10 R[$1] = R[$2] << 10

shift right logical srl $1,$2,10 R[$1] = R[$2] >> 10
shift right arithm. sra $1,$2,10 R[$1] = R[$2] >> 10
shift left logical sllv $1,$2,$3 R[$1] = R[$2] << R[$3]
shift right logical srlv $1,$2, $3 R[$1] = R[$2] >> R[$3]
shift right arithm. srav $1,$2, $3 R[$1] = R[$2] >> R[$3]

sll $1,$1,1 $1=CBh

srl $1,$1,1
Srl $1,$1,4

$1=0Ch

6
 instructions logiques
Instruction Exemple Signification

shift left logical sll $1,$2,10 R[$1] = R[$2] << 10

shift right logical srl $1,$2,10 R[$1] = R[$2] >> 10
shift right arithm. sra $1,$2,10 R[$1] = R[$2] >> 10
shift left logical sllv $1,$2,$3 R[$1] = R[$2] << R[$3]
shift right logical srlv $1,$2, $3 R[$1] = R[$2] >> R[$3]
shift right arithm. srav $1,$2, $3 R[$1] = R[$2] >> R[$3]

sra $1,$1,1

6
 instructions de transfert de données
Instruction RTL
sw $3, 500($4) M[R[$4]+500] <=R[$3] transfert de 4 octets : 32 bits
sh $3, 502($2) M[R[$2]+502] <=R[$3] transfert de 2 octets 16 bits
sb $2, 41($3) M[R[$3]+41] <=R[$2] transfert de 1 octet 8 bits

7
Exemple avec SW
Sw $t1, ($t0) : M[$t0]<=R[$t1]

9
 Exemple avec SH
• sh $t2, ($t0)

10
 Exemple avec SB
sb $t2, ($t0)

11
 instructions de transfert de données
Instruction RTL
lw $1, 30($2) R[$1]<=M[R[$2]+30] transfert de 4 octets : 32 bits
lh $1, 40($3) R[$1]<=M[R[$3]+30] transfert de 2 octets : 16 bits
lhu $1, 40($3) R[$1]<=M[R[$3]+30] transfert de 2 non signés: 16 bits
lb $1, 40($3) R[$1]<=M[R[$3]+40] transfert de 1octet : 8 bits
lbu $1, 40($3) R[$1]<=M[R[$3]+40] transfert de 1octet non signé : 8 bits
lui $1, 3F40 Load Upper Immediate (16 bits shifted left par 16)

LUI $1, 3F40

$1 3F40 0000 … 0000

7
 Exemple avec LW
• lw $t1, ($t2) ; R[$t1]<=M[R[$t2]]

12
 Exemple avec LH
• lh $t1, 4($t3)

15
 Exemple avec LHU
• lhu $t1, 4($t3)

14
Exemple avec LB
• lb $t1, 4($t3)

13
 Exemple avec LBU
• lbu $t1, 4($t3) ; R[$t1]<=M[R[$t3]+4] transfert
De 1 bit non signé, cases vides seront remplies par
0

13
 Comparaison et branchement
Instruction Exemple Signification
branch on equal beq rs,rt,100 Si (R[rs]== R[rt]) go to CP+4+SX(100)<<2
branch on not eq. bne $1,$2,100 Si ($1!= $2) go to PC+4+SX(100)<<2

jump j 10000 go to 10000 saut à une adresse

jump and link jal 10000 $31 = PC + 4; go to 10000
appel de procédure

Étiquettes = adresses de saut

15
La représentation des instructions
Instruction de type R

31-26 25-21 20-16 15-11 10-6 5-0

0 rs rt rd decval fonct
La représentation des instructions
Instruction de type I

31-26 25-21 20-16 15-0

Code Op rs rt Signe Offset
6 bits 5 bits 5 bits 16 bits
 La représentation des instructions
Instruction de type J

31-26 25 0
Code Op Target=adresse
 EX 1 : ecriture RTL
• 2/ Donner écriture RTL pour la suite des
instructions

• SUB $1,$2,$3 : R[$1]<=R[$2]-R[$3]

• ORI $1,$2,10 : ……………………………………………….
• SRL $1,$2,10 :……………………………………………….
• LH $1, 40($3) :…………………..............................
 EX2 :
Soit l’exemple suivant,
formats d’instructions
add $5,$6,$8 :
Registre désignation est $5
Registre source $6
Registre transfert $8

000000 00110 01000 00101 00000 100000

Compléter :
Sub $11,$23,$2 ;
Registre désignation est $11
Registre source $23
Registre transfert $2

000000 10111 00010 01011 00000 100010

 EX2 :
Soit l’exemple suivant,
formats d’instructions
add $5,$6,$8 :
Registre désignation est $5
Registre source $6
Registre transfert $8

000000 00110 01000 00101 00000 100000

Compléter :
Sub $11,$23,$2 ;
Registre désignation est ……………
Registre source …………..
Registre transfert ……………………;

000000 100010
LW $6,300($4) ; Extension de bit de signe 0
100011 00100 00110 0…0100101100

SW $6,200($4) ; 25 21 20 16 15 0
101011 00100 00110 0..0 011001000

LH $23,-200($5) ;
25 21 20 16 15 0
100001 00101 10100 1..1 100111000

LHU $6,-300($8) ; 25 21 20 16 15 0
100101 01000 00110 1..11011010100

SH $9,200($8) ; 25 21 20 16 15 0
101001 01000 01001 0..0 11001000
 Compléter

beq $1,$2,200 Si R[$1]==R[$2] go to PC<=PC+4+SX(200)<<2 else PC<=PC+4

$1 : est registre source Nombre des cases mémoires à

$2 : est registre transfert sauter entre beq et l’instruction
+200 : est un adresse positive destination
PC : Compteur de programme

Donner code binaire des numéros des registres sur 5 bits et adresse sur 16 bits
1 = 00001
2 = 00010
+200 = 0000000011001000

SX : Bit de signe
extension
de bit de
signe
 Compléter

beq $1,$2,200 Si R[$1]==R[$2] go to PC<=PC+4+SX(200)<<2 else PC<=PC+4

$1 : est registre source Nombre des cases mémoires à

$2 : est registre transfert sauter entre beq et l’instruction
+200 : est un adresse positive destination
PC : Compteur de programme

Donner code binaire des numéros des registres sur 5 bits et adresse sur 16 bits
1 = 00001
2 = 00010
+200 = 0000000011001000

SX : Bit de signe
extension
de bit de
signe
 EX3 : implémentation entre BR et UAL
Soit exemple :
Sub $31, $31,$2 :R[$31]<=R[$31]-R[$2]
Type d’instruction : R
Registre source : $31
Registre transfert : $2
Registre destination : $31
Comme exemple précédent, Compléter

OR $2, $1,$2 : ……………………………………………………………..

Registre source : ..................
Registre transfert :..........................;
Registre destination :...............................
Compléter

OR $2, $1,$2 : R[$2]<=R[$1] ORR[$2]

Registre source : $1
Registre transfert :$2
Registre destination :$2
Comme exemple précédent, Compléter

SRLV $1, $2,$31 : R[$1]<=R[$31] >> R[$2]

Registre source : .$2
Registre transfert :$31
Registre destination :$1
 Ex 4 : Implémentation de ADD sur µP
Chaque instruction passe par 3 étapes : Fetch-décodage-exécution
a/ Implémenter par couleur étape (Recherche d’instruction / Fetch)
PC <= PC+4
 Ex 4 : Implémentation de ADD sur µP
Solution : Implémentation de l’étape (Recherche d’instruction / Fetch)
PC <= PC+4
 Ex 4 : Implémentation de ADD sur µP

b/ Implémenter par couleur étape (Décodage) Lecture de R[rs] et R[t]

 Ex 4 : Implémentation de ADD sur µP
Solution : Implémentation de l’étape (Décodage) Lecture de R[rs] et R[t]
Ex 4 : Implémentation de ADD sur µP
C/ Implémenter par couleur étape (exécution) de add : R[rd]<=R[rs]+R[rt]
 Ex 4 : Implémentation de ADD sur µP
Solution : Implémentation de l’étape (exécution) de add : R[rd]<=R[rs]+R[rt]
Chapitre 3: CONCEPTION DE PROCESSEUR
MIPS MONOCYCLE
 Chapitre 3 : Conception de processeur MIPS mono_cycle
Les cinq composants classiques d’un Calculateur

Contrôle Entrées

Mémoire
Chemin de Sorties
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)?

• 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
$1,$2,$3)
• Le chemin de données doit permettre le transfert des informations entre les
registres.
• Le chemin de données inclut la mémoires programme.
• 2. Choix d’un ensemble de composants nécessaires (UAL MUX, Banc de
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
Fonctionnalité du chemin de
données
Type I

Type R

Type I
Type J
Type I

Page : 44
 Etape 1
• Choix d’un ensemble de composants
nécessaires (UAL MUX, Banc de Registre…)
pour le chemin de données et établissement
de la méthodologie horloge.
 Composants du chemin de données

• 1/2Adder A 32

Adder
Somme
32
B
32

Select Éléments logique combinatoire

(blocks de base)
• MUX A
32
MUX
Y
32
B
32

OP

A
• UAL 32
ALU

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

• N-bit entrées et N-bit 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
Write Enable
•Banc de registre 5 5 5
busA
RA or RB valide => busA or busB busW 32
valide après « temps d’accès » 32 32-bit
32 Registres
Clk busB
32: 47
Page
 É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 Entrée est un facteur utilisée seulement dans le cas 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 : 48
 Etape 2

Assemblage des différents

composants pour la
satisfaction des besoins.
 Implémentation matérielle de la Phase de recherche d’instruction (FETCH)

Au moment du front de l’horloge, cette phase

passe par deux étapes :
Etape 1 : lire le format d’instruction logée
dans la mémoire de programme
correspondant à une valeur d’adresse
courante de PC (Counter Program). Pour cela,
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 de décodage d’instruction (DECOD)

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
des formats R et I afin de lire les contenus des
registres sources. Cette lecture est désignée
en niveau RTL par R[rs] et R[rt]

Mémoire d’instruction
 Implémentation matérielle de la phase d’exécution d’instruction (EXECUTE)

Exécutions d’instructions de type R

Prenant l’exemple de l’instruction : add rd,rs,rt, le niveau RTL est donné par : R[rd]<-R[rs]
+R[rt]
Ainsi, Les deux éléments pour réaliser les instructions de type R comme add sont : le banc de
registres et L'UAL :
ADD
 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

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

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

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

Page : 57
 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).
Architecture d’un chemin de données Monocycle : Processeur MIPS monocycle +
Mémoires

Op

rs
rt R[rs]

R[rt]
rd

Imm16/
offset
 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]

Regdst 1
jump 0
Branch X
MemRead 0
Aluop Add
MemWrite 0
AluSrc 0
RegWrite 0/1
memtoReg 0
Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex
ORI rt,rs,imm16 RTL R[rt]<=R[rs] OR ZEX(imm16)

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

Memtoreg 0
Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex

• Type I : LW rt,imm16(rs) RTL : R[rt] <=M[R[rs]+SignExt(imm16)

Regdst 0
jump 0
Branch X
MemRead 1
Aluop +
MemWrite 0
AluSrc 1
RegWrite 0/1
Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex

• Type I : instruction SW : M[R[rs]+SignExt(imm16)<=R[rt]

Regdst 0
jump 0
Branch X
MemRead 0
Aluop +
MemWrite 1
AluSrc 1
RegWrite 0
 Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex
• Type I :
instruction Beq rs,rt,imm16 RTL :si R[rs]==R[rt] alors PC=PC+4+SX(imm16)<<2

Regdst X
jump 0
Branch 1
MemRead 0
Aluop sub
MemWrite 0
AluSrc 0
RegWrite 0
 Implémentation des instructions Arith et logique Sur
SoC monocycle : F-D-Ex
• Type J :
j target RTL PC ← PC [31-28] II (IR[25-0]<<2).

Regdst X
jump 1
Branch X
MemRead 0
Aluop xxx
MemWrite 0
AluSrc x
RegWrite x
 Latences et calcul de Période
• Mémoire : 300ns
• UAL/ADD : 50 ns
• Banc de registres 100 ns
• Mux : 2 ns
• Autres blocs négligeables
• Période minimale T = cumule des Latences de LW
• Temps d’exécution pour un Processeur MIPS
monocycle :
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)+UAL(50)+mux(2)+mux(2)
= 458ns

Période de horloge = 856 ns

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

instructions =.CPI*N*T= 1*100*856 = 85600ns
EX :SoC à base de Processeur Mono cycle Dual Core

EX

Soit le chemin de données monocycle d’un microprocesseur donné comme suit

Ce chemin de données implémente les instructions suivantes :
Instruction RTL
lw_add rd, (rs), rt R[rd] = Memory[R[rs]] + R[rt];
addi_st (rs), rs, imm Memory[R[rs]] = R[rs] + imm;
sll_add rd, rs, rt, imm R[rd] = (R[rs] << imm) + R[rt];
1- Donner le nom de chaque bloc dans le chemin ci-dessus
Bloc 1 : Mémoire I Bloc 2 : Additionneur Bloc 3 : Banc de registres
Bloc 4 : Mémoire D Bloc 5 :Mux à 2 E Bloc 6 : ALU
Q : Implémenter lw_add rd, (rs), rt
R[rd] = Memory[R[rs]] + R[rt];
R : Implémentation de lw_add rd, (rs), rt
Q : Implémenter addi_st (rs), rs, imm
Memory[R[rs]] = R[rs] + imm;
R : Implémentation de
addi_st (rs), rs, imm
 Q : Implémenter
sll_add rd, rs, rt, imm
R : Implémentation de
sll_add rd, rs, rt, imm
Q: Sachant les temps de latences (durée nécessaire à l’exécution)
des unités fonctionnelles suivantes, calculer le temps minimal
requis pour exécuter chacune des instructions. Expliquez.

Unité fonctionnelle Latence

Mémoire 3 ns
ALU 4 ns
Banc de registres 2 ns
Reste négligeable

Inst Temps Explication

Lw_add

Addi_st
Sll_add

Q : Donnez la valeur de CPI et Ie temps approximatif du cycle

de l’horloge.
 Réponse

Unité fonctionnelle Latence

Mémoire 3 ns
ALU 4 ns
Banc de registres 2 ns
Reste négligeable

Inst Temps Explication

Lw_add 14 ns MI(3)+ BR(2)+ MD(3)+ UAL(4)+ BR(2)
Addi_st 12 ns MI(3)+ BR(2)+ UAL(4)+ MD(3)
Sll_add 15 ns MI(3)+ BR(2)+ UAL(4)+ UAL(4)+ BR(2)

CPI = 1
T = 15ns
Q: Pour chacune des instructions suivantes, spécifier les valeurs des
signaux de contrôle. La valeur de ALUOp peut être ADD, SUB, SLL,
PASS_A ou PASS_B (PASS_X veut dire qu’on passe la valeur de
l’opérande X sans changement).
Réponse
 Etape 4

Assemblage de la logique de
contrôle. (séquenceur)
Chemin de données Mono-cycle réduit
Conception de l’unité de contrôle mono-cycle
Les signaux de contrôle
Les signaux de contrôle
Les signaux de contrôle
Les signaux de contrôle
Les signaux de contrôle
Les signaux de contrôle
Les signaux de contrôle
Les signaux de contrôle
Table de vérité de Contrôle principal
op 00 0000 00 1101 10 0011 10 1011 00 0100 00 0010
R-type ori lw sw beq jump
RegDst
ALUSrc
MemtoReg
RegWr
MemWr
MemRd
Branch
Jump
ALUop (Symbolic) “R-type” Or Add Add Sub
ALUop <2> 1 0 0 0 0 X
ALUop <1> X 1 0 0 0 X
ALUop <0> X 0 0 0 1 X
 Exemple: Table de vérité pour RegWr
op 00 0000 00 1101 10 0011 10 1011 00 0100 00 0010
R-type ori lw sw beq jump
RegWr 1 1 1 0 0 0

• RegWr = R-type + ori + lw

=op<5> & op<4> & op<3> & op<2> & op<1> & op<0> (R-type)
+ op<5> & op<4> & op<3> & op<2> & op<1> & op<0> (ori)
+ op<5> & op<4> & op<3> & op<2> & op<1> & op<0> (lw)

op<5> .. op<5> .. op<5> .. op<5> .. op<5> .. op<5> ..

<0> <0> <0> <0> <0> op<0>

R-type ori lw sw beq jump

RegWr
 Implémentation RLP
op<5> .. op<5> .. op<5> .. op<5> .. op<5> .. op<5> ..
<0> <0> <0> <0> <0> op<0>

R-type ori lw sw beq jump

RegWr

ALUSrc
RegDst
MemtoReg
MemWr
nPCsel
Jump
ExtOp
ALUop<2>
ALUop<1>
ALUop<0>
 Inconvénients du processeur mono-cycle
• Cycle horloge Long:
– Cycle doit être suffisant pour Instruction de chargement :
Temps propagation PC +
Temps Accès Mémoire +
Temps Accès Banc registres +
Délai ALU (calcul adresse données) +
Temps accès mémoire (chargement données) +
Temps établissement Banc registres (écriture données)
• Longueur cycle horloge pour chargement DEPASSE DE LOINS
les nécessités des autres instructions
 Conclusions
° Chemin données mono-cycle => CPI=1, CCT => long

° 5 étapes pour conception de processeur

• 1. Analyse jeux instructions => Exigences chemin données
• 2. Sélection des composants & établissement méthodologie horloge
• 3. Assemblage du chemin données pour réalisation des exigences
• 4. Analyse de l implémentation de chaque instruction pour déterminer les
valeurs nécessaires des contrôles
• 5. Assemblage du logique de contrôle

° Contrôle est le plus difficile Processeur

Entrées
° MIPS facilite logique de contrôle Contrôle
• Instructions même taille Mémoire
• Source registres toujours même place dans instruction
Chem. D. Sorties
• Immédiate toujours mémé place et taille
• Opérations toujours sur registres/immédiate
Chapitre 4: CONCEPTION DE PROCESSEUR
MIPS MULTICYCLE
 Chapitre 4: Conception d ’un processeur Multi-Cycle
Introduction: Vue Simplifiée du processeur Mono-Cycle

97
 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

nouvelle architecture qui a un cycle de base plus court
et qui requièrent plusieurs cycles d’horloge par
instruction. Cette technique est appelée multicycle.
98
Longueur requise par chaque type d’instruction po
Monocycle
• 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

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

10
25

30
Inactivité
35
40 Cycle
Cycled’horloge
d’horloge

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

10
25

30
35
40

L’idée
L’idée::découpage
découpageen
encycle
cycleélémentaire
élémentaire
101
 Mise en oeuvre multicycle
• Nous allons éviter la perte :
– Au niveau de temps
– Au niveau 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. 102
 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.
103
Multicycle Datapath

104
 Instruction Execution
Action Register Transfers RTL

IR ← Memory[PC]
1 Fetch
PC ← PC + 4

A ← Reg[Rs] B ← Reg[Rt]
2 Decode

Beq &
R-Type ORI LW SW Jump
cond

PC = PC +
ALUOut
3 Execute ALUOut= A op =A+zero- ALUOut = A+sign- ALUOut= A+sign-
sign-
PC = PC [31-
28] II
extend(IR[
B extend(IR[15- extend(IR[15-0]) extend(IR[15-0]) (IR[25-
0]) 15-0]) <<
0]<<2)
2

Write
R [Rd] ← MDR ← Memory[ALUout] ←
memory/
4 Banc
ALUout R[Rt]←ALUout Memory[ALUout] B
registre

Charge
ment R[Rt] ←
5 dans le MDR
BancRe
g

10
5
 Recherche d’instruction
IR = Memory[PC];
PC = PC + 4;

106
 Décodage d’Instruction
A = Reg[IR[25-21]]; (A = Reg[rs])
B = Reg[IR[20-15]]; (B = Reg[rt])

107
Instruction Type -R : ADD
Execution :ALUOut = A op B

108
 Instruction Type -R : ADD
Ecriture dnas le BancReg : R [Rd] ← ALUout

109
 Instruction Type -I : ORI
Exécution: ALUOut = A + zero-extend(IR[15-0])

110
Instruction Type -I : ORI
Ecriture dans le BancReg: R [Rt] ← ALUout

111
 Instruction Type -I : Lw
Exécution : ALUOut = A + sign-extend(IR[15-0])

112
 Instruction Type -I : Lw
Accès à la memoire: MDR ← Memory[ALUout]

113
Instruction Type -I : Lw
Ecriture dans le le BancReg: R[Rt] ← MDR

114
 Instruction Type-I : Sw
Exécution: ALUOut = A + sign-extend(IR[15-0])

115
Instruction Type-I : Sw
Acces à la Memoire: Memory[ALUout] ← B

116
 Instruction Saut Conditionnel : Beq
BEQ: if (A == B) PC = PC + sign-extend(IR[15-0]) << 2

117
Instruction Saut Non Conditionnel :Jump
JUMP: PC = PC [31-28] II (IR[25-0]<<2)

118
 Modèle de contrôle

PCWriteCond PCSource
PCWrite
ALUOp
IorD Outputs
ALUSrcB
MemRead
Control ALUSrcA
MemWrite
RegWrite
MemtoReg
Op RegDst
IRWrite [5– 0]
0
M
Jump 1 u
Instruction [25– 0] 26 28 address [31-0] x
Shift
2
left 2
Instruction
[31-26] PC [31-28]
PC 0 0
M Instruction Read
[25– 21] register 1 M
u Address u
x Read x
Instruction Read A Zero
1 Memory
[20– 16] register 2 data 1 1
MemData 0 ALU ALU ALUOut
Registers
Instruction M Write Read result
[15– 0] register data 2 B
Instruction u 0
Write Instruction [15– 11] x 4 1 M
data Write
register 1 data u
2 x
Instruction 0 3
[15– 0] M
u
x
Memory 1
data 16 32 ALU
Sign Shift
register control
extend left 2

Instruction [5– 0]

119
Modèle de contrôle:
implémentation
 Modèle de 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

121
 Conception du Contrôleur
• Les diagrammes du contrôle obtenu sont simple et structurées
• Utilisation de structure simple pour construction de “micro-séquenceur”
• Implémentation de la logique de contrôle: programmation
– microprogrammation

Contrôle Contrôle Chem. Donn.

Séquenceur

microinstruction

micro-PC
sequenceur
Spécification détaillée du contrôle: Machine Traditionnel
Op5 PCWrite
Op4 PCWriteCond
Op3
IorD
Op2 MemRead
Op1
MemWrite
Op0
IRWrite
S3
Control logic
S2
MemtoReg
S1 PCSource
S0 ALUOp
Outputs
PCWrite ALUSrcB
PCWriteCond
IorD
MemRead
ALUSrcA
MemWrite
IRWrite RegWrite
MemtoReg
PCSource1
PCSource0
RegDst
ALUOp1
ALUOp0
ALUSrcB1 NS3
ALUSrcB0
ALUSrcA NS2
RegWrite
RegDst NS1
Inputs NS3
NS0
NS2
NS1
NS0
Op5

Op4

Op3

Op2

Op1

Op0

S3

S2

S1

S0
Instruction register State register
opcode field

125
 Evaluation de Performances

CPI Moyen?
Diagramme des états donne CPI pour chaque instruction
Fréquence d ’utilisation de chaque instruction

Type CPIi Fréquence CPIi x freqIi

Arith/Logic 4 40% 1.6
Chargement 5 30% 1.5
Rangement 4 10% 0.4
Saut Cond. 3 20% 0.6
Moyenne CPI:4.1

126