Vous êtes sur la page 1sur 9

Département des Sciences de l’Informatique Section IE4 Prof. : S.

BEN AHMED

« Architecture Avancée»
TD2 : Etude des aléas du pipeline des processeurs RISC
Probème : Etudes des Aléas du pipeline du processeur MIPS R3000
L’étude concerne un processeur RISC le MIPS R3000. C’est un processeur 32 bits de type Harvard
(séparation entre mémoire instruction et mémoire données). Les registres généraux du MIPS R3000 sont
donnés par la figure 1.
- $i, (0≤ i ≤ 31) : ce sont les registres
d’usage général. Les opérandes des
instructions et leur(s) résultat(s) y sont
placés
- pc (program counter) : ce registre contient l’adresse de
l’instruction à exécuter
Figure 1 : Registres généraux du MIPS
R3000 - ir (instruction register) : ce registre contient l’instruction
en cours d’exécution, il n’est pas directement accessible
- hi et lo : ces registres contiennent le résultat de la
multiplication par 64 bits, ou le résultat de la division
euclidienne (quotient dans lo et reste dans hi).

Un extrait du jeu d’instruction du MIPS R3000 est fourni en Annexe 1.


Question 1 : Soit la séquence d’instruction suivante :
Adresse Instruction
0x00400000 : lui $1, 0xdead
0x00400004 : ori $2, $1, 0xbeef
0x00400008 : add $4,$3, $1
0x0040000C : and $6, $5, $1
0x00400010 : sub $8, $7, $1
Sachant que les valeurs initiales des registres sont : pc = 0x00400000, $3 = 3, $5 = 5, $7 = 7. Donnez la valeur
des registres ($1, $2, $4, $6, $8) après l’exécution de chaque instruction dans le cas du processeur monocycle
en complétant le tableau suivant.
$pc $ir $1 $2 $4 $6 $8
0x00400000 lui $1, 0xdead X X X X
0x00400004 ori $2, $1, 0xbeef X X X
0x00400008 add $4,$3, $1 X X
0x0040000C and $6, $5, $1 X
0x00400010 sub $8, $7, $1

On désire mettre en évidence les problèmes liés à l’existence du pipeline. Le processeur MIPS R3000 possède
un pipeline de 5 étages. On fait l’hypothèse que le pipeline est réalisé uniquement par insertion de registres
(sans les courts-circuits). Par ailleurs, on suppose que le pipeline est vide lors du démarrage.
Structure générale du pipeline :
L’exécution d’une instruction ii se déroule conceptuellement comme décrit ci-dessous :
cycle 1 2 3 4 5 6 7 8 9
instruction
i0 IF DE EXE MEM WB
1
i1 IF DE EXE MEM WB
i2 IF DE EXE MEM WB
i3 IF DE EXE MEM WB
i4 IF DE EXE MEM WB
L’étage IF récupère l’instruction de la mémoire. L’étage DE décode l’instruction et récupère la valeur des
registres opérandes d’entrée. L’étage EXE est utilisé pour le calcul de l’adresse effective des accès mémoire
et pour l’exécution des opérations arithmétiques. L’étage MEM effectue les accès aux données dans la
mémoire. L’étage WB met à jour le registre résultat. La structure du pipeline est donnée par la figure 2.
Question 2 :
On reprend la séquence d’instruction précédente et on l’exécute à présent sur le processeur pipeline dont la
structure est décrite ci-dessus.
Donnez la valeur de chacun des registres au fur et à mesure du déroulement des instructions. En quoi ce
comportement est-il problématique ?

Figure2 : Structure du pipeline du MIPS R3000


Question 3 :
Donnez le déroulement du pipeline pour l’exécution de la séquence d’instructions suivante :
add $3, $2, $1
lw $4, 0($3)
sw $4, 4($3)
En quoi ce comportement est-il problématique ?
Question 4 :
Donnez le déroulement du pipeline pour l’exécution de la séquence d’instruction suivante :
lw $4, 0($3)
ori $5, $4, 0xcafe
andi $6, $4, 0xdod
xori $7, $4, 0xdeca
En quoi ce comportement est-il problématique, notamment vis-à-vis des cas précédents ?
On suppose que le processeur ne possède qu’un accès mémoire, et il exécute la séquence s’instruction
suivante :
lw $4, 0($29)
ori …………
and ………..
sub ………..
xor …………
Question 5 :

2
Identifiez les aléas dus à des conflits de ressources. Comment proposez-vous de le résoudre ? En faisant
l’hypothèse que 40% des instructions font des accès mémoire, donnez la performance de ce processeur par
rapport à un processeur ayant 2 accès.

Annexe 1 : Extrait du jeu d’instruction du MPIS R3000

3
4
5
Correction TD 3

Q1

$pc $ir $1 $2 $4 $6 $8
0X00400000 Lui $1,0Xdead Dead0000 X X X X
0X00400004 Ori $2,$1,0Xbeef Dead0000 deadbeef X X X
0X00400008 Add $4,$3,$1 Dead0003 X X
0X0040000C And $6,$5,$1 00000000 X
0X00400010 Sub $8,$7,$1 Deacfff9

Q2
Aléas de données

Inst 1 2 3 4 5

I1 IF DE EXE MEM WB
Pc<- PC+4=0X004000004 imm<-0Xdead Wd<- 0Xdead0000 ---- $1<-wd=0Xdead0000
IR<- code lui $1,0XDEAD
I2 IF DE EXE MEM
Pc<PC+4=0X004000008 imm<-0Xdead Wd<-$1ori imm=? ----
IR<- code ORI rs<-$1=?
I3 IF DE EXE
Pc<PC+4=0X00400000C rt<-$1=? Wd<-$1add $3=?
IR<- code add rs<-$3=3
I4 IF DE
Pc<PC+4=0X004000010 rt<-$1=0Xdead0000
IR<- code and
rs<-$5=5
I5 IF
Pc<PC+4=0X004000014
IR<- code SUB

Inst 6 7 8 9

I1

I2 WB
$2<-wd=?

I3 MEM WB
---- $4<-wd=?

I4 EXE MEM WB
Wd<-$5add $1=0x00000000 ---- $6<-0x00000000

I5 DE EXE MEM WB
rt<-$1=0Xdead0000 Wd<-$5sub$1=0x00000000 ---- $8<-0xdeacfff9
rs<-$7=5

6
Solutions ajout de NOP
Inst 1 2 3 4 5

I1 IF DE EXE MEM WB
Pc<- PC+4=0X004000004 Rt<-0Xdead Wd<- 0Xdead0000 ---- $1<-wd=0Xdead0000
IR<- code lui $1,0XDEAD
I2 IF NOP NOP DE
Pc<PC+4=0X004000008 Rs<-$1=0Xdead0000
IR<- code ORI Rt<-0Xbeef
I3 IF
Pc<PC+4=0X00400000C
IR<- code add
I4

I5

Inst 6 7 8 9 10

I1

I2 EXE MEM WB
Wd<- 0Xdeadbcef ---- $2<-wd=0Xdeadbcef

I3 DE EXE MEM WB
Rs<-$3=3 Wd<- 0Xdead0003 ---- $4<-wd=0Xdead0003
Rt<-$1=0Xdead0000
I4 IF DE EXE MEM WB
Pc<PC+4=0X004000010 Wd<- 0X00000000 ---- $6<-wd=0X00000000
Rs<-$5=5
IR<- code and
Rt<-$1=0Xdead0000
I5 IF DE EXE MEM
Pc<PC+4=0X004000014 Rs<-$7=7 Wd<- $7-$1 ----
IR<- code sub
Rt<-$1=0Xdead0000

Inst 11

I1

I2

I3

I4

I5 WB
$8<-wd=0Xdeadcfff9

7
Question 3 :

Inst 1 2 3 4 5

I1 IF DE EXE MEM WB
Pc<- PC+4 Rs<-$2 Wd<- $1+$2 ---- $3<-wd
IR<- code add Rt<-$1
I2 IF NOP NOP DE
Pc<PC+4 im<-0
IR<- code Lw Rt<-$3
I3 IF
Pc<PC+4
IR<- code Sw

Inst 6 7 8 9 10 11

I1

I2 EXE MEM WB
Wd<- $3+ext(im) D=M(wd) $4<-D

I3 NOP NOP DE EXE MEM WB


im<-4 Wd<- $3+ext(im) M(wd) <-$4 -----------
Rt<-$3
Rs<-$4

Question 4 : 1-Problème 3-Aléa de données


structurelle (mémoire)

Inst 1 2 3 4 5

I1 IF DE EXE MEM WB
Pc<- PC+4 Rs<-$3 Wd<- $3+Ext(im) D<-M(@wd) $4<- D
IR<- code lw Im<-0
I2 IF DE EXE MEM
Pc<PC+4 im<-0XCAF Wd<- $4 or ext(im) -------------------------
IR<- code ORi Rt<-$4
I3 IF DE EXE
Pc<PC+4 im<-0X d0d Wd<- $4 and ext(im)
IR<- code andi Rs<-$4

I4 IF DE
Pc<PC+4 im<-0X deca
IR<- code xori Rs<-$4

2-Problème
structurelle (lecture et
écriture dans le banc
de registre)

8
Inst 6 7 8

I1

I2 WB
$5<-Wd

I3 MEM WB
------------------------- $6<-Wd

I4 EXE MEM WB
Wd<- $4 xori ext(im) ------------------------- $7<-Wd

Q5
calculons l’accélération du pipeline pour chaque machine en utilisant la formule :
Tempsmoyend ' uneinstruction = CPI idéal + *Tempsdeccyl
Puisqu’il n’y a pas de suspensions, le temps moyen d’une instruction pour la machine ayant 2 accès mémoire est
simplement le temps de cycle idéal. Le temps moyen d’une instruction pour la machine avec aléas structurel est :

Tempsmoyend ' uneinstruction = CPI idéal + *Tempsdeccyle = (1 + .4 *1) * tempsdecycleidéal

La machine sans aléa structurel est de manière évidente plus rapide

Solution :
• Aléa structurel quand 2 ou plusieurs instructions ont besoin de la même ressource
Autres solutions que bloquer les instructions :
– dupliquer la ressource
– diviser le cycle d'horloge
– réordonner les instructions

Vous aimerez peut-être aussi