Ex MCP 2015+corr

Université de la Manouba
École Nationale des Sciences de l’Informatique

Examen « Méthodologie de Conception des Processeurs »
Enseignants : Ch. Jerad, D. Mezghanni, I. Ben Abdessalem, L. Latrach, L. Durée : 2 H
Kriaa, M. K. Bouaffoura Date : 07/01/2016
Documents : Non autorisés Nbr pages : 9
Nom et prénom :…………………………………………… Classe :………………..
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
Note :
Exercice 1 (5.5 pts) :
1. Pour les différentes conceptions de processeur MIPS étudiés, indiquer si chacune des modifications
données va améliorer, détériorer ou est sans effet sur la latence et le débit du processeur.
Latence Débit
Réduction du cycle d’horloge d’un chemin de
Améliore Améliore 0.25
données monocycle
Augmentation du CPI, tout en gardant le cycle
Détériore Détériore 0.5
d’horloge constant
Changer la conception monocycle exécutant à une Sans effet
fréquence X MHz en un pipeline à 5 étages (on accepte améliore car ils peuvent Améliore 0.5
confondre la latence d’une seule
exécutant à X/5 MHz instruction ou tout le programme)
Enlever les renvois au niveau d’un chemin de
Détériore Détériore 0.5
donnée pipeliné
2. Considérons la suite des instructions suivante :
Deb : sub $1, $1, $3

add $3, $1, $5
or $2, $7, $8
bne $1, $4, Fin
and $5, $2, $3
addi $1, $8, 15
j Deb
Fin : ori $1, $2, $3
a) Trouver les aléas dans cette suite pour la machine pipelinée à 5 étages du cours. Donner les solutions
possibles pour ces aléas.
Aléas :
Aléas de données de type 1 entre sub et add sur $1
Aléas de données de type 3 entre sub et bne sur $1 (qui revient à un aléas de structure)
1.5
Possibilité d’aléas de données de type 3 entre add et and sur $3 (qui revient à un aléas de structure)
Possibilité d’aléas de données de type 2 entre or et and sur $2
Aléas de contrôle au niveau des instructions bne et j
1/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
Solutions :
Aléas de données de type 1, 2  renvoie
Aléas de structure résolue par HW
0.75
Aléas de contrôle (bne)  suspension / prédiction / changement de la sémantique d’exécution
/1
b) Calculer le temps d’exécution sur une machine MIPS en pipeline à 5 étages d’un programme
composé de 20 instructions de chargements, 10 instructions de rangements, 50 instructions de
type-R et 10 instructions de branchements.
Un temps de cycle (période) d’horloge est égal à 2,2ns. On considère pour la machine pipelinée les
conditions suivantes :
• Les Aléas de structure sont résolus,
• Les Aléas de contrôle sont résolus par prédiction dynamique (avec 85% des prédictions sont
correctes).
• Le programme ne contient pas d’autres types d’aléas.
Taux de succès =0.85

On a 10 branchements, et si notre prédiction est fausse, on perd 2 cycles, donc le nombre de
cycles perdus : np=10*0.15*2=3 cycles
1
/1.5
Texec= *(Nbre d’étages -1 +Nbre d’instruction) + np+ * T = *5-1+90+3]*2.2ns = 213.4ns
Vous disposez de 2 processeurs RISC à 16 bits, qu’on désigne par X et Z. ces 2 processeurs possèdent
les caractéristiques suivantes. Les 2 processuers sont multi-cycle, càd qu’une instruction est exécuté
dans un nombre variable de cycles. X et Z implémentent des variations du même jeu d’instruction (ISA)
de la manière suivante :
- Le processeur X implémente le jeu d’instructions de base, y compris LUI. De plus, le processeur
X implémente la multiplication en software, càd qu’il n’implémente pas l’instruction MULT.
- Le processeur Z implémente le jeu d’instructions de base et élimine l’instruction LUI en faveur
de l’instruction MULT. La fonctionnalité de LUI est dérivée à partir de LW.
2/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
- L’instruction MULT du processeur Z utilise répétitivement l’UAL dans une boucle, réalise les
décalages et les additions conditionnelles, nécessitant ainsi 80 cycles du processeur par
instruction de multiplication.
- L’exécution d’une instruction MULT sur le processuer Z élimine une moyenne de 30 instructions
qui auraient à s’exécuter dans le processeur X lorsque la multiplication est implémentée en
software. Cependant, le processeur Z nécessite des fonctionnalités additionnelles au niveau de
l’UAL, augmentant ainsi le chemin critique de l’UAL de 10ns à 12 ns
Nous assumons que :
- La latence d’accès mémoire : 10 ns
- La latence d’accès aux registres : 8 ns
- La latence d’exécution de l’UAL : 10ns pour le processeur X et 12 ns pour le processeur Z.
Considérons la distribution suivante des types d’instructions (nous supposons que LUI nécessite 3
cycles)
Processor X Processor Z
MULT 0% 5%
LUI 5% 0%
LW 20% 25%
SW 10% 10%
Type R 45% 40%
BEQ 20% 20%
Remarque importante: par exemple, si le processeur Z exécute 5 instructions MULT parmi 100, pour
chacune de ces instructions, le processeur X exécute 20 instructions additionnelles.
a. Déterminer le nombre de cycles par instructions (si définit) et le CPI moyen de chacun des
processeurs.
Processeur X Processeur Z
MULT -- 80
LUI 3 --
LW 5 5
1
SW 4 4
Type R 4 4
BEQ 3 3
b. Calculez de CPI moyen de chacun des processeurs
3/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
CPI moyen du processeur X

CPIx = (0.05*3)+(0.2*5)+(0.1*4)+(0.45*4)+(0.2*3)=3.95 0.5
CPI moyen du processeur Z

CPIz = (0.05*80)+(0.25*5)+(0.1*4)+(0.4*4)+(0.2*3)=7.85
0.5
c. Admettons que nous partons d’un programme tournant sur le processeur Z. Ce programme est
composé de 100 instructions dont 5% sont des instructions MULT. Déterminez le nombre
d’instructions du programme équivalent tournant sur le processeur X.
Iz : nombre des instructions dans le programme tournant sous Z
Ix : nombre des instructions dans le programme tournant sous X
Si Iz=100,
0.5
Alors Ix= 95 + (5 * 20) = 195
d. Calculer, comparer et conclure sur le temps d’exécution de ce programme sur les deux
processeurs.
Temps exec (x) = 10 ns/c * 3.95 * 195 = 7702,5 ns

Temps exec (z) = 12 ns/c * 7.85 * 100 = 9420 ns
1
Malgé que Z implémente la muliplication en HW, il est plus lent
e. Sachant que la latence originale de l’UAL du processeur Z est de 12ns, quelle devrait être la
rapidité des instructions software équivalents sur le processeur X, afin que le procssseur X soit
aussi rapide que le processeur Z ? en d’autres termes, combien d’instructions devrait exécuter
le processeur X à la place de 1 instruction MULT ?
Ix = 95 + (nbr MULT) * (nbr intsr equivalents )
We first need to find the instruction count of processor X necessary for equal performance.
10ns * 3.95 * Ix = 12ns * 7.85 * 100  Ix = 238.5
1
Nbr des intrs equivalents = ( 238.5‐95 ) / 5= 143.5 / 5 = ~28 instructions
4/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
Considérons le code MIPS suivant :

isDAG: # a0 = trie, a1 = n
I1 li $t0, 0 # t0 = i, a0 = &trie[i]
loop:
I2 beq $t0, $a1, done # while(i != n)
I3 lw $t1, 0($a0) # t1 = trie[i].left
I4 beq $t1, $0, next # if(t1 != 0)
I5 lw $t2, 4($a0) # t2 = trie[i].right
I6 beq $t2, $0, next # if(t2 != 0)
I7 beq $t1, $t2, true # if(t1 == t2) goto true
next:
I8 addi $a0, $a0, 8 # a0 = &trie[i+1]
I9 addi $t0, $t0, 1 # i++
I10 j loop # end-while
done:
I11 li $v0, 0 # answer = false
I12 jr $ra # return
true:
I13 li $v0, 1 # answer = true
I14 jr $ra # return
Cette fonction prend deux arguments: un tableau de noeuds trie et la longueur du tableau n. elle
détermine si le trie est un DAG (Direct Acyclic Grapg, càd quelques nœuds possèdent des champs
droite et gauche à la fois égaux et différents de zéro).
Ce code tourne sur un processeur MIPS pipeliné à 5 étages, sachant que les aléas de structure sont
résolus et que les unités de renvois sont implémentés. Nous supposons que les branchements
conditionnels sont résolus par prédiction et qu’ils sont résolus à l’étage EX.
1. Le corps de la boucle inclut 3 beq (mis à part le beq au début de la boucle). Donnez pour une seule
itération de la boucle le diagramme d’écxécution ainsi que le nombre de cycles nécessaires dans chacun
des cas suivants :
Rmq : laisser la ligne vide si l’instruction n’est pas exécutée.
5/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
Cas 1 : condition vérifiée de beq 1 (instruction I4)

Instruction 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
I1 F D E M W
I2 F D E M W
I3 F D E M W
I4 F D - E M W
I5
I6
0.75
I7
/1
I8 F D E M W
I9 F D E M W
I10 F D E M W
I11
I12
I13
I14
0.25
Nbr de cycles : 10 = (14 – 4 du remplissage)
Cas 2 : condition non vérifiée de beq 1 (instruction I4)

& condition vérifiée de beq 2 (instruction I6)
Instruction 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
I1 F D E M W
I2 F D E M W
I3 F D E M W
I4 F D - E M W
I5 F - D E M W
I6 - F D E M W
0.75
I7
/1
I8 F D E M W
I9 F D E M W
I10 F D E M W
I11
I12
I13
I14
0.25
Nbr de cycles : 12 (16 – 4 )
6/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
Cas 3 : condition non vérifiée de beq 1 (instruction I4) et de beq 2 (instruction I6)
& condition vérifiée de beq 3 (instruction I7)
Instruction 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
I1 F D E M W
I2 F D E M W
I3 F D E M W
I4 F D - E M W
I5 F - D E M W
I6 - F D E M W
0.75
I7 F D E M W
/1
I8
I9
I10
I11
I12
I13 F D E M W
I14 F D E M W
0.25
Nbr de cycles : 12 = 16-4
Cas 4 : condition non vérifiée de beq 1, 2 et 3 (instruction I4, I6 et I7)

Instruction 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
I1 F D E M W
I2 F D E M W
I3 F D E M W
I4 F D - E M W
I5 F - D E M W
I6 - F D E M W
0.75
I7 F D E M W
/1
I8 F D E M W
I9 F D E M W
I10 F D E M W
I11
I12
I13
I14
0.25
Nbr de cycles : 11 = 15-4
7/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
2. Calculez le nombre total de cycles afin d’exécuter la fonction dans son pire cas d’exécution (en fonction
de n le nombre des itérations).
Pire nbr de cycles dans l’itération qui re-mène dans la boucle = (max (cas 1, cas 2, cas 4 ))
= max (9 (10-1), 11 (12-1), 10 (=11-1)) = 11
Et on ajoute +2 dues au jump = 11 + 2 = 13
(le -1 est celui de l’instruction I1 qui ne fait pas partie du corps de la boucle !)
Sortie de la boucle : soit cas 3, soit suite à l’éxécution de I2 (vérifiée) et I11 et I12
0.5
= max (12 - 1 (du I1) + 2 (du surcout de j) et 1+2(i2)+ 2 (i11 et i12) + 2)
= max (13, 7) = 13
Nbr de cycles dans le pire cas = remplissage du pipeline + I1 + [(n-1) * 13] + 13 = 5+13n
3. Sachant ces exécutions, proposez une optimization de ce code.

isDAG: # a0 = trie, a1 = n
li $t0, 0 # t0 = i, a0 = &trie[i]
loop: isDAG:
beq $t0, $a1, done # while(i != n) sll $t0, $a1, 3
lw $t1, 0($a0) # t1 = trie[i].left add $t0, $a0, $t0
beq $t1, $0, next # if(t1 != 0) loop:
lw $t2, 4($a0) # t2 = trie[i].right beq $a0, $t0, done
beq $t2, $0, next # if(t2 != 0) lw $t1, 0($a0)
beq $t1, $t2, true # if(t1 == t2) goto true lw $t2, 4($a0)
next: addi $a0, $a0, 8
2
addi $a0, $a0, 8 # a0 = &trie[i+1] beq $t1, $0, loop
addi $t0, $t0, 1 # i++ beq $t2, $0, loop
j loop # end-while bne $t1, $t2, loop
done: li $v0, 1
li $v0, 0 # answer = false jr $ra
jr $ra # return done:
true: li $v0, 0 li $v0, 0
li $v0, 1 # answer = true jr $ra jr $ra
jr $ra # return
8/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
On considère un jeu d’instructions ne contenant qu'une seule instruction:

SBN A,B,S : où SBN signifie (Soustrait et Saute si Négatif).
L'instruction effectue l'opération suivante:
Mem(A) = Mem(A) - Mem(B), et
si (Mem(A) < 0) PC = PC + S ; sinon PC = PC + 1 (saut à l'instruction suivante) ;
où Mem(A) correspond au contenu de la mémoire à l’adresse A, et PC au compteur de programme; le
test est effectué après la soustraction; on suppose que la largeur de la mémoire est telle qu’une
adresse mémoire correspond à une donnée ou une instruction; on ne se préoccupe pas non plus de la
taille du mot que l’on suppose suffisamment grand pour les calculs; enfin, on considère qu’un
programme se termine quand sa dernière instruction est exécutée.
On suppose que Mem(0)=1, et on peut utiliser les adresses 1 à 9 pour stocker des valeurs temporaires.
Dans les questions suivantes, on suppose que 10 ≤ A, B, C ≤ 20.
1. Ecrire le programme permettant d'effectuer Mem(A) ← 0.
SBN A,A,1 ; Mem(A)=Mem(A)-Mem(A)=0 1
2. Ecrire le programme permettant d’effectuer Mem(A) ← Mem(B).
SBN A,A,1 ; Mem(A)=0
SBN 1,1,1 ; Mem(1)=0

1.25
SBN 1,B,1 ; Mem(1)=-Mem(B)
SBN A,1,1 ; Mem(A)=-Mem(1)=Mem(B)
3. Ecrire le programme permettant d’effectuer Mem(A) ← 3.
SBN A,A,1 ; Mem(A)=0
SBN 1,1,1 ; Mem(1)=0

1.5
SBN 1,0,1 ; Mem(1)=-Mem(0)=-1
SBN 1,0,1 ; Mem(1)=Mem(1)-Mem(0)=-2
SBN 1,0,1 ; Mem(1)=Mem(1)-Mem(0)=-3
9/10
CIN : ……………………………….………………………. CE : ……………………..
------------------------------------------------------------------------------------------------------------------------------
SBN A,1,1 ; Mem(A)=-Mem(1)=3
10/10

Ex MCP 2015+corr

Transféré par

Droits d'auteur :

Formats disponibles

Ex MCP 2015+corr

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Ex MCP 2015+corr

Transféré par

Droits d'auteur :

Formats disponibles

Université de la Manouba

École Nationale des Sciences de l’Informatique

Exercice 1 (5.5 pts) :

2. Considérons la suite des instructions suivante :

Deb : sub $1, $1, $3

Taux de succès =0.85

Exercice 2 (4.5 pts) :

b. Calculez de CPI moyen de chacun des processeurs

CPI moyen du processeur X

CPI moyen du processeur Z

Temps exec (x) = 10 ns/c * 3.95 * 195 = 7702,5 ns

Malgé que Z implémente la muliplication en HW, il est plus lent

Exercice 3 (5.5 pts) :

Considérons le code MIPS suivant :

Cas 1 : condition vérifiée de beq 1 (instruction I4)

Cas 2 : condition non vérifiée de beq 1 (instruction I4)

Cas 4 : condition non vérifiée de beq 1, 2 et 3 (instruction I4, I6 et I7)

3. Sachant ces exécutions, proposez une optimization de ce code.

Exercice 4 (3.5 pts) :

On considère un jeu d’instructions ne contenant qu'une seule instruction:

SBN A,A,1 ; Mem(A)=Mem(A)-Mem(A)=0 1

2. Ecrire le programme permettant d’effectuer Mem(A) ← Mem(B).

SBN A,A,1 ; Mem(A)=0

SBN 1,1,1 ; Mem(1)=0

SBN A,1,1 ; Mem(A)=-Mem(1)=Mem(B)

3. Ecrire le programme permettant d’effectuer Mem(A) ← 3.

SBN A,A,1 ; Mem(A)=0

SBN 1,1,1 ; Mem(1)=0

SBN 1,0,1 ; Mem(1)=Mem(1)-Mem(0)=-2

SBN 1,0,1 ; Mem(1)=Mem(1)-Mem(0)=-3

SBN A,1,1 ; Mem(A)=-Mem(1)=3

Vous aimerez peut-être aussi