Fichier PowerPoint de l`ensemble du cours

Gei 431
Architecture des ordinateurs II
GEI 431 - Frédéric Mailhot
1. Introduction
2. Concepts de base du pipeline
3. Utilisation d'unités d'exécution multiples
4. Méthodes superscalaires et VLIW
5. Structures superscalaires
6. Gestion avancée des branchements
7. Études de cas
8. Machines "Dataflow"
9. Développements futurs
10. Mémoires caches
11. Multiprocesseurs
12. VHDL
13. Introduction à la synthèse logique
14. BDD et algorithme de buffering
Gei 431
Introduction
Objectifs du cours
Évaluation
Références
Matière du cours:
- Techniques modernes d’architecture
- Les systèmes parallèles
- La synthèse automatisée de circuit
Architecture des ordinateurs II – Frédéric Mailhot
Introduction
Matière couverte
•
•
Amélioration des derniers 10 ans
Comprendre ce qui s’en vient d’ici 10 ans
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Pourquoi l’évolution de l’architecture?
•
Loi de Moore: 2X plus de transistors / 18 mois
 Depuis 15 ans: environ 1000X (de 4 à 0.13 microns)
 En 2008: 0.05 micron, 100M transistors, plusieurs GHz
•
•
•
Différence croissante entre le délai intra-chip et le
délai extra-chip
Importance croissante des interconnections entre
les transistors
Corrolaire de la loi de Moore: augmentation
exponentielle de la puissance dissipée (à voltage
constant)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Défis
•
Taille et puissance
 Comment gérer l’augmentation de puissance
consommée? (prédite par Dennart en ’70)
•
Performance du système
 Qu’est-ce qui définit la performance?
 Où doit-on miser pour augmenter la performance?
•
Complexité
 Comment gérer le design de systèmes de plus en plus
gros?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Force motrice derrière l’architecture des
ordinateurs
•
Fin des années ’80, début ’90:
 Performance des processeurs
•
Fin des années ’90, début 2000:
 Puissance
 Accès à la mémoire lent
 Fiabilité
 Coût de développement, maintenance de logiciel
 Désuétude rapide
 Performance des processeurs
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Qu’allons-nous étudier ici?
•
Techniques d’amélioration de la performance des
processeurs utilisées depuis 10 ans:
 Parallélisme (MLP, ILP)
 Pipelines / superscalaires / VLIW
•
Multiprocesseurs
 Synchronisation
•
Techniques modernes de conception de circuits
 Synthèse de haut niveau, logique
 HDLs (Hardware Description Languages)
 Technologies-cibles: ASIC, FPGA
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Comment améliorer la performance?
•
Matériel
 Dispositifs
 Ensemble d’instructions (RISC vs CISC)
•
Conception
 Techniques de synthèse
 Techniques de test
•
Parallélisme
 MLP (Machine Level Parallelism)
 ILP (Instruction Level Parallelism)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Matériel: Amélioration des dispositifs
•
•
Plus grande intégration (Moore / Dennart)
Utilisation nouvelle des composants
 FPGA: utilisation d’éléments reconfigurables
 Protocoles d’entrées/sorties différents
• E.g. Rambus
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Matériel: Amélioration des dispositifs
•
Silicium
 Sous 0.1 um (IBM prévoit 0.05 um en 2008)
 Oxyde trop mince -> effet tunnel
 Variations locales du dopage
 Transport ballistique
 DIBL (Drain-Induced Barrier Lowering)
•
Arseniure de Gallium (AsGa), GermaniumSilicium (siGe) ?
• Communications optiques?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Matériel: Amélioration des dispositifs (2)
•
•
•
Superconducteurs à haute température?
Systèmes quantiques?
Nanotechnologie?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Matériel: ensemble d’instructions
•
RISC: instructions plus simples à décoder
 Plus d’instructions pour la même tâche
 Chaque instruction s’exécute plus rapidement
• CISC: instructions complexes
• VLIW (Very Large Instruction Word)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Conception: techniques de synthèse
•
•
•
•
Langages de haut niveau (VHDL, Verilog)
Synthèse de haut niveau
Synthèse logique
Placement / Routage
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Conception: techniques de test
•
Vecteurs de test
 Modèle stuck-at
•
•
JTAG et Full / Partial Scan
BIST (Built-In Self-Test)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Parallélisme: MLP
•
Machines massivement parallèles
 Thinking machines
 Masspar
• NOW (Network of Workstations)
• Multiprocesseurs
 ASCI White
 Beowulf
© 2004 Frédéric Mailhot
Université de Sherbrooke
Introduction
Parallélisme: ILP
•
•
Pipelines
Méthodes superscalaires
 Scoreboard, Tomasulo
•
Prédiction des branches
 Méthodes statiques / dynamiques
•
Spéculation (EPIC – Explicitely Parallel
Instructions Computer)
•
Machines « multithreaded »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Systèmes Pipeline
Les systèmes modernes utilisent tous des
architectures pipelines – Pourquoi?
Architecture des ordinateurs II – Frédéric Mailhot
Pipeline
Matière couverte
•
•
Principes de base des systèmes pipelines
•
Problèmes rencontrés
Utilisation de pipeline dans un microprocesseur
simple
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Exemple: le lavage du linge
•
•
Soient 4 étudiants qui désirent faire leur lavage
Il y a une laveuse, une sécheuse, et une table
pour plier le linge
• Le lavage prend 30 minutes
• Le séchage prend 40 minutes
• Le pliage prend 20 minutes
• Si l’opération commence à 6h00 du soir, à quelle
heure termineront-ils?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Lavage du linge: 1ère itération
•
•
•
•
•
L: 30
S: 40
P: 20
4 * (30 + 40 + 20) = 360 minutes
On termine à minuit
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Lavage du linge: 2e itération: pipeline
•
•
L:30, S: 40, P: 20
On superpose le lavage, séchage et pliage:
30
40
30
• On termine à 21h30
• Régime permanent:
100 min/pers
20
40
30
20
40
20
30
30
70
110
150
© 2004 Frédéric Mailhot
40
20
190
210
Université de Sherbrooke
Pipeline
Lavage du linge: 3e itération –
sécheuse/plieuse
•
L:30, SP: 50 (une sécheuse/plieuse):
 SP = 50, au lieu de S + P = 40 + 20 = 60
30
• On termine à 21h50
• Régime permanent:
100 min/pers
50
30
50
30
50
30
30
80
130
180
© 2004 Frédéric Mailhot
50
230
Université de Sherbrooke
Pipeline
Lavage du linge: 4e itération: 2 sécheuses
•
L:30, S1: 20, S2: 20, P: 20
30
20
30
20
20
20
20
20
20
20
20
30
20
20
20
120
140
160
180
30
30
60
• On termine à 21h00
• Régime permanent:
110 min/pers
90
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Lavage du linge: 5e itération: 1 sécheuse
« haute température »
•
L:30, S1: 15, S2: 20, P: 20
30
15
30
20
20
15
20
20
15
20
20
30
15
20
20
120
140
160
180
30
30
60
• On termine à 21h00
• Régime permanent:
110 min/pers
90
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Lavage du linge: 6e itération: 2 sécheuses
« haute température »
•
L:30, S1: 15, S2: 15, P: 20
30
15
15
30
• On termine à 20h50!
• Régime permanent:
80 min/pers
20
15
15
30
20
15
15
30
30
60
90
120
20
15
15
150
© 2004 Frédéric Mailhot
20
170
Université de Sherbrooke
Pipeline
Leçons du pipeline de lavage
•
Le pipeline n’améliore pas la latence. Il améliore
le temps moyen par tâche (throughput)
•
La vitesse du pipeline est limitée par l’étage le
plus lent
Plusieurs tâches se font en parallèle
•
•
•
•
Accélération possible: nombre d’étages
Les durées d’étage inégales limitent
l’accélération
Le temps de remplir et de vider le pipeline réduit
l’accélération
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Le processeur DLX (De Luxe)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Vue « pipeline » du DLX
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
La loi de Amdahl
•
N = (performance avec amélioration)
(performance sans amélioration)
=
1
(1 – Fraction améliorée) + Fraction (améliorée)
Accélération (améliorée)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Performance: principe de base
•
•
Comment mesurer et comparer la performance?
X est N fois plus rapide que Y veut dire:
 N = (temps d’exécution de Y)
(temps d’exécution de X)
• On doit distinguer le temps de réponse pour une
tâche du temps moyen de réponse (throughput)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Équation de la performance d’un CPU
•
Temps CPU = coups d’horloge d’un programme
multiplié par la période de l’horloge
•
Soit IC = Instruction Count
= Nombre d’instructions d’un programme
• Soit CPI = Clock cycle Per Instruction
= coups d’horloge d’un programme
IC
• Alors: temps CPU = IC * CPI * période de l’horloge
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Le pipeline – principes de base
•
•
Une instruction par coup d’horloge
L’information doit être propagée d’un étage à
l’autre
• Il ne peut y avoir de conflit de ressources
• L’ajout de registres (ou de latches) a un impact
sur la période de l’horloge
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Le DLX – pipeline à 5 étages
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
L’arrêt temporaire du pipeline (stall)
•
Dans certains cas, on doit arrêter temporairement
un ou plusieurs étages d’un processeur:
 « cache miss »
 Problème local à une instruction
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Impact des « stalls » sur la performance
•
Amélioration = CPI(sans) * période (sans)
CPI(avec)
•
•
période (avec)
CPI(avec) = 1 + stall / instruction
Amélioration =
CPI(sans)
1 + stall / instruction
Amélioration = profondeur du pipeline
1 + stall / instruction
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Les obstacles majeurs au pipeline
•
•
•
Problèmes structuraux
Problèmes de dépendances de données
Problèmes de contrôle
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Exemple de problème de structure
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Effet d’un problème de structure sur les stall
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipelines: classification des problèmes de
dépendance de données
• RAW (Read after Write): instruction subséquente lit la
source avant que l’instruction précédente l’ait écrite.
Problème résolu avec « forwarding »
• WAW (Write after Write): instruction subséquente tente
d’écrire une destination avant que l’instruction précédente
l’ait écrite. Ce type de problème existe dans les pipelines
où l’écriture se fait à plus d’un endroit
• WAR (Write after Read): instruction subséquente écrit la
destination avant que l’instruction précédente ne l’ait lue.
Ce type de problème peut apparaître lorsqu’il y a des
écritures hâtives et des lectures tardives
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Problème de dépendance de données RAW
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Solution au RAW: le « forwarding »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Autre exemple de « forwarding »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: Problèmes de données exigeant
des retards (stalls)
•
Soit la séquence d’instructions suivante:
LW
SUB
AND
OR
R1, 0 (R2)
R4, R1, R5
R6, R1, R7
R8, R1, R9
•
La 1ère instruction est une lecture de la mémoire.
La 2e utilise dans l’ALU la valeur lue en mémoire
(MEM1 et ALU2 sont concurrentes)
•
Solution: on utilise un dispositif matériel, le
« pipeline interlock », pour détecter ce cas et
introduire un retard (stall)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Stalls: impact sur la performance
•
Supposons que 30% des instructions sont des
« load »
•
Supposons que 50% des instructions qui suivent
un « load » utilisent la valeur lue
• Le CPI de l’instruction qui suit le « load » est de
1.5 (stall ½ du temps)
•
Puisque 30% des instructions sont des « load »,
les CPI moyen devient:
CPI = (0,7 * 1 + 0,3 * 1,5) = 1,15
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Certains « stalls » peuvent être évités, mais
pas tous
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Effet d’un « stall » sur le pipeline
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
La nécéssité des « stall » - exemple
LW R1, 0(R1)
IF
SUB R4, R1, R5
ID
EX
MEM
WB
IF
ID
EX
MEM
WB
IF
ID
EX
MEM
WB
IF
ID
EX
MEM
AND R6, R1, R7
OR R8, R1, R9
LW R1, 0(R1)
SUB R4, R1, R5
AND R6, R1, R7
OR R8, R1, R9
IF
WB
ID
EX
MEM
WB
IF
ID
stall
EX
MEM
WB
IF
stall
ID
EX
MEM
WB
stall
IF
ID
EX
MEM
© 2004 Frédéric Mailhot
WB
Université de Sherbrooke
Pipeline
Pipeline: utilisation des compilateurs pour
réduire les problèmes de dépendences
•
L’instruction de haut niveau suivante:
• A=B+C
cause un délai (stall) pour charger la 2e valeur (C)
•
Solution: on tente, à l’aide du compilateur,
d’éviter de générer du code où un « load » est
immédiatement suivi par l’utilisation du registre
visé. Cette technique est appellée « pipeline
scheduling » ou « instruction scheduling »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Exemple de « pipeline scheduling »
•
Soient les instructions suivantes:
A=B+C
D=E–F
•
Le code suivant évitera les « stall »:
•
•
•
•
•
•
•
•
LW
LW
LW
ADD
LW
SW
SUB
SW
Rb, B
Rc, C
Re, E
Ra, Rb, Rc
Rf, F
A, Ra
Rd, Re, Rf
D, Rd
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Réalisation du contrôle du pipeline du DLX
• Lorsqu’une instruction passe de ID à EX, on dit que
•
•
l’instruction est émise (issued). Dans le DLX, tous les
problèmes de dépendances de données peuvent être
détectés durant la phase ID. S’il y a un problème de
dépendance, il n’y a qu’à retarder l’émission de
l’instruction.
De même, on peut détecter durant la phase ID quels
« forwarding » devront être faits, et à quels moments
Pour pouvoir contrôler ces 2 opérations, il y a 4 cas à
considérer:




Pas de dépendance
Dépendance qui exige un « stall »
Dépendance qui exige un « forward »
Dépendance dénouée d’elle-même
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: insertion de « stalls »
•
Lorsqu’on détecte un problème de dépendance
de données exigeant un « stall », il faut
simplement faire 3 choses:
 Émettre un no-op à l’étage EX
 Recirculer l’état de ID
 Conserver le même IF
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: insertion de « forward »
•
Pour détecter la nécessité de faire un « forward »,
il y a un certain nombre de cas qui doivent être
détectés dans le pipeline. Dans le DLX, il y a 10
cas à considérer pour les « forward sur les
entrées de l’ALU
Note: l’ajout de chemins de « forward » implique
que la taille des multiplexeurs des destinations
doit augmenter
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Cas à considérer pour le « forwarding » des
entrées de l’ALU du DLX
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: délais causés par des problèmes
de contrôle
• Lorsqu’on exécute un branchement (branch), l’impact sur la
•
•
performance peut être important. Dans le DLX tel que
présenté jusqu’à maintenant, la modification du PC
(lorsqu’un branchement est utilisé) ne se fait qu’à la fin de
l’étage MEM.
Le plus simple à faire est de retarder l’exécution jusqu’à ce
que le PC soit valide. Dans ce cas, on doit attendre 3
cycles d’horloge. Mais… C’ext très coûteux!
Pour réduire les délais des branchements, on peut faire 2
choses:
 Déterminer plus rapidement si le branchement est utilisé ou
non
 Calculer le PC résultant plus rapidement
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: réduction des délais des
branchements
•
La solution simple est de retarder l’exécution en
présence de branchements, mais elle est
coûteuse en termes de performance. Peut-on
faire mieux?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: réduction des délais de
branchement
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: réduction des délais de
branchement (2)
 On peut supposer que le branchement ne sera pas
effectué. Dans ce cas, on continue tout simplement de
lire des instructions pendant le calcul du branchement
 On peut supposer que le branchement sera effectué. On
commence à lire les instructions dès que la destination
du branchement est connue. Pour le DLX, ceci
n’apporte rien, puisqu’on sait simultanément la
destination et la décision de branchement
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: réduction des délais des
branchements (3)
•
On peut utiliser le branchement retardé (delayed
branch). Dans le DLX, puisqu’il y a au maximum
un délai d’une instruction avant de connaître la
décision de branchement, on utilise un « branchdelay slot ». C’est-à-dire que l’instruction qui suit
immédiatement celle de branchement est une
instruction commue aux deux possibilités de
branchement.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: branchement retardé
•
Il existe trois possibilités pour utiliser le
« branch-delay slot »:
 Intervertir l’instruction de branchement et celle qui la
précède. Ceci ne fonctionne que si cette instruction
n’affecte pas le branchement
 Utiliser la première instruction du branchement effectué.
Ne fonctionne que si cette instruction n’affecte pas le
branchement non-effectué
 Utiliser la première instruction du branchement noneffectué. Dual de la solution précédente.
•
Que choisir? Tout dépend…
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
L’utilisation du « branch-delay slot »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: Branchement retardé (2)
•
Que faire s’il n’y a pas d’instructions sans impact
sur l’autre branche?
•
Solution: on peut inclure dans le matériel un
système de reconnaissance et d’élimination des
mauvaises instructions de « branch-delay slot ».
Il suffit que le compilateur indique pour quelle
branche l’instruction du « branch-delay slot »
fonctionne. Le processeur n’a qu’à comparer la
prédiction du compilateur avec la décision réelle,
et canceller l’instruction si la prédiction est
invalide.
•
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: prédiction des branchements
•
Comment le compilateur peut-il décider des
branchements?
 Étude du comportement des programmes en général (%
général des branchements utilisés, vers l’avant et vers
l’arrière)
 Étude des résultats de l’exécution du programme
(souvent, système bi-modal)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Performance des « branch-delay slots »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Pipeline: pourquoi est-ce difficile à réaliser?
•
Difficulté majeure: comment gérer les exceptions
(interruptions)?
 Utilisation de périphériques
 Utilisation de services du système d’exploitation
 Exceptions arithmétiques
 Fautes de pages
 Fautes de segmentation
 Etc.
• Difficulté dérivée: exceptions multiples,
exceptions désordonnées
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline
Exemples d’exceptions
•
•
•
•
•
•
•
•
•
Requête d’entrée/sortie
Appel à une fonction de l’OS à partir d’une application
Debuggage: tracing, breakpoints
Dépassement arithmétique (overflow, underflow)
Faute de page
Mauvais accès à la mémoire
Instruction non-définie
Mauvais fonctionnement du matériel
Problème d’alimentation
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Systèmes Pipeline – opérations
multicycles
Nous avons vu jusqu’à maintenant comment faire
un pipeline simple, avec une seule unité
d’exécution.
Comment peut-on ajouter de multiples unités
d’exécution, certaines utilisant plus d’un coup
d’horloge pour faire leurs calculs?
Architecture des ordinateurs II – Frédéric Mailhot
Pipeline multicycles
DLX plus complet: plus d’unités d’exécution
•
Pour améliorer le DLX, nous allons maintenant
considérer l’ajout de plusieurs unités d’exécution
à l’ALU initial:
 Unité d’addition point flottant
 Unité de multiplication d’entiers
 Unité de multiplication point flottant
 Unite de division
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Le DLX avec des unités d’exécution
multiples
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline: Comment utiliser des opérations
multicycles?
•
Jusqu’à maintenant, nous n’avons considéré que
des opérations sur les entiers dans l’ALU.
Qu’arrive-t-il lorsqu’on incorpore des opérations
à point flottant?
 Ou bien on allonge le cycle de l’horloge
 Ou bien on augmente la taille du circuit
 On bien on permet d’intégrer des opérations multicycles dans le pipeline
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Le DLX avec des unité d’exécution point
flottant
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline: intégration des opérations
multicycles
•
But: permettre à un opérateur point flottant
d’utiliser plus d’un cycle d’horloge pour effectuer
son travail
•
Nous supposerons que l’unité point flottant peut
utiliser un nombre arbitraire de cycles (le nombre
exact dépend du type d’opération). Nous
supposerons de plus qu’il peut y avoir plusieurs
unités point flottant en parallèle
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline: intégration des opérations
multicycles (2)
•
Nous définissons 2 termes: la latence et
l’intervalle d’émission
 Latence: durée de l’opération totale par rapport à la
durée d’une opération ALU sur des entiers
 Intervalle d’émission (initiation interval): délai entre
l’émission de deux opérations du même type
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline: unités multicycles
•
Soient les 5 opérations suivantes: ALU entier,
accès à la mémoire, addition FP, multiplication
FP/entier, division FP, avec les paramètres
suivants:
Latence
Intervalle d’émission
ALU entier
0
1
Accès mémoire
1
1
Addition FP
3
1
Multiplication FP
6
1
Division FP
24
24
Quelles sont les implications de ce tableau?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline: implications multicycles
• Toutes les opérations peuvent commencer une instruction
•
•
•
•
par coup d’horloge, excepté la division. Celle-ci peut donc
causer des problèmes structuraux (structural hazards).
Dans ce cas, la seule solution est de faire des « stalls »
Puisque les opérations sont de durée variable, il se peut
que deux opérations atteignent l’étage d’écriture en même
temps
Il peut y avoir des problèmes de dépendance de données
de type WAW
Les instructions peuvent être complétées dans un ordre
différent que l’ordre d’émission
Puisque la latence est plus longue, il y aura plus de
problèmes de type RAW
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline multicycle: solution à l’écriture
multiple
•
Il est possible que deux instructions ou plus se
terminent en même temps, et tentent d’écrire
leurs résultats simultanément. Quoi faire?
 On pourrait ajouter des registres à plusieurs ports
d’entrée. On ajouterait beaucoup de matériel pour un
cas relativement peu fréquent. Et il faudrait de toutes
façons gérer l’écriture simultanée au même registre
 Une meilleure solution est de détecter l’utilisation
simultanée (on peut le faire dès l’étage ID), et réserver
l’utilisation de l’étage d’écriture. Comment? En
utilisant un registre à décalage pour réserver l’étage
MEM. De cette façon, on peut faire un « stall » de
l’opération problématique au niveau du ID.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline multicycles: sommaire du contrôle
1.
Vérification de problèmes de structure
(seulement avec le diviseur)
2.
3.
Vérification de problèmes de type RAW
Vérification de problèmes de type WAW
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Pipeline: quoi d’autre?
•
Que peut-on faire pour augmenter l’efficacité des
méthodes de pipeline?
•
Dans le MIPS 4000, on a utilisé plus d’étages de
pipeline (8 au lieu de 5). En répartissant les
opérations sur plus d’étages, il est possible
d’augmenter la vitesse de l’horloge.
•
Dans le R4000, on a ajouté des étages pour
l’accès à la mémoire. On appelle parfois cette
technique le « superpipelining »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Le MIPS R4000
•
Dans le MIPS R4000, les étages sont les suivants:
 IF / IS / RF / EX / DF / DS / TC / WB
• IF: première partie du « instruction fetch » (sélection du
PC, début d’accès)
• ID: deuxième partie du « instruction fetch » (lecture)
• RF: instruction decode, register fetch, cache hit?
•
•
•
•
•
EX: unité d’exécution
DF: data fetch
DS: deuxième partie de l’accès à la mémoire (lecture)
TC: cache hit?
WB: write back
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
Le MIPS R4000 (2)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Pipeline multicycles
La suite chez SGI
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Systèmes Superscalaires et VLIW
Parallélisme des instructions: quoi d’autre?
Avec le pipeline, nous avons vu une des
techniques de parallélisme des instructions (ILP
ou Instruction Level Parallelism). Que peut-on
faire de plus?
•VLIW (Very Large Instruction Word)
•Techniques superscalaires
Architecture des ordinateurs II – Frédéric Mailhot
Systèmes superscalaires et VLIW
Limites du pipelining, et comment les
dépasser
•
Pour une machine pipeline, on peut espérer au
mieux l’exécution d’une instruction par coup
d’horloge: il n’y a jamais plus d’une instruction
lue par coup d’horloge.
•
•
Rappel: temps CPU = IC * CPI * période de l’horloge
Pour augmenter la performance, on peut donc:
 Diminuer le nombre d’instructions (IC)
 Diminuer le CPI
 Diminuer la période de l’horloge
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
Limites du pipelining, et comment les
dépasser (2)
•
Une question fondamentale se pose:
1. Est-il préférable de tenter de simplifier le circuit pour
augmenter la fréquence de l’horloge?
2. Ou bien, doit-on rendre le circuit plus complexe pour tenter
de faire plus durant la même période d’horloge?
•
L’architecture RISC, avec le pipeline, procède de la
première approche. Les résultats sont probants, mais il
semble qu’on ne puisse réduire la période de l’horloge en
dessous d’un certain seuil.
•
D’où: il faut aussi considérer la deuxième approche (ce
que l’on fait avec le VLIW et le superscalaire).
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
Comment augmenter le ILP: en considérant
plus d’une instruction par coup d’horloge
•
L’idée de base ici est que la fréquence de
l’horloge ne peut être réduite indéfiniment, et
donc que pour une certaine durée d’horloge, on
doit réussir à faire plus de travail utile.
•
Comment faire? Lorsque nous arrivons à traiter
tout près d’une instruction par coup d’horloge, la
seule chose à faire de plus est de tenter de lire,
décoder et exécuter plus d’une instruction par
coup d’horloge…
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
Exécution de multiples instructions par
coup d’horloge: difficultés
• Lorsqu’on tente d’exécuter plus d’une instruction par coup
d’horloge, cela implique qu’au même moment plusieurs
instructions, qui ont été produites selon une certaine
séquence par le compilateur et apparaissent
séquentiellement en mémoire, doivent être séparées en des
chemins d’exécution parallèles
• Deux façons de faire cela:
 Décider au moment de la compilation des instructions qui
peuvent s’exécuter en parallèle (approche VLIW, EPIC)
 Décider au moment de l’exécution des séquences
d’instructions qui peuvent se faire en parallèle (approche
superscalaire)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
VLIW: qu’est-ce que c’est?
• VLIW: technique pour exécuter plusieurs opérations en
parallèle
• Méthode: on définit des groupes de plusieurs instructions,
qui sont lues, décodées et exécutées en parallèle. Chaque
groupe devient une « super-instruction » destinée à être lue
d’un bloc par le processeur VLIW
• Avantage: le compilateur décide des instructions à grouper
ensemble. Ceci élimine pour le processeur VLIW le fardeau
du scheduling des instructions (détermination des
instructions qui peuvent être exécutées en parallèle). Le
processeur est donc plus simple à concevoir, et par
conséquent peut être plus rapide.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
Superscalaire: qu’est-ce que c’est?
• Superscalaire: technique pour exécuter plusieurs
opérations en parallèle
• Méthode: lit en même temps des blocs d’instructions
séquentielles (compilées de façon traditionnelle), et le
processeur décide dynamiquement quelles instructions du
bloc peuvent s’exécuter en parallèle
• Avantage:
 On utilise un compilateur traditionnel pour produire le code
exécutable
 Le parallélisme est extrait de façon dynamique par le
processeur, donnant une plus grande marge de manœuvre
pour le scheduling des instructions
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
VLIW vs superscalaire: les enjeux
•
Le débat entre VLIW et superscalaire s’apparente
au débat CISC/RISC du début des années ’80:
simplicité du matériel (et performance améliorée)
vs simplicité du compilateur
•
Selon vous, lequel devrait gagner la bataille?
 VLIW?
 Superscalaire?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
Le vainqueur apparent: le VLIW
•
Comme le RISC a pris le dessus sur le CISC
parce que le matériel est plus simple à réaliser et
donc plus rapide, le VLIW devrait produire des
systèmes plus performants
•
Évidemment, les compilateurs devraient être
améliorés, mais le type d’améliorations requises
(détection de parallélisme au niveau des
instructions) est déjà possible.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
VLIW: l’architecture du futur?
• Mais… il y a un problème important avec le VLIW: c’est le
compilateur qui prend en charge toutes les dépendances
entre les instructions, et qui les résout lors de la
compilation. D’où deux constats importants:
1. Le compilateur est lié intimement à l’implémentation de
l’architecture. Si celle-ci change, le compilateur (et donc le
code) doit changer. Que fait-on avec nos « vieux » logiciels
lorsqu’on change de machine?
2. La résolution de conflits se fait lors de la compilation. Elle
doit donc être conservatrice. Dans un autre type
d’architecture (i.e. le superscalaire) on fait cette résolution de
façon dynamique. D’où plus de flexibilité et potentiellement
une amélioration de la performance.
• Autre limitation du VLIW: puisque le code doit être libre de
dépendances, il est presque impossible de l’écrire en
langage assembleur
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires et VLIW
La suite: le superscalaire
•
Nous couvrirons principalement les techniques
superscalaires dans ce qui suit. Pourquoi?
 Le VLIW est une extension relativement simple du
pipeline (en théorie, on pourrait imaginer qu’on ne fait
que mettre un ensemble de machines pipelines
indépendantes en parallèle).
 Pour ce qui est du superscalaire, la gestion dynamique
des dépendances entre instructions est beaucoup plus
sophistiquée, et exige qu’on s’y arrête pour comprendre
ce qui se passe.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Systèmes Superscalaires
Comment peut-on déterminer de façon
dynamique, au niveau du processeur, quelles sont
les instructions qui peuvent s’exécuter en
parallèles?
Dans ce qui suit nous étudierons l’architecure
superscalaire générale, et nous examinerons en
particulier deux méthodes utilisées pour extraire
dynamiquement le parallélisme des instructions:
•La méthode « scoreboard »
•La méthode de Tomasulo
Architecture des ordinateurs II – Frédéric Mailhot
Systèmes superscalaires
Architecture superscalaire: introduction
•
•
Idée derrière l’architecture superscalaire:
émission de plus d’une instruction par coup
d’horloge, à partir de code compilé de façon
traditionnelle
Mécanismes sous-jacents:
 Décodage parallèle
 Gestion d’instructions multiples
• Émission d’instructions multiples
• Exécution parallèle des instructions
• Préservation de l’ordre des instructions
 Préservation de l’ordre des exceptions
© 2004 Frédéric Mailhot
Utilisation
du scoreboard
ou
de la méthode
de Tomasulo
Université de Sherbrooke
Systèmes superscalaires
Architecture superscalaire: Gestion
d’instructions multiples
• Puisqu’il y a plusieurs instructions émises en même temps,
les problèmes de structure, de dépendances de données
(RAW, WAW) et de contrôle seront exacerbés
• Il est impératif de gérer efficacement l’émission des
instructions (structure, dépendances de données)
 Scoreboard
 Tomasulo
• Il faut minimiser les délais causés par le branchements
(contrôle)
 Techniques de prévision et de spéculation liées aux
branchements
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: technique du scoreboard
•
•
Origine: Control Data CDC 6600, en… 1963!
Technique utilisée au départ pour maintenir un
taux d’exécution de une instruction par coup
d’horloge, en absence de problèmes de structure
 Extension: utilisation de multiples instructions par coup
d’horloge
•
Idée: si une instruction est arrêtée (« stalled »),
on peut utiliser une instruction subséquente si
elle ne dépend pas de celle qui est arrêtée
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: technique du scoreboard (2)
•
Le scoreboard est un tableau interne qui contient
toute l’information nécessaire (au sujet des
instructions présentes dans le processeur) pour
décider quand et où exécuter chacune des
instructions
• On y conserve l’état de chacune des unités
d’exécution, ainsi que le statut de chacun des
registres
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: architecture pour la méthode
du scoreboard
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: technique du scoreboard (3)
•
Pour chaque unité d’exécution, on doit connaître:




Si elle est en opération
L’opération qui y est effectuée
Le nom des registres de destination et des opérandes
Le nom des unités d’exécution qui doivent produire les
valeurs requises pour les registres des opérandes (si
les valeurs courantes ne sont pas prêtes)
 L’état des registres des opérandes
•
Le scoreboard utilise toutes ces valeurs pour
décider à quel moment les instructions peuvent
être exécutées
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
LD
F6,34(R2)
LD
F2, 45(R3)
Opérandes lus
Exécution
Écriture
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
Qj
Qk
Rj
Rk
ALU
Mult1
Mult2
Add
Div
Statut des registres de résultats
F0
F2
F4
F6
F8
F10
F12
…
F30
UE
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
LD
F6,34(R2)
LD
F2, 45(R3)
Émise
Opérandes lus
l
l
Exécution
Écriture
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
ALU
oui
Load
F6
R2
Mult1
non
Mult2
non
Add
non
Div
non
Fk
Qj
Qk
Rj
Rk
non
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
F10
F12
…
F30
ALU
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
LD
F6,34(R2)
LD
F2, 45(R3)
Émise
Opérandes lus
Exécution
l
l
l
Écriture
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
ALU
oui
Load
F6
R2
Mult1
non
Mult2
non
Add
non
Div
non
Fk
Qj
Qk
Rj
Rk
non
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
F10
F12
…
F30
ALU
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
LD
F6,34(R2)
LD
F2, 45(R3)
Émise
Opérandes lus
Exécution
Écriture
l
l
l
l
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
ALU
non
Mult1
non
Mult2
non
Add
non
Div
non
Op
Fi
Fj
Fk
Qj
Qk
Rj
Rk
Statut des registres de résultats
F0
F2
F4
F6
F8
F10
F12
…
F30
UE
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
l
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
ALU
oui
Load
F2
R3
Mult1
non
Mult2
non
Add
non
Div
non
Fk
Qj
Qk
Rj
Rk
non
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
F10
F12
…
F30
ALU
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
l
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
ALU
oui
Load
F2
R3
Mult1
oui
Mul
F0
F2
Mult2
non
Add
non
Div
non
Fk
Qj
Qk
Rj
Rk
non
F4
ALU
non
oui
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
F10
F12
…
F30
ALU
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
l
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
oui
Load
F2
R3
Mult1
oui
Mul
F0
F2
F4
Mult2
non
Add
oui
Sub
F8
F6
F2
Div
non
Qj
Qk
Rj
Rk
non
ALU
ALU
non
oui
oui
non
Statut des registres de résultats
F0
UE
Mult1
F2
ALU
F4
F6
F8
F10
F12
…
F30
Add
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
l
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
oui
Load
F2
R3
Mult1
oui
Mul
F0
F2
F4
Mult2
non
Add
oui
Sub
F8
F6
F2
Div
oui
Div
F10
F0
F6
Qj
Qk
Rj
Rk
non
ALU
ALU
Mult1
non
oui
oui
non
non
oui
Statut des registres de résultats
F0
UE
Mult1
F2
ALU
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
RAW:
LD-> MULTD, SUBD
MULTD-> DIVD
SUBD-> ADDD
WAR:
DIVD-> ADDD
Struct:
SUBD-> ADDD
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
l
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
oui
Load
F2
R3
Mult1
oui
Mul
F0
F2
F4
Mult2
non
Add
oui
Sub
F8
F6
F2
Div
oui
Div
F10
F0
F6
Qj
Qk
Rj
Rk
non
ALU
ALU
Mult1
non
oui
oui
non
non
oui
Statut des registres de résultats
F0
UE
Mult1
F2
ALU
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
oui
Load
F2
R3
Mult1
oui
Mul
F0
F2
F4
Mult2
non
Add
oui
Sub
F8
F6
F2
Div
oui
Div
F10
F0
F6
Qj
Qk
Rj
Rk
non
ALU
ALU
Mult1
non
oui
oui
non
non
oui
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
DIVD
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
non
Mult1
oui
Mul
F0
F2
Mult2
non
Add
oui
Sub
F8
Div
oui
Div
F10
Qj
Qk
Rj
Rk
F4
non
non
F6
F2
non
non
F0
F6
non
oui
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
non
Mult1
oui
Mul
F0
F2
Mult2
non
Add
oui
Sub
F8
Div
oui
Div
F10
Qj
Qk
Rj
Rk
F4
non
non
F6
F2
non
non
F0
F6
non
oui
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
F10,F0,F6
l
ADDD F6,F8,F2
l
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
non
Mult1
oui
Mul
F0
F2
Mult2
non
Add
oui
Addd
F6
Div
oui
Div
F10
Qj
Qk
Rj
Rk
F4
non
non
F8
F2
non
non
F0
F6
non
oui
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
RAW:
MULTD-> DIVD
WAR:
DIVD-> ADDD
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
l
l
F10,F0,F6
l
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
non
Mult1
oui
Mul
F0
F2
Mult2
non
Add
oui
Addd
F6
Div
oui
Div
F10
Qj
Qk
Rj
Rk
F4
non
non
F8
F2
non
non
F0
F6
non
oui
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
l
l
F10,F0,F6
l
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
non
Mult1
oui
Mul
F0
F2
Mult2
non
Add
oui
Addd
F6
Div
oui
Div
F10
Qj
Qk
Rj
Rk
F4
non
non
F8
F2
non
non
F0
F6
non
oui
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
l
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
non
Mult1
non
Mult2
non
Add
oui
Addd
F6
F8
Div
oui
Div
F10
F0
Qj
Qk
Rj
Rk
F2
non
non
F6
oui
oui
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
l
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
Op
Fi
Fj
Fk
ALU
non
Mult1
non
Mult2
non
Add
oui
Addd
F6
F8
Div
oui
Div
F10
F0
Qj
Qk
Rj
Rk
F2
non
non
F6
non
non
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
Add
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
l
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
ALU
non
Mult1
non
Mult2
non
Add
non
Div
oui
Op
Fi
Fj
Fk
Div
F10
F0
F6
Qj
Qk
Rj
Rk
non
non
Statut des registres de résultats
F0
F2
F4
F6
F8
UE
F10
F12
…
F30
Div
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
l
l
l
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
ALU
non
Mult1
non
Mult2
non
Add
non
Div
oui
Op
Fi
Fj
Fk
Div
F10
F0
F6
Qj
Qk
Rj
Rk
non
non
Statut des registres de résultats
F0
F2
F4
F6
F8
UE
F10
F12
…
F30
Div
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de scoreboard
Statut des instructions
Instructions
Émise
Opérandes lus
Exécution
Écriture
LD
F6,34(R2)
l
l
l
l
LD
F2, 45(R3)
l
l
l
l
MULTD F0,F2,F4
l
l
l
l
SUBD F8,F6,F2
l
l
l
l
DIVD
l
l
l
l
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
Statut des unités d’exécution
Nom
Utilisé
ALU
non
Mult1
non
Mult2
non
Add
non
Div
non
Op
Fi
Fj
Fk
Qj
Qk
Rj
Rk
Statut des registres de résultats
F0
F2
F4
F6
F8
F10
F12
…
F30
UE
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: méthode de Tomasulo
•
Origine: IBM System/ 360 modèle 91 en… 1967!
 Inventée par Robert Tomasulo
•
•
Technique utilisée pour éliminer les « fausses »
dépendances qui proviennent de l’utilisation des
mêmes registres à des fins différentes. La
méthode de Tomasulo est une extension de la
méthode du scoreboard
Idée: Lorsqu’il y a de fausses dépendances de
données parce qu’on réutilise les mêmes
registres, on n’a qu’à « renommer » les registres
(register renaming)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: méthode de Tomasulo (2)
• On utilise des étiquettes sur les données pour indiquer
•
•
•
d’où elles doivent provenir lorsque le registre d’origine des
opérandes n’est pas encore valide
On utilise un bus de données commun (Common Data Bus,
CDB) qui transporte à la fois les données et l’étiquette de
leur unité d’exécution d’origine
Tous les endroits qui attendent une donnée « écoutent » le
CDB et attrapent les données qui leur sont destinées
On utilise des « stations de réservation » pour conserver
les instructions en attente d’exécution. Il peut y avoir une
station de réservation par unité d’exécution, ou une par
type d’unité d’exécution, ou même une seule pour toutes
les unités d’exécution
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: architecture pour la méthode
de Tomasulo
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: différences entre les
méthodes de Tomasulo et scoreboard
•
Tomasulo:
 Pas de vérification des cas de WAW et/ou WAR
(l’utilisation d’étiquettes de provenance élimine ces
problèmes)
 Utilisation du CDB pour obtenir directement les
résultats, sans avoir à passer par les registres
 Load/Store considérés comme des unités d’exécution
au même titre que les additions/multiplications/divisions
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
LD
F6,34(R2)
LD
F2, 45(R3)
Émise
Exécution
Écriture
l
l
l
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Add1
non
Add2
non
Mult1
non
Mult2
non
Div1
non
Op
Vj
Vk
Qj
Qk
Statut des registres de résultats
F0
F2
F4
F6
F8
F10
F12
…
F30
UE
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
 Résultat attendu de Load2
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Add1
non
Add2
non
Mult1
non
Mult2
non
Div1
non
Op
Vj
Vk
Qj
Qk
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
F10
F12
…
F30
Load2
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
SUBD F8,F6,F2
DIVD
F10,F0,F6
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Add1
non
Add2
non
Mult1
oui
Mult2
non
Div1
non
Op
Vj
MULTD
Vk
Qj
Reg(F4)
Load2
Qk
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
F10
F12
…
F30
Load2
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
F10,F0,F6
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Op
Vj
Add1
oui
SUBD
Reg(F6)
Add2
non
Mult1
oui
Mult2
non
Div1
non
Vk
Qj
Qk
Load2
MULTD
Reg(F4)
Load2
Statut des registres de résultats
F0
UE
Mult1
F2
Load2
F4
F6
F8
F10
F12
…
F30
Add1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
l
F10,F0,F6
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Op
Vj
Add1
oui
SUBD
Reg(F6)
Add2
non
Mult1
oui
Mult2
non
Div1
oui
Vk
Qj
Qk
Load2
MULTD
Reg(F4)
Load2
DIVD
Reg(F6)
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
Load2
F4
F6
F8
Add1
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div1
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
l
LD
F6,34(R2)
l
l
LD
F2, 45(R3)
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
l
F10,F0,F6
l
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Qj
Add1
oui
SUBD
Reg(F6)
Add2
oui
ADDD
Mult1
oui
MULTD
Reg(F4)
Load2
Mult2
non
Div1
oui
DIVD
Reg(F6)
Mult1
Qk
Load2
Add1
Load2
Statut des registres de résultats
F0
UE
Mult1
F2
Load2
F4
F6
F8
Add2
Add1
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div1
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
SUBD F8,F6,F2
l
DIVD
l
F10,F0,F6
l
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Qj
Add1
oui
SUBD
Reg(F6)
Add2
oui
ADDD
Mult1
oui
MULTD
Reg(F4)
Load2
Mult2
non
Div1
oui
DIVD
Reg(F6)
Mult1
Qk
Load2
Add1
Load2
Statut des registres de résultats
F0
UE
Mult1
F2
Load2
F4
F6
F8
Add2
Add1
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div1
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
DIVD
l
F10,F0,F6
l
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Qj
Add1
oui
SUBD
Reg(F6)
Val(F2)
Add2
oui
ADDD
Mult1
oui
MULTD
Mult2
non
Div1
oui
Val(F2)
Val(F2)
Qk
Add1
Reg(F4)
DIVD
Reg(F6)
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add2
Add1
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div1
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
DIVD
l
F10,F0,F6
l
l
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Qj
Add1
oui
SUBD
Reg(F6)
Val(F2)
Add2
oui
ADDD
Mult1
oui
MULTD
Mult2
non
Div1
oui
Val(F2)
Val(F2)
Qk
Add1
Reg(F4)
DIVD
Reg(F6)
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add2
Add1
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div1
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
DIVD
l
F10,F0,F6
l
ADDD F6,F8,F2
l
l
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Add1
non
Add2
oui
ADDD
Val(F8)
Val(F2)
Mult1
oui
MULTD
Val(F2)
Reg(F4)
Mult2
non
Div1
oui
DIVD
Qj
Reg(F6)
Qk
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add2
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div1
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
SUBD F8,F6,F2
l
l
l
DIVD
l
l
l
F10,F0,F6
l
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Add1
non
Add2
oui
ADDD
Val(F8)
Val(F2)
Mult1
oui
MULTD
Val(F2)
Reg(F4)
Mult2
non
Div1
oui
DIVD
Qj
Reg(F6)
Qk
Mult1
Statut des registres de résultats
F0
UE
Mult1
F2
F4
F6
F8
Add2
© 2004 Frédéric Mailhot
F10
F12
…
F30
Div1
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
l
SUBD F8,F6,F2
l
l
l
DIVD
l
l
l
F10,F0,F6
l
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Add1
non
Add2
non
Mult1
oui
Mult2
non
Div1
oui
Op
Vj
Vk
MULTD
Val(F2)
Reg(F4)
DIVD
Qj
Reg(F6)
Qk
Mult1
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
Mult1
F10
F12
…
F30
Div1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
l
SUBD F8,F6,F2
l
l
l
DIVD
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
l
Stations de réservation
Nom
Utilisé
Add1
non
Add2
non
Mult1
non
Mult2
non
Div1
oui
Op
Vj
Vk
Qj
DIVD
Val(F0)
Reg(F6)
Qk
Statut des registres de résultats
F0
F2
F4
F6
F8
UE
F10
F12
…
F30
Div1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
l
SUBD F8,F6,F2
l
l
l
DIVD
l
l
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Add1
non
Add2
non
Mult1
non
Mult2
non
Div1
oui
Op
Vj
Vk
Qj
DIVD
Val(F0)
Reg(F6)
Qk
Statut des registres de résultats
F0
F2
F4
F6
F8
UE
F10
F12
…
F30
Div1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
LD
F6,34(R2)
l
l
l
LD
F2, 45(R3)
l
l
l
MULTD F0,F2,F4
l
l
l
SUBD F8,F6,F2
l
l
l
DIVD
l
l
l
l
l
l
F10,F0,F6
ADDD F6,F8,F2
Stations de réservation
Nom
Utilisé
Add1
non
Add2
non
Mult1
non
Mult2
non
Div1
non
Op
Vj
Vk
Qj
Qk
Statut des registres de résultats
F0
F2
F4
F6
F8
F10
F12
…
F30
UE
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: Exemple de la puissance de
la méthode de Tomasulo
•
Soit une portion de code où les éléments d’un
tableau doivent tous être multipliés par une
certaine constante:
Loop:
LD
F0, 0(R1)
MULTD F4, F0, F2
SD
0(R1), F4
SUBI
R1, R1, #8
BNEZ
R1, Loop
; Branchement si R1 != 0
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: Exemple de la puissance de
la méthode de Tomasulo (2)
•
Dans la boucle qu’on vient de voir, l’utilisation
répétitive de F0, F4 et R1 fait qu’on ne peut
exécuter qu’une itération à la fois si rien de
spécial n’est fait
•
On peut résoudre ce problème au niveau du
compilateur, et faire ce qu’on appelle du « loop
unrolling », c’est-à-dire utiliser différents
registres pour éliminer les dépendances entre les
itérations successives
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: Exemple de la puissance de
la méthode de Tomasulo (3)
• Exemple de boucle « déroulée » (unrolled loop):
LD
MULTD
SD
SUBI
LD
MULTD
SD
SUBI
LD
MULTD
…
F0, 0(R1)
F4, F0, F2
0(R1), F4
R1, R1, #8
F6, 0(R1)
F8, F6, F2
0(R1), F8
R1, R1, #8
F10, 0(R1)
F12, F10, F2
• Cette méthode fonctionne au niveau du compilateur si:
 On connaît le nombre d’itération au moment de la compilation
 Il y a assez de registres dans la machine pour contenir toutes
les itérations qu’on désire exécuter en parallèle
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: Exemple de la puissance de
la méthode de Tomasulo (4)
• Au lieu de faire le travail de déroulement des boucles au
niveau de la compilation, on peut le faire dynamiquement
avec la méthode de Tomasulo!
 Il n’est plus nécessaire de connaître le nombre d’itérations
lors de la compilation
 Le nombre de registres de la machine n’est plus un goulot
d’étranglement
• Dans ce qui suit, on fera une simulation de ce qui se passe
avec le système de Tomasulo. On supposera que les
branchements n’existent pas (i.e., qu’ils sont prédits
correctement)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
LD
F0, 0(R1)
Émise
Exécution
l
l
Écriture
MULTD F4, F0, F2
SD
0(R1), F4
LD
F0, 0(R1)
MULTD F4, F0, F2
SD
0(R1), F4
Stations de réservation
Nom
Utilisé
Store1
non
Store2
non
Mult1
non
Mult2
non
Div1
non
Op
Vj
Vk
Qj
Qk
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
F10
F12
…
F30
Load1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
F0, 0(R1)
l
l
MULTD F4, F0, F2
l
LD
SD
0(R1), F4
LD
F0, 0(R1)
Écriture
MULTD F4, F0, F2
SD
0(R1), F4
Stations de réservation
Nom
Utilisé
Store1
non
Store2
non
Mult1
oui
Mult2
non
Div1
non
Op
Vj
MULTD
Vk
Qj
Reg(F2)
Load1
Qk
Statut des registres de résultats
F0
UE
Load1
F2
F4
F6
F8
F10
F12
…
F30
Mult1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
F0, 0(R1)
l
l
MULTD F4, F0, F2
l
SD
0(R1), F4
l
LD
F0, 0(R1)
LD
Écriture
MULTD F4, F0, F2
SD
0(R1), F4
Stations de réservation
Nom
Utilisé
Op
Store1
oui
SD
Store2
non
Mult1
oui
Mult2
non
Div1
non
Vj
Vk
Qj
Qk
Mult1
MULTD
Reg(F2)
Load1
Statut des registres de résultats
F0
UE
Load1
F2
F4
F6
F8
F10
F12
…
F30
Mult1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
F0, 0(R1)
l
l
MULTD F4, F0, F2
l
SD
0(R1), F4
l
LD
F0, 0(R1)
l
LD
Écriture
l
MULTD F4, F0, F2
SD
0(R1), F4
Stations de réservation
Nom
Utilisé
Op
Store1
oui
SD
Store2
non
Mult1
oui
Mult2
non
Div1
non
Vj
Vk
Qj
Qk
Mult1
MULTD
Reg(F2)
Load1
Statut des registres de résultats
F0
UE
Load2
F2
F4
F6
F8
F10
F12
…
F30
Mult1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
F0, 0(R1)
l
l
MULTD F4, F0, F2
l
SD
0(R1), F4
l
LD
F0, 0(R1)
l
LD
l
l
MULTD F4, F0, F2
SD
Écriture
0(R1), F4
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Qj
Store1
oui
SD
Store2
non
Mult1
oui
MULTD
Reg(F2)
Load1
Mult2
oui
MULTD
Reg(F2)
Load2
Div1
non
Qk
Mult1
Statut des registres de résultats
F0
UE
Load2
F2
F4
F6
F8
F10
F12
…
F30
Mult2
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
F0, 0(R1)
l
l
MULTD F4, F0, F2
l
SD
0(R1), F4
l
LD
F0, 0(R1)
l
LD
MULTD F4, F0, F2
l
SD
l
0(R1), F4
Écriture
l
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Qj
Store1
oui
SD
Mult1
Store2
oui
SD
Mult2
Mult1
oui
MULTD
Reg(F2)
Load1
Mult2
oui
MULTD
Reg(F2)
Load2
Div1
non
Qk
Statut des registres de résultats
F0
UE
Load2
F2
F4
F6
F8
F10
F12
…
F30
Mult2
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
F0, 0(R1)
l
l
l
MULTD F4, F0, F2
l
SD
0(R1), F4
l
LD
F0, 0(R1)
l
l
l
LD
MULTD F4, F0, F2
l
SD
l
0(R1), F4
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Qj
Store1
oui
SD
Mult1
Store2
oui
SD
Mult2
Mult1
oui
MULTD
Val(Load1)
Reg(F2)
Mult2
oui
MULTD
Val(Load2)
Reg(F2)
Div1
non
Qk
Statut des registres de résultats
F0
UE
F2
F4
F6
F8
F10
F12
…
F30
Mult2
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: 2e exemple de Tomasulo
Statut des instructions
Instructions
Émise
Exécution
Écriture
F0, 0(R1)
l
l
l
MULTD F4, F0, F2
l
l
l
SD
0(R1), F4
l
l
LD
F0, 0(R1)
l
l
l
MULTD F4, F0, F2
l
l
l
SD
l
l
LD
0(R1), F4
Stations de réservation
Nom
Utilisé
Op
Vj
Vk
Store1
oui
SD
Val(Mult1)
Store2
oui
SD
Val(Mult2) = Reg(F4)
Mult1
non
Mult2
non
Div1
non
Qj
Qk
Statut des registres de résultats
F0
F2
F4
F6
F8
F10
F12
…
F30
UE
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: Tomasulo VS Scoreboard
• Tomasulo:
 Dénoue automatiquement les problèmes de WAR et WAW
 Utilisation du CDB élimine le délai de lecture des registres
après qu’un résultat est obtenu (lecture directe sur le bus)
 Plus complexe en termes de matériel: bus plus large (multiples
données+étiquettes), nécéssité de mémoire associative
distribuée
• Scoreboard:
 Plus simple à réaliser
 Ne peut résoudre les problèmes de WAW qu’avec des
« stalls »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
Superscalaire: Que choisir – Tomasulo ou
Scoreboard?
•
Pour une machine assez simple, qui n’émet
qu’une instruction par coup d’horloge, la
complexité supplémentaire de
Tomasulo est probablement trop importante pour
en valoir la peine (un bon compilateur peut
probablement faire aussi bien)
•
Pour une machine complexe, qui supporte
plusieurs émissions par coup d’horloge, où il est
possible que l’utilisation des registres cause des
problèmes de WAW, Tomasulo est probablement
le meilleur choix
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
La quête de la performance: récapitulation
• Nous avons vu jusqu’ici que pour améliorer la performance
des processeurs, on peut:
 Utiliser le pipeline (instructions découpées en petits éléments
qu’on peut exécuter en parallèle, amélioration de la période de
l’horloge)
 Utiliser plusieurs unités d’exécution en parallèle, qui ont
possiblement des temps de latence différents (permet l’ajout
de matériel dédié pour produire plus rapidement des
multiplications, divisions et additions point flottant)
 Utiliser des méthodes superscalaires pour parvenir à exécuter
plus d’une instruction par coup d’horloge
• Scoreboard
• Tomasulo
© 2004 Frédéric Mailhot
Université de Sherbrooke
Systèmes superscalaires
La quête de la performance:
récapitulation (2)
•
Nous avons aussi vu qu’il existe d’autres
facteurs qui influencent la performance:
1. Les branchements
2. L’accès à la mémoire (lecture/écriture)
•
Pour la suite, nous verrons ce qu’on peut faire
d’abord pour le premier facteur (les
branchements), et ensuite pour l’accès à la
mémoire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Gestion des branchements
L’un des goulots d’étranglements des
processeurs moderne est ce qui se passe en
présence de branchements
Que peut-on faire pour accélérer l’exécution du
code en présence de branchements
conditionnels?
Architecture des ordinateurs II – Frédéric Mailhot
Gestion des branchements
Pourquoi la gestion des branchements est
de première importance dans les
architectures superscalaires?
• Nous savons déjà que dans une simple machine pipeline
comme le DLX, chaque branchement causera possiblement
un délai de 2 coups d’horloge.
 En conséquence, il y aura dans ce cas deux instructions qui
devront être éliminées, et le CPI augmentera en conséquence
• Dans une machine superscalaire, le problème est encore
plus aigu: à chaque coup d’horloge, on lit maintenant
plusieurs instructions (de 2 à 8 instructions simultanées)
 Un délai de 2 coups d’horloge peut donc maintenant
représenter plus d’une dizaine d’instructions
 L’impact sur le CPI est donc encore plus important pour une
machine superscalaire que pour un simple pipeline
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction des branchements
•
Nous avons vu déjà qu’il est possible d’utiliser
des prédictions statiques (décidées au niveau du
compilateur) pour améliorer la performance des
branchements
•
Pourquoi ne pas tenter de faire des prévisions
dynamiques (i.e. basée sur l’éxécution actuelle du
code)?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Accélérer les branchements: les choix
possibles
• Déterminer plus tôt si le branchement sera pris ou non
(branch resolution)
 Utiliser des prédictions de branchement et l’exécution
spéculative
 Pouvoir revenir en arrière si la prédiction s’avère fausse
• Déterminer plus tôt la destination du branchement
 Garder dans un tampon l’adresse de destination du
branchement, pour utilisation future
• Permettre de gérer plusieurs branchements imbriqués
 Il peut arriver qu’un branchement ne soit toujours pas résolu
lorsqu’un 2e branchement doit être traité
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Prédiction 1-bit
• 1ère idée (simple): on utilise un registre à 1 bit pour
capturer la décision du dernier branchement. Lors du
traitement de toute instruction de branchement, on met le
registre à 1 si le branchement a été effectué, et à 0 si le
branchement n’a pas été effectué.
• Chaque fois qu’on rencontre une instruction de
branchement, on utilise le registre de prédiction pour tenter
de deviner la décision de branchement. Évidemment, la
prédiction doit être validée plus tard par la vraie décision de
branchement! (Et si la prédiction était mauvaise, on doit
pouvoir éliminer les instructions inappropriées et
commencer à lire et exécuter les bonnes instructions)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Prédiction 1-bit (2)
• Le système simple qu’on vient de présenter va bien
•
•
•
fonctionner tant qu’on a affaires au même branchement,
mais la prévision n’aura pas de sens dès qu’on passera à
une autre instruction de branchement…
Que peut-on faire?
On peut utiliser une petite mémoire de 2^k bits, et pour
chaque instruction de branchement, on utilise les k bits
d’adresse les plus petits de cette instruction pour accéder à
la mémoire prédictive. (Idée connexe: hash de l’adresse sur
k bits)
On utilise maintenant 2^k bits au lieu d’un seul bit, mais la
prévision est valable pour un ensemble plus grand de
branchements (on appelle tout de même cette technique
« prédiction à 1-bit »)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
problèmes avec la prédiction 1-bit
• Supposons une boucle qui s’exécute 10 fois, et qui est elle-
•
•
même ré-exécutée répétitivement. Quel sera le
pourcentage de succès de notre prédicteur à 1 bit en
régime permanent?
Évidemment, le dernier branchement de la boucle
(lorsqu’on sort après 10 itérations) est toujours mal prédit.
De plus, le branchement de sortie de la boucle va modifier
la valeur de notre prédicteur à 1-bit (il va maintenant prédire
qu’on sort de la boucle), et donc la prochaine fois qu’on
exécutera cette boucle, le premier branchement sera aussi
mal prédit.
Donc, on se trompe 2 fois sur dix (20% d’erreur)! Comment
faire mieux?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Prédiction 2-bits
•
Pour diminuer le pourcentage d’erreur de notre
prédiction, on peut utiliser 2 bits au lieu de 1.
•
Avec 2 bits, on peut représenter 4 états, ce qui
nous permet de définir une petite machine à états
finis. Par exemple, on peut définir un compteur
avec saturation:
branche
ne branche pas
(11)
branche
ne branche pas
(01)
ne branche pas
(10)
branche
branche
ne branche pas
branche
branche
Note: en blanc, prédiction en orange, valeur calculée (réelle)
© 2004 Frédéric Mailhot
(00)
ne branche pas
ne branche pas
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Prédiction 2-bits
•
La machine à états finis précédente va
doucement évoluer vers l’un des deux pôles, et
ensuite va tendre à rester dans cet état pendant
longtemps. Chez SUN, pour le Ultra-SPARC-I, on
a utilisé une version légèrement modifiée de cette
machine à états finis:
ne branche pas
branche
ne branche pas
(11)
branche
(10)
branche
branche
ne branche pas
(01)
ne branche pas
(00)
ne branche pas
branche
branche
ne branche pas
Note: en blanc, prédiction en orange, valeur calculée (réelle)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Efficacité de la prédiction 2-bits
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Prédiction n-bits?
•
On vient de voir qu’en passant d’un prédicteur à
1-bit à un prédicteur à 2-bits, on diminue le
pourcentage d’erreur. On peut continuer dans le
même sens, et passer à un prédicteur a k-bit…
Est-ce une bonne idée?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Prédiction n-bits?
•
© 2004 Frédéric Mailhot
Réponse: non, les
résultats sont
essentiellement les
mêmes qu’avec un
prédicteur à 2-bits
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
problèmes avec la prédiction 2-bits
•
La prédiction à 2-bits est plus efficace que la
prédiction à 1-bit, mais elle n’est tout de même
pas si bonne. Avec les benchmarks entiers, ce
type de prédiction se trompe plus de 11% du
temps.
• Quoi faire?
 Augmenter la taille de la mémoire? Pas très efficace
 Tenir compte de la corrélation entre les branchements?
Oui! (Idée de Pan, So et Rameh, 1992)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
problèmes de corrélation
•
Soit le code suivant:
if (d == 0) d = 1;
if (d == 1) …
•
Ceci devient:
L1:
L2:
•
BNEZ R1, L1
ADDI R1, R0, 1
SUBI R3, R1, 1
BNEZ R3, L2
…
branche b1 (d != 0)
branche b2 (d != 1)
Supposons que le code est exécuté avec les
valeurs d = 2,0,2,0. Qu’est-ce qui arrive à nos
prédictions?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
utilisation de la corrélation
• Puisque les branchements sont souvent dépendants les
uns des autres, comment peut-on faire pour en tenir
compte lors de notre prédiction?
• Nous utiliserons un registre à décalage de « m » bits pour
conserver les valeurs des « m » derniers branchements.
Ces « m » bits seront ensuite utilisés en partie pour
adresser notre tampon de prédiction (le lire, et lorsque la
décision définitive de branchement est prise, l’écrire)
• Le reste de l’adresse utilisée pour lire le tampon proviendra
des k bits les plus faibles de l’adresse de l’instruction de
branchement que nous sommes à prédire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
utilisation de la corrélation (2)
•
•
•
Si on utilise les « m » derniers branchements
(leurs valeurs, 1 ou 0, étant conservées dans un
registre à décalage de « m » bits)
Si on utilise un prédicteur à n-bits dans notre
tampon de prédiction
On dit que le prédicteur basé sur la corrélation
est un prédicteur (m,n)
 Notre prédicteur 2-bits vu auparavant est donc un (0,2),
puisqu’il n’utilisait aucune historique
 Les prédicteurs (2,2) donnent habituellement de bons
résultats
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
utilisation de la corrélation (3)
Pattern History Table (PHT)
Branch history register (BHR)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
utilisation de la corrélation (4)
•
Le prédicteur (2,2)
donne des résultats
supérieurs ou égaux à
ceux de prédicteurs 2bits utilisant
beaucoup plus de
mémoire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
corrélation différente
•
•
•
(Yeh et Patt, en 1992, 1993): Lorsqu’on parle de
corrélation (m,n) (m choix de branchements, n
bits de prédiction), doit-on considérer les « m »
choix de branchements globalement ou
localement?
De même, la mémoires des « n » bits de
prédiction doit-elle être globale ou locale?
En d’autres mots, aurait-on intérêt à produire
localement ou globalement l’information dans le
BHR (Branch History Register)? Même question
pour le PHT (Pattern History Table)?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
corrélation différente (2)
•
On appellera prédicteur XAy des systèmes de
prédiction de branchement Adaptifs (le A du
milieu) où le type de BHR (Branch History
Register) est « X », et le type de PHT (Pattern
History Table) est « y ».
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
corrélation différente (3)
•
On définit les types de prédicteurs XAy suivants:






•
G: BHR global (unique)
g: PHT global (unique)
P: BHR local, lu/écrit par adresse complète
p: PHT local, lu/écrit par adresse complète
S: BHR utilisant un sous-ensemble des bits d’adresse
s: PHT utilisant un sous-ensemble des bits d’adresse
On peut donc avoir des prédicteurs de 9 types
différents:
 GAg, GAp, GAs, PAg, PAp, PAs, SAg, SAp et SAs
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
corrélation différente (4)
•
Exemple: GAg
 Un seul BHR (Branch History Register), un seul PHT
(Pattern History Table)
 On appelle GAg(4) un tel système qui utilise 4 bits pour
le BHR (Branch History Register)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Système de Yeh et Patt
•
Exemple: GAg(4)
1 1 0 0 BHR
shift
PHT
0
0
0
1
1
0
1
1
0
1
1
1
1
0
0
0
1
1
0
0
0
1
1
1
1
0
1
1
0
0
0
1
© 2004 Frédéric Mailhot
1111
1110
1101
1100
1011
1010
1001
Prédiction:
1000
0111
0110
0101
0100
0011
0010
0001
0000
on branche!
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Système de Yeh et Patt (2)
Adresse de l’instruction de branchement
•
Exemple: GAp(4)
•
GAs(4): comme GAp(4),
0
1
0
0
1
0
0
1
1
1
0
0
mais avec un sous-ensemble
1
1
1
0
0
0
de l’adresse de l’instruction
1
1
1
1
1
0
0
1
1
1
0
0
1
1
0
1
1
0
0
0
1
0
1
1
1
0
0
0
0
1
1
0
1
1
0
1
1
0
0
0
0
1
0
0
0
1
1
1
1
0
1
1
0
1
1
1
1
0
0
0
1
0
1
1
0
0
1
0
0
0
0
1
0
0
0
1
1
1
de branchement
1111
1110
1101
1100
1011
1010
1001
1000
0111
0110
0101
0100
0011
0010
0001
0000
Prédiction: on …
branche!
1 1 0 0 BHR
shift
© 2004 Frédéric Mailhot
PHT
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Système de Yeh et Patt (3)
•
PHT
Exemple: PAg(4)
Semblable: SAg(4)
1 0 0 1
0 0 0 0
1 1 1 0
1Prédiction:
0 1 0 on ne
Adresse de l’instruction
de branchement
1111
0 1 1110
1 0 1101
0 0 1100
0 1 1011
1 1 1010
1 0 1001
branche
pas!
0 0 1000
1 1 0111
0 0 0110
0 1 0101
1 1 0100
1 0 0011
1 1 0010
0 0 0001
0 1 0000
0
1 1 0 0
1 1 1 0
0 0 0 0
1 1 1 1 BHR
shift
© 2004 Frédéric Mailhot
0
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Système de Yeh et Patt (4)
Adresse de l’instruction de branchement
• Exemple: PAp(4)
0
1
0
0
1
0
0
1
1
1
0
0
1 0 0 1
1
1
1
0
0
0
1
1
1
1
1
0
0 0 0 0
0
1
1
1
0
0
1
1
0
1
1
0
0
0
1
0
1
1
0
0
0
1
1
1
0
1
Semblable: SAs(4)
1 1 1 0
Adresse de l’instruction
de branchement
1 0
1 0 1Prédiction:
0
1 0
1 1 0 0
on …
branche!
1
0
0
0
0
1
0
0
0
1
1
1
1
0
1
1
0
1
0 0 0 0
1
1
1
0
0
0
1
0
1
1
0
0
1 1 1 1 BHR
1
0
0
0
0
1
0
0
0
1
1
1
1 1 1 0
shift
© 2004 Frédéric Mailhot
1111
1110
1101
1100
1011
1010
1001
1000
0111
0110
0101
0100
0011
0010
0001
0000
PHT
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Système de Yeh et Patt (5)
• Coût en matériel des différents systèmes de prédiction
adaptive:
Type de
prédicteur
Longueur du
BHR
Nombre de
PHT
Coût (nombre de bits
à emmagasiner)
GAg(k)
k
1
k + 2^k * 2
GAs(k,p)
k
p
k + p * 2^k * 2
SAg(k,s)
k
1
s * k + 2^k * 2
SAs(k,s,p)
k
p
s * k + p * 2^k * 2
• Meilleur système avec un budget de 128k bits:
GAs(13,32), qui obtient 97,2% de succès avec les SPEC89
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Prédiction dynamique des branchements:
Système de Yeh et Patt (6)
•
Fait intéressant:
 Les systèmes utilisant de l’information globale semblent
donner de meilleurs résultats pour des programmes qui
utilisent des opérations sur des entiers
(ces applications utilisent habituellement beaucoup de
conditions)
 Les systèmes utilisant de l’information locale semblent
donner de meilleurs résultats pour des programmes qui
utilisent des opérations sur des nombres à point flottant
(ces applications utilisent souvent des boucles)
•
GAs(13,32) est probablement un bon compromis
entre ces deux types d’applications
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchements: manque-t-il
quelque chose?
•
Nous avons maintenant une technique
intéressante pour prédire si un branchement sera
accepté ou non. Est-ce qu’il nous manque
encore quelque chose pour que le tout fonctionne
vraiment?
• Oui! C’est bien de savoir si le branchement sera
pris ou non, mais il faut encore savoir où va nous
mener ce branchement pour aller chercher
l’instruction suivante en cas de branchement…
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchements: Branch target
Buffer
• Pour savoir où aller dès que le prédicteur a produit son
•
•
•
estimé, on utilise une mémoire tampon qui contient
l’adresse de destination du branchement en question. On
appelle ce dispositif un Branch Target Buffer (BTB)
Ce tampon associe l’adresse d’un branchement avec
l’adresse de destination utilisée précédemment
Dans les processeurs qui contiennent des mémoires
caches pour les instructions directement sur le circuit (Icache), on peut immédiatement aller chercher l’instruction
de destination
Dans les processeurs qui n’ont pas de I-cache (vieux), on a
considéré mettre directement l’instruction dans le tampon.
On appelle alors le tampon un Branch Target Address
cache (BTAC)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchements: Branch Target
Buffer
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchements: utilisation du
BTB
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion de branchements: quoi d’autre?
•
Jusqu’ici, nous avons parlé de:
 Techniques de prédiction statiques (au niveau du
compilateur)
 Techniques de prédictions dynamiques (prédiction à 2bits, prédiction adaptive)
 Techniques pour conserver l’adresse de destination des
branchements
•
Qu’est-ce qui manque à notre arsenal?
 L’exécution spéculative
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchements: spéculation
•
Soit le code suivant:
if (x == 0) {
/* branche b1 */
a=b+c;
d=e–f;}
g=h*i;
•
/* instruction indépendante de b1 */
En supposant que la condition b1 soit faussement
prédite prise, l’instruction « g = h * i » sera retranchée
du processeur alors qu’elle doit être exécutée de
toutes façons
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchements: spéculation (2)
•
Si le processeur le supporte, le compilateur
pourrait réécrire la portion de code précédente
comme suit:
Pred = (x == 0) ;
/* branche b1 */
if Pred then a = b + c ;
/* Opération effectuée seulement si */
if Pred then d = e – f ;
/* Pred est vrai */
g=h*i;
•
Cette technique est utilisée dans le processeur
Itanium (aka Merced, IA64) de Intel / HP
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchement: spéculation (3)
•
Certains processeurs font aussi ce qu’on appelle
du « eager » ou « multipath » execution:
 Le processeur exécute en parallèle les 2 branches d’une
condition, et élimine celle qui est mauvaise lorsqu’on
connaît le résultat de la condition
 Fonctionne bien pour des conditions qui ont peu
d’instruction à l’intérieur
 En théorie, avec un nombre infini d’unités d’exécution,
on peut paralléliser toutes les branches. En pratique, le
nombre d’unités d’exécution du processeur limite le
nombre de branches effectivement exécutées en
parallèle
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchement: spéculation (4)
•
Puisque la spéculation est limitée par le matériel
disponible, il faut choisir judicieusement les
branches qu’on exécute de façon spéculative
•
Comment? En intégrant un système de
prédiction des branches!
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Gestion des branchements – effets des
langages orientés-objet
• Lorsqu’on examine le code exécutable de programmes
écrits dans des langages de programmation orientés-objet
(e.g. C++, Java), on s’aperçoit qu’il existe un bon nombre de
branchements dont la destination n’est pas une constante
 Cela vient du fait que certaines méthodes sont décidées de
façon dynamique, au cours de l’exécution du programme
• La destination des branchements étant variable, il devient
intéressant d’utiliser un Branch Target Buffer (BTB), ou
même de l’intégrer au Pattern History Table (PHT) pour
pouvoir prédire rapidement la destination du branchement
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gestion des branchements
Processeurs réels et gestion des
branchements
Technique
Processeur
Pas de prédiction
Intel 8086
Prédiction statique
non-prise
Intel i486
prise
Sun SuperSPARC
prise (vers l’arrière) /
HP-PA-7x00
non-prise (avant)
Prédiction dynamique
1-bit
DEC Alpha 21064, AMD-K5
2-bits
PowerPC 604, MIPS R10000
Adaptive
Intel Pentium Pro, Pentium II, AMD K-6
Spéculation
Intel / HP Itanium
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Étude de cas
Maintenant qu’on a vu les pipelines, le
superscalaire, le VLIW, la gestion des
branchements… Nous verrons comment le
tout est intégré dans quelques processeurs
connus:
1. La famille Pentium, Pentium Pro, Pentium II,
2.
3.
Pentium MMX, Pentium III, (Pentium 4)
Le processeur Itanium de Intel / HP
Le processeur Crusoë de Transmeta
Architecture des ordinateurs II – Frédéric Mailhot
Études de cas
Note de départ
•
Nous parlerons ici de processeurs pour lesquels
tous les détails techniques ne sont pas
disponibles. Ce qui suit est donc incomplet, et
peut contenir des erreurs.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 1: Famille Pentium
• L’ensemble d’instructions (ISA – Instruction Set
•
Architecture) x86 débute avec le processeur CISC 8086,
suivi par la suite des processeurs scalaires 8088, 80286,
Intel386, Intel486, suivi des processeurs superscalaires des
familles P5 et P6
Le premier Pentium fait partie de la famille P5
 C’est une machine superscalaire qui peut émettre 2
instructions par coup d’horloge
• La famille P6 apparaît en 1995, avec le Pentium Pro, suivi
•
•
du Pentium MMX (P5) et du Pentium II (P6) en 1997
En 1999, on introduit les instructions « Internet Streaming
SIMD extension » (ISSE), avec le Pentium III
Fin 2000, apparaît le Pentium 4, avec ISSE 2, et le « hyper
pipelining » (pipeline de 20 étages)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 1: Famille Pentium
Année
Type
m
Transistors
MHz
(x 1000)
Émission
(Ops)
1993
Pentium
3 100
0,8
66
2
1996
Pentium
3 300
0,35
150 - 166
2
1997
Pentium MMX
4 500
0,35
200 - 233
2
1995
PentiumPro
5 500
0,35
200
3
1998
Celeron
7 500 – 19 000
0,25
266 - 333
3
1997
Pentium II
7 500
0,25
233 – 450
3
1998
Pentium II Xeon
7 500
0,25
400 – 450
3
1999
Pentium III
9 500
0,25
450 – 500
3
1999
Pentium III Xeon
9 500
0,25
500 - 550
3
2000
Pentium 4
?
0,18
1,3 – 2 GHz
3 (?)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 1: Famille Pentium
• Pentium II:
 Exécution d’instructions dans le désordre, utilisation du
« register renaming »  Utilisation de la méthode de Tomasulo
 Mémoire cache séparée pour les instructions et les données
 ISA: IA-32, instructions x86 transformées en instructions
pseudo-RISC (ops) envoyées dans une station de réservation
centralisée (appelée « instruction window »)
 Les ops peuvent être exécutées dans le désordre, mais avant
(et après) leur exécution elles sont envoyées à un tampon qui
écrit les résultats dans le bon ordre (« reorder buffer »)
© 2004 Frédéric Mailhot
Université de Sherbrooke
External Bus
L2 Cache
Memory
Reorder Buffer
Bus Interface Unit
Instruction Fetch Unit (I-cache)
Branch Target
Buffer
Instruction
Decode
Microcode Instruction
Sequencer
Unit
D-Cache Unit
Reservation Station Unit
Études de cas
Cas 1: Microprocesseur Pentium II
Memory
Interface Unit
Functional
Units
Reorder Buffer
and
Register Alias
Table
Retirement
Register File
© 2004 Frédéric Mailhot
Université de Sherbrooke
External Bus
L2 Cache
Instruction
Memory
Fetch Unit (I-cache)
Reorder Buffer
Bus Interface Unit
Instruction Fetch Unit (I-cache)
D-Cache
I-Cache Unit
Reservation Station Unit
Études de cas
Cas 1: Microprocesseur Pentium II (Décodage)
Next IP
Memory
InterfaceBranch
Unit Target
Buffer
Instruction
Branch Target
Buffer
Instruction
Decode
Decode
Unit
Microcode Instruction
Sequencer
Unit
Microcode Instruction
Functional
Sequencer
Units
Register Alias
Table
Reorder Buffer
and
Register Alias
Table
Retirement
Register File
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 1: Microprocesseur Pentium II (Décodage)
• L’unité « Next IP » génère
l’adresse pour le I-Cache
Instruction
Fetch Unit (I-cache)
I-Cache
Next IP
Branch Target
Buffer
 Basé sur l’information provenant du
BTB, qui utilise un prédicteur adaptif 2
niveaux (type Yeh et Patt)
 Le BTB a 512 entrées
 Les branches mal prédites causent un
délai moyen de 15 cycles (minimum:
11 cycles)
Instruction
Decode
Microcode Instruction
Sequencer
Unit
Register Alias
Table
© 2004 Frédéric Mailhot
Université de Sherbrooke
Instruction IA-32
Instruction
Alignement
Fetch Unit (I-cache)
Branch Target
Buffer
Instruction
Decode
Microcode Instruction
Sequencer
Simple Decoder
Next IP
Simple Decoder
I-Cache
Geneal Decoder
Études de cas
Cas 1: Microprocesseur Pentium II (Décodeur)
Unit
Register Alias
Table
op1
© 2004 Frédéric Mailhot
op2
op3
Université de Sherbrooke
Instruction IA-32
• Le Décodeur lit 16 octets, et
aligne les octets des instructions
(jusqu’à 7 octets / instruction), qui
sont de taille variable
Alignement
Simple Decoder
Simple Decoder
• Il y a 3 unités de décodage:
Geneal Decoder
Études de cas
Cas 1: Microprocesseur Pentium II (Décodeur)
 Le décodeur général (traite les
instructions complexes, et génère de
1 à 4 ops)
 2 décodeurs simples (traitent les
instructions de LOAD et registre-àregistre, générant 1 op)
 Le décodeur peut générer jusqu’à 6
ops par cycle
op1
op2
op3
 La station de réservation peut
accepter jusqu’à 3 ops par cycle
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 1: Microprocesseur Pentium II (Décodeur)
 Les ops sont des instructions pseudo-RISC, de
taille fixe, qui contiennent un code d’opération, deux
opérandes pour les sources, et un opérande pour la
destination
Instruction
Fetch Unit (I-cache)

I-Cache
Next IP
Branch Target
Buffer
Instruction
Decode
Microcode Instruction
Sequencer
Unit
Register Alias
Table (RAT)


Les instructions x86 les plus complexes (celles qui
requièrent plus de 4 ops) sont décodées à l’aide du
« Microcode Instruction Sequencer »
 Instructions registres-à-registres: 1 op
 Instructions Load:
1 op
 Instructions Store, Read / Modify: 2 ops
 Instructions registres-mémoire:
2- 3 ops
 Instructions Read / Modify / Write: 4 ops
RAT: Conversion de registres en étiquettes liées au
matériel
Ensuite, les ops sont envoyées au ROB et au RSU
© 2004 Frédéric Mailhot
Université de Sherbrooke
External Bus
L2 Cache
Memory
Reorder Buffer
D-Cache Unit
Instruction Fetch Unit (I-cache)
Branch Target
Buffer
Instruction
Decode
Microcode Instruction
Sequencer
Unit
Memory
Interface Unit
(RSU)
Bus Interface Unit
Reservation Station Unit
Études de cas
Cas 1: Microprocesseur Pentium II (ROB et RSU)
Functional
Units
Reorder Buffer
(ROB) and
Register Alias
Table (RAT)
Retirement
Register File
© 2004 Frédéric Mailhot
Université de Sherbrooke
•
Le ROB garde en
mémoire l’ordre des
ops, pour qu’à la fin de
leur exécution elles
puissent être « retirées »
(retired) dans le bon
ordre (écriture dans les
registres ou en
mémoire)
Le RSU contient une
fenêtre de 20 ops, qui
peuvent être exécutées
dans le désordre
Memory
Reorder Buffer
D-Cache Unit
Memory
Interface Unit
(RSU)
•
Reservation Station Unit
Études de cas
Cas 1: Microprocesseur Pentium II (ROB et RSU)
Functional
Units
Reorder Buffer
(ROB) and
Retirement
Register File
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 1: Microprocesseur Pentium II (Reorder
Buffer - ROB)
Le ROB est utilisé à deux reprises dans le processeur:
1. Entre le décodage des instructions et l’exécution des ops:
•
On indique alors l’ordre relatif des ops dans une instruction et des
ops appartenant à des instructions distinctes
2. Après l’exécution, pour les retirer dans le bon ordre:
•
•
•
Retirer une instruction, c’est écrire de façon permanente (commit)
les changements de valeurs de registres et de la mémoire, dans une
mémoire tampon temporaire, le Retirement Register File (RRF)
Le processeur peut retirer 3 ops par coup d’horloge
Une op peut être retirée si:




Son exécution est terminée
Toutes les autres ops de la même instruction sont terminées (?)
Toutes les autres instructions qui précèdent sont terminées (et leurs ops
respectives)
Il n’y a pas eu d’interruption, d’exception ou d’erreur de prédiction de
branchement
© 2004 Frédéric Mailhot
Université de Sherbrooke
External Bus
L2 Cache
Memory
Reorder Buffer
D-Cache Unit
Instruction Fetch Unit (I-cache)
Branch Target
Buffer
Instruction
Decode
Microcode Instruction
Sequencer
Unit
Memory
Interface Unit
(RSU)
Bus Interface Unit
Reservation Station Unit
Études de cas
Cas 1: Microprocesseur Pentium II (Exécution)
Functional
Units
Reorder Buffer
(ROB) and
Register Alias
Table (RAT)
Retirement
Register File
© 2004 Frédéric Mailhot
Université de Sherbrooke
MMX FU
External Bus
Reservation Station Unit (RSU)
L2 Cache
Port0
Bus Interface Unit
Floating Pt FU
Integer
Functional Unit
Memory
Reorder Buffer
D-Cache Unit
MMX FU
Jump FU
Integer
Instruction FetchPort1
Unit (I-cache)
Functional Unit
Buffer
Port3
Store
Microcode Instruction
Functional
Sequencer
Unit
Store
Memory
Interface Unit
(RSU)
Load
Branch Target Functional Unit
Port2
Instruction
Decode
Reservation Station Unit
Études de cas
Cas 1: Microprocesseur Pentium II (Exécution)
Functional
Units
Unit
Port4
Register Alias Functional Unit
Table (RAT)
Reorder Buffer
(ROB) and
Retirement
Register File
© 2004 Frédéric Mailhot
Université de Sherbrooke
•
•
Si une op a les
valeurs de ses
opérandes d’entrées,
et que le FU requis
est libre, le RSU peut
faire l’émission
Le RSU peut émettre
jusqu’à 5 ops par
cycle (une par port),
mais en moyenne
c’est 3 ops
MMX FU
Floating Pt FU
Reservation Station Unit (RSU)
Études de cas
Cas 1: Microprocesseur Pentium II (Exécution)
© 2004 Frédéric Mailhot
Port0
Integer
Functional Unit
MMX FU
Jump FU
Port1
Integer
Functional Unit
Port2
Load
Functional Unit
Port3
Store
Functional Unit
Port4
Store
Functional Unit
Université de Sherbrooke
Études de cas
Cas 1: Microprocesseur Pentium II (Exécution)
Port du RSU
Latence
FU
Intervalle d’émission
Integer Arithmetic / logical / Shift
1
1
Integer multiplication
4
1
Floating Point Add
3
1
Floating Point Multiplication
5
2
Long
Long
MMX Arithmetic / logical / Shift
1
1
MMX Multiplication
3
1
Integer Arithmetic / logical / Shift
1
1
MMX Arithmetic / logical / Shift
1
1
2
Load
3
1
3
Store Address
3
1
4
Store Data
1
1
0
Floating Point Division
1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
BTB1
Reservation Station
RSU
IFU0
IDU0
Émission
ROB read
Port 0
IFU1
Port 1
IFU2
Exécution
Accès BTB
Reorder Buffer read
Accès I-cache
BTB0
Decode
Fetch et pre-decode
Cas 1: Microprocesseur Pentium II (Pipeline)
Port 2
IDU1
Register renaming
Reorder Buffer read
RAT
ROB read
Opérations dans l’ordre
Reorder Buffer
Write
Port 4
Retirement
Opérations dans le désordre
© 2004 Frédéric Mailhot
ROB write
RRF
Retraite
Port 3
Opérations dans l’ordre
Université de Sherbrooke
Études de cas
Cas 1: Microprocesseur Pentium 4
(Diagramme)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 1: Microprocesseur Pentium 4 (Pipeline)
•
Le pipeline du Pentium 4 a 20 étages ( environ 2
fois plus que le Pentium III):
• Avantage: il est plus facile d’augmenter la
fréquence de l’horloge
•
Inconvénient: remplir / vider le pipeline prend du
temps…
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium
•
Développé conjointement par HP et Intel:
 ISA mis au point chez HP
 Design matériel principalement chez Intel
•
But: mettre au point la prochaine génération de
processeurs haute performance 64 bits
•
Principes de base: éliminer les goulots
d’étranglements connus des systèmes
superscalaires existants
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium (2)
• Ce qui limite la performance dans les systèmes
superscalaires « standard »:
 Les branchements
• Les mauvaises prédictions limitent la performance
• Les petites branches (peu de code) ont peu de code à exécuter, ce
qui limite le parallélisme
 L’accès à la mémoire
• Utilise plus d’un coup d’horloge
• Souvent, on doit faire un load juste après un branchement
 L’extraction du parallélisme des instructions
• Le compilateur « sérialise » le code, dont le parallélisme
intrinsèque doit être redécouvert dynamiquement par le
processeur
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Les limites de la
performance: Branchements
•
•
Erreurs de prédiction limitent la performance
Les petits blocs de destination limitent le parallélisme
 Mauvaise utilisation des machines ayant beaucoup d’unités
d’exécution
Ld R1
IF
Use R1
Tranches
d’exécution
inutilisées
St R2
THEN
ELSE
Ld R4
Use R4
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Les limites de la
performance (2): Latence de la mémoire
•
Temps d’accès à la mémoire augmente continuellement par
rapport à la vitesse des processeurs
•
Délais de chargement exacerbés par les machines qui exécutent
plus d’une instruction par coup d’horloge
branchement
Le branchement
est une barrière
load
branchement
load
utilisation
utilisation
Machine scalaire
Machine 4 X superscalaire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Les limites de la
performance (3): Extraction du parallélisme
•
•
Modèle d’exécution séquentiel
Le compilateur a une vue limitée, indirecte du
matériel
Code source
original
Compilateur
Code machine
séquentiel
Matériel
Code parallèle
Code parallèle
Unités d’exécution multiples
…
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Meilleure stratégie:
parallélisme explicite
•
Le compilateur expose, améliore et exploite le parallélisme du
programme source et le rend explicite dans le code machine
Code source
original
Compilateur
Code machine
parallèle
« Expose »
« Exploite »
« Améliore »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Format des instructions
• Les instructions sont regroupées en paquets de 128 bits
 Chaque instruction fait 40 bits
• Il y a un gabarit (template) de 8 bits qui indique quelles
instructions peuvent s’exécuter en parallèle
 Permet au compilateur d’extraire plus de parallélisme
 Simplifie le matériel en éliminant les mécanismes de détection
dynamiques
 Augmentation modeste de la taille du code
• Instructions EPIC: Explicitely Parallel Instruction
Computing (parallélisme explicite grâce aux gabarits)
Groupe de 128 bits
0
127
Instruction 2
Instruction 1
© 2004 Frédéric Mailhot
Instruction 0
Gabarit
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Branchements traditionnels
if
then
Instr 1
Instr 2
•
Architecture
traditionnelle: 4 blocs
de base
•
Les conditions
introduisent des
branchements
.
.
p1, p2 <- cmp(a == b)
Jump p2
Instr 3
Instr 4
.
.
Jump
else
Instr 5
Instr 6
.
.
Instr 7
Instr 8
.
.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Utilisation de « prédicats »
if
then
Instr 1
Instr 2
.
.
p1, p2 <- cmp(a == b)
Jump p2
(p1) Instr 3
(p1) Instr 4
.
.
Jump
else
(p2) Instr 5
(p2) Instr 6
.
.
Instr 7
Instr 8
.
.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Utilisation de « prédicats »
Architecture traditionnelle: 4 blocs
if
then
Instr 1
Instr 2
.
.
p1, p2 <- cmp(a == b)
Jump p2
Architecture EPIC: 1 seul bloc
Instr 1
Instr 2
if
.
.
p1, p2 <- cmp(a == b)
Instr 3
Instr 4
else
(p1) Instr 3
(p1) Instr 4
(p2) Instr 5
(p2) Instr 6
.
.
.
.
.
.
Instr 7
Instr 8
Jump
else
then
.
.
Instr 5
Instr 6
.
.
Instr 7
Instr 8
•
Les prédicats permettent une
meilleure utilisation du
matériel parallèle
.
.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Utilisation de « prédicats »
• Le compilateur a une plus grande marge de manœuvre
pour faire le « scheduling » des instructions
 La plupart des instructions peuvent inclure des prédicats
 L’état de la machine (les registres et la mémoire) ne sont mis à
jour que si le prédicat est vrai. Sinon, l’instruction devient
effectivement un NOP
 Le compilateur assigne des prédicats aux instructions, qui
sont déterminés par les instructions de comparaison
 EPIC définit 64 registres de prédicats à 1-bit
• L’utilisation de prédicats élimine les branchements
 Convertit une dépendance de contrôle en dépendance de
données
 Réduit les pénalités pour les mauvaises prédictions
• Exécution parallèle de plus d’instructions
 Utilisation plus efficace du matériel parallèle
• Sur les SPEC89, près de ½ des branchements sont éliminés
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Délais d’accès à la mémoire
avec les machines traditionnelles
•
La lecture de la mémoire affecte la performance
de façon majeure
 Souvent le LOAD est la 1ère instruction d’une chaîne
d’instructions dépendantes
 Il peut y avoir une grande latence
 Les LOAD peuvent causer des exceptions
Instr 1
Instr 2
Architecture traditionnelle
.
.
Jump p2
Barrière
Load
Utilisation
.
.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Spéculation
Architecture EPIC
ld.s
Instr 1
Instr 2
….
Jump p2
Détection des exceptions
Propagation des
Exceptions
Livraison des exceptions
chk.s
Utilisation
.
.
•
On sépare la lecture du traitement des exceptions
 L’instruction de lecture spéculative (ld.s) démarre un
Load et détecte les exceptions
 Les exceptions sont propagées (à l’aide d’un jeton
attaché au registre de destination) de ls.s à chk.s
 La vérification spéculative (chk.s) « rend publiques » les
exceptions détectées par ld.s
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium – Spéculation
Architecture traditionnelle
Architecture EPIC
ld.s
Instr 1
Instr 2
Instr 1
Instr 2
.
.
….
Jump p2
Barrière
Jump p2
Load
Utilisation
chk.s
Utilisation
.
.
.
.
Détection des exceptions
Propagation des
Exceptions
Livraison des exceptions
• Donne plus de liberté au compilateur pour le scheduling
 Permet aux instructions ld.s d’apparaître avant les
branchements
 Chk.s demeure à sa position initiale, et initie une correction si
une exception est détectée
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium: Exemple - La boucle des 8 Reines
if ((b[ j ] == true) && (a[ i + j ] == true) && (c[ i - j + 7 ] == true))
Code original
2
4
5
R1 = &b[ j ]
R3 = &a [i+j]
R5 = &c [i-j+7]
Ld R2 = [R1]
P1, P2 <- cmp(R2 == true)
<P2> br exit
Vrai
38%
6
8
9
Ld R4 = [R3]
P3, P4 <- cmp(R4 == true)
<P4> br exit
72%
33%
10
12
13
Ld R6 = [R5]
P5, P6 <- cmp(R6 == true)
<P5> br then
else
47%
39%
1
Mauvaise préd
43%
13 cycles,
3 mauvaises prédictions possibles
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium: Exemple - La boucle des 8 Reines
if ((b[ j ] == true) && (a[ i + j ] == true) && (c[ i - j + 7 ] == true))
Code original
1
2
4
5
R1 = &b[ j ]
R3 = &a [i+j]
R5 = &c [i-j+7]
Ld R2 = [R1]
P1, P2 <- cmp(R2 == true)
<P2> br exit
6
8
9
Ld R4 = [R3]
P3, P4 <- cmp(R4 == true)
<P4> br exit
10
12
13
Ld R6 = [R5]
P5, P6 <- cmp(R6 == true)
<P5> br then
else
13 cycles,
3 mauvaises prédictions possibles
Spéculation
1
2
4
5
6
7
8
9
R1 = &b[ j ]
R3 = &a [i+j]
R5 = &c [i-j+7]
Ld R2 = [R1]
Ld.s R4 = [R3]
Ld.s R6 = [R5]
P1, P2 <- cmp(R2 == true)
<P2> br exit
Chk.s R4
P3, P4 <- cmp(R4 == true)
<P4> br exit
Chk.s R6
P5, P6 <- cmp(R6 == true)
<P5> br then
else
9 cycles,
3 mauvaises prédictions possibles
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium: Exemple - La boucle des 8 Reines
if ((b[ j ] == true) && (a[ i + j ] == true) && (c[ i - j + 7 ] == true))
Spéculation
1
2
4
5
6
7
8
9
R1 = &b[ j ]
R3 = &a [i+j]
R5 = &c [i-j+7]
Ld R2 = [R1]
Ld.s R4 = [R3]
Ld.s R6 = [R5]
P1, P2 <- cmp(R2 == true)
<P2> br exit
Chk.s R4
P3, P4 <- cmp(R4 == true)
<P4> br exit
Chk.s R6
P5, P6 <- cmp(R6 == true)
<P5> br then
else
Usage de prédicats
1
2
4
5
6
7
R1 = &b[ j ]
R3 = &a [i+j]
R5 = &c [i-j+7]
Ld R2 = [R1]
Ld.s R4 = [R3]
Ld.s R6 = [R5]
P1, P2 <- cmp(R2 == true)
<P2> br exit
<P1> Chk.s R4
<P1> P3, P4 <- cmp(R4 == true)
<P4> br exit
<P3> Chk.s R6
<P3> P5, P6 <- cmp(R6 == true)
<P5> br then
else
7 cycles,
1 mauvaise prédiction possible
9 cycles,
3 mauvaises prédictions possibles
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium: Exemple - La boucle des 8 Reines
if ((b[ j ] == true) && (a[ i + j ] == true) && (c[ i - j + 7 ] == true))
Code original
1
2
4
5
R1 = &b[ j ]
R3 = &a [i+j]
R5 = &c [i-j+7]
Ld R2 = [R1]
P1, P2 <- cmp(R2 == true)
<P2> br exit
Usage de prédicats
1
R1 = &b[ j ]
R3 = &a [i+j]
R5 = &c [i-j+7]
Ld R2 = [R1]
Ld.s R4 = [R3]
Ld.s R6 = [R5]
P1, P2 <- cmp(R2 == true)
<P2> br exit
<P1> Chk.s R4
<P1> P3, P4 <- cmp(R4 == true)
<P4> br exit
<P3> Chk.s R6
<P3> P5, P6 <- cmp(R6 == true)
<P5> br then
else
Résultat: réduction2de près
de la moitié du nombre de cycles
4
6
8
9
Ld R4 = [R3]
P3, P4 <- cmp(R4 == true)
<P4> br exit
10
12
13
Ld R6 = [R5]
P5, P6 <- cmp(R6 == true)
<P5> br then
else
5
2/3 des erreurs possibles
de prédictions sont6 éliminées
13 cycles,
3 mauvaises prédictions possibles
7
7 cycles,
1 mauvaise prédiction possible
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 2: Itanium - Conclusion
•
EPIC (Explicitely Parallel Instruction Computing)
 Utilise du code assembleur où le parallélisme est
indiqué explicitement avec des gabarits (templates)
 Utilise la prédication pour éliminer les branchements
(utilisation de 64 registres de statut qui permettent
l’exécution conditionnelle d’instructions)
 Utilise la spéculation pour diminuer l’impact des Loads
(on sépare le chargement du traitement des exceptions)
•
Architecture des instructions faite pour que les
processeurs soient facilement améliorés par des
ajouts de matériel parallèle supplémentaire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 3: Crusoë de Transmeta
•
Processeur destiné au marché des machines
portables
 Requiert très peu de puissance électrique comparé à
d’autres processeurs ayant des performances
semblables
•
Attrait intéressant: utilise un noyau VLIW sur
lequel un émulateur logiciel peut interpréter des
instructions destinées à un autre processeur
 Transmeta a démontré l’utilisation d’une application
hybride Java / x86, où l’ensemble des instructions sont
exécutées (interprétées et traduites) sur le VLIW sousjacent
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 3: Crusoë de Transmeta
•
Pour contrôler ses besoins de puissance
électrique, Crusoe détecte si le système est peu
utilisé, et à la fois réduit la fréquence de l’horloge
(de 700 MHz à 200MHz) et le potentiel
d’alimentation (de 1,65 V à 1,1 V)
• Puisque P = ½ f * C V^2,
 La puissance est diminuée de (700 / 200) * (1,65 / 1,1)^2
et P’ = (1 / 7,88) * P
(près de 8 fois moins de puissance)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 3: Crusoë – CMS (Code Morphing Software)
•
Le processeur Crusoe est un VLIW sur lequel
s’exécute un logiciel d’interprétation
d’instructions x86
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 3: Crusoë - CMS
•
Le CMS (Code
Morphing System)
•
Interprétation des
instructions x86
en instructions
VLIW
•
Mise en mémoire
des séquences
d’instructions
fréquentes
•
Réutilisation des
instructions déjà
traduites
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 3: Crusoë: Diagramme
•
Diagramme du 5400:
© 2004 Frédéric Mailhot
Université de Sherbrooke
Études de cas
Cas 3: Crusoë
•
Le 5400:
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Digression: «Control flow » et
« Data flow »
Jusqu’ici, les processeurs que nous avons étudié
ont tous été du type « Von Neumann », c’està-dire des machines où un « program
counter » indique où aller chercher la
prochaine instruction. C’est ce qu’on appelle
le modèle « control flow », et c’est le type de
machine principal qui existe de nos jours
Mais… on peut imaginer un autre paradigme pour
l’exécution des instructions!
Architecture des ordinateurs II – Frédéric Mailhot
Processeurs ‘Data Flow’
Comment faire un processeur autrement
qu’en utilisant le « control flow » de Von
Neumann?
• Rappelons-nous notre étude du Itanium: nous avons vu
que les programmes peuvent être représentés par des
graphes:
• Ces graphes représentent le fait que les instructions ont
des dépendances entre elles à cause des données
© 2004 Frédéric Mailhot
Université de Sherbrooke
Processeurs ‘Data Flow’
L’idée derrière les processeurs « Data flow »
•
Sachant que ce qui va empêcher une instruction
de s’exécuter, ce sont les valeurs inconnues des
opérandes, on peut changer le mode d’opération
de la machine:
 Au lieu d’indiquer où se trouve la prochaine instruction,
on indique quelles sont les dépendances entre les
instructions
 Lorsque toutes les valeurs d’entrées d’une instruction
sont connues, on peut alors l’exécuter
© 2004 Frédéric Mailhot
Université de Sherbrooke
Processeurs ‘Data Flow’
Processeur VS matériel dédié
• En fait, le mode d’opération « Data Flow » est la méthode
utilisée lors de la génération de circuits matériels, par
exemple dans les ASICs (Application Specific Integrated
Circuits)
• Lorsqu’on fait la synthèse de circuits à partir de langages
HDL (VHDL ou Verilog), c’est aussi le modèle « Data Flow »
qui est utilisé
 On verra cela avec un peu plus de détail plus tard durant la
session
• De cette façon, l’ordre d’exécution des opérations est
décidé de façon dynamique, pendant que le système est à
évaluer les données
© 2004 Frédéric Mailhot
Université de Sherbrooke
Processeurs ‘Data Flow’
Processeurs « Data Flow »
•
Depuis le début des années ’70, il y a eu plusieurs
processeurs « Data Flow » étudié par diverses
équipes de recherche





•
MIT Static Dataflow Machine (1975)
Manchester Dataflow Machine (1979)
Hughes Dataflow Multiprocessor (1985)
Stateless Data-Flow Architecture (1993)
Et beaucoup d’autres…
Plusieurs types de machines Dataflow ont été
étudiées, mais nous nous contenterons d’un bref
aperçu de la plus simple, la méthode « statique »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Processeurs ‘Data Flow’
Approche simple: Static dataflow
•
On utilise des jetons (tokens) pour indiquer la
validité des données
ni

*
x
y
2
x
y
3
3
2
*
Jeton de données
nj
x
ni
y
Jeton de retour
nj
Arc de données
Arc de retour
(acknowlege)
SQRT
nj
sqrt
z
ni
z
© 2004 Frédéric Mailhot
z
Université de Sherbrooke
Processeurs ‘Data Flow’
Approche simple: Static dataflow
•
On peut utiliser deux façons différentes d’initier
les calculs:
 Push ou Pull:
• Push: on fait le calcul de la sortie lorsque tous les
opérandes sont connus (le contrôle des calculs va des
entrées vers les sorties)
• Pull: on initie le calcul d’une valeur que lorsqu’elle est
nécessaire (le contrôle des calculs va des sorties vers les
entrées)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Processeurs ‘Data Flow’
Exemple: la MIT Static Dataflow Machine
Vers le Communication
Network
Send
Unit
Receive
Unit
Update
Unit
Operation
Unit(s)
Instruction
Queue
Activity
Store
Fetch
Unit
Processing Element
© 2004 Frédéric Mailhot
Université de Sherbrooke
Processeurs ‘Data Flow’
Exemple: la MIT Static Dataflow Machine
Vers le Communication
Network
Send
Unit
Receive
Unit
Update
Unit
PE
OperationCommunication
… Unit(s)
Network
PE
Instruction
Queue
Activity
Store
Fetch
Unit
Processing Element
© 2004 Frédéric Mailhot
Université de Sherbrooke
Processeurs ‘Data Flow’
Machines Dataflow – Remarques et
conclusion
•
Certaines idées des machines Dataflow ont été
reprises dans les processeurs de type Von
Neumann « traditionnels »:
 Le « renaming », avec utilisation du Common Data Bus,
est assez proche des idées dataflow: une instruction ne
s’exécute que lorsque tous ses opérandes sont prêts
 L’exécution des instructions dans le « désordre »
respecte toujours la disponibilité des opérandes,
comme dans les systèmes Dataflow
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Et maintenant, où allons-nous?
Après toutes les techniques vues jusqu’ici:
Que peut-on faire de plus?
Question plus fondamentale (et importante):
Lorsque toutes les techniques vues jusqu’ici
sont en place, d’où viennent les limites de
performance?
Architecture des ordinateurs II – Frédéric Mailhot
Que nous réserve le futur?
Quelles sont les limites de performance qui
n’ont pas été abordées jusqu’ici?
•
Dans les années ’50, lorsqu’on s’est aperçu que
les ordinateurs passaient le plus clair de leur
temps à faire des entrées/sorties, on a découplé
les E/S (I/O) du processeur central.
•
Plus tard, on a même introduit les systèmes
« batch », pour augmenter le niveau d’utilisation
du CPU central.
•
En quoi ces deux problèmes des années ’50 sontils semblables à ce qui limite maintenant la
performance?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Que nous réserve le futur?
Le temps d’accès à la mémoire est grand!
•
Maintenant, dans les années 2000, qu’est-ce qui
limite la performance des processeurs?
 Le temps d’accès à la mémoire est de plus en plus
grand par rapport au temps d’exécution du processeur.
 Lorsqu’un accès à la mémoire est fait, on observe les
temps d’accès suivants (valeurs provenant d’un
processeur Alpha 21164 à 300 MHz):
•
•
•
•
Pas de délai pour le cache L1
7 cycles pour un accès manqué dans L1, réussi dans L2
21 cycles pour un accès manqué dans L2, réussi dans L3
80 cycles pour un accès à la mémoire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Que nous réserve le futur?
Les implications des grands temps d’accès
• Les délais impliqués lorsque les données ne sont pas dans
les mémoires caches sont très grands.
 Donc, lorsqu’il y a un « cache miss », le processeur va
s’arrêter pendant un long moment (en supposant qu’on ne
peut exécuter d’autres instructions qui sont déjà dans le
processeur):
•
Ceci va se passer assez souvent lorsqu’on vient de faire un saut
dans une nouvelle partie de code
• Si le délai d’accès à la mémoire est trop grand, éventuellement
l’instruction en attente va arrêter toutes les autres à causes de
dépendances de données
• D’une certain façon, on revient au problème vécu dans les
années ’50: le processeur passe trop de temps à faire des
entrées/sorties, et le CPU (les unités d’exécution dans notre
cas) sont trop souvent inactives en attendant que les
données soient disponibles)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Que nous réserve le futur?
Une solution possible aux grands temps
d’accès à la mémoire
•
Dans les années ’50, on a tout fait pour garder le
CPU occupé autant que possible
•
Dans les années 2000, on doit aussi tenter de
garder (toutes) les unités d’exécution occupées,
même pendant un accès à la mémoire…
 Au niveau du système d’exploitation, on sait qu’il y a
souvent beaucoup de threads qui existent au niveau du
répartiteur.
 Et si on faisait le context switch entre les threads au
niveau du processeur?…
© 2004 Frédéric Mailhot
Université de Sherbrooke
Que nous réserve le futur?
Les processeurs multithreaded: l’avenir?
•
Puisque le processeur est souvent inactif (en tout
ou en partie, i.e. toutes/certaines unités
d’exécution sont inutilisées), une idée
intéressante est de faire exécuter plusieurs
threads parallèles par le processeur
• En ayant plus d’instructions parmi lesquelles
choisir, le taux d’occupation des unités
d’exécution devrait augmenter
© 2004 Frédéric Mailhot
Université de Sherbrooke
Que nous réserve le futur?
Les processeurs multithreaded: Qu’est-ce
que c’est?
•
On définit une machine « multithreaded » ainsi:
 Processeur dans lequel les instructions à exécuter
proviennent potentiellement de différents threads
•
Quel est l’avantage de ces machines?
 Lorsqu’un thread est immobilisé (par une instruction en
attente de quelque donnée ou unité d’exécution),
d’autres instructions provenant de d’autres threads
peuvent s’exécuter
 Les threads partagent la même mémoire, donc l’accès à
la mémoire (le tableau des pages) n’a pas besoin d’être
modifié
© 2004 Frédéric Mailhot
Université de Sherbrooke
•
Machine single-thread scalaire:
1
1
1
Temps
Que nous réserve le futur?
Types de machines « multithread »
1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Machine multi-thread scalaire par bloc:
1
2
3
4
1
1
1
2
2
© 2004 Frédéric Mailhot
Changement de contexte
(Context Switch)
•
Temps
Que nous réserve le futur?
Types de machines « multithread »
Université de Sherbrooke
Machine multi-thread scalaire cycle-par-cycle:
1
2
3
4
1
2
3
4
1
2
© 2004 Frédéric Mailhot
Changement de contexte
(Context Switch)
•
Temps
Que nous réserve le futur?
Types de machines « multithread »
Université de Sherbrooke
•
Machine single-thread superscalaire:
1
1
1
1
1
1
1
1
1
1
1
Temps
Que nous réserve le futur?
Types de machines « multithread »
© 2004 Frédéric Mailhot
Université de Sherbrooke
•
Machine single-thread VLIW:
1
1
1
N
N
1
N
N
N
1
1
1
1
1
1
1
N
Temps
Que nous réserve le futur?
Types de machines « multithread »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Machine multi-thread superscalaire cycle-parcycle:
1
2
3
4
1
1
2
2
2
4
4
4
1
1
3
2
© 2004 Frédéric Mailhot
4
Changement de contexte
(Context Switch)
•
Temps
Que nous réserve le futur?
Types de machines « multithread »
Université de Sherbrooke
Machine multi-thread VLIW cycle-par-cycle:
1
2
3
4
1
1
N
N
2
2
2
N
3
N
N
N
4
4
4
4
1
1
N
N
2
N
N
N
© 2004 Frédéric Mailhot
Changement de contexte
(Context Switch)
•
Temps
Que nous réserve le futur?
Types de machines « multithread »
Université de Sherbrooke
•
Machine multi-thread superscalaire par émission
(Simultaneous multithreading, SMT):
 Université de Washington (1995), Karlsruhe (1996)
1
2
3
4
Temps
Que nous réserve le futur?
Types de machines « multithread »
1
3
3
3
4
4
4
2
2
2
2
3
2
4
1
1
3
4
4
1
1
2
2
4
© 2004 Frédéric Mailhot
Université de Sherbrooke
•
1
Machine multi-thread scalaire par émission (chip
multiprocessor, CMP):
2
3
4
1
1
1
Temps
Que nous réserve le futur?
Types de machines « multithread »
2
2
2
2
3
4
2
1
1
4
1
3
2
1
2
© 2004 Frédéric Mailhot
4
2
4
3
3
4
3
3
4
4
Université de Sherbrooke
Que nous réserve le futur?
Le futur: quoi d’autre?
•
On a remarqué que dans de nombreux
programmes, les mêmes variables sont lues de
façon répétitive avec les mêmes valeurs.
•
Idée: on va commencer l’exécution d’une
instruction avant de connaître la valeur de ses
opérandes, en utilisant des valeurs « prédites » à
partir des valeurs précédentes
•
On appelle cette technique la
« superspéculation »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Que nous réserve le futur?
La superspéculation
•
Les processeurs utilisant cette technique utilisent
deux sous-systèmes:
 Un système « front end » qui spécule de façon
agressive, allant jusqu’à prédire les valeurs manquantes
 Un système « back end » qui valide les prédictions de
valeurs et qui peut corriger le tir lorsque nécessaire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Hiérarchie de la mémoire
Les processeurs modernes requièrent beaucoup
de mémoire rapide. Or, plus la mémoire est
rapide, plus elle est chère. Que faire pour
obtenir à coût raisonnable une machine
performante?
On utilise une hiérarchie de mémoires cache
Architecture des ordinateurs II – Frédéric Mailhot
Hiérarchie de la mémoire
Pourquoi les mémoires caches
fonctionnent-elles?
• Les mémoires caches fonctionnent parce que les mêmes
•
instructions sont réutilisées de multiples fois (évidemment
si chaque instruction n’était utilisée qu’une seule fois,
l’utilisation de la mémoire cache ne serait pas très en
vogue…)
On parle de localité des références:
 Localité temporelle
• Les instructions utilisées récemment sont souvent réutilisées
 Localité spatiale
• Les instructions voisines sont souvent exécutées de concert
 Localité séquentielle
• Les branchements constituent de 20 à 30% des instructions.
Donc, de 70 à 80% des instructions s’exécutent toujours en
séquence
• Les branchements vont souvent prendre les mêmes chemins
pendant un certain temps (les branchements sont corrélés)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Pourquoi une hiérarchie de mémoire?
• Plus la mémoire a un temps d’accès petit, plus elle coûte
cher. Il vaut donc la peine d’utiliser le moins possible de
mémoire rapide tout en conservant une performance
acceptable:
 Touchant le processeur, on a la mémoire la plus rapide (et
aussi la plus chère)
 En bout de ligne, on a la mémoire principale, suivie du disque
• De nos jours, le premier niveau de mémoire cache se
trouve souvent sur le même chip que le processseur (le 2e
niveau peut aussi s’y retrouver)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Coût VS temps d'accès de la mémoire
Coût
Hiérarchie de la mémoire
Coût de la mémoire et temps d’accès
Temps d'accès
© 2004 Frédéric Mailhot
Université de Sherbrooke
Probabilité VS Taille des mémoires caches
100%
90%
Probabilité de présence
Hiérarchie de la mémoire
Taille de la mémoire cache et probabilité de
« hit »
80%
70%
60%
50%
40%
30%
20%
10%
0%
Taille de la mémoire cache
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mémoire cache: comment ça marche?
•
L’idée de la mémoire cache, c’est de conserver
dans une mémoire rapide les données dont on
aura besoin bientôt
•
Il existe plusieurs techniques pour distinguer les
données emmagasinées dans la mémoire cache:
 Mapping associatif
 Mapping direct
 Mapping par ensemble associatif (set-associative)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mémoire associative: comment ça marche
•
Chaque entrée dans ce type de mémoire contient
une clé et une valeur. Pour accéder à la valeur, il
suffit de présenter la bonne clé (c’est la même
idée que pour un tableau de hachage)
•
Lorsqu’on présente une clé à ce type de mémoire,
toutes les clés de toutes les entrées de la
mémoire sont comparées en parallèle. Celle qui
est identique (si elle existe) détermine quelle
valeur est présentée à la sortie
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mémoire associative: comment ça marche
0x00000000
0x00CCBB50 2220
0x000011B0 5823
0xCC0011B0 155277
0x00CCBB50 2220
0xCC0011B0 155277
0x000011B0 5823
Mémoire cache
0xFFFFFFFF
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mémoire associative: pour ou contre?
•
Avantages:
 Très flexible
 Peut être très rapide
•
Inconvénients:
 Système coûteux (chaque élément de mémoire doit
contenir un comparateur!)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
…
Mapping direct
0x000011B0 5823
0x00CCBB50
Étiquettes
Addresse (index)
Étiquettes
…
Mémoire
Données
Taille de la mémoire:
64K X taille (données)
Comparateur
Données
Match?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mapping direct: pour ou contre?
•
Avantages:
 Utilise de la mémoire rapide mais « standard » (sans
comparateur intégré)
 Moins coûteux que la mémoire associative
•
Désavantages:
 Requiert un peu de circuiterie additionnelle
 Si 2 addresses utilisées dans la même période de temps
ont le même index, il y aura continuellement des
collisions…
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mapping set-associative
0x00CCBB50
Addresse (index)
Étiquette
Système à
Mapping
direct
1
32
Système à
Mapping
direct
1
Système à
Mapping
direct
32
1
32
Match?
Données
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mapping set-associative: bilan
•
Bon compromis entre mapping direct et mapping
associatif:
 Moins coûteux que la mémoire associative
 Permet d’avoir des addresses dont les index sont les
mêmes
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mémoire cache: que fait-on lorsque la
mémoire est pleine?
• Lorsque la mémoire cache est remplie et une nouvelle
valeur doit y être écrite, on doit faire de la place…
• Les méthodes utilisées sont variables:
 Remplacement aléatoire
 Remplacement « Least Frequently Used », LFU
• Un compteur comptabilise le nombre de fois qu’une valeur est
utilisée
 Remplacement « Least Recently Used », LRU
• Avec une mémoire cache assez grande, les méthodes LRU
et aléatoires donnent des résultats comparables (sachant
que la méthode aléatoire est beaucoup plus simple à mettre
en place, que choisiriez-vous?)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mémoire cache: que fait-on lors d’écritures?
• Il existe deux méthodes de gérer les écritures en mémoire
par le biais de la mémoire cache:
 Write-through: Dès qu’une nouvelle valeur est écrite, on fait
l’écriture en mémoire principale, et on garde (ou pas) cette
valeur dans la mémoire cache.
 Write-back: On conserve la nouvelle valeur dans la mémoire
cache, et éventuellement on écrit cette valeur dans la mémoire
principale
• Avantage du write-back: Une série de lectures/écritures à la
•
même adresse n’implique pas de délai pour les écritures
intermédiaires
Avantages du write-through: lorsqu’on manque de place
dans la mémoire cache (à cause d’un read miss), il n’y a
jamais d’écriture requise
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
Mémoire cache: write-back, write-through
• Lorsque l’adresse de destination de l’écriture n’est pas en
mémoire (write miss), on peut soit garder une copie dans la
mémoire cache (write allocate), soit ne rien faire (no write
allocate)
• Le write allocate est habituellement associé au write-back,
où on espère qu’une prochaine écriture pourra se faire
directement dans la mémoire cache
• Le no-write allocate est habituellement associé au writethrough, puisque les écritures subséquentes vont de toutes
façons aller jusqu’à la mémoire principale
© 2004 Frédéric Mailhot
Université de Sherbrooke
Hiérarchie de la mémoire
La performance des mémoires cache
• La performance des mémoires cache dépend évidemment
de la quantité de « misses ». On peut séparer ceux-ci en
trois catégories:
 Obligatoires – lorsqu’on accède à une adresse pour la
première fois
 De capacité – lorsque la mémoire cache était pleine et qu’on a
dû laisser aller certaines des valeurs lues précédemment
 De conflit – lorsque deux adresses distinctes correspondent à
la même entrée dans la mémoire cache
• La performance du système dépend aussi du délai encouru
•
lors d’un « miss ».
Pour optimiser la performance d’un système, il faut donc à
la fois réduire le nombre de misses, et réduire les délais
encourus lors de « misses »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Les multiprocesseurs
Jusqu’à maintenant, nous avons parlé longuement
des microprocesseurs.
Nous allons maintenant étudier les
multiprocesseurs, comment ils fonctionnent,
quels sont les problèmes particuliers qui
apparaissent.
Architecture des ordinateurs II – Frédéric Mailhot
Les multiprocesseurs
Les multiprocesseurs
• Périodiquement, depuis les années ’60, on a prédit la fin
des uniprocesseurs, au profit des multiprocesseurs
• On parle souvent de la vitesse de la lumière comme d’une
limite proche d’être atteinte:
 C = 3 X 10 ^ 8 m/s – » 15 cm / 0,5 ns (2 GHz)
 On dit que des architectures nouvelles (multiprocesseurs)
devront être utilisées pour continuer d’améliorer la
performance
• Mais… depuis 1985, l’augmentation de performance des
processeurs est la plus importante depuis la fin des années
’50!
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Les multiprocesseurs – pourquoi
• En supposant que les microprocesseurs demeurent la
technologie dominante pour les uniprocesseurs, il semble
naturel d’imaginer en connecter plusieurs ensemble pour
augmenter la performance
• Il n’est pas clair que le taux d’innovation au niveau de
l’architecture pourra se continuer longtemps
• Il semble qu’il y ait des progrès constants dans les 2
domaines où les machines parallèles ont le plus de
difficulté: le logiciel et les interconnexions
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Les types de multiprocesseurs
•
Taxonomie proposée par Flynn dans les années
’60:
 SISD (Single Instruction Single Data): uniprocesseur
 SIMD (Single Instruction Multiple Data): plusieurs
processeurs, qui exécutent en parallèle les mêmes
instructions sur plusieurs données
 MISD (Multiple Instruction Single Data): pas d’exemple
connu
 MIMD (Multiple Instruction Multiple Data): plusieurs
processeurs qui opèrent de façon indépendantes ou
semi-indépendantes sur leurs données
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Types de multiprocesseurs utilisés
•
•
Les premiers multiprocesseurs étaient du type
SIMD, et cette architecture est encore utilisée
pour certaines machines spécialisées
Le type MIMD semble être la cible de choix de nos
jours pour des ordinateurs d’application
courante:
 Les MIMD sont flexibles: on peut les utiliser comme
machines à un seul utilisateur, ou comme machines
multi-programmées
 Les MIMD peuvent être bâties à partir de processeurs
existants
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Au centre des processeurs MIMD: la
mémoire
•
On peut classifier les processeurs MIMD en deux
classes, dépendant du nombre de processeurs
dans la machine. Ultimement, c’est l’organisation
de la mémoire qui est affectée:
 Mémoire partagée centralisée (centralized shared
memory)
 Mémoire distribuée
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Architecture possible des multiprocesseurs
Multiprocesseur
Mémoire partagée centralisée
(UMA)
Basée sur
l’espionnage
(bus)
Write invalidate
protocol
Write-through
(mémoire centrale)
Write update
protocol
Mémoire distribuée
Espace d’adressage
unique (NUMA)
Espace d’adressage
privé (multi-ordinateurs)
Basée sur
un répertoire
Cohérence
de la
mémoire
cache
Write-back
(mémoire centrale)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Mémoire partagée centralisée
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Mémoire partagée centralisée
•
La mémoire partagée centralisée (centralized
shared memory) est utilisée par des machines
d’au plus une douzaine de processeurs en 1995
•
On utilise un bus qui connecte les processeurs et
la mémoire, avec l’aide de mémoire cache locale.
•
On appelle ce type de structure de mémoire le
Uniform Memory Access (UMA).
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Mémoire distribuée
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Architecture possible des multiprocesseurs
Multiprocesseur
Mémoire partagée centralisée
(UMA)
Mémoire distribuée
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Mémoire distribuée
• La mémoire distribuée est utilisée dans des machines
utilisant « beaucoup » de processeurs, qui requièrent une
bande passante trop grande pour une mémoire unique
• « Beaucoup » tend à diminuer avec le temps, puisque la
performance des processeurs continue d’augmenter plus
rapidement que celle de la mémoire
• Avantages de la mémoire distribuée: il est plus facile
d’augmenter la bande passante de la mémoire si la plupart
des accès mémoire sont locaux. La latence est aussi
améliorée lorsqu’on utilise la mémoire locale
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Modèles de mémoire distribuée
• Il existe deux modèles de mémoire distribuée:
 Espace d’adressage unique, accessible par tous les
processeurs, mais distribué parmi les processeurs. On dit de
ce système qu’il est Non-Uniform Memory Access (NUMA),
parce que le temps d’accès à la mémoire dépend de l’endroit
où se trouve la région qui est adressée (locale ou distante)
 Espace d’adressage privé, où chaque processeur a un accès
exclusif à la mémoire locale. On appelle parfois ces systèmes
des systèmes multi-ordinateurs (multi-computers)
• Pour ces deux modèles, le mode de communication diffère:

Pour la mémoire partagée, la communication se fait de façon
implicite, en écrivant/lisant la mémoire.
 Pour la mémoire privée, on doit utiliser des messages
explicites entre les processeurs pour passer l’information de
l’un à l’autre, d’où leur nom de machines à passage de
message (Message Passing Machines)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Architecture possible des multiprocesseurs
Multiprocesseur
Mémoire partagée centralisée
(UMA)
Mémoire distribuée
Espace d’adressage
unique (NUMA)
© 2004 Frédéric Mailhot
Espace d’adressage
privé (multi-ordinateurs)
Université de Sherbrooke
Les multiprocesseurs
Avantages et inconvénients des
mécanismes de communication
•
Mémoire partagée:
 Mécanisme bien connu
 Facile à programmer (et facile de bâtir des compilateurs)
 Meilleure utilisation de la bande passante (protection de
la mémoire au niveau du matériel, et non au niveau du
système d’exploitation
 Possibilité d’utiliser des techniques de caching
•
Message-passing:
 Matériel simplifié
 Communication explicite, exigeant l’intervention du
programmeur
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Paramètres de communication
• Bande passante:
 Limitée par l’interconnection ou par les processeurs euxmêmes?
• Temps de latence
 Temps de préparation de l’envoyeur + temps de vol + (taille du
message) / (bande passante) + temps de réception.
• Élimination apparente de la latence (latency hiding)
 Comment minimiser l’impact de la latence?
 Impact au niveau du logiciel
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Limites de la programmation parallèle
• Loi de Amdahl:
Speedup =
1
_____________
Fraction(améliorée) + (1 - Fraction(améliorée)
Speedup(amélioré)
• Soit un speedup désiré de 80 avec 100 processeurs. Quelle
portion de l’application peut être séquentielle?
 Fraction(parallèle) = 0.9975 --> 0,25% maximum peut être
séquentielle
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Limites de la programmation parallèle (II)
• Importance de la latence:
 Dans les machines parallèles d’aujourd’hui, l’accès à de
l’information sur un autre processeur peut prendre entre 50 et
10,000 coups d’horloge.
• Soit une machine qui prend 2,000 ns pour un accès
mémoire à distance, une horloge de 10 ns, et un CPI de
base de 1.0. Quelle est l’impact sur le CPI si 0,5% des
instructions font un accès mémoire à distance?
 Accès à distance = 2,000 / 10 = 200 coups d’horloge
 CPI = 1.0 + 0,5% X 200 = 2.0
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Les systèmes à mémoire partagée
centralisée
•
Dans ce qui suit, nous allons maintenant étudier
comment faire un système parallèle MIMD qui
utilise de la mémoire partagée centralisée
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
La cohérence de la mémoire – qu’est-ce que
c’est?
• Comme pour les uniprocesseurs, il est essentiel pour la
performance des multiprocesseurs que le temps d’accès à
la mémoire soit raisonnable
• L’utilisation de mémoire cache est donc encore de première
importance
• Puisqu’on est en présence de plusieurs machines, il se
peut qu’une adresse mémoire utilisée par une machine
« A » soit modifiée par une machine « B ». Il faut s’assurer
que les données gardées dans les mémoires caches soient
les mêmes pour tous les processeurs. C’est ce qu’on
appelle la « cohérence » de la mémoire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Exemple du problème de cohérence de
cache
Temps Événement
Cache du
CPU A
Cache du
CPU B
0
Contenu de la mémoire,
adresse « X »
1
1
CPU A lit X
1
1
2
CPU B lit X
1
1
1
3
CPU A écrit 0
dans X
0
1
0
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Définition de la cohérence de la mémoire
•
Définition 1: Chaque lecture de la mémoire
retourne la valeur écrite le plus récemment
 Cette définition traite de 2 concepts:
• La cohérence (est-ce que la lecture retourne la bonne
valeur)
• La consistence (quand est-ce qu’une valeur écrite devient
visible?)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Définition de la cohérence
•
La mémoire est cohérente si:
 Un read par le processeur P à l’adresse X qui suit un
write à l’adresse X par le processeur P, sans qu’il n’y ait
eu d’écriture par d’autres processeurs, retourne
toujours la valeur écrite par P
 Un read par P à l’adresse X qui suit un write par Q à
l’adresse X retourne la valeur écrite par Q si les 2
événements sont assez distants dans le temps
 Les écritures au même endroit sont sérialisées
• Les écritures par deux processeurs P et Q à l’adresse X
sont vues dans le même ordre par tout processeur du
système
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Fonction de la mémoire cache
•
La mémoire cache a deux fonctions:
 La migration: On transporte les valeurs dans la mémoire
cache locale pour diminuer le temps d’accès
 La réplication: Lorsqu’une donnée est modifiée, toutes
les caches qui la détiennent doivent être infformées
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Dans un système à multiprocesseur,
comment connaître l’état des différentes
caches?
•
Il existe deux classes de protocoles de cohérence
de cache:
 Basé sur un répertoire (directory based): l’état de
partage des adresses de la mémoire est conservé dans
un endroit unique, le directory
 Basé sur l’espionnage (snooping): chaque mémoire
cache est branchée sur un bus de mémoire commun, et
écoute continuellement ce qui se passe
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Architecture possible des multiprocesseurs
Multiprocesseur
Mémoire partagée centralisée
(UMA)
Basée sur
l’espionnage
(bus)
Mémoire distribuée
Espace d’adressage
unique (NUMA)
Basée sur
un répertoire
Cohérence
de la
mémoire
cache
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Méthodes de maintient de la cohérence
• Il y a deux façons de s’assurer de la cohérence des caches:
 Obtenir l’accès exclusif de l’adresse mémoire visée
 Mettre à jour les autres copies
• L’usage exclusif de la mémoire est appelé le protocole
•
d’écriture invalidante (write invalidate protocol). Le
principe est le suivant: suivant l’écriture d’une donnée,
toutes les autres copies de cette donnée sont marquées
comme étant invalides.
La mise à jour des autres copies est appelée le protocole
d’écriture et mise à jour (write update protocol, aussi
appellé write broadcast protocol). Ici, chaque écriture est
suivie de messages de mises à jour pour les autres
versions de la même donnée.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Architecture possible des multiprocesseurs
Multiprocesseur
Mémoire partagée centralisée
(UMA)
Basée sur
l’espionnage
(bus)
Write invalidate
protocol
Write update
protocol
Cohérence
de la
mémoire
cache
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Méthodes de maintient de la cohérence (II)
• Les deux protocoles d’opération ont des caractéristiques
différentes qui infuencent leur performance:
 Dans le cas d’écritures multiples au même espace mémoire,
sans lecture intermédiaire:
•
Le protocole de mise à jour utilisera de multiples appels aux
autres machines
• Le protocole d’usage exclusif n’utilisera qu’un seul accès
d’invalidation.
 Il est possible de regrouper les mots mémoire pour le
protocole d’usage exclusif, et ainsi diminuer le nombre
d’invalidations nécessaires lors d’écriture à des adresses
adjacentes (on invalide toute un bloc de mémoire)
 Cette possibilités n’existe pas pour le protocole de mise à
jour.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Méthodes de maintient de la cohérence (III)
•
Le délai nécessaire entre l’écriture d’une donnée
et sa lecture sur une autre machine est
habituellement plus petit avec un protocole de
mise à jour
•
Le protocole d’usage exclusif est maintenant le
plus utilisé dans les machines multiprocesseurs
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Implémentation du protocole d’usage
exclusif
•
Comment réaliser ce protocole? Sur un
multiprocesseur à petite échelle, on utilise le bus
comme moyen privilégié de synchronisation.
 Pour pouvoir écrire dans la mémoire, un processeur doit
d’abord obtenir le contrôle du bus.
 Ensuite, l’adresse de la mémoire modifiée est envoyée
sur le bus.
 Tous les autres processeurs sont continuellement à
l’écoute. Si une écriture est faite à une adresse
mémoire qui est dans leur cache, cette adresse est
invalidée.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Implémentation du protocole d’usage
exclusif (II)
•
Pour la lecture, s’il y a un “cache miss”, le
processeur va demander la donnée sur le bus.
Ici, il y a 2 possibilités:
 Si la mémoire centrale est continuellement mise à jour
(write-through), alors elle peut fournir la valeur
demandée.
 Si au contraire on utilise l’écriture avec délai (writeback), il se peut que ce soit un processeur qui détienne
la valeur la plus récente. Pour ce type de machine, les
processeurs doivent écouter le bus pour la lecture
aussi, et fournir la valeur demandée en interrompant la
lecture de la mémoire centrale.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Architecture possible des multiprocesseurs
Multiprocesseur
Mémoire partagée centralisée
(UMA)
Basée sur
l’espionnage
(bus)
Write invalidate
protocol
Write-through
(mémoire centrale)
Write update
protocol
Cohérence
de la
mémoire
cache
Write-back
(mémoire centrale)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Implémentation du protocole d’usage
exclusif (III)
• On peut ajouter de l’information dans la mémoire cache
locale pour améliorer le rendement du système (write-back).
On utilise alors un bit de partage:
 Lors de l’écriture d’une adresse mémoire, on met le bit de
partage à 0.
 Lors d’écritures subséquentes, on n’informe personne de
l’écriture si le bit de partage est toujours à 0.
 Si un autre processeur lit cette adresse mémoire, le bit de
partage est mis à 1, et une écriture subséquente va donc
générer une invalidation.
•
Note: comment permettre l’accès efficace de la mémoire cache à
la fois par le processeur et par le système de surveillance du bus?
On peut tout simplement dédoubler l’information de partage. Une
façon de faire est d’utiliser des caches multi-niveaux.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Protocole « write-invalidate »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Protocole « write – invalidate » unifié
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Architecture possible des multiprocesseurs
Multiprocesseur
Mémoire partagée centralisée
(UMA)
Basée sur
l’espionnage
(bus)
Write invalidate
protocol
Write-through
(mémoire centrale)
Write update
protocol
Mémoire distribuée
Espace d’adressage
unique (NUMA)
Espace d’adressage
privé (multi-ordinateurs)
Basée sur
un répertoire
Cohérence
de la
mémoire
cache
Write-back
(mémoire centrale)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Gestion de la mémoire pour des machines à
beaucoup de processeurs
•
Lorsqu’on désire utiliser beaucoup de
processeurs, la méthode de mémoire partagée
centralisée ne fonctionne plus: les délais
deviennent trop importants
 Solution: utiliser de la mémoire partagée distribuée
• Problème (toujours le même): cohérence des
mémoires cache.
 Solution possible: on défend d’utiliser de la mémoire
cache pour les données partagées!
• C’est la solution adoptée entres autres par le Cray T3D.
Chaque nœud possède une mémoire cache uniquement
pour ses données privées (locales).
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Problème de cohérence de cache pour des
machines à beaucoup de processeurs
•
Solution possible: gestion logicielle (simplifie le
matériel), mais…
 Pas de mécanismes efficaces pour « passer » le
problème au compilateur, et faire gérer le problème de
cohérence sans l’intervention du programmeur
 On ne peut accéder à des adresses adjacentes de façon
efficace.
•
Meilleure solution: utiliser un système matériel
qui assure la cohérence des caches
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Mémoire partagée distribuée: le répertoire,
un protocole plus efficace que l’espionnage
•
Au lieu de faire de l’espionnage (snooping), du
bus de connexion des processeurs, on peut
utiliser un répertoire qui indique l’état de la
mémoire.
•
En particulier, le répertoire peut indiquer l’état de
chaque bloc de mémoire qui peut se retrouver
dans la mémoire cache.
 On y indique par exemple quelles mémoires cache ont
des copies de quels blocs de mémoire, et si la mémoire
a été modifiée (dirty bit) ou non.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Mémoire partagée distribuée: le répertoire
•
Problème avec le répertoire:
 La quantité d’information à emmagasiner est
proportionnelle au nombre de blocs de mémoire
multiplié par le nombre de processeurs. Pour plus de
100 processeurs, on peut avoir un problème d’espace
requis pour le répertoire…
• Autre problème: le répertoire lui-même peut
•
devenir le goulot d’étranglement (trop de
requêtes).
Solution: Le répertoire lui-même peut être
distribué de concert avec la mémoire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Système multiprocesseur à répertoire
distribué
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Protocole de répertoire simple
• Pour fonctionner correctement, le système doit pouvoir
gérer 2 types d’opérations:
 Les lectures manquées (« read miss »)
 Les écritures dans un bloc de mémoire partagée
• Pour ce faire, le répertoire doit contenir l’information
suivante pour chaque bloc de mémoire:
 Mémoire partagée (un ou plusieurs processeurs utilisent ce
bloc mémoire, qui est à jour)
 Mémoire non en cache (aucun processeur n’utilise une copie
de ce bloc mémoire)
 Mémoire exclusive ( un et un seul processeur utilise ce bloc,
qui a été écrit et donc qui n’est plus à jour)
• Il faut savoir quels processeurs utilisent le bloc mémoire
s’il est partagé. On peut utiliser un vecteur de bits par bloc
mémoire pour gérer cette information
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Protocole de répertoire simple (2)
•
On suppose que la machine contient un grand
nombre de processeurs.
•
Il n’est plus possible d’utiliser le bus pour
résoudre les problèmes d’accès simultanés.
• De plus, on suppose que la communication se fait
de point à point (pourquoi?)
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Protocole d’utilisation de répertoire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Les multiprocesseurs
Protocole d’utilisation de répertoire
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Le VHDL
De nos jours, les circuits numériques de haute
performance sont habituellement créés à partir
de descriptions en langages de haut niveau.
Nous allons maintenant parler de l’un de ces
langages, le VHDL
Architecture des ordinateurs II – Frédéric Mailhot
Le VHDL
Le VHDL: Qu’est-ce que c’est, et à quoi cela
sert-il?
•
•
•
•
VHDL:
VHSIC Hardware Description Language
VHSIC: Very High Speed Integrated Circuit
(projet de grande envergure du DoD
(Departement of Defense) Américain, mis en
place dans les années ’80
Principe de base:
Définir un langage de
description de matériel qui puisse être utilisé
pour simuler du matériel numérique
Extension:
Utilisation du même langage
pour la synthèse automatique de circuits
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
VHDL: Est-ce le seul HDL?
•
Il existe plusieurs autres langages de description
de matériel, entre autres:
 Verilog (Très populaire aux États-Unis, utilisé aussi en
Europe, au Japon et au Canada)
 UDL/1 (Utilisé à un certain moment au Japon)
 Estérel (langage académique – Français)
 HardwareC (langage académique – Stanford)
•
Verilog est plus simple que le VHDL, mais est un
peu moins utilisé
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
« Design Flow » moderne
Design fonctionnel
Design « Register Transfer Level »
Design Logique
Design « Physique »
Simulation comportermentale
Simulation RTL
Validation
Simulation logique
Vérification
Simulation de fautes
Analyse des délais
Analyse du circuit
« Design Rule Checking »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Concepts de base
• Description du système:
 Structurale
 Comportementale (behavioral)
•
•
•
•
Événements
Délais de propagation
Concurrence
Timing:
 Synchrone
 Asynchrone
• Signaux:
 Forme
 Valeur
 Partage
• Simulation d’événements discrets
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Pourquoi utiliser des langages HDL?
•
Pour accélérer la conception de circuits (raison
économique)
•
Pour permettre la conception de circuits très
complexes (150 millions de portes logiques d’ici 5
ans)
•
Pour pouvoir représenter les systèmes
numériques selon les différents axes
d’abstraction
© 2004 Frédéric Mailhot
Université de Sherbrooke
Revenus maximum
Pertes de revenus
Revenus
Le VHDL
Pourquoi mettre en marché plus
rapidement?
Délai
Temps
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Le « Y » de Gadjsky
Structural
Comportemental
Algorithmes
Processeurs
Register transfer
Registres
Expressions Booléennes
Fonctions de transfert
Portes
Transistors
Cellules
Modules
Circuits
Printed Circuit Board
Physique
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Valeur des signaux
•
À la base, tout système numérique est constitué
de signaux binaires. VHDL supporte le ‘bit’ au
plus bas niveau.
• Valeur possible du bit: 0 ou 1
• Est-ce suffisant?
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Valeur des signaux
Standard IEEE 1164:
Valeur Interprétation
0
0 - Forcé
1
1 - Forcé
U
Uninitialized (non-initialisé)
X
Inconnu - Forcé
Z
Haute impédance
W
Inconnu - Faible
L
0 - Faible
H
1 - Faible
-
Don’t Care
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Premier concept de base: les entités (entity)
•
Première étape de définition de matériel: définir
l’interface
•
Comment: à l’aide de la déclaration « entity »
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Les « entity »
a
b
sum
carry
•
L’interface externe du circuit ci-haut est spécifiée
par la déclaration « entity » suivante:
entity half_adder is
port(a, b: in bit;
sum, carry: out bit);
end half_adder;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple d’entity: multiplexeur de bus
entity mux is
port (I0, I1 : in std_ulogic_vector (7 downto 0);
I2, I3: in std_ulogic_vector (7 downto 0);
Sel: in std_ulogic_vector (1 downto 0);
z : out std_ulogic_vector (7 downto 0));
end mux;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple d’entity: Flip-flop
entity D_ff is
port (D,Clk, S, R: in std_ulogic;
Q, Qbar:
out std_ulogic);
end D_ff;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Deuxième concept de base: les énoncés
concurrents
•
Il faut être capable de définir la fonctionnalité de
notre système, qui représente ce que le matériel
devra effectuer
•
Puisqu’on parle de matériel, tout ce qui est décrit
va « s’exécuter » en parallèle
•
Pour décrire la fonctionnalité d’un système, on
utilise la déclaration « architecture », qui
implicitement contient des énoncés concurrents
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple d’architecture: un demiadditionneur
library IEEE;
use IEEE.std_logic_1164.all;
entity half_adder is
port(a, b: in bit;
sum, carry: out bit);
end half_adder;
architecture comportement_concurrent of half_adder is
begin
sum <= (a xor b) after 5 ns;
carry <= (a and b) after 5 ns;
end comportement_concurrent;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Signaux à source multiples
•
Qu’arrive-t-il si un signal est produit par plus
d’une source (e.g. élément d’un bus)?
•
Qu’arrive-t-il si les différentes sources ne
déterminent pas la même valeur?
• On utilise une fonction de « résolution » pour
traiter ces cas
•
Dans la librairie IEEE, le type « std_logic » du
standard 1164 est résolu
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Assignations conditionnelles
• On peut utiliser une assignation conditionnelle pour définir
la valeur d’un signal:
library IEEE;
use IEEE.std_logic_1164.all;
entity mux4 is
port (In0, In1, In2, In3: in std_logic_vector (7 downto 0);
S0, S1: in std_logic;
z: out std_logic_vector (7 downto 0));
end mux4;
architecture comportemental of mux4 is
begin
z <= In0 after 5 ns when S0 = ‘0’ and S1 = ‘0’ else
In1 after 5 ns when S0 = ‘0’ and S1 = ‘1’ else
In2 after 5 ns when S0 = ‘1’ and S1 = ‘0’ else
In3 after 5 ns when S0 = ‘1’ and S1 = ‘1’ else
‘00000000’ after 5 ns;
end comportemental;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Utilisation de sélecteurs
•
Lorsqu’il y a un grand nombre de possibilités qui
sont toutes énumérées, on peut utiliser un
sélecteur
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Utilisation de sélecteurs – exemple
library IEEE;
use IEEE.std_logic_1164.all;
entity memoire is
port (addr1,addr2: in std_logic_vector (2 downto 0);
mem1: out std_logic_vector (31 downto 0));
end memoire;
architecture comportemental of memoire is
signal reg0, reg1, reg2, reg3: std_logic_vector (31 downto 0):= to_stdlogicvector(x’’1234AB’’);
signal reg4, reg5, reg6, reg7: std_logic_vector (31 downto 0):= to_stdlogicvector(x’’5678FF’’);
begin
with addr1 select
mem1 <= reg0 after 5 ns when ‘‘000’’;
reg1 after 5 ns when ‘‘001’’;
reg2 after 5 ns when ‘‘010’’;
reg3 after 5 ns when ‘‘011’’;
reg4 after 5 ns when others;
end comportemental;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Les délais
• VHDL permet de modéliser différents types de délais, qui
sont utiles lors des simulations:
 Délais d’inertie (inertial delay): représentent la durée minimum
d’une entrée pour que son effet puisse être observé à la sortie.
Utile pour tenir compte du temps de montée/descente
• E.g.: sum <= reject 2 ns inertial (a xor b) after 5 ns;
 Délais de transport: représentent le délai encouru par les
interconnections. Utile pour tenir compte des délais RC dans
les longs fils
• E.g.: sum <= transport (a xor b) after 5 ns;
 Délais « delta »: utilisés à l’interne par les simulateurs pour
ordonner l’arrivée des signaux
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Les délais: exemple
s1
a
b
sum
s2
carry
library IEEE;
use IEEE.std_logic_1164.all;
a
entity half_adder is
port(a, b: in std_logic;
sum, carry: out std_logic);
end half_adder;
b
inertie
sum
architecture delai_transport of half_adder is
signal s1, s2: std_logic := ‘0’;
begin
s1 <= (a xor b) after 2 ns;
s2 <= (a and b) after 2 ns;
sum <= transport s1 after 4 ns;
carry <= transport s2 after 4 ns;
end delai_transport;
transport
carry
© 2004 Frédéric Mailhot
s1
s2
2
4 6 8 10 12
Temps (ns)
Université de Sherbrooke
Le VHDL
Les  délais: exemple
s1
a
s3
z
b
s2
library IEEE;
use IEEE.std_logic_1164.all;
entity circuit is
port(a, b: in std_logic;
z: out std_logic);
end circuit;
architecture circ of circuit is
signal s1, s2, s3, s4: std_logic;
begin
s1 <= not a;
s2 <= not b;
s3 <= not ( s1 and b);
s4 <= not (s2 and a);
z <= not (s3 and s4);
end circ;
s4
a
b
s1
s2
s3
s4
z
2
© 2004 Frédéric Mailhot
4 6 8 10 12
Temps (ns)
Université de Sherbrooke
Le VHDL
Les  délais: exemple
s1
a
s3
z
b
s2
s4
a
b
s1
b
s2
s2
s3
s3
s4
z
z
2
4 6 8 10 12
Temps (ns)
2
© 2004 Frédéric Mailhot
 2 3 4
Temps (ns)
Université de Sherbrooke
Le VHDL
Modélisation de comportement
•
Pour décrire des systèmes plus complexes qu’un
petit groupe de simples portes logiques, nous
devons ajouter un nouveau concept: le
processus (process)
•
Le «process » a une liste de dépendance
(dependency list). Lorsqu’un ou plusieurs
signaux de la liste sont modifiés, le process est
enclenché
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Les processus: exemple
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
begin
addr_int := to_integer(addr (1 downto 0));
if (Mem_wr = ‘1’ then
entity mem is
port(addr: in std_logic_vector (31 downto 0);
data_memo(addr_int) := wr_data;
elsif Mem_rd = ‘1’ then
wr_data: in std_logic_vector (31 downto 0);
Mem_wr, Mem_rd: in std_logic;
rd_data: out std_logic_vector (31 downto 0);
end mem;
rd_data <= data_memo(addr_int);
end if;
end process memo_proc;
end comport;
architecture comport of mem is
type memo_arr is array(0 to 3) of std_logic_vector
(31 downto 0);
begin memo_proc: process ( addr, wr_data)
variable data_memo: memo_arr := (
to_stdlogicvector(X’’00000000’’),
to_stdlogicvector(X’’00000000’’),
to_stdlogicvector(X’’00000000’’),
to_stdlogicvector(X’’00000000’’));
variable addr_int: integer;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
If, Case, For et While
•
À l’intérieur d’un « process », on peut utiliser des
« if » et/ou des « case ». L’exécution est alors
séquentielle
•
De même, on peut utiliser des boucles pour
contrôler l’exécution. Les « for » sont à bornes
fixes, alors que les « while » ne le sont pas.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
If, case: exemple
library IEEE;
carry_proc: process (a, b)
use IEEE.std_logic_1164.all;
begin
case a is
entity half_adder is
when ‘0’ =>
port(a, b: in bit;
carry <= a after 5 ns;
sum, carry: out bit);
when ‘1’ =>
end half_adder;
carry <= b after 5 ns;
when others =>
architecture proc_add of half_adder is
carry <= ‘X’ after 5 ns;
begin
end case;
sum_proc: process (a, b)
end process carry_proc;
begin
if (a = b) then
end proc_add;
sum <= ‘0’ after 5 ns;
else
sum <= (a or b) after 5 ns;
end if;
end process sum_proc;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
For loop: exemple
library IEEE;
begin
use IEEE.std_logic_1164.all;
mult_reg := mult1;
use IEEE.std_logic_arith.all;
prod_reg (63 downto 0) :=
to_ stdlogicvector(X’’00000000’’) & mult2;
entity mult32 is
for index in 1 to 32 loop
if prod_reg(0) = ‘1’ then
port(mult1: in std_logic_vector (31 downto 0);
prod_reg(63 downto 32) :=
mult2: in std_logic_vector (31 downto 0);
prod_reg(63 downto 32)
prod: out std_logic_vector (63 downto 0));
+ mult_reg(31 downto 0);
end mult32;
end if;
prod_reg(63 downto 0) :=
architecture comp_mult of mult32 is
‘0’ & prod_reg (63 downto 1);
constant delai_module: Time:= 10 ns;
end loop;
begin
mult_proc: process (mult1, mult2)
variable prod_reg : std_logic_vector (63 downto 0)
:= to_stdlogicvector(X’’0000000000000000’’);
prod <= prod_reg after delai_module;
end process mult_proc;
end comp_mult;
variable mult_reg : std_logic_vector (31 downto 0)
:= to_stdlogicvector(X’’00000000’’);
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Communication entre processus
•
Les signaux sont globaux: il est possible à un
processus d’accéder (lire et/ou écrire) un signal
d’un autre processus
•
La communication entre processus se fait donc à
l’aide de signaux
•
Note: on parle ici de processus qui font partie
d’une même architecture…
•
Exemple: additionneur 1-bit
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de communication entre
processus: additionneur 1-bit
In1
In2
s1
Demi-additionneur
HA1
Demi-additionneur
HA2
s2
C_in
Demi-additionneur
Somme
s3
C_out
OR1
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de communication entre
processus: additionneur 1-bit
library IEEE;
use IEEE.std_logic_1164.all;
HA2: process(s1, C_in)
begin
Somme <= (s1 xor C_in) after delai;
entity add_1_bit is
port(In1, In2, C_in: in std_logic;
Somme, C_out: out std_logic);
end add_1_bit;
s2 <= (s1 and C_in) after delai;
end process HA2;
OR1: process(s2, s3)
begin
C_out <= (s2 or s3) after delai;
architecture comp_add of add_1_bit is
signal s1, s2, s3: std_logic;
constant delai: Time:= 5 ns;
begin
HA1: process(In1, In2)
begin
s1 <= (In1 xor In2) after delai;
s3 <= (In1 and In2) after delai;
end process HA1;
end process OR1;
end comp_add;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
L’instruction « wait »
•
Il est possible de définir un « process » sans liste
de dépendance. Chaque « process » est toujours
exécuté au moins une fois, au début
•
En ajoutant des énoncés « wait », il devient
possible d’indiquer que le « process » sera
réveillé à un certain endroit, selon une certaine
condition:
 wait for time
 wait on signal
 wait until condition
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Les attributs dans VHDL
•
Il existe un certain nombre d’attributs avec le
VHDL, qui permettent d’utiliser de l’information
sur l’état des signaux ou sur leur définition:
 Var’event
: Changement sur Var
 Var’active
: Assignation sur Var (peut être la
même valeur
 Var’last_event
: Retourne le temps depuis le dernier
 Var’last_value
événement
: Retourne la valeur précédente de Var
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de wait et d’attributs: flip-flop
library IEEE;
use IEEE.std_logic_1164.all;
entity dff is
port(D, Clk: in std_logic;
Q, QN: out std_logic);
end dff;
architecture comp_dff of dff is
constant delai: Time:= 5 ns;
begin
One_ff: process
begin
wait until (Clk’event and Clk = ‘1’);
Q <= D after delai;
QN <= not D after delai;
end process One_ff;
end comp_dff;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de wait et d’attributs: flip-flop
asynchrone
library IEEE;
use IEEE.std_logic_1164.all;
entity async_dff is
port(D, Clk, S, R: in std_logic;
Q, QN: out std_logic);
end async_dff;
architecture comp_adff of async_dff is
elsif (S = ‘1’) then
Q <= ‘1’ after delai;
QN <= ‘0’ after delai;
elsif (Clk’event and Clk = ‘1’) then
Q <= D after delai;
QN <= not D after delai;
end if;
end process One_aff;
end comp_adff;
constant delai: Time:= 5 ns;
begin
One_aff: process(R, S, Clk)
begin
if (R = ‘1’) then
Q <= ‘0’ after delai;
QN <= ‘1’ after delai;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de registre
library IEEE;
use IEEE.std_logic_1164.all;
entity registre is
port(D: in std_logic_vector (31 downto 0);
Cl, enable, Clk : in std_logic;
Q : out std_logic_vector (31 downto 0));
elsif (Clk’event and Clk = ‘1’) then
if (enable = ‘1’) then
Q <= D after delai;
end if;
end if;
end process Reg_proc;
end comp_reg;
end registre;
architecture comp_reg of registre is
constant delai: Time:= 5 ns;
begin
Reg_proc: process(Cl, Clk)
begin
if (Cl = ‘1’) then
Q <= X’’00000000’’ after delai;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Génération d’une horloge
•
À l’aide du VHDL, il est facile de générer un signal
d’horloge périodique:
library IEEE;
use IEEE.std_logic_1164.all;
entity horloge is
port(Clk : out std_logic);
end horloge;
architeture comp_horloge of horloge is
begin
proc_horloge: process
Clk <= ‘0’, ‘1’ after 5 ns;
wait for 10 ns;
end process proc_horloge;
end comp_horloge;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Les process: ils peuvent
a
ne pas faire ce que
vous pensez…
b
s1
z
s2
library IEEE;
use IEEE.std_logic_1164.all;
library IEEE;
use IEEE.std_logic_1164.all;
entity circuit is
port(a, b: in std_logic;
z: out std_logic);
end circuit;
entity circuit is
port(a, b: in std_logic;
z: out std_logic);
end circuit;
architecture circ of circuit is
signal s1, s2, s3, s4: std_logic;
begin
s1 <= not a;
s2 <= not b;
s3 <= not ( s1 and b);
s4 <= not (s2 and a);
z <= not (s3 and s4);
end circ;
s3
architecture circ of circuit is
signal s1, s2, s3, s4: std_logic;
begin
process(a, b)
begin
s1 <= not a;
s2 <= not b;
s3 <= not ( s1 and b);
s4 <= not (s2 and a);
z <= not (s3 and s4);
end process;
© 2004 Frédéric Mailhot
end circ;
s4
Université de Sherbrooke
Le VHDL
Les process: ils peuvent
a
ne pas faire ce que
vous pensez…
b
a
a
b
b
s1
s1
s2
s2
s3
s3
s4
s4
z
z
2
4 6 8 10 12
Temps (ns)
s1
z
s2
2
© 2004 Frédéric Mailhot
s3
s4
4 6 8 10 12
Temps (ns)
Université de Sherbrooke
Le VHDL
Représentation hiérarchique
•
On peut utiliser VHDL de façon hiérarchique et
ainsi simplifier la description d’une machine
complexe.
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: portes XOR et AND
library IEEE;
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_1164.all;
entity one_xor is
entity one_and is
port(In1, In2 : in std_logic;
port(In1, In2 : in std_logic;
Z: out std_logic);
Z: out std_logic);
end one_xor;
end one_and;
architecture comp_xor of one_xor is
architecture comp_and of one_and is
constant delai: Time:= 5 ns;
constant delai: Time:= 5 ns;
begin
begin
z <= (In1 xor In2) after delai;
end comp_xor;
z <= (In1 and In2) after delai;
end comp_and;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: porte OU
library IEEE;
use IEEE.std_logic_1164.all;
entity one_or is
port(In1, In2 : in std_logic;
Z: out std_logic);
end one_or;
architecture comp_or of one_or is
constant delai: Time:= 5 ns;
begin
z <= (In1 or In2) after delai;
end comp_or;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: demi-additionneur
library IEEE;
use IEEE.std_logic_1164.all;
entity one_half_adder is
port(In1, In2 : in std_logic;
sum, c_out: out std_logic);
end one_half_adder;
architecture comp_ha of one_half_adder is
component xor_gate
port (In_1, In2: in std_logic;
z: out std_logic);
end component;
for XOR1: xor_gate use entity
work.one_xor(comp_xor);
for AND1: and_gate use entity
work.one_and(comp_and);
begin
XOR1:xor_gate port map(In1, In2, sum);
AND1:and_gate port map(In1, In2,
c_out);
end comp_ha;
component and_gate
port (In_1, In2: in std_logic;
z: out std_logic);
end component;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: l’ensemble
library IEEE;
use IEEE.std_logic_1164.all;
entity one_adder is
port(In1, In2, C_in : in std_logic;
sum, c_out: out std_logic);
end one_adder;
for HA1: half_addr use entity
work.one_half_adder(comp_ha);
for HA2: half_addr use entity
work.one_half_adder(comp_ha);
for OR1: or_gate use entity
work.one_or(comp_or);
signal s1, s2, s3: std_logic;
architecture comp_add of one_adder is
component half_addr
port (In_1, In2: in std_logic;
sum, c_out: out std_logic);
end component;
component or_gate
port (In_1, In2: in std_logic;
z: out std_logic);
begin
HA1:half_addr port map(In1, In2, s1,
s3);
HA2:half_addr port map(s1, C_in, sum,
s2);
OR1:or_gate port map(s2, s3, c_out);
end comp_add;
end component;
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
La synthèse automatique de
circuits
Comment fait-on pour faire le design des
processeurs et des circuits numériques en
général?
Ce qui suit donne un aperçu des différentes
techniques utilisées à cette fin.
Architecture des ordinateurs II – Frédéric Mailhot
La synthèse automatisée de circuits
Qu’est-ce que la synthèse?
•
Depuis maintenant plus de 15 ans, le design de
circuit numériques complexes passe presque
toujours par la synthèse automatisée:
 Les circuits sont trop complexes pour pouvoir en faire
le design sans aide
 Le temps requis pour parvenir à la mise en marché
(« time to market ») est capital, d’où l’importance
d’utiliser des méthodes rapides et qui garantissent
l’atteinte des résultats escomptés de performance
 La méthodologie actuelle de synthèse de circuit permet
de produire plus rapidement des circuits plus
performants
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Les étapes de la synthèse de circuits
Analyse syntaxique
Synthèse de haut niveau
Scheduling
Restructuring
Allocation des ressources
Retiming
Synthèse 2 niveaux
Synthèse logique
Extraction de noyaux
Synthèse multi-niveaux
Technology mapping
Lien avec la technologie
Buffering
Global: floorplan
Placement
Synthèse physique
Local
Routage
Global – Vdd, Vss, Bus
Local
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Les étapes de la synthèse de circuits
Analyse syntaxique
Synthèse de haut niveau
Scheduling
Restructuring
Allocation des ressources
Retiming
Synthèse 2 niveaux
Synthèse logique
Extraction de noyaux
Synthèse multi-niveaux
Technology mapping
Lien avec la technologie
Buffering
Global: floorplan
Placement
Synthèse physique
Local
Routage
Global – Vdd, Vss, Bus
Local
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse de haut niveau
•
À partir d’un langage de description de matériel
(VHDL, Verilog), on extrait un graphe qui
représente la fonctionalité:
 Graphe de dépendance de données (data flow graph)
 Graphe de séquencement (sequencing graph)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Graphe de dépendance de données (data
flow graph)
•
Représente les liens entre les différents
composants qui produisent un certain
comportement. Ici, les nœuds représentent les
opérations, et les arcs représentent les
dépendances entre les opérations
• Exemple: Soit la portion de code suivante:
xl = x + dx
ul = u – ( 3 * x * u * dx) – ( 3 * y * dx)
yl = y + u * dx
c = xl < a
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Graphe de dépendance de données (2)
x u dx 3
3
y u dx x
dx
xl = x + dx
*
*
*
dx
*
y
*
+
*
a
xl
+
<
– ( 3 * y * dx)
yl = y + u * dx
c = xl < a
u
yl
-
ul = u – ( 3 * x * u * dx)
c
ul
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Graphe de dépendance de données (2)
x u dx 3
3
y
x
dx
xl = x + dx
*
*
dx
*
+
*
y
*
a
xl
+
<
yl
-
– ( 3 * y * dx)
yl = y + u * dx
c = xl < a
u
-
ul = u – ( 3 * x * u * dx)
c
Optimisation possible
ul
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Graphe de sequencement (sequencing
graph)
•
•
Extension du graphe de dépendance de données
Utile pour représenter à la fois la partie opérative
et la partie contrôle d’un circuit (data-path et
control path)
• Ajouts au graphe de dépendance de données:
 Hiérarchie
 Commandes de contrôle de données (boucles et
branchements)
 Graphe polaire, avec une source et un puit (source et
sink)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Graphe de séquencement
NOP
xl = x + dx
*
*
*
*
+
ul = u – ( 3 * x * u * dx)
– ( 3 * y * dx)
*
+
*
<
yl = y + u * dx
c = xl < a
NOP
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Utilisation du graphe de séquencement
•
Chaque nœud est soit:
 En attente d’exécution
 En exécution
 Après l’exécution
•
On suppose qu’un nœud est exécuté lorsque
tous ses fanins ont complété leur exécution
•
On annote les nœuds avec des informations
supplémentaires:
 Délai
 Surface
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Transformation du HDL
• On lit d’abord le HDL, et à l’aide d’un analyseur syntaxique
(parser), on crée le graphe correspondant
• Le graphe initial est transformé:
 Réduction de la hauteur des arbres
 Propagation des constantes
 Élimination de sous-expressions communes
 Élimination de code mort
 Réduction de la complexité des opérateurs
 Déplacement de code
 Expansion des boucles
 Expansion des conditions
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Transformations:
•
Réduction de la hauteur des arbres:
x=a+b*c+d
Devient
x = (a + d) + (b * c)
• Propagation de constantes:
a = 0; b = a + 1; c = 2 * b;
devient
a = 0; b = 1; c = 2;
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Transformations: (2)
•
Élimination de sous-expressions communes:
a = x + y; b = a + 1; c = x + y;
Devient
a = x + y; b = a + 1; c = a;
• Élimination de code mort:
a = x; b = x + 1; c = 2 * x;
devient
b = x + 1; c = 2 * x;
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Transformations: (3)
•
Réduction de la complexité d’un opérateur:
a = x^2; b = 3 * x;
Devient
a = x * x; t = x << 1; b = x + t;
• Déplacement de code :
for (i = 1; i < a * b) {}
devient
t = a * b; for ( i = 1; i < t) {}
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Transformations: (4)
•
Expansion des boucles:
x = 0; for (i = 1; i < 3; i++) {x = x + i;}
Devient
x = 0; x = x + 1; x = x + 2; x = x + 3;
• Expansion des conditions (variables logiques):
y = a b; if (a) {x = b + d;} else {x = b d;}
devient
y = a b; x = y + d ( a + b);
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Les ressources
•
On peut séparer les ressources d’un circuit en 3
classes:
 Les ressources fonctionnelles, qui transforment les
données (e.g. additionneur, multiplieur)
 Les ressources de mémoires, qu’on utilise pour
conserver les données (e.g. mémoire vive, registres)
 Les ressources d’interface (e.g. bus et ports
d’entrées/sorties)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Les contraintes
•
Pour un circuit donné, il y aura typiquement des
contraintes de surface et de délai
•
Les contraintes de surface (et de délai, les 2 sont
souvent corrélées) ont un impact sur le choix des
ressources
Les contraintes de délai proviennent souvent de
la période de l’horloge projetée, ainsi que des
temps d’arrivée des entrées et des temps requis
des sorties. Elles ont un impact sur le
séquencement des opérations dans le temps
(scheduling)
•
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Scheduling
•
Étant donné un graphe de
séquencement et un
ensemble de contraintes,
on doit:
- décider quelle ressource
utiliser pour chaque
nœud
- décider quand effectuer
NOP
*
*
*
*
*
+
*
+
<
NOP
l’opération (scheduling)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Scheduling (2)
•
On peut procéder de 2 façons pour résoudre le
problème de l’allocation de ressource et du
scheduling:
 Commencer par le scheduling, et enchaîner avec
l’allocation de données
 Procéder à l’inverse
•
Puisque le facteur important est habituellement le
délai, on commence souvent par le scheduling
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Scheduling (3)
•
On va établir les deux solutions extrêmes:
 Dès que possible
 Aussi tard que possible
NOP
*
*
*
NOP
*
*
+
*
+
<
*
*
-
*
*
-
NOP
T=2
*
-
T=1
*
+
+
<
T=3
T=4
NOP
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Scheduling (4)
•
À l’aide des 2 extrêmes de scheduling, on établit
la « mobilité », i.e. l’ensemble des positions (dans
le temps) possibles pour les nœuds
•
Il s’agit ensuite de trouver une des ces positions
qui satisfait les contraintes de délai du système
 On utilise l’algorithme de Bellman-Ford pour établir la
faisabilité du système (détecte les boucles dans le
graphe)
 On utilise l’algorithme de Liao-Wong pour trouver une
solution valable.
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Allocation de ressources
•
Soit à la suite du scheduling, ou de concert avec
le scheduling, on doit décider des ressources
(e.g. additionneurs, multiplieurs) qui sont requis
 On peut toujours réutiliser la même ressource pour
toutes les opérations, à condition d’introduire des délais
dans l’exécution des opérations et d’utiliser des
multiplexeurs…
•
Lorsque scheduling et allocation de ressources
sont terminés, on produit une description logique
du système, qui prend la forme d’un ensemble
d’équations booléennes interreliées
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Réseau Booléen
•
On appelle « réseau Booléen » le système
d’équation produit:
x = a + b;
t = a b’ + a’b;
y=tc
z = x + t;
w = z’ + y;
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Les étapes de la synthèse de circuits
Analyse syntaxique
Synthèse de haut niveau
Scheduling
Restructuring
Allocation des ressources
Retiming
Synthèse 2 niveaux
Synthèse logique
Extraction de noyaux
Synthèse multi-niveaux
Technology mapping
Lien avec la technologie
Buffering
Global: floorplan
Placement
Synthèse physique
Local
Routage
Global – Vdd, Vss, Bus
Local
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse logique: 1ère étape: synthèse à 2
niveaux
•
Les équations logiques produites par la synthèse
de haut niveau sont souvent beaucoup plus
complexes que nécessaires.
•
La première étape est de simplifier chaque
équation, qui apparaît à ce stade sous forme de
somme de produits:
 On tente de limiter le nombre de « litéraux », i.e. le
nombre de fois que les variables ou leur complément
apparaissent dans les équations
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux
•
On représente le circuit par un ensemble de
fonctions à n entrées et m sorties
•
Par exemple:
 f: B3 -> {0, 1, *} 2
 f1 = a’ b’ c’ + a’ b’ c + a b’ c + a b c + a b c’
 f2 = a’ b’ c + a b’ c
a’ b c
a’ b’ c
c
b
a
a b c’
f1
abc
a b’ c
a b c’
a’ b’ c’ f a b’ c’
2
© 2004 Frédéric Mailhot
Diagramme de Hasse
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: minterms
c
b
a
f1
f2
• Minterms de f1: a’ b’ c’, a’ b’ c, a b’ c, a b c, a b c’
• Minterms de f2: a’ b’ c, a b’ c
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: cubes
c
b
a
•
f1
f2
Cubes de f1: Tous les minterms de f1 +
a’ b’, b’ c, a c, a b
• Cubes de f2: Tous les minterms de f2 + b’ c
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: implicants multisorties


c
b
a



f1
f2
• En utilisant l’encodage suivant:
{0,1,*} pour les entrées inversées (0), directes (1) ou qui
n’aparaissent pas (*)
{0,1} pour les sorties qui ont une valeur VRAI ou DON’T CARE (1) ou
INDÉFINIES (0)
•
On obtient les codes suivants pour l’exemple ci-haut:
: 00* 10
: 1*1 10
: *01 11
: 11* 10
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: couverture

c
b
a
•
•
•




f1
f2
Une couverture est un ensemble d’implicants qui couvrent tous
les minterms d’une fonction, sans intersecter les zéros (off-set) de
celle-ci
La couverture minimum est celle qui a la plus petite cardinalité
(plus petit nombre d’implicants)
Exemple: 3 couvertures possibles pour f1 et f2:
C1 = 00* 10
C2 = 00* 10
C3 = 00* 10
*01 11
*01 11
*01 01
1*1 10
11* 10
1*1 10
11* 10
11* 10
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: couverture nonredondante

c
b
a




f1
f2
• Couverture qui est non-redondante, et minimum
• Note: la couverture minimum n’est pas nécessairement
celle qui a le coût le plus bas (tout dépend du coût associé
à chacun des implicants). Toutefois, pour les besoins de
l’optimisation à 2 niveaux, il est habituel de confondre les
deux (dit autrement, on suppose que le coût de chaque
implicant est le même)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: couverture nonredondante

c
b
a




f1
f2
Couverture qui n’est PAS non-redondante, et PAS minimum

c
b
a




f1
f2
Couverture qui est non-redondante, mais PAS minimum
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: couverture première
c
b
a
•
•

f1
f2
Un implicant est premier s’il n’est pas strictement
contenu dans aucun autre implicant de la
fonction considérée
Dans l’exemple plus haut, a’b’ est premier, mais
a’b’c’ n’est pas premier (a’b’  a’b’c’)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: couverture première,
non-redondante

c
b
a




f1
f2
Couverture première, mais PAS non-redondante ( n’est pas nécessaire)

’

c
b
a ’
’
f1
f2
Couverture qui n’est PAS première, mais qui EST non-redondante
(’, ’ et ’ ne sont pas premiers)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: définitions
•
Couverture non-redondante: couverture dont on
ne peut enlever aucun implicant sans modifier la
fonction couverte
•
Implicant premier: implicant qui n’est contenu en
entier dans aucun autre implicant
•
Couverture première: couverture dont tous les
implicants sont premiers
•
Couverture minimale: couverture dont le nombre
d’implicants est minimal
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: implicants essentiels
•
Un implicant premier est essentiel s’il couvre un minterm qui n’est
couvert par aucun autre implicant de la couverture de la fonction

c
b
a




f1
f2
: 00* 10
est essentiel pour 000 1-
: *01 11
est essentiel pour *01 -1
: 1*1 10
: 11* 10
est essentiel pour 110 1-
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: but
•
Idéalement: obtenir une couverture minimum
 Méthodes standard: Quine-McCluskey, Espresso exact:
• Génèrent tous les implicants premiers
• Établissent la couverture minimum
 Problème: Exigences de calcul trop grandes (NPcomplet)
•
But plus réalisable: obtenir une couverture
première et non-redondante (peut être fait en
utilisant des méthodes heuristiques rapides)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: quelques méthodes
courantes
•
Expansion (expand): rend une couverture
première et élimine chaque implicant directement
contenu dans un autre implicant
c
b
a
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: quelques méthodes
courantes (2)
•
Réduction (reduce): rend une couverture non
première, en réduisant la taille d’implicants
individuels
c
b
a
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: quelques méthodes
courantes (3)
•
Déformation (reshape): modifie une couverture
en opérant sur une paire d’implicants, l’un étant
changé par expansion, l’autre par réduction
c
b
a
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse à 2 niveaux: quelques méthodes
courantes (4)
•
Non-redondant (irredundant): rend une
couverture non-redondante
c
b
a
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse 2 niveaux: sommaire
•
•
•
Pour la synthèse à 2 niveaux, on utilise un
ensemble de méthodes heuristiques (par exemple
expansion, réduction, déformation et nonrédondant)
Les méthodes heuristiques sont utilisées de
façon itérative sur une réprésentation compacte
des équations logiques, jusqu’à ce la taille de
celles-ci soit minimisée
Espresso, mis au point chez IBM (Yorktown) et
ensuite à Berkeley, est l’outil de choix pour la
synthèse 2 niveaux depuis près de 20 ans.
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Les étapes de la synthèse de circuits
Analyse syntaxique
Synthèse de haut niveau
Scheduling
Restructuring
Allocation des ressources
Retiming
Synthèse 2 niveaux
Synthèse logique
Extraction de noyaux
Synthèse multi-niveaux
Technology mapping
Lien avec la technologie
Buffering
Global: floorplan
Placement
Synthèse physique
Local
Routage
Global – Vdd, Vss, Bus
Local
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux - Introduction
•
La synthèse à 2 niveaux permet d’optimiser
l’expression de chaque expression logique
individuelle, mais on doit aussi souvent
restructurer le réseau Booléen, i.e. modifier les
fonctions des équations logiques et leur
interdépendance.
•
Pour ce faire, on doit faire des opérations qui
vont ajouter/modifier/enlever des nœuds du
réseau Booléen
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – Introduction (2)
• Le problème de restructuration optimum d’un réseau de
portes logiques est extrêmement complexe. Encore une
fois, il n’est pas possible d’obtenir de solution exacte, et on
doit recourir à des approches heuristiques
• Il existe 2 écoles de pensées pour faire la synthèse multiniveaux:
 Utilisation de règles (rule base)
 Utilisation d’algorithmes
• De nos jours, la majorité des outils de synthèse utilisent
des algorithmes, que nous allons maintenant étudier
brièvement
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux
• Le but de cette étape est de modifier les équations logiques
et leurs relations, en vue d’obtenir un « meilleur » circuit
• À ce stade de la synthèse, on utilise des équations logiques
comme base de représentation. Il est donc difficile de
savoir précisément le délai et/ou la surface des portes
logiques qu’on modifie
• Il apparaît qu’il y a une assez bonne corrélation entre le
nombre total de litéraux dans les équations et le délai et la
taille du circuit final. On utilise donc souvent le nombre de
litéraux comme métrique pour mesurer si une opération
donne de bons résultats ou non.
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – Les
transformations
• De nombreuses techniques heuristiques existent pour
•
changer la structure des équations logiques. Typiquement,
on utilise des opérations locales qui font évoluer
progressivement le réseau Booléen vers un circuit de
meilleure qualité
Techniques utilisées:






Élimination
Extraction
Décomposition
Simplification
Substitution
Factorisation
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – les
transformations (2)
•
Soit le réseau Booléen suivant. Les exemples qui suivent
démontrent les différentes transformation du circuit
a
b
v = a’d + b d + c’d + a e’
p=ce+de
r = p + a’
w
s = r + b’
x
c
d
e
t=ac+ad+bc+bd+e
q=a+b
y
u = q’ c + q c’ + q c
© 2004 Frédéric Mailhot
z
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – les
transformations (3)
•
Élimination (un nœud interne est enlevé, et la variable
correspondante est remplacée par son équation)
a
b
v = a’d + b d + c’d + a e’
p=ce+de
w
r = p + a’ + b’ s = r + b’
x
c
d
e
t=ac+ad+bc+bd+e
q=a+b
y
u = q’ c + q c’ + q c
© 2004 Frédéric Mailhot
z
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – les
transformations (4)
•
Extraction (une sous-expression commune à deux nœuds ou plus
est extraite et devient un nouveau noeud
a
b
v = a’d + b d + c’d + a e’
p=k
ce+de
w
r = p + a’
s = r + b’
x
c
d
e
t == ac c+ +da d + tb=ck+ab+dk+be+ e
k
q=a+b
u = q’ c + q c’ + q c
© 2004 Frédéric Mailhot
y
z
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – les
transformations (5)
•
Décomposition (Séparation d’un nœud complexe en un ensemble
d nœuds plus simples
a
b
jv==a’
a’d
+b
++
b cd + c’d + a ve’= j d + a e’
p=ce+de
r = p + a’
s = r + b’
w
x
c
d
e
t=ac+ad+bc+bd+e
q=a+b
y
u = q’ c + q c’ + q c
© 2004 Frédéric Mailhot
z
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – les
transformations (6)
•
•
Simplification: utilisation de techniques 2 niveaux
Substitution (Ajout d’entrées pour simplifier un nœud)
a
b
v = a’d + b d + c’d + a e’
p=ce+de
r = p + a’
w
s = r + b’
x
c
d
e
t=q
a c + aq d
d ++ be c + b d + e
q=a+b
y
u = q’ c + q c’ + q c
© 2004 Frédéric Mailhot
z
Université de Sherbrooke
La synthèse automatisée de circuits
Synthèse multi-niveaux – les
transformations (7)
•
Factorisation (Identification de facteurs dans les équations)
a
b
v = (a’
a’d++bb+dc’)
+ c’d
d ++a ae’e’
p = (c
c e++d)d ee
r = p + a’
w
s = r + b’
x
c
d
e
t = (a
a c++b)a (c
d ++ bd)c++eb d + e
q=a+b
y
u = q’ c + q c’ + q c
© 2004 Frédéric Mailhot
z
Université de Sherbrooke
La synthèse automatisée de circuits
Les étapes de la synthèse de circuits
Analyse syntaxique
Synthèse de haut niveau
Scheduling
Restructuring
Allocation des ressources
Retiming
Synthèse 2 niveaux
Synthèse logique
Extraction de noyaux
Synthèse multi-niveaux
Technology mapping
Lien avec la technologie
Buffering
Global: floorplan
Placement
Synthèse physique
Local
Routage
Global – Vdd, Vss, Bus
Local
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Le technology mapping
• De l’étape d’optimisation multi-niveaux on obtient un circuit
qui est « meilleur » qu’auparavant, mais qui est toujours
sous forme d’équations logiques inter-reliées. Pour la
suite, il faut maintenant remplacer les équations logiques
par des portes logiques provenant de la bibliothèque de
cellules cible.
• Le but du technology mapping est de produire un circuit
qui ne contiennent que des portes logiques « réelles », et
qui évidemment soit un circuit avec la même fonctionnalité
que le circuit initial
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Le technology mapping – les étapes
•
On procède en 4 étapes pour faire cette
opération:
1. Partitionnement
2. Décomposition
3. Matching
4. Couverture
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
1. Le partitionnement
•
La première étape consiste à identifier les sous-circuits qui
contiennent un ensemble de portes interconnectées qui
convergent vers une porte unique. Cette dernière produit la seule
sortie du sous-circuit dont elle fait partie. Cette porte est soit
connectée à une sortie du circuit, soit connectée à plus d’une
porte.
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
2. La décomposition
•
Pour chaque partition du circuit, on doit s’assurer
que les équations qui y sont incluses ont un
maximum de 2 entrées. Lorsque les équations
utilisent plus de 2 entrées, on effectue une
décomposition simple en portes à 2 entrées
(portes OU, ET et dans certains cas OUEXCLUSIF)
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
3. Le matching
•
Pour une certaine partition et sa décomposition en portes à 2
entrées, on énumère tous les « cutsets », et pour chacun de ces
« cutsets », on détermine si la fonction sous-tendue est
équivalente à une ou plusieurs portes logiques de la bibliothèque
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
3. Le matching: comment établir
l’équivalence
•
On utilise des BDDs (Binary Decision Diagram)
pour comparer la fonction logique sous-tendue
par un certain cutset et les portes logiques
disponibles dans la bibliothèque
Portion de la partition
Bibliothèque
© 2004 Frédéric Mailhot
…
Université de Sherbrooke
La synthèse automatisée de circuits
4. Couverture
•
Lorsque tous les éléments de bibliothèque qui
correspondent à une partie d’une partition sont
connus, on doit déterminer quels éléments
choisir pour couvrir le sous-circuit
•
On utilise la « programmation dynamique »
(dynamic programming) pour déterminer
l’assemblage optimal d’éléments de bibliothèque
© 2004 Frédéric Mailhot
Université de Sherbrooke
La synthèse automatisée de circuits
Les étapes de la synthèse de circuits
Analyse syntaxique
Synthèse de haut niveau
Scheduling
Restructuring
Allocation des ressources
Retiming
Synthèse 2 niveaux
Synthèse logique
Extraction de noyaux
Synthèse multi-niveaux
Technology mapping
Lien avec la technologie
Buffering
Global: floorplan
Placement
Synthèse physique
Local
Routage
Global – Vdd, Vss, Bus
Local
© 2004 Frédéric Mailhot
Université de Sherbrooke
Gei 431
Synthèse logique:
Quelques algorithmes et techniques
La synthèse logique consiste en un très grand
nombre d’opérations diverses, qui doivent
produire un circuit performant (délai,
puissance, taille, etc).
Dans ce qui suit, nous examinerons les Binary
Decision Diagrams (BDD), leur utilisation dans
un problème de couverture, et nous
inventerons un algorithme de création
d’arbres de buffers.
Architecture des ordinateurs II – Frédéric Mailhot
BDDs et buffering
Les BDD
•
Les Binary Decision Diagrams (BDD) ont été
proposés en 1986 par Randy Bryant, pour
représenter efficacement les fonctions
booléennes.
•
Problème: soit une fonction booléenne de N
variables. Sa représentation par un tableau de
vérité (ou un tableau de Karnaugh, qui est
équivalent) requière 2^N bits. Lorsque N est
grand (N>30), cette taille devient prohibitive.
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Les BDD (suite)
• Idée:
 Représenter les fonctions logiques à l’aide d’un graphe qui
permet de réutiliser des parties communes.
 Plus spécifiquement, utiliser la décomposition de Boole (aussi
appelée décomposition de Shannon), ce qui produit tout
simplement un réseau de multiplexeurs contrôlés par les
variables d’entrée de la fonction:
• F(…, x, …) = x * Fx + x’ * Fx’
• Exemple: f = a + b c
F = a * fa + a’ * fa’
F = a * 1 + a’ * (b c)
F = a + a’ * (b c)
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Exemple simple de BDD
•
Exemple: f = a + b c
F = a * fa + a’ * fa’
F = a * 1 + a’ * (b c)
F = a * 1 + a’ * ( b * (c) + b’ * 0)
F = a * 1 + a’ * (b * (c * 1 + c’ * 0) + b’ * 0)
F
a
01
b
c
01
0
01
0
© 2004 Frédéric Mailhot
1
1
Université de Sherbrooke
BDDs et buffering
Les BDD – autres règles de création
•
Autres règles:
 La décomposition de Boole doit se faire avec le même
ordre de variables dans tous les chemins entre les
entrées et les sorties. On dit dans ce cas que le BDD est
ordonné (Ordered Binary Decision Diagram, ou OBDD)
 Les sous-circuits identiques doivent être partagés. On
dit alors que le BDD est réduit
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Exemple de BDD ordonné, et non-ordonné
• Exemple: f = a (b + c) + a’ b’ c
F
a
a
01
c
b
F
0
1
01
01
1
b
01
01
0 0
c
1
01
b
c
0
01
0
1
b
01
01
1
01
0
c
1
Ordonné (bon)
Non-ordonné (mauvais)
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Exemple de BDD simutanément ordonné et
réduit
• Exemple: f = a (b + c) + a’ b’ c
F
F
a
a
01
b
c
0
01
0
1
b
01
01
1
01
0
Ordonné
1
b
01
0
c
c
b
01
01
1
01
0 1
Ordonné et réduit
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Représentation du ROBDD
• Exemple: f = a (b + c) + a’ b’ c
F
F
a
b
a
01
0
b
01
01
b
0
0
c
01
0
0
b
1
1
0
1
0
c
1
1
1
1
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Pourquoi les BDD sont-ils intéressants?
• Pour un ordre de variables donné, les BDD sont
canoniques, c’est-à-dire que leur représentation
est unique pour une fonction booléenne donnée.
•
Exemple: Est-ce que F = a (b + c) + a’ b’ c
et G = a b + b’ c
sont des fonctions équivalentes?
Difficile à dire sans établir la table de vérité…
mais leurs BDD respectifs sont identiques.
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Pourquoi les BDD sont-ils intéressants? (2)
• Pour la plupart des fonctions logiques
intéressantes, les BDD correspondants sont
petits, même pour des fonctions ayant un très
grand nombre de variables.
• Parmi les quelques ombres au tableau:
 Multiplicateurs
•
Pour plus de renseignements et le code source
d’un gestionnaire de BDD, voir CUDD de Fabio
Somenzi (University of Colorado, Boulder)
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering
• Problème: l’extraction de noyaux, qui est très
efficace pour réduire la taille des circuits lors de
la synthèse logique, crée des portes avec de très
grands « fanouts », ce qui ralentit beaucoup le
circuit.
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Délais
• Nous utiliserons un modèle simple de délai:
 Chaque porte logique aura:
• Un délai intrinsèque, 
• Une résistance interne, 
• Une capacité à l’entrée, 
 Pour une porte donnée « P », qui est connectée à une
capacité à la sortie S, alors le délai DP est:
DP =  P +  P *  S
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering
• Dans un problème réel, si une porte a un très
grand fanout, il est probable que les charges des
différentes portes de son fanout soient inégales.
•
Ce problème est complexe, alors nous le
simplifierons:
 Nous supposerons que toutes les charges sont
identiques. Nous supposerons de plus que les charges
peuvent être divisées autant que l’on veut.
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering (2)
0
1
T
1 
1
D =  0 *  1 + 1 +  1 *  T
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering (3)
2
0
1
n1
1 
1
n2
2 
2
2
T
2 
2
D = 0 1 n1 + 1 + 1 n2 2 + 2 + 2 T
n1 n2
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering (4)
D = 0 1 n1 + 1 + 1 n2 2 + 2 + 2 T
n1 n2
Nous cherchons le minimum pour D.
D’ou:
d D = 0 1 - 2 T
d n1
n12 n2
d D = 1 2 - 2 T
d n2
 0
 0
n22 n1
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering (5)
Des équations précédentes, on tire:
n1 =
n2 =
3
3
1 2 2 T
 0 2  12
0 2 1 T
 1 2  22
Dopt = 3 ( 0 1 2 1 2 T)1/3 +  1 + 2
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering (6)
Les résultats obtenus étaient pour 2 niveaux de buffers,
mais nous ignorons combien il devrait y en avoir idéalement:
Soit k la quantité idéale de niveaux, alors:
D = 0 1 n1 + 1 + 1 n2 2 + … + k T
n1 n2 … nk-1
Dopt = (k + 1) ( 0 1 … k 1 2 … k T)1/(k+1) +
© 2004 Frédéric Mailhot

i
Université de Sherbrooke
BDDs et buffering
Buffering (7)
Puisque Dopt doit être aussi petit que possible, et que les
 et les  vont de pair, alors il doit y avoir un buffer idéal b pour
lequel le produit ( ) est minimum. Si on utilise ce buffer b, on
obtient:
Dopt = (k + 1) ( b b )k 0 T)1/(k+1) + k  b
Mais… on ne connaît toujours pas k…
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Buffering (8)
Il s’agit donc tout simplement de dériver par rapport à k…
Puis il ne reste qu’à solutionner pour k en égalant la dérivée
à zéro. On obtient alors:
Dmin =  ln 0 T -  b
b b
Avec

=
b b exp( 1 +  b /  )
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Algorithme de buffering
•
Nous avons maintenant une formule qui nous
donne le délai minimum qu’on peut espérer pour
un problème de buffering donné. En quoi cela
nous est-il utile?
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Algorithme de buffering – branch and bound
•
On peut utiliser cette formule dans un algorithme
« branch and bound »:
 On commence avec la porte de départ, et sa charge
totale. On calcule le délai total entre la porte et les
charges. On utilise cette valeur comme notre meilleur
délai pour le moment
 On ajoute les buffers de notre bibliothèque de cellules,
un type à la fois, pour tenter d’ajouter un étage de
buffer. Il doit y avoir au minimum un buffer, et au
maximum le fanout de départ.
 Pour chaque cas, on calcule le délai entre la porte de
départ et le nouvel étage de buffers, puis on calcule le
délai entre le nouvel étage de buffers et la charge totale
en utilisant notre formule. Il est certain qu’on ne peut
faire mieux avec les vrais buffers.
© 2004 Frédéric Mailhot
Université de Sherbrooke
BDDs et buffering
Branch and bound (2)
 On élimine les solutions qui donnent des résultats
moindre que le meilleur résultat jusqu’à présent, et on
tente d’ajouter un nouvel étage pour les solutions qui
sont bonnes jusqu’à maintenant
 En début de chaque nouvelle exploration, on tente de
brancher la charge totale directement à l’étage de buffer
courant. Si le délai obtenu est plus petit que le meilleur
résultat en mémoire, on met celui-ci à jour.
 On continue ce manège jusqu’à ce qu’il ne reste aucune
solution avec un bon potentiel.
 La meilleure solution est utilisée lorsque l’algorithme se
termine.
© 2004 Frédéric Mailhot
Université de Sherbrooke