Chapitre 3: Architecture type d’une

plate-forme pour systèmes embarqués

Bloc 1: Bloc processeur/

architectures RISC:
parallélisme d’instruction et
autres optimisations

INF3610 - Systèmes embarqués 1

 Plan
• C’est quoi une architecture RISC (motivations)?
• Le scalaire typique à 5 étages (DLX)

• Les aléas
• Les 5 modèles d’une architectures RISC

• Techniques d’optimisations appliquées à un exemple complet

• Le superscalaire et suite des techniques d’optimisation

• La machine VLIW

• Prédiction de branchement et autres points

INF3610 - Systèmes embarqués 2

 Motivation

Principe du
pipeline:
déménagement
en chaîne

Temps d’exécution
Temps
d’exécution 10 ns
50ns 10 ns
10 ns
Total 50ns
Total 30ns
avant les à partir des
années 80 années 80 3
 Références
(pas obligatoire pour le cours mais si vous désirez aller plus loin…)

Bible de l’architecture

INF3610 - Systèmes embarqués 4

 Architecture RISC (rappel)
Exemple d‘instructions RISC/DLX
• Cycle d'horloge court
LD F0, 0(R1)
• Petit nombre de cycles/instruction ADDD F4, F0, F2
SD 0(R1), F4
• Efficacité du pipeline d'instruction

• Comparaisons avec CISC (Complex Instruction-Set Computer) :

– Instruction complexe en langage assembleur pour simplifier le mapping
avec un langage de programmation de haut niveau.
– Pour simplifier la construction des compilateurs.
– Pour diminuer les accès mémoires autrefois dispendieuses (de plus, on ne
connaissait pas encore la mémoire cache).
– Pipeline difficile à réaliser donc Ncpi > 1.
– N.B. Le CISC est réapparu avec le processeur configurable (RISC +
CISC) réf. cours INF8505

5
 Architecture RISC (rappel)

• DLX peut être réalisé avec 5 étapes du pipeline

(architecture scalaire typique):
• LI: lecture d'instruction
• DI: décodage de l'instruction et lecture des registres
• EX: exécution et calcul de l'adresse effective (réalisation
de l'opération indiquée par le code d'opération ou addition
pour accès mémoire ou addition pour branchement/saut)
• MEM: accès mémoire ou fin de branchement (exécution
de l'accès mémoire ou du branchement)
• ER: écriture du résultat dans le banc de registres

6
 Le pipeline DLX
Adresse calculée

Condition de branchement

LI/DI DI/EX EX/MEM MEM/ER

4 M NCP Branche- Donnée à écrire en

U
X
Zéro? ment pris registre
ADD
C
P
RI[6:10]
M
A U
Mémoire RI[11:15]
X
RI M
instruc- U
tions Registres Mémoire X
UAL données Valeur chargée
B Adresse
MEM/ER (DMC)
M
U
X

Donnée à écrire

Imm
Étendre
RI[16:31]

RI[0:5] Instruction Instruction

7
Donnée à écrire en
registre
 Le pipeline DLX
Adresse calculée

Condition de branchement

LI/DI DI/EX EX/MEM MEM/ER

Exemple d‘instructions RISC/DLX

B: LD F0, 0(R1)
4 M
ADDD F4, F0, F2
NCP Branche- Donnée à écrire en
Zéro?
ADD
U
X ment pris registre
SD 0(R1), F4
C
P
RI[6:10]
M
SUBI R1, R1, #8
A U
Mémoire
instruc-
RI RI[11:15]
X
M
U
BNEZ R1, B
tions Registres Mémoire X
UAL données Valeur chargée
B Adresse
MEM/ER (DMC)
M
U
X

Donnée à écrire

Imm
Étendre
RI[16:31]

RI[0:5] Instruction Instruction

Après 5 cycles
Cycle 1 LD
Donnée à écrire en
registre j’ai une instruction
Cycle 2 ADDD LD complétée, mais aux
Cycle 3 SD ADDD LD cycles suivants
Cycle 4 SUBI SD ADDD LD j’aurai un une
Cycle 5 BNEZ SUBI SD ADDD LD instruction qui
terminera à
chaque cycle.

Tableau qu’on
va utiliser
8
Architecture RISC (rappel)

9
Architecture RISC (rappel)

10
 Architecture RISC (rappel)
• Objectif du concepteur: équilibrer la taille des étages du pipeline.
• L'accélération liée au pipeline = nombre d'étages
= 5
• Remarques:
– La difficulté principale de la technique du pipeline est ce qu'on
appelle les aléas du pipeline, en effet il existe des situations,
appelées aléas de données, qui empêchent l'instruction suivante du
flux d'instruction de s'exécuter au cycle d'horloge qui lui est
affecté.
– 3 types aléas: structurels, données et de contrôle
– Par conséquent, les aléas réduisent la performance du pipeline
(accélération inférieure à 5)
• Les aléas (conflits) de données et de contrôle sont ceux qui affectent
l’accélération de 5 (typiquement entre 3.5 et 5 selon la stratégie)
11
Regardons plus en détail ces dépendances

Par convention, il s’agit de l’ordre à respecter dans le pipeline.

Considérons deux instruction i et j, avec i intervenant avant j. Les aléas de
données possibles sont:
• LAE (lecture après écriture): le conflit survient lorsque j essaie de
lire la source avant que i ne l'ait écrite: j obtient alors l'ancienne
valeur. C'est l'aléas le plus fréquent.
• EAL (écriture après lecture): le conflit survient lorsque j écrit dans
une destination avant qu'elle ne soit lue (complètement) par i. i
obtient alors par erreur la nouvelle valeur.
• EAE (écriture après écriture): le conflit survient lorsque j écrit un
opérande avant qu'il ne soit écrit par i. L'écriture se fait alors dans
le mauvais ordre, et laisse dans la destination la valeur écrite par i
plutôt que celle écrite par j.

12
 Regardons plus en détail ces dépendances

Dépendances de données
LD F0, 0(R1)
• LAE (RBW)
1. F0 de LD doit contenir ADDD F4, F0, F2

la donnée avant que ADD SD 0(R1), F4

additionne F0 et F2 .
.
2. F4 de ADD doit contenir le
résultat de l’addition F0 et F2 Tableau
qui représente
avant qu’il soit mis en mémoire l’exécution

par SD

Les 2 bulles rouges représentent les 2 problèmes de dépendance de donnée:

1. on débute l’exécution et le load (LD) de la mémoire n’est pas fini et 2. on
débute le strore (ST) avant que l’exécution soit terminé.
13
 Regardons plus en détail ces dépendances

Dépendances de données
LD F0, 0(R1)
• LAE (RBW)
1. F0 de LD doit contenir ADDD F4, F0, F2

la donnée avant que ADD SD 0(R1), F4

additionne F0 et F2 .
.
2. F4 de ADD doit contenir le
résultat de l’addition F0 et F2
avant qu’il soit mis en mémoire
par SD

Solution: on doit suspendre le pipeline avec SU

N.B. Pour simplifier ADD prend ici 1 cycle d’exécution (EX), mais on verra plus
loin qu’il peut aussi prendre plusieurs cycles (EX1, EX2, etc.) ce qui
implique possiblement plusieurs suspensions. 14
 Regardons plus en détail ces dépendances

Dépendances de données

• EAL (WBR)
– DIV doit avoir terminé avec F0 LD F0, 0(R1)

avant que LD l’affecte à une DIV F4, F0, F2

nouvelle donnée.
n.b. DIV peut être beaucoup plus
SD 0(R1), F4

long à exécuter que LD LD F0, 0(R1)

DIV F4, F0, F2

SD 0(R1), F4

N.B. DIV peut être beaucoup plus long à exécuter que LD

15
Regardons plus en détail ces dépendances

LD F0, 0(R1)
• EAE (WBW)
DIV F4, F0, F2
– DIV doit avoir affecté F4
avant que ADD affecte F4 SD 0(R1), F4

(sinon SD entre les 2 n’utilise LD F0, 0(R1)

pas la bonne valeur de F4)
ADD F4, F0, F2

SD 0(R1), F4

N.B. DIV peut être beaucoup plus long à exécuter que LD

16
Regardons plus en détail ces dépendances

• Dépendances de contrôle
if (condition1)

instruction1 possède une dépendance

instruction1;
else
de contrôle par rapport condition1 instruction2;

instruction2 possède une dépendance

de contrôle par rapport condition1

• Le compilateur doit analyser ces dépendances

17
Regardons plus en détail ces dépendances

•Dépendances de contrôle
...

instruction1 possède une dépendance

SUBI R1,R1,#8

de contrôle par rapport condition1 BEQZ R1, sortie

?
instruction2 possède une dépendance LD F6,0(R1)
de contrôle par rapport condition1
ADDD F8,F6,F2

SD 0(R1),F8
...

sortie LD F10, 0(R10)

•Le compilateur doit analyser ces dépendances

18
 Parallélisme d’instruction
• Parallélisme d’instructions (ILP)

– Il faut trouver des séquences d’instructions indépendantes

qui se recouvriront dans le pipeline

– Très efficace au niveau du point flottant

Réf.: Computer Architecture, A Quantitative Approach, H&P, 1996. p228-251

19
• Regardons d’abord les différents modèles d’architecture possible:

M1
(pas très réaliste)

20
Autres modèles possibles:

• Modèle pipeline sauf pour EX qui supporte à la fois les opérations

entières et flottantes.

M2

• Modèle pipeline sauf pour EX qui supporte des opérations entières et

flottantes distinctes.

M3
Deux EX distincts peuvent s’exécuter en parallèle, mais lorsqu’on a deux exécutions
identiques (ex. ADDF) successives on devra attendre que la première soit terminée
avant de commencer la seconde.

21
Réf.: Computer Architecture, A Quantitative Approach, H&P, 1996. p228-251
Autres modèles possibles:
•Modèle pipeline étendu aux opérations flottantes.

M4

22
 Parallélisme d’instruction

• Exemple:

for (i=1; i<=1000; i++)

x[i] = x[i] + s;

Délais:
• FP-ALU 3 cycles dans EX (E1, E2 et E3)
donc 2 cycles de supension
• Branchement avec délai de 3 cycles (2
cycles de suspension)

Réf.: Computer Architecture, A Quantitative Approach, H&P, 1996. p228-251

23
Technique d’optimisation:

Code DLX sans optimisation

B: LD F0, 0(R1) ; chargement element vecteur

ADDD F4, F0, F2 ; x[i] = x[i] + s;
SD 0(R1), F4 ; ranger
SUBI R1, R1, #8 ; pointeur (double-mot)
BNEZ R1, B ; R1 <> 0

Analyse selon M2

Délais: 1 itération = 10 cycles

• FP-ALU 3 cycles 1000 itérations = 10000 cycles
• Branch 3 cycles
LD F0, 0(R1)

ADDD F4, F0, F2

SD 0(R1), F4
LAE (RBW)
24
Technique d’optimisation:

Code DLX sans optimisation

B: LD F0, 0(R1) ; chargement element vecteur

ADDD F4, F0, F2 ; x[i] = x[i] + s;
SD 0(R1), F4 ; ranger
SUBI R1, R1, #8 ; pointeur (double-mot)
BNEZ R1, B ; R1 <> 0

Analyse selon M2
cycle
B: LD F0, 0(R1) 1
suspension 2
ADDD F4, F0, F2 3 1 itération = 10 cycles
suspension 4
1000 itérations = 10000 cycles
suspension 5
SD 0(R1), F4 6
SUBI R1, R1, #8 7 LD F0, 0(R1)
BNEZ R1, B 8
suspension 9 ADDD F4, F0, F2
suspension 10
SD 0(R1), F4
LAE (RBW)
25
Analysons le schéma précédant

• On voit qu’il faut un délai de un cycle entre LD et ADDD, par

conséquent on (le compilateur) va insérer un NOP après LD
• On voit également qu’il faut un délai de deux cycles entre ADDD et
SD, par conséquent on (le compilateur) va insérer deux NOP après
ADDD
• On voit également qu’il faut un délai de deux cycles entre BNEZ et
la prochaine instruction, par conséquent on (le compilateur) va
insérer deux NOP après BNEZ

26
 Note: Stall or NOP
• Stall (cas du ARM): aucune nouvelle
instruction n’est lue durant le(s) SU(s) donc
aucune instruction ne termine durant ce(s)
cycle(s).
• NOP (cas du MIPS): l’assembleur insère
des NOP instructions.

27
Technique d’optimisation (suite)
D‘où le résultat assembleur

B: LD F0, 0(R1) 1
SU 2 LD F0, 0(R1)
ADDD F4, F0, F2 3
NOP 4 ADDD F4, F0, F2
NOP 5
SD 0(R1), F4 6 SD 0(R1), F4
SUBI R1, R1, #8 7 LAE (RBW)
BNEZ R1, B 8
NOP 9
NOP 10

Selon
M2

10 cycles 28
Technique d’optimisation (suite)

• Comment mieux voir d’où proviennent ces 5 suspensions:

1 suspension
2 suspensions

Selon
M2

10 cycles
2 suspensions

(page
précédente):

29
Technique d’optimisation (suite)

• Comment mieux voir d’où proviennent ces 5 suspensions:

1 suspension
2 suspensions

Selon
M2

10 cycles/itération

Total de 5 suspensions, on peut commencer la

prochaine itération au 11e cycle. 2 suspensions

• On a donc un modèle pipeline avec une seule unité EX qui peut jouer le rôle d’entier
ou de flottante. Lorsqu’on fait un ADDD (addition sur un double mot), ça demande 3
cycles dans l’unité EX alors que si on fait un ADD (addition sur un entier) ça demande
1 cycle seulement.
• Convention: quand on a un SU qui apparait au cycle i tout ce qui suit en bas est SU.

30
Technique d’optimisation (suite)

1. Parallélisme
entre E2 et EX

2. Ordre des 3
EX doit être
préservé

1. On voit un parallélisme possible entre deux chemins différents du

pipeline ADDD et SD)
2. Mais l’ordre des instructions (e.g. le EX) doit être préservé pour les
instruction qui traversent un même chemin du pipeline (SD, SUBI et
BNEZ):
Selon
M3
31
31
Technique d’optimisation (suite)
• Que se passerait-il si il n’y avait pas de dépendance entre ADDD et SD???
1 suspension
Un seul port
pour la mémoire

Selon
M3

1 suspension 9 cycles
2 suspensions au total
• 3 SU doivent quand même être insérés:

32
Analysons le schéma précédant

• À partir du schéma précédent, on voit qu’il un délai de un cycle

entre LD et ADDD, par conséquent on (le compilateur) va insérer
un NOP après LD
• On va voir plus loin qu’on aurait pu mettre SD à la place du NOP
(on inverse l’ordre des opérations).
• Puisque la mémoire a un seul port d’accès, SUBI ne peut accéder à
ME au cycle 8, par conséquent on a besoin de un cycle de délai
entre ADD et SUBI. On (le compilateur) va insérer un NOP après
SD
• On voit également qu’il faut ralentir de deux cycles BNEZ et la
prochaine instruction, par conséquent on (le compilateur) va insérer
deux NOP après BNEZ

33
Technique d’optimisation (suite)

Selon
M4

34
Technique d’optimisation (suite)

Ordonnancement (1ère optimisation M4)

B: LD F0, 0(R1) 1
suspension 2
ADDD F4, F0, F2 3
SUBI R1, R1, #8 4
BNEZ R1, B 5
SD 8(R1), F4 6
suspension 7

1 itération = 7 cycles
1000 itérations = 7000 cycles

A = 10000/7000 = 1.43

35
Réf.: Computer Architecture, A Quantitative Approach, H&P, 1996. p228-251
Technique d’optimisation pour le point flottant (suite)

Déroulage de la boucle pour 4 itérations (2e optimisation M4)

B: LD F0, 0(R1)
ADDD F4, F0, F2
SD 0(R1), F4

LD F6, -8(R1) ; retrait des SUBI et

ADDD F8, F6, F2 ; BNEZ à chaque
SD -8(R1), F8 ; itération

LD F10, -16(R1)
ADDD F12, F10, F2
SD -16(R1), F12

LD F14, -24(R1)
ADDD F16, F14, F2
SD -24(R1), F16
1 itération = 28 cycles
250 itérations = 7000 cycles
SUBI R1, R1, #32
BNEZ R1, B
A = 10000/7000 = 1.43

36
Réf.: Computer Architecture, A Quantitative Approach, H&P, 1996. p228-251
Technique d’optimisation pour le point flottant (suite)
Déroulage de la boucle pour 4 itérations (2e optimisation M4)
B: LD F0, 0(R1) ; 1
SU ; 2
ADDD F4, F0, F2 ; 3
SU ; 4
SU ; 5
SD 0(R1), F4 ; 6

LD F6, -8(R1) ; 7
ADDD F8, F6, F2 ; 9
SD -8(R1), F8 ; 12

LD F10, -16(R1) ; 13
ADDD F12, F10, F2 ; 15
SD -16(R1), F12 ; 18

LD F14, -24(R1) ; 19
ADDD F16, F14, F2 ; 21 1 itération = 28 cycles
SD -24(R1), F16 ; 24 250 itérations = 7000 cycles
SUBI R1, R1, #32 ; 25
BNEZ R1, B ; 26 A = 10000/7000 = 1.43
SU ; 27
SU ; 28

37
Réf.: Computer Architecture, A Quantitative Approach, H&P, 1996. p228-251
 Technique d’optimisation pour le point flottant (suite)

Déroulage + Ordonnancement

B: LD F0, 0(R1)
Les LD LD F6, -8(R1)
remplace LD F10, -16(R1)
efficacement LD F14, -24(R1)
le SU
1 itération = 14 cycles
250 itérations = 3500 cycles
ADDD F4, F0, F2
Les ADD ADDD F8, F6, F2
remplace A = 10000/3500 = 2.86
efficacement
ADDD F12, F10, F2
les 2 SU ADDD F16, F14, F2
N.B. Un déroulement de 3
aurait suffit pour éviter les SU,
mais 100/3 n’est pas un entier.
SD 0(R1), F4
SD -8(R1), F8
; SD -16(R1), F12
; SD -24(R1), F16

SUBI R1, R1, #32

BNEZ R1, B
SD 16(R1), F12 ; 32 – 16 = 16
SD 8(R1), F16 ; 32 - 24 = 8

38
Réf.: Computer Architecture, A Quantitative Approach, H&P, 1996. p228-251
 Architectures pour ILP
(Superscalaire, SIMD, VLIW)

Idée: Exécuter plus d’une instruction par cycle

Impact: CPI < 1 !

Solutions: Architecture superscalaire

plusieurs pipelines travaillent en parallèle sur
plusieurs instructions

Architecture VLIW (Very Long Instr. Word)

Une seule instruction effectue plusieurs traitements

39
 Exemple de superscalaire
(ARM Cortex A72)

LI (1 instruction de 128 bits,

2 instructions de 64 bits
ou 4 instruction de 32 bits)

DI (3 décodage en parallèle)

EX (8 unités de calcul pipelinable

et en parallè)

NEON = SIMD* = 4 additions/soustraction/etc.

en parallèle

*Single Instruction Multiple Data

4 additions en
N.B. Le Raspberry Pi 4 comporte 1 Cortex-A72 à 1,5 GHz parallèle sur 4 mots
de 32 bits

40
Architecture superscalaire

Plusieurs pipelines en parallèle (M5)

•Ordonnancement dynamique selon le cours de l’exécution

Pour 2 pipelines on aura:

INSTRUCTION
ENTIÈRE LI DI EX ME ER

FLOTTANT LI DI E1 E2 E3 … En ME ER

ENTIÈRE LI DI EX ME ER

FLOTTANT LI DI E1 E2 E3 … En ME ER

ENTIÈRE LI DI EX ME ER

FLOTTANT LI DI E1 E2 E3 … En ME ER

41
Architecture superscalaire

Exemple: Paralléliser:
B: LD F0, 0(R1)
ADDD F4, F1, F2
SD 0(R1), F4
SUBI R1, R1, #8
BNEZ R1, B

Problème:
Le microprocesseur ne peut pas résoudre tous les aléas
de données.

Solution:
Trouver un ordonnancement déroulé sans délai ni
suspension qu’on peut séparer sur 2 pipelines.

42
Architecture superscalaire

Le calcul de l’addition se fait B:

LD F0,0(R1)
en 3 cycles LD F6,-8(R1)
LD F10,-16(R1)
LD F14,-24(R1)
Au moins 3 itérations doivent LD F18,-32(R1)
être déroulées … ADDD F4,F0,F2
ADDD F8,F6,F2
ADDD F12,F10,F2
Ici on va faire 5 déroulements ADDD F16,F14,F2
i.e. par groupe de 5. ADDD F20,F18,F2
SD 0(R1),F4
Donc pour 1000 éléments SD -8(R1),F8
(ou 200 itérations) SD -16(R1),F12
SUBI R1, R1, #40
BNEZ R1, B
1 itération = 17 cycles SD 16(R1),F16
200 itérations = 3400 cycles SD 8(R1), F20

A = 10000/3400 = 2.94

43
Architecture superscalaire

PIPELINE ENTIER PIPELINE FLOTTANT

B: B:
LD F0,0(R1)
LD F6,-8(R1)
LD F10,-16(R1) ADDD F4,F0,F2
LD F14,-24(R1) ADDD F8,F6,F2
LD F18,-32(R1) ADDD F12,F10,F2
SD 0(R1),F4 ADDD F16,F14,F2
SD -8(R1),F8 ADDD F20,F18,F2
SD -16(R1),F12
SUBI R1, R1, #40
BNEZ R1, B 1 itération = 12 cycles
SD 16(R1),F16 200 itérations = 2400 cycles
SD 8(R1), F20
A = 10000/2400 = 4,17

44
Architecture superscalaire

À chaque cycle deux

instructions peuvent
s’exécuter:
Instruction entière
Instruction flottante

45
En résumé:

5 modèles possibles pour une architecture (super) scalaire:

1. Modèle pipeline avec une seule unité EX (elle aussi pipelinable) qui
supporte à la fois les opérations entières et flottantes.

2. Modèle pipeline sauf pour EX (non pipelinable) qui supporte à la

fois les opérations entières et flottantes.

3. Modèle pipeline sauf pour EX (non pipelinable) qui supporte des

opérations entières et flottantes distinctes.

4. Modèle pipeline avec pour EX plusieurs pipelines en parallèle.

5. Plusieurs pipelines en parallèle (LI, DI, EX, MEM, ER)

46
Architecture VLIW

47
 Architecture VLIW

• Une architecture VLIW utilisent plusieurs unités fonctionnelles

indépendantes.

• Plutôt que d’essayer de lancer plusieurs instructions indépendantes

vers les unités, une VLIW met plusieurs opérations dans une seule
instruction très longue, d’où son nom.

48
 VLIW

• Voir aussi:
http://marcel.developpez.com/cours/systeme/architecture-
ordinateur/html/node222.html

49
Exemple d’architecture VLIW chez STMicroelectronics

Mot de160 bits

50
 Architecture VLIW

UNITÉ TRANSFERT 1 UNITÉ TRANSFERT 2 UNITÉ EXÉCUTION 1 UNITÉ EXÉCUTION 2 UNITÉ ENTIÈRE
1 LD F0,0(R1) LD F6,-8(R1)
2 LD F10,-16(R1) LD F14,-24(R1)
3 LD F18,-32(R1) ADDD F4,F0,F2 ADDD F8,F6,F2
4 ADDD F12,F10,F2 ADDD F16,F14,F2
5 ADDD F20,F18,F2
6 SD 0(R1),F4
7 SUBI R1, R1, #40
8 BNEZ R1, B
9 SD 24(R1),F12 SD 32(R1),F8 Plutôt que de mettre à la suite de la ligne 6, on
10 SD 8(R1),F20 SD 16(R1),F16 a gardé pour le remplissage du branch
11
12

1 itération = 10 cycles
200 itérations = 2000 cycles

A = 10000/2000 = 5

51
Architecture VLIW

Ordonnancement statique
le compilateur cherche plusieurs
instructions indépendantes et les encode en
une seule

Des unités spéciales exécutent chaque

d’instruction

Exemple:

LD F0,0(R1) || LD F6,-8(R1) || ADDD F10,F12,F16 || ADDD F11,F13,F17 || bnez r1,b || sub r2,r2,#1

52
Attention il y a une limite à dérouler les boucles et à
vouloir tout paralléliser: parallélisme de boucle

L’itération 1 indépendante de for (i=1; i<=1000; i++)

l’itération 2 x[i] = x[i] + s;

A[i] de l’itération 2 dépend de for (i=1; i<=100; i++){

A[i+1] de l’itération 1 A[i+1]= A[i] + C[i];
B[i+1]= B[i] + A[i+1]; }
Parallélisme impossible car les
Voir pp. 73 et 74
boucles doivent s’exécuter dans l’ordre Cours no 9

53
 Prédiction statique

• Par conséquent, à l'aide de ce genre de prédictions, deux actions sont

possibles:
1. Considérer que le branchement n'est pas effectué ou
2. Considérer que le branchement est effectué. L'adresse de la
destination doit être connue avant le résultat du branchement.
• Remarque: dans les deux cas, si la prédiction s'avère fausse, on "flush"
le pipeline et on doit tout remettre comme avant (dangereux si on fait
des écritures en mémoire). On doit alors garder une trace des
transactions.

56
 Prédiction dynamique (matérielle)
• On utilise un tampon de prédiction de branchement, c’est-à-dire une petite cache au
quelle on accède par l'adresse de l'instruction à l'étage LI du pipeline ou par 1 bit attaché
à chaque bloc de la cache d’instruction et lu avec l'instruction. Ce bit représente ce qui a
été fait la dernière fois que l’instruction a été exécutée et à partir de la valeur de ce
même bit obtenue on adopte la convention suivante:
Convention:
• bit = 0 veut dire qu’on a fait le branchement lors de l’itération précédente (effectuée), donc
on va faire le branchement. Si on a pris la bonne décision le bit reste à 0 sinon on flush
le pipeline et on met bit=1.
• bit = 1 veut dire qu’on a pas fait le branchement lors de l’itération précédente (non effectuée), donc
on va pas faire le branchement. Si on a pris la bonne décision le bit reste à 1 sinon on flush
le pipeline et on met bit=0.
Regardons un exemple pour laquelle on aurait 1 bit attaché à BNEZ:
On suppose R1 = 1000 (on va donc boucler 1000 de fois à chaque
exécution de la boucle)

B: LD F0, 0(R1) On peut montrer qu’au niveau prédiction de branchement,

ADDD F4, F0, F2 On va se tromper (flusher) 2 fois sur 1000. C’est-à-dire
SD 0(R1), F4 quand on arrive à 0, mais aussi la fois suivante lorsque
SUBI R1, R1, #8 l’on va ré-exécuter la boucle (i.e, quand on repars à
BNEZ R1, B 1000).
57
 Prédiction dynamique (matérielle)
• Mais dans les architecture modernes (ARM Cortex A, Intel, etc.), on fait
encore mieux en prenant 2 bits de mémorisation plutôt qu’un seul. On utilise
donc un tampon de prédiction de branchement, c’est-à-dire une petite cache
auquel on accède par l'adresse de l'instruction à l'étage LI du pipeline ou par 2
bits attaché à chaque bloc du cache instruction et lu avec l'instruction. Ces 2
bits représentent ce qui a été fait la dernière fois que l’instruction a été
exécutée. Ici on adopte la convention suivante:

Convention:
• Puisqu’on a 2 bits on 4 états. Voyez le comme une machine à états de Mealy (prédiction effectuée 1,
prédiction effectuée 2, prédiction non effectuée 1 et prédiction non effectuée 2)
• Quand on passe d’une transition à une autre on flush le pipeline mais on doit se tromper
2 fois de suite (consécutivement), donc 2 flush consécutifs, pour qu’une prédiction effectuée
passe à non effectuée et vice versa.
• Voir l’application sur notre exemple à la page suivante.

Non Effectuée
Effectuée

Prédition Prédition
effectuée non effectuée
58
Effectuée Non Effectuée
 Prédiction dynamique (matérielle)

On doit se tromper 2 fois pour qu’une prédiction non effectuée passe à effectuée.

Boucle dans laquelle on attache 2 bits à BNE avec

toujours R1 = 1000:
Non Effectuée/Flush pipeline
Effectuée
B: LD F0, 0(R1)
ADDD F4, F0, F2 Prédition Prédition
Effectuée 1 Effectuée 2
SD 0(R1), F4
SUBI R1, R1, #8 Effectuée

BNEZ R1, B Effectuée/

Non Effectuée/
flush pippeline
flush pipeline

Dans la boucle du haut, Non Effectuée

on peut ainsi montrer

Prédition Prédition
qu’au niveau prédiction non effectuée 1 non effectuée 2
de branchement,
Effectuée/flush pipeline Non Effectuée
on va flusher 1 fois sur 1000:
quand on sors de la boucle seulement.

On doit se tromper 2 fois pour qu’une prédiction effectuée passe à non effectuée. 59
 Quelques recommandations pour
Valeurs peuvent changer
les exercices d’un examen à l’autre…

Je donne
toujours
une table
dans ce format
en annexe de
l’examen.

INF3610 - Systèmes embarqués 60

 Quelques recommandations pour
les exercices
Je vais toujours
allouer les numéros LD F30, 0(R4)
de registres en
arrondissant à la
LD F31, 8(R4)
dizaine (F10, F20, F30, etc). LD F32, 16(R4)
Ainsi si vous avez à LD F40, 0(R5)
dérouler une boucle 3 fois,
vous utiliserez
LD F41, 8(R5)
F60, F61 et F62 (voir page
suivante).
Ainsi vous me faciliterez
la correction…

INF3610 - Systèmes embarqués 61

 Quelques recommandations pour
les exercices
Je vais toujours
allouer les numéros
de registres en
arrondissant à la
dizaine (F10, F20, F30, etc).
Ainsi si vous avez à
dérouler une boucle 3 fois,
vous utiliserez
F60, F61 et F62 (voir page
suivante).
Ainsi vous en adoptant
Cette convention, vous me
faciliterez
la correction…

INF3610 - Systèmes embarqués 62

Exemple

Selon
M3

16 cycles par iteration

16 x 125 = 2000 cycles d’horloge
S = 3750/2000 = 1.875
63
Example

Selon
M4

15 cycles par iteration

15 x 125 = 1875 cycles d’horloge
S = 3750/1875 ≈ 2.02

64