Fonctionnement d'un ordinateur depuis zro

Par Lucas Pesenti (Lucas-84) et Guy Grave (Mewtow)

www.siteduzero.com

Licence Creative Commons BY-NC-SA 2.0 Dernire mise jour le 26/09/2012

2/378

Sommaire
Sommaire ........................................................................................................................................... Lire aussi ............................................................................................................................................ Fonctionnement d'un ordinateur depuis zro ..................................................................................... Partie 1 : Tout a rien qu'avec des 0 et des 1 ! ................................................................................... 2 6 8 9

Un ordinateur, c'est trs bte : a ne sait pas compter jusqu' deux ! ............................................................................. 9
Nombres entiers positifs .............................................................................................................................................................................................. 9 Diffrentes bases ........................................................................................................................................................................................................ 9 Le binaire, la base 2 .................................................................................................................................................................................................. 10 Nombres entiers ngatifs ........................................................................................................................................................................................... 11 Reprsentation en signe-valeur absolue ................................................................................................................................................................... 11 Codage en complment 1 ...................................................................................................................................................................................... 12 Complment deux .................................................................................................................................................................................................. 13 Sign Extend ............................................................................................................................................................................................................... 14 Nombres virgule ..................................................................................................................................................................................................... 15 criture scientifique ................................................................................................................................................................................................... 15 Formats de flottants .................................................................................................................................................................................................. 16 Exceptions et arrondis ............................................................................................................................................................................................... 18 Codage du texte ........................................................................................................................................................................................................ 19 Standard ASCII .......................................................................................................................................................................................................... 20 Unicode ..................................................................................................................................................................................................................... 21

Nos bits prennent la porte ! ............................................................................................................................................. 21

Codage NRZ ............................................................................................................................................................................................................. 22 Transistors ................................................................................................................................................................................................................. 23 Loi de Moore ............................................................................................................................................................................................................. 24 Portes logiques ......................................................................................................................................................................................................... 25 La porte NON ............................................................................................................................................................................................................ 26 La porte ET ................................................................................................................................................................................................................ 28 La porte OU ............................................................................................................................................................................................................... 28 Porte XOR ................................................................................................................................................................................................................. 29 Porte NAND ............................................................................................................................................................................................................... 29 Porte NOR ................................................................................................................................................................................................................. 30

Crons nos circuits ! ........................................................................................................................................................ 32

Circuits combinatoires ............................................................................................................................................................................................... 32 Tables de vrit ......................................................................................................................................................................................................... 32 quations logiques .................................................................................................................................................................................................... 33 Mthode des Minterms .............................................................................................................................................................................................. 34 Simplifications du circuit ............................................................................................................................................................................................ 35 Mais ........................................................................................................................................................................................................................... 37 Mmorisation et circuits squentiels ......................................................................................................................................................................... 37 Comment donner de la mmoire nos circuits ? ...................................................................................................................................................... 37 Niveau circuits ........................................................................................................................................................................................................... 38 Bascules et mmoires ............................................................................................................................................................................................... 39 Tic, Tac, Tic, Tac : Le signal d'horloge ....................................................................................................................................................................... 43 Origine du temps de propagation .............................................................................................................................................................................. 43 L'horloge .................................................................................................................................................................................................................... 44 Et dans nos PC ? ...................................................................................................................................................................................................... 45

Partie 2 : Architecture de base .......................................................................................................... 47

C'est quoi un ordinateur ? ............................................................................................................................................... 47
Numrique versus analogique .................................................................................................................................................................................. 47 L'immunit au bruit .................................................................................................................................................................................................... 47 Ordinateurs ................................................................................................................................................................................................................ 49 Automates ................................................................................................................................................................................................................. 49 Programme ............................................................................................................................................................................................................... 50 Les composants de base d'un ordinateur ................................................................................................................................................................. 51 Mmoire .................................................................................................................................................................................................................... 51 Bus de communication .............................................................................................................................................................................................. 52 Processeur ................................................................................................................................................................................................................ 53

La gestion de la mmoire ................................................................................................................................................ 56

Deux mmoires pour le prix d'une ............................................................................................................................................................................. 57 Sparation matrielle des mmoires ......................................................................................................................................................................... 57 Architecture modifie ................................................................................................................................................................................................ 59 La pile ........................................................................................................................................................................................................................ 60 Pile, Tas et Mmoire Statique .................................................................................................................................................................................... 60 La pile ........................................................................................................................................................................................................................ 61 Last Input First Output ............................................................................................................................................................................................... 62 Machines pile et successeurs ................................................................................................................................................................................ 63 Machines pile ......................................................................................................................................................................................................... 63 Machines accs alatoire ....................................................................................................................................................................................... 66 Les hybrides .............................................................................................................................................................................................................. 67

Partie 3 : Processeur et Assembleur ................................................................................................. 70

Langage machine et Assembleur .................................................................................................................................... 70
Instructions ................................................................................................................................................................................................................ 70 C'est quoi une instruction ? ....................................................................................................................................................................................... 70 Reprsentation en binaire d'une instruction .............................................................................................................................................................. 72

www.siteduzero.com

Sommaire

3/378

Jeux d'instruction ....................................................................................................................................................................................................... 72 RISC vs CISC ............................................................................................................................................................................................................ 72 Jeux d'instructions spcialiss .................................................................................................................................................................................. 73 Et pour nos ordinateurs ? .......................................................................................................................................................................................... 74 Registres ................................................................................................................................................................................................................... 74 A quoi servent ces registres ? ................................................................................................................................................................................... 75 Noms de registre ....................................................................................................................................................................................................... 76 Registres architecturaux ............................................................................................................................................................................................ 78 8, 16, 32, 64 bits : une histoire de taille des registres ............................................................................................................................................... 78 Codage d'une instruction ........................................................................................................................................................................................... 79 Opcode ...................................................................................................................................................................................................................... 79 Modes d'adressage ................................................................................................................................................................................................... 80 Longueur d'une instruction ........................................................................................................................................................................................ 82 Classes d'architectures ............................................................................................................................................................................................. 82 A accumulateur unique .............................................................................................................................................................................................. 82 Architectures registre-mmoire ................................................................................................................................................................................. 82 Load-store ................................................................................................................................................................................................................. 83 A pile .......................................................................................................................................................................................................................... 84 A accs mmoire strict .............................................................................................................................................................................................. 85

Un peu de programmation ! ............................................................................................................................................ 85

C'est un ordre, xecution ! ........................................................................................................................................................................................ 86 Passage l'instruction suivante ................................................................................................................................................................................ 86 Les exceptions .......................................................................................................................................................................................................... 87 Et que ca saute ! ....................................................................................................................................................................................................... 87 Instructions de test .................................................................................................................................................................................................... 88 Branchements ........................................................................................................................................................................................................... 88 Structures de contrle, tests et boucles .................................................................................................................................................................... 90 Le Si...Alors ............................................................................................................................................................................................................... 90 Si...Alors...Sinon ........................................................................................................................................................................................................ 91 Boucles ..................................................................................................................................................................................................................... 92 Sous-programmes : c'est fait en quoi une fonction ? ................................................................................................................................................ 94 A quoi a sert ? .......................................................................................................................................................................................................... 94 Retour vers la future (instruction) ! ............................................................................................................................................................................ 97 Paramtres et arguments .......................................................................................................................................................................................... 98 Une histoire de registres ........................................................................................................................................................................................... 98 Valeur de retour ....................................................................................................................................................................................................... 100 Variables automatiques ........................................................................................................................................................................................... 101 Plusieurs piles ......................................................................................................................................................................................................... 101 Tableaux .................................................................................................................................................................................................................. 101 Comment sont implments les tableaux ? ............................................................................................................................................................ 102 Autrefois .................................................................................................................................................................................................................. 103 Indexed absolute ..................................................................................................................................................................................................... 104 Register indirect ...................................................................................................................................................................................................... 104 Base plus index ....................................................................................................................................................................................................... 104

Les circuits d'une unit de calcul .................................................................................................................................. 105

Dcalages et rotations ............................................................................................................................................................................................ 106 Dcalages et rotations ............................................................................................................................................................................................ 106 Multiplexeurs ........................................................................................................................................................................................................... 108 Dcaleur logique ..................................................................................................................................................................................................... 109 Dcaleur arithmtique ............................................................................................................................................................................................. 112 Rotateur ................................................................................................................................................................................................................... 113 Barell shifter ............................................................................................................................................................................................................. 113 Addition .................................................................................................................................................................................................................... 113 Demi-additionneur ................................................................................................................................................................................................... 113 Additionneur complet ............................................................................................................................................................................................... 114 L'additionneur propagation de retenue ................................................................................................................................................................. 116 L'additionneur slection de retenue ...................................................................................................................................................................... 116 D'autres additionneurs, plus rapides ....................................................................................................................................................................... 118 Soustraction ............................................................................................................................................................................................................. 119 Le circuit .................................................................................................................................................................................................................. 119 Comparaison ........................................................................................................................................................................................................... 120 Multiplication ............................................................................................................................................................................................................ 120 Principe ................................................................................................................................................................................................................... 120 Algorithme naf ........................................................................................................................................................................................................ 121 On peut faire mieux ................................................................................................................................................................................................. 123 Les dpassements de capacit ............................................................................................................................................................................... 123 Entiers strictement positifs, non signs ................................................................................................................................................................... 123 Complment deux et complment un ............................................................................................................................................................... 124 La division ............................................................................................................................................................................................................... 124 Division restauration ............................................................................................................................................................................................. 125 Division sans restauration ....................................................................................................................................................................................... 127 La division SRT ....................................................................................................................................................................................................... 127

Il y a quoi dans un processeur ? ................................................................................................................................... 128

Execution d'une instruction ..................................................................................................................................................................................... 128 Instruction d'accs mmoires .................................................................................................................................................................................. 128 Instruction de calcul ................................................................................................................................................................................................ 129 L'intrieur d'un processeur ...................................................................................................................................................................................... 130 Units de calcul ....................................................................................................................................................................................................... 131 Vu de lextrieur ...................................................................................................................................................................................................... 132 A l'intrieur d'une unit de calcul ............................................................................................................................................................................. 133 Units annexes ........................................................................................................................................................................................................ 136 Registres, accumulateurs, et communication avec la mmoire .............................................................................................................................. 136 Architectures accumulateur .................................................................................................................................................................................. 137

www.siteduzero.com

Sommaire

4/378

Register File ............................................................................................................................................................................................................ 137 Plusieurs Register Files .......................................................................................................................................................................................... 139 Communication avec la mmoire ............................................................................................................................................................................ 139 Bus interne au processeur ...................................................................................................................................................................................... 140 Une histoire de connexion ....................................................................................................................................................................................... 140 Chemin de donne un seul bus ........................................................................................................................................................................... 140 Et avec plusieurs bus ? ........................................................................................................................................................................................... 141 Le dcodage d'une instruction ................................................................................................................................................................................ 144 Units de dcodage d'instruction ............................................................................................................................................................................ 144 Squenceurs cbls ................................................................................................................................................................................................ 145 Squenceur micro-cod .......................................................................................................................................................................................... 145 Squenceurs hybrides ............................................................................................................................................................................................. 148 Les transport triggered architectures ....................................................................................................................................................................... 148 L'tape de fetch ....................................................................................................................................................................................................... 149 Registre pointeur instruction ................................................................................................................................................................................... 149 Compteur ordinal ..................................................................................................................................................................................................... 149 Le calcul de l'adresse suivante ............................................................................................................................................................................... 151 Les branchements ................................................................................................................................................................................................... 152 Lexception qui confirme la rgle ............................................................................................................................................................................. 153

Partie 4 : Mmoires ......................................................................................................................... 154

Mmoires ....................................................................................................................................................................... 155
Des mmoires en veux-tu, en voil ! ....................................................................................................................................................................... Capacit mmoire ................................................................................................................................................................................................... Mmoires volatiles et non-volatiles ......................................................................................................................................................................... RWM ou ROM ......................................................................................................................................................................................................... Mmoires accs squentiel et accs alatoire ................................................................................................................................................. Le temps d'accs .................................................................................................................................................................................................... Mmoires RAM ........................................................................................................................................................................................................ Donne, o es-tu ? .................................................................................................................................................................................................. Une histoire de capacit .......................................................................................................................................................................................... Bus d'adresse .......................................................................................................................................................................................................... Lecture-criture ....................................................................................................................................................................................................... Connexion du bus sur la mmoire .......................................................................................................................................................................... Toutes les mmoires ne se valent pas ! .................................................................................................................................................................. Une histoire de vitesse ............................................................................................................................................................................................ Registres ................................................................................................................................................................................................................. Cache ...................................................................................................................................................................................................................... Mmoires principales .............................................................................................................................................................................................. Mmoires de masse ................................................................................................................................................................................................ 155 155 156 157 158 158 158 159 160 161 161 162 164 164 167 168 168 168

Comment font nos mmoires RAM pour stocker un bit ? ............................................................................................. 169
Mmoire SRAM ....................................................................................................................................................................................................... 170 Bascule D ................................................................................................................................................................................................................ 170 Case mmoire de SRAM ......................................................................................................................................................................................... 170 Crer une bascule ................................................................................................................................................................................................... 171 Mmoire DRAM ....................................................................................................................................................................................................... 174 Lecture et criture d'un bit ....................................................................................................................................................................................... 175 Une vraie passoire ! ................................................................................................................................................................................................ 175 1T DRAM ................................................................................................................................................................................................................. 176 Correction d'erreurs ................................................................................................................................................................................................. 176 Bit de parit ou d'imparit ........................................................................................................................................................................................ 176 Mmoires ECC ........................................................................................................................................................................................................ 177

Contrleur et plan mmoire ........................................................................................................................................... 178

Mmoires adressage linaire ............................................................................................................................................................................... Plan mmoire linaire ............................................................................................................................................................................................. Connectons le tout au bus ...................................................................................................................................................................................... Adressage ............................................................................................................................................................................................................... Mmoires adressage par coicidence ................................................................................................................................................................... Plan mmoire .......................................................................................................................................................................................................... Adressage par concidence ..................................................................................................................................................................................... Adresses hautes et basses ..................................................................................................................................................................................... Mmoire Row Buffer ............................................................................................................................................................................................. Le plan mmoire ..................................................................................................................................................................................................... Adressage ............................................................................................................................................................................................................... Avantages ............................................................................................................................................................................................................... Interfacage avec le bus ........................................................................................................................................................................................... Circuits trois tats .................................................................................................................................................................................................... Mmoires ports de lecture et criture spars ..................................................................................................................................................... Assemblages de mmoires ..................................................................................................................................................................................... Arrangement horizontal ........................................................................................................................................................................................... Arrangement vertical ............................................................................................................................................................................................... Arrangement mixte .................................................................................................................................................................................................. Les anctres : les Fast Page Mode et EDO-RAM ................................................................................................................................................... Format des mmoires FPM et EDO ........................................................................................................................................................................ Timings de base des mmoires asynchrones ......................................................................................................................................................... Mmoires FPM et EDO ........................................................................................................................................................................................... EDO-RAM ............................................................................................................................................................................................................... SDRAM et mmoires DDR ...................................................................................................................................................................................... Bancs mmoires ..................................................................................................................................................................................................... Pipelining des requtes mmoires .......................................................................................................................................................................... Ordre des requtes d'accs mmoire ..................................................................................................................................................................... Mode Burst .............................................................................................................................................................................................................. 178 178 179 180 181 182 183 183 183 183 184 184 184 184 186 187 188 189 191 193 193 194 196 197 198 198 199 200 200

Mmoires DDR, SDRAM et leurs cousines .................................................................................................................. 193

www.siteduzero.com

Sommaire

5/378

Mmoires DDR ........................................................................................................................................................................................................ 201 Format DIMM et SO-DIMM ...................................................................................................................................................................................... 203 Les timings mmoires ............................................................................................................................................................................................. 204 Quelques timings connaitre .................................................................................................................................................................................. 205 Le SPD .................................................................................................................................................................................................................... 205 Quelques exemples d'accs ................................................................................................................................................................................... 205

Disques durs et mmoires FLASH ................................................................................................................................ 207

Le disque dur ........................................................................................................................................................................................................... 207 C'est fait en quoi ? ................................................................................................................................................................................................... 207 Adressage d'un disque dur ...................................................................................................................................................................................... 209 Requtes d'accs au disque dur ............................................................................................................................................................................. 210 Mmoires FLASH .................................................................................................................................................................................................... 211 Cellule mmoire de FLASH ..................................................................................................................................................................................... 211 Mmoires FLASH MLC ........................................................................................................................................................................................... 212 Les mmoires FLASH ne sont pas des RAM ! ........................................................................................................................................................ 213 FLASH NAND et NOR ............................................................................................................................................................................................. 214 Les SSD .................................................................................................................................................................................................................. 214

Partie 5 : Priphriques, bus, et entres-sorties ............................................................................. 214

Bus, cartes mres, chipsets et Front Side Bus ............................................................................................................. 215
Un bus, c'est rien qu'un tas de fils... ........................................................................................................................................................................ Bus srie et parallles ............................................................................................................................................................................................. Simplex, Half duplex ou Full duplex ........................................................................................................................................................................ Bus synchrones et asynchrones ............................................................................................................................................................................. Va falloir partager ! .................................................................................................................................................................................................. Conflit d'accs ......................................................................................................................................................................................................... Arbitrage par multiplexage temporel ....................................................................................................................................................................... Arbitrage par requte .............................................................................................................................................................................................. Chipset, back-plane bus, et autres .......................................................................................................................................................................... Premire gnration ................................................................................................................................................................................................ Seconde gnration ................................................................................................................................................................................................ De nos jours ............................................................................................................................................................................................................ Architectures sans Front side bus ........................................................................................................................................................................... 215 216 218 218 220 221 221 221 221 222 222 223 225

Communication avec les Entres-Sorties ..................................................................................................................... 227

Interfacage Entres-sorties ..................................................................................................................................................................................... 227 Interfaage .............................................................................................................................................................................................................. 227 Registres d'interfaage ............................................................................................................................................................................................ 227 Contrleur de priphrique ...................................................................................................................................................................................... 228 Problmes ............................................................................................................................................................................................................... 230 Interruptions ............................................................................................................................................................................................................ 231 Droulement d'une interruption ............................................................................................................................................................................... 231 Les diffrents types d'interruptions .......................................................................................................................................................................... 232 Direct Memory Access ............................................................................................................................................................................................. 234 Arbitrage du bus ...................................................................................................................................................................................................... 234 Direct Memory Acces .............................................................................................................................................................................................. 234

Adressage des priphriques ....................................................................................................................................... 236

Connexion directe ................................................................................................................................................................................................... Bus d'entres-sorties multiplex ............................................................................................................................................................................. Espace d'adressage spar .................................................................................................................................................................................... Entres-sorties mappes en mmoire .................................................................................................................................................................... Memory Mapped I/O ................................................................................................................................................................................................ Bus unique .............................................................................................................................................................................................................. Et pour le CPU ? ..................................................................................................................................................................................................... 237 237 238 240 240 242 242

Partie 6 : Hirarchie mmoire ......................................................................................................... 244

La mmoire virtuelle ...................................................................................................................................................... 244
Principe de base ..................................................................................................................................................................................................... 244 Le principe ............................................................................................................................................................................................................... 244 La MMU ................................................................................................................................................................................................................... 245 Segmentation .......................................................................................................................................................................................................... 245 Adresse virtuelle ...................................................................................................................................................................................................... 246 Relocation ............................................................................................................................................................................................................... 247 Allocation dynamique .............................................................................................................................................................................................. 248 Protection mmoire ................................................................................................................................................................................................. 250 Partage de segments .............................................................................................................................................................................................. 251 Pagination ............................................................................................................................................................................................................... 252 Swapping ................................................................................................................................................................................................................. 253 Translation d'adresse .............................................................................................................................................................................................. 254 Allocation dynamique .............................................................................................................................................................................................. 256 Protection mmoire ................................................................................................................................................................................................. 256

Les mmoires caches ................................................................................................................................................... 256

Accs au cache ....................................................................................................................................................................................................... Accs au cache ....................................................................................................................................................................................................... criture dans un cache ........................................................................................................................................................................................... Localit spatiale et temporelle ................................................................................................................................................................................. Localit temporelle .................................................................................................................................................................................................. Localit spatiale ...................................................................................................................................................................................................... L'influence du programmeur .................................................................................................................................................................................... Prefetching .............................................................................................................................................................................................................. Prefetchers squentiels ........................................................................................................................................................................................... History based prefecther ......................................................................................................................................................................................... Runahead ................................................................................................................................................................................................................ Prefetching des instructions .................................................................................................................................................................................... 257 257 258 260 260 260 261 261 262 264 265 266

www.siteduzero.com

Sommaire

6/378
267 268 268 269 269 270 272 273 273 274 276 277

Suppression des lignes de cache ........................................................................................................................................................................... Algorithmes de suppression des lignes de cache ................................................................................................................................................... Dans la ralit ......................................................................................................................................................................................................... Correspondance Index - Adresse ............................................................................................................................................................................ Tag d'une ligne de cache ......................................................................................................................................................................................... Les caches direct mapped ...................................................................................................................................................................................... Les caches Fully associative ................................................................................................................................................................................... Les caches N-way associative ................................................................................................................................................................................ On n'a pas qu'un seul cache ! ................................................................................................................................................................................. Caches L1, L2 et L3 ................................................................................................................................................................................................ Caches d'instruction ................................................................................................................................................................................................ Caches spcialiss .................................................................................................................................................................................................

Partie 7 : Le paralllisme d'instruction et les processeurs modernes .............................................. 278

Le pipeline : qu'est-ce que c'est ? ................................................................................................................................. 279
Un besoin : le paralllisme d'instruction .................................................................................................................................................................. Le pipeline : rien voir avec un quelconque tuyau ptrole ! ................................................................................................................................ Sans pipeline ........................................................................................................................................................................................................... Et dieu inventa le pipeline ....................................................................................................................................................................................... Implmentation hardware ........................................................................................................................................................................................ Un besoin : isoler les tages du pipeline ................................................................................................................................................................. Comment on fait ? ................................................................................................................................................................................................... Une histoire de frquence... .................................................................................................................................................................................... Un pipeline pas parfait ............................................................................................................................................................................................ Les dpendances d'instructions .............................................................................................................................................................................. Les accs mmoires ............................................................................................................................................................................................... L'ala structurel ....................................................................................................................................................................................................... Les branchements ................................................................................................................................................................................................... Conclusion .............................................................................................................................................................................................................. 279 280 281 281 282 282 284 285 287 287 288 288 289 289

Interruptions et Pipeline ................................................................................................................................................ 289

Interruptions prcises ou imprcises ....................................................................................................................................................................... 290 Techniques conservatrices ...................................................................................................................................................................................... 291 Implmentation ........................................................................................................................................................................................................ 291 Pipeline Bubble ....................................................................................................................................................................................................... 291 In-Order Completion ................................................................................................................................................................................................ 292 Ordre des critures .................................................................................................................................................................................................. 292 Result Shift Register ............................................................................................................................................................................................... 293 Speculation Recovery ............................................................................................................................................................................................. 294 Out Of Order Completion ........................................................................................................................................................................................ 295 Re-Order Buffer ....................................................................................................................................................................................................... 295 History Buffer ........................................................................................................................................................................................................... 295 Future File ............................................................................................................................................................................................................... 298 Autre solution .......................................................................................................................................................................................................... 299

Les branchements viennent mettre un peu d'ambiance ! ............................................................................................. 300

Effet des branchements sur le pipeline ................................................................................................................................................................... Les solutions de base ............................................................................................................................................................................................. Dlai de branchements ........................................................................................................................................................................................... Les processeurs malins .......................................................................................................................................................................................... Branch Free Code ................................................................................................................................................................................................... Instructions prdicats ........................................................................................................................................................................................... Prdiction de branchement ..................................................................................................................................................................................... Erreurs de prdiction ............................................................................................................................................................................................... Prdiction de direction de branchement .................................................................................................................................................................. Prdiction de branchement ..................................................................................................................................................................................... Eager execution ...................................................................................................................................................................................................... Quelques limites pratiques ...................................................................................................................................................................................... Disjoint Eager Execution ......................................................................................................................................................................................... 300 301 301 301 301 302 303 303 304 306 312 313 315

Dpendances de donnes ............................................................................................................................................ 317

Dpendances d'instructions .................................................................................................................................................................................... 317 Dpendances structurelles ...................................................................................................................................................................................... 317 Dpendances de contrles ..................................................................................................................................................................................... 318 Dpendances de donnes ...................................................................................................................................................................................... 318 Pipeline Bubble ....................................................................................................................................................................................................... 319 Temps d'attente ....................................................................................................................................................................................................... 319 Implmentation ........................................................................................................................................................................................................ 320 Que faire ? ............................................................................................................................................................................................................... 321 Bypass et Forwarding .............................................................................................................................................................................................. 322 Effet des dpendances RAW .................................................................................................................................................................................. 322 Mais pourquoi ? ....................................................................................................................................................................................................... 322 Bypass ..................................................................................................................................................................................................................... 322 Clusters ................................................................................................................................................................................................................... 325 Bypass Cache ......................................................................................................................................................................................................... 325

Execution Out Of Order ................................................................................................................................................. 326

Principe ................................................................................................................................................................................................................... 327 Une ide gniale ..................................................................................................................................................................................................... 327 Deux types d'Out Of Order ...................................................................................................................................................................................... 328 Scoreboarding ......................................................................................................................................................................................................... 328 Pipeline d'un processeur Scoreboard ................................................................................................................................................................... 329 Scoreboard .............................................................................................................................................................................................................. 330 Final ......................................................................................................................................................................................................................... 331 Out Of Order Issue .................................................................................................................................................................................................. 331 Centralized Instruction Window ............................................................................................................................................................................... 331 Instructions Windows Multiples ............................................................................................................................................................................... 332

www.siteduzero.com

Lire aussi

7/378

Quelques dtails ..................................................................................................................................................................................................... 333

L'algorithme de Tomasulo et le renommage de registres ............................................................................................. 334

Le renommage de registres .................................................................................................................................................................................... 335 Des dpendances fictives ....................................................................................................................................................................................... 335 Le renommage de registres .................................................................................................................................................................................... 335 Des registres en double ! ........................................................................................................................................................................................ 336 C'est fait comment ? ................................................................................................................................................................................................ 336 Reservations stations .............................................................................................................................................................................................. 337 Aperu ..................................................................................................................................................................................................................... 337 Issue ........................................................................................................................................................................................................................ 337 Reservation Stations ............................................................................................................................................................................................... 338 Dispatch .................................................................................................................................................................................................................. 340 Le Common Memory Bus ........................................................................................................................................................................................ 340 Accs mmoires ...................................................................................................................................................................................................... 341 Bilan ........................................................................................................................................................................................................................ 341 Re-Orders Buffers ................................................................................................................................................................................................... 341 Le Reorder Buffer .................................................................................................................................................................................................... 342 Une File ................................................................................................................................................................................................................... 343 Spculation Recovery ............................................................................................................................................................................................. 345 Accs mmoire ....................................................................................................................................................................................................... 346 Autres formes de renommages ............................................................................................................................................................................... 346 ROB ......................................................................................................................................................................................................................... 346 Rename Register File ............................................................................................................................................................................................. 348 Physical Register File .............................................................................................................................................................................................. 348

Les optimisations des accs mmoire .......................................................................................................................... 349

Dpendances, le retour ! ......................................................................................................................................................................................... Utilit ....................................................................................................................................................................................................................... De nouvelles dpendances ..................................................................................................................................................................................... Dpendances de nommage .................................................................................................................................................................................... Store queue ............................................................................................................................................................................................................. Bypass Store Queue ............................................................................................................................................................................................... Dependances d'alias ............................................................................................................................................................................................... Vrifications des adresses ...................................................................................................................................................................................... Excution spculative ............................................................................................................................................................................................. Memory Dependance Prediction ............................................................................................................................................................................. Load Value Prediction ............................................................................................................................................................................................. Value prediction ....................................................................................................................................................................................................... Pourquoi a marche ? ............................................................................................................................................................................................. Implmentation ........................................................................................................................................................................................................ Efficacit .................................................................................................................................................................................................................. 350 350 350 351 351 351 351 352 352 352 353 353 353 354 355

Processeurs Multiple Issue ........................................................................................................................................... 355

Processeurs superscalaires .................................................................................................................................................................................... 356 Plusieurs units de calcul rentabiliser .................................................................................................................................................................. 356 Micro-architecture d'un processeur superscalaire ................................................................................................................................................... 357 Superscalaire In Order ............................................................................................................................................................................................ 358 Processeurs superscalaires Out Of Order .............................................................................................................................................................. 358 Processeurs VLIW .................................................................................................................................................................................................. 359 Bundles ................................................................................................................................................................................................................... 359 Problmes ............................................................................................................................................................................................................... 360 Processeurs EPIC ................................................................................................................................................................................................... 361 Bundles ................................................................................................................................................................................................................... 361 Prdication .............................................................................................................................................................................................................. 361 Delayed Exceptions ................................................................................................................................................................................................. 362 Spculation sur les lectures .................................................................................................................................................................................... 362 Large Architectural Register File ............................................................................................................................................................................. 365 Bilan ........................................................................................................................................................................................................................ 365

Partie 8 : Annexes ........................................................................................................................... 365

Alignement mmoire et endianess ................................................................................................................................ 366
Alignement mmoire ............................................................................................................................................................................................... 366 Accs mmoires la granularit de l'octet .............................................................................................................................................................. 366 Alignement suprieur l'octet ................................................................................................................................................................................. 368 Endianness ............................................................................................................................................................................................................. 371 Big Endian ............................................................................................................................................................................................................... 371 Little Endian ............................................................................................................................................................................................................ 372 Bi-Endian ................................................................................................................................................................................................................. 372

Autres optimisations de la hirarchie mmoire ............................................................................................................. 373

Local Stores ............................................................................................................................................................................................................ 373 Rappels sur les caches ........................................................................................................................................................................................... 373 Local Store .............................................................................................................................................................................................................. 373 Avantages/inconvnients ........................................................................................................................................................................................ 374 Prefetch Input Queue .............................................................................................................................................................................................. 374 Implmentation ........................................................................................................................................................................................................ 375 Paye tes branchements ! ......................................................................................................................................................................................... 375 Liens sur le Siteduzro ............................................................................................................................................................................................ 375 Quelques liens internet ........................................................................................................................................................................................... 376 Ouvrages de rfrence ............................................................................................................................................................................................ 377 Remerciements ....................................................................................................................................................................................................... 377

www.siteduzero.com

Lire aussi

8/378

Fonctionnement d'un ordinateur depuis zro

Par

Guy Grave (Mewtow) et

Lucas Pesenti (Lucas-84)

Mise jour : 22/08/2012 Difficult : Facile Dure d'tude : 6 jours, 6 heures, 6 minutes 4 940 visites depuis 7 jours, class 36/792 V ous vous tes dj demand comment fonctionne un ordinateur ou ce qu'il y a dedans ?

Alors ce tutoriel est fait pour vous. Dans ce cours, vous allez apprendre ce qu'il y a dans notre ordinateur, ce qui se passe l'intrieur de votre processeur ou de votre mmoire RAM. V ous saurez tout des dernires innovations prsentes dans nos processeurs, pourquoi la course la frquence est termine, ou encore comment fabriquer des registres. On commencera par des choses simples comme le binaire, pour arriver progressivement jusqu'au fonctionnement des derniers processeurs, en passant par plein de choses passionnantes comme l'assembleur, les mmoires caches, et d'autres choses encore ! Ce tutoriel ne posera pas de soucis, mme pour ceux qui nont jamais programm ou qui dbutent tout juste : ce cours est accessible n'importe qui, sans vraiment de prrequis. En clair : on part de zro !

www.siteduzero.com

Fonctionnement d'un ordinateur depuis zro

9/378

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

Quitte parler d'architecture des ordinateurs, autant commencer par les bases, non ? On va donc voir comment l'ordinateur va se reprsenter les informations (sons, images, vidos...) en utilisant le binaire. On va aussi voir en quoi il est fait, et quels sont les circuits de base qui le compose. V ous y apprendrez aussi concevoir des circuits assez simples.

Un ordinateur, c'est trs bte : a ne sait pas compter jusqu' deux !

On a srement dj d vous dire qu'un ordinateur comptait uniquement avec des zros et des uns. Et bien sachez que c'est vrai : on dit que notre ordinateur utilise la numration binaire. Le binaire, qu'est-ce que c'est que ce truc ?

C'est juste une faon de reprsenter un nombre en utilisant seulement des 0 et des 1. Et un ordinateur ne sait compter qu'en binaire. Toutefois, le binaire ne sert pas qu' stocker des nombres dans notre ordinateur. Aprs tout, votre ordinateur ne fait pas que manipuler des nombres : il peut aussi manipuler du texte, de la vido, du son, et pleins d'autres choses encore. Eh bien, sachez que tout cela est stock... avec uniquement des 0 et des 1. Que ce soit du son, de la vido, ou tout autre type de donne manipulable par notre ordinateur, ces donnes sont stockes sous la forme de suites de zros et de uns que notre ordinateur pourra manipuler comme bon lui semble. Pour comprendre le fonctionnement d'un ordinateur, on va donc devoir aborder le binaire. Nous allons commencer par voir comment sont stockes quelques donnes de base comme les nombres ou le texte. Et pour cela, nous allons commencer par un petit rappel pour ceux qui n'ont jamais t en CM1.

Nombres entiers positifs

Nous allons commencer par parler des nombres entiers positifs. Dans notre systme de reprsentation dcimal, nous utilisons dix chiffres pour crire nos nombres entiers positifs : 0, 1, 2, 3, 4 , 5 , 6 , 7 , 8 et 9. Prenons le nombre 1337. Le chiffre le plus droite est le chiffre des units, celui ct est pour les dizaines, suivi du chiffre des centaines... Cela nous donne :

Jusque l vous devez vous ennuyer, non (Enfin j'espre ! )? Bref, reprenons notre nombre 1337. On va remplacer les units, dizaines, centaines et milliers par leurs puissances de dix respectives :

Tous les nombres entiers qui existent peuvent eux aussi tre crits sous cette forme : on peut les dcomposer en une somme de multiples de puissances de 10. Lorsque c'est le cas, on dit qu'ils sont en base 10.

Diffrentes bases
Ce qui peut tre fait avec des puissances de 10 peut tre fait avec des puissances de 2, 3, 4, 125, etc : on peut utiliser dautres bases que la base 10. Rien nempche de dcomposer un nombre en une somme de multiples de puissance de 2, ou de 3, par exemple. On peut ainsi utiliser d'autres bases. En informatique, on utilise rarement la base 10 laquelle nous sommes tant habitus. Nous utilisons la place deux autres bases : La base 2 (systme binaire) : les chiffres utiliss sont 0 et 1 ; La base 16 (systme hexadcimal) : les chiffres utiliss sont 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9 ; auxquels s'ajoutent les six premires lettres de notre alphabet : A, B, C, D, E et F.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

V le tableau des 16 premiers nombres des bases cites ci-dessus : oici

10/378

Base 10 Base 2 Base 16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 0 1 2 3 4 5 6 7 8 9 A B C D E F

Le binaire, la base 2
Le binaire, c'est la base 2. Seuls deux chiffres sont utiliss : 0 et 1. Lorsque vous crivez un nombre en binaire, celui-ci peut toujours tre crit sous la forme d'une somme de puissances de 2. Par exemple 6 s'crira donc en binaire :

En gnral, tout nombre en binaire s'crit sous la forme . Les coefficients valent 1 ou 0. Ces coefficients ne sont rien d'autres que les "chiffres" de notre nombre crit en base 2. Ces "chiffres" d'un nombre cod en binaire sont aussi appels des bits. Pour simplifier, on peut dire qu'un bit est un truc qui vaut 0 ou 1. L'exposant qui correspond un bit est appel le poids du bit. Le bit de poids faible est celui qui a la plus petite valeur dans un nombre : c'est celui qui est le plus droite du nombre (si vous crivez vos nombres dans le bon sens, videmment). Le bit de poids fort c'est l'inverse, videmment : c'est celui qui est plac le plus gauche. La reprsentation des entiers positifs en binaire est trs simple : il suffit simplement de changer de base, et de passer de la base 10 la base 2. Il existe un algorithme qui permet de changer un nombre en base dcimale vers un nombre en base binaire : il consiste diviser itrativement le quotient de la division prcdente par 2, et de noter le reste. Enfin, il faut lire de bas en haut les restes trouvs. Exemple :

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

11/378

Soit

en binaire.

Petite remarque assez importante : avec bits, on peut coder valeurs diffrentes, dont le . Ce qui fait qu'on peut compter de . N'oubliez pas cette petite remarque : elle sera assez utile dans le suite de ce tutoriel.

Nombres entiers ngatifs

Dans ce qui prcde, on a vu les entiers strictement positifs ou nuls. Maintenant, on va voir comment faire pour reprsenter les entiers ngatifs. Avec nos 1 et nos 0, comment va-t-on faire pour reprsenter le signe moins ("-") ? Eh bien, il existe plusieurs mthodes. Les plus utilises sont : La reprsentation en signe-valeur absolue ; La reprsentation en complment un ; La reprsentation en complment deux. On va voir chacune d'entre elles en dtail.

Reprsentation en signe-valeur absolue

La solution la plus simple pour reprsenter un entier ngatif consiste coder sa valeur absolue en binaire, et rajouter un bit de signe au tout dbut du nombre. Ce bit servira prciser si c'est un entier positif ou un entier ngatif. C'est un peu la mme chose qu'avec les nombres usuels : pour crire un nombre ngatif, on crit sa valeur absolue, en plaant un moins devant. Ici, c'est la mme chose, le bit de signe servant de signe moins (quand il vaut 1) ou plus (quand il vaut 0). Bit de signe Nombre cod en binaire sur n bits

Par convention, ce bit de signe est gal : 0 si le nombre est positif ; 1 si le nombre est ngatif . Exemple : Codage de sur 8 bits : 34 = 0010 0010 Codage de sur 8 bits : -34 = 1010 0010 Petite remarque : pour obtenir l'oppos d'un nombre cod en reprsentation signe-valeur absolue, il suffit simplement d'inverser le bit de signe.

Capacit
En utilisant bits, bit de signe inclut, un nombre cod en reprsentation signe-valeur absolue peut prendre toute valeur et . On remarque que l'intervalle des entiers reprsentables sur n bits est symtrique : pour

comprise entre

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

chaque nombre reprsentable sur n bits en reprsentation signe-valeur absolue, son inverse l'est aussi. Exemple avec des nombres cods sur 4 bits

12/378

Dsavantages
V ous avez certainement remarqu que le zro, est reprsentable par deux entiers signs diffrents, quand on utilise la reprsentation signe-magnitude. Exemple avec un nombre dont la valeur absolue est code sur 8 bits, et un bit de signe au dbut. Le bit de signe est color en rouge. 0 0000 0000 = 0 1 0000 0000 = -0, ce qui est gal zro. Comme vous le voyez sur cet exemple, le zro est prsent deux fois : un , et un . Cela peut parfois poser certains problmes, lorsqu'on demande notre ordinateur d'effectuer des calculs ou des comparaisons avec zro par exemple. Il y a un autre petit problme avec ces entiers signe-valeur absolue : faire des calculs dessus est assez compliqu. Comme on le verra plus tard, nos ordinateurs disposent de circuits capables d'additionner, de multiplier, diviser, ou soustraire deux nombres entiers. Et les circuits capables de faire des oprations sur des entiers reprsents en signe-magnitude sont compliqus fabriquer et assez lents, ce qui est une dsavantage.

Codage en complment 1
Passons maintenant une autre mthode de codage des nombres entiers qu'on appelle le codage en complment 1. Cette mthode est trs simple. Si le nombre crire en binaire est positif, on le convertit en binaire, sans rien faire de spcial. Par contre, si ce nombre est un nombre ngatif, on code sa valeur absolue en binaire et on inverse tous les bits du nombre obtenu : les 0 deviennent des 1, et vice-versa. Avec cette mthode, on peut remarquer que le bit de poids fort (le bit le plus gauche) vaut 1 si le nombre est ngatif, et 0 si le nombre reprsent est positif. Celui-ci se comporte comme un bit de signe. Par contre, il y a un petit changement compar la reprsentation en signe-valeur absolue : le reste du nombre (sans le bit de signe) n'est pas gal sa valeur absolue si le nombre est ngatif.

Capacit
En utilisant bits, un nombre reprsent en complment un peut prendre toute valeur comprise entre et :

pas de changements avec la reprsentation signe-valeur absolue. Exemple avec des nombres cods sur 4 bits

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

13/378

Dsavantages
Cette mthode est relativement simple, mais pose exactement les mmes problmes que la reprsentation signe-magnitude. Le zro est toujours reprsent par deux nombres diffrents : un nombre ne contenant que des 0 (0000 0000 ...), et un nombre ne contenant que des 1 (1111 1111 ...). Pour la complexit des circuits, la situation est un peu meilleure qu'avec la reprsentation en signe-valeur absolue. Mais les circuits manipulant des nombres en complment un doivent grer correctement la prsence de deux zros, ce qui ajoute un peu de complexit inutilement. Il faut avouer que ces problmes mritent bien une solution ! Pour faciliter la vie des concepteurs de circuits ou des programmeurs, on prfre utiliser une autre reprsentation des nombres entiers, diffrente du complment 1 et de la reprsentation signe-valeur absolue, qui permet de faire des calculs simplement, sans avoir utiliser de circuits complexes, et avec laquelle le zro ne pose pas de problmes.

Complment deux
Pour viter ces problmes avec le zro et les oprations arithmtiques, on a d recourir une astuce : on ne va utiliser que des entiers non-signs et se dbrouiller avec . L'ide derrire la mthode qui va suivre est de coder un nombre entier ngatif par un nombre positif non-sign en binaire, de faon ce que les rsultats des calculs effectus avec ce nombre positif non-sign soient identiques avec ceux qui auraient ts faits avec notre nombre ngatif. Par contre, pour les nombres positifs, rien ne change au niveau de leur reprsentation en binaire. Pour cela, on va utiliser les rgles de l'arithmtique modulaire. Si vous ne savez pas ce que c'est, ce n'est pas grave ! Il vous faudra juste admettre une chose : nos calculs seront faits sur des entiers ayant un nombre de bits fix une fois pour toute. En clair, si un rsultat dpasse ce nombre de bits fix (qu'on notera ), on ne gardera que les bits de poids faible (les bits les plus droite). Prenons un exemple : prenons des nombres entiers non-signs de 4 bits. Ceux-ci peuvent donc prendre toutes les valeurs entre 0 et 15. Prenons par exemple 13 et 3. 13 + 3 = 16, comme vous le savez. Maintenant, regardons ce que donne cette opration en binaire. . Ce rsultat dpasse 4, qui est le nombre de bits fix. On doit donc garder uniquement les 4 bits de poids faible et on va virer les autres. Et voici le rsultat : . En clair, avec ce genre d'arithmtique, . ! On peut aussi reformuler en disant que , ou encore que

Et ne croyez pas que a marche uniquement dans cet exemple : cela se gnralise assez rapidement. Pire : ce qui marche pour l'addition marche aussi pour les autres oprations, tel la soustraction ou la multiplication. Un nombre ngatif va donc tre reprsent par un entier positif strictement quivalent dans nos calculs qu'on appelle son complment deux.

Capacit
En utilisant bits, un nombre reprsent en complment deux peut prendre toute valeur comprise entre et :

cette fois, l'intervalle n'est pas symtrique. Au passage, avec la mthode du complment deux, le zro n'est cod que par un seul nombre binaire. Exemple avec des nombres cods sur 4 bits

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

14/378

Au fait : je ne sais pas si vous avez remarqu, mais le bit de poids fort (le bit le plus gauche) vaut 1 si le nombre est ngatif, et 0 si le nombre reprsent est positif. Celui-ci se comporte comme un bit de signe.

Conversion entier -> binaire

a a l'air joli, mais comment je fais pour trouver quel est l'entier positif qui correspond -15, ou -50 ? Il faut bien que serve ton truc, non ?

Ce complment deux se calcule en plusieurs tapes : 1 - On inverse tous les bits du nombre. Les 1 sont transforms en 0 et rciproquement, les 0 en 1. Exemples : 0000 1111 devient 1111 0000. 0011 0000 devient 1100 1111. 0111 1001 devient 1000 0110. On obtient le complment un du nombre. 2 - On ajoute 1 au rsultat. On obtient le complment deux. Ce complment deux est alors strictement quivalent au nombre d'origine, du point de vue de l'addition, de la multiplication, de la soustraction, etc. Et je recommande aux matheux de tenter de le dmontrer par eux-mme. Rien de bien compliqu : juste savoir ce qu'est un modulo et un peu de jugeote devraient suffire. Pas convaincu ? alors on va prendre un exemple : 7 + (-6). On suppose que ces nombres sont cods sur quatre bits. Pour 7, pas de changements, a reste 0111. Pour coder -6, on va : prendre 6 : 0110 ; calculer son complment 1 : 1001 ; calculer son complment 2 : 1010. Ensuite, il nous faut faire l'addition : 0111 + 1010 = 10001. Et l, on prend en compte le fait que nos deux nombres de base sont cods sur 4 bits ! On ne doit garder que les 4 derniers bits de notre rsultat. Le rsultat de 0111 + 1010 = 10001, une fois tronqu sur 4 bits, donnera alors 0001. On trouve bien le bon rsultat.

Sign Extend
Dans nos ordinateurs, tous les nombres sont reprsents sur un nombre fix et constant de bits. Ainsi, les circuits d'un ordinateur ne peuvent manipuler que des nombres de 4, 8, 12, 16, 32, 48, 64 bits, suivant l'ordinateur. Si l'on veut utiliser un entier cod sur 16 bits et que l'ordinateur ne peut manipuler que des nombres de 32 bits, il faut bien trouver un moyen de convertir notre nombre de 16 bits en un nombre de 32 bits, sans changer sa valeur et en conservant son signe. Cette conversion d'un entier en un entier plus grand, qui conserve valeur et signe s'appelle l'extension de signe, ou sign extend .

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

15/378

L'extension de signe des nombres positif ne pose aucun problme : il suffit de remplir les bits gauche de notre nombre de base avec des 0 jusqu arriver la taille voulue. C'est la mme chose qu'en dcimal : rajouter des zros gauche d'un nombre ne changera pas sa valeur. Cela marche quelque soit la reprsentation utilise, que ce soit la reprsentation signe-valeur absolue, le complment 1 ou complment 2. Exemple, si je veux convertir l'entier positif 0100 0101, prenant 8 bits, en l'entier quivalent mais utilisant 16 bits, il me suffit de remplir les 8 bits gauche de 0100 0101 par des 0. On obtient ainsi 0000 0000 0100 0101. Pour les nombres ngatifs, la conversion dpend de la reprsentation utilise. Avec le complment 2, l'extension de signe d'un entier ngatif est simple effectuer : il suffit de remplir les bits gauche du nombre convertir avec des 1, jusqu' obtenir le bon nombre de bits. Exemple, prenons le nombre -128, cod sur 8 bits en complment deux : 1000 0000. On veut le convertir en nombre sur 16 bits. Il suffit pour cela de remplir les 8 bits de poids fort (les 8bits les plus gauche) de 1 : on obtient 1111 1111 1000 000. L'extension de signe d'un nombre cod en complment 2 se rsume donc en une phrase. Pour un nombre cod en complment deux, il suffit de recopier le bit de poids fort de notre nombre convertir gauche de celui-ci jusqu atteindre le nombre de bits voulu.

Nombres virgule
On sait donc comment sont stocks nos nombres entiers dans un ordinateur. Nanmoins, les nombres entiers ne sont pas les seuls nombres que l'on utilise au quotidien : il nous arrive d'utiliser des nombres virgule. Notre ordinateur n'est pas en reste : il est lui aussi capable de manipuler des nombres virgule sans trop de problmes (mme si de ce point de vue, certains ordinateurs se dbrouillent mieux que d'autres). Notre ordinateur va parfaitement pouvoir manipuler des nombres virgule. Il existe deux mthodes pour coder des nombres virgule en binaire : La virgule fixe ; La virgule flottante. La mthode de la virgule fixe consiste muler nos nombres virgule partir de nombre entiers. Un nombre virgule fixe est donc cod par un nombre entier proportionnel notre nombre virgule fixe. Pour obtenir la valeur de notre nombre virgule fixe, il suffit de diviser l'entier servant le reprsenter par un nombre constant, fix une bonne fois pour toute. Par exemple, pour coder 1,23 en virgule fixe, on peut choisir comme "facteur de conversion" 1000. L'entier permettant de coder 1,23 sera alors 1230. La reprsentation en virgule fixe tait utile du temps o les ordinateurs n'intgraient pas de circuits capables de travailler directement sur des nombres virgule flottante. Cette mthode n'est presque plus utilise, et vous pouvez l'oublier sans problme. Les nombres virgule fixe ont aujourd'hui ts remplacs par les nombres virgule flottante. Ce sont des nombres dont le nombre de chiffre aprs la virgule est variable. De nombreuses mthodes existent pour reprsenter ces nombres virgule qui sont souvent incompatibles entre-elles et les concepteurs de matriel lectronique se sont dit qu'il fallait normaliser le stockage des flottants en mmoire ainsi que les rsultats des calculs afin que tous les ordinateurs supportent les mmes flottants et pour que les calculs flottants donnent les mmes rsultats quelque soit l'ordinateur. C'est ainsi qu'est ne la norme IEEE754. Cette norme IEEE754 impose diverses choses concernant nos flottants. Elle impose une faon d'organiser les bits de nos nombres flottants en mmoire, standardise par la norme. Il faut tout de mme noter qu'il existe d'autres normes de nombres flottants, moins utilises.

criture scientifique
La faon utilise pour crire nos nombres flottants en binaire est trs diffrente de celle utilise pour coder des nombres entiers. L'criture d'un nombre flottant en binaire est base sur son criture scientifique. Cela permet de coder beaucoup plus de valeurs qu'un nombre en virgule fixe, nombre de bits gal. Mais un flottant ne peut stocker qu'un nombre fini de valeurs. Pour rappel, en dcimal, lcriture scientifique d'un nombre consiste crire celui-ci comme un produit entre un nombre et une puissance de 10. Ainsi, un nombre aura une criture scientifique en base 10 de la forme :

Notre nombre est un nombre virgule dont la valeur est comprise entre 1 et 10 (1 inclus et 10 exclu). Ce nombre qu'un seul chiffre gauche de la virgule : on peut toujours trouver un exposant tel que ce soit le cas.

ne possde

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

16/378

En binaire, c'est peu prs la mme chose. L'criture scientifique binaire d'un nombre consiste crire celui-ci sous la forme

Cette fois-ci on n'utilise plus une puissance de 10 (comme c'tait le cas avec la base 10), mais une puissance de 2. Autre changement : est un nombre virgule qui ne possde qu'un seul chiffre gauche de la virgule, comme en base 10. Le seul truc, c'est qu'en binaire, seuls deux chiffres sont possibles : 0 et 1. Le chiffre de situ gauche de la virgule est donc soit un zro ou un 1. Si le nombre est diffrent de zro, on peut toujours russir transformer notre nombre crit ainsi en binaire de faon ce que ait son chiffre situ gauche de la virgule qui vaut 1. En consquence, l'criture scientifique d'un nombre en binaire est donc quelque chose de la forme :

Sauf pour quelques exceptions dont on parlera plus tard : le zro par exemple. Pour stocker cette criture scientifique avec des zros et des un, il nous faut stocker la partie fractionnaire de notre nombre , qu'on appelle la mantisse et l'exposant. On rajoute souvent un bit de signe qui sert calculer le signe du nombre flottant : ce bit vaut 1 si ce nombre est ngatif et vaut 0 si notre flottant est positif. Bit de signe Exposant 0 Mantisse

0011 0001 111 0000 1101 1001

On calcule la valeur d'un flottant IEE754 en utilisant la formule qui suit :

Le dcalage est l pour permettre aux flottants de coder des nombres trs petits : en effet, pour un exposant plus petit que le dcalage, est ngatif, et la puissance de deux correspondante sera un nombre trs petit. Multipli par la mantisse, cela permet de coder des nombres trs trs petits. Sans ce dcalage, on ne pourrait coder que des grands nombres. Remarquez bien un truc avec la mantisse : on doit lui ajouter 1 pour faire nos calculs avec : ne l'oubliez pas ! Sauf pour certains de nos flottants spciaux.

Formats de flottants
La norme IEEE754 impose diverses choses concernant la faon dont on gre nos flottants. Elle impose un certain format en mmoire : les flottants doivent tre stocks dans la mmoire d'une certaine faon, standardise par la norme. Elle impose une faon d'organiser les bits de nos nombres flottants en mmoire. Cette norme va (entre autres) dfinir quatre types de flottants diffrents. Chacun de ces types de flottants pourra stocker plus ou moins de valeurs diffrentes. V ces types de flottants : oici Format Simple prcision Simple prcision tendue Double prcision Double prcision tendue Nombre de bits utiliss pour coder un flottant 32 Au moins 43 64 80 ou plus Nombre de bits de l'exposant 8 Variable 11 15 ou plus Nombre de bits pour la mantisse 23 Variable 52 64 ou plus

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

17/378

Simple prcision Bit de signe Exposant Mantisse

cod sur 1 bit cod sur 8 bits cod sur 23 bits

Double prcision Bit de signe Exposant Mantisse

cod sur 1 bit cod sur 11 bits cod sur 52 bits

IEEE754 impose aussi le support de certains nombres flottants spciaux. Parmi eux, on trouve l'infini (aussi bien en ngatif qu'en positif), la valeur NaN, utilise pour signaler des erreurs ou des calculs n'ayant pas de sens mathmatiquement, ou des nombres spciaux nomms les dnormaux qui reprsentent des valeurs trs petites et qui sont utiliss dans des scnarios de calcul assez particuliers.

Flottants dnormaliss
Commenons notre revue des flottants spciaux par les dnormaux, aussi appels flottants dnormaliss. Pour ces flottants, l'exposant auquel on a enlev le dcalage vaut zro. Ces flottants ont une particularit. On calcule leur valeur grce la formule suivante :

On a pas besoin d'ajouter 1 la mantisse pour calculer avec. Bit de signe Exposant 1 ou 0 0 Mantisse Mantisse diffrente de zro

Ils servent parfois amliorer la prcision des calculs dans des scnarios de calcul particulirement tordus.

Le zro
Le zro est un de ces flottants spciaux. Il ressemble un peu aux flottants dnormaliss, un dtail prt : la mantisse est nulle ! C'est la seule diffrence avec les autres flottants dnormaliss : l'exposant et bel et bien nul, et on n'a pas besoin d'ajouter 1 la mantisse pour calculer sa valeur partir de sa reprsentation en binaire. Bit de signe Exposant Mantisse 1 ou 0 0 0

Au fait, remarquez que le zro est cod deux fois cause du bit de signe. Si vous mettez l'exposant et la mantisse la bonne valeur de faon avoir zro, le bit de signe pourra valoir aussi bien 1 que 0 : on se retrouve avec un et un .

Amusons-nous avec l'infini !

Plus haut, j'ai dit que les calculs sur les flottants pouvaient poser quelques problmes. On va prendre un exemple : . Citation : Lecteur du tutoriel

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

"Notre ordinateur ne pourra pas faire ce calcul ! C'est interdit de diviser par zro !"

18/378

Et bien c'est rat cher lecteur !

Le rsultat sera un flottant spcial qui vaut

. Passons sous le tapis la rigueur

mathmatique de ce rsultat, c'est comme a. Et oui, quand j'ai dit plus haut que les flottants servaient coder des nombres rels, j'ai menti (oui, je sais, c'est mal) : les flottants peuvent aussi coder les infinis. C'est honteux, n'est-ce pas ? V oyons comment notre ordinateur code ces infinis. est cod de la faon suivante : Bit de signe 0 Exposant Mantisse

Valeur maximale possible de l'exposant 0000 0000 0000 0000 ...

Il faut savoir qu'il existe aussi un flottant qui vaut est gal 1. Bit de signe 1

. Celui-ci est identique au flottant codant

part son bit de signe qui

Exposant

Mantisse

Valeur maximale possible de l'exposant 0000 0000 0000 0000 ...

Et le pire, c'est qu'on peut effectuer des calculs sur ces flottants infinis. Mais cela a peu d'utilit. On peut donner comme exemple : L' addition ou soustraction d'un nombre rel fini un de ces deux infinis, qui ne changera rien l'infini de dpart. Idem pour la multiplication par un nombre positif : aura pour rsultat . La multiplication par un nombre ngatif changera le signe de l'infini. Par exemple, aura pour rsultat

NaN
Mais malheureusement, l'invention des flottants infinis n'a pas rgl tous les problmes. On se retrouve encore une fois avec des problmes de calculs avec ces infinis. Par exemple, quel est le rsultat de ? Et pour ? Ou encore ?

Autant prvenir tout de suite : mathmatiquement, on ne peut pas savoir quel est le rsultat de ces oprations. Pour pouvoir rsoudre ces calculs dans notre ordinateur sans lui faire prendre feu, il a fallu inventer un nombre flottant qui signifie "je ne sais pas quel est le rsultat de ton calcul pourri". Ce nombre, c'est NAN. V comment celui-ci est cod : oici Bit de signe Exposant Mantisse

1 ou 0, c'est au choix Valeur maximale possible de l'exposant Diffrent de zro

NAN est l'abrviation de Not A Number, ce qui signifie : n'est pas un nombre. Malgr son nom explicite, on peut faire des oprations avec NAN, mais cela ne sert pas vraiment grand chose : une opration arithmtique applique avec un NAN aura un rsultat toujours gal NAN. Pour tre plus prcis, il existe diffrents types de NaN, qui diffrent par la valeur de leur mantisse, ainsi que par les effets qu'ils peuvent avoir. Pour plus de renseignements, voir ce lien : Nan - Wikipdia.

Exceptions et arrondis
www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

19/378

La norme impose aussi une gestion des exceptions (attention, rien voir avec les exceptions matrielles vues plus haut), qui arrivent lors de calculs particuliers. Ces exceptions correspondant des erreurs, il faut bien "rpondre" l'exception afin de corriger l'erreur. Cette rponse peut tre un arrt de lexcution du programme fautif, ou un traitement particulier (un arrondi par exemple). En voici la liste : Invalid operation : opration qui produit un NAN. Overflow : rsultat trop grand pour tre stock dans un flottant. Le plus souvent, on traite l'erreur en arrondissant le rsultat vers . Underflow : pareil, mais avec un rsultat trop petit. Le plus souvent, on traite l'erreur en arrondissant le rsultat vers 0. Division par zro. La rponse la plus courante est de rpondre + ou - l'infini. Inexact : le rsultat ne peut tre reprsent par un flottant et on doit l'arrondir.

Arrondis
Pour donner un exemple avec l'exception Inexact , on va prendre le nombre mais c'est parce qu'il est crit en dcimal. . Ce nombre ne semble pourtant pas mchant,

En binaire, ce nombre s'crit comme ceci : et ainsi de suite jusqu l'infini. Notre nombre utilise une infinit de dcimales. Bien videment, on ne peut pas utiliser une infinit de bits pour stocker notre nombre et on doit imprativement l'arrondir. Comme vous le voyez avec la dernire exception, le codage des nombres flottants peut parfois poser problme : dans un ordinateur, il se peut qu'une opration sur deux nombres flottants donne un rsultat qui ne peut tre cod par un flottant. On est alors oblig d'arrondir ou de tronquer le rsultat de faon le faire rentrer dans un flottant. Pour viter que des ordinateurs diffrents utilisent des mthodes d'arrondis diffrentes, on a dcid de normaliser les calculs sur les nombres flottants et les mthodes d'arrondis. Pour cela, la norme impose le support de quatre modes d'arrondis : Arrondir vers + l'infini, vers - l'infini, vers zro vers le nombre flottant le plus proche.

Autres exceptions
L'exception Invalid operation est leve dans deux cas : des calculs ayant un rsultat qui est un nombre complexe : le calcul est une forme indtermine , , et autres.

Pour ceux qui ne savent pas trop ce que sont les formes indtermines, voici en exclusivit la liste des calculs qui retournent NaN :

; et dans certains cas, , , et

Codage du texte
Nous savons donc comment faire pour reprsenter des nombres dans notre ordinateur, et c'est dj un bon dbut. Mais votre ordinateur peut parfaitement manipuler autre chose que des nombres. Il peut aussi manipuler des images, du son, ou pleins d'autres choses encore. Eh bien sachez que tout cela est stock dans votre ordinateur... sous la forme de nombres cods en binaire, avec uniquement des 0 et des 1. Le codage dfinit la faon de reprsenter une information (du texte, de la vido, du son...) avec des nombres. Ce codage va attribuer un nombre : une lettre, la couleur d'un pixel l'cran... Ainsi, notre ordinateur sera non seulement capable de manipuler des nombres (et de faire des calculs avec), mais il sera aussi capable de manipuler une information ne reprsentant pas forcment

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

un nombre pour l'utilisateur.

20/378

Bien videment, l'ordinateur n'a aucun moyen de faire la diffrence entre un nombre qui code un pixel, un nombre qui code une lettre ou mme un nombre. Pour lui, tout n'est que suites de zro et de uns sans aucune signification : une donne en binaire ne contient aucune information sur linformation qu'elle code (son "type"), et l'ordinateur n'a aucun moyen de le deviner. Par exemple, si je vous donne la suite de bits suivante : 1100101 cod sur 7 bits ; vous n'avez aucun moyen de savoir s'il s'agit d'une lettre (la lettre e avec l'encodage ASCII), le nombre 101, ou l'entier -26 cod en complment 1, ou encore l'entier -25 cod en complment deux. Ce qui va faire la diffrence entre les types c'est la faon dont sera interprte la donne : on n'effectuera pas les mmes traitements sur une suite de bits selon ce qu'elle reprsente. Par exemple, si on veut afficher un 'e' l'cran, les manipulations effectues ne seront pas les mmes que celles utilise pour afficher le nombre 101, ou le nombre -25, etc. Pour la suite, on va prendre l'exemple du texte.

Standard ASCII
Pour stocker un texte, rien de plus simple : il suffit de savoir comment stocker une lettre dans notre ordinateur et le reste coule de source. On va donc devoir coder chaque lettre et lui attribuer un nombre. Pour cela, il existe un standard, nomme la table ASCII qui va associer un nombre particulier chaque lettre. L'ASCII est un standard qui permet tous les ordinateurs de coder leurs caractres de la mme faon. Ce standard ASCII utilise des nombres cods sur 7bits, et peut donc coder 128 symboles diffrents. Notre table ASCII est donc une table de correspondance qui attribue un nombre chaque symbole. La voici dans son intgralit, rien que pour vous.

Si vous lisez en entier la table ASCII, vous remarquerez srement qu'il n'y a pas que des lettres codes par l'ASCII : il y tous les caractres d'un clavier qui sont inscrits dans cette table. On peut faire quelques remarques sur cette table ASCII : Les lettres sont stockes dans l'ordre alphabtique, pour simplifier la vie des utilisateurs. Le passage des minuscules aux majuscules se fait en changeant le 6me bit du caractre, ce qui est trs simple. Les symboles 0 31 , ainsi que le 127me sont un peu bizarres... Revenons en dtail sur ces symboles bizarres.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

21/378

Symboles non-affichables
Ces symboles prsents dans ce standard ASCII ne peuvent mme pas tre taps au clavier et ils ne sont pas affichables ! Mais quoi peuvent-ils bien servir ?

Il faut savoir que ce standard est assez ancien. A l'poque de la cration de ce standard, il existait de nombreuses imprimantes et autres systmes qui l'utilisaient Et pour faciliter la conception de ces machines, on a plac dans cette table ASCII des symboles qui n'taient pas destins tre affichs, mais dont le but tait de donner un ordre l'imprimante/machine crire... On trouve ainsi des symboles de retour la ligne, par exemple.

Unicode
Le problme avec la table ASCII, c'est qu'on se retrouve assez rapidement limit avec nos 128 symboles. On n'arrive pas caser les accents ou certains symboles particuliers certaines langues dedans. Impossible de coder un texte en grec ou en japonais : les idogrammes et les lettres grecques ne sont pas dans la table ASCII. Pour combler ce genre de manque, de nombreuses autres mthodes sont apparues qui peuvent coder bien plus de symboles que la table ASCII. Elles utilisent donc plus de 7 bits pour coder leurs symboles : on peut notamment citer l'unicode. Pour plus de simplicit, l'unicode est parfaitement compatible avec la table ASCII : les 128 premiers symboles de l'unicode sont ceux de la table ASCII, et sont rangs dans le mme ordre.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

22/378

Nos bits prennent la porte !

Grce au chapitre prcdent, on sait enfin comment sont reprsentes nos donnes les plus simples avec des bits. On n'est pas encore alls bien loin : on ne sait pas comment reprsenter des bits dans notre ordinateur ou les modifier, les manipuler, ni faire quoi que ce soit avec. On sait juste transformer nos donnes en paquets de bits (et encore, on ne sait vraiment le faire que pour des nombres entiers, des nombres virgule et du texte...). C'est pas mal, mais il reste du chemin parcourir ! Rassurez-vous, ce chapitre est l pour corriger ce petit dfaut. On va vous expliquer comment reprsenter des bits dans un ordinateur et quels traitements lmentaires notre ordinateur va effectuer sur nos bits. Et on va voir que tout cela se fait avec de llectricit !

Codage NRZ
Pour compter en binaire , il faut travailler avec des bits qui peuvent prendre deux valeurs notes 0 et 1. Le tout est de savoir comment reprsenter ces bits dans l'ordinateur. Pour cela, on utilise une grandeur physique nomme la tension. Pas besoin de savoir ce que c'est, sachez juste que a se mesure en volts et que a n'est pas synonyme de courant lectrique. Rien voir avec un quelconque dplacement dlectrons, comme certains le pensent. Avec cette tension, il y a diverses mthodes pour coder un bit : codage Manchester, NRZ, etc. Ces diverses mthodes ont chacune leurs avantages et leurs dfauts. Autant trancher dans le vif tout de suite : la quasi-intgralit des circuits de notre ordinateur se basent sur le codage NRZ. Pour coder un 0 ou 1 en NRZ, si suffit de dire que si la tension est en-dessous d'un seuil donn, C'est un 0. Et il existe un autre seuil au-dessus duquel la tension reprsente un 1. Du moins, c'est ainsi dans la majorit des cas : il arrive que ce soit l'inverse sur certains circuits lctroniques : en-dessous d'un certain seuil, c'est un 1 et si c'est au-dessus d'un autre seuil c'est 0. Tout ce qu'il faut retenir, c'est qu'il y a un intervalle pour le 0 et un autre pour le 1. En dehors de ces intervalles, on considre que le circuit est trop imprcis pour pouvoir conclure sur la valeur de la tension : on ne sait pas trop si c'est un 1 ou un 0.

Il y a deux seuils, car les circuits qui manipulent des tensions n'ont pas une prcision parfaite, et qu'une petite perturbation lectrique pourrait alors transformer un 0 en 1. Pour limiter la casse, on prfre sparer ces deux seuils par une sorte de marge de scurit. Ces tensions vont tre manipules par diffrents circuits lectroniques plus ou moins sophistiqus. Pour pouvoir travailler avec des tensions, nos circuits ont besoin d'tre aliments en nergie. Pour cela, notre circuit possdera une tension qui alimentera le circuit en nergie, qui s'appelle la tension d'alimentation. Aprs tout, si un circuit doit coder des bits valant 1, il faudra bien qu'il trouve de quoi fournir une tension de 2, 3, 5 volts : la tension codant notre 1 ne sort pas de nulle part ! De mme, on a besoin d'une tension de rfrence valant zro volt, qu'on appelle la masse, qui sert pour le zro.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

23/378

Dans tous les circuits lectroniques (et pas seulement les ordinateurs), cette tension d'alimentation varie gnralement entre 0 et 5 volts. Mais de plus en plus, on tend utiliser des valeurs de plus en plus basses, histoire d'conomiser un peu d'nergie. Et oui, car plus un circuit utilise une tension leve, plus il consomme d'nergie et plus il chauffe. Pour un processeur, il est rare que les modles rcents utilisent une tension suprieure 2 volts : la moyenne tournant autour de 1-1.5 volts. Mme chose pour les mmoires : la tension d'alimentation de celle-ci diminue au court du temps. Pour donner des exemples, une mmoire DDR a une tension d'alimentation qui tourne autour de 2,5 volts, les mmoires DDR2 ont une tension d'alimentation qui tombe 1,8 volts, et les mmoires DDR3 ont une tension d'alimentation qui tombe 1,5 volts. C'est trs peu : les composants qui manipulent ces tensions doivent tre trs prcis.

Transistors
Pour commencer, nous allons devoir faire une petite digression et parler un peu dlectronique : sans cela, impossible de vous expliquer en quoi est fait un ordinateur ! Sachez tout d'abord que nos ordinateurs sont fabriqus avec des composants lectroniques que l'on appelle des transistors, relis pour former des circuits plus ou moins compliqus. Presque tous les composants d'un ordinateur sont fabriqus avec un grand nombre de transistors, qui peut monter quelques milliards sur des composants sophistiqus. Pour donner un exemple, sachez que les derniers modles de processeurs peuvent utiliser prs d'un milliard de transistors. Et le tout doit tenir sur quelques centimtres carrs : autant vous dire que la miniaturisation a fait dnormes progrs ! Il existe diffrents types de transistors, chacun avec ses particularits, ses avantages et ses inconvnients. On ne va pas en parler plus que a, mais il faut prciser que les transistors utiliss dans nos ordinateurs sont des transistors effet de champ technologie CMOS. Si vous ne comprenez pas ce que a signifie, ce n'est pas grave, c'est un simple dtail sans grande importance. Mais qu'est-ce qu'un transistor CMOS ?

Il s'agit simplement d'un composant reli un circuit lectronique par trois morceaux de "fil" conducteur que l'on appelle broches. On peut appliquer de force une tension lectrique sur ces broches (attention ne pas la confondre avec le courant lectrique), qui peut reprsenter soit 0 soit 1 en fonction du transistor utilis.

Ces trois broches ont des utilits diffrentes et on leur a donn un nom pour mieux les reprer : la grille ; le drain ; la source. Dans les processeurs, on utilise notre transistor comme un interrupteur qui ragit en fonction de sa grille : suivant la valeur de la tension qui est applique sur la grille, le transistor conduira ou ne conduira pas le courant entre la source et le drain. En clair, appliquez la tension adquate et la liaison entre la source et le drain se comportera comme un interrupteur ferm et conduira le courant : le transistor sera alors dit dans l'tat passant. Par contre, si vous appliquez une tension la bonne valeur sur la grille, cette liaison se comportera comme un interrupteur ouvert et le courant ne passera pas : le transistor sera dit dans l'tat bloqu.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

24/378

Il existe ainsi deux types de transistors, qui diffrent entre autres par la tension qu'il faut mettre sur la grille pour les ouvrir/fermer : les transistors NMOS qui s'ouvrent lorsqu'on place une tension gale zro sur la grille et se ferment si la tension place sur cette mme grille reprsente un 1 ; et les PMOS pour qui s'est l'inverse : ils se ferment lorsque la tension sur la grille est nulle, et s'ouvrent si celle-ci reprsente un 1.

Loi de Moore
De nos jours, le nombre de transistors des composants lectroniques actuels augmente de plus en plus, et les concepteurs de circuits rivalisent d'ingniosit pour miniaturiser le tout. En 1965, le cofondateur de la socit Intel, spcialise dans la conception des mmoires et de processeurs, a affirm que la quantit de transistors prsents dans un processeur doublait tous les 18 mois. Cette affirmation porte aujourd'hui le nom de premire loi de Moore. En 1975, le cofondateur d'Intel rvalua cette affirmation : ce n'est pas tous les 18 mois que le nombre de transistors d'un processeur double, mais tous les 24 mois. Cette nouvelle version, appele la seconde loi de Moore, a redoutablement bien survcue : elle est toujours valable de nos jours.

Ce faisant, la complexit des processeurs augmente de faon exponentielle dans le temps et sont censs devenir de plus en plus gourmands en transistors au fil du temps.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

25/378

De plus, miniaturiser les transistors permet parfois de les rendre plus rapides : c'est un scientifique du nom de Robert Dennard qui a dcouvert un moyen de rendre un transistor plus rapide en diminuant certains paramtres physiques d'un transistor. C'est grce cela que nos processeurs et nos cartes graphiques deviennent plus rapides, plus puissants, plus performants : cela permet d'avoir des transistors plus rapides, de mettre plus de circuits pour faire plus de choses, d'amliorer ou d'optimiser les circuits existants, etc. Sans cette miniaturisation, vous pouvez tre certains que nos processeurs en seraient pas aussi complexes quaujourdhui. Mais attention, cela ne signifie pas pour autant que le nombre de transistors soit un indicateur efficace de performances : avoir beaucoup de transistors ne sert rien si on le les utilise pas correctement. Mais cette miniaturisation a ses limites et elle pose de nombreux problmes dont on ne parlera pas ici. Sachez seulement que cette loi de Moore restera valable encore quelques dizaines d'annes, et qu'au del, on ne pourra plus rajouter de transistors dans nos processeurs aussi facilement que de nos jours.

Portes logiques
C'est bien beau de savoir coder des bits et d'avoir des transistors pour les manipuler, mais j'aimerais savoir comment on fait pour triturer des bits avec des transistors ?

Et bien que vos vux soient exhausss ! La solution consiste rassembler ces transistors dans ce qu'on appelle des circuits logiques. Ce sont simplement des petits circuits, fabriqus avec des transistors, qui possdent des sorties et des entres, sur lesquelles on va placer des bits pour les manipuler. Ces entres et ces sorties ne sont rien d'autre que des morceaux de "fil" conducteur sur lesquelles on peut mesurer une tension qui reprsente un zro ou un 1. Sur chaque entre du composant, on peut forcer la valeur de la tension, histoire de mettre l'entre 0 ou 1. A partir de l, le circuit lectronique va ragir et dduire la tension placer sur chacune de ses sorties en fonction de ses entres. Autant vous le dire tout de suite, votre ordinateur est remplit de ce genre de choses. Quasiment tous les composants de notre ordinateur sont fabriqus avec ce genre de circuits. Par exemple, notre processeur est un composant lectronique comme un autre, avec ses entres et ses sorties.

Brochage d'un processeur MC68000. L'exemple montr au dessus est un processeur MC68000, un vieux processeur, prsent dans les calculatrices TI-89 et TI-92, qui contient 68000 transistors (d'o son nom : MC68000) et invent en 1979. Il s'agit d'un vieux processeur compltement obsolte et particulirement simple. Et pourtant, il y en a des entres et des sorties : 37 au total ! Pour comparer, sachez que les processeurs actuels utilisent entre 700 et 1300 broches d'entre et de sortie. A ce jeu l, notre pauvre petit MC68000 passe pour un gringalet !

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

26/378

Le nombre de broches (entres et sorties) d'un processeur dpend du socket de la carte mre. Par exemple, un socket LGA775 est conu pour les processeurs comportant 775 broches d'entre et de sortie, tandis qu'un socket AM2 est conu pour des processeurs de 640 broches. Certains sockets peuvent carrment utiliser 2000 broches (c'est le cas du socket G34 utilis pour certains processeurs AMD Opteron). Pour la mmoire, le nombre de broches dpend du format utilis pour la barrette de mmoire (il existe trois formats diffrents), ainsi que du type de mmoire. Certaines mmoires obsoltes (les mmoires FPM-RAM et EDO-RAM) se contentaient de 30 broches, tandis que la mmoire DDR2 utilise entre 204 et 244 broches.

Nanmoins, quelque soit la complexit du circuit crer, celui-ci peut tre construit en reliant quelques petits circuits de base entre eux. Ces circuits de base sont nomms des portes logiques. Il existe trois portes logiques qui sont trs importantes et que vous devez connaitre : les portes ET, OU et NON . Mais pour se faciliter la vie, on peut utiliser d'autres portes, plus ou moins diffrentes. V oyons un peu quelles sont ces portes, et ce qu'elles font.

La porte NON
Le premier oprateur fondamental est la porte NON aussi appele porte inverseuse. Cette porte agit sur un seul bit. Cette porte est symbolise par le schma suivant :

Sur les schmas qui vont suivre, les entres des portes logiques seront gauche et les sorties droite !

Pour simplifier la comprhension, je vais rassembler les tats de sortie en fonction des entres pour chaque porte logique dans un tableau qu'on appelle table de vrit. V celui de la porte NON : oici Entre Sortie 0 1 1 0

Le rsultat est trs simple, la sortie d'une porte NON est exactement le contraire de l'entre.

Cblage
Cette porte est fabrique avec seulement deux transistors et son schma est diablement simple. V le montage en question. oici

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

27/378

Je crois que mrite une petite explication, non ? Rappelez-vous qu'un transistor CMOS n'est rien d'autre qu'un interrupteur, qu'on peut fermer suivant ce qu'on met sur sa grille. Certains transistors se ferment quand on place un 1 sur la grille, et d'autres quand on place un zro. L'astuce du montage vu plus haut consiste utiliser deux transistors diffrents : celui du haut conduit le courant quand on place un 0 sur sa grille, et ne conduit pas le courant sinon ; et celui du bas fait exactement l'inverse. Si on met un 1 en entre de ce petit montage lectronique, le transistor du haut va fonctionner comme un interrupteur ouvert, et celui du bas comme un interrupteur ferm. On se retrouvera donc avec notre sortie relie au zro volt, et donc qui vaut zro.

Inversement, si on met un 0 en entre de ce petit montage lectronique, le transistor du bas va fonctionner comme un interrupteur ouvert, et celui du haut comme un interrupteur ferm. On se retrouvera donc avec notre sortie relie la tension d'alimentation, qui vaudra donc 1.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

28/378

Comme vous le voyez, avec un petit nombre de transistors, on peur russir crer de quoi inverser un bit. Et on peut faire pareil avec toutes les autres portes lmentaires : on prend quelques transistors, on cble cela comme il faut, et voil une porte logique toute neuve !

La porte ET
Maintenant une autre porte fondamentale : la porte ET. Cette fois, diffrence avec la porte NON , la porte ET a 2 entres, mais une seule sortie. V comment on la symbolise : oici

Cette porte a comme table de vrit : Entre 1 Entre 2 Sortie 0 0 1 1 0 1 0 1 0 0 0 1

Cette porte logique met sa sortie 1 quand toutes ses entres valent 1.

La porte OU
Maintenant une autre porte fondamentale : la porte OU. Cette fois, comme la porte ET, elle possde 2 entres, mais une seule sortie.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

On symbolise cette porte comme ceci :

29/378

Cette porte est dfinie par la table de vrit suivante : Entre 1 Entre 2 Sortie 0 0 1 1 0 1 0 1 0 1 1 1

Cette porte logique met sa sortie 1 quand au moins une de ses entres vaut 1.

Porte XOR
Avec une porte OU , deux ET et deux portes NON , on peut crer une porte nomme XOR. Cette porte est souvent appele porte OU Exclusif . Sa table de vrit est : Entre 1 Entre 2 Sortie 0 0 1 1 0 1 0 1 0 1 1 0

On remarque que sa sortie est 1 quand les deux bits placs sur ses entres sont diffrents, et valent 0 sinon. On la symbolise comme ceci :

Porte NAND
La porte NAND est l'exact inverse de la sortie d'une porte ET. Elle fait la mme chose qu'une porte ET suivie d'une porte NON . Sa table de vrit est :

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

Entre 1 Entre 2 Sortie 0 0 1 1 0 1 0 1 1 1 1 0

30/378

Cette porte a une particularit : on peut recrer les portes ET, OU et NON , et donc n'importe quel circuit lectronique, en utilisant des montages composs uniquement de portes NAND. A titre d'exercice, vous pouvez essayez de recrer les portes ET, OU et NON partir de portes NAND. Ce serait un petit entrainement assez sympathique. Aprs tout, si a peut vous occuper lors d'un dimanche pluvieux. On la symbolise par le schma qui suit.

Au fait, si vous regardez le schma de la porte NAND, vous verrez que son symbole est presque identique celui d'une porte ET : seul le petit rond ajout sur la sortie de la porte a t rajout. Et bien sachez que ce petit rond est une sorte de raccourci pour schmatiser une porte NON . Ainsi, si vous voyez un petit rond quelque part sur un schma (sur une entre ou une sortie, peut importe), sachez que ce petit rond symbolise une porte NON .

Porte NOR
La porte NOR est l'exact inverse de la sortie d'une porte OU. Elle est quivalente une porte OU suivie d'une porte NON . Sa table de vrit est : Entre 1 Entre 2 Sortie 0 0 1 1 0 1 0 1 1 0 0 0

On peut recrer les portes ET, OU et NON , et donc n'importe quel circuits lectronique, en utilisant des montages composs uniquement de portes NOR. Comme quoi, la porte NAND n'est pas la seule avoir ce privilge. Cela a une consquence : on peut concevoir un circuits en n'utilisant que des portes NOR. Pour donner un exemple, sachez que les ordinateurs chargs du pilotage et de la navigation des missions Appollo taient intgralement conus uniquement avec des portes NOR. A titre d'exercice, vous pouvez essayez de recrer les portes ET, OU et NON partir de portes NOR. Si vous en avez envie, hein ! On la symbolise avec le schma qui suit.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

31/378

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

32/378

Crons nos circuits !

Bon, c'est bien beau d'avoir quelques portes logiques, mais si je veux crer un circuit, je fais comment ?

Il faut avouer qu'on irait pas loin en sachant uniquement ce que sont les ET, NAND, et autres. Ce qu'il faudrait, c'est pouvoir crer de vrais circuits. Et bien que vos vux soient exaucs (enfin presque) : nous allons enfin voir comment sont raliss les circuits de nos ordinateurs. Du moins, nous allons voir comment crer des circuits simples, mais qui sont la base des circuits de notre ordinateur.

Circuits combinatoires
Pour commencer, nous allons parler d'une classe de circuits assez simples : les circuits combinatoires. Ces circuits font comme tous les autres circuits : ils prennent des donnes sur leurs entres, et fournissent un rsultat en sortie. Le truc, c'est que ce qui est fourni en sortie ne dpend que du rsultat sur les entres, et de rien d'autre ! Cela peut sembler tre vident, mais on verra que ce n'est pas le cas pour tous les circuits. Pour donner quelques exemples de circuits combinatoires, on peut citer les circuits qui effectuent des additions, des multiplications, ou d'autres oprations arithmtiques du genre. Par exemple, le rsultat d'une addition ne dpend que des nombres additionner et rien d'autre. Pareil pour la division, la soustraction, la multiplication, etc. Notre ordinateur contient de nombreux circuits de ce genre. Toutefois, nous ne verrons pas tout de suite les circuits capables d'effectuer ces calculs : ceux-ci sont un peu plus compliqus que ce qu'on va voir ici et on va donc les laisser pour plus tard, dans la partie sur le processeur. Par contre, vous apprendrez crer une petite mmoire de 1 bit dans ce chapitre.

Tables de vrit
Bref, poursuivons. J'ai promis de vous apprendre concevoir des circuits, de faon "simple". Pour commencer, il va falloir dcrire ce que notre circuit fait. Pour un circuit combinatoire, la tche est trs simple, vu que ce qu'on trouve sur ses sorties ne dpend que de ce qu'on a sur les entres. Pour dcrire intgralement le comportement de notre circuit, il suffit donc de lister la valeur de chaque sortie pour toute valeur possible en entre. Cela peut se faire simplement en crivant ce qu'on appelle la table de vrit du circuit. Pour crer cette table de vrit, il faut commencer par lister toutes les valeurs possibles des entres dans un tableau, et crire cot les valeurs des sorties qui correspondent ces entres. Cela peut tre assez long : pour un circuit ayant entres, ce tableau aura lignes.

Exemple : circuit de calcul du bit de parit

Pour donner un exemple, on va prendre l'exemple d'un circuit calculant la le bit de parit d'un nombre. Le quoi ?

Ah oui, pardon ! Ce bit de parit est une technique qui permet de dtecter des erreurs de transmission ou dventuelles corruptions de donnes qui modifient un nombre impair de bits. Si un, trois, cinq, ou un nombre impair de bits voient leur valeur s'inverser (un 1 devient un 0, ou inversement), l'utilisation d'un bit de parit permettra de dtecter cette erreur. Par contre, il sera impossible de la corriger. Le principe cach derrire un bit de parit est simple : il suffit d'ajouter un bit supplmentaire aux bits stocker. Le but d'un bit de parit est de faire en sorte que le nombre de bits 1 dans le nombre stocker, bit de parit inclut, soit toujours un nombre pair. Ce bit, le bit de parit vaudra : zro si le nombre de bits 1 dans le nombre stocker (bit de parit exclu) est pair ; 1 si ce nombre est impair. Dtecter une erreur est simple : on compte le nombre de bits 1 dans le nombre stocker, bit de parit inclut, et on regarde s'il est pair. S'il est impair, on sait qu'au moins un bit t modifi. Dans notre cas, on va crer un circuit qui calcule le bit de parit d'un nombre de 3 bits. Celui-ci dispose donc de 3 entres, et d'une sortie sur laquelle on retrouvera notre bit de parit. Notre tableau possdera donc lignes : cela fait 8 lignes. V donc le oici tableau de ce circuit, ralis ci-dessous.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

Entre e2 Entre e1 Entre e0 0 0 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1 Sortie s0 0 1 1 0 1 0 0 1

33/378

quations logiques
Une fois qu'on a la table de vrit, une bonne partie du travail dj t fait. Il ne nous reste plus qu' transformer notre table en ce qu'on appelle des quations logiques. Mais que viennent faire les quations ici ?

Attention : il ne s'agit pas des quations auxquelles vous tes habitus. Ces quations logiques ne font que travailler avec des 1 et des 0, et n'effectuent pas d'oprations arithmtiques mais seulement des ET, des OU, et des NON . Ces quations vont ainsi avoir des bits pour inconnues. Chacune de ces quations logiques correspondra un circuit, et vice-versa : un circuit sera associ une quation qui permettra de dcrire le circuit. Par exemple, prenons le circuit vu dans le QCM de la question prcdente.

Ce circuit a pour quation logique

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

34/378

Syntaxe
Pour pouvoir commencer crire ces quations, il va falloir faire un petit point de syntaxe. V rsum dans ce tableau les oici diffrentes oprations, ainsi que leur notation. Dans ce tableau, a et b sont des bits.

Opration logique Symbole NON a a ET b a OU b a XOR b

V oil, avec ce petit tableau, vous savez comment crire une quation logique...enfin presque, il ne faut pas oublier le plus important : les parenthses ! Et oui, il faudra bien viter quelques ambiguts dans nos quations. C'est un peu comme avec des quations normales : donne un rsultat diffrent de . Avec nos quations logiques, on peut trouver des situations similaires : par exemple, est diffrent de . On est alors oblig d'utiliser des parenthses.

Mthode des Minterms

Reste savoir comment transformer une table de vrit en quations logiques, et enfin en circuit. Pour cela, il n'y a pas trente-six solutions : on va crire une quation logique qui permettra de calculer la valeur (0 ou 1) d'une sortie en fonction de toutes les entres du circuits. Et on fera cela pour toutes les sorties du circuit que l'on veut concevoir. Pour cela, on peut utiliser ce qu'on appelle la mthode des minterms. Cette mthode permet de dcouper un circuit en quelques tapes simples : lister les lignes de la table de vrit pour lesquelles la sortie vaut 1 ; crire l'quation logique pour chacune de ces lignes ; faire un OU entre toutes ces quations logiques, en n'oubliant pas de les entourer par des parenthses Il ne reste plus qu' faire cela pour toutes les sorties du circuit, et le tour est jou.

Exemple : circuit de calcul du bit de parit

Pour illustrer le tout, on va reprendre notre exemple avec le bit de parit. tape 1 : lister les lignes de la table de vrit dont la sortie est 1.

Entre e2 Entre e1 Entre e0 0 0 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1

Sortie s0 0 1 1 0 1 0 0 1

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

tape 2 : crire l'quation logique de chacune des lignes slectionnes l'tape d'avant. Pour crire l'quation logique d'une ligne, il faut simplement : lister toutes les entres de la ligne ; faire un NON sur chaque entre 1 ; et faire un ET avec le tout. Par exemple, prenons la premire ligne dont la sortie vaut 1, savoir la deuxime.

35/378

Entre e2 Entre e1 Entre e0 0 0 1

L'quation logique de cette ligne sera donc :

Il faut ensuite faire cela pour toutes les lignes dont la sortie vaut 1. Seconde ligne :

Entre e2 Entre e1 Entre e0 0 1 0

L'quation logique de cette ligne sera donc : Troisime ligne :

Entre e2 Entre e1 Entre e0 1 0 0

L'quation logique de cette ligne sera donc : Quatrime ligne :

Entre e2 Entre e1 Entre e0 1 1 1

L'quation logique de cette ligne sera donc : tape 3

On a alors obtenu nos quations logiques. Reste faire un bon gros OU entre toutes ces quations, et le tour est jou ! On obtient alors l'quation logique suivante : A ce stade, vous pourriez traduire cette quation directement en circuit, mais il y a un petit inconvnient...

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

36/378

Simplifications du circuit
Comme on l'a vu, on fini par obtenir une quation logique qui permet de dcrire notre circuit. Mais quelle quation : on se retrouve avec un gros paquet de ET et de OU un peu partout ! Autant dire qu'il serait sympathique de pouvoir simplifier cette quation. Bien sr, on peut vouloir simplifier cette quation juste pour se simplifier la vie lors de la traduction de cette quation en circuit, mais cela sert aussi autre chose : cela permet d'obtenir un circuit plus rapide et/ou utilisant moins de portes logiques. Autant vous dire qu'apprendre simplifier ces quations est quelque chose de crucial, particulirement si vous voulez concevoir des circuits un tant soit peu rapides. Pour donner un exemple, sachez que la grosse quation logique obtenue auparavant : ; peut se simplifier en : avec les rgles de simplifications vues au-dessus. Dans cet exemple, on passe donc de 17 portes logiques seulement 3 !

Rgles de lalgbre de Boole

Pour simplifier notre quation, on peut utiliser certaines proprits mathmatiques simples de ces quations. Ces proprits forment ce qu'on appelle lalgbre de Boole, du nom du mathmaticien qui les a dcouvertes/inventes.

Rgle

Description

Commutativit

Associativit

Distributivit Idempotence Element nul Element Neutre

;

Loi de De Morgan

Complmentarit

On peut aussi rajouter que la porte XOR a ses propres rgles. Regle Description

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

37/378

XOR

En utilisant ces rgles algbriques, on peut arriver simplifier une quation assez rapidement. On peut ainsi factoriser ou dvelopper certaines expressions, comme on le ferait avec une quation normale, afin de simplifier notre quation logique. Le tout est de bien faire ces simplifications en appliquant correctement ces rgles. Pour cela, il n'y a pas de recette miracle : vous devez sortir votre cerveau, et rflchir ! Il existe d'autres mthodes pour simplifier nos circuits. Les plus connues tant les tableaux de Karnaugh et l'algorithme de Quine Mc Cluskey. On ne parlera pas de ces mthodes, qui sont assez complexes et n'apporteraient rien dans ce tutoriel. Il faut dire que ces mthodes risquent de ne pas vraiment nous servir : elles possdent quelques dfauts qui nous empchent de crer de trs gros circuits avec. Pour le dire franchement, elles sont trop longues utiliser quand le nombre d'entre du circuit dpasse 5 ou 6.

Mais
Un des problmes des approches mentionnes plus haut est qu'elles ncessitent de crer une table de vrit. Et plus on a d'entres, plus la table devient longue, et cela prend du temps pour la remplir. Cela ne pose aucun problmes pour crer des circuits de moins de 5 ou 6 variables, mais au-del, il y a de quoi rendre les armes assez rapidement. Et si vous ne me croyez pas, essayez de remplir la table de vrit d'un circuit qui additionne deux nombres de 32 bits, vous verrez : cela vous donnera une table de vrit de 4 294 967 296 lignes. Je ne sais pas si quelqu'un a dj essay de crer une telle table et d'en dduire le circuit correspondant, mais si c'est le cas, j'aurais de srieuses craintes sur sa sant mentale. Pour compenser, on doit donc ruser. La premire astuce consiste crer des circuits en combinant intelligemment des circuits plus petits, qui travaillent sur un nombre plus petit d'entre, et les relier ensemble dans un seul gros circuit. Par exemple, rien ne vous empche de crer un circuit qui additionne 4 bits, et d'en relier plusieurs ensembles pour obtenir un circuit additionnant deux nombres de 16 bits. Autre technique : crer un algorithme matriel. En rflchissant un peu, on peut trouver un moyen de dcomposer notre circuit en pleins de petits sous-circuits assez simples construire. Ces algorithmes matriels sont vraiment semblables aux algorithmes logiciels, qu'on utilise pour crer des programmes.

Mmorisation et circuits squentiels

Avec le premier chapitre, on sait coder de linformation. Avec le second chapitre et la partie sur les circuits combinatoires, on sait traiter et manipuler de linformation. Il nous manque encore une chose : savoir comment faire pour mmoriser de l'information. Les circuits combinatoires nont malheureusement pas cette possibilit et ne peuvent pas stocker de l'information pour l'utiliser quand on en a besoin. La valeur de la sortie de ces circuits ne dpend que de l'entre, et pas de ce qui s'est pass auparavant : les circuits combinatoires n'ont pas de mmoire. Ils ne peuvent qu'effectuer un traitement sur des donnes immdiatement disponibles. On n'irait pas loin en se contentant de ce genre de circuits : il serait totalement impossible de crer un ordinateur qui soit un assemblage de circuits combinatoires.

Comment donner de la mmoire nos circuits ?

Mais rassurez-vous, tout n'est pas perdu ! Il existe des circuits qui possdent une telle capacit de mmorisation : ce sont les circuits squentiels. Ces circuits sont donc capables de mmoriser des informations, et peuvent les utiliser pour dterminer quoi mettre sur leurs sorties. L'ensemble de ces informations mmorises dans notre circuit forme ce qu'on appelle l'tat de notre circuit. Pour mmoriser des informations (un tat), notre circuit doit possder des circuits spciaux, chacun d'entre eux pouvant stocker un ou plusieurs bits, qu'on appelle des mmoires. On verra dans la suite de ce tutoriel comment les mmoires actuelles font pour stocker des bits : elles peuvent utiliser aussi bien un support magntique (disques durs), optique (CD-ROM, DVDROM, etc), que des transistors (mmoires RAM, FLASH, ROM, etc), etc. Reste que cet tat peut changer au cours du fonctionnement de notre circuit. Rien nempche de vouloir modifier les informations mmorises dans un circuit. On peut faire passer notre circuit squentiel d'un tat un autre sans trop de problmes. Ce passage d'un tat un autre s'appelle une transition. La transition effectue entre deux tats dpend souvent de ce qu'on met sur l'entre du circuit. Aussi bien l'tat du circuit (ce qu'il a mmoris) que les valeurs prsentes sur ses entres, vont dterminer ce qu'on trouve sur la sortie. Par exemple, la valeur

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

38/378

prsente sur l'entre peut servir mettre jour l'tat ou donner un ordre au circuit pour lui dire : change d'tat de tel ou tel faon. Dans la suite du tutoriel, vous verrez que certains composants de notre ordinateur fonctionnent sur ce principe : je pense notamment au processeur, qui contient des mmoires internes dcrivant son tat (des registres), et que l'on fait changer d'tat via des instructions fournies en entre. Un circuit squentiel peut tre intgralement dcrit par les tats qu'il peut prendre, ainsi que par les transitions possibles entre tats. Si vous voulez concevoir un circuit squentiel, tout ce que vous avez faire est de lister tous les tats possibles, et quelles sont les transitions possibles. Pour ce faire, on utilise souvent une reprsentation graphique, dans laquelle on reprsente les tats possibles du circuit par des cercles, et les transitions possibles par des flches.

Niveau circuits
Pour rendre possible les transitions, on doit mettre jour l'tat de notre circuit avec un circuit combinatoire qui dcide quel sera le nouvel tat de notre circuit en fonction de l'ancien tat et des valeurs des entres. Un circuit squentiel peut donc (sans que ce soit une obligation) tre dcoup en deux morceaux : une ou plusieurs mmoires qui stockent l'tat de notre circuit, et un ou plusieurs circuits combinatoires chargs de mettre jour l'tat du circuit, et ventuellement sa sortie. Pour la culture gnrale, il existe principalement deux types de circuits squentiels, qui varient suivant le traitement effectu sur l'tat du circuit. Ce sont les automates de Moore, et les Automates de Mealy.

Automates de Moore
Avec les automates de Moore, ce qu'on trouve en sortie ne dpend que de l'tat de l'automate. On peut donc simplement placer un circuit combinatoire qui se chargera de lire l'tat de l'automate et qui fournira un rsultat sur la sortie directement. Pour mettre jour l'tat, on place un circuit combinatoire qui va prendre les entres du circuit, ainsi que l'tat actuel du circuit (fourni sur la sortie), et qui dduira le nouvel tat, les nouvelles donnes mmoriser.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

39/378

Automates de Mealy
Autre forme de circuits squentiels : les automates de Mealy. Avec ceux-ci, la sortie dpend non seulement de l'tat du circuit, mais aussi de ce qu'on trouve sur les entres.

Bascules et mmoires
On a vu plus haut que la logique squentielle se base sur des circuits combinatoires, auxquels on a ajout des mmoires. Pour le moment, on sait crer des circuits combinatoires, mais on ne sait pas faire des mmoires. Pourtant, on a dj tout ce qu'il faut :

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

avec nos portes logiques, on peut crer des circuits capables de mmoriser un bit. Ces circuits sont ce qu'on appelle des bascules.

40/378

En assemblant plusieurs de ces bascules ensembles, on peut crer ce qu'on appelle des registres, des espces de mmoires assez rapides qu'on retrouve un peu partout dans nos ordinateurs : presque tous les circuits prsents dans notre ordinateur contiennent des registres, que ce soit le processeur, la mmoire, les priphriques, etc.

Principe
Une solution pour crer une bascule consiste boucler la sortie d'un circuit sur son entre, de faon ce que la sortie rafrachisse le contenu de l'entre en permanence et que le tout forme une boucle qui s'auto-entretienne. Une bonne partie des circuits squentiels contiennent des boucles quelque part, avec une entre relie sur une sortie. Ce qui est tous le contraire des circuits combinatoires, qui ne contiennent jamais la moindre boucle ! Bien sur, cela ne marche pas avec tous les circuits : dans certains cas, cela ne marche pas, ou du moins cela ne suffit pas pour mmoriser des informations. Par exemple, si je relie la sortie d'une porte NON son entre, le montage obtenu ne sera pas capable de mmoriser quoique ce soit. Et si on essayait avec deux portes NON ?

Ah, c'est plutt bien vu ! En effet, en utilisant deux portes NON , et en les reliant comme indiqu sur les schma juste en dessous, on peut mmoriser un bit.

Si on place l'entre de la premire porte NON zro, la sortie de celle-ci passera 1. Cette sortie sera relie l'entre de l'autre porte NON , qui inversera ce 1, donnant un zro. Zro qui sera alors r-envoy sur l'entre initiale. L'ensemble sera stable : on peut dconnecter l'entre du premier inverseur, celle-ci sera alors rafraichie en permanence par l'autre inverseur, avec sa valeur prcdente. Le mme raisonnement fonctionne si on met un 1 en sortie.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

41/378

Bascule RS NOR
Le seul problme, c'est qu'il faut bien mettre jour l'tat de ce bit de temps en temps. Il faut donc ruser. Pour mettre jour l'tat de notre circuit, on va simplement rajouter une entre notre circuit qui servira le mettre jour, et remplacer notre porte NON par une porte logique qui se comportera comme un inverseur dans certaines conditions. Le tout est de trouver une porte logique qui inverse le bit venant de l'autre inverseur si l'autre entre est zro (ou 1, suivant la bascule). Des portes NOR font trs bien l'affaire.

On obtient alors ce qu'on appelle des bascules RS. Celles-ci sont des bascules qui comportent deux entres sortie , sur laquelle on peut lire le bit stock.

et

, et une

Le principe de ces bascules est assez simple : si on met un 1 sur l'entre R et un 0 sur l'entre S, la bascule mmorise un zro ; si on met un 0 sur l'entre R et un 1 sur l'entre S, la bascule mmorise un un ; si on met un zro sur les deux entres, la sortie Q sera gale la valeur mmorise juste avant. Pour vous rappeler de ceci, sachez que les entres de la bascule ne sont nommes ainsi par hasard : R signifie Reset (qui signifie

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

42/378

mise zro en anglais), et S signifie Set (qui veut dire Mise un en anglais). Petite remarque : si on met un 1 sur les deux entres, le circuit ne rpond plus de rien. On ne sait pas ce qui arrivera sur ses sorties. C'est bte, mais c'est comme a !

Entre Reset Entre Set 0 0 1 1 0 1 0 1

Sortie Q Bit mmoris par la bascule 1 0 Interdit

Bascules RS NAND
On peut aussi utiliser des portes NAND pour crer une bascule.

En utilisant des portes NAND, le circuit change un peu. Celles-ci sont des bascules qui comportent deux entres sortie , sur laquelle on peut lire le bit stock.

et

, et une

Ces bascules fonctionnent diffremment de la bascule prcdente : si on met un 0 sur l'entre et un 1 sur l'entre , la bascule mmorise un 0 ; si on met un 1 sur l'entre et un 0 sur l'entre , la bascule mmorise un 1 ; si on met un 1 sur les deux entres, la sortie sera gale la valeur mmorise juste avant.

Entre Reset Entre Set 0 0 1 1 0 1 0 1

Sortie Q Interdit 0 1 Bit mmoris par la bascule

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

43/378

Les autres bascules

Il existe d'autres types de bascules, comme les bascules D, JK, T, etc. Toutes fonctionnent sur un principe plus ou moins similaire aux bascules vues au-dessus. Pour information, on reparlera des bascules D dans la suite du tutoriel, quand on verra en quoi sont faites certaines mmoires RAM : les SRAM, pour tre prcis.

Tic, Tac, Tic, Tac : Le signal d'horloge

videment, tout circuit, quel qu'il soit, va mettre un petit peu de temps avant de ragir. Ce temps mit par le circuit pour s'apercevoir qu'il s'est pass quelque chose sur son entre et modifier sa sortie en consquence s'appelle le temps de propagation. Pour faire simple, c'est le temps que met un circuit faire ce qu'on lui demande. Pour en donner une dfinition plus complte, on peut dire que c'est le temps entre le moment pendant lequel on modifie la tension sur une entre d'un circuit logique et le moment o cette modification se rpercute sur les sorties.

Origine du temps de propagation

Ce temps de propagation dpend fortement du circuit et peut dpendre de pas mal de paramtres. Mais il y a trois raisons principales, qui sont l'origine de ce temps de propagation. Il va de soit que plus ce temps de propagation est lev, plus notre circuit risque d'tre lent, et savoir sur quoi jouer pour le diminuer n'est pas un luxe. V oyons donc ce qu'il en est.

Critical Path
Le plus important de ces paramtres est ce qu'on appelle le Critical Path . Il s'agit du nombre maximal de portes logiques entre une entre et une sortie de notre circuit. Pour donner un exemple, nous allons prendre le schma suivant.

Pour ce circuit, le Critical Path est le chemin dessin en rouge. En suivant ce chemin, on va traverser 3 portes logiques, contre deux ou une dans les autres chemins. Pour information, tous les chemins possibles ne sont pas prsents sur le schma, mais ceux qui ne sont pas reprsents passent par moins de 3 portes logiques.

Fan Out
Autre facteur qui joue beaucoup sur ce temps de propagation : le nombre de composants relis sur la sortie d'une porte logique. Plus on connecte de portes logiques sur un fil, plus il faudra du temps pour la tension l'entre de ces portes change pour atteindre sa bonne valeur.

Wire Delay

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

44/378

Autre facteur qui joue dans le temps de propagation : le temps mis par notre tension pour se propager dans les "fils" et les interconnexions qui relient les portes logiques entre elles. Ce temps dpend notamment de la rsistance (celle de la loi d'Ohm, que vous avez surement dj vue il y a un moment) et de ce qu'on appelle la capacit des interconnexions. Ce temps perdu dans les fils devient de plus en plus important au fil du temps, les transistors et portes logiques devenant de plus en plus rapides force des les miniaturiser. Pour donner un exemple, sachez que si vous comptez crer des circuits travaillant sur des entres de 256 512 bits qui soient rapides, il vaut mieux modifier votre circuit de faon minimiser le temps perdu dans les interconnexions au lieu de diminuer le Critical Path.

L'horloge
Ce temps de propagation pose un lger problme : les diffrents circuits d'un ordinateur n'ont pas tous le mme temps de propagation, et ceux-ci vont fonctionner des vitesses diffrentes. Si l'on ne fait rien, on peut se retrouver avec des dysfonctionnements : par exemple, un composant lent peut donc rater deux ou trois ordres successifs envoyes par un composant un peu trop rapide. Comment synchroniser les portes logiques entre elles afin qu'elles puissent viter les ennuis dus l'existence de ce temps de propagation ?

Rassurez-vous, beaucoup de monde y a pens avant vous et de nombreuses solutions ont ts trouves. Pour cadencer les circuits les plus clbres de notre ordinateur (processeur, RAM, etc), on utilise une mthode redoutablement simple : cadencer tout ces circuits avec l'aide d'un signal d'horloge. Cette solution a besoin : d'une tension qui varie de faon cyclique ; d'une entre supplmentaire sur nos circuits. La tension cyclique est appele l'horloge. C'est elle qui va permettre de synchroniser tous nos composants entre eux. Tout ce qui compte pour notre horloge, c'est qu'elle passe de faon cyclique de 1 0. On doit avoir une tension qui varie dans le temps, mais de faon rptitive. Cette tension effectue un cycle plusieurs fois par seconde. Le temps que met la tension pour effectuer un cycle est ce qu'on appelle la priode. Le nombre de cycle, de priodes, en une seconde est appel la frquence. Cette frquence se mesure dans une unit : le hertz.

On voit sur ce schma que la tension ne peut pas varier instantanment : la tension met un certain temps pour passer de 0 1 et de 1 0. On appelle cela un front. La passage de 0 1 est appel un front montant et le passage de 1 0 un front descendant. L'ide de crer un signal d'horloge pour synchroniser nos circuits est sympa, mais comment nos circuits pourraient connaitre l'tat de l'horloge ?

Trs simple : on branche l'horloge sur une entre spcialement ddie pour.

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

45/378

Notre circuit doit alors tre conu de faon prendre en compte les bits prsents sur son entre uniquement lors d'un front montant et/ou descendant. En clair, notre circuit logique va "lire" les entres et en dduire une sortie uniquement lorsqu'il voit un front montant (ou descendant) sur son entre d'horloge ! Entre deux fronts montants (ou descendants), notre circuit est compltement autiste du point de vue des entres : on peut faire varier autant de fois qu'on veut nos entres, il faudra attendre le prochain front montant pour notre circuit ragisse. Pour ce faire, on peut se dbrouiller pour relier la ou les mmoires du circuit l'horloge et les concevoir pour qu'elles ne se mettent jour que lorsque l'horloge le demande. Ainsi, l'tat du circuit n'est mis jour que lorsque l'horloge l'autorise, et les modifications faites entre deux fronts d'horloge ne sont pas prises en compte. Cela peut se faire simplement en modifiant nos bascules RS de base, en rajoutant quelques portes logiques. Dans le cas o notre circuit est compos de plusieurs sous-circuits devant tre synchroniss via lhorloge, celle-ci est distribue tous les sous-circuits travers un rseau de connections lectriques qu'on appelle l'arbre d'horloge.

Et dans nos PC ?
Autant prvenir tout de suite : cette horloge n'est pas obligatoire ! Aprs tout, certains circuits squentiels peuvent se passer d'horloge et utilisent des mcanismes de synchronisation plus sophistiqus. Mais dans la pratique, une bonne partie des composants d'un ordinateur sont synchroniss par des horloges. Oui, j'ai bien dit DES horloges. Par exemple, notre processeur fonctionne avec une horloge diffrente de l'horloge de la mmoire ! La prsence de plusieurs horloges est justifie par un fait trs simple : certains composants informatiques sont plus lents que d'autres et ne sont pas capables de fonctionner avec des horloges rapides. Par exemple, le processeur a souvent une horloge trs rapide compare l'horloge des autres composants. En fait, il existe une horloge de base qui est "transforme" en plusieurs horloges dans notre ordinateur. On peut parfaitement transformer un signal d'horloge en un autre, ayant une priode deux fois plus grande ou plus petite, grce des montages lectroniques spcialiss. Cela peut se faire avec des composants appels des PLL ou encore avec des montages portes logiques un peu particuliers, qu'on n'abordera pas ici.

Frquence du processeur
Gnralement, plus un composant utilise une frquence leve, plus celui-ci est rapide. Cela n'est toutefois pas un lment dterminant : un processeur de 4 gigahertz peut tre bien plus rapide qu'un processeur de 200 gigahertz, pour des raisons techniques qu'on verra plus tard dans ce tutoriel. De nos jours, c'est plus la faon dont notre processeur va faire ses oprations qui sera dterminante : ne vous faites pas avoir par le Megahertz Myth ! Les premiers processeurs avaient une frquence assez faible et taient peu rapides. Au fil du temps, avec lamlioration des mthodes de conception des processeurs, la frquence de ceux-ci a commence a augmenter. Ces processeurs sont devenus

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

46/378

plus rapides, plus efficaces. Pour donner un ordre de grandeur, le premier microprocesseur avait une frquence de 740 kilohertz (740 000 hertz). De nos jours, les processeurs peuvent monter jusqu' plusieurs gigahertz : plusieurs milliards de fronts par secondes ! Quoiqu'il en soit, cette monte en frquence est aujourd'hui termine : de nos jours, les concepteurs de processeurs sont face un mur et ne peuvent plus trop augmenter la frquence de nos processeurs aussi simplement qu'avant. Et pourquoi les concepteurs de processeurs ont-ils arrts d'augmenter la frquence de nos processeurs ?

Augmenter la frquence a tendance vraiment faire chauffer le processeur plus que de raison : difficile de monter en frquence dans ces conditions. C'est la premire limite la monte en puissance : la dissipation thermique est tellement importante qu'elle limite grandement les amliorations possibles et la monte en frquence de nos processeurs. Auparavant, un processeur tait refroidi par un simple radiateur. Aujourd'hui, on est oblig d'utiliser un radiateur et un ventilateur, avec une pte thermique de qualit tellement nos processeurs chauffent. Pour limiter la catastrophe, tous les fabricants de CPU cherchent au maximum diminuer la temprature de nos processeurs. Pour cela, ils ont invent diverses techniques permettant de diminuer la consommation nergtique et la dissipation thermique d'un processeur. Mais ces techniques ne suffisent plus dsormais. C'est ce qui est appel le Heat Wall . Une grande part de cette dissipation thermique a lieu dans l'arbre d'horloge. On estime que 20% 35% de l'nergie envoye au processeur est inutilement transforme en chaleur dans l'arbre d'horloge. Cela vient du fait que les composants relis l'arbre horloge doivent continuer changer d'tat tant que l'horloge est prsente, et ce mme quand ils sont inutiliss. Ajoutez cela un nombre de transistors de plus en plus important dans nos processeurs, et le Heat Wall devient de rgle. Et voil, avec un cerveau en parfait tat de marche, et beaucoup de temps devant vous, vous pouvez construire n'importe quel circuit imaginable et fabriquer un ordinateur. Du moins, en thorie : n'essayez pas chez vous. Bon, blague part, avec ce chapitre, vous avez tout de mme le niveau pour crer certains circuits prsents dans notre ordinateur comme l'ALU. Sympa, non ?

www.siteduzero.com

Partie 1 : Tout a rien qu'avec des 0 et des 1 !

47/378

Partie 2 : Architecture de base

Dans ce chapitre, on essaye de comprendre comment est organis l'intrieur d'un ordinateur. On verra sa structure de base et nous parlerons des diffrents composants d'un PC : processeurs, RAM, priphriques, etc.

C'est quoi un ordinateur ?

Nos ordinateurs servent manipuler de l'information. Cette information peut tre une temprature, une image, un signal sonore, etc. Bref, du moment que a se mesure, c'est de l'information. Cette information, ils vont devoir la transformer en quelque chose d'exploitable et de facilement manipulable, que ce soit aussi bien du son, que de la vido, du texte et pleins d'autres choses. Pour cela, on va utiliser l'astuce vue au chapitre prcdent : on code chaque information grce un nombre. Une fois linformation code correctement sous la forme de nombres, il suffira d'utiliser une machine calculer (un calculateur) pour pouvoir effectuer des manipulations sur ces nombres, et donc sur linformation code : une simple machine calculer devient alors une machine traiter de l'information. Un ordinateur est donc un calculateur. Mais par contre, tout calculateur n'est pas un ordinateur : par exemple, certains calculateurs ne comptent mme pas en binaire. Mais alors, qu'est-ce qu'un ordinateur ?

Numrique versus analogique

Pour pouvoir traiter de l'information, la premire tape est d'abord de coder celle-ci. On a vu dans le chapitre sur le binaire comment reprsenter des informations simples en utilisant le binaire. Mais ce codage, cette transformation dinformation en nombre, peut tre fait de plusieurs faons diffrentes, et coder des informations en binaire n'est pas le seul moyen. Dans les grandes lignes, on peut identifier deux grands types de codage : Celui-ci utilise des nombres rels : il code linformation avec des grandeurs physiques (des trucs qu'on peut mesurer par un nombre) comprises dans un intervalle. Un codage analogique a une prcision thoriquement infinie : on peut par exemple utiliser toutes les valeurs entre 0 et 5 pour coder une information. Celle-ci peut alors prendre une valeur comme 1 , 2.2345646, ou pire... Celui-ci utilise uniquement des suites de symboles (qu'on peut assimiler des chiffres), assimilables des nombres entiers pour coder les informations. Pour simplifier, le codage numrique va coder des informations en utilisant des nombres entiers cods dans une base, qui peut tre 2, 3, 4, 16, etc. Les fameux symboles dont je viens de parler sont simplement les chiffres de cette base. Le codage numrique n'utilise qu'un nombre fini de valeurs, contrairement au codage analogique. Un code numrique a une prcision fige et ne pourra pas prendre un grand nombre de valeurs (compar l'infini). Cela donnera des valeurs du style : 0, 0.12 , 0.24 , 0.36, 0.48... jusqu' 2 volts.

Le codage analogique

Le codage numrique

Une machine calculer analogique peut donc faire des calculs avec une prcision trs fine, et peut mme faire certains calculs avec une prcision impossible atteindre avec un calculateur numrique : des drives, des intgrations, etc. Un calculateur numrique peut bien sr effectuer des intgrations et drivations, mais ne donnera jamais un rsultat exact et se contentera de donner une approximation du rsultat. Un calculateur analogique pourra donner un rsultat exact, du moins en thorie : un calculateur analogique insensible aux perturbations extrieures et n'ayant aucune imperfection n'a pas encore t invent. Pour les calculateurs numriques, les nombres manipuls sont cods par des suites de symboles (des "chiffres", si vous prfrez), et un calculateur numrique ne fera que transformer des suites de symboles en d'autres suites de symboles. V ous pouvez par exemple identifier chacun de ces symboles en un chiffre dans une base entire quelconque (pas forcment la base 10 ou 2). Dans un ordinateur, les symboles utiliss ne peuvent prendre que deux valeurs : 0 ou 1. De tels symboles ne sont rien d'autre que les fameux bits du chapitre prcdent, ce qui fait que notre ordinateur ne manipule donc que des bits : vous comprenez maintenant l'utilit du premier chapitre.

L'immunit au bruit
Vu ce qui a t dit prcdemment, nos calculateurs numriques ne semblent pas vraiment trs intressants. Et pourtant, la grande majorit de nos composants et appareils lctroniques (dont nos ordinateurs) sont des machines numriques ! C'est du au fait que les calculateurs analogiques ont un gros problme : ils ont une faible immunit au bruit. Explication : un signal analogique peut facilement subir des perturbations qui vont changer sa valeur, de faon parfois assez drastique. Autant vous dire que si une de ces perturbations un peu violente arrive, le rsultat qui arrive en sortie n'est vraiment pas celui attendu. Si un systme est peu sensible ces perturbations, on dit qu'il a une meilleure immunit au bruit.

www.siteduzero.com

Partie 2 : Architecture de base

48/378

Un signal numrique n'a pas trop ce problme : les perturbations ou parasites vont moins perturber le signal numrique et vont viter de trop modifier le signal original : l'erreur sera beaucoup plus faible qu'avec un signal analogique.

Le choix du binaire
Mais pourquoi avoir choisi la base 2 dans nos ordinateurs ?

La question est parfaitement lgitime : on aurait tout aussi bien pu prendre la base 10 ou n'importe quelle autre base. Il aurait t bien plus facile pour les humains qui doivent programmer ces machines d'utiliser la base 10. D'ailleurs, il existe de nombreuses machines qui manipulent des donnes numriques en base 10, en base 3, etc. D'ailleurs, on a dj invent des ordinateurs qui comptaient en base 3 : l'ordinateur SETUN, par exemple, fabriqu et conu pour l'universit de Moscou. Et rien nempche de crer des ordinateurs qui compteraient en base 10, 16, ou tout autre base. Mais il y a plusieurs raisons qui font que le binaire a t choisi comme base pour le codage de l'information dans un ordinateur. La plus importante de toutes, c'est qu'une perturbation n'aura pas le mme effet sur un nombre cod en base 2 et sur un nombre cod en base 10. En effet, supposons que nous utilisions, par exemple, une tension comprise entre 0 et 9 volts, qui code un chiffre/symbole allant de 0 9 (on utilise donc la base 10). Le moindre parasite peut changer la valeur du chiffre cod par cette tension.

Avec cette tension qui code seulement un 0 ou un 1 (de 0volts pour un 0 et 10 pour un 1), un parasite de 1 volt aura nettement moins de chance de modifier la valeur du bit cod ainsi.

www.siteduzero.com

Partie 2 : Architecture de base

49/378

Le parasite aura donc un effet nettement plus faible : la rsistance aux perturbations lectromagntiques extrieure est meilleure.

Ordinateurs
Une fois notre information code, il faut ensuite pouvoir la manipuler et la stocker. Ce traitement de notre information peut tre fait de diffrentes faons. Pour transformer cette information et en faire quelque chose, il va falloir effectuer une srie d'tapes. La premire tape, c'est de coder cette information sous une forme utilisable. Mais a ne fait pas tout, il faut encore traiter cette information. Pour cela, on va donc devoir : recevoir une information code par un nombre, modifier ce nombre et effectuer des calculs avec (de faon en faire quelque chose), envoyer le rsultat sur une sortie pour l'exploiter. Toute machine traitant de l'information est donc compos par : Une entre sur laquelle on envoie une information. Une unit de traitement, qui va manipuler l'information une fois code et donner un rsultat cod sous la forme d'une suite de symboles ou d'un nombre. Une sortie, qui va prendre le rsultat et en faire quelque chose (crire sur une imprimante ou sur un moniteur, mettre du son,...).

Automates
Cette unit de traitement peut trs bien consister en un vulgaire circuit combinatoire, ou tout autre mcanisme, sans mmoire. Mais d'autres units de traitement ont une certaine capacit de mmorisation, comme les circuits squentiels. Tout systme dont l'unit de traitement possde cette capacit de mmorisation, et fonctionne comme un circuit lctronqiue squentiel, est appel

www.siteduzero.com

Partie 2 : Architecture de base

50/378

un automate. Nos ordinateurs sont des automates spciaux, qui peuvent eux-mme tre dcoups en composants plus petits qui sont eux-mme des automates. Celui-ci contiendra donc des mmoires internes en plus de lunit de traitement, qui reprsenteront l'tat de lautomate (les informations qu'il a mmorises). Bien sr, cet tat peut tre mis jour, et on peut changer l'tat de notre automate pour modifier ces informations, les manipuler, etc. Notre unit de traitement pourra donc manipuler directement le contenu de nos mmoires. Notre automate passera donc d'tats en tats, via des suites d'tapes qui transformeront un tat en un autre : on modifiera les informations contenues dans notre automate tapes par tapes jusqu' arriver au rsultat voulu. Ces changements d'tat sont bien sur gouverns par l'unit de traitement.

Attention : ce schma est un schma de principe. Il existe des automates pour lesquels il n'y a pas de sparation nette entre mmoire et circuits de traitement. Il est possible de crer des circuits dans lesquels la mmorisation des informations est entremle avec les circuits chargs de traiter l'information. Toutefois, dans nos ordinateurs, les deux sont relativement bien spars, mme si ce n'est pas totalement le cas. Pour information, on peut trs bien crer des automates avec un peu n'importe quoi. Du genre, des dispositifs hydrauliques, ou lectriques, magntiques, voire air comprim. Pour citer un exemple, on peut citer le calculateur hydraulique MONIAC. Quant nos ordinateurs, ils sont fabriqus avec des dispositifs lectroniques, comme des portes logiques ou des montages base de transistors et de condensateurs. videment, il existe des automates numriques, et des automates analogiques, voire des automates hybrides mlangeant des circuits analogiques et des circuits numriques. Dans un automate numrique (un ordinateur par exemple), linformation place sur l'entre est code sous la forme d'une suite de symboles avant d'tre envoye l'unit de traitement ou en mmoire. Nos informations seront codes par des suites de symboles, des nombres cods dans une certaine base, et seront stockes ainsi en mmoire. Les suites de symboles manipules sont appeles des donnes. Dans nos ordinateurs, les symboles utiliss tant des zros et des uns, nos donnes sont donc de simples suites de bits. Reste que ces donnes seront manipules par notre automate, par son unit de traitement. Tout ce que peut faire la partie traitement d'un automate numrique, c'est modifier l'tat de l'automate, savoir modifier le contenu des mmoires de l'automate. Cela peut permettre de transformer une (ou plusieurs) donne en une (ou plusieurs) autre(s), ou de configurer l'automate pour qu'il fonctionne correctement. Ces transformations lmentaires qui modifient l'tat de l'automate sont appeles des instructions. Un automate numrique est donc une machine qui va simplement appliquer une suite d'instructions dans un ordre bien prcis sur les donnes. Cest cette suite d'instructions qui va dfinir le traitement fait par notre automate numrique, et donc ce quoi il peut servir.

Programme
Dans certains automates, la suite d'instructions effectue est toujours la mme. Une fois conus, ceux-ci ne peuvent faire que ce pourquoi ils ont t conus. Ils ne sont pas programmables. C'est notamment le cas pour les calculateurs analogiques : une fois qu'on a cbl un automate analogique, il est impossible de lui faire faire autre chose que ce pour quoi il a t conu sans modifier son cblage. A la rigueur, on peut le reconfigurer et faire varier certains paramtres via des interrupteurs ou des boutons, mais cela sarrte l. D'autres automates numriques ont le mme problme : la suite d'instruction qu'ils excutent est impossible changer sans modifier les circuits de l'automate lui-mme. Et cela pose un problme : chaque problme qu'on veut rsoudre en utilisant un automate, on doit recrer un nouvel automate. Autant dire que a peut devenir assez embtant !

www.siteduzero.com

Partie 2 : Architecture de base

51/378

Mais il existe une solution : crer des automates dont on peut remplacer la suite d'instructions qu'ils effectuent par une autre sans avoir modifier leur cblage. On peut donc faire ce que l'on veut de ces automates : ceux-ci sont rutilisables volont et il est possible de modifier leur fonction du jour au lendemain et leur faire faire un traitement diffrent. On dit qu'ils sont programmables. Ainsi, pour programmer notre ordinateur, il suffira de crer une suite d'instructions qui va faire ce que l'on souhaite. Et c'est bien plus rapide que de crer un automate complet de zro. Cette suite d'instruction sera alors appele le programme de l'automate. La solution utilise pour rendre nos automates programmables consiste stocker le programme dans une mmoire, qui sera modifiable loisir. C'est ainsi que notre ordinateur est rendu programmable : on peut parfaitement modifier le contenu de cette mmoire (ou la changer, au pire), et donc changer le programme excut par notre ordinateur sans trop de problmes. Mine de rien, cette ide d'automate stockant son programme en mmoire est ce qui a fait que linformatique est ce qu'elle est aujourdhui. C'est la dfinition mme d'ordinateur : automate programmable qui stocke son programme dans sa mmoire.

Les composants de base d'un ordinateur

Tous nos ordinateurs sont plus ou moins organiss sur un mme modle de base, une organisation commune. Notre ordinateur est ainsi dcoup en composants bien distincts, qui ont chacun une utilit particulire. Dans ce dcoupage en composant, on retrouve plus ou moins l'organisation qu'on a vue au-dessus, avec son entre, sa sortie, son unit de traitement, sa mmoire, etc. Notre ordinateur contient donc : des entres et des sorties, pour communiquer avec l'extrieur ; un truc qui va effectuer les instructions du programme : le processeur ; un machin qui va conserver nos donnes et le programme : la mmoire ; et enfin, de quoi faire communiquer le tout : le Bus.

Cela ressemble fortement l'organisation vue plus haut, avec son entre, sa sortie, son unit de traitement et sa mmoire. Rien d'tonnant cela, notre ordinateur est un automate comme un autre, et il n'est pas tonnant qu'il reprenne une organisation commune pas mal d'automates (mais pas tous : certains fusionnent la mmoire et l'unit de traitement dans un seul gros circuit, ce que ne font pas nos ordinateurs). Rien nempche notre ordinateur (ou tout autre automate d'ailleurs) d'utiliser plusieurs processeurs, plusieurs mmoires, plusieurs bus, plusieurs entres ou plusieurs sorties. Cet ensemble de composants, ainsi que la faon dont ils communiquent entre eux est la structure minimum que tout ordinateur possde, le minimum syndical. Tout ce qui n'appartient pas la liste du dessus est obligatoirement connect sur les ports d'entre-sortie et est appel priphrique. On peut donner comme exemple le clavier, la souris, l'cran, la carte son, etc.

Microcontroleurs
Parfois, on dcide de regrouper la mmoire, les bus, le CPU et les ports d'entre-sortie dans un seul botier, histoire de rassembler tout cela dans un seul composant lectronique nomm microcontrleur. Dans certains cas, qui sont plus la rgle que l'exception, certains priphriques sont carrment inclus dans le microcontrleur ! On peut ainsi trouver dans ces microcontrleurs, des compteurs, des gnrateurs de signaux, des convertisseurs numriques-analogiques... On trouve des microcontrleurs dans les disques durs, les baladeurs mp3, dans les automobiles, et tous les systmes embarqus en gnral. Nombreux sont les priphriques ou les composants internes un ordinateur qui contiennent des microcontrleurs. Maintenant qu'on connait un peu mieux l'organisation de base, voyons plus en dtail ces diffrents composants.

Mmoire
La mmoire est, je me rpte, le composant qui se chargera de stocker notre programme xecuter, ainsi que les donnes qu'il va manipuler. Son rle est donc de retenir que des donnes ou des instructions stockes sous la forme de suites de bits, afin qu'on

www.siteduzero.com

Partie 2 : Architecture de base

puisse les rcuprer et les traiter.

52/378

ROM et RWM
Pour simplifier grandement, on peut grossirement classer nos mmoire en deux types : les Read Only Memory, et les Read Write Memory. Pour les mmoires ROM (les Read Only Memory), on ne peut pas modifier leur contenu. C'est dire que l'on peut rcuprer une donne ou une instruction dans notre mmoire : on dit qu'on y accde en lecture. Mais on ne peut pas modifier les donnes qu'elles contiennent. On utilise de telles mmoires pour stocker des programmes ou pour stocker des donnes qui ne peuvent pas varier. Mais pour stocker des donnes censes changer au cours de lexcution de notre programme, ces mmoires sont inutilisables. Ces mmoires sont tout de mme trs utilises, comme vous le verrez au chapitre suivant. Par exemple, votre ordinateur contient une mmoire ROM spciale qu'on appelle le BIOS, qui permet de dmarrer votre ordinateur, le configurer l'allumage, et qui dmarre votre systme d'exploitation. Quand aux mmoire RWM (les Read Write Memory), on peut accder celle-ci en lecture, et donc rcuprer une donne stocke en mmoire, mais on peut aussi y accder en criture : on stocke une donne dans la mmoire, ou on modifie une donne existante. Ces mmoires RWM sont dj plus intressantes, et on peut les utiliser pour stocker des donnes. On va donc forcment trouver au moins une mmoire RWM dans notre ordinateur.

Adressage
Pour utiliser cette mmoire, le processeur va pouvoir rapatrier des donnes depuis celle-ci. Pour viter de semmler les pinceaux, et confondre une donne avec une autre, le processeur va devoir utiliser un moyen pour retrouver une donne dans notre mmoire. Il existe plusieurs solutions, mais une de ces solutions est utilise dans la grosse majorit des cas. Dans la majorit des cas, notre mmoire est dcoupe en plusieurs cases mmoires, des blocs de mmoire qui contiennent chacun un nombre fini et constant de bits. Chaque case mmoire se voit attribuer un nombre binaire unique, l'adresse, qui va permettre de la slectionner et de l'identifier celle-ci parmi toutes les autres. En fait, on peut comparer une adresse un numro de tlphone (ou une adresse d'appartement) : chacun de vos correspondants a un numro de tlphone et vous savez que pour appeler telle personne, vous devez composer tel numro. Ben les adresses mmoires, c'est pareil ! Exemple : on demande notre mmoire de slectionner la case mmoire d'adresse 1002 et on rcupre son contenu (ici, 17).

Il existe des mmoires qui ne fonctionnent pas sur ce principe, mais passons : ce sera pour la suite du tutoriel.

Bus de communication
Maintenant qu'on a une mmoire ainsi que nos entres-sorties, il va bien falloir que notre processeur puisse les utiliser. Pour cela, le processeur est reli la mmoire ainsi qu'aux entres-sorties par un ou plusieurs bus. Ce bus n'est rien d'autre qu'un ensemble de fils lectriques sur lesquels on envoie des zros ou des uns. Ce bus relie le processeur, la mmoire, les entres et les sorties ; et leur permet dchanger des donnes ou des instructions. Pour permettre au processeur (ou aux priphriques) de communiquer avec la mmoire, il y a trois prrequis que ce bus doit

www.siteduzero.com

Partie 2 : Architecture de base

respecter : pouvoir slectionner la case mmoire (ou l'entre-sortie) dont on a besoin, prciser la mmoire s'il s'agit d'une lecture ou d'une criture, et enfin pouvoir transfrer la donne.

53/378

Pour cela, on doit donc avoir trois bus spcialiss, bien distincts, qu'on nommera le bus de commande, le bus d'adresse, et le bus de donne. Ceux-ci seront relieront les diffrents composants comme indiqu dans le schma qui suit.

V ous l'avez surement dj devin grce leur nom, mais je vais quand mme expliquer quoi servent ces diffrents bus. Bus Utilit Le bus d'adresse permet au processeur de slectionner l'entre, la sortie ou la portion de mmoire avec qui il veut changer des donnes. Le bus de donne est un ensemble de fils par lequel s'changent les donnes (et parfois les instructions) entre le processeur et le reste de la machine. Ce bus de commande va permettre de grer l'intgralit des transferts entre la mmoire et le reste de l'ordinateur. Il peut transfrer au moins un bit prcisant si on veut lire ou crire dans la mmoire. Gnralement, on considre par convention que ce bit vaut : 1 si on veut faire une lecture, 0 si c'est pour une criture.

Bus d'adresse Bus de donne Bus de commande

Processeur
Ce processeur est aussi appel Central Processing Unit , abrvi en CPU. C'est un composant qui va prendre en entre une ou plusieurs donnes et xecuter des instructions. Ces instructions peuvent tre des additions, des multiplications, par exemple, mais qui peuvent aussi faire des choses un peu plus utiles. Un processeur ne peut qu'effectuer une suite d'instructions dans un ordre bien prcis. C'est cette proprit qui fait que notre ordinateur est un

www.siteduzero.com

Partie 2 : Architecture de base

54/378

automate particulier, programmable : on lui permet de faire des instructions indpendantes, et on peut organiser ces instructions dans l'ordre que l'on souhaite : en clair, crer un programme. Pour vous donner une ide de ce que peut tre une instruction, on va en citer quelques-unes.

Instructions arithmtiques
Les instructions les plus communes sont des instructions arithmtiques et logiques, qui font simplement des calculs sur des nombres. On peut citer par exemple : ET logique entre deux nombres (consiste effectuer un ET entre les bits de mme rang de deux nombres) ; OU logique entre deux nombres (consiste effectuer un OU entre les bits de mme rang de deux nombres) ; NON logique : inverse tous les bits d'un nombre ; XOR logique entre deux nombres (consiste effectuer un XOR entre les bits de mme rang de deux nombres) ; addition de deux nombres; multiplication ; division ; modulo ; soustraction ; ... Ces instructions sont des instructions dont le rsultat ne dpend que des donnes traiter. Elle sont gnralement prises en charge par un circuit combinatoire indpendant, qui s'occupe exclusivement du calcul de ces instructions : l'unit de calcul.

Registres
Pour pouvoir fonctionner, tout processeur va devoir stocker un certain nombre dinformations ncessaires son fonctionnement : il faut qu'il se souvienne quel instruction du programme il en est, qu'il connaisse la position en mmoire des donnes manipuler, qu'il manipule certaines donnes, etc. Pour cela, il contient des registres. Ces registres sont de petites mmoires ultrarapides fabriques avec des bascules. Ces registres peuvent servir plein de choses : stocker des donnes afin de les manipuler plus facilement, stocker l'adresse de la prochaine instruction, stocker l'adresse d'une donne aller chercher en mmoire, etc. Bref, suivant le processeur, ces registres peuvent servir tout et n'importe quoi.

Instructions d'accs mmoire

Pour faire ces calculs, et excuter nos instructions arithmtiques et logiques, notre processeur doit aller chercher les donnes manipuler dans la mmoire RAM ou dans ses registres. Aprs tout, les donnes manipules par nos instructions ne sortent pas de nulle part. Certaines d'entre elles peuvent tre stockes dans les registres du processeur, mais d'autres sont stockes dans la mmoire principale : il faut bien y aller les chercher. Pour cela, notre processeur va devoir changer des donnes entre les registres et la mmoire, copier une donne d'un endroit de la mmoire un autre, copier le contenu d'un registre dans un autre, modifier directement le contenu de la mmoire, effectuer des lectures ou criture en mmoire principale, etc. Comme vous l'avez surement devin, les accs mmoires ne sont pas pris en charge par les units de calcul. Pour grer ces communications avec la mmoire, le processeur devra tre reli la mmoire et devra dcider quoi lui envoyer comme ordre sur les diffrents bus (bus de commande, de donne, d'adresse). Il pourra ainsi lui envoyer des ordres du style : "Je veux rcuprer le contenu de l'adresse X", ou "Enregistre moi la donne que je t'envoie l'adresse Y". Ces ordres seront transmis via le bus. L'intrieur de notre processeur ressemble donc ceci, pour le moment :

www.siteduzero.com

Partie 2 : Architecture de base

55/378

Program Counter
Il est vident que pour excuter une suite d'instructions dans le bon ordre, notre ordinateur doit savoir quelle est la prochaine instruction excuter. Il faut donc que notre processeur se souvienne de cette information quelque part : notre processeur doit donc contenir une mmoire qui stocke cette information. C'est le rle du registre d'adresse d'instruction, aussi appel Program Counter. Ce registre stocke l'adresse de la prochaine instruction excuter. Cette adresse permet de localiser l'instruction suivante en mmoire. Cette adresse ne sort pas de nulle part : on peut la dduire de l'adresse de l'instruction en cours dexcution par divers moyens plus ou moins simples qu'on verra dans la suite de ce tutoriel. Ce calcul peut tre fait assez simplement. Gnralement, on profite du fait que ces instructions sont excutes dans un ordre bien prcis, les unes aprs les autres. Sur la grosse majorit des ordinateur, celles-ci sont places les unes la suite des autres dans l'ordre o elles doivent tre excutes. L'ordre en question est dcid par le programmeur. Un programme informatique n'est donc qu'une vulgaire suite d'instructions stocke quelque part dans la mmoire de notre ordinateur. Adresse 0 1 2 3 4 ... 5464 Instruction Charger le contenu de l'adresse 0F05 Charger le contenu de l'adresse 0555 Additionner ces deux nombres Charger le contenu de l'adresse 0555 Faire en XOR avec le rsultat antrieur ... Instruction d'arrt

En faisant ainsi, on peut calculer facilement l'adresse de la prochaine instruction en ajoutant la longueur de l'instruction juste charge (le nombre de case mmoire qu'elle occupe) au contenu du registre d'adresse d'instruction. Dans ce cas, l'adresse de la prochaine instruction est calcule par un petit circuit combinatoire coupl notre registre d'adresse d'instruction, qu'on appelle le compteur ordinal. L'intrieur de notre processeur ressemble donc plus ce qui est indiqu dans le schma du dessous.

www.siteduzero.com

Partie 2 : Architecture de base

56/378

Mais certains processeurs n'utilisent pas cette mthode. Mais il s'agit de processeur particulirement rares : ce sont les processeurs dataflow. Sur de tels processeurs, chaque instruction va devoir prciser quelle est la prochaine instruction. Pour ce faire, une partie de la suite de bit reprsentant notre instruction xecuter va stocker cette adresse. Dans ce cas, ces processeurs utilisent toujours un registre pour stocker cette adresse, mais ne possdent pas de compteur ordinal, et n'ont pas besoin de calculer une adresse qui leur est fournie sur un plateau.

Prise de dcision
Notre processeur peut donc xecuter des instructions les unes la suite des autres grce notre registre d'adresse d'instruction (le Program Counter). C'est bien, mais on ne pas bien loin avec ce genre de choses. Il serait videmment mieux si notre processeur pouvait faire des choses plus volues et s'il pouvait plus ou moins s'adapter aux circonstances au lieu de ragir machinalement. Par exemple, on peut souhaiter que celui-ci n'excute une suite d'instructions que si une certaine condition est remplie et ne lexcute pas sinon. Ou faire mieux : on peut demander notre ordinateur de rpter une suite d'instructions tant qu'une condition bien dfinie est respecte. Pour ce faire, on a cre des instructions un peu spciales, qui permettent de "sauter" directement une instruction dans notre programme, et poursuivre l'excution partir de cette instruction. Cela permet au programme de passer directement une instruction situe plus loin dans le droulement normal du programme, voir de revenir une instruction antrieure. Ces instructions sont ce qu'on appelle des branchements. Pour ce faire, elles modifient le contenu du registre d'adresse d'instruction, et y place l'adresse de l'instruction laquelle on veut sauter. Ces instructions sont appeles des branchements. Elles sont trs utiles pour crer nos programmes informatiques, et il serait vraiment difficle, voire impossible de vous passer d'elles. Tout programmeur utilise des branchements quand il programme : il ne s'en rend pas compte, mais ces branchements sont souvent cachs derrire des fonctionnalits basiques de nos langages de programmation usuels (les if, tests, boucles, et fonctions sont fabriques avec des branchements). Comme vous l'avez surement devin, les branchements ne sont pas prises en charge par les units de calcul.

Squenceur
Quoiqu'il en soit, toutes nos instructions sont stockes en mmoire sous la forme de suites de bits. A telle instruction correspondra telle suite de bit. Notre processeur devra donc dcider quoi faire de ces suites de bits, et les interpreter, en dduire quoi faire. Par exemple, est-ce que la suite de bit que je viens de lire me demande de charger une donne depuis la mmoire, estce qu'elle me demande de faire une instruction arithmtique, etc. Une fois cela fait, il faut ensuite aller configurer la mmoire pour grer les instructions d'accs mmoire (lire la bonne adresse, prciser le sens de transferts, etc), ou commander l'unit de calcul afin qu'elle fasse une addition et pas une multiplication, ou mettre jour le registre d'adresse d'instruction si c'est un branchement, etc. Pour ce faire, notre processeur va contenir un circuit squentiel spcial, qui dduit quoi faire de la suite d'instruction charge, et qui commandera la mmoire, le Program Counter, ou l'unit de calcul en fonction. Ce circuit spcialis s'appelle le squenceur.

www.siteduzero.com

Partie 2 : Architecture de base

57/378

La gestion de la mmoire
On a vu que notre programme tait stock dans la mmoire de notre ordinateur. Les instructions du programme excut par le processeur sont donc stockes comme toutes les autres donnes : sous la forme de suites de bits dans notre mmoire, tout comme les donnes qu'il va manipuler. Dans ces conditions, difficile de faire la diffrence entre donne et instruction. Mais rassurez-vous : le processeur intgre souvent des fonctionnalits qui empchent de confondre une donne avec une instruction quand il va chercher une information en mmoire. Ces fonctionnalits ne sont pas totalement fiables, et il arrive assez rarement que le processeur puisse confondre une instruction ou une donne, mais cela est rare. Cela peut mme tre un effet recherch : par exemple, on peut crer des programmes qui modifient leurs propres instructions : cela s'appelle du self modifying code , ce qui se traduit par code automodifiant en franais. Ce genre de choses servait autrefois crire certains programmes sur des ordinateurs rudimentaires (pour grer des tableaux et autres fonctionnalits de base utilises par les programmeurs), pouvait aussi permettre de rendre nos programmes plus rapides, servait compresser un programme, ou pire : permettait de cacher un programme et le rendre indtectable dans la mmoire (les virus informatiques utilisent beaucoup de genre de procds). Mais passons !

Deux mmoires pour le prix d'une

La plus importante de ces astuces vitant la confusion entre donnes et instructions est trs simple : les instructions et les donnes sont stockes dans deux portions de mmoire bien spares. Sur de nombreux ordinateurs, la mmoire est spare en deux gros blocs de mmoires bien spcialiss : un bloc de mmoire qui stocke le programme, nomme la mmoire programme ; et un bloc de mmoire qui stocke le reste nomme la mmoire travail. Ces blocs de mmoire vont donc stocker des contenus diffrents : Portion de la mmoire

Mmoire programme

Mmoire de travail

Contenu du bloc

le programme informatique excuter et parfois les constantes : ce sont des donnes qui peuvent tre lues mais ne sont jamais accdes en criture durant l'excution du programme. Elle ne sont donc jamais modifies et gardent la mme valeur quoi qu'il se passe lors de l'excution du programme.

les variables du programme excuter, qui sont des donnes que le programme va manipuler.

Il faut toutefois prciser que ce dcoupage en mmoire programme et mmoire de travail n'est pas une obligation. En effet, certains ordinateurs s'en passent compltement : je pense notamment aux architectures dataflow, une classe dordinateur assez spciale, qui ne sera pas traite dans ce tutoriel, mais qui est nanmoins abordes dans un article assez compliqu sur ce site. Mais remettons cela plus tard, pour quand vous aurez un meilleur niveau. Le processeur ne traitera pas de la mme faon les instructions en mmoire programme et les donnes prsentes en mmoire de travail, afin de ne pas faire de confusions. Nos instructions sont en effet interprtes par le squenceur, tandis que nos donnes sont manipules par l'unit de calcul. Et tout cela, c'est grce l'existence du Program Counter, le fameux registre d'adresse d'instruction vu prcdemment. En regroupant nos instructions dans un seul bloc de mmoire, et en plaant nos instructions les unes la suite des autres, on est sur que le registre d'adresse d'instruction passera d'une instruction l'autre en restant dans un bloc de mmoire ne contenant que des instructions. Sauf s'il dborde de ce bloc, ou qu'un branchement renvoie notre processeur n'importe o dans la mmoire, mais passons. Quoiqu'il en soit, ce dcoupage entre mmoire programme et mmoire de travail est quelque chose d'assez abstrait qui peut tre mis en pratique de diffrentes manires. Sur certains ordinateurs, on utilise deux mmoires spares : une pour le programme, et une pour les donnes. Sur d'autres, ces deux mmoires seront fusionnes en une seule mmoire, dont une portion stockera notre programme, et l'autre servira de mmoire de travail. Il faut bien faire la diffrence entre le dcoupage de notre mmoire en mmoires de programmes et de travail, purement "conceptuelles" ; et les diffrentes mmoires qu'on trouvera dans nos ordinateurs. Rassurez-vous, vous allez comprendre en lisant la suite. Dans ce qui suit, on va voir comment des deux mmoires sont organises dans nos ordinateurs.

Sparation matrielle des mmoires

Sur les ordinateurs trs simples, La mmoire programme et la mmoire travail sont souvent places dans deux mmoires spares. Il y a deux composants lectroniques, chacun dans un botier spar : un pour la mmoire programme et un autre pour la mmoire

www.siteduzero.com

Partie 2 : Architecture de base

travail.

58/378

Avec cette sparation dans deux mmoires spares, la mmoire programme est gnralement une mmoire de type ROM, c'est dire accessible uniquement en lecture : on peut rcuprer les informations conserves dans la mmoire (on dit qu'on effectue une lecture), mais on ne peut pas les modifier. Par contre, la mmoire travail est une mmoire RWM : on peut lire les informations conserves, mais on peut aussi modifier les donnes qu'elle contient (criture). On peut ainsi effectuer de nombreuses manipulations sur le contenu de cette mmoire : supprimer des donnes, en rajouter, les remplacer, les modifier, etc.

Architectures Harvard et Von Neumann

On a vu que le processeur est reli la mmoire par un ensemble de fils qui connectent ces deux composants, le bus. Dans le cas o la mmoire programme et la mmoire travail sont spares dans deux composants lectroniques matriellement diffrents, il y a deux faon de relier ces deux mmoires au processeur par un bus : un seul bus pour les deux mmoires. un bus par mmoire. Le premier cas s'appelle l'architecture Von Neumann.

Le second s'appelle l'architecture Harvard.

www.siteduzero.com

Partie 2 : Architecture de base

59/378

Chacune possde quelques avantages et inconvnients: Architecture Von neumann Architecture Harvard Permet de charger une instruction et une donne simultanment : on charge la donne sur le bus qui relie la mmoire de travail au processeur, et l'instruction sur le bus qui relie processeur et mmoire programme. Les deux bus tant spars, on peut le faire simultanment. On se retrouve donc avec un gain de vitesse

Avantages

Accs la mmoire facile : un seul bus grer ; Un seul bus cbler : simplicit de conception.

Inconvnients

Ne peut pas charger une donne simultanment avec une instruction : on doit charger la donne, puis l'instruction, vu que tout passe par un seul bus. Ce genre d'architecture est donc plus lente.

Deux bus cbler et grer ; Accs la mmoire plus compliqu grer.

Architecture modifie
Sur d'autres, on a besoin de modifier certains paramtres du programmes pour qu'il s'adapte certaines circonstances. Pour ce faire, il faut donc modifier certaines parties de la mmoire programme. On ne peut donc stocker ces paramtres en ROM, et on prfre plutt les stocker dans une RWM : la mmoire programme est donc compose d'une ROM et d'une partie de la RWM.

www.siteduzero.com

Partie 2 : Architecture de base

60/378

Avec cette organisation, une partie ou la totalit du programme est stock dans une mmoire cense stocker des donnes. Rien de choquant cela : programme et donnes sont tous les deux stocks sous la forme de suites de bits dans la mmoire. Rien n'empche de copier l'intgralit du programme de la mmoire ROM vers la mmoire RWM, mais ce cas est assez rare.

Mettre les programmes sur un priphrique

On peut mme aller plus loin : on peut utiliser une mmoire ROM, contenant un programme de base, et charger directement nos programmes dans la mmoire RWM, depuis un priphrique connect sur une entre-sortie : un disque dur, par exemple. Dans ce cas, la mmoire programme n'est pas intgralement stocke dans une ROM : le programme est en effet plac sur un priphrique et charg en mmoire RWM pour tre excut. Mais il y a toujours dans tous les ordinateurs, une petite mmoire ROM. Cette ROM contient un petit programme qui va charger le programme stock sur le priphrique dans la mmoire de travail. On aura donc le systme d'exploitation et nos programmes qui seront donc copis en mmoire RWM : une partie de la mmoire RWM deviendra la mmoire programme qui stockera vos applications et le systme d'exploitation et une autre restera de la mmoire travail. L'avantage, c'est qu'on peut modifier le contenu d'un priphrique assez facilement, tandis que ce n'est pas vraiment facile de modifier le contenu d'une ROM (et encore, quand c'est possible). On peut ainsi facilement installer ou supprimer des programmes sur notre priphrique, en rajouter, en modifier, les mettre jour sans que cela ne pose problme. C'est cette solution qui est utilise dans nos PC actuels, et la petite mmoire ROM en question s'appelle le BIOS.

La pile
Reste que notre mmoire de travail peut-tre organise de diffrentes faons, et que celle-ci est elle-mme subdivise en plusieurs morceaux de taille et d'utilit diffrentes. Suivant le programme que vous utilisez, ou votre systme d'exploitation, la mmoire est gnralement organise plus ou moins diffremment : votre systme d'exploitation ou le programme excut peut ainsi rserver certains morceau de programme pour telle ou telle fonctionnalit, ou pour stocker des donnes particulires. Mais certaines particularits reviennent souvent.

Pile, Tas et Mmoire Statique

Gnralement, la mmoire d'un ordinateur est segmente en quatre parties. On retrouve la mmoire programme, contenant le programme. Par contre, notre mmoire de travail est dcoupe en trois portions, qui ont des utilits diffrentes : la mmoire de travail statique ; le tas ; et la pile.

www.siteduzero.com

Partie 2 : Architecture de base

61/378

La mmoire de travail statique est une partie de la mmoire de travail dans laquelle on stocke des donnes dfinitivement. En clair, on ne peut pas supprimer l'espace mmoire utilis par une donne dont on n'a plus besoin pour l'utiliser pour stocker une autre donne. On peut donc lire ou modifier la valeur d'une donne, mais pas la supprimer. Et c'est pareil pour la mmoire programme : on ne peut pas supprimer tout un morceau de programme en cours dexcution (sauf dans le cas d'ventuels cas pathologiques que je ne connais pas). A l'inverse, on peut utiliser le reste de la mmoire pour stocker temporairement des donnes et les effacer lorsqu'elles deviennent inutiles. Cela permet de limiter l'utilisation de la mmoire. Cette partie de la mmoire utilisable au besoin peut tre utilise de deux faon : Soit avec une pile Soit avec un tas. La diffrence principale entre le tas et la pile est la faon dont sont organises les donnes dedans. Une autre diffrence est leur utilisation : le tas est intgralement gr par le logiciel (par le programme ne cours dexcution et ventuellement le systme d'exploitation), tandis que la pile est en partie, voire totalement, gre par le matriel de notre ordinateur. Dans ce qui va suivre, on va parler de la pile. Pourquoi ? Et bien parce que celle-ci est en partie gre par notre matriel, et que certains processeurs l'utilisent abondamment. Il existe mme des processeurs qui utilisent systmatiquement cette pile pour stocker les donnes que notre processeur doit manipuler. Ces processeurs sont appels des machines pile, ou stack machines.

La pile
Comme je l'ai dit plus haut, la pile est une partie de la mmoire de travail. Mais cette portion de la RAM a une particularit : on stocke les donnes l'intrieur d'une certaine faon. Les donnes sont regroupes dans la pile dans ce qu'on appelle des stack frame ou cadres de pile. Ces stack frames regroupent plusieurs cases mmoires contigus (places les unes la suite des autres). On peut voir ces stack frames comme des espces de blocs de mmoire.

www.siteduzero.com

Partie 2 : Architecture de base

62/378

Sur les stack machines, ces stack frames stockent gnralement un nombre entier, des adresses, des caractres, ou un nombre flottant ; mais ne contiennent gure plus. Mais sur d'autres processeurs un peu plus volus, on utilise la pile pour stocker autre chose, et il est alors ncessaire d'avoir des stack frame pouvant stocker des donnes plus volues, voire stocker plusieurs donnes htrognes dans une seule stack frame. Ce genre de choses est ncessaire pour implmenter certaines fonctionnalits de certains langages de haut niveau.

Last Input First Output

Mais ce qui diffrencie une pile d'une simple collection de morceaux de mmoire, c'est la faon dont les stack frames sont gres. Comme on peut le voir facilement, les stack frame sont cres une par unes, ce qui fait qu'elles sont places les unes la suite des autres dans la mmoire : on cre une stack frame immdiatement aprs la prcdente. C'est une premire contrainte : on ne peut pas crer de stack frames n'importe o dans la mmoire. On peut comparer l'organisation des stack frames dans la pile une pile d'assiette : on peut parfaitement rajouter une assiette au sommet de la pile d'assiette, ou enlever celle qui est au sommet, mais on ne peut pas toucher aux autres assiettes. Sur la pile de notre ordinateur, c'est la mme chose : on ne peut accder qu' la donne situe au sommet de la pile. Comme pour une pile d'assiette, on peut rajouter ou enlever une stack frame au sommet de la pile, mais pas toucher aux stack frame en dessous, ni les manipuler. Le nombre de manipulations possibles sur cette pile se rsume donc trois manipulations de base qu'on peut combiner pour crer des manipulations plus complexes. On peut ainsi : dtruire la stack frame au sommet de la pile, et supprimer tout son contenu de la mmoire : on dpile. crer une stack frame immdiatement aprs la dernire stack frame existante : on empile. utiliser les donnes stockes dans la stack frame au sommet de la pile.

www.siteduzero.com

Partie 2 : Architecture de base

63/378

Source de l'image : Wikipdia Si vous regardez bien, vous remarquerez que la donne au sommet de la pile est la dernire donne avoir t ajoute (empile) sur la pile. Ce sera aussi la prochaine donne tre dpile (si on n'empile pas de donnes au dessus). Ainsi, on sait que dans cette pile, les donnes sont dpiles dans l'ordre inverse d'empilement. Ainsi, la donne au sommet de la pile est celle qui a t ajoute le plus rcemment. Au fait, la pile peut contenir un nombre maximal de stack frames, ce qui peut poser certains problmes. Si l'on souhaite utiliser plus de stack frames que possible, il se produit un stack overflow, appel en franais dbordement de pile. En clair, l'ordinateur plante !

Machines pile et successeurs

De ce qu'on vient de voir, on peut grosso-modo classer nos ordinateurs en deux grandes catgories : les machines pile, et les machines accs alatoire.

Machines pile
Les machines pile, aussi appeles stack machines en anglais, utilisent la pile pour stocker les donnes manipules par leurs instructions. Sur ces machines, les cadres de pile ne contenir que des donnes simples, comme des nombres, ou des caractres. Leur taille est donc facile dterminer : elle est de la taille de la donne manipuler. Exemple avec des entiers de 4 octets.

Ces machines ont besoin d'un registre pour fonctionner : il faut bien stocker l'adresse du sommet de la pile. Je vous prsente donc le Stack Pointer, qui n'est autre que ce fameux registre qui stocke l'adresse du sommet de la pile. Ce registre seul suffit : nos cadres de pile ayant une taille bien prcise, on peut se passer de registre pour stocker leur taille ou leur adresse de dbut/fin en se dbrouillant bien.

www.siteduzero.com

Partie 2 : Architecture de base

64/378

Sur certaines machines pile trs simples, la pile n'est pas tout fait stocke dans une portion de la mmoire : elle est stocke directement dans le processeur. Le processeur contient ainsi un grand nombre de registres, qui seront utiliss comme une pile. Ces registres tant plus rapides que la mmoire principale de l'ordinateur, les oprations manipulant uniquement la pile et ne devant pas manipuler la mmoire seront donc beaucoup plus rapides (les autres instructions tant aussi acclres, mais moins).

Push Et Pop
Bien videmment, les donnes traiter ne s'empilent pas toutes seules au sommet de la pile. Pour empiler une donne au sommet de la pile, notre processeur fourni une instruction spcialement ddie. Cette instruction s'appelle souvent Push. Elle permet de copier une donne vers le sommet de la pile. Cette donne peut tre aussi bien dans la mmoire statique que dans le tas, peu importe. Cette instruction va prendre l'adresse de la donne empiler, et va la stocker sur la pile. Bien videmment, le contenu du Stack Pointer doit tre mis jour : on doit additionner (ou soustraire, si on fait partir la pile de la fin de la mmoire) la taille de la donne qu'on vient d'empiler.

Bien videmment, on peut aussi ranger la donne lace au sommet de la pile dans la mmoire, une certaine adresse. Dans ce cas, on utilise l'instruction Pop, qui dpile la donne au sommet de la pile et la stocke l'adresse indique dans l'instruction. Encore une fois, le Stack Pointer est mis jour lors de cette opration, en soustrayant (ou additionnant si on fait partir la pile de la fin de la mmoire) la taille de la donne qu'on vient d'enlever de la pile.

www.siteduzero.com

Partie 2 : Architecture de base

65/378

Instructions de traitement de donnes

Sur une machine pile, les seules donnes manipulables par une instruction sont celles qui sont places au sommet de la pile. Pour excuter une instruction, il faut donc empiler les oprandes une par une, et excuter l'instruction une fois que les oprandes sont empiles. Le rsultat de l'instruction sera sauvegard au sommet de la pile. Chose importante : l'instruction dpile automatiquement les oprandes qu'elle utilise. Elle est un peu oblige, sans quoi la gestion de la pile serait horriblement complique, et de nombreuses donnes s'accumuleraient dans la pile durant un bon moment, faute de pouvoir tre dpiles rapidement (vu qu'on empile au-dessus). Ce qui signifie qu'on ne peut pas rutiliser plusieurs fois de suite une donne place sur la pile : on doit recharger cette donne chaque fois. Ceci dit, certaines instructions ont ts inventes pour limiter la casse. On peut notamment citer l'instruction dup, qui copie le sommet de la pile en deux exemplaires.

Pour faciliter la vie des programmeurs, le processeur peut aussi fournir d'autres instructions qui peuvent permettre de manipuler la pile ou de modifier son organisation. On peut par exemple citer l'instruction swap, qui change deux donnes dans la pile.

www.siteduzero.com

Partie 2 : Architecture de base

66/378

Avantages et dsavantages
Avec une telle architecture, les programmes utilisent peu de mmoire. Les instructions sont trs petites : on n'a pas besoin d'utiliser de bits pour indiquer la localisation des donnes dans la mmoire, sauf pour Pop et Push. Vu que les programmes cres pour les machines pile sont souvent trs petits, on dit que la code density (la densit du code) est bonne. Les machines pile furent les premires tre inventes et utilises : dans les dbuts de linformatique, la mmoire tait rare et chre, et l'conomiser tait important. Ces machines pile permettaient d'conomiser de la mmoire facilement, et taient donc bien vues. Ces machines n'ont pas besoin d'utiliser beaucoup de registres pour stocker leur tat : un Stack Pointer et un Program Counter suffisent. A peine deux registres (avec ventuellement d'autres registres supplmentaires pour faciliter la conception du processeur). Par contre, une bonne partie des instructions de notre programmes seront des instructions Pop et Push qui ne servent qu' dplacer des donnes dans la mmoire de notre ordinateur. Une bonne partie des instructions ne sert donc qu' manipuler la mmoire, et pas faire des calculs. Sans compter que notre programme comprendra beaucoup d'instructions compar aux autres types de processeurs.

Machines accs alatoire

Ah ben tient, vu qu'on parle de ces autres types de processeurs, voyons ce qu'ils peuvent bien tre ! Dj, pourquoi avoir invent autre chose que des machines pile ? Et bien tout simplement pour supprimer les dfauts vus plus haut : l'impossibilit de rutiliser une donne place sur la pile, et beaucoup de copies ou recopies de donnes inutiles en mmoire. Pour viter cela, les concepteurs de processeurs ont invent des processeurs plus labors, qu'on appelle des machines accs alatoire. Sur ces ordinateurs, les donnes qu'une instruction de calcul (une instruction ne faisant pas que lire, crire, ou dplacer des donnes dans la mmoire) doit manipuler ne sont pas implicitement place au sommet d'une pile. Avec les machines pile, on sait o sont places ces donnes, implicitement : le Stack Pointer se souvient du sommet de la pile, et on sait alors o sont ces donnes. Ce n'est plus le cas sur les machines accs alatoire : on doit prciser o sont les instructions manipuler dans la mmoire. Une instruction peut ainsi fournir ce qu'on appelle une rfrence, qui va permettre de localiser la donne manipuler dans la mmoire. Cette rfrence pourra ainsi prciser plus ou moins explicitement dans quel registre, quelle adresse mmoire, quel endroit sur le disque dur, etc ; se situe la donne manipuler. Ces rfrences sont souvent stockes directement dans les instructions qui les utilisent, mais on verra cela en temps voulu dans le chapitre sur le langage machine et l'assembleur. Cela permet d'viter d'avoir copier des donnes dans une pile, les empiler, et les dplacer avant de les manipuler. Le nombre d'accs la mmoire est plus faible compar une machine pile. Et cela a son importance : il faut savoir qu'il est difficile de crer des mmoires rapides. Et cela devient de plus en plus problmatique : de nos jours, le processeur est beaucoup plus rapide que la mmoire. Il n'est donc pas rare que le processeur doive attendre des donnes en provenance de la mmoire : c'est ce qu'on appelle le "Von Neumann Bottleneck". Diverses techniques ont ts inventes pour limiter la casse, et on verra celles-ci dans la suite de ce tutoriel. Quoiqu'il en soit, viter daccder la mmoire est ncessaire si on veut que nos ordinateurs deviennent de plus en plus rapides. C'est pour cela que nos ordinateurs actuels sont des machines accs alatoire : pour limiter les accs la mmoire principale.

www.siteduzero.com

Partie 2 : Architecture de base

67/378

On peut aussi signaler que quelques anciennes machines et prototypes de recherche ne sont ni des machines pile, ni des machines accs alatoire. Elles fonctionnent autrement, avec des mmoires spciales : des content adressables memory. Mais passons : ces architectures sont un peu compliques, alors autant les passer sur le tapis pour le moment.

Machines registres
Certaines machines accs alatoire assez anciennes ne faisaient que manipuler la mmoire RAM. Les fameuses rfrences mentionnes plus haut taient donc des adresses mmoires, qui permettaient de prciser la localisation de la donne manipuler dans la mmoire principale (la ROM ou la RWM). Pour diminuer encore plus les accs cette mmoire, les concepteurs d'ordinateurs ont invents les machines registres. Ces machines peuvent stocker des donnes dans des registres intgrs dans le processeur, au lieu de devoir travailler en mmoire. Pour simplifier, ces registres stockent des donnes comme la pile le faisait sur les machines pile. en quelque sorte, ces registres vont remplacer la pile, mais d'une manire un peu plus souple : on peut accder chacun de ces registres individuellement, alors qu'on ne pouvait quaccder une seule donne avec la pile (celle qui tait au sommet de la pile). Reste savoir comment charger nos donnes manipuler dans ces registres. Aprs tout, pour la pile, on disposait des instructions Push et Pop, qui permettaient d'changer des donnes entre la pile et la mmoire statique. Sur certains processeurs, on utilise une instruction tout faire : le mov. Sur d'autres, on utilise des instructions spares suivant le sens de transfert et la localisation des donnes (dans un registre ou dans la mmoire). Par exemple, on peut avoir des instructions diffrentes selon qu'on veuille copier une donne prsente en mmoire dans un registre, copier le contenu d'un registre dans un autre, copier le contenu d'un registre dans la mmoire RAM, etc. Certains processeurs peuvent aussi manipuler des donnes supplmentaires en RAM, en plus des donnes prsentes dans ces registres. Les premires de ces machines registres n'utilisaient qu'un seul registre, qu'on appelait l'accumulateur. Certaines instructions taient alors conues pour manipuler le contenu de cet accumulateur : par exemple, le processeur pouvait avoir une instruction pour additionner une donne prsente en mmoire son contenu. Dans de telles conditions, pas besoin de rfrence pour identifier le registre : celui servait en quelque sorte remplacer le sommet de la pile, dont on connaissait l'adresse avec le Stack Pointer. Au fil des annes, les processeurs finirent par intgrer des registres spcialiss en plus de l'accumulateur : des registres d'index furent ajouts afin de faciliter la manipulation des adresses mmoires. Ces registres d'index taient utiliss pour effectuer des manipulations arithmtiques sur des adresses. Sans eux, accder des donnes places des adresses mmoires conscutives ncessitait souvent d'utiliser du self-modifying code : le programme devait tre conu pour se modifier lui-mme en partie, ce qui n'tait pas forcment idal pour le programmeur. Avec le temps, on a remarqu que ces registres faisaient un peu la mme chose qu'un accumulateur, part que ces registres d'index taient spcialiss dans les adresses mmoires. Hors, ces adresses mmoires ne sont que des nombres, et tout ce passait comme si l'on avait deux accumulateurs, dont un tait artificiellement brid pour ne servir qu' calculer des adresses. Avec le temps, l'ide d'utiliser non pas un seul registre accumulateur accoupl un registre d'index, mais plusieurs accumulateur utilisables au besoin fit son chemin. Nos processeurs finirent par utiliser plusieurs registres pour stocker des donnes, en plus dutiliser des registres pour stocker des adresses ou des instructions si besoin est. Au lieu d'utiliser des registres spcialiss pour grer la pile, calculer des adresses, etc; les successeurs des processeurs accumulateur finirent par utiliser plusieurs registres, utilisables au besoin et pouvant stocker toute forme d'information (donnes, adresses, etc) : ces registres furent appels des registres gnraux, par opposition aux registres spcialiss d'avant. Il a alors fallu trouver un moyen didentifier le registre stockant la donne manipuler. Pour ce faire, nos instructions vont ainsi devoir utiliser des rfrences spciales, qui permettront d'identifier un registre parmi tous les autres.

Avantages et inconvnients
L'utilisation de registres est plus souple que l'utilisation d'une pile. Par exemple, une fois qu'une donne est charge dans un registre, on peut la rutiliser autant de fois qu'on veut tant qu'on ne l'a pas efface. Avec une pile, cette donne aurait automatiquement efface, dpile, aprs utilisation : on aurait du la recharger plusieurs fois de suite. De manire gnrale, le nombre total d'accs la mmoire diminue fortement compar aux machines pile. Et on retrouve les mmes avantages pour les machines accs alatoires n'ayant pas de registres, mme si c'est dans une moindre mesure. Il faut dire que nos registres sont souvent des mmoires trs rapides, bien plus rapides que la mmoire principale. Utiliser des registres est donc une bonne manire de gagner en performances. C'est pour ces raisons que nos ordinateurs actuels sont souvent des machines accs alatoires utilisant des registres. Le seul problme, c'est qu'il faut bien faire de la place pour stocker les rfrences. Comme je l'ai dit, ces rfrences sont places dans les instructions : elles doivent prciser o sont stockes les donnes manipuler. Et cela prend de la place : des bits sont utiliss pour ces rfrences. La code density est donc moins bonne. De nos jours, cela ne pose pas vraiment de problmes : la taille des programmes n'est pas vraiment un sujet de proccupation majeur, et on peut s'en accommoder facilement.

Les hybrides
De nos jours, on pourrait croire que les machines accs alatoire l'ont emport. Mais la ralit est plus complexe que : nos ordinateurs actuels sont certes des machines accs alatoire, mais ils possdent de quoi grer une pile. Le seul truc, c'est que cette pile n'est pas une pile simple comme celle qui est utilise sur une machine pile : la pile de nos ordinateurs utilise des

www.siteduzero.com

Partie 2 : Architecture de base

68/378

cadres de pile de taille variable. On peut ainsi mettre ce qu'on veut dans ces cadres de pile, et y mlanger des tas de donnes htrognes. Bon, c'est bien beau, mais ces cadres de pile de taille variables, on les dlimite comment ?

Pour cela, on a besoin de sauvegarder deux choses : l'adresse laquelle commence notre Stack Frame en mmoire, et de quoi connaitre l'adresse de fin. Certains processeurs possdent des registres spcialiss qui sont spcialement ddis au stockage de ces deux adresses (ou de l'adresse de dbut et de la longueur de la Stack Frame). Si ce n'est pas le cas, on est oblig de stocker ces informations dans deux registres normaux, et se dbrouiller avec les registres restants. Pour ce faire, on doit donc rajouter un registre en plus du Stack Pointer, afin de pouvoir grer de tes cadres de pile. Ce registre s'appelle le Frame Pointer, et sert souvent dire quelle adresse commence (ou termine, si on fait grandir notre pile de la fin de la mmoire) la Stack Frame qui est au sommet de la pile. La cration d'une Stack Frame se base sur des manipulations de ces deux registres: le Stack Pointer, et le Frame Pointer.

D'autres processeurs arrivent se passer de Stack Pointer. Ceux-ci n'utilisent pas de registres pour stocker l'adresse de fin de la pile, mais prfrent calculer cette adresse partir de l'adresse de base de la Stack Frame en cours, et de sa longueur. Cette longueur tant souvent stocke dans un registre, bien videmment. Tout dpend du processeur ou du programme. Certains prfreront stocker l'adresse de fin de la Stack Frame, et d'autres la calculer partir de l'adresse de base et de la taille de la Stack Frame. Pour info, le calcul est une simple addition du contenu des deux registres : l'adresse de fin de la Stack Frame est gale : adresse de dbut + nombre de cases mmoires utilises pour stocker la Stack Frame. Pour localiser une donne dans cette Stack Frame, il suffit de la reprer en utilisant un dcalage par rapport au dbut de celle-ci. Ainsi, on pourra dire : la donne que je veux manipuler est place 8 adresses aprs le dbut de la Stack Frame. On peut donc calculer l'adresse de la donne manipuler en additionnant ce dcalage avec le contenu du Stack Pointer. Une fois cette adresse connue, nos instructions vont pouvoir manipuler notre donne en fournissant comme rfrence cette fameuse adresse calcule.

Avantages
Utiliser des piles aussi compliques a une utilit : sans cela, certaines fonctionnalits de nos langages de programmation actuels n'existeraient pas ! Pour les connaisseurs, cela signifierait qu'on ne pourrait pas utiliser de fonctions rentrantes ou de fonctions

www.siteduzero.com

Partie 2 : Architecture de base

69/378

rcursives. Mais je n'en dis pas plus : vous verrez ce que cela veut dire d'ici quelques chapitres. V oil, les bases sont clairement poses : vous avez maintenant un bon aperu de ce qu'on trouve dans nos ordinateurs. V ous savez ce qu'est un processeur, une mmoire, des bus, et savez plus ou moins comment tout cela est organis. V ous savez de plus avec quoi sont cres les circuits de notre ordinateurs, surtout pour ce qui est des mmoires. V ous tes prt pour la suite. Dans les chapitres suivants, on va approfondir ces connaissances superficielles, et on va aborder chaque composant (mmoire, processeur, entres-sorties, bus, etc) uns par uns. V ous saurez comment crer des mmoires compltes, ce qu'il y a dans un processeur, et aurez aussi un aperu des dernires volutions technologiques. On peut considrer que c'est maintenant que les choses srieuses commencent.

www.siteduzero.com

Partie 2 : Architecture de base

70/378

Partie 3 : Processeur et Assembleur

C'est maintenant au tour du processeur de passer sur le devant de la scne. Dans cette partie, nous allons commencer par expliquer les bases du langage assembleur, ainsi que du langage machine. Puis, nous descendrons un niveau plus bas : celui des circuits du processeur et nous finirons par voir comment ceux-ci sont organiss pour concevoir un processeur.

Langage machine et Assembleur

Dans ce chapitre, on va aborder le modle de programmation d'un processeur. Le modle de programmation d'un processeur est l'ensemble des composants internes au processeur qui sont manipulables par un programmeur. On va donc considrer pour le moment que notre processeur est une espce de boite noire, et on va voir ce que l'on peut apprendre sur lui. Au fait : la majorit des concepts qui seront vus dans ce chapitre ne sont rien d'autre que les bases ncessaires pour apprendre l'assembleur. De plus, ce chapitre sera suivi par un chapitre spcialement ddi aux bases thoriques de la programmation en assembleur : boucles, sous-programmes, et autres. C'est sympa, non ?

Instructions
Pour rappel, le rle d'un processeur est dexcuter des programmes. Un programme informatique est une suite d'instructions excuter dans l'ordre. Celles-ci sont places dans la mmoire programme les unes la suite des autres dans l'ordre dans lequel elles doivent tre excutes.

C'est quoi une instruction ?

Il existe plusieurs types d'instructions dont voici les principaux : Instruction Utilit Ces instructions font simplement des calculs sur des nombres. On peut citer par exemple : L'addition ; la multiplication ; la division ; le modulo ; la soustraction ; la racine carre ; le cosinus ; et parfois d'autres.

Les instructions arithmtiques

Elles travaillent sur des bits ou des groupes de bits. On peut citer : Le ET logique. Le OU logique. Le XOR. Le NON , qui inverse tous les bits d'un nombre : les 1 deviennent des 0 et les 0 deviennent des 1. Pour rappel, cela permet de calculer le complment 1 d'un nombre (rappelez-vous le chapitre sur le binaire) Les instructions de dcalage droite et gauche, qui vont dcaler tous les bits d'un nombre d'un cran vers la gauche ou la droite. Les bits qui sortent du nombre sont considrs comme perdus. Les instructions de rotation, qui font la mme chose que les instructions de dcalage, la diffrence prs que les bits qui "sortent d'un ct du nombre" aprs le dcalage rentrent de l'autre.

Les instructions logiques

Les instructions de manipulation de chaines de caractres

Ces instructions permettent de manipuler directement du texte. Dans notre ordinateur, une lettre est stocke sous la forme d'un nombre souvent cod sur 1 octet (rappelez-vous le premier chapitre sur la table ASCII). Pour stocker du texte, on utilise souvent ce que l'on appelle des chaines de caractres : ce ne sont rien de plus que des suites de lettres stockes les unes la suite des autres dans la mmoire, dans l'ordre dans lesquelles elles sont places dans le texte. Certains processeurs intgrent des instructions capables de manipuler ces chaines de caractres directement. Les processeurs capables dexcuter ce genre d'instructions sont toutefois assez peu frquents.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

Elles peuvent comparer deux nombres entre eux pour savoir si une condition est remplie ou pas. Pour citer quelques exemples, il existe certaines instructions qui peuvent vrifier si : deux nombres sont gaux ; si deux nombres sont diffrents ; si un nombre est suprieur un autre ; si un nombre est infrieur un autre.

71/378

Les instructions de test Les instructions de contrle Les instructions daccs mmoire Les instructions de gestion de l'nergie

Elles permettent de contrler la faon dont notre programme sexcute sur notre ordinateur. Elle permettent notamment de choisir la prochaine instruction excuter, histoire de rpter des suites d'instructions, de ne pas excuter des blocs d'instructions dans certains cas, et bien d'autres choses.

Elles permettent d'changer des donnes entre le processeur et la mmoire, ou encore permettent de grer la mmoire et son adressage.

Elles permettent de modifier la consommation en lectricit de l'ordinateur (instructions de mise en veille du PC, par exemple).

Les inclassables

Il existe une grande quantit d'autres instructions, qui sont fournies par certains processeurs pour des besoins spcifiques. Ainsi, certains processeurs ont des instructions spcialement adapts aux besoins des OS modernes. Il arrive aussi qu'on puisse trouver des instructions qui permettent des programmes de partager des donnes, d'changer des informations (via Message Passing ), etc. etc. On peut aussi trouver des instructions spcialises dans les calculs cryptographiques : certaines instructions permettent de chiffrer ou de dchiffrer des donnes de taille fixe. De mme, certains processeurs ont une instruction permettant de gnrer des nombres alatoires. Certains processeurs sont aussi capables d'effectuer des instructions sur des structures de donnes assez complexes, comme des listes chaines ou des arbres.

Ces types d'instructions ne sont pas les seuls : on peut parfaitement trouver d'autres instructions diffrentes, pour faciliter la cration de systmes d'exploitation, pour manipuler des structures de donnes plus complexes comme des arbres ou des matrices, etc.

Type des donnes et instructions

Petite remarque sur les instructions manipulant des nombres (comme les instructions arithmtiques, les dcalages, et les tests) : ces instructions dpendent de la reprsentation utilise pour ces nombres. La raison est simple : on ne manipule pas de la mme faon des nombres signs, des nombres cods en complment 1, des flottants simple prcision, des flottants double prcision, etc. Par exemple, quand on veut faire une addition, on ne traite pas de la mme faon un entier ou un flottant. Si vous ne me croyez pas, prenez deux flottants simple prcision et additionnez-les comme vous le feriez avec des entiers cods en complment deux : vous obtiendrez n'importe quoi ! Et c'est pareil pour de nombreuses autres instructions (multiplications, division, etc). On peut se retrouver avec d'autres cas de ce genre, pour lequel le "type" de la donne sur laquelle on va instructionner est important. Dans ce cas, le processeur dispose souvent d'une instruction par type manipuler. On se retrouve donc avec des instructions diffrentes pour effectuer la mme opration mathmatique, chacune de ces instructions tant adapte une reprsentation particulire : on peut avoir une instruction de multiplication pour les flottants, une autre pour les entiers cods en complment un, une autre pour les entiers cods en Binary Coded Decimal , etc. Sur d'anciennes machines, on stockait le type de la donne (est-ce un flottant, un entier cod en BCD, etc...) dans la mmoire. Chaque nombre, chaque donne naturellement manipule par le processeur incorporait un tag , une petite suite de bit qui permettait de prciser son type. Le processeur ne possdait pas d'instruction en plusieurs exemplaires pour faire la mme chose, et utilisait le tag pour dduire quoi faire comme manipulation sur notre donne. Par exemple, ces processeurs n'avaient qu'une seule instruction d'addition, qui pouvait traiter indiffremment flottants, nombres entiers cods en BCD, en complment deux, etc. Le traitement effectu par cette instruction dpendait du tag incorpor dans la donne. Des processeurs de ce type s'appellent des Tagged Architectures. De nos jours, ces processeurs n'existent plus que dans quelques musums : ils ont faits

www.siteduzero.com

Partie 3 : Processeur et Assembleur

leur temps, laissons-les reposer en paix.

72/378

Longueur des donnes traiter

La taille des donnes manipuler peut elle aussi dpendre de l'instruction. Ainsi, un processeur peut avoir des instructions pour traiter des nombres entiers de 8 bits, et d'autres instructions pour traiter des nombres entiers de 32 bits, par exemple. On peut aussi citer le cas des flottants : il faut bien faire la diffrence entre flottants simple prcision et double prcision ! Les tous premiers ordinateurs pouvaient manipuler des donnes de taille arbitraire : en clair, ils pouvaient manipuler des donnes aussi grandes qu'on le souhaite sans aucun problme. Alors certes, ces processeurs utilisaient des ruses : ils n'utilisait pas vraiment le binaire qu'on a vu au premier chapitre. A la place, ils stockaient leurs nombres dans des chaines de caractres ou des tableaux encods en Binary Coded Decimal (une mthode de reprsentation des entiers assez proche du dcimal), et utilisaient des instructions pouvant manipuler de tels tableaux. Mais de nos jours, cela tend disparaitre, et les processeurs ne disposent plus d'instructions de ce genre.

Reprsentation en binaire d'une instruction

Ces instructions sont stockes dans la mmoire programme de l'ordinateur sous la forme de suites de bits. Certaines instructions possdent une reprsentation en binaire unique : il n'y a qu'une seule faon pour les reprsenter sous la forme de suites de bits. Mais il arrive trs souvent que certaines instructions identiques peuvent tre reprsentes par plusieurs suites de bits diffrentes, suivant les donnes qu'elles manipulent. Les raisons cela sont assez diverses. Cela permet notamment de prciser la localisation des donnes manipuler : nos instructions peuvent avoir une partie variable pour prciser o sont places les donnes manipuler dans la mmoire. Cela peut aussi permettre de donner des informations au processeur sur l'instruction, sur ses donnes, ou permettre dautres choses encore. Exemple : ici, les valeurs binaires sont compltement fictives. Instruction Ne rien faire durant un cycle d'horloge : NOP 1001 0000 Mise en veille : HALT Addition : ADD criture en mmoire : STORE 0110 1111 0000 0000, ou 0000 0001, ou 1000 0000, etc... 1111 1100, ou 1111 1101, ou 1111 1110, etc... Valeur Binaire

Jeux d'instruction
Au fait, on va mettre les choses au clair tout de suite : certains processeurs peuvent faire des instructions que d'autres ne peuvent pas faire. Ainsi, les instructions excutables par un processeur dpendent fortement du processeur utilis. La liste de toute les instructions qu'un processeur peut excuter s'appelle son jeu d'instruction. Ce jeu d'instruction va dfinir quelles sont les instructions supportes, ainsi que les suites de bits correspondant chaque instruction.

RISC vs CISC
Il existe diffrents jeux d'instructions : le X86 , le PPC, etc. Et tout ces jeux d'instructions ont leurs particularits. Pour s'y retrouver, on a grossirement class ces jeux d'instructions en plusieurs catgories. La premire classification se base sur le nombre d'instructions et classe nos processeurs en deux catgories : les RISC (reduced instruction set computer) qui peuvent excuter trs peu d'instructions ; et les CISC (complex instruction set computer) avec pleins d'instructions.

CISC
CISC est l'acronyme de Complex Instruction Set Computer . Traduit de l'anglais cela signifie Ordinateur jeu d'instruction complexe. Les processeurs CISC ont un jeu d'instruction toff, avec beaucoup d'instructions. De plus, certaines de ces instructions sont assez complexes et permettent de faire des oprations assez volues. Par exemple, ces processeurs peuvent calculer des exponentielles, des racines carres, des logarithmes, des fonctions mathmatiques compliques, etc. Ou ils peuvent avoir des instructions pour traiter du texte, des tableaux, ou d'autres formes de donnes complexes. Ces jeux d'instructions sont les plus anciens : ils taient la mode jusqu' la fin des annes 1980. A cette poque, on programmait rarement avec des langages de haut niveau et beaucoup de programmeurs devaient utiliser l'assembleur. Avoir un jeu d'instruction complexe, avec des instructions de "haut niveau" qu'on ne devait pas refaire partir d'instructions plus simples,

www.siteduzero.com

Partie 3 : Processeur et Assembleur

tait un gros avantage : cela facilitait la vie des programmeurs.

73/378

Cette complexit des jeux d'instructions n'a pas que des avantages "humains", mais a aussi quelques avantages techniques. Il n'est pas rare qu'une grosse instruction complexe puisse remplacer une suite d'instructions plus lmentaires. Cela a quelques effets plutt bnfiques : un programme crit pour un processeur CISC comportera moins d'instructions et prendra donc moins de place en mmoire programme. A l'poque des processeurs CISC, la mmoire tait rare et chre, ce qui faisait que les ordinateurs n'avaient pas plusieurs gigaoctets de mmoire : conomiser celle-ci tait crucial. Les processeurs CISC permettait un programme d'utiliser moins de mmoire, et taient donc plutt bien vus. De plus, dans certaines situations, une grosse instruction lente peut tre plus rapide excuter que plusieurs instructions rapides. Mais ces avantages ne sont pas sans contreparties. On a besoin de beaucoup de circuits pour cbler toutes ces instructions, ce qui est rarement gratuit.

L'agence tout RISC

Au fil du temps, on s'est demand si les instructions complexes des processeurs CISC taient vraiment utiles. Pour le programmeur qui crit ses programmes en assembleur, elle le sont. Mais avec l'invention des langages de haut niveau, la roue a commence tourner. Diverses analyses ont alors ts effectues par IBM, DEC et quelques chercheurs, visant valuer les instructions rellement utilises par les compilateurs. Et l'poque, les compilateurs n'utilisaient pas la totalit des instructions fournies par un processeur. Nombre de ces instructions n'taient utilises que dans de rares cas, voire jamais. Autant dire que beaucoup de transistors taient gchs rien ! L'ide de crer des processeurs possdant des jeux d'instructions simples et contenant un nombre limit d'instructions trs rapides commena germer. Ces processeurs sont de nos jours appels des processeurs RISC. RISC est l'acronyme de Reduced Instruction Set Computer. Traduit de l'anglais cela signifie Ordinateur jeu d'instruction rduit. Mais de tels processeurs RISC, compltement opposs aux processeurs CISC, durent attendre un peu avant de percer. Par exemple, IBM dcida de crer un processeur possdant un jeu d'instruction plus sobre, l'IBM 801, qui ft un vritable chec commercial. Mais la relve ne se fit pas attendre. C'est dans les annes 1980 que les processeurs possdant un jeu d'instruction simple devinrent la mode. Cette anne l, un scientifique de l'universit de Berkeley dcida de crer un processeur possdant un jeu d'instruction contenant seulement un nombre rduit d'instructions simples, possdant une architecture particulire. Ce processeur tait assez novateur et incorporait de nombreuses amliorations qu'on retrouve encore dans nos processeurs haute performances actuels, ce qui fit son succs : les processeurs RISC taient ns. Dautres processeurs de ce type suivirent dans les annes qui suivirent, comme les processeurs MIPS, par exemple. Comme ce qui a t dit plus haut, les RISC ont peu d'instructions, ce qui implique qu'un processeur RISC utilise peu de circuits lectroniques. En consquence, le processeur est souvent plus simple fabriquer. Mais par contre, les programmes compils sur les processeurs RISC prennent plus de mmoire.

Qui est le vainqueur ?

Durant longtemps, les CISC et les RISC eurent chacun leurs admirateurs et leurs dtracteurs. De longs et interminables dbats eurent lieu pour savoir si les CISC taient meilleurs que les RISC, similaires aux "Windows versus Linux", ou "C versus C++", qu'on trouve sur n'importe quel forum digne de ce nom. Au final, on ne peut pas dire qu'un processeur CISC sera meilleur qu'un RISC ou l'inverse : chacun a des avantages et des inconvnients, qui rendent le RISC/CISC adapt ou pas selon la situation. Par exemple, on mettra souvent un processeur RISC dans un systme embarqu, devant consommer trs peu. Par contre, le CISC semble mieux adapt dans certaines conditions, en raison de la taille plus faible des programmes, ou quand les programmes peuvent faire un bon usage des instructions complexes du processeur. Au final, tout dpend d'un tas de paramtres : qualit du compilateur, faon dont est conue le processeur, spcificits du jeu d'instruction, etc. Tout ces paramtres jouent beaucoup dans la faon dont on pourra tirer au mieux parti d'un processeur RISC ou CISC, et ils sont bien plus importants que le fait que le processeur soit un RISC ou un CISC. De plus, de nos jours, les diffrences entre CISC et RISC commencent s'estomper. Les processeurs actuels sont de plus en plus difficiles ranger dans des catgories prcises. Les processeurs actuels sont conus d'une faon plus pragmatiques : au lieu de respecter la lettre les principes du RISC et du CISC, on prfre intgrer les techniques et instructions qui fonctionnent, peut importe qu'elles viennent de processeurs purement RISC ou CISC. Les anciens processeurs RISC se sont ainsi garnis d'instructions et techniques de plus en plus complexes et les processeurs CISC ont intgr des techniques provenant des processeurs RISC (pipeline, etc). Au final, cette guerre RISC ou CISC n'a plus vraiment de sens de nos jours.

Jeux d'instructions spcialiss

En parallle de ces architectures CISC et RISC, qui sont en quelques sorte la base de tous les jeux d'instructions, d'autres classes de jeux d'instructions sont apparus, assez diffrents des jeux dinstructions RISC et CISC. On peut par exemple citer le Very Long Instruction Word, qui sera abord dans les chapitre la fin du tutoriel. La plupart de ces jeux d'instructions sont implants dans des processeurs spcialiss, qu'on fabrique pour une utilisation particulire. Ce peut tre pour un langage de programmation particulier, pour des applications destines un marche de niche comme les supercalculateurs, etc. Parmi ces jeux d'instructions spcialiss, on peut citer les fameux jeux d'instructions Digital Signal Processor , aussi appels des

www.siteduzero.com

Partie 3 : Processeur et Assembleur

DSP.

74/378

Les DSP
Ces DSP sont des processeurs chargs de faire des calculs sur de la vido, du son, ou tout autre signal. Ds que vous avez besoin de traiter du son ou de la vido, vous avez un DSP quelque part, que ce soit une carte son ou une platine DVD. Ces DSP ont souvent un jeu d'instruction similaire aux jeux d'instructions RISC, avec peu d'instructions, toutes spcialises pour faire du traitement de signal. On peut par exemple citer l'instruction phare de ces DSP, l'instruction MAD (qui multiplie deux nombres et additionne un 3me au rsultat de la multiplication). De nombreux algorithmes de traitement du signal (filtres FIR, transformes de Fourier) utilisent massivement cette opration. Ces DSP possdent aussi des instructions permettant de faire rpter rapidement une suite d'instruction (pour les connaisseurs, ces instructions permettent de crer des boucles), ou des instructions capables de traiter plusieurs donnes en parallle (en mme temps). Ces instructions manipulent le plus souvent des nombres entiers (en ralit, des nombres virgule fixe), et parfois (plus rarement) des nombres flottants. Ces DSP ont souvent une architecture de type Harvard. Pour rappel, cela signifie qu'ils sont connects deux bus de donnes : un pour les instructions du programme, et un autre reli la mmoire de travail, pour les donnes. Certains DSP vont mme plus loin : ils sont relis plusieurs bus mmoire. Au bout de ces bus mmoire, on retrouve souvent une mmoire multiports, ou plusieurs mmoires spares. Nos DSP sont donc capables de lire et/ou d'crire plusieurs donnes simultanment : une par bus mmoire reli au DSP.

Il y a pire
On peut aussi citer les jeux d'instructions de certains processeurs particulirement adapts un systme d'exploitation en particulier. Un exemple serait les processeurs multics, spcialement ddis au systme d'exploitation du mme nom. Il faut avouer que ces processeurs sont assez rares et ddis des marchs de niche. Dans le mme genre, certains processeurs sont spcialement conus pour un langage en particulier. Il existe ainsi des processeurs possdant des instructions permettant dacclrer le traitement des oprations de base fournies par un langage de programmation, ou encore d'implmenter celle-ci directement dans le jeu d'instruction du processeur, transformant ainsi ce langage de haut niveau en assembleur. On appelle de tels processeurs, des processeurs ddis. Historiquement, les premiers processeurs de ce type taient des processeurs ddis au langage LISP, un vieux langage fonctionnel autrefois utilis, mais aujourd'hui peu usit. De tels processeurs datent des annes 1970 et taient utiliss dans ce qu'on appelait des machines LISP. Ces machines LISP taient capables dexcuter certaines fonctions de base du langage directement dans leur circuits : elles possdaient notamment un garbage collector cbl dans ses circuits ainsi que des instructions machines supportant un typage dtermin lexcution. D'autres langages fonctionnels ont aussi eu droit leurs processeurs ddis : le prolog en est un bel exemple. Autre langage qui a eu l'honneur d'avoir ses propres processeurs ddis : le FORTH, un des premiers langages pile de haut niveau. Ce langage possde de nombreuses implmentations hardware et est un des rares langages de haut niveau avoir t directement cbl en assembleur sur certains processeurs. Par exemple, on peut citer le processeur FC16, capable dexcuter nativement du FORTH. En regardant dans les langages de programmation un peu plus connus, on peut aussi citer des processeurs spcialiss pour JAV qui intgrent une machine virtuelle JAV directement dans leurs circuits : de quoi excuter nativement du bytecode ! A, A Certains processeurs ARM, qu'on trouve dans des systme embarqus, sont de ce type.

Et pour nos ordinateurs ?

Le jeu d'instruction de nos PC qui fonctionnent sous Windows est appel le x86. C'est un jeu d'instructions particulirement ancien, apparu certainement avant votre naissance : 1978. Depuis, de plus en plus d'instructions ont t ajoutes et rajoutes : ces instructions sont ce qu'on appelle des extensions x86. On peut citer par exemple les extensions MMX, SSE, SSE2, voir 3dnow!. Le rsultat, c'est que les processeurs x86 sont de type CISC, avec tous les inconvnients que cela apporte. Les anciens macintoshs (la gnration de macintosh produits entre 1994 et 2006) utilisaient un jeu d'instruction diffrent : le PowerPC. Celui-ci tait un jeu d'instruction de type RISC. Depuis 2006, les macintoshs utilisent un processeur X86. Mais les architectures x86 et Power PC ne sont pas les seules au monde : il existe d'autres types d'architectures qui sont trs utilises dans le monde de linformatique embarque et dans tout ce qui est tablettes et tlphones portables derniers cris. On peut citer notamment l'architecture ARM, qui domine ce march. Et n'oublions pas leurs consurs MIPS et SPARC.

Registres
Nos instructions manipulent donc des donnes, qui sont forcment stockes quelques part dans la mmoire de notre ordinateur.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

75/378

En plus d'avoir accs aux donnes places dans la mmoire RAM, le processeur possde plusieurs mmoires internes trs rapides qui peuvent stocker trs peu de donnes : des registres. Ces registres servent stocker temporairement des informations dont le processeur peut avoir besoin, aussi bien instructions, adresses ou donnes. Il s'agit bien des registres vus dans les chapitres prcdents, fabriqus avec des bascules. Mais pourquoi utiliser des registres pour stocker des donnes alors que l'on a dj une mmoire RAM ?

C'est trs simple : la mmoire RAM est une mmoire assez lente, et y accder en permanence rendrait notre ordinateur vraiment trop lent pour tre utilisable. Par contre, les registres sont des mmoires vraiment trs rapides. En stockant temporairement des donnes dans ces registres, le processeur pourra alors manipuler celle-ci trs rapidement, sans avoir attendre une mmoire RAM la lenteur pachydermique. Typiquement, ds qu'une donne doit tre lue ou modifie plusieurs fois de suite, on a tout gagner la mettre dans un registre.

A quoi servent ces registres ?

On peut se demander quoi servent ces registres. Tout cela dpend du processeur, et tous nos processeurs ne grent pas ces registres de la mme faon.

Registres spcialiss
Certains processeurs disposent de registres spcialiss, qui ont une utilit bien prcise. Leur fonction est ainsi prdtermine une bonne fois pour toute. Le contenu de nos registres est aussi fix une bonne fois pour toute : un registre est conu pour stocker soit des nombres entiers, des flottants, des adresses, etc; mais pas autre chose. Pour donner quelques exemples, voici quelques registres spcialiss qu'on peut trouver sur pas mal de processeurs. Registre Utilit Pour rappel, un processeur doit effectuer une suite d'instructions dans un ordre bien prcis. Dans ces conditions, il est vident que notre processeur doit se souvenir o il est dans le programme, quelle est la prochaine instruction excuter : notre processeur doit donc contenir une mmoire qui stocke cette information. C'est le rle du registre d'adresse d'instruction.

Le registre d'adresse d'instruction

Ce registre stocke l'adresse de la prochaine instruction excuter. Cette adresse permet de localiser l'instruction suivante en mmoire. Cette adresse ne sort pas de nulle part : on peut la dduire de l'adresse de l'instruction en cours dexcution par divers moyens plus ou moins simples qu'on verra dans la suite de ce tutoriel. Cela peut aller d'une simple addition quelque chose d'un tout petit peu plus complexe. Quoiqu'il en soit, elle est calcule par un petit circuit combinatoire coupl notre registre d'adresse d'instruction, qu'on appelle le compteur ordinal. Ce registre d'adresse d'instruction est souvent appel le Program Counter. Retenez bien ce terme, et ne l'oubliez pas si vous voulez lire des documentations en anglais. Le registre d'tat contient plusieurs bits qui ont chacun une utilit particulire. Ce registre est trs diffrent suivant les processeurs, mais certains bits reviennent souvent : divers bits utiliss lors d'oprations de comparaisons ou de tests qui servent donner le rsultat de celles-ci ; le bit d'overflow, qui prvient quand le rsultat d'une instruction est trop grand pour tenir dans un registre ; le bit null : prcise que le rsultat d'une instruction est nul (vaut zro) ; le bit de retenue, utile pour les additions ; le bit de signe, qui permet de dire si le rsultat d'une instruction est un nombres ngatif ou positif. Ces deux registres sont utiliss pour grer une pile, si le processeur en possde une. Pour ceux qui auraient oublis ce qu'est la pile, le chapitre 5 est l pour vous. Pour rappel, le Stack Pointer stocke l'adresse du sommet de la pile. Tout processeur qui possde une pile en possde un. Par contre, le Frame Pointer est optionnel : il n'est prsent que sur les processeurs qui grent des Stack Frames de taille variable. Ce registre stocke l'adresse laquelle commence la Stack Frame situe au sommet de la pile.

Le registre d'tat

Le Stack Pointer, et ventuellement le Frame Pointer Registres

www.siteduzero.com

Partie 3 : Processeur et Assembleur

76/378

Registres entiers Registres flottants

Certains registres sont spcialement conus pour stocker des nombres entiers. On peut ainsi effectuer des instructions de calculs, des oprations logiques dessus. Certains registres sont spcialement conus pour stocker des nombres flottants. Lintrt de placer les nombres flottants part des nombres entiers, dans des registres diffrents peut se justifier par une remarque trs simple : on ne calcule pas de la mme faon avec des nombres flottants et avec des nombres entiers. La faon de grer les nombres flottants par nos instructions tant diffrente de celle des entiers, certains processeurs placent les nombres flottants part, dans des registres spars. On peut ainsi effectuer des instructions de calculs, des oprations logiques dessus. Ces registres de constante contiennent des constantes assez souvent utilises. Par exemple, certains processeurs possdent des registres initialiss zro pour acclrer la comparaison avec zro ou l'initialisation d'une variable zro. On peut aussi citer certains registres flottants qui stockent des nombres comme , ou pour faciliter l'implmentation des calculs trigonomtriques). Autrefois, nos processeurs possdaient des registres d'Index, qui servait calculer des adresses, afin de manipuler rapidement des donnes complexes comme les tableaux. Ces registres d'Index taient utiliss pour effectuer des manipulations arithmtiques sur des adresses. Sans eux, accder des donnes places des adresses mmoires conscutives ncessitait souvent d'utiliser du self-modifying code : le programme devait tre conu pour se modifier lui-mme en partie, ce qui n'tait pas forcment idal pour le programmeur.

Registres de constante

Registres d'Index

Sur certains processeurs, certains des registres cits plus bas ne sont pas prsents ! Il existe ainsi des processeurs qui se passent des registres chargs de grer la pile : tout processeur n'utilisant pas de pile le peut. De mme, il est possible de se passer du registre d'tat, etc.

Registres gnraux
Malheureusement, fournir des registres trs spcialiss n'est pas trs flexible. Prenons un exemple : j'ai un processeur disposant d'un Program Counter, de 4 registres entiers, de 4 registres d'Indexpour calculer des adresses, et de 4 registres flottants. Si jamais jexcute un morceau de programme qui manipule beaucoup de nombres entiers, mais qui ne manipule pas d'adresses ou de nombre flottants, j'utiliserais juste les 4 registres entiers. Une partie des registres du processeur sera inutilis : tous les registres flottants et d'Index. Le problme vient juste du fait que ces registres ont une fonction bien fixe. Pourtant, en rflchissant, un registre est un registre, et il ne fait que stocker une suite de bits. Il peut tout stocker : adresses, flottants, entiers, etc. Pour plus de flexibilit, certains processeurs ne fournissent pas de registres spcialiss comme des registres entiers ou flottants, mais fournissent la place des Les registres gnraux utilisables pour tout et n'importe quoi. Ce sont des registres qui n'ont pas d'utilit particulire et qui peuvent stocker toute sorte dinformation code en binaire. Pour reprendre notre exemple du dessus, un processeur avec des registres gnraux fournira un Program Counter et 12 registres gnraux, qu'on peut utiliser sans vraiment de restrictions. On pourra s'en servir pour stocker 12 entiers, 10 entiers et 2 flottants, 7 adresses et 5 entiers, etc. Ce qui sera plus flexible et permettra de mieux utiliser les registres. Dans la ralit, nos processeurs utilisent souvent un espce de mlange entre les deux solutions. Gnralement, une bonne partie des registres du processeur sont des registres gnraux, part quelques registres spcialiss, accessibles seulement travers quelques instructions bien choisies. C'est le cas du registre d'adresse d'instruction, qui est manipul automatiquement par le processeur et par les instructions de branchement.

La catastrophe
Ceci dit, certains processeurs sont trs laxistes : tous les registres sont des registres gnraux, mme le Program Counter. Sur ces processeurs, on peut parfaitement lire ou crire dans le Program Counter sans trop de problmes. Ainsi, au lieu d'effectuer des branchements sur notre Program Counter, on peut simplement utiliser une instruction qui ira crire l'adresse laquelle brancher dans notre registre. On peut mme faire des calculs sur le contenu du Program Counter : cela n'a pas toujours de sens, mais cela permet parfois d'implmenter facilement certains types de branchements avec des instructions arithmtiques usuelles.

Noms de registre
a doit tre du sport pour se retrouver dans un processeur avec tout ces registres ! On a invent quelque chose pour rendre a plus simple ?

www.siteduzero.com

Partie 3 : Processeur et Assembleur

Et bien rassurez-vous, les concepteurs de processeurs ont trouv des solutions.

77/378

Noms de registres
Dans le premier cas, chaque registre se voit attribuer une rfrence, une sorte d'identifiant qui permettra de le slectionner parmi tous les autres. C'est un peu la mme chose que pour la mmoire RAM : chaque byte de la mmoire RAM se voit attribuer une adresse bien prcise. Et bien pour les registres, c'est un peu la mme chose : ils se voient attribuer quelque chose d'quivalent une adresse, une sorte d'identifiant qui permettra de slectionner un registre pour y accder. Cet identifiant est ce qu'on appelle un nom de registre. Ce nom n'est rien d'autre qu'une suite de bits attribue chaque registre, chaque registre se voyant attribuer une suite de bits diffrente. Celle-ci sera intgre toutes les instructions devant manipuler ce registre, afin de slectionner celui-ci. Ce numro, ou nom de registre, permet d'identifier le registre que l'on veut, mais ne sort jamais du processeur : ce nom de registre, ce numro, ne se retrouve jamais sur le bus d'adresse. Les registres ne sont donc pas identifis par une adresse mmoire.

Toutefois, tous les registres n'ont pas forcment besoin d'avoir un nom. Par exemple, les registres chargs de grer la pile n'ont pas forcment besoin d'un nom : la gestion de la pile se fait alors via des instructions Push et Pop qui sont les seules pouvoir manipuler ces registres. Toute manipulation du Frame Pointer et du Stack Pointer se faisant grce ces instructions, on n'a pas besoin de leur fournir un identifiant pour pouvoir les slectionner. C'est aussi le cas du registre d'adresse d'instruction : sur certains processeurs, il est manipul automatiquement par le processeur et par les instructions de branchement. Dans ces cas bien prcis, on n'a pas besoin de prciser le ou les registres manipuler : le processeur sait dj quels registres manipuler et comment, de faon implicite. Quand on effectue un branchement, le processeur sait qu'il doit modifier le Program Counter : pas besoin de lui dire. Pareil pour les instructions de gestion de la pile. Ces noms de registres posent un petit problme. Quand une instruction voudra manipuler des donnes, elle devra fatalement donner une adresse ou un nom de registres qui indiquera la position de la donne en mmoire. Ces adresses et noms de registres sont cods sous la forme de suites de bits, incorpores dans l'instruction. Mais rien ne ressemble plus une suite de bits qu'une autre suite de bits : notre processeur devra viter de confondre suite de bits reprsentant une adresse, et suite de bits reprsentant un nom de registre. Pour viter les confusions, chaque instruction devra prciser quoi correspondra la suite de bits prcisant la localisation des donnes manipuler : est-ce un registres ou une adresse, ou autre chose encore. Cette prcision (cet-ce une adresse ou un nom de registres) sera indique par ce qu'on appelle un mode d'adressage. Nous reviendront dessus tout l'heure.

Registres adressables
Mais il existe une autre solution, assez peu utilise. Sur certains processeurs assez rares, on peut adresser les registres via une adresse mmoire. Il est vrai que c'est assez rare, et qu' part quelques vielles architectures ou quelques micro-contrleurs, je n'ai pas d'exemples donner. Mais c'est tout fait possible ! C'est le cas du PDP-10.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

78/378

Registres architecturaux
Ainsi, un programmeur (ou un compilateur) qui souhaite programmer en langage machine peut manipuler ces registres en utilisant des rfrences (des noms de registre), ou des instructions spcialises. Si on veut manipuler un registre, il suffit simplement d'appliquer des instructions machines dessus. A ce stade, il faut faire une petite remarque : tous les registres d'un processeur ne sont pas forcment manipulables par le programmeur. Il existe ainsi deux types de registres : les registres architecturaux, manipulables par des instructions, et d'autres registres internes au processeurs. On pourrait se demander quoi servent ces registres qu'on ne peut pas manipuler. Le fait est que ces registres non-architecturaux n'ont pas tre modifis par un programmeur : le processeur gre leur contenu tout seul. De plus, nos processeurs peuvent intgrer un grand nombre de registres secrets afin de simplifier la conception du processeur ou pour permettre l'implmentation d'optimisations. Le nombre de registres architecturaux varie suivant le processeur. Gnralement, les processeurs RISC et les DSP possdent un grand nombre de registres. Sur les processeurs CISC, c'est l'inverse : il est rare d'avoir un grand nombre de registres architecturaux manipulables par un programme.

8, 16, 32, 64 bits : une histoire de taille des registres

V ous avez dj entendu parler de processeurs 32 ou 64 bits ?

Derrire cette appellation qu'on retrouve souvent dans la presse ou comme argument commercial se cache un concept simple. Il s'agit de la quantit de bits qui peuvent tre stocks dans chaque registre gnraux. Attention : on parle bien des registres gnraux, et pas forcment des autres registres. Notre processeur contient pas mal de registres et certains peuvent contenir plus de bits que d'autres. Par exemple, dans certains processeurs, les registres gnraux sont spars des registres stockant des flottants et ces deux types de registres peuvent avoir une taille diffrente. Exemple : dans les processeurs x86, il existe des registres spcialement ddis aux nombres flottants et d'autres spcialement ddis aux nombres entiers (ce sont les registres gnraux qui servent pour les entiers). Les registres pour nombres entiers n'ont pas la mme taille que les registres ddis aux nombres flottants. Un registre pour les nombres entiers contient environ 32 bits tandis qu'un registre pour nombres flottants contient 80 bits. Ce nombre de bits que peut contenir un registre est parfois diffrent du nombre de bits qui peuvent transiter en mme temps sur

www.siteduzero.com

Partie 3 : Processeur et Assembleur

79/378

le bus de donne de votre ordinateur. Cette quantit peut varier suivant l'ordinateur. On l'appelle la largeur du bus de donnes. Exemple : sur les processeurs x 86 - 32 bits, un registre stockant un entier fait 32bits. Un registre pour les flottants en fait gnralement 64. Le bus de donne de ce genre d'ordinateur peut contenir 64 bits en mme temps. Cela a une petite incidence sur la faon dont une donne est transfre entre la mmoire et un registre. On peut donc se retrouver dans trois situations diffrentes : Situation Le bus de donnes a une largeur gale la taille d'un registre La largeur du bus de donne est plus petite que la taille d'un registre Consquence Le bus de donne peut charger en une seule fois le nombre de bits que peut contenir un registre. On ne peut pas charger le contenu d'un registre en une fois, et on doit charger ce contenu morceau par morceau.

Au fait : il est possible que la taille du bus de donne soit plus grande que la taille des registres du processeur. Mais cela ne permet pas (du moins pas ma connaissance) de charger le contenu de plusieurs registres la fois depuis la mmoire. L'utilit est tout autre : les processeurs ayant des bus plus larges que leurs registres utilisent souvent une mmoire cache, intercale entre les registres et la mmoire principale. Gnralement, on prfre que le bus de donne soit suffisamment large pour changer de gros blocs de donnes entre la mmoire et le cache. Ces blocs de donnes sont souvent plus gros que les registres, et donc le bus de donnes doit tre plus grand que la taille d'un registre.

Codage d'une instruction

Pour rappel, nos instructions sont stockes dans la mmoire programme de l'ordinateur sous la forme de nombres cods en binaire. Exemples : ici, les valeurs binaires sont valables uniquement pour les processeurs x86. Instruction Addition de deux entiers : ADD Valeur Binaire 1110 1000

Ne rien faire durant un cycle d'horloge : NOP 1001 0000 Instruction de rupture de squence JMP Empiler au sommet de la pile : PUSH 1110 1011 0110 1010

Mais j'ai volontairement pass sous silence quelque chose : cette suite de bits n'est pas organise n'importe comment. Elle contient non seulement de quoi dire quelle est linstruction xecuter, mais elle doit aussi contenir d'autre informations. Sans cela, rien ne marche ! En effet, notre instruction va devoir prciser la localisation des donnes manipuler : est-ce que la donne manipuler est dans un registre, dans la mmoire (et quelle adresse ?). De mme, o enregistrer le rsultat ?

Opcode
On ne va bien videmment pas coder une instruction diffrente pour chaque case mmoire utilisable, ou encore pour chaque combinaison registre-adresse mmoire. Pour rsoudre ce problme, la solution est simple : coder notre instruction en deux parties distinctes : l'opcode, qui spcifie l'instruction effectuer, et une partie variable qui dpend de la localisation des donnes ncessaires pour pouvoir excuter notre instruction et qui prcise aussi o enregistrer le rsultat de l'instruction. On se retrouve alors avec une instruction code en deux parties : une partie fixe nomme le code opration ou encore l'Opcode, qui dtermine quelle est l'opration que doit effectuer l'instruction ; une partie variable, qui dpend de la localisation des donnes que l'on souhaite donner en entre l'instruction ; et ventuellement une deuxime partie variable, qui prcise quel endroit l'on doit enregistrer notre rsultat en mmoire. Exemple : ici, on a une instruction code sur 16 bits avec un opcode de 8 bits et une oprande de 8 bits. Opcode Oprande

11110010 XXXXXXXX

www.siteduzero.com

Partie 3 : Processeur et Assembleur

80/378

Pour la mme instruction, l'opcode peut tre diffrent suivant le processeur, ce qui est source d'incompatibilit. Ce qui fait que pour chaque processeur, ses fabricants donnent une liste qui recense l'intgralit des instructions et de leur opcode : l'opcode map.

Modes d'adressage
Cette partie variable va donner quelques indications sur l'endroit ou est place notre donne : dans un registre, dans la mmoire statique, sur la pile. Reste savoir comment interpreter cette partie variable : aprs tout, c'est une simple suite de bits qui peut reprsenter une adresse, un nombre, un nom de registre, etc. Il existe diverses faons pour cela : chacune de ces faon va permettre dinterprter le contenu de la partie variable comme tant une adresse, une constante, un nom de registre, etc, ce qui nous permettra de localiser la ou les donne de notre instruction. Ces diverses manires dinterprter notre partie variable pour en exploiter son contenu s'appellent des modes d'adressage. Pour rsumer, ce mode d'adressage est une sorte de recette de cuisine capable de dire o se trouve la ou les donnes ncessaires pour excuter une instruction. Pour comprendre ce qu'est un mode d'adressage, voyons quelques exemples de modes d'adressages assez communs et qui reviennent souvent : Mode d'adressage Description des oprandes La partie variable est une donne constante, qui reste toujours la mme : ce peut tre un nombre, un caractre... Ainsi, notre donne est charge en mme temps que l'instruction et est place dans la partie variable. La partie variable est l'adresse de la donne laquelle accder. Cela permet parfois de lire une donne directement depuis la mmoire sans devoir la copier dans un registre, mme si les contre-exemples cette "rgle" sont nombreux. Dans ce cas, la partie variable n'existe pas ! Certaines instructions n'ont pas besoin qu'on leur donne la localisation des donnes d'entre et "savent" o est la ou les donne(s). Certaines instructions manipulant la pile sont adresses de cette manire : on connait d'avance l'adresse de la base ou du sommet de la pile. Pour rappel, celle-ci est stocke dans quelques registres du processeur. La partie variable est une suite de bits qui permet d'identifier un registre qui contient la donne voulue. Cela permet de slectionner le bon registre : celui qui contient la donne voulue. Dans certains cas, les registres gnraux du processeur peuvent stocker des adresses mmoire. Aprs tout, une adresse n'est rien d'autre qu'un nombre entier ayant une signification spciale, et utiliser un registre cens stocker des nombres entiers pour stocker une adresse n'a rien de choquant. Ces adresses sont alors manipulables comme des donnes, et on peut les incrmenter, les dcrmenter ou leur faire subir quelques manipulations arithmtiques (certains auront remarqu une ressemblance avec l'arithmtique des pointeurs). On peut alors dcider un moment ou un autre d'accder au contenu de l'adresse stocke dans un registre : c'est le rle du mode d'adressage indirect registre. Ici, la partie variable est une suite de bits qui permet d'identifier un registre contenant l'adresse de la donne voulue. Ce mode d'adressage a t invent pour faciliter le parcours et la manipulation de tableaux en assembleur : il suffit de placer l'adresse de base du tableau dans le registre et incrmenter celui-ci de la bonne valeur pour parcourir un tableau. L'adressage indirect registre permet aussi dimplmenter les pointeurs d'une faon simple en assembleur.

Adressage immdiat Adressage direct Adressage implicite Adressage inhrent

Adressage indirect registre

Ce mode dadressage peut tre prcis dans l'opcode, ou alors dans quelques bits spars de l'opcode et des oprandes (gnralement, ces bits sont intercals entre l'opcode et les oprandes).

www.siteduzero.com

Partie 3 : Processeur et Assembleur

81/378

Ces modes d'adressage dpendent fortement de l'instruction qu'on veut faire excuter et du processeur. Certaines instructions supportent certains modes d'adressage et pas d'autres, voir mixent plusieurs modes d'adressages : les instructions manipulant plusieurs donnes peuvent parfois utiliser un mode d'adressage diffrent pour chaque donne. Dans de tels cas, tout se passe comme si l'instruction avait plusieurs parties variables, nommes oprandes, contenant chacune soit une adresse, une donne ou un registre. Retenez bien ce terme, on en parlera dans les chapitres qui suivent. Ces oprandes peuvent trs bien ne pas avoir la mme taille. Par exemple, une oprande contenant une adresse mmoire (adressage direct) prendra plus de place qu'une oprande spcifiant un registre : pour un processeur de 64 registres, il suffira d'encoder de quoi spcifier 64 registres. Par contre, une adresse permet souvent de prciser bien plus que 64 cases mmoires et prend donc plus de place. Gnralement, l'adressage par registre et l'adressage indirect registre permettent d'avoir des oprandes petites compar aux modes d'adressage direct et immdiat. Mais le mode d'adressage implicite est celui qui permet de se passer compltement de partie variable et est donc le plus conome en mmoire. D'autres modes d'adressages existent et certains processeurs CISC en ont beaucoup plus. Par contre, les processeurs RISC ont trs peu de modes d'adressage et se contentent souvent de 2-3 modes d'adressage : cela permet de simplifier la conception du processeur au maximum. Et cela rend difficile la programmation en assembleur : certains modes d'adressages facilitent vraiment la vie (le mode d'adressage indirect registre, notamment). En effet, de nombreux modes d'adressages permettent de faciliter la programmation, notamment tout ce qui concerne : les pointeurs, avec par exemple les modes d'adressage Memory indirect et Memory indirect autoincrement ; le parcours d'un tableau, grce aux modes d'adressage Register autoincrement indirect et Autodecrement register indirect ; la slection d'un lment dans une structure de donne ou un tableau, grandement simplifie grce aux modes d'adressage Indexed absolute et Base plus index ; l'implmentation de buffers circulaires (une structure de donnes spciale) grce aux modes d'adressages bit reverse adressing et hardware modulo adressing : ces modes d'adressages sont utiliss dans les DSP afin de faciliter et d'acclrer le traitement de certains algorithmes. la gestion d'une pile, avec les modes d'adressage post-incrment et pr-dcrment ; la slection d'un lment d'un tableau de structures, avec le mode d'adressage Base plus index plus offset. Et il en existe bien d'autres. Sur certains processeurs, chaque instruction dfinie dans le jeu d'instruction peut utiliser tous les modes d'adressages supports par le processeurs : on dit que le jeu d'instruction du processeur est orthogonal. Les jeu d'instructions orthogonaux sont une caractristique des processeurs CISC, et sont trs rares chez les processeurs RISC.

O stocker le rsultat ?
De plus, notre partie variable peut aussi prciser o stocker le rsultat de l'instruction. Cela peut tre un registre, une adresse mmoire, ou sur la pile. Comme pour la partie variable charge de localiser les oprandes d'une instruction, il existe diffrents modes d'adressage permettant de dterminer l'adresse ou la place laquelle le rsultat doit tre enregistr.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

82/378

O stocker le rsultat de l'instruction

Contenu de la seconde partie variable La partie variable prcise dans quel registre stocker le rsultat. La partie variable contient directement l'adresse de la cellule mmoire dans laquelle on devra stocker le rsultat. Dans ce cas, la partie variable ne prcise rien ! Certaines instructions n'ont pas besoin qu'on leur dise o enregistrer leur rsultat. Par exemple, ce serait le cas pour une instruction devant retourner son rsultat au sommet de la pile : on connait d'avance l'adresse du sommet de la pile. Dans ce cas, l'adresse laquelle on veut crire est place dans un registre. La partie variable doit donc prciser le registre voulu. Mais elle doit aussi prciser que ce registre n'est pas l'endroit dans lequel on veut stocker le rsultat, et que son contenu est l'adresse mmoire laquelle on veut crire le rsultat. Le contenu du registre sera alors plac sur le bus d'adresse..

Registre Adresse mmoire Implicite Adresse stocke dans un registre

Longueur d'une instruction

V ous l'avez vu, une instruction possde une certaine longueur. Sur les processeurs CISC, cette longueur est variable. Cela permet de gagner un peu de mmoire. Avoir des instructions qui font entre 2 et 3 octet est plus avantageux que de tout mettre sur 3 octets. Il faut dire que les processeurs CISC ont beaucoup d'instructions, ce qui fait que l'opcode de chaque instruction est assez long et prend de la mmoire. Avoir des instructions de longueur variable permet de limiter fortement la casse, voir mme d'inverser la tendance. La taille de l'instruction dpend aussi du mode d'adressage : la taille d'une oprande varie suivant sa nature (une adresse, une constante, quelques bits pour spcifier un registre, voire rien). Sur les processeurs RISC, cette longueur est gnralement fixe. L'opcode prend peu de place : il y a peu d'instructions diffrentes coder, donc l'opcode est plus court, sans compter le peu de modes d'adressages possibles : on utilise souvent des modes d'adressage permettant d'avoir des oprandes petites. On prfre simplifier le tout et utiliser des instructions de taille fixe. Cela permet au processeur de calculer plus facilement ladresse de l'instruction suivante en faisant une simple addition.

Classes d'architectures
Tous ces modes d'adressage ne sont pas supports par tous les processeurs ! En fait, il existe plusieurs types d'architectures, dfinies par leurs modes d'adressages possibles. Certaines ne supportent pas certains modes d'adressage. Et pour s'y reprer, on a dcider de classifier un peu tout a. V donc ces diffrents types d'architectures. oici

A accumulateur unique
Ces processeurs possdent un registre unique pour stocker des donnes : l'accumulateur. Dans ce cas, les donnes sur lesquelles s'excutent les instructions sont stockes dans l'accumulateur ou dans la mmoire principale. Les oprandes d'une instruction ne peuvent tre que des adresses mmoires ou des constantes (l'accumulateur tant adress implicitement). Cela autorise seulement trois modes d'adressage : immdiat ; implicite ; direct. L'accumulateur est localis grce au mode d'adressage implicite : il n'y a qu'un seul registre dans le processeur, pas besoin de le spcifier dans certains cas. De plus, le rsultat des instructions arithmtiques et logiques est stock dans l'accumulateur, et on n'a pas besoin de prciser o stocker le rsultat : pas de mode d'adressage pour le rsultat. Ces architectures sont parfois appeles architectures 1-adresse.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

83/378

Architectures registre-mmoire
C'est la mme chose que l'architecture accumulateur, mais cette fois, le processeur peut aussi contenir plusieurs autres registres gnraux qui peuvent servir stocker pleins de donnes diverses et varies. Le processeur peut donc utiliser plusieurs registres pour stocker des informations (gnralement des rsultats de calcul intermdiaires), au lieu d'aller charger ou stocker ces donnes dans la mmoire principale. Les oprandes peuvent donc tre des adresses mmoires, des constantes et des noms de registres. Cela autorise tous les modes d'adressage : immdiat ; implicite ; inhrent ; direct ; indirect registre.

Mnmonique

Nom registre

Nom registre

adresse mmoire

ADD (Addition) EAX - registre de donnes EDX - registre de donnes 01000000000011100

Ces architectures registres gnraux (ainsi que les architectures Load-store qu'on verra juste aprs) sont elles-mme divises en deux sous-classes bien distinctes : les architectures 2 adresses et les architectures 3 adresses. Cette distinction entre architecture 2 et 3 adresses permet de distinguer les modes d'adressages des oprations arithmtiques manipulant deux donnes : additions, multiplications, soustraction, division, etc. Ces instructions ont donc besoin d'adresser deux donnes diffrentes, et de stocker le rsultat quelque part. Il leur faut donc prciser trois oprandes dans le rsultat : la localisation des deux donnes manipuler, et l'endroit o ranger le rsultat.

Architectures 2 adresse
Sur les architectures deux adresses, l'instruction possde seulement deux oprandes pour les donnes manipuler, l'endroit o ranger le rsultat tant adress implicitement. Plus prcisment, le rsultat sera stock au mme endroit que la premire donne qu'on manipule : cette donne sera remplace par le rsultat de l'instruction. Mnmonique Oprande 1 Oprande 2

DIV (Division) Dividende / Rsultat Diviseur

Avec cette organisation, les instructions sont plus courtes. Mais elle est moins souple, vu que l'une des donnes utilise est crase : si on a encore besoin de cette donne aprs lexcution de notre instruction, on est oblig de copier cette donne dans un autre registre et faire travailler notre instruction sur une copie.

Architectures 3 adresse
Sur les architectures trois adresses, l'instruction possde trois oprandes : deux pour les donnes manipuler, et une pour le rsultat. Mnmonique Oprande 1 Oprande 2 Oprande 3 DIV Dividende Diviseur Rsultat

Les instructions de ce genre sont assez longues, mais on peut prciser quel endroit ranger le rsultat. On n'est ainsi pas oblig d'craser une des deux donnes manipules dans certains cas, et stocker le rsultat de l'instruction dans un registre inutilis, prfrer craser une autre donne qui ne sera pas rutilise, etc. Ce genre d'architecture permet une meilleure utilisation des registres, ce qui est souvent un avantage. Mais par contre, les instructions deviennent trs longues, ce qui peut devenir un vrai problme. Sans compter que devoir grer trois modes d'adressages (un par oprande) au lieu de deux risque d'tre assez couteux en circuits et en transistors : un circuit aussi complexe sera plus lent et coutera cher. Et ces dsavantages sont souvent assez ennuyeux.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

84/378

Load-store
Cette fois, la diffrence n'est pas au niveau du nombre de registres. Dans cette architecture, toutes les instructions arithmtiques et logiques ne peuvent aller chercher leurs donnes que dans des registres du processeurs. Seules les instructions load et store peuvent accder la mmoire. load permet de copier le contenu d'une (ou plusieurs) adresse mmoire dans un registre, tandis que store copie en mmoire le contenu d'un registre. load et store sont des instructions qui prennent comme oprande le nom d'un registre et une adresse mmoire. Mnmonique LOAD Nom registre Adresse mmoire

MTX - registre de donnes 01010111111111

Ces instructions peuvent aussi utiliser l'adressage indirect registre, ce qui fait que l'adresse laquelle accder est stocke dans un registre. Elles peuvent donc utiliser deux modes d'adressage. Mnmonique LOAD Nom registre Adresse mmoire

MTX - registre de donnes ATX - registre stockant l'adresse laquelle lire

Toutes les autres instructions n'accdent pas directement la mmoire. En consquence, ces instructions ne peuvent prendre que des noms de registres ou des constantes comme oprandes. Cela autorise les modes d'adressage suivants : immdiat ; registre ; indirect registre.

Mnmonique ADD

Nom registre

Nom registre

MTN - registre de donnes MTX - registre de donnes

Il faut noter aussi que les architectures Load-store sont elles aussi classes en architectures 2 ou 3 adresses. Tous les processeurs RISC invents ce jour sont bass sur une architecture Load-store.

A pile
Cette fois-ci, c'est encore pire : pas de registres stockant de donnes : les instructions n'accdent qu' la mmoire principale. Nanmoins, les registres d'instruction, pointeurs d'instruction, et les registres utiliss pour manipuler la pile existent toujours : seuls les registres qui contiennent des donnes et les registres gnraux disparaissent. Ces processeurs implmentent une pile, et crivent donc tous leurs rsultats en mmoire RAM. Et oui, vous ne vous tes pas tromps : il s'agit bien de nos bonnes vielles machines pile, vues il y a quelques chapitres. Les instructions arithmtiques et logiques de ces processeurs vont donc manipuler des donnes prsentes au sommet de la pile. Ces instructions vont donc dpiler un certain nombre d'oprandes (1 ,2 voire 3), et vont stocker le rsultat au sommet de la pile. Le truc, c'est qu'il faut bien stocker ces oprandes dans la pile et conserver le rsultat. Pour cela, ces processeurs disposent d'instructions spcialises pour pouvoir empiler une donne au sommet de la pile : push ; et une instruction pour dpiler la donne au sommet de la pile et la sauvegarder en mmoire : pop. Les instructions push et pop prennent une adresse mmoire comme oprande. Cette adresse spcifie l'adresse de la donne charger pour push et l'adresse laquelle sauvegarder le sommet de la pile pour pop. L'instruction push peut ventuellement empiler une constante, et utilise dans ce cas le mode d'adressage immdiat. Mnmonique PUSH Adresse mmoire 0000 1111 0101 1100

Le sommet de la pile est adress de faon implicite. Toutes les instructions arithmtiques et logiques utilisent le mode

www.siteduzero.com

Partie 3 : Processeur et Assembleur

85/378

d'adressage implicite : le sommet de la pile est toujours connu (son adresse est stocke dans un registre ddi et on n'a donc pas besoin de la prciser par un mode d'adressage). Mnmonique MUL (multiplication)

Sur ces processeurs, la mmoire utilise par le programme est trs faible. Toutes les instructions arithmtiques et logiques sont adresses en adressage implicite, et se contentent d'une opcode, sans utiliser de mmoire pour les oprandes. Sur un ordinateur qui n'est pas bas sur une architecture pile, on aurait d prciser la localisation des donnes en ajoutant une partie variable l'opcode de l'instruction, augmentant ainsi la quantit de mmoire utilise pour stocker celle-ci.

Machines pile 1 et 2 adresses

Dans ce que je viens de dire au-dessus, les machine pile que je viens de dcrire ne pouvait pas manipuler autre chose que des donnes places sur la pile : ces machines pile sont ce qu'on appelle des machines zro adresse. Toutefois, certaines machines pile autorisent certaines instructions pouvoir, si besoin est, prciser l'adresse mmoire d'une (voire plusieurs dans certains cas) de leurs oprandes. Ainsi, leurs instructions peuvent soit manipuler des donnes places sur la pile, soit une donne place sur la pile et une donne qui n'est pas sur la pile, mais dans la mmoire RAM. Ces machines sont appeles des machines pile une adresse.

A accs mmoire strict

Dans cette architecture ci, il n'y a pas de registres gnraux : les instructions n'accdent qu' la mmoire principale. Nanmoins, les registres d'instruction et pointeur d'instruction existent toujours. Les seules oprandes possibles pour ces processeurs sont des adresses mmoire, ce qui fait qu'un mode d'adressage est trs utilis : l'adressage direct. Mnmonique Adresse mmoire Adresse mmoire DIV 010010111111110 010000000001110

Ce genre d'architectures est aujourd'hui tomb en dsutude depuis que la mmoire est devenue trs lente compar au processeur.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

86/378

Un peu de programmation !
Notre processeur va excuter des programmes, fabriqus l'aide de ce qu'on appelle un langage de programmation. Ces langages de programmations sont des langages qui permettent un humain de programmer plus ou moins facilement un ordinateur pour que celui-ci fasse ce qu'on veut. Ces langages de programmations ont influencs de faon notable les jeux d'instructions des processeurs modernes : de nombreux processeurs implmentent des instructions spcialement conues pour faciliter la traduction des "briques de base" de certains langages de programmation en une suite d'instructions machines. Ces fameuses "briques de base" sont ce que l'on appelle les structures de contrle. Autant prvenir tout de suite : j'ai fait en sorte que mme quelqu'un qui ne sait pas programmer puisse comprendre cette partie. Ceux qui savent dj programmer auront quand mme intrt lire ce chapitre : il leur permettra de savoir ce qui se passe quand leur ordinateur excute du code. De plus, ce chapitre expliquera beaucoup de notions concernant les branchements et les instructions de test, survoles au chapitre prcdent, qui serviront plus tard quand on abordera la prdiction de branchement et d'autres trucs du mme acabit. Et c'est sans compter que vous allez apprendre des choses intressantes, comme l'utilit de la pile dans les architectures actuelles.

C'est un ordre, xecution !

On va commencer ce chapitre par quelques rappels. V ous savez dj qu'un programme est une suite d'instructions stocke dans la mmoire programme. Lorsqu'on allume le processeur, celui-ci charge automatiquement la premire instruction du programme : il est conu pour. Puis, il va passer l'instruction suivante et l'excuter. Notre processeur poursuivra ainsi de suite, en passant automatiquement l'instruction suivante, et excutera les instructions du programme les unes aprs les autres. Il fera ainsi jusqu' la dernire instruction de notre programme. Celle-ci est souvent une instruction qui permet de stopper l'excution du programme au point o il en est (du moins si le programme ne boucle pas indfiniment). Cette fameuse instruction d'arrt est souvent excute par le programme, histoire de dire : "j'ai fini" ! Ou alors pour dire : "j'ai plant !" . Certains processeurs modernes fonctionnent d'une manire lgrement diffrente de ce qu'on vient de voir. Par exemple, ils peuvent xecuter plusieurs instructions la fois, ou peuvent excuter les instructions d'un programme dans un ordre diffrent de celui impos par notre programme. On verra cela plus tard, dans la suite du tutoriel. Qui plus est, il existe une classe de processeurs un peu spciaux, qui n'utilise pas de registre d'adresse d'instruction et nexcute pas vraiment les instructions dans l'ordre impos par un programme qui demanderait de les excuter unes par unes, en srie : il s'agit des fameuses architectures dataflow !

Passage l'instruction suivante

Il est vident que pour xecuter une suite d'instructions dans le bon ordre, notre ordinateur doit savoir quelle est la prochaine instruction excuter. Il faut donc que notre processeur se souvienne de cette information quelque part : notre processeur doit donc contenir une mmoire qui stocke cette information. C'est le rle du registre d'adresse d'instruction, aussi appel Program Counter. Ce registre stocke l'adresse de la prochaine instruction excuter. Cette adresse permet de localiser l'instruction suivante en mmoire. Cette adresse ne sort pas de nulle part : on peut la dduire de l'adresse de l'instruction en cours dexcution par divers moyens plus ou moins simples qu'on verra dans la suite de ce tutoriel.

Program Counter
Ce calcul peut tre fait assez simplement. Gnralement, on profite du fait que ces instructions sont excutes dans un ordre bien prcis, les unes aprs les autres. Sur la grosse majorit des ordinateur, celles-ci sont places les unes la suite des autres dans l'ordre o elles doivent tre excutes. L'ordre en question est dcid par le programmeur. Un programme informatique n'est donc qu'une vulgaire suite d'instructions stocke quelque part dans la mmoire de notre ordinateur. Par exemple : Adresse 0 1 2 3 4 ... Instruction Charger le contenu de l'adresse 0F05 Charger le contenu de l'adresse 0555 Additionner ces deux nombres Charger le contenu de l'adresse 0555 Faire en XOR avec le rsultat antrieur ...

www.siteduzero.com

Partie 3 : Processeur et Assembleur

5464 Instruction d'arrt

87/378

En faisant ainsi, on peut calculer facilement l'adresse de la prochaine instruction en ajoutant la longueur de l'instruction juste charge (le nombre de case mmoire qu'elle occupe) au contenu du registre d'adresse d'instruction. Dans ce cas, l'adresse de la prochaine instruction est calcule par un petit circuit combinatoire coupl notre registre d'adresse d'instruction, qu'on appelle le compteur ordinal.

Les exceptions
Mais certains processeurs n'utilisent pas cette mthode. Mais il s'agit de processeurs particulirement rares. Sur de tels processeurs, chaque instruction va devoir prciser o est la prochaine instruction. Pour ce faire, une partie de la suite de bits reprsentant notre instruction xecuter va stocker cette adresse.

Dans ce cas, ces processeurs utilisent toujours un registre pour stocker cette adresse, mais ne possdent pas de compteur ordinal, et n'ont pas besoin de calculer une adresse qui leur est fournie sur un plateau.

Et que ca saute !
En gros, un processeur est sacrment stupide s'il ne fait qu'excuter des instructions dans l'ordre. Certains processeurs ne savent pas faire autre chose, comme le Harvard Mark I, et il est difficile, voire impossible, de coder certains programmes sur de tels ordinateurs. Mais rassurez-vous : on peut faire mieux ! Il existe un moyen permettant au processeur de faire des choses plus volues et de pouvoir plus ou moins s'adapter aux circonstances au lieu de ragir machinalement. Pour rendre notre ordinateur "plus intelligent", on peut par exemple souhaiter que celui-ci n'excute une suite d'instructions que si une certaine condition est remplie. Ou faire mieux : on peut demander notre ordinateur de rpter une suite d'instructions tant qu'une condition bien dfinie est respecte. Diverses structures de contrle de ce type ont donc ts inventes. V les plus utilises et les plus courantes : ce sont celles oici qui reviennent de faon rcurrente dans un grand nombre de langages de programmation actuels. On peut bien sur en inventer dautres, en spcialisant certaines structures de contrle des cas un peu plus particuliers ou en combinant plusieurs de ces structures de contrles de base, mais cela dpasse le cadre de ce tutoriel : ce tutoriel ne va pas vous apprendre programmer. Nom de la structure de contrle SI...ALORS SI...ALORS...SINON Boucle WHILE...DO Boucle DO...WHILE aussi appele REPEAT UNTIL Boucle FOR Ce qu'elle fait excute une suite d'instructions si une condition est respecte excute une suite d'instructions si une condition est respecte ou excute une autre suite d'instructions si elle ne l'est pas. rpte une suite d'instructions tant qu'une condition est respecte. rpte une suite d'instructions tant qu'une condition est respecte. La diffrence, c'est que la boucle DO...WHILE excute au moins une fois cette suite d'instructions. rpte un nombre fix de fois une suite d'instructions.

Concevoir un programme (dans certaines langages de programmation), c'est simplement crer une suite d'instructions, et utiliser ces fameuses structures de contrle pour l'organiser. D'ailleurs, ceux qui savent dj programmer auront reconnu ces fameuses structures de contrle. Reste adapter notre ordinateur pour que celui-ci puisse supporter ces fameuses structures. Et pour cela, il suffit simplement de rajouter quelques instructions. Pour que notre ordinateur puisse excuter ces structures de contrle basiques, il utilise : des instructions de test, qui vrifient si une condition est respecte ou pas ; et les instructions de saut ou branchements.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

88/378

Instructions de test
Ces instructions sont des instructions assez simples : elles permettent de comparer deux valeurs. Elles permettent gnralement de comparer des nombres entiers. Mais certains processeurs fournissent des instructions pour comparer des nombres virgule flottante, des caractres, ou des donnes plus complexes. Ces instructions permettent souvent d'effectuer les comparaisons suivantes : A < B (est-ce que A est suprieur B ?) ; A > B (est-ce que A est infrieur B ?) ; A == B (est-ce que A est gal B ?) ; A != B (est-ce que A est diffrent de B ?. Ces instructions dites de test ou de comparaison vont chacune fournir un rsultat qui est cod sur un bit, qui permettra de dire si la condition teste est vraie ou fausse. Dans la majorit des cas, ce bit vaut 1 si la condition teste est vraie, et 0 sinon. Dans de rares cas, c'est l'inverse. Bien sur, ce bit de rsultat n'est pas plac n'importe o : notre processeur incorpore un registre spcialis, qui stocke ces rsultats des comparaisons, ces bits. Il s'agit du registre d'tat. Ce registre d'tat est un registre, qui ne stocke pas de donnes comme des nombres entiers, ou des nombres flottants, mais stocke des bits individuels. Chacun de ces bits a une signification propre, prdtermine lors de la conception du processeur. Le bit du registre d'tat qui est modifi par une instruction de test dpendent de l'instruction utilise. Par exemple, on peut utiliser un bit qui indiquera si l'entier test est gal un autre, un autre bit qui indiquera si le premier entier test est suprieur gal l'autre, etc. Il arrive que certaines de ces instructions de test effectuent plusieurs comparaisons en mme temps et fournissent plusieurs rsultats : l'instruction de test modifie plusieurs bits du registre d'tat en une seule fois. Par exemple, un processeur peut trs bien possder une instruction cmp capable de vrifier si deux valeurs A et B sont gales, diffrentes, si A est infrieure B, et si A est suprieur B, en mme temps.

l'exception qui confirme la rgle

Ces instructions de test peuvent parfois tre remplaces par des instructions arithmtiques. Ce registre d'tat ne sert pas que pour les comparaisons. Les bits qu'il contient peuvent servir autre chose : on peut utiliser un bit pour indiquer si le rsultat d'une opration arithmtique est gal ou non zro, un autre pour indiquer si ce rsultat est ngatif ou non, encore un autre pour savoir si le rsultat est pair ou impair, etc. Et pour cela, certaines instructions arithmtiques vont modifier ces bits du registre d'tat. Ainsi, nos instructions arithmtiques peuvent ainsi remplacer une instruction de test : elles positionnant des bits du registre d'tat, suivant une condition (rsultat gal zro, ngatif, etc). Par exemple, prenons le cas d'un processeur qui possde une instruction machine permettant d'effectuer une soustraction ; et qui possde un bit nomm NULL dans le registre d'tat qui vaut 1 si le rsultat d'une opration est nul, et qui vaut 0 sinon. Il est parfaitement possible que l'instruction de soustraction puisse mettre jour ce bit NULL. Dans ce cas, on peut tester si deux nombres sont gaux en soustrayant leur contenu : si les deux registres contiennent la mme valeur, le bit Null correspondant au registre dans lequel on stocke le rsultat sera positionn 1 et on saura si la condition est remplie. D'autres bits peuvent tre modifis suivant le signe du rsultat ou d'autres facteurs (une ventuelle retenue, par exemple). Cela permet de dterminer si la valeur soustraite est suprieure ou infrieure la valeur l'autre valeur. D'ailleurs, sur certains processeurs, l'instruction cmp (mentionne plus haut) n'est qu'une soustraction dguise dans un opcode diffrent (il faut aussi prciser que le rsultat de la soustraction n'est pas sauvegard dans un registre ou en mmoire et est simplement perdu). C'est le cas sur certains processeurs ARM ou sur les processeurs x86.

Branchements
Quoiqu'il en soit, ces instructions de test ne permettent pas de crer des structures de contrle elles seules. Elles doivent imprativement tre combines avec d'autres instructions spciales, qu'on appelle des branchements. Ces branchements sont des instructions qui modifient la valeur stocke dans le registre d'adresse d'instruction. Elles permettent de sauter directement une instruction autre que l'instruction immdiatement suivante et poursuivre l'excution partir de cette instruction. Cela permet au programme de passer directement une instruction situe plus loin dans le droulement normal du programme, voire de revenir une instruction antrieure, plutt que d'excuter les instructions dans

www.siteduzero.com

Partie 3 : Processeur et Assembleur

l'ordre. Il existe deux types de branchements.

89/378

Les branchements inconditionnels : le processeur passe toujours l'instruction vers laquelle le branchement va renvoyer. Les branchements conditionnels. L'instruction de branchement n'est excute que si certains bits du registre d'tat sont une certaine valeur (qui peut aussi bien 0 que 1 suivant l'instruction de branchement utilise). Les branchements conditionnels sont souvent prcds d'une instruction de test ou de comparaison qui va modifier un ou plusieurs des bits du registre d'tat. C'est souvent ainsi qu'on va fabriquer nos structures de contrle. Sur certains processeurs, certains branchements conditionnels sont un peu plus malins : ils peuvent permettre d'effectuer le test et le branchement en une seule instruction machine. Si on rflchit bien, les instructions de test sont toujours couples avec des branchements conditionnels et ne servent jamais seules. Pareil pour les branchements conditionnels, qui sont presque toujours prcdes d'une instruction de test (sauf dans le cas o on utilise des instructions arithmtiques en remplacement du test, ce qui peut tre utile dans certaines situations). Dans ce cas, pourquoi utiliser deux instructions, une pour le test, et une pour le branchement ? Autant utiliser une seule instruction qui effectue le test et le branchement ! Cela permet de se passer des instructions de test et du registre d'tat. Pas besoin d'ajouter une ou plusieurs instructions de test dans le jeu d'instruction de notre processeur. Cette mthode n'est toutefois pas utilise sur tous les processeurs : tous n'ont pas de branchements conditionnels de ce type. Il faut dire que dans certains cas, cela peut servir d'avoir des instructions de test et de branchement spares : pour grer les overflow (un rsultat d'instruction trop grand pour tenir dans un registre), par exemple. Gnralement, les anciens processeurs CISC utilisent des instructions de test et de branchements spares, tandis que les processeurs RISC effectuent test et branchement dans une seule instruction. A l'inverse, certains processeurs sont un peu plus extrmes, mais dans l'autre sens : ils se passent totalement de branchements conditionnels et ils mulent d'une faon assez particulire. Sur ces processeurs, les instructions de test sont un peu spciales : si la condition teste par l'instruction est fausse, elle vont simplement zapper l'instruction immdiatement suivante. On peut ainsi crer l'quivalent d'un branchement conditionnel avec une instruction de test suivie d'un branchement inconditionnel. Chacune de ces trois mthodes a ses avantages et ses inconvnients, qu'on abordera pas ici. Je peux juste vous dire que la mthode fusionnant les instructions de tests et de branchement permet de se passer de registre d'tat et d'avoir un programme plus petit (on utilise une seule instruction au lieu de deux). Par contre, la mthode avec instructions de tests et branchements conditionnels spars permet de mieux grer des overflows ou certaines conditions plus efficacement : une instruction arithmtique peut positionner un bit du registre d'tat pour guider un branchement (on l'a vu dans le paragraphe "l'exception qui confirme la rgle"). Mais je marrterais l : sachez juste qu'il existe d'autres avantages et dsavantages sur les processeurs modernes suivant la mthode utilise : ces trois mthodes interagissant plus ou moins bien avec les dernires technologies rcentes implantes dans nos processeurs (pipeline, OOO, etc).

Modes d'adressage
Ces branchements peuvent avoir trois modes d'adressages : direct, par offset, indirect registre. Dans le premier cas, l'oprande est simplement l'adresse de l'instruction laquelle on souhaite reprendre. Mnmonique JMP Oprande Adresse mmoire

Dans le second cas, l'oprande est un nombre. Il suffit d'ajouter ce nombre l'adresse dj prsente dans le registre d'adresse d'instruction pour tomber sur l'adresse voulue. On appelle ce nombre un dcalage ou offset. De tels branchements sont appels des branchements relatifs. Mnmonique Oprande JMP Dcalage

www.siteduzero.com

Partie 3 : Processeur et Assembleur

Les branchements bass sur des dcalages permettent de localiser un branchement par rapport l'instruction en cours dexcution : par exemple, cela permet de dire "le branchement est 50 instructions plus loin".

90/378

Ce genre de branchement facilite la cration de programmes qui se moquent compltement de l'adresse laquelle on les charge en mmoire. Sur certains ordinateurs capables dexcuter plusieurs programmes "en mme temps", un programme n'est presque jamais charg en mmoire au mme endroit et l'adresse de chaque branchement (ou de n'importe quoi d'autre d'ailleurs) change chaque excution du programme. Par dfaut, les branchements qui ne sont pas des branchements relatifs considrent que le programme commence l'adresse zro et localisent leurs instructions partir de la premire adresse d'un programme. Pour localiser l'adresse de destination (l'adresse vers laquelle le branchement va faire reprendre le processeur), on est alors plus ou moins oblig de la calculer lexcution du programme, partir de l'adresse de base du programme, en effectuant une addition. On est donc oblig de conserver l'adresse de la premire instruction du programme dans un registre pour reprer un branchement. Les branchements relatifs ne sont pas concerns par ce genre de problme : ceux-ci ne reprent pas l'adresse de destination du branchement par rapport l'adresse de dbut du programme, mais par rapport l'adresse laquelle est place le branchement, contenue dans le registre d'adresse d'instruction. Pas besoin d'utiliser un autre registre supplmentaire, ou de corriger les adresses lexcution. Ces deux types de branchements sont ce qu'on appelle des branchements directs : l'adresse vers laquelle il faut brancher est constante et ne peut en aucun cas varier au cours de l'excution d'un programme (sauf cas particuliers utilisant du Selfmodifying code). Il existe un dernier mode d'adressage pour les branchements : l'adresse vers laquelle on veut brancher est stocke dans un registre. L'oprande du branchement est donc un registre. Mnmonique JMP Oprande Nom d'un registre

Avec de tels branchements, l'adresse vers laquelle on souhaite brancher peut varier au cours de lexcution du programme. On appelle de tels branchements des branchements indirects. Ce genre de branchement peut tre utilis pour fabriquer la structure de contrle Switch, voque plus haut, dans certaines conditions. Ce genre de branchements est souvent camoufl dans certaines fonctionnalits offertes par certains langages de programmation (pointeurs sur fonction, chargement dynamique de DLL, etc) et il n'est pas si rare d'en utiliser sans en avoir conscience.

Structures de contrle, tests et boucles

Maintenant que l'on a appris ce qu'taient les branchements et les tests, on va voir comment faire pour fabriquer nos fameuses structures de contrle avec. Bien sr, on ne va pas aller trs loin : juste voir ce qu'il faut pour comprendre la suite du tutoriel. Par exemple, ce qu'on va voir sera assez utile lorsqu'on tudiera la prdiction de branchement.

Le Si...Alors
Implmenter un simple Si...Alors est assez intuitif : il suffit de tester la condition, et de prendre une dcision suivant le rsultat du branchement. V ce que cela peut donner : oici

www.siteduzero.com

Partie 3 : Processeur et Assembleur

91/378

Avec cette organisation, on utilise un branchement tel que si la condition teste soie vraie, alors on poursuit lexcution sans reprendre la suite du programme : on excute alors la suite d'instruction du Si...Alors, avant de reprendre la suite du programme. Dans le cas o la condition teste est fausse, on reprend directement la suite du programme, sans xecuter la suite d'instruction du Si...Alors. Et a marche ! Enfin presque, i y a un problme : comment faire pour que le branchement conditionnel puisse faire ce qu'on lui demande ? Et oui, j'ai dit plus haut qu'un branchement est excute quand la condition teste est vraie, valide, et pas autrement. Pour cela il y a, deux solutions. La premire solution est assez intuitive : il suffit de tester la condition inverse celle ncessaire pour faire excuter notre suite d'instruction de la structure de contrle Si...Alors. Pour la seconde solution, quelques explications s'imposent. Comme je l'ai dit plus haut, notre branchement va sexcuter si certains bits du registre d'tat sont placs une certaine valeur. Sur certains processeurs, il peut exister des branchements diffrents qui vrifient le mme bit du registre d'tat. Seul diffrence : ces branchements sexcutent pour des valeurs diffrentes de ce bit. Ainsi, pour chaque test possible, il existe un branchement qui sexcute quand une condition est valide, et un autre qui sexcute quand la condition n'est pas valide. Il suffit de choisir un branchement qui sexcute quand une condition teste n'est pas valide pour viter d'avoir inverser le test.

Si...Alors...Sinon
Cette structure de contrle sert effectuer un traitement diffrent selon que la condition est respecte ou non : si la condition est respecte, on effectue une suite d'instruction ; tandis que si elle ne l'est pas, on effectue une autre suite d'instruction diffrente. C'est une sorte de Si...Alors contenant un second cas. Pour implmenter cette structure de contrle, on peut donc amliorer le Si...Alors vu plus haut. La seule diffrence, c'est l'endroit vers lequel le branchement conditionnel va nous envoyer. L'astuce est de placer les deux suites d'instructions les unes aprs les autres. Le branchement conditionnel enverra sur la suite excuter quand la condition voulue par le programmeur n'est pas ralise. Dans le cas contraire, on poursuit lexcution du programme aprs le branchement et on retombe sur le cas du Si...Alors.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

92/378

Pour viter dexcuter les deux suites les unes aprs les autres, on place un branchement inconditionnel la fin de la suite d'instruction excuter quand la solution est vraie. Ce branchement renverra sur la suite du programme. Je tiens signaler qu'on est pas limit seulement deux suites dinstructions : on peut imbriquer des structures de contrle Si...Alors...Sinon les unes dans les autres, si le besoin s'en fait sentir. Dans ce cas, il faut bien penser mettre un branchement inconditionnel branchant sur la suite du programme aprs chaque suite d'instruction (sauf la dernire, qui est immdiatement suivie par la suite du programme).

Boucles
V oyons maintenant comment un CPU fait pour excuter une boucle. Pour rappel, une boucle consiste rpter une suite d'instructions CPU tant qu'une condition est valide (ou fausse). En gros, les boucles peuvent tre vues comme des variantes de la structure de contrle Si...Alors. Plutt que de reprendre l'excution du programme aprs la suite d'instructions excute quand la condition est valide (cas du Si...Alors), on reprend l'excution du programme l'instruction de test. Histoire de rpter les instructions dj excutes.

Boucle Do...While

www.siteduzero.com

Partie 3 : Processeur et Assembleur

93/378

Je vais tout d'abord commencer par la boucle la plus simple qui soit : la boucle Do...While. Dans la boucle Do...While, on souhaite que la suite d'instructions soit rpte tant qu'une certaine condition est vrifie, et qu'en plus, elle soit excute au moins une fois ! Pour cela, la suite d'instructions excuter est place avant les instructions de test et de branchement.

En faisant ainsi, notre suite d'instruction est excute une fois, avant de rencontrer une instruction de test qui va tester la condition de la boucle. Si jamais la condition teste est vrifie (valide), alors notre branchement va renvoyer notre processeur vers la premire instruction de la suite d'instruction rpter. Si jamais la condition teste est fausse, on passe tout simplement la suite du programme. Si on regarde bien, c'est bien le comportement qu'on attend d'une boucle Do...While.

While...Do, le retour !
Une boucle While...Do est identique une boucle Do...While un dtail prt : la suite d'instruction de la boucle n'a pas forcment besoin d'tre excute. On peut trs bien ne pas rentrer dans la boucle dans certaines situations. On peut donc adapter une boucle Do...While pour en faire une boucle While...Do : il suffit de tester si notre boucle doit tre excute au moins une fois, et excuter une boucle Do...While quivalente si c'est le cas. Si la boucle ne doit pas tre excute, on poursuit partir de la suite du programme directement. Et pour cela, il suffit de placer une instruction qui teste si on doit renter dans la boucle, accouple un branchement qui renvoie sur la suite du programme si jamais on n rentre pas dans la boucle.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

94/378

Boucle FOR
Une boucle For n'est qu'une boucle While...Do un peu spciale. Aucune diffrence particulire dans la faon de crer une boucle for et une boucle While...Do n'existe dans la faon dont notre ordinateur excute la boucle : c'est seulement ce qui est test qui change et rien d'autre.

Sous-programmes : c'est fait en quoi une fonction ?

Ceux qui ont dj faits de la programmation ont dj certainement vus le concept de fonctions, quelque soit le langage qu'ils aient vus. On va ici expliquer ce qu'est une fonction, du point de vue du processeur ! Mais tout d'abord, on va clarifier un point de vocabulaire : on ne dira plus fonction, mais sous-programme ! Pour expliquer ce qu'est un sous-programme, il faut d'abord savoir quoi a sert. Car les sous-programmes sont des inventions qui rpondent des besoins bien prcis : conomiser de la mmoire et grandement faciliter la vie du programmeur !

A quoi a sert ?
Lorsque vous crez un programme, le rsultat sera une grosse suite d'instructions codes en langage machine, avec des 0 et des 1 partout : c'est une horreur ! Et parmi cette gigantesque suite d'instructions, il y a souvent des "sous-suites", des paquets d'instructions qui reviennent rgulirement et qui sont prsents en plusieurs exemplaires dans le programme final. Ces soussuites servent quasiment toujours excuter une tache bien prcise et ont presque toujours une signification importante pour le programmeur. Par exemple, il va exister une de ces sous-suite qui va servir calculer un rsultat bien prcis, communiquer avec un priphrique, crire un fichier sur le disque dur, ou autre chose encore.

Sans sous-programmes

www.siteduzero.com

Partie 3 : Processeur et Assembleur

95/378

Sans utiliser de sous-programmes, ces suites d'instructions sont prsentes en plusieurs exemplaires dans le programme. Le programmeur doit donc recopier chaque fois ces suites d'instructions, ce qui ne lui facilite pas la tache (sauf en utilisant lanctre des sous-programmes : les macros). Et dans certains programmes, devoir recopier plusieurs fois la squence d'instruction qui permet d'agir sur un priphrique ou de faire une action spciale est franchement barbant ! De plus, ces suites d'instructions sont prsentes plusieurs fois dans le programme final, excut par l'ordinateur. Et elles prennent de la place inutilement !

On a donc cherch un moyen qui ferait que ces suites d'instructions soient prsentes une seule fois dans le programme et utilisables au besoin. On a donc invent les sous-programmes.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

96/378

Avec les sous-programmes

La technique du sous-programme consiste ne mettre qu'un seul exemplaire de ces suites d'instructions. Cet exemplaire plac dans la mmoire, un peu cot du programme "principal". On appellera cette suite d'instruction un sous-programme. En effet, un programme est une suite d'instruction. Donc, cette suite d'instructions peut tre vue comme tant un programme que le programme principal excutera au besoin. C'est au programmeur de "slectionner" ces suites d'instructions qui apparaissent de faon rpte dans le programme, et d'en faire des sous-programmes. Lorsqu'on a besoin d'excuter ce sous-programme, il suffira d'excuter une instruction de branchement qui pointera vers la premire instruction de ce sous-programme. Sur certains processeurs, cette instruction de branchement est une instruction un peu spciale qui ne se contente pas d'envoyer le processeur sur la premire instruction du sous-programme, comme nous allons le voir. On appelle cette instruction une instruction d'appel de fonction.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

97/378

Retour vers la future (instruction) !

Logiquement, cette suite d'instructions apparait plusieurs fois dans notre programme. Comment savoir quelle instruction reprendre l'excution de notre programme, une fois notre sous-programme termin ?

La solution : sauvegarder l'adresse de l'instruction laquelle il faut reprendre ! Notre programme doit donc reprendre l'instruction qui est juste aprs le branchement qui pointe vers notre sous-programme. Pour cela, on doit sauvegarder cette adresse appele l'adresse de retour.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

Cette sauvegarde peut tre faite de deux manires :

98/378

soit le processeur possde une instruction spciale, capable de sauvegarder l'adresse de retour et de brancher vers le sous-programme voulu en une seule instruction ; soit on doit muler cette instruction avec une instruction qui sauvegarde l'adresse de retour, suivie d'un branchement inconditionnel qui pointera vers notre sous-programme. Pour le premier cas, cette instruction spciale, capable de sauvegarder automatiquement l'adresse de retour et de brancher vers le sous-programme voulu n'est rien d'autre que notre fameuse instruction d'appel de fonction vue plus haut.

Reprenons l o on en tait
Une fois le sous-programme fini, il suffit de charger l'adresse de retour dans le registre pointeur d'instruction pour reprendre lexcution de notre programme principal l o il s'tait arrt pour laisser la place au sous-programme. L encore, deux solutions sont possibles pour faire cela. Sur certains processeurs, cela est fait par l'instruction situe la fin du sous-programme, qu'on nomme instruction de retour. C'est un branchement inconditionnel. Cette instruction a pour mode d'adressage, l'adressage implicite (l'adresse vers laquelle brancher est place au sommet de la pile, pas besoin de la prciser). Sur d'autres, cette instruction spciale n'existe pas et il faut encore une fois l'muler avec les moyens du bord. L'astuce consiste souvent charger l'adresse de retour dans un registre et utiliser un branchement inconditionnel vers cette adresse.

Pile de sauvegarde des adresses de retour

Pour pouvoir excuter plusieurs sous-programmes imbriqus (un sous-programme contient dans sa suite d'instructions un branchement vers un autre sous-programme), on permet de sauvegarder plusieurs adresses de retour : une par sous-programme. chaque fin de sous-programme, on est oblig de choisir quelle est la bonne adresse de retour parmi toutes celles qui ont ts sauvegardes. Pour cela, on a encore une fois deux solutions diffrentes. Avec la premire solution, les adresses de retour sont stockes dans la pile. Lorsque l'on appelle un sous-programme, l'adresse de retour est sauvegarde au sommet de la pile, au-dessus de toute les autres. Ce stockage des adresses de retour utilisant la pile permet de toujours retourner la bonne adresse de retour. Bien sr, il y a une limite aux nombres de stack frame qu'on peut crer dans la pile. Et donc, un nombre maximal de sous-programmes imbriqus les uns dans les autres. Nanmoins, certains processeurs ne peuvent pas grer de pile en mmoire RAM, et doivent donc trouver un moyen d'muler cette pile d'adresse de retour sans utiliser de pile. La solution, est d'incorporer dans le processeur des registres spcialiss, organiss en pile, dont le but est de conserver l'adresse de retour. Ainsi, chaque appel de sous-programme, l'adresse de retour sera stocke dans un de ces registres pour tre conserve. Certains processeurs utilisent un mlange des deux solutions : une partie des adresses de retour (celles sauvegardes le plus rcemment) est conserve dans les registres du processeur pour plus de rapidit, et le reste est sauvegard dans la pile.

Paramtres et arguments
Notre sous-programme va parfois modifier des donnes en mmoire RAM. Cela peut poser problme dans certains cas : on peut avoir besoin de conserver les anciennes donnes manipules par le sous-programme. Pour cela, le sous-programme va devoir manipuler une copie de ces donnes pour que notre sous-programme puisse les manipuler loisir. Ces copies seront appeles des arguments ou encore des paramtres. Ces paramtres sont choisis par le programmeur qui cre le sous-programme en question. Une des solutions ce problme est d'utiliser la pile, encore une fois. Vu que notre pile est une simple portion de la mmoire RAM, on peut stocker ce qu'on veut dans une stack frame, et pas seulement une adresse de retour. On va donc, dans certains cas, copier les donnes manipuler dans la pile. C'est ce qu'on appelle le passage par la pile. On peut aussi stocker directement les arguments dans les registres du processeur si ils sont peu nombreux, sans avoir utiliser la pile. Comme cela, le processeur pourra les manipuler directement sans devoir les charger depuis la RAM ou les stocker dans le cache. C'est le passage par registre. Suivant le langage de programmation, le compilateur, le systme d'exploitation ou le processeur utilis, les sous-programmes utiliseront soit le passage par la pile, soit le passage par registre, ou encore un mlange des deux.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

99/378

Une histoire de registres

Enfin, pour terminer, la pile va aussi servir stocker le contenu de l'ensemble des registres du processeur tels qu'ils taient avant qu'on excute notre sous-programme. En effet, lorsqu'un sous-programme s'excute, il va utiliser certains registres, qui sont souvent dj utiliss par le programme. Pour viter de remplacer le contenu des registres par une valeur calcule-alloue par notre sous-programme, on doit donc conserver une copie de ceux-ci dans la pile. Une fois que le sous-programme a finit de s'excuter, on remet les registres dans leur tat original, en remettant leur sauvegarde depuis la pile, dans les registres adquats. Ce qui fait que lorsqu'un sous-programme a fini son excution, tous les registres du processeur sont reviennent leur ancienne valeur : celle qu'ils avaient avant que le sous-programme ne s'excute. Rien n'est effac ! Bien videmment, plus un processeur a de registres architecturaux (des registres qui ont un nom et sont manipulables par des instructions), plus cette sauvegarde de registre prend du temps. Si les processeurs CISC sont pargns avec leur faible nombre de registres, ce n'est pas le cas des processeurs RISC. Ceux-ci contiennent un grand nombre de registres et sauvegarder ceux-ci prend du temps. Quand aux machines piles pures, elles sont tranquilles : il n'y a pas de registres sauvegarder, hormis le registre pointeur d'interruption. Autant vous dire que sur ces machines pile, les appels de sous-programmes sont supers rapides.

Fentrage de registres
Quoiqu'il en soit, excuter un sous-programme prend du temps : il faut sauvegarder l'adresse de retour, empiler les arguments, empiler une copie des registres du processeur, etc. Pour limiter le temps mit grer la sauvegarde des registres, certains processeurs utilisent une petite astuce assez sympa nomme le fentrage de registres. Les processeurs utilisant le fentrage de registres possdent des registres supplmentaires cachs, invisibles pour le programmeur. Par exemple, si notre processeur possde 8 registres architecturaux, (ce sont des registres qui possdent un nom et qui sont donc manipulables par notre programme), alors le fentrage de registre impose la prsence de 2, 3, 4, 8 fois plus de registres. Lensemble des registres rellement prsent dans notre processeur s'appelle le register file. Dans le cas du fentrage de registre, seule une petite partie du register file peut tre manipulable par un programme ou un sous-programme : on appelle cette partie une fentre de registre. Ces fentres ont toute la mme taille, et contiennent autant de registres qu'il y a de registres architecturaux. Prenons un exemple : un processeur dont le jeu d'instruction contient 3 registres architecturaux, et qui contient en ralit 12 registres. Ces 12 registres sont regroups dans des paquets, des fentres de 3 registres : cela nous fait donc 4 fentres diffrentes.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

100/378

Lorsque notre programme sexcute, il va utiliser 3 registres en tout : une fentre sera donc utilis par notre programme principal. Si un sous-programme veut sexcuter, notre processeur va faire en sorte que notre sous-programme utilise une fentre (un paquet) de registres inutilise : pas besoin de sauvegarder les 3 registres principaux, vu que notre sous-programme ne les utilisera pas et manipulera 3 registres diffrents appartenant une autre fentre ! Bien sr, cela fonctionne pour chaque sous-programme qui cherche sexcuter : on lui attribue une fentre de registres vierge, inutilise, qu'il pourra utiliser loisir, au lieu d'utiliser une fentre dj prise. videmment, cela ne marche que s'il reste une fentre inutilise. Dans le cas contraire, on est oblig de sauvegarder les registres d'une fentre dans la pile. Avec notre exemple 4 fentres, on peut donc excuter un programme, et 3 sous-programmes imbriqus. Au fait : vous avez remarqu ? Un sous-programme est cens manipuler des registres architecturaux, mais utilisera en fait des registres cachs, localiss dans une autre fentre. Le fait est que chaque registre architectural est prsent en plusieurs exemplaires, un dans chaque fentre. Ainsi, deux registres placs dans des fentres diffrentes peuvent avoir le mme nom. Lorsqu'un sous-programme sexcute, il manipulera le registre architectural localis dans la fentre qui lui a t attribue. On voit bien que les registres utilisables en assembleur sont diffrents des registres rellement prsent dans le processeur. Et ce n'est pas la seule situation dans laquelle certains registres architecturaux seront prsents en double, comme on le verra dans la suite du tutoriel.

Valeur de retour
Un sous-programme peut parfois servir calculer un rsultat, et qu'il faut bien fournir ce rsultat quelque part. On pourra donc le rcuprer pour faire quelque chose avec. Gnralement, c'est le programmeur qui dcide de conserver une donne. Celui-ci peut avoir besoin de conserver le rsultat d'un calcul pour pouvoir l'utiliser plus tard, par exemple. Ce rsultat dpend fortement du sous-programme, et peut tre n'importe quelle donne : nombre entier, nombre flottant, tableau, objet, ou pire encore. Cette donne est appele la valeur de retour du sous-programme. Cette donne, aprs avoir t "calcule" par le sous-programme, devra tre conserve quelque part : calculer une valeur de retour

www.siteduzero.com

Partie 3 : Processeur et Assembleur

101/378

pour l'effacer serait stupide, non ? Dans certains langages (ou suivant le compilateur), tous les registres du processeur sont remis leur valeur originelle lorsqu'un sous-programme se termine. Il va de soit que l'on ne peut pas stocker cette valeur de retour dans un registre : elle serait crase lors de la restauration des registres. Sans compter que cette valeur ne tient pas toujours dans un registre : un registre contenant 64 bits pourra difficilement contenir une valeur de retour de 5 kilo-octets. Une des solutions possible consiste sauvegarder la valeur de retour sur la pile. Ainsi, la valeur de retour est prsente au sommet de la pile et peut tre utilise si besoin. J'ai dit plus haut que tous les registres du processeur sont restaurs lors du retour d'un sous-programme. Sauf que cela dpend des langages et des compilateurs : certains grent les registres de faon ne pas remettre tous les registres leur valeur d'origine immdiatement. Cela permet de conserver une valeur de retour dans les registres, ds que possible. Suivant la taille de la valeur de retour, diverses mthodes sont envoyes pour conserver celle-ci. on peut conserver une valeur de retour quand elle est capable de tenir dans les registres du processeur : une valeur de retour peut prendre un ou plusieurs registres elle toute seule, tout dpend de ce qu'on veut sauvegarder ; on peut aussi de sauvegarder la valeur de retour dans la mmoire RAM ou dans la pile, et conserver l'adresse de l'endroit dans lequel la valeur de retour est localise en mmoire dans un registre. On peut aussi inventer dautres solutions (ne l'oubliez pas), mais les deux solutions cites plus haut sont les plus simples expliquer.

Variables automatiques
Un sous-programme doit gnralement manipuler des donnes temporaires qui lui permettent de faire ce qu'on lui demande. Ces donnes sont des donnes internes au sous-programme, que lui seul doit manipuler et qui ne doivent gnralement pas tre accessibles dautres programmes ou sous-programmes. Dans certains langages de programmation, on appelle ces variables des variables locales. Une solution pour grer ces variables pourrait consister rserver une portion de la mmoire chaque sous-programme, spcialement ddie au stockage de ces variables. Mais cela prendrait trop de mmoire, et rserver dfinitivement de la mmoire pour stocker des donnes temporaires de faon occasionnelle serait du gchis. Sans compter le cas dans lequel un sousprogramme s'appelle lui-mme : il vaut mieux que ces appels de sous-programmes aient des donnes places dans des emplacements mmoires bien spars, pour viter des catastrophes. Pour cela, ces donnes sont cres pendant l'excution du sous-programme, restent en mmoire tant que le sous-programme s'excute, et sont effaces ds que le sous-programme termine. La solution consiste rserver une partie d'une stack frame pour stocker ces donnes durant l'excution du sous-programme. En effet, quand on dpile une stack frame la fin de lexcution d'un sous-programme, le contenu de celle-ci est compltement perdu. On appelle de telles donnes temporaires, stockes sur la pile des variables automatiques. On peut aussi stocker ces donnes internes que le sous-programme doit manipuler dans les registres du processeur, si elles sont peu nombreuses. Comme cela, le processeur pourra les manipuler directement sans devoir les charger depuis la RAM ou les stocker dans le cache. Pour manipuler ces variables automatiques, ainsi que les arguments/paramtres, notre processeur dispose parfois de modes d'adressages spcialiss, qui permettent de slectionner une donne dans une Stack Frame. Gnralement, ces modes d'adressage permettent d'ajouter une constante l'adresse du dbut de la Stack Frame (cette adresse tant stocke dans un registre).

Plusieurs piles
Certains processeurs ne possdent qu'une seule pile dans laquelle un programme mettra la fois les adresses de retour, les variables locales, les paramtres, et le reste des informations ncessaires pour excuter notre sous-programme sans accros. Nanmoins, certaines processeurs sont plus malins et possdent deux ou plusieurs piles, chacune tant spcialise : on peut ainsi avoir une pile pour le adresses de retour, et une autre pour les paramtres et les variables locales. Certains processeurs possdent carrment trois piles : une pour les adresses de retour, une pour les paramtres, et une pour les variables locales. Cela permet d'viter de recopier les arguments ou les variables locales d'un sous-programme sur la pile pour les passer un autre sous-programme si besoin est. Cela permet d'implmenter certains sous-programmes de faon plus efficace.

Tableaux
V ous vous souvenez que dans le chapitre prcdent, j'avais dit que certains modes d'adressage permettaient de faciliter la programmation en assembleur ?

Et bien ce n'tait pas des paroles en l'air. J'avais beaucoup cit le cas des tableaux. Alors autant vous montrer en quoi ces modes

www.siteduzero.com

Partie 3 : Processeur et Assembleur

dadressage permettent une manipulation des tableaux plus aise.

102/378

Comment sont implments les tableaux ?

Un tableau est quelque chose de simple : c'est un ensemble de donnes de mme taille ranges les unes la suite des autres en mmoire. Premire chose : chaque donne (on dit aussi lment) d'un tableau prend un nombre d'octets fix une fois pour toute. Cela a son importance, comme on va le voir. Gnralement, une donne prend entre 1, 2, 4, 8 octets : ce sont des nombres qui sont une puissance de deux. Cela a son importance dans ce qui va suivre. De ce que l'on vient de dire, on dduit facilement que la quantit de mmoire occupe par un tableau est gale au produit de son nombre dlments par la taille d'un lment. Deuxime chose, ces donnes sont ranges les unes cot des autres en mmoire : on ne laisse pas le moindre vide. Les unes cot des autre signifie dans des adresses mmoires conscutives.

Exemple avec un tableau d'entiers prenant chacun 8 octets.

Calcul d'adresse
Stocker des donnes dans un tableau ne sert rien si on ne peut pas les rcuprer. Pour cela, on peut slectionner un lment d'un tableau et le manipuler comme on le souhaite. Chaque lment d'un tableau reoit un nombre, un indice, qui dtermine sa place dans le tableau : llment d'indice 0 est celui qui est plac au dbut du tableau, celui d'indice 1 est celui qui le suit immdiatement aprs dans la mmoire, etc. Le processeur doit connaitre l'adresse de llment qu'on veut lire ou crire pour y accder. On doit donc calculer son adresse partir de l'indice et d'autres informations. Pour cela, on utilise le fait que les lments d'un tableau ont une taille fixe et sont rangs dans des adresses mmoires conscutives. Prenons un exemple : un tableau d'entiers, prenant chacun 4 octets. Le premier lment d'indice zro est plac l'adresse : c'est l'adresse laquelle commence le tableau en mmoire. Le second lment est plac 4 octets aprs (vu que le premier lment prend 4 octets) : son adresse est donc . Le second lment est plac 4 octets aprs le premier lment, ce qui donne l'adresse . Si vous continuez ce petit jeu pour quelques valeurs, on obtiendrait quelque chose dans le genre : Indice i Adresse de l'lment

www.siteduzero.com

Partie 3 : Processeur et Assembleur

0 1 2 3 4 5 ... A A+4 A+8 A+12 A+16 A+20 ...

103/378

V ous remarquerez surement quelque chose sur l'adresse de l'lment d'indice i, si vous vous souvenez que l'entier de notre exemple fait 4 octets. Indice i Adresse de l'lment 0 1 2 3 4 5 ... A + (0 * 4) A + (1 * 4) A + (2 * 4) A + (3 * 4) A + (4 * 4) A + (5 * 4) ...

On peut formaliser cette remarque mathmatiquement en posant la longueur d'un lment du tableau, l'indice de cet lment, et l'adresse de dbut du tableau (l'adresse de llment d'indice zro). l'adresse de llment d'indice vaut toujours .

On peut ainsi dduire l'adresse d'un lment d'un tableau par une formule simple : notre adresse peut donc tre calcule ! Mais a nous avance quoi de savoir a ?

Et bien tous les modes d'adressage permettant de faciliter la manipulations des tableaux permettent de faciliter le calcul de cette adresse. Certains permettent mme de faciliter l'implmentation des tableaux, en permettant de placer un tableau n'importe o en mmoire, et de pouvoir calculer les adresses des lments de ce tableau sans problmes. C'est autant de choses que le programmeur n'a plus faire la main. Remarquons une chose : les lments d'un tableau prennent souvent 1, 2, 4, 8 octets, et 1, 2, 4 et 8 sont des puissances de 2. Dans notre calcul d'adresse, on doit donc souvent multiplier l'indice i par une puissance de 2, ce qui peut tre remplac par une instruction de dcalage : une multiplication par est quivalente une instruction de dcalage de rangs vers la gauche. A quoi sert ? Et bien il faut juste savoir que les instructions de dcalages sont trs souvent bien plus rapides que des multiplications, ce qui permet de calculer l'adresse de notre lment bien plus rapidement !

Autrefois
Au dbut de l'informatique, les processeurs ne possdaient pas d'instructions ou de modes d'adressages pour grer les tableaux. On pouvait quand mme grer ceux-ci, mais d'une manire vraiment crade, en utilisant l'adressage direct. Mais cela requrait l'utilisation de self-modifying code, c'est dire que le programme devait contenir des instructions qui devaient lire certaines instructions et en modifier le contenu avant de les excuter ! En clair, le programme devait se modifier tout

www.siteduzero.com

Partie 3 : Processeur et Assembleur

104/378

seul pour faire ce qu'il faut. Mais on ne va pas en parler plus, c'est tellement lourd, moche, compliqu, rpugnant et stupide qu'on ne va pas en parler dans ce chapitre : le self-modifying code (une des plus belles chose qui existe en assembleur) mrite nettement mieux que ce genre d'exemple !

Indexed absolute
Le premier mode d'adressage permet de calculer l'adresse d'un lment d'un tableau sans avoir effectuer de multiplications/dcalages et d'additions : l'instruction calcule elle-mme l'adresse quand on lexcute. Notre processeur doit donc contenir des circuits capables d'effectuer du calcul d'adresse. En soit, rien de plus simple : il suffit de crer des circuits capables de faire des additions et des dcalages en une fois. Rien de bien sorcier ! Ce mode d'adressage a besoin de deux oprandes, places dans la partie variable de notre instruction : une adresse mmoire, et un registre qui contient l'indice du tableau. Ce registre est nomm le registre d'index. Adresse mmoire Registre d'index

Adresse de dbut du tableau Indice de llment slectionn

On remarque une chose : l'adresse est stocke telle qu'elle dans l'instruction. On ne peut pas modifier celle-ci, et le tableau est toujours plac au mme endroit dans la mmoire de notre ordinateur. Il s'agit d'un tableau statique : il est de taille fixe, et est impossible supprimer. On ne peut pas dcider de placer notre tableau en mmoire o l'on souhaite, ni le supprimer de la mmoire pour rcuprer la mmoire qu'il occupe quand on en a plus besoin. En clair, ce tableau prend de la mmoire une fois pour toute, ce qui peut mener un gros gchis de mmoire.

Register indirect
Il serait nettement mieux de pouvoir stocker un tableau n'importe o en mmoire et de pouvoir rcuprer la mmoire qu'il utilise quand il ne nous sert plus. Au lieu de rserver la mmoire pour le tableau en permanence, on peut la rserver lexcution et mettre le tableau o l'on veut en mmoire, avant de librer celle-ci. Cette rservation peut tre faite en plaant le tableau sur la pile, ou en utilisant des fonctionnalits avances d'un systme d'exploitation pour le mettre dans le tas (souvenez vous du chapitre "Registres ou pile", et n'hsitez pas lire le chapitre sur l'allocation mmoire de mon tutoriel sur les OS : systmes d'exploitation). L'adresse du tableau varie lexcution d'un programme. Difficile pour cela d'utiliser le mode d'adressage Indexed absolute, avec lequel l'adresse de dbut du tableau est une constante impossible modifier durant lexcution (sauf cas pathologiques incluant l'utilisation de self-modifying code). Pour implmenter de tels tableaux, on a invent le mode d'adressage indirect registre. Avec ce mode d'adressage, il suffit de placer l'adresse de llment du tableau auquel on veut accder dans un registre. Le mode d'adressage copiera cette adresse sur le bus d'adresse pour y accder. On peut ainsi implmenter des tableaux relocalisables plus facilement. Seul problme : on doit conserver l'adresse de dbut du tableau quelque part si on veut accder plusieurs lments. De plus, le calcul d'adresse n'est pas fait par l'instruction, mais doit tre fait la main : on doit utiliser des instructions arithmtiques pour manipuler l'adresse de llment du tableau et se taper du calcul dadresse explicite. Pour corriger cela, certains processeurs implmentent des instructions de calculs d'adresse qui peuvent faire un dcalage et une addition en une seule fois : LEA sur x86, par exemple. Mais il nempche que l'accs d'un lment d'un tableau est effectu en plusieurs instructions, au lieu d'une seule. Au fait : certains processeurs implmentent des instructions capables de vrifier si les indices des tableaux sont corrects. Cela permet de vrifier qu'on ne "dborde pas" du tableau, en calculant par erreur une adresse en dehors du tableau, cause d'un indice erron par exemple. Accder llment 25 d'un tableau de seulement 5 lment n'a pas de sens et est souvent signe d'une erreur. Aussi, il existe des instructions capables de vrifier si un entier (l'indice) dpasse d'indice maximal autoris, et qui effectuent un branchement automatique si l'indice n'est pas correct. L'instruction BOUND sur le jeu d'instruction x86 en est un exemple. Ce mode d'adressage existe aussi avec une variante : l'instruction peut augmenter ou diminuer de 1 le contenu du registre stockant l'adresse de llment du tableau automatiquement. Cela permet de passer directement l'adresse suivante ou prcdente, ce qui est utile quand on veut passer llment suivant ou prcdent dans un tableau.

Base plus index

Pour viter d'avoir calculer les adresses la main avec le mode d'adressage register indirect, on a invent un mode d'adressage

www.siteduzero.com

Partie 3 : Processeur et Assembleur

pour combler ce manque : le mode d'adressage Base plus index.

105/378

Ce mode d'adressage spcifie deux registres dans sa partie variable : une registre qui contient l'adresse de dpart du tableau en mmoire : le registre de base ; et un qui contient l'indice : le registre d'index. Registre de base Registre d'index

Adresse de dbut du tableau Indice de llment slectionn

Suivant l'instruction utilise, le processeur dtermine tout seul la valeur du type utiliser. Gnralement, quelques bits dans l'opcode spcifient la taille de llment manipul. Ce mode d'adressage possde aussi une variante qui permet de vrifier qu'on ne "dborde pas" du tableau, en calculant par erreur une adresse en dehors du tableau, cause d'un indice erron, par exemple. Pour cela, l'instruction peut prendre deux oprandes supplmentaires (qui peuvent tre constantes ou places dans deux registres). Et voil, nous avons commenc effleurer les diffrentes instructions et autres dtails architecturaux qui ont permis d'adapter nos processeurs aux langages de haut niveau dits procduraux. Alors certes, a semble assez bas niveau et ne semble peut-tre pas vraiment convainquant, mais le matriel peut aller beaucoup haut dans l'abstraction : il existe des processeurs capables de grer nativement des langages fonctionnels ! Ce sont les architectures dataflow, que j'ai cites plus haut. Un bel exemple pour moi n'est autre que les machines LISP : ces machines possdaient de quoi excuter nativement certaines primitives du langages LISP, un langage fonctionnel. Comme autres exemples, certains processeurs implmentent directement dans leur circuits de quoi traiter la programmation objet : ils supportent l'hritage, des structures de donnes spciales, des appels de donnes diffrents suivant que les fonctions appeles soient dans le mme module/classe que l'appelant, et pleins d'autres choses. Comme quoi, l'imagination des constructeurs d'ordinateurs a de quoi surprendre ! Ne sous-estimez jamais les constructeurs dordinateurs.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

106/378

Les circuits d'une unit de calcul

Aprs avoir vu l'architecture extrieure d'un processeur, on va pousser le vice dans ses deniers retranchements et descendre au niveau des circuits. Comme vous le savez surement, les circuits de base de notre ordinateur sont fabriqus en transistors et en portes logiques. Fabriquer ces circuits de base n'est pas une mince affaire et les constructeurs de processeurs, ainsi que des chercheurs en arithmtique des ordinateurs, travaillent d'arrache-pied pour trouver des moyens de rendre nos circuits plus rapides et plus conomes en nergie. Il me sera donc difficile de vous montrer des circuits rellement prsents dans nos processeurs. Mais je peux au moins vous montrer quelques circuits simplifis qu'on trouvait autrefois dans des processeurs simples. Nous allons donc commencer par voir des circuits permettant d'effectuer des additions, des multiplications, des divisions, des dcalages, et des soustractions. Tous ces circuits sont des circuits combinatoires, c'est dire qu'ils donnent toujours le mme rsultat pour des entres identiques. En quelque sorte, ils n'ont pas de mmoire. Une mthode simple pour crer ces circuits consisterait utiliser les mthodes vue dans les premiers chapitres de ce tutoriel, mais cela serait possible uniquement pour des circuits devant manipuler des nombres trs petits. A la place, nous allons devoir ruser...

Dcalages et rotations
On va commencer par les circuits capables dexcuter des instructions de dcalage et de rotation. On en a trs brivement parl dans les chapitres prcdents, mais vous ne savez peut-tre pas ce qu'elles font. Vu la situation, une petite explication sur ces instructions ne fera pas de mal.

Dcalages et rotations
Il existe plusieurs types de dcalages, dont deux vont nous intresser particulirement : les dcalages logiques, et les dcalages arithmtiques.

Logical shift
Le dcalage logique, aussi appel logical shift, est le dcalage le plus simple comprendre. Effectuer un dcalage logique sur un nombre consiste simplement dcaler tout ses chiffres d'un ou plusieurs crans vers la gauche ou la droite. Exemple avec un dcalage d'un cran.

Comme vous le voyez, vu que nos nombres sont de taille fixe, certains bits sortent du nombre. Pour le dcalage droite, c'est le bit de poids faible qui sort du nombre, tandis que pour le dcalage gauche,c'est le bit de poids fort qui est perdu. On remarque aussi que certains bits du rsultat sont "vides" : ils ne peuvent pas tre dduits de la valeur du nombre dcaler. Ces vides sont remplis par des zros.

Grce ce remplissage par des zros, un dcalage vers la gauche d'un rang est quivalent une multiplication par 2 pour des entiers non-signs ou pour des entiers signs positifs. Mme chose pour le dcalage vers la droite qui revient diviser un

www.siteduzero.com

Partie 3 : Processeur et Assembleur

nombre entier par 2. Avec des nombres signs, ce n'est pas le cas : on obtient un rsultat qui n'a pas grand sens mathmatiquement.

107/378

De mme, pour des entiers non-signs ou positifs, on peut gnraliser avec un dcalage de rangs vers la droite/gauche : un tel dcalage correspond une multiplication ou division entire par . Cette proprit est souvent utilise par certains compilateurs, qui prfrent utiliser des instructions de dcalages (qui sont des instructions trs rapides) la place d'instructions de multiplication ou de division qui ont une vitesse qui va de moyenne (multiplication) particulirement lente (division). Il faut remarquer un petit dtail : lorsqu'on effectue une division par - un dcalage droite -, certains bits de notre nombre vont sortir du rsultat et tre perdus. Cela a une consquence : le rsultat est tronqu ou arrondi. Plus prcisment, le rsultat d'un dcalage droite de rangs sera gal la partie entire du rsultat de la division par .

Arithmetical shift
Pour pouvoir effectuer des divisons par sur des nombres ngatifs en utilisant un dcalage, on invent les dcalages arithmtiques ou arithmtical shift. Ces dcalages sont similaires aux logical shift, un dtail prt : pour les dcalages droite, le bit de signe de notre nombre n'est pas modifi, et on remplit les vides laisss par le dcalage avec le bit de signe.

Ces instructions sont quivalentes une multiplication/division par , que le nombre soit sign ou non, un dtail prt : l'arrondi n'est pas fait de la mme faon pour les nombres positifs et ngatifs. Cela pose un problme avec les nombres cods en complment deux (ceux cods en complment un ne sont pas concerns). Pour les nombres positifs ou nuls, un arithmtical shift donne toujours le mme rsultat qu'un logical shift et on n'a pas de problme : le rsultat est arrondi vers zro quelque soit le dcalage. Mais la situation change pour les nombres ngatifs qui sont arrondis vers moins l'infini. Pour donner un exemple, sera arrondi en , tandis que sera arrondi en .

Cela peut poser quelques problmes et donner des rsultats faux dans certaines situations. Pour viter tout problme, on peut corriger le rsultat en faisant quelques manipulations sur le rsultat, en utilisant quelques instructions suplmentaires. Mais cela reste au minimum 6 26 fois plus rapide que d'effectuer la division par un circuit capable d'effectuer des divisions sur les processeurs actuels.

Rotations
Les instructions de rotation sont similaires aux logical shift, part que les bits qui sortent du nombre d'un cot rentrent de l'autre et servent boucher les trous.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

108/378

Multiplexeurs
Pour commencer, les circuits capables d'effectuer des dcalages et des rotations sont fabriqus avec des composants lectroniques qu'on appelle des multiplexeurs, aussi appels des MUX. Un multiplexeur possde plusieurs entres et une sortie. Par plusieurs entres, on veut dire que suivant le multiplexeur, le nombre dentres peut varier. Le rle d'un multiplexeur est de recopier le contenu d'une des entres sur sa sortie. Bien sr, il faut bien choisir l'entre qu'on veut recopier sur la sortie : pour cela, notre multiplexeur contient une entre de commande qui permet de spcifier quelle entre doit tre recopie. Dans la suite de ce chapitre, on ne va utiliser que des multiplexeurs qui possdent deux entres et une sortie. Aprs tout, nous travaillons en binaire, n'est-ce pas.

La table de vrit d'un multiplexeur est assez simple, comme vous pourrez en juger. Dans ce qui suit, on prendra nommera les deux entres du multiplexeur E1 et E2, sa sortie S, et son entre de commande C. En supposant que si l'entre de commande 1 va slectionner l'entre 1 (et donc que si l'entre de commande est 0, c'est l'entre 2 qui est slectionne), on obtient la table de vrit suivante :

Entre C Entre E1 Entre E2 0 0 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1

Sortie S 0 0 1 1 0 1 0 1

En utilisant la mthode vue au chapitre 3, on arrive alors trouver l'quation logique suivante : Cela nous donne donc le circuit suivant :

www.siteduzero.com

Partie 3 : Processeur et Assembleur

109/378

Sachez toutefois que les multiplexeurs utiliss dans nos ordinateurs ne sont pas forcment fabriqus avec des portes logiques. Ils sont fabriqus directement avec des transistors, afin de grappiller quelques prcieux transistors.

Dcaleur logique
V oyons maintenant comment crer un dcaleur simple vers la droite. Ce dcaleur va pouvoir dcaler un nombre, vers la droite, d'un nombre de rang variable. En effet, on pourra dcaler notre nombre de 2 rangs, de 3 rangs, de 4 rangs, etc. Comment grer ce nombre de rangs variables ?

Tout d'abord, il faudra prciser ce nombre de rangs duquel on veut dcaler notre circuit. Celui-ci devra donc comporter des entres pour spcifier de combien on veut dcaler notre nombre. Reste savoir comment crer notre circuit. Ensuite, on peut faire une remarque simple : dcaler vers la droite de 6 rangs, c'est quivalent dcaler notre nombre vers la droite de 4 rangs, et re-dcaler le tout de 2 rangs. Mme chose pour 7 rangs : cela consiste dcaler de 4 rangs, re-dcaler de 2 rangs et enfin re-dcaler d'un rang. En suivant notre ide jusqu'au bout, on se rend compte qu'on peut crer un dcaleur partir de dcaleur plus simples, relis en cascade, qu'il suffira d'activer ou dsactiver suivant la valeur du nombre de rangs qu'il faut dcaler.

Dcaleur lmentaire
Pour se faciliter la vie, on va partir de circuit capables de dcaler un nombre de 1, 2, 4, etc, rangs, et qu'on peut activer ou dsactiver la demande. On va prendre comme exemple un dcaleur par 4, pour se simplifier la vie. Mais ce que je vais dire pourra tre adapt pour crer des dcaleurs par 1, par 2, par 8, etc. Commenons par dcrire le comportement de ce dcaleur. Celui-ci prend en entre un nombre dcaler (ici, ce sera un nombre de 8 bits qu'on nommera A). Sa sortie vaudra : soit le nombre tel qu'il est pass en entre (le dcaleur est inactif), soit le nombre dcal de 4 rangs. Ainsi, si je prend un nombre A, compos des bits a7, a6, a5, a4, a3, a2, a1, a0 ; (cits dans l'ordre), mon rsultat sera : soit le nombre compos des chiffres a7, a6, a5, a4, a3, a2, a1, a0 : on n'effectue pas de dcalage ; soit le nombre compos des chiffres 0, 0, 0, 0, a7, a6, a5, a4 : on effectue un dcalage par 4. On voit donc qu'il existe deux choix possibles pour chaque bit de sortie : par exemple, le bit de poids fort peut prend deux valeurs : soit 0, soit a7. Pareil pour le 4me bit en partant de la droite du rsultat : celui-ci vaut soit a7, soit a3. On se retrouve donc avec deux choix pour chaque bit de sortie, qu'on doit slectionner au besoin. Je ne sais pas si vous avez remarqu, mais c'est exactement ce que va faire notre multiplexeur : il va choisir deux entres possibles et en recopier une sur sa sortie en fonction de son entre de commande. Il nous suffira donc dutiliser des multiplexeurs pour effectuer ce choix du bit mettre en sortie.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

110/378

Par exemple, pour le choix du bit de poids faible du rsultat, celui-ci vaut soit a7, soit 0 : il suffit dutiliser un multiplexeur prenant le bit a7 sur son entre 1, et un 0 sur son entre 0. Il suffira de rgler le multiplexeur pour choisir le bon bit. Reste faire la mme chose pour tous les autres bits, et le tour est jou. V ous devriez avoir compris le principe et tes maintenant censs pouvoir crer un dcaleur tout seul, en faisant la mme chose pour les bits qui restent. V le rsultat. oici

Bien sr, on peut faire la mme chose pour des dcalages par 2, 3, 4, et autres. Pour se simplifier la vie, nous allons utiliser des dcalages par des puissances de deux. a aura une grande utilit, comme nous allons le voir plus tard. Ainsi, nous allons aussi utiliser un dcaleur par 2 et par 1. Leur construction est identique celle effectue pour notre dcaleur par 4, aussi je vais me contenter de vous donner simplement le rsultat. Dcaleur par 2

Dcaleur par 1

Le dcaleur complet
Maintenant qu'on a cre suffisamment de dcaleurs lmentaires, on va devoir fusionner tout cela dans un seul grand circuit. La seule chose qui nous reste faire, c'est relier les dcaleurs par 4, 2, 1, etc ; entre eux, et les commander correctement. Pour les

www.siteduzero.com

Partie 3 : Processeur et Assembleur

111/378

relier, rien de plus simple il suffit de les placer en srie les uns la suite des autres. Pour savoir quels dcaleurs activer et quels dcaleurs doivent conserver leurs entres telles quelles, on va devoir ruser. Pour cela, on va devoir jouer sur le fait que nos dcaleurs lmentaires vont dcaler par 1, 2, 4, 8, 16, etc, bits : bref, ceux-ci doivent dcaler d'un nombre de rangs qui est une puissance de deux. Cela nous permettra de simplifier fortement la conception de notre dcaleur complet. Le nombre de rangs par lequel on va devoir dcaler est un nombre, qui est videmment stock en binaire dans notre ordinateur. Celui s'crit donc sous la forme d'une somme de puissances de deux (relisez le premier chapitre si vous avez oubli). Vu que l'on possde des circuits dcaleurs par des rangs qui sont aussi des puissances de deux, on peut donc utiliser la mthode suivante : chaque bit de ce nombre servira actionner le dcaleur qui dplace d'un nombre de rangs gal la valeur du bit.

Par actionner le dcaleur, on veut dire positionner le bit de commande de chaque multiplexeur l'intrieur du dcaleur par 1, 2, 4, etc ; 1 afin de configurer celui-ci de faon ce qu'il fasse ce qu'il faut.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

112/378

Mine de rien, notre circuit commence tre un peu charg...

Dcaleur arithmtique
Un dcaleur arithmtique peut tre cre de la mme faon. Plus intressant, on peut modifier le schma vu au-dessus pour lui permettre d'effectuer des dcalages arithmtiques en plus des dcalages logiques. Il suffit simplement d'ajouter un ou plusieurs multiplexeurs pour chaque dcaleur lmentaire par 1, 2, 4, etc. Il suffit simplement que ce ou ces multiplexeurs choisisse quoi envoyer sur l'entre de l'ancienne couche : soit un 0 (dcalage logique), soit le bit de signe (dcalage arithmtique). Exemple avec un dcaleur par 4

Ou encore avec un seul multiplexeur, mais plus de fils. Exemple avec un dcaleur par 4

www.siteduzero.com

Partie 3 : Processeur et Assembleur

113/378

Rotateur
Et ce qui peut tre fait pour le dcalage arithmtique peut aussi l'tre pour les rotations. On peut transformer notre circuit en circuit encore plus gnraliste, capable de faire des rotations en plus des dcalages en rajoutant quelques multiplexeurs pour choisir les bits envoyer sur les entres des dcaleurs. Par exemple, on peut rajouter une couche de multiplexeurs pour faire en sorte que notre dcaleurs par 4 puisse faire la fois des dcalages par 4 et des rotations par 4. Pour cela, il suffit de choisir quoi mettre sur les 4 bits de poids fort. Si c'est un dcalage par 4, notre circuit devra mettre ces bits de poids fort 0, tandis qu'il devra recopier les 4 bits de poids faible si c'est une rotation. Pour choisir entre un zro ou le bit voulu du nombre d'entre, il suffit de rajouter des multiplexeurs.

Bien videmment, on peut faire la mme chose pour les rotateurs par 2, 1 , etc. Et ainsi obtenir de quoi effectuer des rotations en plus des dcalages.

Barell shifter
Avec tout ce qui a t dit plus haut, on est donc arriv crer un circuit capable d'effectuer aussi bien des rotations que des dcalages : ce fameux circuit s'appelle un barrel shifter, et est utilis dans certains processeurs modernes, dans une version un peu plus amliore. Il existe d'autres types de Barrel shifter qu'on a pas voqus dans ce chapitre : ce sont les mask barrel shifter. Pour ceux qui sont intresss, voici un peu de documentation sur ces dcaleurs un peu spciaux : Mask Barrel Shifters.

Addition
V oyons maintenant un circuit capable d'additionner deux nombres : l'additionneur. Dans la version qu'on va voir, ce circuit manipulera des nombres strictement positifs ou des nombres cods en compltement deux.

Demi-additionneur
Pour effectuer notre addition, tout repose sur l'addition de deux bits et d'une ventuelle retenue. Aussi, tous nos additionneurs sont, par facilit, ou cause de contraintes techniques, constitus d'un assemblage de petits circuits de base capables

www.siteduzero.com

Partie 3 : Processeur et Assembleur

114/378

dadditionner deux bits (on verra comment grer la retenue plus tard). Nous allons donc commencer par crer ces fameux circuits capables d'additionner deux bits : un tel circuit sera appel un demi-additionneur. Pour cela, on va utiliser nos portes logiques, vues dans le second chapitre de ce tutoriel. En binaire, l'addition de deux bits est trs simple, jugez plutt : 0 +0 =0 ; 0 +1 =1 ; 1 +0 =1 ; 1 + 1 = 10, ce qui est quivalent 0 plus une retenue. On voit que l'addition de deux bits n'est pas forcment code sur un seul bits : on peut avoir une retenue, qui devra tre prise en compte lors de l'addition des bits suivants. On aura donc deux sorties : une pour le rsultat, et une pour la retenue. Pour concevoir notre circuit additionnant deux bits, on va d'abord commencer par crire sa table de vrit.

Bit a Bit b 0 0 1 1 0 1 0 1

Retenue a+b 0 0 0 1 0 1 1 0

D'aprs la table de vrit, le rsultat de l'addition n'est rien d'autre qu'une simple porte XOR. Et pour la retenue, on reconnait immdiatement la table de vrit d'une porte ET. On sait maintenant comment cbler notre demi-additionneur.

Petite remarque : on pourrait parfaitement crer un demi-additionneur sans utiliser de portes logiques, mais en travaillant directement avec des transistors. On peut ainsi crer des demi-additionneurs utilisant moins de transistors que celui vu audessus, et qui sont donc plus rapides et moins gourmand en nergie.

Additionneur complet
Maintenant que l'on sait additionner deux bits, il faut prendre en compte la retenue de l'addition des bits prcdents. Pour cela, on va crer un circuit capable d'additionner trois bits : deux bits additionner, et la retenue calcule l'tape prcdente. On va donc se retrouver avec un composant trois entres : le bit a, le bit b et la retenue de l'tape prcdente ; et trois sorties : une retenue, et le rsultat. On appelle ce circuit un additionneur complet. Pour cela, on va tablir la table de vrit de notre circuit. Notre circuit comprendra trois entres : les deux bits a et b additionner, et une entre Cin, pour la retenue de l'addition des bits prcdents. Il aura aussi deux sorties : une pour la retenue du rsultat, qu'on nommera Cout, et une autre pour le rsultat de l'addition, qu'on nommera Sum.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

Bit a Bit b Cin 0 0 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1 Sum Cout 0 1 1 0 1 0 0 1 0 0 0 1 0 1 1 1

115/378

En utilisant les techniques vues au chapitre 3 de ce tutoriel, on peut alors trouver que le cblage de notre additionneur complet ressemble ceci :

Si vous regardez bien, vous remarquerez que ce schma du dessus est compos de deux demi-additionneurs et d'une porte OU, le tout tant strictement reli de cette faon :

Comme pour le demi-additionneur, il existe de nombreuses faons d'implmenter un additionneur complet. On peut parfaitement crer un additionneur complet sans utiliser de portes logiques, mais en travaillant directement avec des transistors : cela permet d'avoir quelques opportunits d'amliorations assez sympathiques. On peut ainsi crer des additionneurs complets comprenant bien moins de transistors que celui vu au-dessus.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

116/378

L'additionneur propagation de retenue

Maintenant, on a tout ce qu'il faut pour pouvoir additionner deux nombres. L'ide derrire ce circuit est trs simple : elle consiste poser l'addition comme nous avons l'habitude de la faire en dcimal. Pour effectuer une addition, il suffit d'additionner deux chiffres de mme rang (mieux dit : de mme poids) en tenant compte d'une ventuelle retenue. On obtient un rsultat et si besoin est, on pose une retenue. Par exemple : . Cela se fait en reliant les additionneurs les uns aux autres, dans l'ordre. Par exemple, pour additionner deux nombres de 4 bits, on obtiendra le circuit suivant.

Notez la prsence de lentre de retenue C : elle est trs importante, car elle permet dimplmenter des soustractions l'aide de cet additionneur. Presque tous les additionneurs de notre ordinateur on une entre de retenue comme celle-ci, afin de faciliter l'implmentation de certaines oprations comme l'inversion de signe, l'incrmentation, etc.

Pour votre information, ce circuit a un gros problme : les additionneurs sont relis les uns aux autres, et chaque additionneur doit attendre que la retenue de l'addition prcdente soit disponible pour donner son rsultat. Les retenues doivent se propager travers le circuit, d'un additionneur un autre, et cette propagation des retenues prend du temps : ce circuit est trs lent. Et le truc, c'est que l'addition est une opration trs utilise dans nos programmes. De plus, ces additionneurs sont utiliss dans d'autres circuits, pour calculer d'autres oprations arithmtiques, comme les multiplications, les soustractions, etc. La rapidit de ces oprations, dont certaines sont trs complexes, dpend fortement de la rapidit des additionneurs qu'elles vont utiliser. Il nous faut donc crer des additionneurs un peu plus rapides.

L'additionneur slection de retenue

Pour cela, il existe une solution assez simple qui consiste casser notre additionneur propagation de retenue en plusieurs petits additionneurs qu'on organise diffremment. Un additionneur conu ainsi s'appelle un additionneur slection de retenue. Cet additionneur va dcouper nos deux nombres additionner en blocs, qui se feront additionner en deux versions : une avec la retenue du bloc prcdent valant zro, et une autre version avec la retenue du bloc prcdent valant 1. Il suffira alors de choisir le bon rsultat une fois cette retenue connue. On gagne ainsi du temps en calculant l'avance les valeurs de certains bits du rsultat, sans connaitre la valeur de la retenue.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

117/378

Un tel additionneur slection de retenue est compos de briques de base, capables de pr-calculer un morceau du rsultat de l'addition et de choisir le bon rsultat. Chacune de ces briques de base sera compos de deux additionneurs : bl'un calculant la somme des bits (retenue incluse) passs en entre si lentre de retenue est zro ; et l'autre faisant la mme chose mais avec l'entre de retenue 1. La slection du bon rsultat se fait en fonction de l'entre de retenue : il suffit de relier lentre de retenue sur l'entre de commande d'un multiplexeur.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

118/378

En faisant ainsi, il suffira juste de relier les entres de retenues d'un bloc de base aux sorties de retenues du bloc prcdents.

Notre additionneur slection de retenue est donc termin. Il est plus rapide que notre additionneur propagation de retenue, beaucoup plus : l o l'additionneur propagation de retenue prenait un temps proportionnel la taille (le nombre de bits) des deux nombres additionner, notre additionneur va prendre un temps proportionnel la racine carre de la taille des nombres additionner.

D'autres additionneurs, plus rapides

Dautres additionneurs encore plus rapides existent. Ceux-ci permettent d'avoir un temps de calcul du rsultat bien plus faible, qui n'est pas proportionnel au nombre de bits additionner, mais qui est un multiple du logarithme de celui-ci (pour ceux qui ne le savent pas, le logarithme est une opration mathmatique), ce qui est un gros gain en terme de performances. Certains de ces

www.siteduzero.com

Partie 3 : Processeur et Assembleur

119/378

additionneurs (la majorit) utilisent pour cela une astuce trs simple : ils calculent la retenue en avance en fonction de la valeur de tout ou partie des bits prcdents, et n'attendent pas que l'on aie additionns ceux-ci. On les appelle des additionneurs anticipation de retenue. Le plus clbre de ces additionneurs est l'additionneur de Kogge-Stone, qui est l'additionneur le plus souvent utilis dans les processeurs actuels. Il faut toutefois rajouter que ces additionneurs sont parfois dcoups et forment un additionneur slection de retenue : on utilise ainsi des additionneurs anticipation de retenue dans les blocs de base d'un additionneur slection de retenue, histoire d'aller encore plus vite pour calculer notre addition.

Soustraction
On sait maintenant effectuer une addition. C'est pas mal, mais pas question de sarrter en chemin. Si on sait cbler une addition, cbler une soustraction ne doit pas tre trs compliqu. Pour se simplifier la vie, on va concevoir un circuit capable de soustraire deux nombres reprsents en complment deux. La raison : se faciliter la vie, vu que travailler avec des entiers reprsents en signe-valeur absolue ou en complment un est souvent plus compliqu. Pour comprendre l'algorithme utilis pour soustraire deux nombres reprsents en compltement deux, il va falloir faire un tout petit peu d'arithmtique lmentaire. V ous savez surement que et sont deux expressions quivalentes. Sauf que si l'on regarde bien, la premire expression est une soustraction, tandis que la seconde est une addition. Pour le moment, vous ne savez pas faire car on n'a pas encore cbl de circuit capable de faire une soustraction. Mais , vous en tes capables : il s'agit d'une addition, qui peut tre effectue grce au circuit vu au-dessus. Il ne nous reste plus qu' trouver un moyen de calculer l'oppos de b, et on pourra rutiliser l'additionneur vu prcdemment pour notre calcul. Et c'est l que l'on se rend compte qu'on peut utiliser les proprits de la reprsentation en complment deux. Si vous vous souvenez du premier chapitre, j'avais dit qu'on pouvait trouver l'inverse d'un nombre positif en inversant tous les bits du nombre et en ajoutant 1. Et bien cette mthode marche aussi pour les entiers ngatifs : on calcule l'inverse d'un nombre en additionnant 1 son complment 1.

Le circuit
Notre circuit doit donc inverser tous les bits du nombre soustraire ; ajouter 1 au rsultat de cette inversion ; ajouter la seconde oprande au rsultat calcul l'tape 2 (l'autre nombre : celui auquel on soustrait) au rsultat. le circuit capable d'inverser tous les bits d'un nombre est vident : il s'agit d'un circuit compos uniquement de portes NON , chacune d'entre elle tant relie un bit du nombre inverser. Il ne nous reste plus qu'a additionner la premire oprande (le nombre auquel on soustrait), augmente de 1. Navement, on pourrait se dire qu'il faudrait utiliser deux additionneurs propagation de retenue, ou un additionneur suivi d'un circuit capable d'incrmenter (augmenter de 1) cette oprande. Mais il y a moyen de faire nettement mieux en rusant juste un choua. La majorit des additionneurs possde une entre de retenue (la fameuse entre de retenu C que je vous ais fait remarquer plus haut), pour simplifier la conception de certaines instructions. C'est le cas de l'additionneur propagation de retenue qu'on a construit prcdemment. Pour additionner la seconde oprande augmente de 1, il suffira de positionner ce bit de retenue 1 et envoyer les oprandes sur les entres de notre additionneur.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

120/378

Notre circuit soustracteur est donc trs simple : il est constitu du circuit inverseur vu au-dessus, auquel on relie une des deux entres d'un additionneur sur sa sortie. Il faut juste faire en sorte de positionner la retenue de l'additionneur 1 pour que tout fonctionne. Au fait, le circuit utilis pour soustraire deux nombres reprsents en complment un est identique part un dtail : il n'y a pas besoin de positionner l'entre de retenue de notre additionneur 1 et on doit laisser celle-ci zro.

Comparaison
Je tiens signaler que les comparaisons sont souvent "fabriques" partir de soustractions. Pour comparer deux nombres, il suffit simplement de soustraire les deux nombres, de comparer le rsultat avec zro et de regarder le signe du rsultat : si le rsultat est positif, le nombre auquel on a soustrait l'autre est plus grand ; si le rsultat est ngatif, le nombre auquel on a soustrait l'autre est plus petit ; si le rsultat est nul, les deux nombres sont gaux. Une fois que l'on a fait ces tests, le rsultat peut alors tre oubli et n'a pas tre conserv. Il suffit juste de rajouter quelques circuits base de portes XOR, ET, OU, et NON notre soustracteur, et relier ceux-ci au registre d'tat pour le mettre jour. Par exemple, pour tester si le rsultat est nul, il suffit de regarder la valeur de ses bits : un rsultat vaut zro si et seulement si tous ses bits sont zro. Faire un vulgaire NOR sur tous les nombres du rsultat permet ainsi de savoir si celui-ci est nul ou non. Pour voir si un rsultat est positif ou ngatif, il suffit de regarder son bit de signe (son bit de poids fort).

Multiplication
Aprs avoir vu quelques oprations simples, comme les dcalages/rotations, les additions et les soustractions, il est temps de passer des oprations un peu plus gourmandes en terme de temps et de circuits. Nous allons aborder la multiplication, effectue par un circuit nomm le multiplieur.

Principe
Pour commencer, nous allons voir comment effectuer une multiplication de deux nombres entiers en utilisant l'algorithme le plus simple possible. Comme pour l'addition, nous allons calculer une multiplication de la mme faon qu'on a appris le faire en primaire, avec un petit dtail : nous allons travailler en binaire. Mais pour commencer, petite prcision de vocabulaire : une multiplication s'effectue sur deux nombres, dont le premier est appel multiplicande, et l'autre multiplieur. Il faut donner une petite prcision sur la taille du rsultat : si on multiplie deux nombres de bits chacun, le rsultat sera un nombre faisant bits. Suivant le circuit utilis, il se peut que tous les bits soient conservs, ou que les bits supplmentaires soient perdus. Par exemple, sachez sur les processeurs x86 32 bits qu'on trouve dans nos ordinateurs, l'instruction de multiplication permet de conserver tous les bits du rsultat de la multiplication : ceux-ci peuvent tre conservs dans deux registres spars, l'un prenant les 32 bits du poids faible, et l'autre conservant les 32 bits de poids fort.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

Pour effectuer une multiplication en binaire, on fait comme en dcimal :

121/378

on multiplie le multiplicande par le premier chiffre du multiplieur et on conserve le rsultat ; on recommence et on multiplie par le deuxime chiffre du multiplieur, mais en dcalant le rsultat d'un cran (le dcalage est bien un dcalage binaire, effectue par les dcaleurs vus au-dessus) et on stocke le rsultat ; on recommence et on multiplie par le troisime chiffre, mais en dcalant le rsultat de deux crans et on stocke le rsultat ; et on continue ainsi de suite jusqu' avoir puis tous les chiffres du multiplieur ; et enfin, on additionne tous les rsultats temporaires obtenus lors des tapes du dessus. Exemple avec la multiplication de deux nombres de 4 bits A et B, composs respectivement des bits a3, a2, a1, a0 pour A et b3, b2, b1, b0 pour B.

Produit partiel n1 Produit partiel n2 Produit partiel n3 Produit partiel n4

0 0 0

0 0

0 0 0 0 0 0 0

Comme on le voit, notre multiplication gnre un grand nombre de rsultats temporaires, chacun provenant de la multiplication de notre multiplicande par un chiffre du multiplieur, auquel on aura appliqu un dcalage. Ces rsultats temporaires sont appels des produits partiels. Ce sont les lignes dans le tableau du dessus. Gnrer ces produits partiels ncessite donc de quoi multiplier des bits entre eux. Il suffira ensuite d'avoir un additionneur pour additionner tout ces produits partiels, et le tour est jou.

Algorithme naf
Dans les multiplieurs les plus simples, on gnre ces produits partiels les uns aprs les autres, et on les additionne au fur et mesure qu'ils sont calculs. Pour cela, on utilise un registre qui stocke le rsultat. Celui-ci est initialis zro au commencement de la multiplication, et on additionne les produits partiels au contenu de ce registre.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

122/378

On voit donc que notre circuit aura besoin de faire des dcalages et des additions : il va falloir sortir les dcaleurs et les additionneurs qui vont bien pour fabriquer notre circuit.

Choix du bit du multiplieur

Pour choisir le bit du multiplieur, il suffit simplement d'utiliser ce qu'on appelle un registre dcalage. Un registre dcalage est un composant lectronique qui fonctionne comme (j'ai pas dit qui est) un registre coupl un dcaleur, ce dcaleur se chargeant de dcaler les bits du nombre stock dans le registre quand on lui demande. Ainsi, il suffira de stocker notre multiplieur dans un de ces registres dcalage. Ce multiplieur sera dcal d'un rang chaque fois qu'on devra calculer un produit partiel et il suffira alors de slectionner le bit de poids faible. Cela se fait en reliant ce bit de poids faible l'entre du circuit charg de multiplier ce bit par le multiplicande. On peut amliorer cette technique de faon arrter la multiplication une fois que le multiplieur vaut zro, histoire d'viter de calculer des produits partiels qui ne serviront rien. Avec cette technique, le temps de calcul varie donc suivant le multiplieur et n'est pas fixe. Autant dire que ce genre d'amlioration est rarement utilise dans nos ordinateurs.

Gnration des produits partiels

Gnrer notre produit partiel est trs simple : il suffit de multiplier notre nombre par un bit de l'autre nombre. Pour cela, on fait comme en dcimal : on multiplie chaque bit du multiplicande par un bit du multiplieur. Pour cela, rien de plus simple vu que les tables de multiplication sont vraiment trs simples en binaires : jugez plutt !

Opration Rsultat

www.siteduzero.com

Partie 3 : Processeur et Assembleur

123/378

Quel dommage que l'on ne compte pas naturellement en binaire : vous n'auriez pas eus vous farcir une dizaine de tables de multiplications compltement indigestes ! Cette table de vrit ressemble fortement une table de vrit d'une porte ET, et pour cause : c'est la table de vrit d'une porte ET ! Ainsi, notre circuit est donc trs simple : il suffit d'effectuer un ET entre les bits du multiplicande, et le bit du multiplieur qu'on a slectionn juste avant.

Circuits utilisant l'algorithme naf

Enfin, il ne reste plus qu ajouter de quoi configurer correctement les circuits de dcalage (dont le registre dcalage qui stocke le multiplieur : il faut bien lui dire quand dcaler), et le tour est jou. V ous remarquerez qu'au final, notre multiplieur utilise la fois des dcaleurs et des additionneurs, et qu'en consquence, utiliser des dcaleurs et additionneurs rapides est ncessaire pour avoir une multiplication rapide.

On peut faire mieux

Nanmoins, cet algorithme naf vu prcdemment est juste lent, moche et stupide. Et comme toujours, il y a moyen de faire nettement mieux (et surtout, plus complexe). Il existe en effet les multiplieurs base d'arbres de Wallace, ou les multiplieurs Dadda qui sont bien plus rapides. Ces multiplieurs vont calculer tous les produits partiels simultanment dans des circuits spars, au lieu de les calculer uns par uns, avant d'additionner les bits du rsultat d'une certaine faon. Pour donner un exemple du principe de base de ces multiplieurs, on va prendre l'exemple d'une multiplication de deux nombres de 4 bits. Soit deux nombres A et B, composs respectivement des bits a3, a2, a1, a0 pour A et b3, b2, b1, b0 pour B. Notre multiplication consistera gnrer tous les produits partiels comme ceci.

Produit partiel n1 Produit partiel n2 Produit partiel n3 Produit partiel n4

0 0 0

0 0

0 0 0 0 0 0 0

Une fois ces produits partiels calculs, il suffit d'additionner tous les bits situs sur la mme colonne (en tenant compte ventuellement de la retenue de l'addition des colonnes prcdente), et le tour est jou. Les multiplieurs base d'arbres de Wallace et les multiplieurs Dadda fonctionnent tous les deux sur ce principe. La diffrence tient dans la faon dont ils effectuent l'addition des bits d'une mme colonne. Je ne vous cache pas que ce sont des circuits de ce type qui sont prsents dans nos processeurs actuels.

Les dpassements de capacit

Nos circuits ne doivent pas se contenter de fournir un rsultat : il doit aussi avertir des possibles erreurs qui peuvent avoir lieu lors de l'addition. Quelles erreurs ?

Celles qui ont lieu quand un rsultat est trop grand. Les instructions arithmtiques et quelques autres manipulent des entiers de taille fixe, qui ne peuvent prendre leurs valeurs que dans un intervalle dtermin par une valeur minimale et une valeur maximale. Si le rsultat d'un calcul sur des nombres entiers sort de cet intervalle, il ne pas tre reprsent dans notre ordinateur : il se produit ce qu'on appelle un integer overflow. Et quand un integer overflow a eu lieu, il vaut mieux prvenir ! Pour cela, on va rajouter une sortie supplmentaire nos circuits, qu'on nomme OF et qu'on positionnera 1 si un integer overflow a lieu. Bien sr, il faudra rajouter un peu de circuiterie pour dtecter cet interer overflow et positionner notre bit OF. Premire remarque sur ces circuits : la gestion des integer overflow dpend de la reprsentation des nombres utilise.

Entiers strictement positifs, non signs

www.siteduzero.com

Partie 3 : Processeur et Assembleur

124/378

Ces integer overflow sur des nombres non-signs sont grs diffremment suivant le processeur. Certains ne conservent que les bits de poids faibles du rsultat : les bits en trop sont simplement ignors. Le problme avec ce genre d'arithmtique, c'est qu'une opration entre deux grand nombres peut donner un rsultat trs petit. Par exemple, si je dispose de registres 4 bits et que je souhaite faire l'addition (ce qui donne 15 + 2), le rsultat est cens tre (17), ce qui est un rsultat plus grand que la taille d'un registre. En conservant les 4 bits de poids faible, jobtiens (1). En clair, un rsultat trs grand est transform en un rsultat trs petit. D'autres processeurs utilisent ce qu'on appelle l'arithmtique sature : si un rsultat est trop grand au point de gnrer un integer overflow, on arrondi le rsultat au plus grand entier support par le processeur. Les processeurs qui utilisent l'arithmtique sature sont souvent des DSP, qui doivent manipuler du signal ou de la vido. Certaines instructions de nos processeurs x86 (certaines instructions SSE) font leurs calculs en arithmtique sature. Par contre, les circuits capables de calculer en arithmtique sature sont un peu plus complexes que leurs collgues qui ne travaillent pas en arithmtique sature.

Complment deux et complment un

Pour les nombres cods en complment deux, la situation se corse. Si vous vous rappelez le chapitre 1, j'ai clairement dit que les calculs sur des nombres en compltement deux utilisent les rgles de l'arithmtique modulaire : ces calculs seront faits sur des entiers ayant un nombre de bits fix une fois pour toute et si un rsultat dpasse ce nombre de bits fix (qu'on notera N), on ne conserve pas les bits en trop. C'est une condition ncessaire pour pouvoir faire nos calculs. A priori, on peut donc penser que dans ces conditions, les integer overflow sont une chose parfaitement normale, qui nous permet d'avoir des rsultats corrects. Nanmoins, il faut se mfier de nos intuitions : certains integer overflow peuvent arriver et produire des bugs assez ennuyeux. Si l'on tient en compte les rgles du complment deux, on sait que le bit de poids fort (le plus gauche) permet de dterminer si le nombre est positif ou ngatif : ce bit ne sert pas vraiment reprsenter une valeur et tout se passe comme si les entiers en complment deux taient cods sur un bit de moins que leur longueur. Si le rsultat d'un calcul a besoin d'un bit de plus que cette longueur, ampute du bit de poids fort), ce bit de poids fort sera cras, et on se retrouvera avec un integer overflow digne de ce nom. Par exemple, si l'on additionne les nombres 0111 1111 et 0000 0001, le rsultat sera le nombres 1000 0000, qui est ngatif ! Il y a bien eu integer overflow : le bit de signe aura t cras par un bit du rsultat. Il existe une rgle simple qui permet de dtecter ces integer overflow. L'addition (ou la multiplication) de deux nombres positifs ne peut pas tre un nombre ngatif : on additionne deux nombres dont le bit de signe est 0 et que le bit de signe du rsultat est 1, on est certain d'tre en face d'un integer overflow. Mme chose pour deux nombres ngatif : le rsultat de l'addition ne peut pas tre positif. On peut rsumer cela en une phrase. Si deux nombres de mme signe sont ajouts, un integer overflow a lieu quand le bit du signe du rsultat a le signe oppos.

On peut prciser que cette rgle s'applique aussi pour les nombres cods en complment 1, pour les mmes raisons que pour le codage en complment deux.

La division
Aprs la multiplication, nous allons voir comment effectuer des divisions. Autant prvenir tout de suite : la division est une oprations trs complexe et particulirement lente, bien plus qu'une addition ou une multiplication. Pour information, sur les processeurs actuels, la division est entre 20 80 fois plus lente qu'une addition/soustraction, et presque 7 26 fois plus lente qu'une multiplication. Mais on a de la chance : c'est aussi une opration assez rare. Un programme effectue rarement des divisions, les plus rares tant les divisions entires tandis que les divisions les plus frquentes sont les divisons entre deux nombres flottants. Souvent, les divisions les plus couramment utilises dans un programme sont des divisions par une constante : un programme devant manipuler des nombres dcimaux aura tendance effecteur des divisons par 10, un programme manipulant des dures pourra faire des divisions par 60 (gestion des minutes/secondes) ou 24 (gestion des heures). Diverses astuces permettent de remplacer ces oprations de divisions par des suites d'instructions plus simples mais donnant le mme rsultat. J'ai parl plus haut des dcalages, qui permettent de remplacer de divisons par . Mais il existe d'autres mthodes, qui fonctionnent pur un grand nombre de constantes. Par exemple, on peut remplacer une division par une constante par une multiplication un peu bizarre : la multiplication par un entier rciproque). Sachant cela, certains processeurs ne possdent pas d'instruction de division. Inclure une instruction de division n'acclrerait qu'un faible nombre d'instructions, et ne donnerait pas lieu des gains assez importants en terme de performance : acclrer 1% des instructions d'un programme (ici, les divisions) en implmentant un circuit complexe et gourmand en transistors alors qu'on pourrait utiliser ces circuits pour cbler des instructions plus utiles serait du gchis. Certains processeurs implmentent toutefois la division dans une instruction machine, disposant souvent d'un circuit ddi. Les gains ne sont pas forcment faramineux, mais ne sont pas forcment ngligeables non plus.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

125/378

Division restauration
L'algorithme le plus simple que l'on puisse crer pour excuter une division consiste faire la division exactement comme en dcimal, mais d'une faon un peu diffrente.

Prenons un exemple. Nous allons cherche diviser 100011001111 (2255 en dcimal) par 111 (7 en dcimal). Pour commencer, nous allons commencer par slectionner le bit de poids fort du dividende (le nombre qu'on veut diviser par le diviseur), et voir combien de fois on trouve le diviseur dans ce bit. Pour ce faire, on soustraire le diviseur ce bit, et voir le signe du rsultat. Si le rsultat de cette soustraction est ngatif, alors le diviseur est plus grand que ce qu'on a slectionn dans notre dividende. On place alors un zro dans le quotient. Dans notre exemple, cela fait zro : on pose donc un zro dans le quotient.

Ensuite, on abaisse le bit juste cot du bit qu'on vient de tester, et on recommence. On continue ainsi tant que le rsultat de la soustraction obtenue est ngatif.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

126/378

Quand le rsultat de la soustraction n'est pas ngatif, on met un 1 la droite du quotient, et on recommence en partant du reste. Et on continue ainsi de suite.

Notre algorithme semble se dessiner peu peu : on voir qu'on devra utiliser des dcalages et des soustractions, ainsi que des comparaisons. L'implmentation de cet algorithme dans un circuit est super simple : il suffit de prendre trois registres : un pour conserver le "reste partiel" (ce qui reste une fois qu'on a soustrait le diviseur dans chaque tape), un pour le quotient, et un pour le dividende. A chaque tape, on dcale le dividende et le quotient de un rang vers la gauche, et on envoie le bit qui sort de ce dividende dans le registre qui stocke le reste partiel. Cela permet de slectionner les bits abaisser : on abaisse un bit chaque tape.

Ensuite, on soustrait le diviseur de ce "reste" et on stocke le rsultat dans le registre qui stocke le reste. Deux cas de figure se

www.siteduzero.com

Partie 3 : Processeur et Assembleur

prsentent alors :

127/378

Le rsultat est ngatif. En clair, cela signifie que le reste est plus petit que le diviseur et qu'on aurait pas du soustraire. Vu que notre soustraction a t effectue par erreur, on doit remettre le reste tel qu'il tait, ce qui se fait en rajoutant le diviseur au rsultat obtenu. Dans ce cas, on met le bit de poids faible du quotient zro et on le dcale d'un rang vers la gauche, et on rajoute le diviseur au reste pour revenir la normale. Le rsultat est positif. Dans ce cas, on met le bit de poids faible du quotient 1, puis on dcale celui-ci et on ne fait rien de plus. Et on continue ainsi de suite jusqu' ce que le reste partiel soit infrieur au diviseur. On voit donc que notre circuit charg de faire des divisions a besoin d'un soustracteur, d'un comparateur, d'un additionneur (pour remettre le reste comme il faut quand le rsultat de la soustraction est ngatif), et d'un peu de circuiterie autour pour savoir quoi faire suivant le rsultat de la comparaison. Cette mthode s'appelle la division avec restauration.

Division sans restauration

La mthode prcdente a toutefois un lger dfaut : on a besoin de remettre le reste comme il faut lorsqu'on a soustrait le diviseur du reste alors qu'on aurait pas du et que le rsultat obtenu est ngatif. On fait cela en rajoutant le diviseur au reste. Et il y a moyen de se passer de cette restauration du reste partiel son tat originel. On peut trs bien continuer de calculer avec ce reste faux, pour ensuite modifier le quotient final obtenu de faon simple, pour obtenir le bon rsultat. Il suffit simplement de multiplier le quotient par deux, et d'ajouter 1. a parait vraiment bizarre, mais c'est ainsi. Cette mthode consistant ne pas restaurer le reste comme il faut et simplement bidouiller le quotient s'appelle la division sans restauration.

La division SRT
On peut encore amliorer cette mthode en ne traitant pas notre dividende bit par bit, mais en le manipulant par groupe de deux, trois, quatre bits, voire plus encore. Ce principe est (en partie) la base de l'algorithme de division SRT. C'est cette mthode qui est utilise dans les circuits de notre processeur pour la division entire. Sur certains processeurs, le rsultat de la division de deux groupes de bits est pr-calcul et stock dans une petite mmoire : pas besoin de le recalculer chaque fois avec un circuits, il suffit juste de lire cette mmoire, ce qui va beaucoup plus vite ! Pour information, on peut signaler que sur les processeurs les plus rcents l'heure o j'cris ce tutoriel, on peut traiter au maximum 4 bits la fois. C'est notamment le cas sur les processeurs Core 2 duo. Bien sr, il faut faire attention quand on remplit cette mmoire : si vous oubliez certaines possibilits ou que vous y mettez des rsultats errons, vous obtiendrez un quotient faux pour votre division. Et si vous croyez que les constructeurs de processeurs n'ont jamais fait cette erreur, vous vous trompez : cela arrive mme aux meilleurs ! Intel en a d'ailleurs fait les frais sur le Pentium 1. L'unit en charge des divisions flottantes utilisait un algorithme similaire celui vu au-dessus (les mantisses des nombres flottants taient divises ainsi), et la mmoire qui permettait de calculer les bits du quotient contenait quelques valeurs fausses. Rsultat : certaines divisions donnaient des rsultats incorrects ! Au fait, j'ai un truc vous rvler : tous les circuits qu'on vient de voir ne fonctionnent que pour les nombres entiers non-signs, ou cods en compltement deux. Si vous voulez traiter des nombres flottants ou des entiers reprsents en signe-magnitude, il vous faudra utiliser d'autres circuits, plus complexes. Cela fera peut-tre l'objet d'un futur tutoriel, qui sait ?

www.siteduzero.com

Partie 3 : Processeur et Assembleur

128/378

Il y a quoi dans un processeur ?

Dans le chapitre sur le langage machine, on a vu notre processeur comme une espce de boite noire contenant des registres qui excutait des instructions les unes aprs les autres et pouvait accder la mmoire : on a explor l'architecture extrieure de notre processeur. Mais on n'a pas encore vu comment celui-ci tait organis et comment celui-ci fait pour excuter une instruction. Pour cela, il va falloir nous attaquer la micro-architecture de notre processeur. C'est le but de ce chapitre : montrer comment les grands circuits de notre processeur sont organiss et comment ceux-ci permettent dexcuter une instruction. On verra que notre processeur est trs organis et est divis en plusieurs grands circuits qui effectuent des fonctions diffrentes.

Execution d'une instruction

Le but d'un processeur, c'est dexcuter une instruction. Cela ncessite de faire quelques manipulations assez spcifiques et qui sont toutes les mmes quelque soit l'ordinateur. Pour excuter une instruction, notre processeur va devoir faire son travail en effectuant des tapes bien prcises. V la liste de ces tapes, dans l'ordre dans lesquelles notre processeur doit les effectuer. oici Il va d'abord devoir charger l'instruction depuis la mmoire et la stocker dans un registre spcialis pour la manipuler : c'est l'tape de Fetch. A la fin de cette tape, l'instruction est alors stocke dans un registre : le registre d'instruction. Ensuite, notre processeur va lire l'instruction dans le registre d'instruction et va identifier l'instruction partir de son opcode et de son mode d'adressage. Cela lui permettra de savoir comment configurer les circuits du processeur, pour que ceux-ci excutent l'instruction voulue : on dit que notre processeur va devoir dcoder l'instruction. C'est l'tape de Decode. Une fois que c'est fait, notre instruction va sexcuter. Le seul problme, c'est ce qu'il faut faire pour xecuter une instruction. Toutes les instructions n'ont pas les mmes besoins suivant ce qu'elles font ou leur mode d'adressage.

Instruction d'accs mmoires

Commenons par prendre l'exemple de l'instruction Load. Cette instruction va simplement lire une donne en mmoire et va l'enregistrer dans un registre. Elle a donc besoin d'aller lire une donne en mmoire, et enregistre le rsultat dans un registre.

Adressage absolu
Pour commencer, on suppose que notre instruction Load utilise le mode d'adressage absolu. C'est dire que cette instruction va indiquer l'adresse laquelle lire dans sa suite de bits qui la reprsente en mmoire.

tape 1 tape 2 Fetch Decode

tape 3 Lecture de la donne en mmoire

Lexcution de notre instruction se fait donc en trois tapes : le chargement de l'instruction, le dcodage, et la lecture proprement dite. Pour une instruction Store, qui est cense crire une donne d'un registre vers la mmoire, c'est la mme chose :

tape 1 tape 2 Fetch Decode

tape 3 Ecriture de la donne en mmoire

Nos instructions d'accs mmoire ont donc besoin de pouvoir effectuer des lectures ou des critures. En soit, rien de bien surprenant.

Modes d'adressages plus complexes

Mais si l'on utilise des modes d'adressages plus complexes, les choses changent un petit peu. Reprenons notre instruction Load, mais en utilisant une mode d'adressage utilis pour des donnes plus complexe. Par exemple, on va prendre un mode d'adressage du style Base + Index. Avec ce mode d'adressage, l'adresse doit tre calcule partir d'une adresse de base, et d'un indice, les deux tant stocks dans des registres.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

En plus de devoir lire notre donne, notre instruction va devoir calculer l'adresse en fonction du contenu fourni par deux registres.

129/378

tape 1 tape 2 Fetch

tape 3

tape 4 Lecture de la donne en mmoire

Decode Calcul d'adresse

Notre instruction s'effectue dornavant en deux tapes, pas une seule. Qui plus est, ces deux tapes sont assez diffrentes : une implique un calcul, et l'autre implique un accs la mmoire.

Instruction de calcul
Prenons maintenant le cas d'une instruction d'addition. Celle-ci va additionner deux oprandes, qui peuvent tre soit des registres, soit des donnes places en mmoires, soit des constantes.

Adressage par registre

Si les deux oprandes sont dans un registre et que le rsultat doit tre plac dans un registre, alors la situation est assez simple. Il suffit simplement d'aller rcuprer les oprandes dans les registres, effectuer notre calcul, et enregistrer le rsultat. Suivant le processeur, cela peut se faire en une ou plusieurs tapes. On peut ainsi avoir une seule tape qui effectue la rcupration des oprandes dans les registres, le calcul, et l'enregistrement du rsultat dans les registres.

tape 1 tape 2 Fetch Decode

tape 3 Rcupration des oprandes, calcul, et enregistrement du rsultat

Mais il se peut que sur certains processeurs, cela se passe en plusieurs tapes.

tape 1 tape 2 Fetch Decode

tape 3 Rcupration des oprandes

tape 4 Calcul

tape 5 Enregistrement du rsultat

Adressage absolu
Maintenant, autre exemple : une oprande est aller chercher dans la mmoire, une autre dans un registre, et le rsultat doit tre enregistr dans un registre. On doit alors rajouter une tape : on doit aller chercher la donne en mmoire.

tape 1 tape 2 Fetch Decode

tape 3

tape 4

Lecture de la donne Rcupration des oprandes, calcul, en mmoire et enregistrement du rsultat

www.siteduzero.com

Partie 3 : Processeur et Assembleur

130/378

Et on peut aller plus loin en allant cherche notre premire oprande en mmoire : il suffit d'utiliser le mode d'adressage Bas + Index pour celle-ci. On doit alors rajouter une tape de calcul d'adresse en plus. Ne parlons pas des cas encore pire du style : une oprande en mmoire, l'autre dans un registre, et stocker le rsultat en mmoire.

L'intrieur d'un processeur

On pourrait croire que ces exemples ne sont pas trs instructifs sur l'intrieur d'un processeur. Mais ce n'est pas le cas. Comme vous l'avez vu, nos instruction prenaient un certain nombre d'tapes pour sexcuter. Ces tapes ont des buts assez diffrents : certaines font des lectures ou critures en mmoire, d'autres changent des donnes entre registre, etc. Et bien sachez que toute instruction peut tre dcoupe en tapes qui vont : soit effectuer une lecture ou criture en mmoire RAM ; effectuer un calcul ; changer des donnes entre registres. Comme vous le voyez, les traitements effectuer sur les donnes et les instructions sont assez diffrents. Dans les premiers ordinateurs, ces circuits taient fusionns en un seul gros circuit qui faisait tout. Pour se faciliter la tche, les concepteurs de CPU ont dcid de segmenter les circuits du processeur en circuits spcialiss : des circuits chargs dexcuter des instructions, d'autres chargs de grer les instructions et/ou les accs mmoires...Pour concevoir un processeur, il suffit simplement de crer des circuits capables d'effectuer une de ces tapes, et de crer de quoi effectuer les bonnes tapes dans le bon ordre en fonction de l'instruction voulue. Ainsi, chacune de ces tapes est souvent effectue par un circuit spcialis dans notre processeur.

Le Datapath
Notre processeur dispose donc d'un ou de plusieurs circuits chargs d'effecteur des calculs : ce sont des units de calcul. Ils servent pour effecteur des instructions de calcul, ou pour calculer des adresses mmoires (modes dadressages Base + Index, par exemple). De mme, notre processeur possde un circuit qui lui permet de communiquer avec la mmoire. notre processeur peut ainsi aller configurer des bus d'adresse, lire ou crire sur le bus de donne, etc. Sur les processeurs modernes, ce circuit s'appelle la Memory Management Unit . Notre processeur dispose aussi de registres. Et il faut bien faire communiquer ces registres avec la mmoire, l'unit de calcul, ou faire communiquer ces registres entre eux ! Pour cela, notre processeur incorpore un bus permettant les changes entre tout ce beau mode. L'intrieur de notre processeur ressemble donc ceci :

Cet ensemble minimal de composants ncessaire pour effectuer nos instructions s'appelle le Datapath, ou chemin de donnes. On l'appelle ainsi parce qu'il regroupe tous les composants qui doivent manipuler des donnes.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

131/378

Chacune des tapes autre que Fetch et Decode (le chargement de l'instruction et son dcodage) vont effectuer une manipulation sur ce Datapath. Par exemple, une tape pourra relier des registres sur les entres de lunit de calcul, demander celle-ci de faire un calcul, et relier sa sortie sur un registre. Ou alors, une tape pourra relier des registres sur le circuit permettant de communiquer avec le bus pour effecteur une lecture ou criture. Ou alors, on pourra configurer notre bus de faon copier le contenu d'un registre dans un autre. Bref, chacune des tapes vue plus haut s'effectuera en configurant notre unit de calcul, en configurant notre bus, ou en configurant notre unit de communication avec la mmoire.

Le squenceur
Mais pour pouvoir effectuer une instruction, il faut non seulement savoir effectuer chaque tape de celle-ci, mais il faut aussi effectuer les bonnes tapes, et dans le bon ordre. Par exemple, on ne doit pas actionner l'unit de calcul pour une lecture. Et il ne faut pas effectuer de calcul d'adresse pour une lecture en mode d'adressage absolu. Bref, pour effectuer une instruction, notre processeur doit dduire quoi faire en fonction de sa reprsentation en binaire. Il doit configurer le Datapath, et il doit effectuer les bonnes configurations les unes aprs les autres dans le bon ordre. Pour ce faire, notre processeur contient un circuit qui se charge d'effecteur chaque tape ncessaire lexcution de notre instruction dans le bon ordre en fonction de l'instruction, de sa reprsentation en binaire : c'est le squenceur. L'intrieur de notre processeur ressemble donc quelque chose dans le genre :

Sur ce schma, le chemin de donnes est colori en rouge, le squenceur en noir, et les circuits de gestion de la mmoire en bleu. L'organisation illustre dans le schma du dessus permet de grer les modes d'adressages absolus et registre. Le squenceur peut en effet envoyer une adresse sur le bus et charger une donne du bus de donne dans les registres de donnes : cela permet de grer le mode d'adressage absolu. Pour le mode d'adressage registre, il est gr par le chemin de donne. On peut avoir une organisation bien plus complexe, ce qui permet de grer d'autres modes d'adressage. Par exemple, on pourrait relier le chemin de donnes sur l'interface permettant de communiquer avec le bus d'adresse et la mmoire : on peut ainsi envoyer le contenu d'un registre sur le bus d'adresse, ce qui permet de grer le mode d'adressage indirect registre. On pourrait aussi rajouter un Stack Pointer et un Frame Pointer, afin de grer une pile. On pourrait placer ces deux registres aussi bien dans le squenceur que dans le chemin de donne : tout dpend si l'on veut faire faire nos calculs sur ces registres (les additions et soustractions pour empiler et dpiler) par notre unit de calcul ou dans un circuit spcialis inclus dans le squenceur. Maintenant qu'on sait quels sont les grands circuits prsents dans notre processeur, on va voir ceux-ci plus en dtail.

Units de calcul
Le rle du chemin de donne est dexcuter une instruction et pour ce faire, notre processeur contient des circuits spcialement tudis pour. Dans notre processeur, ces circuits sont presque toujours regroups ensembles, avec quelques petits circuits supplmentaires pour grer le tout, dans ce qu'on appelle une unit de calcul. Pour simplifier, notre unit de calcul est donc une sorte de gros circuit qui contient de quoi faire des calculs arithmtiques ou des oprations logiques (comme des ET, OU, XOR,

www.siteduzero.com

Partie 3 : Processeur et Assembleur

132/378

etc). Je ne vous cache pas que ces units de calculs sont utiliss pour effectuer des instructions arithmtiques et logiques, pour les comparaisons et instructions de test. Mais on peut aussi l'utiliser lors des tapes de calcul d'adresse, requis pour certains modes d'adressage. Aprs tout, calculer une adresse se fait avec des oprations arithmtiques et logiques simples, comme des dcalages, des additions et des multiplications. Une unit de calcul est capable d'effectuer des oprations arithmtiques, des oprations logiques, et des instructions de test (les comparaisons). Les instructions effectues par ces units de calcul sont donc le plus souvent : des additions ; des soustractions ; des multiplications ; des divisions ; des changements de signe ; des dcalages logiques ; des dcalages arithmtiques ; des rotations ; des NON logiques ; des ET logiques ; des OU logiques ; des XOR logiques ; des comparaisons ; des test d'galit ; etc. Certaines units de calculs sont assez rudimentaires, et ne peuvent pas effectuer beaucoup d'instructions : on peut parfaitement crer des units de calcul ne sachant faire que des oprations simples comme des ET, OU, et NON logiques. Par contre, d'autres units de calcul sont plus volues et peuvent faire normment d'instructions diffrentes : certaines units de calcul sont capables d'effectuer toutes les instructions cites au-dessus, et quelques autres comme calculer des racines carres, des tangentes, arc-tangentes, cosinus, etc. Cette unit de calcul est souvent appele l'unit arithmtique et logique ou UAL. Certains (dont moi) prfrent lappellation anglaise Arithmetic and logical unit , ou ALU.

Vu de lextrieur
Nos instructions de comparaisons sont prises en charge par l'unit de calcul et elles doivent mettre jour le registre d'tat. Et c'est sans compter sur les oprations de calcul qui doivent mettre jour d'indicateur d'overflow, et d'autres bits du registre d'tat comme le fameux bit NULL, cit il y a quelques chapitres. On peut donc en dduire que le registre d'tat est obligatoirement reli certaines sorties de lunit de calcul. De plus, il faudra bien spcifier l'instruction effectuer notre unit de calcul parmi toutes celles qu'elle est capable de faire : il faudra aussi rajouter une entre de slection de l'instruction. Pour votre culture gnrale, voici comment sont gnralement schmatises ces fameuses units de calcul :

www.siteduzero.com

Partie 3 : Processeur et Assembleur

133/378

Ce schma montre une unit de calcul effectuant des instructions sur une ou deux donnes la fois : elle possde trois entres et deux sorties.

Slection de l'instruction
Pour excuter une instruction, il faudra donc configurer notre unit de calcul pour que celle-ci excute l'instruction voulue et pas une autre. Aprs tout, il faut bien prvenir notre unit de calcul qu'on veut faire une addition et pas une multiplication : elle ne peut pas le deviner toute seule ! Pour cela, notre unit de calcul possde une entre permettant de la configurer convenablement. Cette entre supplmentaire s'appelle l'entre de slection de l'instruction. Sur cette entre, on va mettre un nombre cod en binaire qui prcise l'instruction effectuer. Suivant le nombre qu'on va placer sur cette entre de slection de l'instruction, notre unit de calcul effectuera une addition, une multiplication un dcalage, etc. Pour chaque unit de calcul, il existe donc une sorte de correspondance entre le nombre qu'on va placer sur l'entre de slection de l'instruction, et l'instruction excuter : Entre de slection de l'instruction Instruction effectue par l'unit de calcul 0000 0111 1111 0100 1100 ... NOP Addition Multiplication ET logique Dcalage droite ...

A l'intrieur d'une unit de calcul

Ces units de calcul contiennent des circuits, fabriqus base de portes logiques et de multiplexeurs, semblables ceux qu'on a vus au chapitre prcdent. Suivant l'unit de calcul utilise, son fonctionnement interne peut tre plus ou moins compliqu.

Dans une ALU, il y a des circuits !

Certaines units de calcul contiennent un circuit diffrent par instruction qu'elles sont capables dexcuter. Lentre de slection sert donc uniquement slectionner le bon circuit et connecter celui-ci aux entres ainsi qu'aux sorties. Pour slectionner un de ces circuits, on utilise plusieurs multiplexeurs, qui vont relier le bon circuit aux entres et aux sorties de

www.siteduzero.com

Partie 3 : Processeur et Assembleur

134/378

notre unit de calcul. On peut voir ces multiplexeurs comme des espces d'interrupteurs qui vont venir connecter ou dconnecter les entres et sorties de notre unit de calcul au bon circuit.

Bien sr, ces multiplexeurs doivent tre commands pour se mettre dans la bonne position : l'entre de slection sert cela.

Unit configurer
Rares sont les units de calcul dans lesquelles on trouve un circuit pour chaque instruction. En effet, des units de calcul fabriques ainsi seraient beaucoup trop gourmandes en circuits : le nombre de portes logiques et de transistors utiliser serait beaucoup trop lev. Et il faut donc viter au maximum de trop faire gonfler la facture. Si on regarde bien, il y a une solution ce problme : des morceaux de circuits se retrouvent en plusieurs exemplaires dans notre unit de calcul, alors qu'un seul pourrait suffire. C'est le cas de l'additionneur, par exemple : il est utilis dans le circuit charg des soustractions et dans celui capable d'effectuer les additions. On se retrouve avec un circuit prsent en double et ce genre de duplication de circuit inutile doit tre vite. Bien videmment, il est plus conome en terme de circuits de ne pas avoir placer deux circuits additionneurs dans notre processeur, et faire en sorte de n'utiliser qu'un seul circuit additionneur pour les deux instructions. Pour viter ce problme, on regroupe l'additionneur et l'inverseur dans un seul circuit et on slectionne l'inverseur quand on veut effectuer une soustraction.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

135/378

Pour spcifier qu'on veut faire une addition ou une soustraction, il faut alors placer une entre charge de spcifier s'il faut connecter ou dconnecter le circuit inverseur : cette entre permettra de configurer le circuit. Ce qui peut tre fait pour une simple soustraction ou des dcalages peut l'tre pour toutes les autres instructions. Par exemple, sachez que les multiplications ou divisons peuvent utiliser l'additionneur, comme les oprations de comparaisons. Et l'additionneur n'est pas le seul concern : les circuits chargs d'effectuer des dcalages peuvent tre utiliss pour excuter des instructions de dcalage, des divisons, des multiplications, etc. Dans ce genre de cas de figure, il faudra relier ou dconnecter ces sous-circuits entre eux suivant l'instruction effectuer. De mme, vous imaginez mettre un circuit spcialis pour chaque dcalage existant (dcalage logique droite, dcalage arithmtique droite, rotation gauche, etc) alors que rajouter quelques multiplexeurs permet notre circuit d'effectuer tous les dcalages et rotations possibles ? Seul problme, notre circuit capable d'effectuer tout ces dcalages doit tre configur pour effectuer la bonne instruction. Il faut lui dire qu'il doit faire un dcalage logique droite, par exemple : il ne peut pas le deviner tout seul. Et pour le configurer, il faut envoyer les bonnes valeurs sur une de ses entres, qui permettra de configurer le circuit afin de lui faire faire ce qu'il faut. Ainsi, au lieu d'utiliser des circuits spars, certaines units de calcul utilisent une solution plus conomique. Elles sont composes de circuits lmentaires rutiliss dans plusieurs instructions, qui sont slectionns ou d-slectionns au besoin, suivant l'instruction excuter. Le choix des circuits activer ou dsactiver se fera grce des "interrupteurs lectroniques" (des transistors ou des multiplexeurs) qui connecteront entre eux les circuits utiliser et dconnecteront les circuits qui sont inutiles pour effectuer l'instruction choisie. Suivant la valeur de l'entre de slection de l'instruction, quelques petits circuits internes l'unit de calcul se chargeront de fermer ou d'ouvrir ces "interrupteurs" convenablement. La solution vue au dessus permet d'conomiser beaucoup de transistors, aussi les concepteurs de processeurs utilisent cette solution ds que possible. Je dis ds que possible, parce que ce n'est pas toujours le cas : il est parfois utile de dupliquer certains circuits pour viter de compliquer la conception de lunit de calcul : il est parfois beaucoup plus simple d'utiliser deux circuits similaires et spars que de tenter de dcouper ce circuit en circuits plus lmentaires et rassembler le tout.

Bit Slicing
Sur certains processeurs assez anciens, l'ALU est elle-mme dcoupe en plusieurs ALU plus petites, chacune capable d'effectuer toutes les instructions de l'ALU, relies entre elles, qui traitent chacune un petit nombre de bits. Par exemple, l'ALU des processeurs AMD's Am2900 est une ALU de 16 bits compose de plusieurs sous-ALU de 4 bits. Cette technique qui consiste crer des units de calcul plus grosses partir dunits de calcul plus lmentaires s'appelle en jargon technique du Bit Slicing.

Dans la ralit
les units de calcul de nos processeurs actuels sont un mlange de tout ce qui a t vu au-dessus. Les units de calcul les plus

www.siteduzero.com

Partie 3 : Processeur et Assembleur

136/378

compltes sont en effet dcoupes en pleins de circuits, certains devant tre configurs, d'autres relis, etc. Tout ce passe comme si ces circuits se comportaient comme des sous-units de calculs inclues dans une unit de calcul plus grosse. Par exemple, on peut avoir une sous-unit de calcul qui se charge des dcalages et des rotations (un barrel shifter), une autre qui se charge des oprations logiques (ET, OU, NON, XOR), une autre pour les additions, soustractions et comparaisons, une autre pour la multiplication, etc.

Autant dire que l'intrieur d'une unit de calcul est assez sympathique. Dans ce genre de cas, une partie seulement de l'entre de slection sert slectionner un circuit, le reste servant configurer le circuit slectionn.

Units annexes
Comme vous le savez, certains ordinateurs peuvent parfaitement calculer avec des entiers ou des flottants. Mais les circuits pour faire un calcul sur un entier ne sont pas les mmes que les circuits faisant la mme opration sur des flottants. Certains processeurs s'en moquent et utilisent une seule unit de calcul capable d'effectuer la fois des calculs sur des entiers que des calculs sur des flottants. Mais dans d'autres processeurs, les circuits calculant sur les entiers et ceux manipulant des flottants sont places dans deux units de calculs spares. On se retrouve donc avec (au moins) deux units de calculs, une unit de calcul normale, et un circuit spcialis dans le traitement des nombres flottants : la Floating Point Unit . On utilise souvent l'abrviation FPU pour dsigner cette Floating Point Unit . Les instructions supportes par les FPU et une unit de calcul standard calculant sur les entiers sont parfois diffrentes. Les FPU peuvent effectuer d'autres instructions supplmentaires en plus des traditionnelles oprations arithmtiques : des racines carres, des sinus, des cosinus, des logarithmes, etc. Et c'est normal : les rsultats de ces oprations sont souvent des nombres virgules et rarement des nombres entiers. On peut aussi dcider de sparer certains circuits des autres dans des units de calculs indpendantes. Il n'y a donc pas que des unit de calcul entires ou des FPU. En effet, un processeur peut contenir des units en plus : des units charges d'effectuer des instructions de dcalage, nomme dcaleurs ; des units spcialises dans le calcul de certaines instructions : pour donner un exemple, les divisions sont parfois excutes dans des circuits part ; etc. En clair, il y a au moins une unit de calcul dans un processeur : on peut en mettre plusieurs, mais tout processeur contient au moins une unit de calcul principale, cot de laquelle on va trouver quelques units de calcul annexes, plus spcialises.

Registres, accumulateurs, et communication avec la mmoire

Notre processeur contient un certain nombre de registres, ncessaires son fonctionnement. La quantit de registres varie suivant le processeur, s'il s'agit d'un processeur RISC, CISC, ou de dtails concernant son jeu d'instruction. Le nombre et le rle

www.siteduzero.com

Partie 3 : Processeur et Assembleur

des diffrents registres joue un rle dans la faon dont on va concevoir notre processeur, et son Datapath.

137/378

Architectures accumulateur
Dans le cas le plus simple, notre processeur utilise un seul registre pour stocker des donnes. Ce registre, l'accumulateur, est second par diffrents registres spcialiss, incorpors dans le processeur. Ces processeurs ont un jeu d'instruction spcial : les instructions vont aller chercher une oprande dans cet accumulateur, et potentiellement d'autres oprandes partir de la mmoire. De plus, le rsultat de l'instruction est stock dans l'accumulateur. Le Datapath d'un tel processeur est facile deviner.

Pour que nos instructions puisse lire une oprande en provenance de l'accumulateur, il suffit de relier notre accumulateur sur l'entre de l'ALU. L'autre entre de l'ALU sera alors relie la mmoire, plus ou moins directement. Pour que le rsultat calcul par l'ALU soit stock dans l'accumulateur, il suffit de relier la sortie de l'ALU sur l'accumulateur. En soit, rien de bien sorcier.

Registres d'Index
Pour plus de simplicit, la majorit des architectures accumulateurs sont fournies avec des registres d'Index, qui permettent de faciliter la gestion d'adresses mmoires. Ces registres d'Index sont cbls dans le processeur comme des accumulateurs, et sont souvent relis une autre unit de calcul.

Register File
Mais la majorit des processeurs ne se contente pas d'un seul registre pour stocker des donnes. Dans la plupart des cas, notre processeur incorpore des tas de registres plus ou moins varis, qu'il faut incorporer dans notre processeur. Il y a diverses faons pour grer ces registres dans le processeur, mais de nos jours, une seule faon de faire est devenue la norme. Tout ce qu'il faut

www.siteduzero.com

Partie 3 : Processeur et Assembleur

savoir, c'est que nos registres sont rassembls dans un seul grand composant qu'on appelle le Register File.

138/378

C'est quoi ?
On peut voir ce Register File comme une sorte de grosse mmoire dont chaque case mmoire serait un registre. Il s'agit rellement d'une mmoire : ce Register File contient des entres qui permettent de slectionner un registre, des entres de commande, et des entres sur lesquelles on envoie des donnes lire ou crire.

Comme ce schma l'indique, ce Register File contient une entre d'adresse sur laquelle on place une suite de bit qui permet d'identifier le registre slectionner. Et oui, vous avez devins : cette suite de bit n'est autre que le nom du registre en question. Sur les processeurs avec un Register File, on peut voir le nom d'un registre comme une sorte d'adresse permettant d'identifier un registre dans le Register File. Bien sr, il y a des exceptions. Il ne faut pas oublier que certains registres n'ont pas de noms : le Program Counter, le registre d'tat, etc. Ceux-ci ne sont pas forcment rassembls avec les autres registres et sont souvent intgrs dans des circuits spcialiss ou mis part des autres registres. Ce n'est pas systmatique : on peut placer ces registres dans un Register File, mais c'est rarement utilis. Dans ce cas, on doit jouer un peu sur les noms de registre avant de les envoyer sur les entres d'adresse du Register File. Rien de bien mchant.

Mmoire multiports
Comme vous l'avez remarqu sur le schma, le Register File a une petite particularit : les critures et les lectures ne passent pas par les mmes ensembles de fils. On a un ensemble de fils pour la lecture, et un autre pour les critures. Tout se passe comme si notre Register File tait reli deux bus de donnes : un pour les lectures, et un pour les critures. Ces ensembles de fils sappellent des ports. Vu que notre Ces ensembles de fils possde plusieurs de ces ports, il s'agit de ce qu'on appelle une mmoire multiports. Mais cette technique, qui consiste fournir plusieurs ensembles de fils pour des lectures ou criture va souvent plus loin : on ne se limite pas deux ports. On peut avoir bien plus que deux ports ! On peut avoir plusieurs ports pour les lectures, voire plusieurs ports pour les critures. Cela permet d'effectuer plusieurs lectures ou critures simultanment.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

139/378

Cela permet de lire (voire d'crire) dans plusieurs registres en une seule fois si le reste du processeur est adapt. Mine de rien, beaucoup d'instructions ont besoin de lire plusieurs registres la fois : une addition a besoin de deux oprandes, pareil pour la soustraction, la comparaison, la multiplications, etc. Beaucoup d'instructions de nos processeurs ont besoin de lire deux donnes pour donner leur rsultat : elles sont dites dyadiques. Et ne parlons pas des (rares) instructions ayant besoin de trois oprandes. Autant dire que crer des mmoires permettant de lire plusieurs registres la fois sont un plus apprciable. Il faut savoir que plus un Register File a de ports, plus il a tendance tre complexe et chauffer. La quantit d'nergie consomme par une mmoire est proportionnelle son nombre de ports : plus on en met, plus notre mmoire va consommer de courant et chauffer. Et notre Register File ne fait pas exception la rgle. Les concepteurs de processeurs sont donc obligs de faire des compromis entre le nombre de ports du Register File (et donc la performance du processeur), et la chaleur dgage par le processeur.

Plusieurs Register Files

Utiliser un gros Register File n'est pas sans dfauts. Un gros Register File consomme beaucoup d'nergie et chauffe beaucoup. Sans compter qu'un gros Register File est plus lent qu'un petit. Quand le nombre de registres augmente dans le processeur, il devient difficile d'utiliser un seul gros Register File. On doit alors trouver une autre solution. Et celle-ci est assez simple : il suffit de scinder ce gros Register File en plusieurs Register Files spars. Utiliser plusieurs Register Files spars a des avantages : cela consomme nettement moins d'nergie, rend le Register File plus rapide, et chauffe beaucoup moins. Cela rend le processeur lgrement plus difficile fabriquer, mais le jeu en vaut la chandelle. C'est assez souvent utilis sur les architectures dont les registres sont spcialiss, et ne peuvent contenir qu'un type bien dfini de donne. Sur ces processeurs, certains registres sont conus pour stocker uniquement des entiers, des flottants, des adresses, etc. On peut ainsi avoir un Register File pour les registres chargs de stocker des flottants, un autre pour les registres stockant des entiers, un autre pour les adresses, etc. Mais ce n'est toutefois pas une obligation : rien ne nous empche de regrouper tout ces registres spcialiss dans un seul gros Register File qui rassemble presque tous les registres. Par exemple, c'est le cas des Pentium Pro, Pentium II, Pentium III, ou des Pentium M : ces processeurs ont des registres spars pour les flottants et les entiers, mais ils sont regroups dans un seul Register File. Autre remarque : rien ne nous empche d'utiliser plusieurs Register Files sur un processeur qui utilise des registres gnraux, non spcialiss. Cela s'utilise quand le nombre de registres du processeur devient vraiment important. Il faut juste prvoir de quoi changer des donnes entre les diffrents Register Files.

Communication avec la mmoire

La communication avec la mmoire est assez simple : il suffit juste de placer l'adresse laquelle accder sur le bus d'adresse, configurer le fameux bit R/W qui permet de dire si on veut lire ou crire, et ventuellement crire une donne sur le bus de donne dans le cas d'une criture. Rien de plus simple, donc. Pour cela, notre unit de communication avec la mmoire doit donc avoir deux entres : une pour spcifier l'adresse laquelle lire ou crire, et une qui permettra d'indiquer si on veut effectuer une lecture ou une criture. Elle doit aussi avoir une autre entre/sortie connecte au bus de donne. Celle-ci peut ainsi tre crite (criture) ou lue (lecture).

www.siteduzero.com

Partie 3 : Processeur et Assembleur

140/378

Pour ce faciliter la vie, et pour simplifier la conception du processeur, ces bus sont parfois relies des registres : les registres dinterfaage mmoire. Ainsi, au lieu d'aller lire ou crire des donnes et des adresses directement sur le bus, on peut alors simplement aller lire ou crire dans des registres spcialiss. Les registres dinterfaage mmoire sont intercals entre le bus mmoire et le reste du processeur (son chemin de donnes). Gnralement, on trouve deux registres dinterfaage mmoire : un registre d'adresse, reli au bus d'adresse ; et un registre de donne, reli au bus de donne. On trouve ainsi un registre dans lequel aller placer l'adresse laquelle lire ou crire, et un autre registre reli au bus de donne accessible en lecture ou criture. Utiliser des registres dinterfaage mmoire permet de relier facilement les bus d'adresse et de donne au reste du chemin de donnes. Cela permet ainsi d'implmenter certains modes d'adressages facilement, sans avoir trop se prendre la tte : le mode d'adressage indirect registre, qui ncessite de relier un registre notre bus d'adresse, en est un bon exemple. V quoi ressemble notre unit de communication avec la mmoire. Certaines units sont un peu plus intelligentes et sont oil capables de faire les calculs d'adresses ncessaires pour certains modes d'adressages. Au lieu d'utiliser notre ALU pour faire ces calculs, on peut la librer pour en faire autre chose. Mais cela ncessite de dupliquer des circuits, ce qui n'est pas gratuit.

Bus interne au processeur

Pour changer des informations entre les composants du Datapath, on utilise un ou plusieurs bus internes au processeur qui relie tous les registres et lunit de calcul entre eux. Bien videmment, il faudra bien grer ce bus correctement pour pouvoir changer des informations entre units de calculs et registres. Ce serait dommage de se tromper de registre et d'crire au mauvais endroit, ou de choisir la mauvaise instruction excuter. Cette gestion du bus interne sera dlgue au squenceur (qui ne fait pas que , bien sr).

Une histoire de connexion

Imaginons que je souhaite excuter une instruction qui recopie le contenu du registre R0 dans R2 : il va me falloir slectionner les deux registres correctement via ce bus. De mme, si je veux excuter une instruction comme une racine carre sur le contenu d'un registre, je dois fatalement connecter le bon registre sur l'entre de l'ALU. Bref, quelque soit la situation, je dois relier certains composants sur le bus correctement, et dconnecter tous les autres. Pour cela, chaque composant d'un processeur est reli au bus via des interrupteurs. Il nous suffit d'intercaler un interrupteur sur chaque fil qui spare le bus de notre composant. Pour slectionner le bon registre ou l'unit de calcul, il suffira de fermer les bons interrupteurs et d'ouvrir les autres. Le principe de gestion du chemin de donne reste le mme : pour excuter une tape d'une instruction, il faut commander des interrupteurs correctement, et ventuellement configurer l'ALU et le register file pour choisir la bonne instruction et les bons registres. Tout cela est gr par le squenceur. On remarque immdiatement une chose : chaque interrupteur doit tre command : on doit lui dire s'il doit se fermer ou s'ouvrir. Oui, vous avez vus o je veux en venir : cet interrupteur n'est rien d'autre qu'un transistor (on utilise aussi des multiplexeurs dans certaines situations). Mais comment on fait pour prciser le sens de transfert des donnes sur le bus ?

En fait, on a pas vraiment besoin de prciser le sens de transfert. L'criture et la lecture ne se font pas par les mmes broches, quelque soit le composant slectionner : cela et vrai pour les ALU ou pour les registres. On a un ensemble dentres pour la lecture, et un ensemble de sorties spcialement ddies pour l'criture. Ces ensembles d'entre-sortie forment ce qu'on appelle un port dentre ou de sortie. Tout ce qu'il faut faire, c'est ouvrir ou fermer les interrupteurs reliant le bon port au bus interne.

Chemin de donne un seul bus

Si vous vous souvenez du dbut de ce chapitre, j'ai dit que sur certains processeurs, lexcution d'une instruction ne travaillant que dans des registres pouvait prendre plusieurs tapes.

tape 1 tape 2 Fetch Decode

tape 3 Rcupration des oprandes

tape 4 Calcul

tape 5 Enregistrement du rsultat

Sachez que ces processeurs sont ceux qui n'utilisent qu'un seul bus interne dans leur processeur. Il utilisent aussi un register file avec seulement un port (qui sert alors aussi bien pour les critures que pour les lectures) ou deux ports (un pour l'criture, et un

www.siteduzero.com

Partie 3 : Processeur et Assembleur

pour la lecture).

141/378

Prenons un exemple : imaginez qu'on souhaite effectuer une addition entre deux registres. Il faut deux nombres pour que notre addition fonctionne. Il va nous falloir relier l'ALU ces deux registres, ce qui impossible avec un seul bus : on ne peut envoyer qu'une seule donne la fois sur le bus ! On pourra donc avoir accs une donne, mais pas l'autre. Pour rsoudre ce problme, on a pas vraiment le choix : on doit utiliser un registre temporaire, directement reli notre ALU, qui stockera une des deux donne ncessaire notre instruction. De mme, il est prfrable d'utiliser un registre temporaire pour stocker le rsultat : comme cela, on vite que celui-ci se retrouve immdiatement sur le bus de donne en mme temps que la seconde oprande.

Le droulement d'une addition est donc simple : il faut recopier la premire donne dans le registre temporaire, connecter le registre contenant la deuxime donne sur lentre de lunit de calcul, lancer la division en envoyant le bon code sur lentre de section de l'instruction de l'ALU, et recopier le rsultat dans le bon registre. Cela se fait donc en plusieurs tapes, chacune d'entre elle devant configurer le chemin de donnes.

Et avec plusieurs bus ?

Certains processeurs s'arrangent pour relier les composants du Datapath en utilisant plusieurs bus, et en utilisant un register file multiport. Cela permet de simplifier la conception du processeur ou d'amliorer ses performances. Par exemple, en utilisant plusieurs bus internes, un calcul dont les oprandes sont dans des registres et dont le rsultat tre stock dans un registre peut se faire en une seule tape (souvenez-vous du dbut de ce chapitre). On gagne donc en rapidit.

tape 1 tape 2 Fetch Decode

tape 3 Rcupration des oprandes, calcul, et enregistrement du rsultat

Pour cela, il suffit d'utiliser trois bus, relis sur nos registres, l'ALU et le bus de donnes comme indiqu dans le schma qui suit.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

142/378

Avec cette organisation, notre processeur peut grer les modes d'adressage absolus, et registre, pas plus. C'est en quelque sorte l'architecture minimale de tout processeur utilisant des registres. Avec une organisation plus complexe, on peut grer d'autres modes d'adressage plus facilement. On remarque qu'avec cette organisation, les lectures en mmoire, les critures, et les instructions travaillant sur des registres se font en une seule tape. Pour le mode d'adressage absolu, c'est notre squenceur qui s'occupe de commander le bus d'adresse, mais les donnes doivent transiter entre les registres et la mmoire : on a donc besoin de relier nos registres au bus de donne.

Adressage immdiat
Pour grer l'adressage immdiat, on n'a pas vraiment le choix : on doit placer la constante inscrite dans l'instruction sur l'entre de notre ALU. Cette constante est fournie par le squenceur : lorsque celui-ci dcode l'instruction, il va savoir qu'un morceau de l'instruction est une constante, et il va pouvoir l'envoyer directement sur l'ALU. Pour ce faire, une sortie du squenceur va tre reli sur l'entre de notre ALU via un des bus. Seul problme : on ne va pas pouvoir rajouter un bus exprs pour le squenceur. Gnralement, on rutilise un bus qui sert pour relier les registres l'entre de l'ALU, et on lui permet d'tre connect soit sur cette sortie du squenceur, soit sur nos registres. On utilise pour cela un gros paquet de multiplexeurs.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

143/378

Sur certains processeurs, cette constante n'est pas toujours positive, et peut aussi tre ngative. Elle est gnralement code en complment deux, et ne prend pas autant de bits que ce qu'un registre permet de stocker. Ces constantes sont souvent codes sur 8 ou 16 bits : aller au del serait inutile vu que la quasi-totalit des constantes manipules par des oprations arithmtiques sont trs petites et tiennent dans un ou deux octets. Le seul problme, c'est que pour tre envoye en entre de l'unit de calcul, une constante doit tre convertie en un nombre de mme taille que ce que peut manipuler notre ALU. Par exemple, si notre ALU manipule des donnes sur 32 bits et que nos registres font 32 bits, une constante code sur 8 ou 16 bits devra tre convertie en un nombre de 32 bits. Cela se fait en recopiant le bit de signe dans les bits de poids fort supplmentaires (rappelez-vous, on a vu a dans le premier chapitre). Pour effectuer cette extension de signe, on peut soit implanter un circuit spcialis qui s'occupera d'effectuer cette extension de signe directement, soit on utilise l'ALU pour effectuer cette extension de signe, on enregistre notre constante convertie dans un registre, et on effectue notre calcul.

Adressage indirect registre

La gestion du mode d'adressage indirect registre est assez simple. Il suffit juste de relier un des bus interne du processeur sur le bus d'adresse, ou sur le registre dinterfaage mmoire adquat. Il suffit alors de relier le bon registre (celui qui contient l'adresse laquelle accder) sur le bus d'adresse. Si on veut effectuer une criture, il suffit denvoyer la donne crire sur le bus de donne via un autre bus interne au processeur.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

144/378

Conclusion
Bref, je suppose que vous voyez le principe : on peut toujours adapter lorganisation des bus internes de notre processeur pour grer de nouveaux modes d'adressages, ou pour amliorer la gestion des modes d'adressages existants. On peut ainsi diminuer le nombre d'tapes ncessaires pour xecuter une instruction en ajoutant des bus ou en modifiant leur configuration. Par exemple, on peut faire en sorte que les instructions manipulant une seule de leurs oprandes en mmoire et qui stockent leur rsultat dans un registre s'effectuent en une seule tape : il suffit d'adapter l'organisation vue au-dessus en reliant le bus de donne sur l'entre de l'unit de calcul. On peut aussi grer des instructions manipulant toutes leurs oprandes en mmoire en utilisant plusieurs registres dinterfaage, qui peuvent tre relis aux entres des units de calcul, etc. Bref, lorganisation du chemin de donne d'un processeur dpend fortement de ses modes d'adressage, et de sa conception : deux processeurs avec des modes d'adressage identiques seront conus diffremment, et n'effectueront pas forcment les mme tapes pour xecuter la mme instruction.

Le dcodage d'une instruction

Comme on l'a vu plus haut, notre chemin de donne est remplit d'interrupteurs et de multiplexeurs configurer. Suivant l'interruption excuter, il faut configurer ceux-ci d'une certaine manire pour que notre chemin de donne soit configur correctement. Il faut de plus configurer l'entre de slection de l'instruction de notre ALU, ainsi que placer ce qu'il faut sur les entres d'adresses du register file.

Units de dcodage d'instruction

Il faut donc dduire les bons bits envoyer sur les entres correspondantes, en fonction de l'opcode et du mode d'adressage de l'instruction excuter. C'est le rle du squenceur ! Notre squenceur doit donc grer le chemin de donnes pour que celui-ci excute correctement l'instruction voulue et pas une autre, en tenant compte des diffrents modes d'adressage et de l'opcode de l'instruction : on dit qu'il dcode l'instruction. Notre squenceur va donc envoyer des "ordres" qui vont configurer les circuits du chemin de donne (ALU, register file, interrupteurs, multiplexeurs, etc) et leur faire faire ce qu'il faut pour excuter notre instruction. Ces ordres sont des bits individuels ou des groupes de bits qu'il faut placer sur les entres des units de calcul, du register file, ou des circuits de gestion du bus interne au processeur (les fameux interrupteurs vus plus haut) dans un ordre bien prcis : on les appelle des signaux de commande. Lorsque nos units de calculs (ou d'autres circuits du processeur) reoivent un de ces signaux de commande, elles sont conues pour effectuer une action prcise et dtermine. Dcoder une instruction est simple : partir l'opcode et de la partie variable de notre instruction, il faut dduire le ou les signaux de commande envoyer au chemin de donnes ou la Memory Management Unit, et parfois dduire l'ordre dans lequel envoyer

www.siteduzero.com

Partie 3 : Processeur et Assembleur

145/378

ces signaux de commande. Pour cela, notre processeur intgre un circuit spcialement ddi cette tape de dcodage : l'unit de dcodage d'instruction.

Un des signaux de commande gnr par notre squenceur est donc le mot binaire placer sur l'entre de slection d'instruction de l'unit de calcul choisie. Bien sr, il y a d'autres signaux de commandes envoyer dans le processeur, mais tout dpend de son architecture et il est trs compliqu de faire des gnralits sur ce sujet. Une des entres de notre squenceur est relie au registre d'instruction, afin d'avoir accs linstruction dcoder. Le registre d'tat est aussi reli sur une entre du squenceur : sans cela, pas de branchements !

Squenceurs cbls
Il existe des processeurs dans lesquels chaque instruction est dcode par un circuits lectronique fabriqu uniquement avec des portes ET, NON et OU relies entre elles : on appelle ce genre de squenceur un squenceur cbl. Ce genre de squenceur va se contenter de gnrer automatiquement les signaux de commande dans le bon ordre pour configurer le chemin de donne et excuter notre instruction. Plus le nombre d'instructions cbler est important, plus le nombre de portes utilises pour fabriquer notre squenceur augmente. Si le nombre d'instructions cbler est trop grand, on a besoin de tellement de portes que le cblage devient un vritable enfer, sans compter le prix de toutes ces portes qui devient important. Autant dire que les processeurs CISC n'utilisent pas trop ce genre de squenceurs et prfrent utiliser des squenceurs diffrents. Par contre, les squenceurs cbls sont souvent utiliss sur les processeurs RISC, qui ont peu d'instructions, pour lequel la complexit du squenceur et le nombre de portes est assez faible et est supportable.

Squenceur micro-cod
Vu que crer des squenceur cbls est souvent un gouffre en terme de portes logiques lorsqu'on rajoute un peu trop d'instructions, il a bien fallu trouver une petite solution. Pour limiter la complexit du squenceur, on fait en sorte que celui-ci ne puisse dcoder qu'un faible nombre d'instructions pour limiter sa complexit, et on se dbrouille avec ces instructions pour simuler ou muler les instructions restantes. Sur de tels processeurs, chaque instruction ne va pas tre dcode directement en signaux de commande, mais va d'abord tre dcoupe en plusieurs instructions beaucoup plus lmentaires, qui seront dcodes unes par unes. Par exemple, sur certains processeurs, la racine carre est dcoupe en plusieurs instructions plus lmentaires excutes dans un ordre bien prcis. Il existe bien une instruction SQRT dans le jeu d'instruction de ces processeurs, mais le squenceur ne dcode pas cette instruction directement : il lexcute sous la forme d'une suite de divisions et de soustractions successives, excutes en boucle. Ce genre de processeurs utilisent ce qu'on appelle des squenceurs micro-cods. Avec ces processeurs, il faut bien faire la diffrence entre : les micro-oprations ou ops, directement excutables par les units de calcul du processeur ; et les instructions du jeu d'instructions aussi appeles instructions micro-codes qui sont mules par une suite de micro-oprations.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

146/378

Ces micro-oprations sont des instructions comme les autres, crites en binaire, avec un opcode et une partie variable, qui seront dcodes par le squenceur, mais qui n'appartiennent pas forcment au jeu d'instruction du processeur. Il faut bien se rendre compte que les micro-oprations sont compltement caches au programmeur qui ne peut pas concevoir un programme avec des micro-oprations, et n'a accs qu'aux instructions du jeu d'instruction. Avec un squenceur micro-cod, chaque instruction machine est quivalente une suite de micro-oprations excute dans un ordre prcis. Chaque instruction machine est traduite en suite de micro-oprations lors de son excution, chaque fois qu'on lexcute. Sur ce genre de processeurs, le squenceur doit traduire chaque instruction du jeu d'instruction en micro-instructions dcodables par le squenceur. Cette traduction se fait lexcution, instruction par instruction. L'ensemble des micro-oprations support par le processeur s'appelle le micro-assembleur. Pour reprendre l'exemple de la racine carre, celle-ci est traduite en une suite de micro-oprations qui donne le rsultat voulu : il s'agit souvent d'une boucle contenant des divisions et soustractions.

Control store
Le dcodage d'une micro-opration ne pose pas trop de problmes : on sait que nos micro-oprations sont des instructions comme les autres, avec un opcode et une ou des oprandes. Elles seront dcodes et excute comme une instruction machine le serait avec un squenceur cbl. Mais il faut imprativement "dcoder" une instruction machine en une suite de microoprations quivalente, capable d'tre excute par les circuits de notre processeur. Pour cela, notre squenceur contient une petite mmoire, souvent de type ROM, qui stocke pour chaque instruction micro-code la suite de micro-oprations quivalente. Cette mmoire s'appelle le control store et les suites de micro-oprations contenues dans ce control store s'appelle le micro-code. Comment notre squenceur va faire la correspondance entre une instruction micro-code et la suite de micro-oprations correspondante dans ce control store ?

Pour retrouver la suite de micro-oprations correspondante, notre squenceur considre l'opcode de l'instruction micro-code comme une adresse. Le control store est conu pour que cette adresse pointe directement sur la suite de micro-oprations correspondante dans la mmoire ROM.

La micro-opration est alors recopie dans un registre, le registre de micro-opration, qui est aux micro-oprations ce que le registre d'instruction est aux instructions machines. Il sert stocker une micro-oprations pour que le squenceur puisse dcoder celle-ci.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

147/378

Bien sr, pour ne pas se contenter d'excuter une seule micro-opration et passer la suivante, le squenceur micro-cod contient un registre dadresse de micro-opration qui stocke l'adresse de la micro-opration en cours dexcution. Lorsque le dcodage d'une instruction machine commence, l'instruction machine, localise dans le registre d'instruction, est recopie dans ce micro-registre d'adresse d'instruction. Puis, le contenu du registre d'adresse d'instruction est alors augment de faon pointer sur la micro-opration suivante, et ainsi de suite jusqu' ce qu'on aie excut toute la suite de micro-oprations. Pour cela, ce registre d'adresse de micro-opration est coupl un micro-compteur ordinal, qui augmente l'adresse de ce registre d'adresse de micro-opration de faon passer la micro-opration suivante, jusqu' pointer sur la fin de la suite de microoprations correspondant l'instruction machine. On peut mme fabriquer ce micro-compteur ordinal de faon permettre les branchements entre micro-oprations : une instruction machine peut ainsi tre mule par une boucle de micro-oprations, par exemple.

l'ensemble est appel le micro-squenceur. le contenu du control store est parfois stock dans une EEPROM et est ainsi modifiable : on peut ainsi changer son contenu et donc modifier ou corriger le jeu d'instruction du processeur si besoin. Idal pour corriger des bugs ou ajouter des instructions, voire optimiser le jeu d'instruction du processeur si besoin est.

Micro-code horizontal et vertical

Il existe deux sous-types de squenceurs micro-cods : ceux qui utilisent un micro-code vertical, et ceux qui utilisent un microcode horizontal. Le micro-code horizontal est le plus utilis de nos jours, du fait de sa simplicit et ses avantages sur le microcode vertical.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

148/378

Le micro-code horizontal est simple : chaque instruction du micro-code (chaque micro-opration) encode directement les signaux de commande envoyer aux units de calcul. Il suffit d'envoyer les bits sur les bons fils pour faire en sorte que le chemin de donnes fasse ce qu'il faut. Avec un micro-code vertical, ce n'est pas le cas : il faut traduire les micro-oprations en signaux de commande l'aide d'un squenceur cbl. Un squenceur micro-cod utilisant un micro-code vertical est divis en deux parties : un micro-squenceur, et une unit de dcodage cble de micro-oprations qui dcode les micro-oprations en signaux de commandes. Le micro-code vertical a un gros dsavantage : il faut placer une unit de dcodage cble supplmentaire dans le processeur. Cette unit est malgr tout trs simple et utilise peu de portes logiques, ce qui est souvent supportable. Le principal dsavantage est le temps mis par cette unit pour traduire une micro-opration en signaux de commande n'est pas ngligeable. L'avantage, c'est qu'on peut rduire le nombre de bits utiliss pour chaque micro-opration : il n'est pas rare que les instructions d'un microcode horizontal fassent plus d'une centaine de bits ! De nos jours, nos processeurs utilisent tous un micro-code horizontal, pour conomiser en circuits.

Fusion de micro-oprations
Un squenceur micro-cod peut effectuer pas mal d'optimisations. Dans certains de cas, le squenceur peut fusionner plusieurs instructions machines sexcutant l'une aprs l'autre en une seule micro-opration. Par exemple, un processeur peut dcider de fusionner une instruction de test suivie d'un branchement en une seule microopration effectuant le comparaison et le branchement et une seule fois. Cette dernire technique est trs efficace : il faut savoir qu'environ une instruction sur 10 est un branchement prcd d'une instruction de test. Implmenter une telle fusion entre branchements et tests permet ainsi de gagner en performance assez rapidement et a pas mal d'avantages sur les architectures actuelles.

Avantages et inconvnients
Les squenceurs micro-cods sont plus simples concevoir : ils n'utilisent pas un grand nombre de portes logiques qu'il faudrait relier entre elles, et cela simplifie beaucoup le travail des concepteurs de processeurs. De plus, le micro-code est stock dans une mmoire qu'on peut reprogrammer : on peut ainsi rajouter des instructions, corriger certains bugs du processeur, ou encore amliorer la vitesse d'une instruction en mettant jour le micro-code. Cela a un avantage norme : on peut conserver le mme jeu d'instruction et amliorer les circuits du processeur sans avoir recrer tout un processeur. Il suffit souvent de rcrire le micro-code et refaire les circuits des UAL, sans avoir refaire tout un squenceur. On peut aussi corriger plus facilement les erreurs de conception d'un processeur. Quand on cre un processeur, on commet souvent des erreurs plus ou moins graves. Et bien sachez que ce certains bugs peuvent tre corrigs plus facilement avec un squenceur micro-cod : il suffit de mettre jour le micro-code. Avec un squenceur cbl, il faudrait refaire une grande partie du squenceur ou des units de calcul, ce qui prendrait un temps fou. Mais il y a aussi des inconvnients qui ne sont pas ngligeables. Un squenceur micro-cod est plus lent qu'un squenceur cbl : lire une ou plusieurs micro-oprations depuis une mmoire est bien plus lent que de simplement manipuler des bits avec des portes logiques.

Squenceurs hybrides
Comme je l'ai dit plus haut, un squenceur micro-cod est plus conome en transistors et en portes logiques, tandis qu'un squenceur cbl est plus rapide. Le squenceurs hybrides sont une sorte de compromis entre ces deux extrmes : ils sont en partie cbls et en partie micro-cods. Gnralement, une partie des instructions est dcode par la partie cble du squenceur, pour plus de rapidit tandis que les autres instructions sont dcodes par la partie micro-code du squenceur. Cela permet d'viter de cbler une partie du squenceur qui prendrait beaucoup de portes pour dcoder des instructions complexes, gnralement rarement utilises, tout en gardant un dcodage rapide pour les instructions simples, souvent utilises. Parfois, cette technique est adapte en scindant les parties cbles et les parties micro-codes en plusieurs unit de dcodage d'instructions bien spares. Notre processeur contient ainsi plusieurs unit de dcodage d'instruction, l'une d'entre elle tant cble, et l'autre est micro-code. Et oui, c'est ainsi : on peut parfois avoir plusieurs units de dcodage d'instruction spares dans un seul processeur. Pour donner un exemple, un processeur Intel bas sur l'architecture Core contient 3 dcodeurs cbls, et un dcodeur micro-cod.

Les transport triggered architectures

Sur certains processeurs, les instructions machines sont trs simples et correspondent directement des micro-instructions qui

www.siteduzero.com

Partie 3 : Processeur et Assembleur

149/378

agissent sur le bus. En clair, toutes les instructions machines permettent de configurer directement le bus interne au processeur, et il n'y a pas de squenceur ! De tels processeurs sont ce qu'on appelle des transports triggered architectures. Sur ces processeurs, on ne peut donc que configurer le bus. Pire : le bus est organis de faon ce qu'on ne puisse pas avoir accs aux units de calcul directement : on doit passer par des registres intermdiaires spcialiss dont le but est de stocker les oprandes d'une instruction. Tout ce qu'on peut faire, c'est connecter des registres sur le bus pour leur faire changer des donnes et communiquer avec la mmoire. On pourrait se dire que rien ne permet d'effectuer d'instructions d'additions ou d'oprations de ce genre et que ces processeurs sont un peu inutiles. Mais ce n'est pas le cas ! En fait, ces processeurs rusent. Ces processeurs contiennent des registres spciaux, relis une unit de calcul. Ces registres servent spcialement stocker les oprandes d'une instruction machine, tandis que d'autres servent aussi dclencher des instructions : lorsqu'on crit une donne dans ceux-ci, cela va automatiquement dclencher lexcution d'une instruction bien prcise par l'unit de calcul, qui lira le contenu des registres chargs de stocker les oprandes. Par exemple, un processeur de ce type peut contenir trois registres Add.oprande.1, Add.dclenchement et Add.rsultat . Le premier registre servira stocker la premire oprande de l'addition. Pour dclencher l'opration d'addition, il suffira d'crire la seconde oprande dans le registre Add.trigger, et l'instruction sexcutera automatiquement. Une fois l'instruction termine, le rsultat de l'addition sera automatiquement crit dans le registre Add.resultat . Il existera des registres similaires pour la multiplication, la soustraction, les comparaisons, etc. Sur certains de ces processeurs, on a besoin que d'une seule instruction qui permet de copier une donne d'un emplacement (registre ou adresse mmoire) un autre. Pas d'instructions Load, Store, etc : on fusionne tout en une seule instruction supportant un grand nombre de modes d'adressages. Et donc, on peut se passer compltement d'opcode, vu qu'il n'y a qu'une seule instruction : pas besoin de prciser quelle est celle-ci, on le sait dj. Sympa, non ? L'utilit de ces architectures n'est pas vidente. Leur raison d'exister est simplement la performance : manipuler le bus interne au processeur directement au lieu de laisser faire les circuits du processeur permet de faire pas mal de raccourcis et permet quelques petites optimisations. On peut ainsi travailler directement avec des micro-instructions au lieu de devoir manipuler des instructions machines, ce qui permet parfois de ne pas utiliser de micro-instructions en trop. Mais lintrt est assez faible.

L'tape de fetch
On a donc nos units de calcul bien fonctionnelles, bien comme il faut. Notre processeur ne peut malgr tout pas encore effectuer d'instructions. Ben oui : on doit grer l'tape de Fetch. Pour cela, notre squenceur va intgrer un registre spcial : le registre d'adresse d'instruction. Ce terme doit fatalement vous rappeler quelque chose : on en a dj parl dans les chapitres prcdents.

Registre pointeur instruction

L'tape de fetch consiste copier l'instruction excuter dans le registre d'instruction. Pour savoir o est cette instruction, le processeur stocke son adresse dans un registre. Comme vous le savez, ce registre s'appelle le registre d'adresse d'instruction. Pour charger notre instruction, il suffit de recopier le contenu du registre d'adresse d'instruction sur le bus d'adresse (en passant ventuellement par un registre dinterfaage mmoire), configurer le bus de commande pour effectuer une lecture, et connecter le bus de donne sur le registre d'instruction (en passant ventuellement par un registre dinterfaage mmoire). Le squenceur le fait automatiquement, en envoyant les signaux de commande adquats. Au dmarrage d'un programme, notre processeur doit excuter la premire instruction, place une certaine adresse dans la mmoire programme. Il suffit d'initialiser le registre pointeur d'instruction cette adresse pour commencer au bon endroit. Navement, on peut penser que la premire adresse de la mmoire programme est l'adresse 0, et qu'il suffit d'initialiser le registre pointeur d'instruction 0. Mais c'est parfois faux : sur certains processeurs, les premires adresses sont rserves et servent adresser des trucs assez importants, comme la pile ou le vecteur d'interruptions. L'adresse de dpart de notre programme n'est pas l'adresse 0, mais une autre adresse. Dans ces cas-l, le processeur est conu pour initialiser le registre pointeur d'instruction la bonne adresse. Juste une remarque : les processeurs haute performance modernes peuvent charger plusieurs instructions qui se suivent en une seule fois et copier le tout dans le registre d'instruction. Cela permet d'viter d'accder trop souvent la mmoire.

Compteur ordinal
On sait donc o est localise notre instruction dans la mmoire. C'est super, une partie du problme est rsolue. Reste la seconde partie. Et l'instruction suivante, c'est quoi son adresse ?

Aie ! Les ennuis commencent. Excuter une suite d'instructions sans savoir o est la suivante risque d'tre un peu compliqu.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

Pour rpondre : on ne sait pas o est la prochaine instruction, mais on peut le calculer !

150/378

Le fait que les instructions soient toutes stockes dans l'ordre dans la mmoire nous arrange bien. Pour calculer l'adresse suivante facilement, il faut que toutes les instructions soient places les unes cot des autres en mmoire et surtout qu'elles y soient classes dans l'ordre dans lesquelles on veut les excuter. Quand on dit "classes les unes cot des autres et dans l'ordre", a veut dire ceci : Adresse 1 2 3 4 5 ... 5464 Instruction Charger le contenu de l'adresse 0F05 Charger le contenu de l'adresse 0555 Additionner ces deux nombres Charger le contenu de l'adresse 0555 Faire en XOR avec le rsultat antrieur ... Instruction d'arrt

Dans cet exemple, une instruction peut tre stocke dans une seule adresse. En fait, ce n'est pas toujours le cas : parfois, une instruction peut tenir dans plusieurs cellules mmoire, mais le principe reste le mme. Avec ce genre d'organisation des instructions en mmoire, on peut alors calculer l'adresse de l'instruction suivante en mmoire avec des additions. Cette addition peut tre effectue de deux manires : soit on utilise notre ALU pour effectuer cette addition, soit on dlgue cette tache un circuit spcialis. Avec la premire solution, il suffit de rajouter une tape pour xecuter notre instruction : en plus des tapes de Fetch, de dcodage, et les autres, dpendantes du mode d'adressage ou de l'instruction, on rajoute une ou plusieurs tapes qui vont modifier le registre d'adresse d'instruction pour le faire pointer sur l'instruction suivante. Le registre d'adresse d'instruction est reli au chemin de donne et le calcul de l'adresse suivante est ainsi ralise par l'ALU. Avec la seconde solution, le calcul de l'adresse de l'instruction suivante est le rle d'un petit circuit nomm le compteur ordinal. Ainsi, pas besoin de rajouter des tapes supplmentaires pour effectuer notre calcul d'adresse : celui-ci est effectu en parallle de lexcution de notre instruction, automatiquement, sans avoir utiliser le chemin de donne. Cette solution demande de rajouter un circuit, mais ce circuit est assez rudimentaire, et ne prend presque pas de place : on a tout gagner utiliser cette deuxime solution sur de gros processeurs. Une fois cette adresse calcule, il suffira de l'envoyer sur le bus d'adresse, configurer le bus de commande en lecture, et connecter le registre d'instruction sur le bus de donne pour la charger dans le registre d'instruction.

www.siteduzero.com

Partie 3 : Processeur et Assembleur

151/378

Le calcul de l'adresse suivante

On sait maintenant comment est organise notre unit de fetch. Il serait maintenant intressant de chercher savoir comment notre compteur ordinal va faire pour calculer l'adresse de l'instruction suivante. Sachez que la mthode varie suivant le processeur et suivant la longueur de l'instruction. Mais dans tous les cas, elle se base sur un principe simple : l'instruction suivante est immdiatement aprs l'instruction en cours. On peut donc calculer cette prochaine adresse via un calcul super simpliste. Adresse de la prochaine instruction = Adresse de l'instruction en cours + Longueur de l'instruction en cours

Exemple : l'instruction en cours est stock l'adresse 12, et fait 4 bytes de long. On voit bien que l'instruction suivante est place l'adresse 12 + 4 (ce qui fait 16). L'adresse de l'instruction suivante est donc gale l'adresse de l'instruction en cours, plus la longueur de cette instruction.

L'adresse de l'instruction en cours est connue : elle est stocke dans le registre d'adresse d'instruction avant sa mise jour. Reste connaitre la longueur cette instruction.

Instructions de tailles fixes

Calculer l'adresse de l'instruction suivante est trs simple lorsque les instructions ont toutes la mme taille. La longueur tant connue, on sait d'avance quoi ajouter l'adresse d'une instruction pour obtenir l'adresse de l'instruction suivante. Notre compteur ordinal peut ainsi tre conu assez simplement, en utilisant un vulgaire circuit combinatoire encore plus simple qu'un additionneur.

Instructions de tailles variables

Mais cette technique ne marche pas tous les coups : certains processeurs CISC ont des instructions qui ne sont pas de taille fixe, ce qui complique le calcul de l'adresse de l'instruction suivante. Il y a plusieurs solutions ce problme. La plus simple consiste indiquer la longueur de l'instruction dans une partie de l'opcode ou de la reprsentation en binaire de l'instruction. Une fois cette longueur connue, on effectue alors l'addition avec le contenu du registre d'adresse d'instruction et puis c'est fini. Une autre solution consiste simplement charger notre instruction en plusieurs fois. Ainsi, on charge notre instruction morceaux par morceaux et on rassemble le tout une fois qu'on a charg tout les morceaux de l'instruction. Les morceaux sont copis dans le registre d'instruction les uns la suite des autres. Quand la totalit de l'instruction est disponible, le processeur envoie l'instruction (contenue dans le registre d'instruction) vers les circuits chargs de dcoder l'instruction. Vu que chaque morceau a une taille fixe, le compteur ordinal est incrment chaque cycle d'horloge de la taille d'un morceau, exprime en nombre de cases mmoires. Le seul dfaut de cette approche, c'est qu'il faut trouver un moyen de savoir si une instruction complte t charge ou pas : un nouveau circuit est requis pour cela. Et enfin, il existe une dernire solution, qui est celle qui est utilise dans vos processeurs, ceux qu'on trouve dans les

www.siteduzero.com

Partie 3 : Processeur et Assembleur

152/378

processeurs haute performance de nos PC. Cette solution est un peu l'inverse de la solution prcdente. Avec la solution prcdente, on chargeait notre instruction morceaux par morceaux. Par exemple, on pouvait faire du byte par byte. Avec la mthode actuelle, on charge un gros bloc de bytes, trs gros. Gnralement, la taille de ce bloc est conue pour tre de la mme longueur que l'instruction la plus longue que le processeur peut supporter. Ainsi, on est sur de charger obligatoirement au moins une instruction complte, et peut-tre mme plusieurs, ce qui est un gros avantage. Ensuite, il suffit de dcouper ce bloc en instructions, en dduisant leur longueur au passage. Gnralement, ce dcoupage se fait instruction par instruction : on spare la premire instruction du reste du bloc et on l'envoie lunit de dcodage, puis on recommence jusqu' atteindre la fin du bloc. Cette solution pose quelques problmes : il se peut qu'on n'aie pas une instruction complte lorsque l'on arrive la fin du bloc, mais seulement un morceau. Imaginez par exemple le cas o un bloc 4 octets. On peut se retrouver dans des situations comme celle-ci :

La dernire instruction dborde : elle est cheval entre deux blocs. Dans ce cas, on a pas trop le choix : on doit charger le prochain bloc avant de faire quoique ce soit. Ceci dit, au del de ce petit inconvnient, cette technique a un gros avantage : on peut parfaitement charger plusieurs instructions en une fois, si elles sont regroupes dans un seul bloc. Et cela arrive trs souvent : on vite de nombreux accs la mmoire.

Les instructions qui posent problme

Dans de rares cas, pour certaines instructions et sur quelques rares architectures, on peut stopper le fonctionnement du compteur ordinal tant qu'une condition n'est pas remplie. Le compteur ordinal tant "stopp", les contenus du registre d'adresse d'instruction et du registre d'instruction ne sont pas modifis : on excute donc la mme instruction en boucle. On peut citer en exemple les instructions de traitement des chaines de caractres de l'instruction x86, qui peuvent tre rptes ainsi.

Les branchements
Lors d'un branchement, l'adresse de destination du branchement va tre copie dans le registre d'adresse d'instruction. Pour cela, il va falloir permettre l'accs en criture dans ce registre, sous certaines conditions. Pour les branchements directs (dont l'adresse est fournie par l'instruction), on permet au squenceur de fournir l'adresse de destination sur une de ses sorties relie plus ou moins indirectement sur notre registre d'adresse d'instruction. Pour les branchements indirects (ceux dont l'adresse de destination est stocke dans un registre), il suffit de relier le registre d'adresse d'instruction et le registre contenant l'adresse de destination du branchement via le bus interne au processeur. Il faudra alors choisir entre l'adresse calcule par notre compteur ordinal et l'adresse fournie par le squenceur, suivant loccurrence d'un branchement ou non. Ce choix est ralis par un certain nombre de multiplexeurs.

Comme vous le voyez sur ce schma, s'il n'y a pas de branchement, le multiplexeur se contente de relier la sortie du compteur

www.siteduzero.com

Partie 3 : Processeur et Assembleur

153/378

ordinal sur le registre d'adresse d'instruction. On va donc crire cette adresse calcule dans le registre d'adresse d'instruction et on va directement passer l'instruction suivante. En cas de branchement, le multiplexeur va relier la sortie du squenceur ou le registre (en cas de branchements indirects) dans lequel se trouve l'adresse du branchement : l'adresse calcule par notre compteur ordinal est perdue et on se retrouve avec l'adresse de notre branchement dans le registre d'adresse d'instruction. C'est le squenceur qui configure correctement le multiplexeur comme il faut, suivant loccurrence d'un branchement ou non.

Les branchements relatifs

Je ne sais pas si vous vous en souvenez, mais il existe un certain type de branchement qu'on a vu prcdemment : les branchements relatifs. Pour rappel, ces branchements demandent au processeur de brancher vers une adresse situe une certaine distance par rapport l'adresse de l'instruction en cours dexcution. Ces branchements permettent de localiser un branchement par rapport l'instruction en cours dexcution : par exemple, cela permet de dire "le branchement est 50 adresses plus loin". Pour prendre en compte ces branchements, on a encore une fois deux solutions. On peut rutiliser l'ALU pour calculer l'adresse de notre branchement. Mais on peut aussi faire autrement : il suffit juste de rajouter un petit circuit qui va alors additionner ce fameux dcalage l'adresse de l'instruction en cours, qui est bien videmment stocke dans le registre d'adresse dinstruction, et rajouter un multiplexeur pour se charger de slectionner l'adresse calcule ainsi quand il le faut.

C'est le squenceur qui configure correctement les multiplexeurs comme il faut, et qui fourni le dcalage, suivant loccurrence d'un branchement ou non, et suivant la localisation de l'adresse de destination (registre ou fournie par l'instruction). On remarque aussi qu'on pourrait faire cette addition du dcalage en utilisant l'ALU : il suffit de relier notre registre d'adresse d'instruction sur l'entre et la sortie de l'ALU (mais pas par les mme ports), et d'envoyer le dcalage sur une autre entre : tout se passe comme si l'on utilisait le mode d'adressage immdiat pour le dcalage, et le mode d'adressage implicite pour le registre d'adresse d'instruction.

Branchements indirects
Enfin, il faut encore grer les branchements indirects. Pour cela, il suffit simplement de relier notre registre d'adresse d'instruction sur un bus interne du processeur (via le chemin de donne, donc). On peut alors copier le contenu d'un registre dans notre registre d'adresse d'instruction, ce qui est exactement ce que fait un branchement indirect.

Lexception qui confirme la rgle

www.siteduzero.com

Partie 3 : Processeur et Assembleur

154/378

Attention, je vais vous faire une rvlation : certains processeurs ne contiennent pas de compteur ordinal et sont incapables de calculer la prochaine adresse. Ces processeurs utilisent une autre mthode pour indiquer au processeur quelle sera la prochaine instruction excuter : chaque suite de bits reprsentant une instruction contient l'adresse mmoire de la prochaine instruction excuter.

Les processeurs de ce type contiennent toujours un registre d'adresse d'instruction : la partie de l'instruction stockant l'adresse de la prochaine instruction est alors recopie dans ce registre, pour faciliter sa copie sur le bus d'adresse. Mais le compteur ordinal n'existe pas. Sur des processeurs aussi bizarres, pas besoin de stocker les instructions en mmoire dans l'ordre dans lesquelles elles sont censes tre excutes. Mais ces processeurs sont trs trs rares et peuvent tre considrs comme des exceptions qui confirment la rgle.

www.siteduzero.com

Partie 4 : Mmoires

155/378

Partie 4 : Mmoires
Comme son nom l'indique, ce chapitre va tenter de vous expliquer ce qu'est une mmoire et comment elle fonctionne. Nous allons voir en dtail ce qu'est une mmoire, comment fait-elle pour retenir des bits, et quelles sont les amliorations apportes sur les mmoires rcentes.

Mmoires
Mmoire.
Ce mot signifie dans le langage courant le fait de se rappeler quelque chose, de pouvoir s'en souvenir. La mmoire d'un ordinateur fait exactement la mme chose (vous croyez qu'on lui a donn le nom de mmoire par hasard ? ) mais dans notre ordinateur. Son rle est donc de retenir que des donnes stockes sous la forme de suites de bits, afin qu'on puisse les rcuprer si ncessaire et les traiter.

Des mmoires en veux-tu, en voil !

Maintenant qu'on a la dfinition d'une mmoire, autant prvenir tout ce suite : toutes les mmoires ne sont pas faites de la mme faon et il en existe diffrents types, chacun ayant ses avantages et ses inconvnients. Dans cette partie, on va passer en revue les diffrences les plus importantes.

Capacit mmoire
Pour commencer, on va commencer par enfoncer des portes ouvertes : on ne peut pas stocker autant de donnes qu'on veut dans une mmoire. V ous avez surement dj du en faire l'exprience : qui n'a jamais eu un disque dur, une disquette, un CD-ROM ou DVD, ou une cl USB pleine ? Et ce qui vaut pour les mmoires que je viens de citer au-dessus marche pour toutes les mmoires. Et ce petit jeu l, toutes les mmoires ne sont pas gales : certaines peuvent contenir plus de donnes que d'autres. C'est la premire diffrence entre nos mmoires : la quantit de donnes qu'elles peuvent stocker. Vu que toutes nos donnes sont stockes sous la forme de suites de bits, on peut facilement valuer la capacit d'une mmoire stocker un nombre plus ou moins de donnes : il suffit de compter le nombre maximal de bits qu'elle peut contenir. Ce nombre de bits que notre mmoire peut stocker porte un nom : c'est la capacit de la mmoire. Pour rsumer, nos mmoires n'ont pas la mme capacit, qui est le nombre maximal de bits qu'elle peut stocker. Dans la majorit des mmoires, les bits sont regroups en "paquets" contenant une quantit fixe de bits : des "cases mmoires", aussi appeles bytes. Gnralement, nos mmoires utilisent un byte de 8 bits. Autrefois, certaines mmoires avaient des cases mmoires de 6 ou 5 bits, parfois plus. Mais maintenant, la situation s'est un peu normalise et la grosse majorit des mmoires utilisent un byte de 8 bits. Au fait : un groupe de 8 bits s'appelle un octet. H, une minute ! Je croyais que byte et octet c'tait la mme chose ?

Rassurez-vous cher lecteur, c'est une erreur courante. Il faut vraiment connaitre le truc pour ne pas se faire avoir. En effet, un byte n'est pas un octet ! Vu que de nos jours nos mmoires utilisent des bytes d'un octet, on utilise souvent les deux termes de faon interchangeable. Mais a reste tout de mme un abus de langage. Le fait que nos mmoires aient presque toutes des bytes faisant un octet nous arrange pour compter la capacit d'une mmoire. Au lieu de compter cette capacit en bits, on prfre mesurer la capacit d'une mmoire en donnant le nombre d'octets que celleci peut contenir. Cela permet d'avoir des nombres plus petits et donne des quantits plus simples manipuler.

Kilo, giga, et compagnie

Comme dit plus haut, nos mmoires n'ont pas toutes la mme capacit : suivant la mmoire, elle peut varier de quelques octets plusieurs milliards d'octets. Le seul problme, c'est que les mmoires actuellement prsentes dans nos ordinateur sont tout de mme assez grosses : cela se compte en millions ou milliards d'octets. Et je ne vous apprends rien en disant que manipuler des quantits dpassant le milliard

www.siteduzero.com

Partie 4 : Mmoires

156/378

est loin d'tre facile. Pour se faciliter la tache, on utilise des prfixes pour dsigner les diffrentes capacits mmoires. V ous connaissez surement ces prfixes : kibioctets, mebioctets et gibioctets, nots respectivement Kio, Mio et Gio. Prfixe Kio Mio Gio Quantit 1024 1 048 576 1 073 741 824 Puissance de deux octets octets octets

Ainsi, un kibioctet correspond 1024 octets ; un mbioctet correspond 1 1 048 576 octets ; un gibioctet correspond 1 073 741 824 octets. De mme, un kibibit correspond 1024 bits ; un mbibit correspond 1 1 048 576 bits ; un gibibit correspond 1 073 741 824 bits. Ainsi, un kibioctet vaut octets, un mbioctet en vaut , un gibioctet vaut octets, etc.

Pourquoi utiliser des puissances de 1024, et ne pas utiliser des puissances un peu plus communes ?

Dans la majorit des situations, les lectroniciens prfrent manipuler des puissances de deux pour se faciliter la vie, et c'est aussi le cas pour les mmoires : il est plus simple de concevoir des mmoires qui contiennent un nombre de cases mmoires qui soit une puissance de deux. Par convention, on utilise souvent des puissances de 1024, qui est la puissance de deux la plus proche de 1000. Bizarre, j'ai toujours entendu parler de kilo-octets, mga-octets, gigaoctets, etc. C'est normal ?

Et bien non ! Logiquement, on ne devrait pas parler de kilo-octets, mga-octets ou gigaoctets : c'est encore une fois un abus de langage. Dans le langage courant, kilo, mga et giga sont des multiples de 1000. Quand vous vous pesez sur votre balance et que celle-ci vous indique 58 kilogrammes (dsol mesdames), cela veut dire que vous pesez 58000 grammes. De mme, un kilomtre est gal mille mtres, et non 1024 mtres. Autrefois, on utilisait les termes kilo, mga et giga la place de nos kibi, mebi et gibi, par abus de langage : les termes kibi, mbi et gibi nexistaient pas. Pour viter les confusions, de nouvelles units (les kibi, gibi et autres) ont fait leur apparition. Malheureusement, peu de personnes sont au courant de l'existence de ces nouvelles units, et celles-ci sont rarement utilises. Aussi, ne vous tonnez pas si vous entendez parler de gigaoctets en lieu et place de gibioctets : cette confusion est trs courante. Saviez-vous que cette confusion permet aux fabricants de disques durs de nous "arnaquer" ? Ceux-ci donnent la capacit des disques durs qu'ils vendent en kilo, mega ou giga octets. Lacheteur croit implicitement avoir une capacit exprim en kibi, mebi ou gibi octets, et se retrouve avec un disque dur qui contient moins de mmoire que prvu. C'est pas grand chose de perdu, mais il faut avouer que c'est tout de mme de l'arnaque !

Mmoires volatiles et non-volatiles

V ous avez dj remarqu que lorsque vous teignez votre ordinateur, le systme d'exploitation et les programmes que vous avez installs...ne s'effacent pas. Par contre, certaines informations (comme le document Word que vous avez oubli de sauvegarder avant que votre PC plante ) s'effacent ds le moment o l'ordinateur s'teint.

www.siteduzero.com

Partie 4 : Mmoires

157/378

Oui, et alors ? Quel est le rapport avec les mmoires ?

Trs simple : vos programmes et le systme d'exploitation sont placs sur une mmoire qui ne s'efface pas quand on coupe le courant, pas votre document Word. On dit que la mmoire dans laquelle votre OS et vos programmes taient placs est une mmoire non-volatile, tandis que celle qui stockait votre document Word tait une mmoire volatile. Mmoires Non-volatiles Mmoires Volatiles

Conservent leurs informations quand on coupe le courant Perdent leurs informations lors d'une coupure de l'alimentation

Comme exemple de mmoire non-volatile, on peut citer le disque dur. Tous vos programmes et votre systme d'exploitation sont stocks dessus. Et quand vous dbranchez votre ordinateur, ils ne s'effacent pas. Notre disque dur est donc une mmoire nonvolatile. Au fait : Les mmoires volatiles ne volent pas et n'ont pas de plumes !

RWM ou ROM
Une autre diffrence concerne la faon dont on peut accder aux informations stockes dans la mmoire. Cette autre diffrence classe les mmoires en mmoires RWM, et ROM. Mmoires ROM On peut rcuprer les informations dans la mmoire, mais pas les modifier : la mmoire est dite accessible en lecture Mmoires RWM On peut rcuprer les informations dans la mmoire et les modifier : la mmoire est dite accessible en lecture et en criture

A l'heure actuelle, les mmoires non-volatiles prsentes dans nos ordinateurs sont toutes des mmoires ROM, (sauf le disque dur qui est accessible en lecture et criture). Attention aux abus de langage : le terme mmoire RWM est souvent confondu dans le langage commun avec les mmoires RAM.

PROM
Nanmoins, il existe des mmoires ROM un peu spciales : on ne peut pas accder en criture une donne bien prcise et ne modifier que celle-ci, mais on peut rcrire intgralement son contenu. On dit qu'on reprogramme la mmoire, ce qui est diffrent d'une criture. Ce terme de programmation vient du fait que les mmoires ROM sont souvent utilises pour stocker des programmes sur certains ordinateurs assez simples : modifier le contenu de ces mmoires revient donc modifier le programme contenu dans la mmoire et donc reprogrammer l'ordinateur. Nanmoins, il faut bien comprendre la diffrence entre crire dans une mmoire : je slectionne une case mmoire et je modifie son contenu, mais je ne touche pas aux autres cases mmoires ; reprogrammer : on efface tout et on recommence ! Ces mmoires sont appeles des mmoires PROM. Il existe plusieurs versions de ces mmoires PROM, qui ont chacune leurs caractristiques. On peut par exemple mentionner les FROM, qui sont fournies intgralement vierges, et on peut les reprogrammer une seule et unique fois. Ces mmoires sont souvent fabriques avec des diodes ou des transistors qui serviront stocker un bit. La programmation d'une telle ROM est trs simple : pour crire un zro, il suffit de faire claquer la diode ou le transistor correspondant au bit qu'on veut modifier ! Pour stocker un un, on laisse notre diode ou transistor indemne. Vu qu'une diode ou un transistor ne se rparent pas tout seuls, on ne pourra pas changer le bit enregistr : impossible de transformer un zro en un :

www.siteduzero.com

Partie 4 : Mmoires
notre mmoire est programme dfinitivement.

158/378

Viennent ensuite les EPROM, qui peuvent tre effaces et reprogrammes plusieurs fois de suite sans problmes, contrairement aux FROM. En effet, ces mmoires s'effacent lorsqu'on les soumet des rayonnements UV : autant dire que l'effacement n'est pas trs rapide. D'autres mmoires ROM peuvent tre effaces par des moyens lectriques : ces mmoires sont appeles des mmoires EEPROM. Pour donner des exemples de mmoires EEPROM, sachez que vous en avez surement une dans votre poche. Et oui, votre cl USB est fabrique avec une mmoire qu'on appelle de la mmoire FLASH, qui est une sorte d'EEPROM.

Mmoires accs squentiel et accs alatoire

Autre diffrence : l'ordre d'accs. Sur les anciennes mmoires, comme les bandes magntiques, on tait oblig d'accder aux donnes dans un ordre prdfini. On parcourait ainsi notre mmoire dans l'ordre, en commenant par la premire donne, et en passant la donne suivante aprs une lecture ou une criture : c'est ce qu'on appelle l'accs squentiel. Pour lire ou crire une donne, il fallait visiter toutes les cases mmoires prcdentes avant de tomber sur la donn recherche. Et impossible de revenir en arrire ! Sauf reprendre le lecture/criture depuis le dbut de la mmoire. Des mmoires dans le genre se passent compltement d'adressage : on n'a pas le besoin, ni la possibilit de slectionner une donne dans la mmoire avec une adresse. De nos jours, l'accs squentiel est obsolte et presque compltement inutilise : seules quelques vielles mmoires utilisaient ce genre daccs.

Les mmoires actuelles utilisent plutt ce qu'on appelle l'accs alatoire. Avec cet accs alatoire, on peut accder chaque case mmoire dans n'importe quel ordre, sans se soucier des donnes dj parcourues avant ou de la position des donnes en mmoire. Ces mmoires sont adressables, et on peut ainsi accder une donne grce son adresse.

Le temps d'accs
Imaginons que l'on souhaite accder une donne localise dans une mmoire. On peut vouloir la lire, voire l'crire si c'est une mmoire RWM, peu importe. Que ce soit une lecture ou une criture, il va falloir attendre un certain temps que notre mmoire aie finie de lire ou d'crire notre donne. Et ce temps, c'est ce qu'on appelle le temps d'accs. Sur certaines mmoires, lire une donne ne prend pas le mme temps que l'crire. On se retrouve alors avec deux temps d'accs : un temps l'accs en lecture et un temps d'accs en criture. Gnralement, la lecture est plus rapide que l'criture. Il faut dire qu'il est beaucoup plus frquent de lire dans une mmoire qu'y crire, et les fabricants prfrent donc diminuer au maximum le temps d'accs en lecture que toucher aux temps d'criture. Ce temps daccs varie beaucoup suivant le type de mmoire. De plus, sur certaines mmoires, le temps d'accs dpend parfois de la position de la donne en mmoire. C'est le cas sur les disques durs, par exemple, ou sur les mmoires accs squentiel.

Mmoires RAM
www.siteduzero.com

Partie 4 : Mmoires

159/378

Les mmoires RAM ont une particularit : le temps d'accs est toujours le mme, quelle que soit l'adresse de la donne que l'on souhaite consulter ou modifier. Toutes les mmoires n'ont pas cette particularit : ce n'est pas le cas d'un disque dur, par exemple, dont le temps d'accs dpend de l'emplacement de l'information sur le disque dur et de la position de la tte de lecture. Toutes les mmoires RAM actuelles sont des mmoires volatiles. Nanmoins, il existe des projets de recherche qui travaillent sur la conception d'une mmoire nomme la MRAM qui serait une mmoire RAM non-volatile. Reste finir le travail de recherche, ce qui n'est pas pour tout de suite ! Il existe deux types de RAM : les SRAM ou ram statiques et les DRAM ou RAMs dynamiques

Les SRAM
Leurs donnes ne s'effacent pas tant qu'elles sont alimentes en courant. Ces mmoires sont souvent (bien que ce ne soit aps une obligation) fabriques avec des bascules, ces fameux circuits de mmorisation qu'on a vu il y a de cela quelques chapitres. Vu que ces fameuses bascules utilise pas mal de transistors (au minimum 6, voire plus), nos cellules mmoires auront tendance prendre un peu de place. En consquence, une cellule mmoire de SRAM est plus grosse qu'une cellule de mmoire DRAM (qui n'utilise qu'un seul transistor, et un autre composant lctronique : un condensateur), ce qui signifie qu'on peut mettre beaucoup moins de cellules de SRAM que de cellules de DRAM sur une surface donne. Pour cette raison, on dit souvent que nos mmoires SRAM ne peuvent contenir beaucoup de bits. Cette mmoire SRAM est donc utilise lorsque l'on souhaite avoir une mmoire rapide, mais en faible quantit. Elle sont assez rapides, mais trs chres. Pour info, votre processeur contient beaucoup de mmoires directement intgres dans ses circuits (les registres et les caches) qui sont toutes faites avec de la SRAM. Il faut dire que les mmoires intgres au processeur ont absolument besoin d'tre rapides, et qu'on a rarement besoin d'en mettre beaucoup, ce qui fait que la SRAM est un choix assez adapt.

Les DRAM
Les DRAM sont plus lentes, mais peuvent stocker beaucoup plus de bits que la SRAM. Il faut dire qu'une cellule mmoire de DRAM prend beaucoup moins de place qu'une cellule de SRAM, ce qui fait que les mmoires DRAM ont souvent une grande capacit compar aux SRAM. C'est ce qui fait qu'elles sont utilises pour la mmoire principale de nos PC : quand on lance plusieurs programmes assez gourmand en mme temps en plus du systme d'exploitation, il vaut mieux avoir suffisamment de RAM. Mais ces DRAM ont tout de mme des dsavantages : elles sont plus lentes que les SRAM, pour diverses raisons techniques. De plus, avec les DRAM, les bits stocks en mmoire s'effacent tout seul en quelques millimes ou centimes de secondes (mme si l'on n'y touche pas). Et c'est sans compter que lire une donne stocke en mmoire va obligatoirement effacer son contenu. Il faut donc rcrire chaque bit de la mmoire rgulirement, ou aprs chaque lecture, pour viter qu'il ne s'efface. On appelle cela le rafrachissement mmoire. Ce rafrachissement prend du temps, et a tendance lgrement diminuer l'efficacit des DRAM. Autrefois, ce rafraichissement tait effectu par un circuit plac sur la carte mre de notre ordinateur, qui tait charg de toute la gestion de la mmoire (on l'appelle le contrleur mmoire). Dans une telle situation, les ordres de rafrachissement de la mmoire transitent donc par le bus, le rendant temporairement incapable de transfrer des donnes. Ce dfaut, autrefois trs pnalisant ne l'est plus de nos jours : de nos jours, les mmoires RAM contient un circuit qui se charge de rafraichir automatiquement les donnes prsente dans notre mmoire DRAM. Les pertes de performances sont ainsi plus mitiges.

Donne, o es-tu ?
Avec les mmoires accs squentiel, trouver une donne aurait t trs simple : il suffisait de parcourir la mmoire depuis le dbut jusqu' ce qu'on arrive la bonne donne. Mais sur nos ordinateurs, toutes les mmoires sont des mmoires accs alatoires, ce qui fait qu'on peut accder n'importe quelle donne dans notre mmoire, sans trop se soucier de l'ordre d'accs. Pour accder une donne, on est oblig d'indiquer notre mmoire la position de celle-ci dans la mmoire. Et on fait comment ?

Faut avouer qu'avec des registres, des mmoires RAM, des mmoires (EEP)ROM et ventuellement un disque dur, a fait un sacr paquet ! Il existe plusieurs solutions, mais la grande majorit des mmoires de nos ordinateurs utilisent toutes une mthode dj vue auparavant : l'adressage. Cette solution est trs simple : chaque case mmoire se voit attribuer un nombre binaire unique, l'adresse, qui va permettre de la slectionner et de l'identifier celle-ci parmi toutes les autres.

www.siteduzero.com

Partie 4 : Mmoires
Adresse Contenu mmoire 0 1 2 3 4 5 11101010 01011010 01111111 01110010 00000000 01111100 01010101 0000000 10101010 00001111 00000000 11000011

160/378

En fait, on peut comparer une adresse un numro de tlphone (ou une adresse d'appartement) : chacun de vos correspondants a un numro de tlphone et vous savez que pour appeler telle personne, vous devez composer tel numro. Ben les adresses mmoires, c'est pareil ! Exemple : on demande notre mmoire de slectionner la case mmoire d'adresse 1002 et on rcupre son contenu (ici, 17).

Une histoire de capacit

videmment, plus on utilise une mmoire ayant une capacit importante, plus on devra utiliser un grand nombre d'adresses diffrentes : une par case mmoire. Hors, une adresse est un nombre, cod en binaire, comme tous les nombres manipuls par notre ordinateur. Celui est un simple nombre strictement positif (ce n'est pas un nombre en complment deux ou avec un bits de signe, et encore moins un nombre flottant). Si on utilise bits pour reprsenter notre adresse, alors celle-ci peut prendre valeurs diffrentes, ce qui fait cases mmoires adressables directement (on peut en adresser plus en envoyant notre adresse en plusieurs fois, mais passons). C'est pour cela que nos mmoires ont toujours une capacit qui est une puissance de deux ! Au fait, vous vous souvenez que je vous ai dit que dans la majorit des ordinateurs actuels, chaque case mmoire pouvait stocker 8 bits ?

Et bien voil l'explication : en utilisant 8 bits par case mmoire, on utilise 8 fois moins d'adresse qu'en utilisant des cases mmoires de 1 bit. Cela diminue donc le nombre de fil cbler sur le bus d'adresse. Mais attention : toutes les mmoires n'ont pas des cases mmoires d'une taille de 8 bits. Si vous regardez les anciens ordinateurs, vous verrez qu'autrefois, on utilisait des cases mmoires plus petites, contenant 2, 3, 4, 7 bits. Il est mme arriv que certaines mmoires soient bit-adressables, c'est dire qu'on pouvait adresser chaque bit individuellement. De mme, rien nempche d'aller au del de 8 bits : certains ordinateurs ont, ou avaient, des cases mmoires de 16 ou 18 bits. Mais pour tre franc, ce genre de chose est assez rare de nos jours.

www.siteduzero.com

Partie 4 : Mmoires

161/378

Bus d'adresse
Pour choisir la case mmoire laquelle on veut accder, il faut bien pouvoir spcifier son adresse notre mmoire. Pour cela, notre mmoire contient des entres sur laquelle on peut placer notre adresse mmoire, relis au reste du circuit par des fils. Les fils du bus qui transmettent l'adresse vers la mmoire sont regroups dans une sorte de "sous-bus" qu'on appelle le bus d'adresses. Ainsi, quelle que soit la case mmoire laquelle on souhaite accder, il suffit d'envoyer son adresse sur le bus d'adresse et la mmoire slectionnera cette case pour nous. Peu importe que cette case mmoire soit en RAM, un registre, ou un registre qui permet la communication avec les priphriques. En effet, sur certains ordinateurs, on utilise un seul bus d'adresse pour grer plusieurs mmoires diffrentes : certaines adresses sont attribues la mmoire RAM, d'autres la mmoire ROM, d'autres des priphriques, etc. Par exemple, certains priphriques possdent des mmoires internes. Ces mmoires internes possdent parfois des adresses, et sont donc adressables directement par le processeur. Ce qui fait, par exemple, que la mmoire de votre carte graphique se retrouve dans l'espace d'adressage du processeur.Et oui, votre processeur peut s'occuper d'une partie de la gestion de la mmoire de votre carte graphique. Il existe une table pour chaque ordinateur qui dfinit quels composants lectroniques sont attribues les adresses. C'est la memory map. V un exemple : oici Adresse Composant lctronique

de 0000 0000 0000 0011 Registres du processeur de 0000 0011 0000 1111 Mmoire Programme de 0000 1111 0011 1111 Mmoire RAM de 0011 1111 0110 0000 Registres De communication Avec le priphrique 1

de 0110 0000 1111 1111 Mmoire du priphrique 1

La gestion de l'adressage (et donc du contenu du bus d'adresse) est ralise dans la majorit des cas par le processeur, qui possde des units permettant de grer les bus de commande et d'adresse. Pour que les priphriques puissent accder la mmoire, il faut que ces priphriques et le processeur de l'ordinateur utilisent la technologie nomme Direct Memory Acces. Le but de cette technologie est justement de permettre aux priphriques d'adresser la mmoire.

Les exceptions qui confirment la rgle

Toutes les cases mmoire possdent donc une adresse. Toutes ? Non ! La mmoire cache du processeur ainsi que certaines mmoires de masse (disques durs, cls USB...) rsistent encore et toujours l'envahisseur. Par exemple, les registres ne possdent pas toujours d'adresse mmoire. C'est un fait : les mmoires de notre ordinateur ne sont pas toutes adressables ! Certaines le sont, mais pas les autres. On verra lesquelles plus tard.

Lecture-criture
On a vu que la mmoire est relie au CPU par trois bus : le bus de donnes, le bus d'adresse, et le bus de commande. Reste savoir quoi sert le bus de commandes. Dans sa version minimale, il sert indiquer les sens de transferts des donnes la mmoire : s'agit-il d'une criture, d'une lecture, etc. Pour les mmoires ROM, on sait d'avance que le composant qui va adresser la mmoire ne peut que faire une lecture : il n'y a pas besoin de prciser que c'est une lecture. Il est donc parfois possible de s'en passer. Mais pour les mmoires RWM, c'est autre chose : on peut aussi bien y accder en criture qu'en lecture. On peut accder une adresse de deux faons : soit on enregistre une information dans la mmoire : c'est une criture. soit on rcupre une information stocke dans la mmoire : c'est une lecture. Pour prciser le sens de transfert la mmoire, on utilise un bit du bus de commande nomm R/W. Il est souvent admis par

www.siteduzero.com

Partie 4 : Mmoires
convention que R/W 1 correspond une lecture, tandis que R/W vaut 0 pour les critures.

162/378

Connexion du bus sur la mmoire

Bus de donne, bus d'adresse, bit R/W : tout cela doit tre reli la mmoire. Pour cela, notre mmoire possde des broches, qui sont des morceaux de mtal ou de conducteur sur lesquelles on va venir connecter nos bus. Cela permettra notre mmoire de pouvoir communiquer avec lextrieur. Dans le cas le plus simple, une mmoire est connecte au bus comme ceci :

La mmoire contient donc des broches sur lesquels brancher nos bus, avec des broches rserves au bus d'adresse, d'autres rserves au bus de donne, et une rserve au bit R/W. On remarque que les informations prsentes sur le bus dadresse et sur le fil R/W vont dans un seul sens : du bus vers la mmoire, mais pas l'inverse. Une mmoire n'a pas envoyer une adresse sur ce bus, ou demander une lecture/criture qui que ce soit : les bits qui se trouvent sur ces broches servira commander la mmoire, mais ne pourra pas tre modifi par celle-ci. Nos broches sur lesquelles on connecte nos bus d'adresse et notre bit R/W sont donc des entres : ce qui se trouve dessus va renter dans le composant qui fera ce qu'il faut avec, mais le composant ne pourra pas modifier le contenu de ces broches. Pour les broches relies au bus de donne, le cas est plus litigieux et dpend de l'accs effectu. Si c'est une criture, ces broches seront des entres : la donne sera lue par la mmoire sur ces entres. Dans le cas d'une lecture,la mmoire va modifier le contenu du bus de donne, et ces broches vont donc se comporter comme des sorties.

www.siteduzero.com

Partie 4 : Mmoires

163/378

Bus multiplex
Nanmoins, on peut remarquer que cela fait beaucoup de fils et beaucoup de broches. Cela peut poser problme : les lectroniciens qui conoivent ce genre de circuits essayent au maximum de limiter le nombre de fils pour viter les problmes. Il y a des raisons cela : un processeur possde lui aussi des entres et des sorties. Parfois, on peut vouloir cbler un grand nombre de composants dessus : on utilise alors beaucoup d'entres et il n'en reste plus pour cbler un bus complet dessus. Sans compter le bordel pour cbler un grand nombre de fils sur une carte d'une taille limite. Il existe alors une petite astuce pour conomiser des fils : utiliser un seul bus qui servira alternativement de bus de donne ou d'adresse. Cela s'appelle multiplexer le bus d'adresse et de donne. On a donc : un seul bus qui sert successivement de bus de donnes et de bus mmoire ; un bus de commande, avec ventuellement un bits R/W ; un bit ALE : celui-ci vaut 1 quand une adresse transite sur le bus, et 0 si le bus contient une donne (ou l'inverse!). V quoi ressemble donc l'ensemble bus-mmoire : oici

Ce genre de bus est plus lent qu'un bus qui ne serait pas multiplex lors des critures : lors d'une criture, on doit en effet envoyer en mme temps l'adresse et la donne crire. Avec un bus multiplex, on ne peut pas envoyer la fois l'adresse, et une donne (pour une criture, par exemple). Cela doit tre fait en deux passes : on envoie l'adresse d'abord, puis la donne ensuite. Sur un bus qui n'est pas multiplex, on peut envoyer l'adresse et la donne en une seule tape, ce qui est plus rapide que de le faire en deux tapes. Par contre, les lectures ne posent pas de problmes : quelque soit le type de bus utilis, on envoie d'abord l'adresse, et on

www.siteduzero.com

Partie 4 : Mmoires

164/378

rcupre la donne lue aprs l'envoi de l'adresse. Vu que ces deux oprations ne se font pas en mme temps et qu'il n'y a pas besoin d'envoyer la fois une adresse et une donne sur le bus, le bus multiplex ne pose pas de problmes. Heureusement, les lectures en mmoire sont bien plus courantes que les critures, ce qui fait que la perte de performance due l'utilisation d'un bus multiplex est souvent supportable.

Mmoire multiports
Aprs avoir vu des mmoires cherchant limiter le nombre de fils en payant le prix en terme de performances, je suis oblig de mentionner le cas inverse : des mmoires qui n'hsitent pas cbler un maximum de fils pour gagner en performances. Ces mmoires possdent plusieurs bus de donnes, d'adresse et de commande : chaque bus est prsent en deux, trois ou quatre exemplaires. Ainsi, on pourra relier la mmoire plusieurs bus, qui permettront de transfrer chacun une donne. Ces mmoires sont appeles des mmoires multiports. Ce nom vient simplement du fait que chaque bus (je parle d'un bus complet, avec bus d'adresse + bus de donne + bus de commande) s'appelle un port, et que ces mmoires en ont plusieurs.

Cela permet de transfrer plusieurs donnes en une seule fois : une sur chaque bus. On peut ainsi slectionner plusieurs cases mmoires (cette slection pouvant passer par un bus d'adresse), et transfrer des donnes avec chacune de ces cases simultanment (via chaque bus de donne). Ce qui fait qu'on peut lire/crire dans une case mmoire en utilisant le premier bus, et en lire/crire une autre via un autre bus, etc. Je suppose que vous voyez quel point cela peut tre plus rapide que d'envoyer chacune de ces donne en une tape. Certaines mmoires multiports possdent des bus spcialiss pour l'criture ou le lecture. Par exemple, certaines mmoires multiports peuvent tre relies seulement deux bus : un sur lequel on ne peut que lire une donne, et un autre sur lequel on ne peut qu'crire. Les registres de nos processeurs sont de ce type : cela permet de simplifier la conception de notre processeur. Ces bus pourront tre relis des composants diffrents, ce qui fait que plusieurs composants pourront accder en mme temps la mmoire. On peut aussi dcider de relier la mmoire avec un seul composant, en utilisant tous les bus : le composant pourra alors modifier ou lire le contenu de tous les bus en mme temps. De quoi effectuer plusieurs lectures/critures en mme temps. videmment, cela fait normment de fils cbler, vu que certains bus sont en double, triple ou quadruple. Cela a un cout en terme de prix, mais aussi en terme de consommation nergtique : plus une mmoire a de ports, plus elle chauffe et consomme de llectricit. Mais on peut gagner normment en performances en utilisant de telles mmoires. Pour donner un exemple d'utilisation, les mmoires multi-ports sont utilises dans les cartes graphiques actuelles, et pour fabriquer les registres du processeur.

Toutes les mmoires ne se valent pas !

Et oui, les mmoires ne se valent pas! Rien de mchant, rassurez-vous, c'est juste qu'il existe pleins de type de mmoires, avec leurs qualits et leurs dfauts : certaines mmoires ont une plus grande capacit, une vitesse plus grande... Par contre un dfaut revient quelque soit le type de mmoire : plus une mmoire peut contenir de donnes, plus elle est lente ! Sur ce point, pas de jaloux ! Toutes les mmoires sont gales, un vrai truc de soviet !

Une histoire de vitesse

On a vu au premier chapitre ce qu'tait le temps d'accs d'une mmoire. Et bien il faut savoir que pour un type de mmoire

www.siteduzero.com

Partie 4 : Mmoires

165/378

(SRAM, DRAM, ROM...), le temps d'accs d'une mmoire dpend de sa capacit. Plus la capacit est importante, plus le temps d'accs est long. En clair, plus une mmoire est grosse, plus elle sera lente.

Pourquoi ?
La raison cela est trs simple : plus une RAM a une capacit importante, plus elle est grosse. Et plus elle est grosse, plus elle contient de portes logiques et plus les fils qui relient les divers composants de notre mmoire seront longs. Hors, le temps que met un signal lectrique (un bit, quoi) pour aller d'un point un autre du circuit gne la monte en frquence. Ce temps s'appelle le temps de propagation, et on en a dj parl dans les chapitres au dbut de ce tutoriel. Ce temps de propagation dpend de pas mal de facteurs, dont le nombre maximal de portes que notre signal doit traverser (le Critical Path), ainsi que de la longueur des fils. Le fait est que plus la mmoire est grosse, plus ce temps de propagation est long. Un temps de propagation trop long aura des effets pas trs reluisants : la frquence de la mmoire sera faible, et notre mmoire sera lente. Alors certes, la capacit d'une mmoire ne fait pas tout et d'autres paramtres entrent en jeu, mais on ne peut pas passer ce problme sous le tapis.

Hirarchie mmoire
Le fait est que si l'on souhaitait utiliser une seule grosse mmoire dans notre ordinateur, celle-ci serait donc fatalement trs lente. Malheureusement, un composant trs rapide ne peut attendre durant plusieurs millisecondes que la donne soit charge de la mmoire sans rien faire, ce serait gaspiller beaucoup trop de temps de calcul. On ne peut donc utiliser une seule grosse mmoire capable de stocker toutes les donnes voulues. Ce problme s'est pose ds les dbut de l'informatique. Les inventeurs des premiers ordinateurs modernes furent rapidement confronts ce problme. Pour ceux qui ne me croient pas, regardez un peu cette citation des annes 1940, provenant d'un rapport de recherche portant sur un des premiers ordinateurs existant au monde : Citation : Burks, Goldstine, et Von Neumann Idalement, nous dsirerions une mmoire d'une capacit indfiniment large tel que n'importe quel byte soit immdiatement accessible. Nous sommes forcs de reconnaitre la possibilit de la construction d'une hirarchie de mmoire, chacune ayant une capacit plus importante que la prcdente, mais accessible moins rapidement.

Comme on le voit, cette citation (traduite de l'anglais), montre le problme, mais voque aussi la solution adopte face ce problme. Pour rsoudre ce problme, il suffit de segmenter la mmoire de l'ordinateur en plusieurs sous-mmoires, de taille et de vitesse diffrentes qu'on utilise suivant les besoins. On aura donc des mmoires pouvant contenir peu de donnes dans lesquelles on pourra lire et crire rapidement et des mmoires plus importante, mais plus lentes. Cette solution a t la premire solution invente pour rsoudre ce problme et est encore massivement utilise l'heure actuelle : on n'a pas encore fait mieux ! Gnralement, un ordinateur contient plusieurs mmoires de taille et de vitesse diffrentes. Ces mmoires peuvent tre classes en quatre grands types : Les mmoires de masse qui stockent des informations qui doivent tre conserves mme aprs extinction du systme et qui sont accde trs rarement. La mmoire principale qui stocke toutes les informations temporaires auxquelles le processeur doit accder peu souvent mais qui doivent tre conserves suffisamment longtemps. les mmoires caches, qui acclrent l'accs la mmoire principale. les registres, trs rapides contenant des instructions ou donnes que le processeur doit manipuler.

www.siteduzero.com

Partie 4 : Mmoires

166/378

Localit de rfrence
On voit bien que les mmoires d'un ordinateur sont organises de la plus lente la moins lente. Le but de cette organisation est de placer les donnes accdes souvent, ou qui ont de bonnes chances d'tre accdes dans le futur, dans une mmoire qui soit la plus rapide possible. Le tout est faire en sorte de placer les donnes intelligemment, et les rpartir correctement dans cette hirarchie des mmoires. Ce placement se base sur deux principes qu'on appelle les principe de localit spatiale et temporelle. Pour simplifier : un programme a tendance rutiliser les instructions et donnes qui ont ts accdes dans le pass : c'est la localit temporelle ; et un programme qui s'excute sur un processeur tendance utiliser des instructions et des donnes qui ont des adresses mmoires trs proches, c'est la localit spatiale. Ces deux principes semblent trs simples, mais sont lourds de consquence. On peut exploiter ces deux principes pour placer correctement nos donnes dans la bonne mmoire. Par exemple, si on a accde une donne rcemment, il vaut mieux la copier dans une mmoire plus rapide, histoire d'y accder rapidement les prochaines fois : on profite de la localit temporelle. On peut ainsi placer des donnes consultes ou modifies frquemment dans les registres ou la mmoire cache au lieu de les laisser en mmoire RAM. On peut aussi profiter de la localit spatiale : si on accde une donne, autant prcharger aussi les donnes juste cot, au cas o elles seraient accdes. Placer les bonnes donnes au bon endroit (dans le cache plutt qu'en RAM) permet d'avoir de sacrs gains de performances. Ce placement des donnes dans la bonne mmoire peut tre gr par le matriel de notre ordinateur, par la faon dont sont construits nos programmes, ou grable par le programmeur. Par exemple : la mmoire cache est souvent gre directement par le matriel de notre ordinateur, d'une faon qui peut tre prise en compte par le programmeur ; les registres sont grs par le programmeur (s'il programme ne assembleur ou en langage machine), ou par son langage de programmation (par le compilateur pour tre prcis) ; la RAM est implicitement gre par le programmeur, etc. Bref, sachez qu'un programmeur peut parfaitement prendre en compte le fait que les mmoires d'un ordinateur ne vont pas la mme vitesse, et peut concevoir ses programmes de faon placer un maximum de donnes utiles dans la bonne mmoire. En effet, la faon dont est conue un programme joue normment sur la faon dont celui-ci accdera ses donnes, et sur sa localit spatiale et temporelle. Vu que de nos jours, nos programmes passent de plus en plus de temps attendre que les donnes manipuler soient lues ou crites depuis la mmoire, ce genre de choses commence devenir une ncessit. Bref, un programmeur peut, et doit, prendre en compte les principes de localits vus plus haut ds la conception de ses programmes. Et cette contrainte va se faire de plus en plus forte quand on devra passer aux architectures multicurs. Maintenant que cette petite remarque est faite, parlons un peu des diffrentes mmoires. Commenons par ces fameux registres.

www.siteduzero.com

Partie 4 : Mmoires

167/378

Registres
Les registres sont fabriqus avec des mmoire SRAM. Ces registres sont trs souvent intgrs dans le processeur de votre ordinateur, mais quelques priphriques possdent eux aussi des registres. La diffrence, c'est que les registres de notre processeur vont stocker temporairement des donnes pour pouvoir les manipuler rapidement. Les priphriques utilisent des registres pour communiquer avec le processeur, bien plus rapide qu'eux.

Noms de registres
Sur les processeurs x86 ainsi que sur la grosse majorit des processeurs existants ou ayant exist, les registres ne sont pas adressables. Sur de tels processeurs, chaque registre est identifi par un numro qui n'a rien voir avec une adresse ! Ce numro, ou nom de registre, permet d'identifier le registre que l'on veut, mais ne sort jamais du processeur : ce nom de registre, ce numro, ne se retrouve jamais sur le bus d'adresse.

Quand une instruction voudra manipuler des donnes, elle devra fatalement donner leur position dans la mmoire. Pour manipuler une case mmoire, elle donne gnralement son adresse, et pour un registre, elle donnera un nom de registre. Ces adresses et noms de registres seront cods sous la forme de suites de bits, incorpores dans l'instruction. Mais rien ne ressemble plus une suite de bits qu'une autre suite de bits : notre processeur devra viter de confondre suite de bits reprsentant une adresse, et suite de bits reprsentant un nom de registre. Pour viter les confusions, chaque instruction devra prciser quoi correspondra la suite de bits prcisant la localisation des donnes manipuler. On peut ainsi utiliser diverses instructions diffrentes suivant qu'on veut manipuler des registres ou des adresses mmoires, par exemple.

Registres adressables
Mais il existe quelques processeurs sur lesquels on peut adresser les registres via une adresse mmoire. Il est vrai que c'est assez rare, et qu' part quelques vielles architectures ou quelques micro-contrleurs, je n'ai pas d'exemples donner. Mais c'est tout fait possible ! C'est le cas du PDP-10.

www.siteduzero.com

Partie 4 : Mmoires

168/378

Cache
Un cache est une mmoire qui doit tre assez rapide, et est donc fabriqu avec de la SRAM, assez vloce. Ce cache est gnralement intgr dans le processeur de votre ordinateur, mais quelques priphriques possdent eux aussi des caches, comme certains disques durs. Un cache n'est jamais adressable ! Cela est du au fait que chaque donne prsente dans la mmoire cache est une copie d'un emplacement de la mmoire RAM. Le contenu du cache est gr par un circuit particulier qui dcide quoi charger dedans et quand. Lorsque le processeur veut ainsi accder une case mmoire en RAM (en lecture ou en criture), il va envoyer l'adresse de cette case sur le bus. Celle-ci sera intercepte par les circuits chargs de grer le cache qui regarderont alors si le cache contient une copie de la case manipuler. Si c'est le cas, on lit ou crit la donne dans le cache. Dans le cas contraire, on accde la mmoire RAM. Cela explique qu'on aie pas besoin de donner des adresses aux cases mmoires du cache : les circuits de gestion du cache savent quelle case mmoire en RAM correspond chaque case mmoire du cache.

Mmoires principales
La mmoire principale sert de mmoire de travail, et parfois de mmoire programme. C'est dedans qu'on va stocker les donnes manipuler et ventuellement le ou les programmes excuter (sur les architectures V Neumann ou sur les architectures Harvard on modifies). Par consquent, on va devoir accder son contenu assez souvent et pouvoir grer cela de faon manuelle : toutes les mmoires RAM sont donc adressables. La mmoire principale est fabrique avec de la DRAM, qui peut contenir plus de donnes sur une surface gale que la SRAM. Il faut dire que contenir un systme d'exploitation moderne et plusieurs programmes en mme temps ncessite au moins quelques centaines de mga-octets. L'utilisation de DRAM au lieu de SRAM permet notre mmoire d'atteindre les 2 4 gigaoctets sans frmir, ce qui fait tout de mme 4 milliards de cases mmoires adressables pour 4 gigaoctets. Nanmoins, il existe des exceptions qui confirment la rgle : la gamecube et la Wii possdent toutes les deux une mmoire principale de 24 mgas-octets de SRAM.

Mmoires de masse
Ces mmoires servent surtout stocker de faon permanente des donnes ou des programmes qui ne doivent pas tre effacs : ce seront donc des mmoires non-volatiles, souvent fabriques avec de la ROM ou des dispositifs magntiques. Les mmoires de masse servent toujours stocker un programme ou quelques paramtres/constantes utiles. On doit donc accder leur contenu et elles sont donc adressables, part certaines vielles mmoires magntiques qui font exception. Vu que ces mmoires doivent souvent stoker une grande quantit de bits (un programme prend souvent beaucoup de place), elles doivent avoir une

www.siteduzero.com

Partie 4 : Mmoires
capacit norme compar aux autres types de mmoires, et sont donc trs lentes. Parmi ces mmoires de masse, on trouve notamment

169/378

les disques durs ; les mmoires FLASH, utilises dans les cls USB, voire dans les disques durs SSD ; les disques optiques, comme les CD-ROM, DVD-ROM, et autres CD du genre ; les fameuses disquettes, totalement obsoltes de nos jours ; mais aussi quelques mmoires trs anciennes et rarement utilises de nos jours, comme les rubans perfors et quelques autres.

www.siteduzero.com

Partie 4 : Mmoires

170/378

Comment font nos mmoires RAM pour stocker un bit ?

Dans les grandes lignes, les mmoires RAM, ROM, et autres EEPROM actuelles sont toutes composes de cellules mmoires capables de retenir un bit. En mettant pleins de ces cellules dans un seul composant, et en mettant quelques circuits lectroniques pour grer le tout, on obtient une mmoire. L'ensemble des cellules mmoires utilises pour stocker des donnes s'appelle le plan mmoire, et c'est lui qui est l'objet de ce chapitre. De nos jours, ces cellules mmoires sont fabriques avec des composants lectroniques et il nous faudra imprativement passer par une petite tude de ces composants pour comprendre comment fonctionnent nos mmoires. Dans ce chapitre, nous allons voir ce qu'il y a l'intrieur d'une mmoire RAM et apprendre crer nos propres bits de mmoires partir de composants lmentaires : des transistors. Mais tout d'abord, ce chapitre se limitera aux mmoires de type RAM. En effet, les cellules mmoires de mmoires ROM, PROM, ou EEPROM sont fabriques d'une faon trs diffrente. Et ne parlons mme pas des disques durs qui utilisent le magntisme pour stocker des donnes et non des composants lectroniques ! V ous verrez aussi que les cellules mmoires des mmoires SRAM et DRAM ne sont pas conues de la mme faon. Bref, commenons !

Mmoire SRAM
Les composants principaux d'une mmoire SRAM sont ce qu'on appelle des bascules. Et oui, il s'agit des fameuses bascules vues au troisime chapitre de ce tutoriel, dans la partie sur les circuits squentiels. Ce sont de petits composants lectroniques capables de mmoriser un bit, et qui peuvent le mettre jour si besoin. Dans ce prcdent chapitre, on avait vu les bascules RS. Mais ce ne sont pas ces bascules RS qui sont utilises pour concevoir nos mmoires RAM actuelles. Il existe diffrents types de bascules qui peuvent tre utilises pour mmoriser des bits (JK, RS NOR, RS NAND, RSH, etc), mais on va mettre les choses au point tout de suite : nos mmoires SRAM utilisent toutes une bascule nomm bascule D.

Bascule D
Notre bascule est un circuit enferm dans un boitier, qui contient tout ce qu'il faut pour mmoriser un bit. Mais ce bit ne vient pas de nulle part : notre bascule doit recevoir celui-ci de quelque part. Pour cela, notre bascule possde une entre sur laquelle on va placer le bit mmoriser. De mme, le bit mmoris doit pouvoir tre lu quelque part et notre bascule va mettre disposition celuici sur une sortie. Notre bascule commence se dessiner peu peu. V exactement quoi elle ressemble. oici

Le fonctionnement d'une bascule est trs simple : quand l'entre E passe de 1 0 (de 0 1 sur certaines bascules), le contenu du bit D est recopi sur la sortie Q. Cette bascule n'est rien d'autre qu'une cellule mmoire de SRAM, qu'on peut lire et crire loisir. Si on veut lire le contenu de la bascule, il suffit de lire le bit prsent sur la sortie Q. Pour crire, il faut placer le bit crire sur l'entre D, et faire passer l'entre E de 0 1 : le contenu du bit (la sortie Q) sera alors mit jour. Mais quoi sert l'entre E ?

Cela permet d'viter que le bit contenu dans notre cellule de mmoire SRAM soit modifi quand on ne souhaite pas : il faut d'abord autoriser l'criture (ou la lecture) avec l'entre E.

Case mmoire de SRAM

Pour crer une case mmoire de SRAM, il suffit simplement de mettre plusieurs bascules les unes cot des autres et les synchroniser en reliant leurs entres E ensemble.

www.siteduzero.com

Partie 4 : Mmoires

171/378

Il suffit de placer le tout dans un seul boitier, avec ses entres et ses sorties pour obtenir une case mmoire de SRAM. Les entres du boitier sont connectes aux entres D des bascules, et les sorties du boitier sont relies aux sorties Q des bascules. Ce qu'on vient de crer n'est rien d'autre qu'un registre assez simple. Toutes les autres mmoires SRAM, comme le cache, sont constitues de pleins de cases mmoires de ce type, colles les unes cot des autres. Il faut noter que les registres de nos ordinateurs sont des registres multiports (revoyez le chapitre prcdent si vous avez oubli ce que c'est), et leurs bascules possdent donc plusieurs entres D et plusieurs sorties Q.

Crer une bascule

Et ces bascules D, elles sont faites en quoi ?

Autant prvenir tout de suite : la faon dont est cre une bascule dpend de la bascule utilise. Sans compter qu'il existe plusieurs faons de concevoir une bascule : on peut aussi bien se dbrouiller avec des portes logiques, que travailler directement au niveau des transistors.

Avec des portes logiques

Nos bascules D peuvent tre cres partir de portes logiques (comme toutes les autres bascules), gnralement 2 ou 6. Dans les chapitres prcdents, on a vu comment crer une petite mmoire de 1 bit, avec quelques portes logiques. C'tait dans le chapitre "crons nos circuits" : on avait cre une bascules RS, qui permettait de stocker un bit. Cette bascules RS possdait deux entres et une sortie : l'entre R forait la bascule mmoriser un 0 ; l'entre S faisait mmoriser un 1 dans notre bascule ; et la sortie Q fournissait le bit mmoris.

Entre Reset Entre Set 0 0 1 1 0 1 0 1

Sortie Q Bit mmoris par la bascule 1 0 Interdit

Cette bascule RS tait cre partir de quelques portes logiques. Le cblage tait alors celui-ci.

www.siteduzero.com

Partie 4 : Mmoires

172/378

C'est partie de cette bascule RS qu'on va crer une bascule D. Pour crer une bascule D, il suffit simplement de prendre une bascule RS, et de l'amliorer de faon en faire une bascule D. Exemple avec une bascule RS utilisant des portes NOR. On pourrait faire de mme avec une bascule RS utilisant des portes NAND.

Ce circuit combinatoire est assez simple. Pour le concevoir, il suffit d'crire sa table de vrit et d'en dduire son quation logique, qu'on traduira en circuit. Entre E Entre D 0 0 1 1 0 1 0 1 Sortie R Sortie S 0 0 1 0 0 0 0 1

Ceux qui sont observateurs verront qu'on peut dduire immdiatement l'quation de chaque sortie, R et S. S est gale au rsultat d'un simple ET entre les entres E et D, tandis que R est gale . On obtient donc ce circuit :

www.siteduzero.com

Partie 4 : Mmoires

173/378

Il existe de nombreuses autres faons de crer des bascules D avec des portes logiques, mais on ne poursuivra pas plus loin dans cette voie. Il faut dire que les mmoires SRAM de nos ordinateurs ne sont pas vraiment conues comme ceci.

Avec des transistors

Le schma vu au-dessus est assez simple comprendre, mais celui-ci utilise beaucoup de transistors : on tourne autour de 10 20 transistors, suivant les transistors et la technologie utilise. Il y a moyen de faire bien plus simple : certaines mmoires SRAM n'utilisent que 6 transistors par cellule mmoire. En voici la preuve !

C'est moche, non ? Bon, c'est pas tout d'avoir balanc un schma tout moche, il va maintenant falloir que je vous explique comment a fonctionne. Analysons un peu l'ensemble du circuit, et cherchons savoir comment tout cela fonctionne. Tout d'abord, les 4 transistors M1, M2, M3 et M4 sont la cellule mmoire SRAM proprement dite : c'est l qu'est conserv le bit. Si on regarde bien, ce montage est compos de deux sous-circuits composs de deux transistors.

www.siteduzero.com

Partie 4 : Mmoires

174/378

Ce montage a dj t vu auparavant. Il se contente d'inverser la tension place sur lentre : si cette tension reprsente un 1, alors la sortie vaut zro. Et inversement, si l'entre vaut zro, la sortie vaut 1. Il s'agit d'un circuit inverseur, aussi appel une porte NON . Avec ce circuit, la sortie sera connecte soit la tension d'alimentation et fournira un 1 en sortie, soit la masse de faon fournir un zro en sortie. Mais ce circuit, tout seul, ne fait qu'inverser le bit pass en entre. Pour conserver le bit pass en entre, la solution est simple : l'inverser deux fois, ce qui est fait avec deux inverseurs : la sortie du premier tant relie l'entre du second. Le premier inverseur va lire le bit de SRAM, et va fournir l'inverse sur sa sortie, en reliant celle-ci au zro volt ou la tension d'alimentation suivant la valeur du bit inverser. Puis, le second inverseur va prendre cet inverse et le r-inverser encore une fois, ce qui fait qu'on va retrouver le bit de dpart sur sa sortie. Cette sortie tant relie directement sur la sortie Q, on retrouve donc notre bit mmoriser sur la sortie. Notre bit d'entre est donc stock en reliant directement la sortie de notre bascule, soit la tension d'alimentation si c'est un 1, soit au zro volt si c'est un zro : pour ceux qui ne voient pas pourquoi, regardez le schma d'une porte inverseuse sous forme de transistors, imaginez que vous en mettiez deux la suite et mettez un bit sur son entre. Et l, il faut remarquer un truc : le bit est stock, mais cela ne fonctionne que tant que nos inverseurs sont aliments. Si on coupe la tension d'alimentation, la tension l'intrieur du fil qui distribuait celle-ci dans nos circuit s'annule. En regardant notre montage vu plus haut, on remarque que dans ce cas, la sortie sera relie soit au zro volt, soit une tension d'alimentation nulle : il vaudra toujours zro et le bit stock dans ce montage est perdu. Cela explique pourquoi les mmoires SRAM sont des mmoires volatiles. Les transistors nots M5 et M6 vont servir d'interrupteur, et relient la cellule mmoire (les 4 transistors du milieu) l'entre D (note BL sur le schma). Lors d'une lecture ou d'une criture, les deux transistors vont s'ouvrir. Cela permet de positionner la sortie des deux inverseurs la bonne valeur, afin de raliser une opration d'criture. Pour une lecture, il suffira de lire le bit voulu sur la sortie Q en fermant "linterrupteur" M5.

SRAM multiports et autres montages

Les mmoires multiports utilisent des transistors supplmentaires, qui ont exactement le mme rle que les transistors M5 et M6, mais qui sont relis des entres et des sorties diffrentes. Par contre, certaines mmoires SRAM arrivent se dbrouiller avec seulement 4 ou 2 transistors par bit, ce qui reprsente une vritable prouesse technique. Il est en effet possible de virer un transistor ou deux ou d'en remplacer certains par des rsistances, en modifiant le circuit. Cela permet de mettre plus de bits sur la mme surface de circuit : 2 transistors prennent moins de place sur une puce lectronique que 6 transistors. Pour information, les mmoires caches et les registres de notre processeur utilisent des bascules prenant 4 ou 2 transistors : c'est grce cela que vous avez autant de mmoires cache sur votre processeur.

Mmoire DRAM
Les DRAM fonctionnent diffremment : elle n'utilisent qu'un seul et unique transistor, et un autre composant lectronique nomm un condensateur. Pour simplifier, ce condensateur n'est rien d'autre qu'un gros rservoir lectrons : on peut le remplir dlectrons ou le vider en mettant une tension sur ses entres. C'est ce condensateur qui va stocker notre bit : le condensateur stocke un 1 s'il est rempli, et

www.siteduzero.com

Partie 4 : Mmoires
stocke un 0 s'il est vide. Rien de plus simple.

175/378

A cot, on ajoute un transistor qui relie ce condensateur au reste du circuit. Ce transistor sert d'interrupteur : c'est lui qui va autoriser l'criture ou la lecture dans notre condensateur. Tant que notre transistor se comporte comme un interrupteur ouvert, le courant ne passe pas travers, et le condensateur est isol du reste du circuit. : pas d'criture ou de lecture possible. Si on l'ouvre, on pourra alors lire ou crire dedans.

On utilise seulement un transistor et un condensateur. Une DRAM peut stocker plus de bits pour la mme surface qu'une SRAM grce cela : votre avis, entre un transistor coupl un condensateur et 6 transistors, qui prend le moins de place ?

Lecture et criture d'un bit

Seul problme : quand on veut lire ou crire dans notre cellule mmoire, le condensateur va tre connect sur le bus de donne. Et quand le condensateur est connect un bout de fil, il se vide entirement ! On perd son contenu : il faut donc le rcrire aprs chaque lecture. Pire : le condensateur se vide sur le bus, mais cela ne suffit pas crer une tension de plus de quelques millivolts dans celui-ci. Pas de quoi envoyer un 1 sur le bus ! Mais il y a une solution : amplifier la tension de quelques millivolts induite par la vidange du condensateur sur le bus. Pour cela, il faut donc placer un dispositif capable d'amplifier cette tension.

Une vraie passoire !

Il faut prciser une chose sur notre condensateur : celui-ci est plus proche d'une passoire que d'un rservoir lectrons. Un condensateur n'est pas vraiment un rservoir parfait, qui stockerait des lectrons indfiniment : il possde toujours quelques dfauts et des imperfections qui font que celui-ci se vide tout seul a bout d'un moment. Pour expliquer pourquoi, il faut savoir comment est fabriqu en condensateur. Celui-ci n'est rien d'autre qu'un ensemble de morceaux de conducteur lectrique (du mtal) spars par un isolant. Chacun de ces morceaux tant appel une armature. C'est sur une de ces armatures, que vont s'accumuler les lectrons, l'autre armature tant relie un fil contenant une tension de zro volts : la masse.

www.siteduzero.com

Partie 4 : Mmoires

176/378

Logiquement, lisolant empche les lectrons de passer d'une armature l'autre : ces lectrons n'ont nulle part o aller et sont censs rester sur l'armature tant que le transistor servant d'interrupteur ne dcide de relier le condensateur au reste du circuit. Mais dans la ralit, l'isolant qui spare les deux armatures n'est pas totalement tanche, et des lectrons passent de l'armature qui le stocke l'autre, relie la masse, et quittent donc le condensateur. En clair, le bit contenu dans la cellule de mmoire DRAM s'efface, et c'est pour cela qu'on doit le rcrire rgulirement. V ous comprenez maintenant pourquoi on doit rafraichir une mmoire DRAM, et aussi pourquoi celle-ci est volatile.

1T DRAM
Au fait, j'ai oubli de dire un truc : certaines mmoires n'ont besoin que d'un transistor dont la grille sert de condensateur. Aprs tout, notre grille consiste elle aussi en un rservoir dlectrons, et on peut s'en servir pour remplacer le condensateur. Ce sont les 1T DRAM. Ces mmoires ont toujours besoin d'tre rafraichies : la grille d'un transistor est aussi une vritable passoire. A croire que tous les composants lectroniques se sont donns le mot ! Mais par contre, un bit de 1T DRAM ne s'efface pas lors d'une lecture. Ces mmoires sont rarement utilises dans les ordinateurs grands-publics : aucun de nos ordinateurs x86 n'en possde, ma connaissance.

Correction d'erreurs
Une mmoire n'est pas un dispositif parfait : il est possible que certaines oprations de lecture ou d'criture ne se passent pas correctement et qu'on lise ou crive des donnes corrompues. Un bit d'une mmoire peut parfaitement tre modifi, suite l'action d'un rayonnement quelconque ou d'une perturbation lectromagntique de passage. Aprs tout, ce n'est pas une chose si rare : on est sans cesse entour par des rayonnements divers, aussi bien naturels quartificiels, qui peuvent interfrer avec le fonctionnement des appareils lectroniques qui nous entourent et les mmoires ne font pas exception ! Et bien sachez que certaines mmoires sont capables de limiter les effets de ces erreurs en les dtectant, voire en les corrigeant. Oui, vous avez bien lu : seules certaines mmoires spcialement conues pour en sont capables. Et c'est tout fait normal : dans la majorit des cas, on se moque qu'un bit de notre mmoire aie t modifi, cela ayant peu de consquences. Seules certaines applications critiques qui ne tolrent pas la moindre erreur, comme les ordinateurs implants sur des serveurs ou des satellites, sont concerns par ce genre de problmes. Dans les autres cas, utiliser une mmoire capable de corriger ou de dtecter des erreurs est inutile. Sans compter que les mmoires capables de corriger des erreurs sont plus chres et parfois plus lentes que les mmoires ordinaires : il faut bien rajouter des circuits capables de dtecter ou de corriger ces erreurs, et cela a un cout pas vraiment ngligeable en terme d'argent ou de performances ! Quoi qu'il en soit, certaines mmoires utilisent des techniques plus ou moins volues pour corriger les erreurs et autres corruptions de la mmoire. Ces techniques ncessitent toutes l'ajout de bits supplmentaires pour pouvoir fonctionner : chaque case mmoire contient non seulement les bits qui servent coder une donne, mais aussi des bits cachs qui servent uniquement dtecter ou corriger des erreurs. Ces bits ne sont jamais relis au bus de donne, et sont accessibles et modifiables uniquement par des circuits internes la mmoire qui sont spcialement ddis au contrle et la correction des erreurs.

Bit de parit ou d'imparit

La premire technique de correction d'erreur n'est rien d'autre que le fameux bit de parit, vu au chapitre 3. Pour rappel, ce bit de parit permet de dtecter des erreurs qui modifient un nombre impair de bits. Si un, trois, cinq, ou un nombre impair de bits voient leur valeur s'inverser (un 1 devient un 0, ou un 0 qui devient un 1), la technique du bit de parit (ou dimparit) permettra de dtecter cette erreur. Par contre, il sera impossible de la corriger. Le principe cach derrire un bit de parit est simple : il suffit d'ajouter un bit supplmentaire aux bits stocker. Ce bit, le bit de parit vaudra zro si le nombre de bits 1 dans le nombre stocker (bit de parit exclu) est pair, et vaudra 1 si ce nombre est impair. Le but d'un bit de parit est de faire en sorte que le nombre de bits 1 dans le nombre stocker, bit de parit inclut, soit toujours un nombre pair : si cette somme est paire, on rajoute zro, et si elle est impaire on rajoute un un pour obtenir un nombre de bit 1 pair. De mme, il existe un bit d'imparit, conu de faon ce que le nombre de bits 1 dans le nombre, bit d'imparit inclut, soit un nombre impair. Sa valeur est l'exact inverse de celle d'un bit de parit obtenu pour le mme nombre.

Exemple
Prenons le nombre 00000101. Celui-ci contient 6 bits 0 et 2 bits 1. La somme de tous ces bits vaut donc 2. Le bit de parit vaudra donc zro.

www.siteduzero.com

Partie 4 : Mmoires
En plaant le bit de parit au dbut du nombre, on obtient : 000000101. Autre exemple : le nombre 11100101. Celui-ci contient 3 bits 0 et 5 bits 1. On trouve 5 bits 1 dans ce nombre, ce qui donne un nombre impair. Le bit de parit vaudra donc un. Le total sera donc : 11110101.

177/378

Dtection d'erreur
Dtecter une erreur est simple : on compte le nombre de bits 1 dans le nombre stocker, bit de parit inclut, et on regarde s'il est pair. S'il est impair, on sait qu'au moins un bit t modifi. En modifiant un bit, la parit du nombre total de bits 1 changera : le nombre de bits 1 sera amput (si un 1 devient un 0) ou augment de 1 (cas inverse) et deviendra un nombre impair. Et ce qui est valable pour un bit l'est aussi pour 3, 5, 7, et pour tout nombre impair de bits modifis. Par contre, si un nombre pair de bit est modifi, la parit du total ne changera pas et restera compatible avec la valeur du bit de parit : on ne pourra pas dtecter l'erreur.

Mmoires ECC
Mais savoir qu'un bit a t modifi sans pouvoir corriger l'erreur est quelque peu frustrant. Sans compter les erreurs qui modifient un nombre pair de bits, qui ne sont pas dtectes. Pour rsoudre ces dfauts, inhrents aux mmoires utilisant un bit de parit, on a invent d'autres types de mmoires : les mmoires ECC. Ces mmoires utilisent des mthodes de dtection d'erreur plus sophistiques, qui utilisent au moins deux bits supplmentaires par case mmoire. On les retrouve le plus souvent dans des serveurs ou dans des ordinateurs qui doivent fonctionner dans des environnements hostiles sans tomber un panne : la mmoire d'un calculateur implant dans un satellite ou une navette spatiale. Le plus souvent, la technique de correction d'erreur utilis est un code de hamming, coupl avec un bit de parit. Cela permet de dtecter les erreurs qui modifient 2 bit ou un nombre impair de bits, et de corriger les erreurs qui ont modifies 1 bit.

www.siteduzero.com

Partie 4 : Mmoires

178/378

Contrleur et plan mmoire

Une fois qu'on a russi crer un plan mmoire, celui-ci ne nous sert rien si l'on ne peut pas slectionner la case mmoire lire ou crire. Heureusement, les mmoires actuelles sont adressables, et on peut prciser quelle case mmoire lire ou crire en prcisant son adresse. Cette gestion de l'adresse mmoire ne se fait pas toute seule : vous vous doutez bien qu'on a forcment besoin de circuits supplmentaires pour grer l'adressage et la communication avec le bus. Ce rle est assur par un circuit spcialis qu'on appelle le contrleur mmoire. Notre mmoire est ainsi compose : d'un tas de cellules mmoires capables de retenir 1 bit, regroupes dans un plan mmoire ; d'un circuit qui gre le plan mmoire, nomm le contrleur mmoire : il s'occupe de l'adressage, du rafraichissement mmoire (pour les DRAM) et de bien d'autres choses ; et des connexions avec le bus. Dans ce chapitre, on va voir comment l'ensemble est organis, et voir dans les grandes lignes comment fonctionne un contrleur mmoire. Mais avant tout, je tiens donner une petite prcision : je ne parlerais pas du fonctionnement des mmoires multiports dans ce chapitre, et me contenterais d'voquer les mmoires connectes un seul bus.

Mmoires adressage linaire

Pour commencer, il faut savoir que tous les plans mmoires ne se ressemblent pas. Il y a beaucoup de faons plus ou moins efficaces d'organiser nos cellules mmoires. Nous allons commencer par parler des plans mmoires les plus simples : ceux utilises dans ce qu'on appelle les mmoires adressage linaire. Pour vous donner un exemple, les registres du processeur sont le meilleur exemple possible de mmoire adressage linaire.

Plan mmoire linaire

Sur de telles mmoires, le plan mmoire est organis sous la forme d'un tableau rectangulaire de cellules mmoires. Les cellules mmoires sont alignes les unes cot des autres, aussi bien horizontalement que verticalement. Toutes les cellules mmoires places sur une ligne appartiennent une mme case mmoire.

Chaque cellule mmoire d'une case mmoire est connecte sur un fil qui lui permettra de communiquer avec le bus de donne. Avec cette organisation, la cellule mmoire stockant le i-me bit du contenu d'une case mmoire (le bit de poids i) est relie au ime fil du bus.

www.siteduzero.com

Partie 4 : Mmoires

179/378

Connectons le tout au bus

Reste un premier problme : comment slectionner la bonne case mmoire lire ou crire ?

Vu qu'une case mmoire est stocke sur une ligne, il suffit de slectionner la bonne ligne dans le plan mmoire . Pour pouvoir slectionner une ligne, une solution simple est utilise : on dconnecte du bus les cases mmoires/lignes dans lesquelles on ne veut pas crire ou lire, et on connecte sur le bus uniquement la case mmoire manipuler. Cette connexion/dconnexion est ralise par un vulgaire interrupteur qu'on peut commander lectroniquement (pour lui dire de s'ouvrir ou de se fermer) : notre transistor fait son retour ! Exemple en utilisant un transistor en guise d'interrupteur.

Pour autoriser une lecture ou une criture dans une cellule mmoire, il suffira de fermer ce transistor en envoyant un 1 sur la grille de celui-ci. Par contre, notre cellule mmoire sera dconnecte du bus si la grille du transistor est zro : le transistor se comportera comme un interrupteur ouvert. V ous vous souvenez que dans les cellules mmoires de DRAM (et certaines SRAM), il y a au moins un petit circuit

www.siteduzero.com

Partie 4 : Mmoires

180/378

(souvent un transistor) qui permet d'autoriser les lectures ou criture ? Et bien il suffit d'intercaler ce transistor entre le bus et la mmoire. Dans ce genre de cas, le transistor est intgr la cellule mmoire. Mais a n'est pas toujours le cas.

Vu que tous les bits d'une case mmoire sont rassembls sur une ligne, tous les transistors relis aux cellules mmoires de cette ligne devront "s'ouvrir" ou se "fermer" en mme temps : on relie donc leur grille au mme fil, sur lequel on enverra un 1 ou un zro selon qu'on veuille ouvrir ou fermer ces transistors.

Comme vous le voyez, ce fil s'appelle Row Line sur le schma. Pour slectionner notre case mmoire parmi toutes les autres, il suffira de positionner son entre Row Line 1, et placer les entres Row Line de toutes les autres cases mmoires zro. Le rle du contrleur mmoire est donc de dduire quelle entre Row Line mettre un partir de l'adresse envoye sur le bus d'adresse.

Adressage
Pour slectionner la bonne ligne, notre contrleur mmoire doit rpondre plusieurs exigences : Il doit partir d'une adresse code sur bits, et en dduire quelle case mmoire slectionner : ce contrleur a donc entres ; notre adresse de bits peut adresser bytes : notre contrleur mmoire doit donc possder sorties ; chacune de ces sorties sera relie une entre row line et permettra de connecter ou dconnecter une case mmoire du bus ; on ne doit slectionner qu'une seule case mmoire la fois : une seule sortie devra tre place 1, et toutes les autres zro ; et enfin, deux adresses diffrentes devront slectionner des cases mmoires diffrentes : la sortie de notre contrleur qui sera mise 1 sera diffrente pour deux adresses diffrentes places sur son entre. Il existe un composant lectronique qui rpond ce cahier des charges : le dcodeur. C'est le composant parfait pour positionner notre bit Row Line. Exemple d'un dcodeur 3 entre et 8 sorties.

www.siteduzero.com

Partie 4 : Mmoires

181/378

On peut remarquer que toutes les sorties d'un dcodeur sont numrotes : sur un dcodeur possdant entres, nos sorties sont numrotes de . Le fonctionnement de notre dcodeur est trs simple : il prend sur son entre un nombre entier x cod en binaire, positionne 1 la sortie numrot x et positionne zro toutes les autres sorties. Ce dcodeur est, comme tous les autres circuits lectroniques, conu avec des portes logiques. Son cblage est assez complexe, aussi on vous l'pargnera dans ce qui va suivre. Nanmoins, vous pouvez parfaitement essayer de tenter de crer un dcodeur 2 vers 4 ou 3 vers 8 par vous mme : essayez, a fait un bon exercice pour les neurones ! Reste savoir comment utiliser ce dcodeur pour slectionner nos adresses.

L'adressage des mmoires adressage linaire

Pour adresser une mmoire adressage linaire, il suffit de relier chaque fil Row Line sur une sortie de ce dcodeur. Plus prcisment, le bit Row Line de la case mmoire d'adresse N doit tre connecte la sortie numro N du dcodeur : ainsi, si on envoie l'adresse N sur l'entre de ce dcodeur, la sortie N sera slectionne, ce qui slectionnera la case mmoire approprie. L'adresse a juste tre place directement sur l'entre de notre dcodeur, qui se chargera de slectionner le bon fil Row Line qui correspond notre adresse. Exemple d'une mmoire de 4 cases mmoires avec une adresse de deux bits.

Notre contrleur mmoire se rsumera donc un simple dcodeur, avec quelques circuits pour grer le sens de transfert (lecture ou criture), et la dtection/correction d'erreur. Ce genre d'organisation s'appelle l'adressage linaire.

Mmoires adressage par coicidence

Sur des mmoires ayant une grande capacit, utiliser un seul gros dcodeur va poser quelques problmes. En effet, plus notre dcodeur doit adresser de cases mmoires, plus celui-ci va contenir de portes logiques relies les unes la suite des autres. Ces portes ne ragissent pas instantanment, et ont toutes un lger temps de raction (le temps de propagation). Ces temps de raction s'accumulent quand on relie nos portes logiques les unes la suite des autres, ce qui fait que gnralement, plus un circuit contient de portes logiques relies ensembles, plus il est lent. Autant dire qu'un gros dcodeur risque d'tre assez lent. Pour rgler ce problme, nos mmoires vont devoir modifier lgrement le plan mmoire. L'ide est de diminuer le nombre de lignes pour viter de se retrouver avec un dcodeur lent et norme. Il n'y a qu'une seule solution cela : regrouper plusieurs cases mmoires sur une seule ligne.

www.siteduzero.com

Partie 4 : Mmoires

182/378

Ainsi, il suffira de slectionner la ligne voulue, et slectionner la case mmoire l'intrieur de la ligne. Slectionner une ligne est facile : on utilise un dcodeur. Mais la slection de la colonne est quelque chose de nettement plus intressant : la mthode utilise pour slectionner la colonne dpend de la mmoire utilise.

Plan mmoire
Commenons par aborder la premire : celle utilise pour les mmoires adressage par concidence. Sur ces mmoires, les cases mmoires sont organises en lignes et en colonnes.

Il faut prciser qu'on trouve une case mmoire l'intersection entre une colonne et une ligne. Bien videmment, chaque case mmoire est relie au bus via un transistor servant d'interrupteur, comme pour les mmoires adressage linaire. Et comme pour les mmoires adressage linaire, la slection d'une case mmoire sur le bus se fait grce un signal qui ouvrira ou fermera ces fameux transistors. Mais ce signal ne se contentera pas d'une ligne Row Line.

www.siteduzero.com

Partie 4 : Mmoires

183/378

Adressage par concidence

Slectionner une colonne se fera en utilisant un second dcodeur. Avec cette solution, toutes les cases mmoires d'une ligne sont relies un fil, qu'on nommera le Row Line, et toutes les cases mmoires d'une colonne sont relies un autre fil : le Column Line. Une case mmoire est slectionne quand ces deux fils sont mit 1 : pour cela, il suffit de relier la Row Line et la Column Line adquates aux entres d'une porte ET dont on relie la sortie sur la grille de notre transistor charg de relier notre case mmoire au bus. Sur ce schma, les carrs noirs sont les portes ET dont je parle au-dessus. Faites attention : les Row Line et les Column Line ne se touchent pas et ne sont pas connectes entre elles : il n'y a pas d'intersection, un des fils passant en-dessous de l'autre.

On utilise donc deux dcodeurs : un pour slectionner la Row Line relie la ligne contenant la case mmoire lire ou crire ; et un autre pour slectionner la colonne. Ces deux dcodeurs sont assez petits, et surtout, ils peuvent fonctionner en mme temps : au lieu d'avoir un seul gros dcodeur assez lent, on peut utiliser deux dcodeurs plus rapides, et qui fonctionnent plus ou moins en mme temps.

Adresses hautes et basses

Cela permet de dcouper notre adresse mmoire en deux morceaux : une adresse haute qui va slectionner la ligne et une adresse basse qui va slectionner la colonne. Nos adresses mmoires peuvent ainsi tre envoyes en deux fois notre mmoire au lieu d'une (en fait, on pourrait aussi envoyer une adresse en deux fois sur une mmoire qui utiliserait l'adressage linaire, mais ce serait un peu plus compliqu).

Mmoire Row Buffer

Enfin, nous allons voir une espce de mlange entre les deux types de mmoires vues prcdemment : les mmoires Row Buffer. Ces mmoires utilisent le mme principe que les mmoires adressage par concidence : elles regroupent plusieurs cases mmoires sur une seule ligne. Mais la slection de la colonne s'effectue diffremment.

Le plan mmoire
le plan mmoire de ces mmoires Row Buffer est identique aux mmoires adressage linaire : il est compos uniquement de lignes. Mais ces lignes sont trs grosses et rassemblent plusieurs cases mmoires. Toutefois attention : les bits d'une mme case

www.siteduzero.com

Partie 4 : Mmoires

184/378

mmoire ne sont pas forcment rassembls les uns cot des autres sur ce genre de mmoires. La nouveaut, c'est que chaque case mmoire n'est pas relie directement sur le bus (ou via un transistor servant dinterrupteur commandable) comme avant.

Adressage
Elles n'utilisent qu'un seul dcodeur, qui ne sert qu' slectionner la ligne. Une fois cette ligne slectionne, elle est recopie intgralement dans une sorte de gros registre temporaire dans lequel on viendra slectionner la case mmoire correspondant notre colonne. Ce gros registre temporaire s'appelle le Row Buffer.

Une fois la ligne recopie, on peut dcider de ne slectionner qu'une partie de ce Row Buffer (partie qui correspond une colonne) et l'envoyer sur le bus de donnes. Pour slectionner la colonne, nos mmoires vont utiliser d'autres composants lectroniques spcifiques qu'on appelle des multiplexeurs. Ces multiplexeurs sont en quelque sorte des "cousins" du dcodeur.

Avantages
a peut paraitre compliqu de concevoir une mmoire ainsi, mais cela a un gros avantage d'organiser les mmoires DRAM comme ceci : cela permet d'effectuer l'opration de rafraichissement trs simplement. Il suffit de recopier le contenu d'une ligne dans le Row Buffer, avant de faire l'inverse en recopiant le contenu du Row Buffer dans la ligne mmoire slectionne. Il suffira d'intercaler un circuit charg du rafraichissement quelque part dans notre contrleur mmoire pour que le tout fonctionne.

Interfacage avec le bus

Avec ce qu'on a vu plus haut, on sait comment adresser une case mmoire, mais il nous reste une chose faire : on peut lire ou crire dans une case mmoire et il nous faut donc commander nos circuits de faon ce qu'ils fassent une lecture ou une criture. Dans le cas d'une lecture, le contenu de notre case mmoire est recopie sur le bus. Dans le cas d'une criture, c'est l'inverse : le contenu du bus qui est recopi dans la case mmoire slectionne. Suivant qu'on fasse une lecture ou criture, le sens de transfert des donnes n'est pas le mme. Comment choisir le sens de transfert des donnes ?

Circuits trois tats

Premire solution : comme chaque fois qu'on a un problme, on rajoute un circuit. Il suffit simplement d'intercaler des composants chargs d'imposer le sens des transferts entre le bus de donnes et les fils relis aux diffrentes cases mmoires.

www.siteduzero.com

Partie 4 : Mmoires
Les circuits chargs d'imposer le sens des transferts de donnes sont indiqus en jaune sur le schma suivant.

185/378

Ces circuits sont ce qu'on appelle des circuits trois tats. Rien de bien mchant, il s'agit juste de circuits lectroniques fabriqus avec des transistors qui vont apporter une solution notre problme.

Fonctionnement
V quoi ressemble un circuit trois-tats : oici

Notre circuit trois tats permet de prciser le sens de transfert : soit de E1 vers E2, soit l'inverse. Il peut aussi se comporter comme un interrupteur ouvert, et ainsi dconnecter les deux fils. Le choix du mode de fonctionnement se fera par ce qu'on mettra sur son entre de commande : soit le circuit trois tats agit comme un interrupteur ouvert ; soit le circuit trois tats recopie la tension prsente sur l'entre E1 sur lentre E2 : le bit envoy sur E1 va alors passer vers le fil reli E2 ; soit circuit trois tats recopie la tension prsente sur l'entre E2 sur lentre E1 : le bit envoy sur E1 va alors passer vers le fil reli E1. On a besoin de prciser trois cas, donc on utilise deux entres pour cela.

www.siteduzero.com

Partie 4 : Mmoires

186/378

On a donc rsolu notre problme : il suffit d'intercaler un circuit trois tats entre le plan mmoire et le bus, et de commander celuici correctement. C'est le contrleur mmoire qui place l'entre de commande du circuit trois tats pour slectionner le sens de transfert de donne suivant l'tat du bit R/W.

Mmoires ports de lecture et criture spars

Encore une fois, la solution vue plus haut n'est pas la seule. Su d'autres mmoires, on n'a pas besoin d'utiliser des circuits trois tats. Sur ces mmoires, la lecture et l'criture ne passe pas par les mmes fils. C'est le cas pour les registres. Souvenez-vous quoi ressemble un registre.

Comme vous le voyez, crire une donne ne passe pas par les mmes fils que la lecture. Ainsi, la solution est vidente : il suffit de relier tout ces fils sur le bus, et connecter les bons fils pour choisir le sens de transfert.

www.siteduzero.com

Partie 4 : Mmoires

187/378

Comme vous le voyez sur ce schma, les fils ddis la lecture ou l'criture sont tous relis sur le bus, avec un transistor intercal au bon endroit. Il suffit d'ouvrir ou de fermer les bons transistors pour dclencher soit une lecture (on ferme les transistors IN) ou une criture (on ferme les transistors OUT). C'est le contrleur mmoire qui se charge de dduire les tensions IN et OUT envoyer sur les grilles des transistors intercals entre le bus et la case mmoire.

Assemblages de mmoires
Ce qu'on a vu plus haut est l'organisation interne d'une mmoire RAM/ROM simple. Dans la ralit, il faut savoir que nos mmoires ne sont pas faites d'un seul bloc, mais sont constitues de plusieurs mmoires plus simples rassembles dans un seul boitier. Si vous ne me croyez pas, prenez une barrette de mmoire RAM, et regardez de plus prt.

V ous voyez : chaque puce noire sur notre barrette de mmoire RAM est une petite mmoire elle toute seule. Sur une barrette de mmoire RAM, on trouve pleins de petites mmoires rassembles sur un seul circuit imprim (notre barrette de mmoire) et organises d'une certaine faon. Cela a un certain avantage, qu'on verra plus tard. Mais avant de passer la pratique, une petite prcision s'impose : rassembler plusieurs mmoires dans un seul boitier peut tre fait de diverses faons diffrentes : on peut dcider de doubler le nombre d'adresses, doubler la taille d'un byte, ou faire les deux. Suivant ce que l'on veut faire, l'organisation de nos sous-mmoires ne sera pas la mme.

www.siteduzero.com

Partie 4 : Mmoires

188/378

Arrangement horizontal
Commenons par notre premier cas : on va utiliser plusieurs boitiers pour doubler la taille d'un byte sans changer le nombre de cases mmoires adressables. C'est ce qu'on appelle l'arrangement horizontal. Prenons un exemple : on va cherche obtenir une mmoire ayant un byte de 16 bits en partant de deux mmoires ayant un byte de 8 bits. Pour cela, il suffit de relier nos mmoires de faon ce que la premire contienne les bits de poids fort du byte de 16 bits, et que l'autre contienne les bits de poids faible.

On voit que l'on adresse plusieurs mmoires en mme temps : chaque mmoire contient un morceau de la donne qu'on souhaite lire ou crire. Il suffit de les relier sur le bus correctement, de faon ce que chaque morceau de la donne aille au bon endroit. videmment, chaque morceau de donne possde la mme adresse que les autres morceaux : l'adresse (et les entres de commande : difficile de lire un morceau de case mmoire perdant qu'on en crit un autre) est envoye sur toutes les sousmmoires. Avec cette organisation, tout se passe comme si notre mmoire tait compose de plusieurs plans mmoires : un par boitier. Ce qu'on vient de voir peut vous semblez d'une tonnante simplicit, mais sachez que c'est quelque chose de similaire qui est utilis dans nos barrettes de mmoires actuelles.

Mmoires plusieurs plans mmoires

Sur les mmoires SDRAM, DDR-RAM et autres mmoires prsentes l'intrieur de notre PC, on utilise beaucoup cet arrangement horizontal. Toutes ces mmoires possdent un byte de 8 bits, mais sont en ralit composes de 8 sous-mmoires ayant un byte de 1 bit. Ces 8 sous-mmoires correspondent aux puces noires prsentes sur vos barrettes de mmoires RAM.

www.siteduzero.com

Partie 4 : Mmoires

189/378

Lintrt de faire comme ceci ? Maitriser la rpartition de chaleur l'intrieur de notre mmoire. Accder une cellule mmoire, a chauffe ! Si on utilisait une seule puce mmoire ayant un byte de 8 bits, les 8 bits auxquels on accderait seraient placs les uns cot des autres et chaufferaient tous au mme endroit. A la place, les fabricants de mmoire RAM prfrent disperser les bits d'un mme octet dans des puces diffrentes pour rpartir la chaleur sur une plus grande surface et la disperser plus facilement. Sans cela, nos mmoires ne fonctionneraient tout simplement pas sans systmes de refroidissements adapts.

Dual channel
V ous avez surement dj entendu parler de dual-channel. Et bien sachez que cette technologie est base sur le mme principe. Sauf qu'au lieu de rassembler plusieurs puces mmoires (les trucs noirs sur nos barrettes) sur une mme barrette, on fait la mme chose avec plusieurs barrettes de mmoires. Ainsi, on peut mettre deux barrettes ayant un bus de donne capable de contenir 64 bits et on les relie un bus de 128 bits. C'est ce qu'on appelle le dual-channel.

Arrangement vertical
Une autre possibilit consiste rassembler plusieurs boitiers de mmoires pour augmenter la capacit totale. On utilisera un boitier pour une partie de la mmoire, un autre boitier pour une autre, et ainsi de suite. Par exemple, on peut dcider d'utiliser deux sous-mmoires : chacune de ces sous-mmoire contenant la moiti de la mmoire totale. C'est ce qu'on appelle l'arrangement vertical. a peut vous paraitre bizarre, mais rflchissez un petit peu, vous pouvez trouver un exemple parfait d'arrangement vertical dans votre PC : vous pouvez parfaitement placer plusieurs barrettes de mmoires sur votre carte mre pour doubler la capacit. Si vus n'utilisez pas de dual-channel, vous aurez un arrangement vertical. Avec cette solution, quand on accde une case mmoire de notre grosse mmoire rassemblant tous les boitiers, on accde un boitier parmi tout les autres. Il nous faudra slectionner le bon boitier, celui qui contient notre case mmoire. Comment faire ?

Entre de slection
Pour cela, il va falloir que je vous dise quelque chose. V ous vous souvenez que dans le chapitre prcdent, j'ai dit qu'une mmoire ressemblait a :

www.siteduzero.com

Partie 4 : Mmoires

190/378

Mais j'ai volontairement pass un dtail sous silence : nos mmoires possdent une broche supplmentaire nomme CS, qui sert activer ou dsactiver la mmoire. Suivant la valeur de ce bit, notre mmoire sera soit place en veille sans possibilit de ragir aux vnements extrieurs (elle conservera toutefois son contenu), soit fonctionnera normalement. Et c'est grce cette broche qu'on va pouvoir rassembler plusieurs boitiers dans notre mmoire.

Une histoire d'adresse

Avec cette organisation, une adresse mmoire est dcoupe en deux partie : une partie qui est dcode pour slectionner le bon boitier, et une autre qui sert slectionner la case mmoire dans le boitier. Sur certaines mmoires, on utilise les bits de poids forts pour slectionner le bon boitier.

l'ide est simple : pour accder une case mmoire, on envoie le morceau de l'adresse slectionnant la case mmoire dans le boitier et le bit R/W toutes les mmoires, et on teint les mmoires qui ne stockent pas la case mmoire voulue. Seul le boitier contenant la donne restera allume et pourra rpondre la commande (adresse + ordre de lecture/criture) envoy par le contrleur mmoire. Il suffira donc de positionner les bits CS de chaque mmoire la bonne valeur. Un seul boitier sera allum et aura donc son bit CS 1, tandis que tous les autres seront teints et verront leur bit CS passer 0. Le fait que seul un boitier parmi tous les autres soit activ devrait vous rappeler quelque chose : oui, on utilise bien un dcodeur pour slectionner le boitier.

Mmoires interleaved
Mais sur d'autres, on utilise les bits de poids faible pour slectionner le bon boitier : ce sont ce qu'on appelle des mmoires interleaved.

www.siteduzero.com

Partie 4 : Mmoires

191/378

En faisant ainsi, on peut mettre des bytes conscutifs dans des mmoires diffrentes. Cela permet, en adaptant le contrleur mmoire, d'obtenir des opportunits doptimisation assez impressionnantes. Et l, je suis sr que vous ne voyez pas vraiment pourquoi. Aussi, une explication s'impose. L'accs un boitier prend toujours un peu de temps : c'est le fameux temps d'accs dont on a parl il y a quelques chapitres. Si on place deux bytes ayant des adresses conscutives dans le mme boitier, et qu'on souhaite lire/crire ces deux bytes, on devra attendre que l'accs au premier byte soit fini avant de pouvoir accder au suivant (sauf si la mmoire est multiports, mais bref). En clair : on ne peut effectuer qu'un seul accs la fois sur des bytes conscutifs.

Mais ce n'est valable qu'avec les mmoires qui ne sont pas des mmoires interleaved ! Avec les mmoires interleaved , la donne est diffrentes : des bytes conscutifs sont localiss dans des boitiers diffrentes qui peuvent tre accds en parallle.

On peut ainsi accder des bits conscutifs bien plus rapidement qu'avec des mmoires "normales".

Arrangement mixte
Enfin, on peut mlanger l'arrangement horizontal et l'arrangement vertical pour obtenir des mmoires plus grosses et ayant des bytes plus gros. Et voil, maintenant que vous avez lu ce chapitre, vous tes capables de crer une petite mmoire RAM assez simples. a vous plait ?

www.siteduzero.com

Partie 4 : Mmoires

192/378

www.siteduzero.com

Partie 4 : Mmoires

193/378

Mmoires DDR, SDRAM et leurs cousines

Au chapitre prcdent, on a vu comment des mmoires RAM ou ROM simples taient organises. Mais les mmoires actuelles sont un peux plus complexes que les mmoires simplistes qu'on a vues au chapitre prcdent. Ce chapitre va vous expliquer dans les grandes lignes en quoi nos mmoires actuelles sont meilleures, et comment elles fonctionnent. Rassurez-vous, vous serez tout de mme en terrain connu : les mmoires RAM actuelles ne sont que des amliorations des mmoires vues prcdemment.

Les anctres : les Fast Page Mode et EDO-RAM

De nos jours, vos mmoires sont des mmoires DDR1, DDR2, voire DDR3. Mais avant l'invention de ces DDR, il a exist un grand nombre de mmoires plus ou moins diffrentes. V ous connaissez surement les mmoires SDRAM, mais on va commencer par encore plus ancien : nous allons parler des mmoires utilises sur les premiers processeurs Intel comme les 486 DX et le premier Pentium, savoir la mmoire FPM et la mmoire EDO. Ces mmoires taient toutes des mmoires qui n'taient pas synchronises avec le processeur via une horloge. On appelle de telles mmoires des mmoires asynchrones. Quand ces mmoires ont ts cres, cela ne posait aucun problme : la mmoire tait tellement rapide que le processeur n'avait pas vraiment se synchroniser avec la mmoire. Une lecture ou criture prenait nettement moins de temps qu'un cycle d'horloge, et le processeur tait certain que la mmoire aurait dj fini sa lecture ou criture au cycle suivant. Du moins, c'tait vrai au dbut. La premire mmoire volue qui fut invente s'appelle la mmoire FPM, ou Fast Page Mode. Ce fut la premire mmoire tre produite sous la forme de barrettes. Elle fut suivi quelques annes plus tard de la mmoire EDO-RAM, qui n'en est qu'une amlioration.

Format des mmoires FPM et EDO

Ces mmoires FPM et EDO-RAM taient produites sous forme de barrettes qui existaient en deux versions : une version 72 broches, et une version 30 broches. Les broches dont je parle, ce sont les trucs jaunes situes en bas des barrettes de mmoire. Elles servent connecter les circuits de notre barrette de mmoire sur le bus. Voici quoi ressemblait la version 30 broches.

Pour les curieux, voici en dtail quoi servent ces broches. Dtail des broches 1 2 3 4 5 6 7 8 9 10 11 Utilit Tension d'alimentation Signal CAS (on en parlera plus tard) Bit 0 du bus de donne Bit 0 du bus d'adresse Bit 1 du bus d'adresse Bit 1 du bus de donnes Bit 2 du bus d'adresse Bit 3 du bus d'adresse Masse : zro volt Bit 2 du bus de donnes Bit 4 du bus d'adresse

www.siteduzero.com

Partie 4 : Mmoires
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 Bit 5 du bus d'adresse Bit 3 du bus de donnes Bit 6 du bus d'adresse Bit 7 du bus d'adresse Bit 4 du bus de donnes Bit 8 du bus d'adresse Bit 9 du bus d'adresse Bit 10 du bus d'adresse Bit 5 du bus de donnes Bit R/W Zro volt : masse Bit 6 du bus de donnes Bit 11 du bus d'adresse Bit 7 du bus de donnes Bit de parit pour les donnes crites Signal RAS (on en parlera dans ce qui va suivre) Signal CASP Bit de parit pour les donnes lues Tension d'alimentation (en double)

194/378

Si vous vous amusez compter les nombre de bits pour le bus de donne et pour le bus d'adresse, vous remarquerez que le bus d'adresse contient 12 bits et que le bus de donnes en fait 8. Les mmoires 72 broches contiennent plus de bits pour le bus de donnes : 32 pour tre prcis. Par contre le bus d'adresse ne change pas : il reste de 12 bits. D'autres bits pour ou moins importants ont ts rajouts : les bits RAS et CAS sont en plusieurs exemplaires et on trouve 4 fois plus de bits de parit (un par octet transfrable sur le bus de donnes). Et voil ce que donnait la version 72 broches.

Pour information, la tension d'alimentation des mmoires FPM tait de 5 volts. Pour les mmoires EDO, cela variait entre 5 et 3.3 volts.

Timings de base des mmoires asynchrones

Je ne sais pas si vous avez remarqus, mais le bus d'adresse de 12 bits de ces mmoires ne permettait d'adresser que 4 kibioctets de mmoires, ce qui est trs peu. En fait, il y a une grosse astuce derrire tout a : l'adresse tait envoye en deux fois. Cette

www.siteduzero.com

Partie 4 : Mmoires

195/378

adresse tait alors dcoupe en deux parties : une adresse haute, et une adresse basse. Ces mmoires asynchrones taient toutes sont des mmoires adressage par concidence ou Row Buffer. Elles taient donc organises en lignes et en colonnes. L'adresse haute permettait de slectionner la ligne du plan mmoire, et l'adresse basse slectionnait la colonne.

RAS et CAS
Mais envoyer l'adresse en deux fois ncessitait de dire la mmoire si le morceau d'adresse prsent sur le bus d'adresse servait slectionner une ligne ou une colonne. Imaginez ce qui pourrait arriver si jamais la mmoire se trompait ! Pour cela, le bus de commande de ces mmoires contenait deux fils bien particuliers : les RAS et le CAS. Pour simplifier, le Signal RAS permettait slectionner une ligne, et le signal CAS permettait de slectionner une colonne.

Petite prcision : les signaux RAS et CAS font quelque chose quand on les met zro et non 1. Le mmoire va les prendre en compte quand on les fait passer de 1 zro : c'est ce moment l que la ligne ou colonne dont l'adresse est sur le bus sera slectionne. Tant que des signaux sont zro, la ligne ou colonne reste slectionne : on peut changer l'adresse sur le bus, cela ne dslectionnera pas la ligne ou la colonne et la valeur prsente lors du front descendant est conserve. Ces signaux RAS et CAS taient gnrs par un circuit install sur la carte mre.

rafraichissement mmoire
Au fait, il ne faut pas oublier quelque chose : ces mmoires FPM et EDO sont avant tout des mmoires DRAM, et doivent donc tre rafraichies suffisamment souvent. Sur ces mmoires FPM et EDO, le rafraichissement se faisait ligne par ligne : on rcrivait chaque ligne une par une, intervalle rguliers. Sur certaines cartes mres, un circuit install sur la carte mre slectionnait priodiquement une ligne, et envoyait les signaux RAS et CAS une certaine valeur pour la rafraichir. Puis, il attendait durant un temps prcis avant de slectionner la ligne suivante, et faisait cela priodiquement. Pour donner l'ordre la mmoire de rafraichir une ligne, il suffit de : placer l'adresse haute permettant de slectionner la ligne rafraichir sur le bus d'adresse ; positionner le signal RAS 0 ; et laisser CAS 1.

www.siteduzero.com

Partie 4 : Mmoires

196/378

Rapidement, les constructeurs de mmoire se sont dit qu'il valait mieux incorporer ce circuit dans la barrette de mmoire directement. Le dclenchement du rafraichissement se faisait alors d'une autre manire.

Mmoires FPM et EDO

Les mmoires FPM et EDO fonctionnaient de faon asynchrone, comme vu au dessus. Mais elles ont apportes une premire amlioration compare aux mmoires vues au chapitre prcdent. Sur les anciennes mmoires (avant l'invention des mmoires FPM), chaque fois qu'on voulait changer de case mmoire, on devait prciser chaque fois la ligne et la colonne. Ainsi, si on voulait accder deux donnes places dans des adresses proches et places sur la mme ligne, on devait slectionner la mme ligne deux fois : une par adresse.

Avec la FPM ou l'EDO, on n'avait plus besoin de prciser deux fois la ligne si celle-ci ne changeait pas : on pouvait garder la ligne slectionne durant plusieurs accs.

www.siteduzero.com

Partie 4 : Mmoires

197/378

Et mine de rien, cela donnait un gain de vitesse assez apprciable : il n'est pas rare qu'un programme doive accder des zones de mmoires trs proches voire conscutives (on verra cela quand on parlera du cache : cela s'appelle le principe de localit spatiale).

EDO-RAM
L'EDO-RAM a t invente quelques annes aprs la mmoire FPM. Il n'y a pas de grandes diffrences entre les mmoires EDORAM et les mmoires FPM. Cette mmoire EDO a t dcline en deux versions : la EDO simple, et la Burst EDO. L'EDO simple n'apportait que de faibles amliorations vraiment mineures, aussi je me permet de la passer sous silence. Mais pour la Burst EDO, c'est autre chose. Celle-ci permettait daccder quatre octets conscutifs placs sur la mme ligne bien plus rapidement que ses prdcesseurs. En effet, sur les mmoires EDO et FPM, on devait lire ces 4 octets conscutifs colonnes par colonnes. Il fallait envoyer les adresses basses unes par unes (en rglant CAS comme il faut).

Notre processeur devait donc envoyer l'adresse du premier octet, attendre que ligne et colonnes soient slectionner, lire le

www.siteduzero.com

Partie 4 : Mmoires

198/378

premier octet, passer la colonne suivante, lire le second octet, rechanger la colonne, etc. Chacune de ces tapes prenait un cycle d'horloge (on parle de l'horloge du processeur). Avec les Burst EDO-RAM, on pouvait faire cela bien plus rapidement : pas besoin d'envoyer les adresses basses de chaque colonne unes par unes. On pouvait programmer notre mmoire pour que celle-ci effectue les 4 accs ces 4 octets conscutifs toute seule, sans qu'on aie besoin de placer les adresses basses de chaque colonnes sur le bus et positionner le signal CAS : cela fait pas mal de temps de gagn. Pour cela, il suffit de configurer le contrleur mmoire (qui tait alors plac sur la carte mre ou dans la barrette de mmoire) pour lui ordonner d'effectuer un tel accs, et adresser le premier octet de la suite d'octets qu'on souhaite lire. Les 4 octets voulus taient alors disponibles les uns aprs les autres : il suffisait d'attendre un cycle d'horloge par octet. Les cycles d'horloges ncessaires pour changer de colonne, ncessaires sur les mmoires FPM, taient inutiles lorsqu'on accdait des donnes successives.

Ce genre d'accs mmoire s'appelle un accs en Burst ou en rafale.

SDRAM et mmoires DDR

De nos jours, nous n'utilisons plus de mmoires FPM ou EDO : ces mmoires FPM et EDO ont laisses la place des mmoires plus perfectionnes. Il faut dire que les mmoires FPM et EDO devinrent de plus en plus lentes au fil du temps et qu'il a fallu leur trouver un successeur. Leur successeur s'appelle la mmoire SDRAM. Cette mmoire n'est pas si diffrente des mmoires FPM ou EDO : on y retrouve toujours nos fameux signaux RAS et CAS, les accs en rafale, et les diverses amliorations apportes par les mmoires FPM et EDO. Mais il y a toute de mme une grosse amlioration avec les mmoires SDRAM : ces mmoires ne sont pas asynchrones et sont synchronises avec le bus par une horloge. L'utilisation d'une horloge ne semble pas vraiment changer grand chose au premier abord. Mais en ralit, a change beaucoup de choses. Premirement, les temps mit pour lire ou crire une donne sont fixs et connus une fois pour toutes : le processeur sait qu'entre le moment o il dposera une adresse sur le bus dadresse, et le moment o la mmoire aura termin, il se passera un nombre fini (2, 3, 5, etc) de cycles d'horloge. Il peut donc dposer son adresse sur le bus, et faire ce qu'il veut dans son coin durant quelques cycles en attendant que la mmoire fasse ce qu'on lui demande. Avec les mmoires asynchrones, ce n'tait pas possible : ces mmoires mettait un temps variable pour faire ce qu'on leur demandait. Le processeur ne faisait rien tant que la mmoire n'avait pas rpondue : il excutait ce qu'on appelle des wait state en attendant que la mmoire aie finie.

Bancs mmoires
V ous vous souvenez du chapitre prcdent et plus prcisment de la partie sur les arrangements verticaux de mmoires : et bien sachez que chaque mmoire SDRAM est un arrangement vertical de plusieurs petites sous-mmoires qu'on appelle des bancs mmoires ! Malheureusement, la mmoires SDRAM et ses descendants ne sont pas des mmoires interleaved .

www.siteduzero.com

Partie 4 : Mmoires

199/378

Si vous vous souveznez du chapitre prcdent, vous savez que chacune de ces sous-mmoires, chacun de ces bancs, possde une entre CS qui permet d'activer le banc pour qu'on puisse le lire ou l'crire. Un banc mmoire peut avoir deux tats principaux, imposs grce cette entre CS : l'tat idle : vous aurez beau envoyer une adresse sur ses entres d'adresse ou faire quoique ce soit, le banc ne fera rien et vous ne pourrez ni lire ni crire quoique ce soit ; l'tat actif, dans lequel le banc est utilisable. Accder une donne en mmoire ncessite donc d'activer le banc mmoire (sauf si celui-ci a t activ auparavant), de slectionner la ligne (sauf si celle-ci a dj t active auparavant), et de slectionner une colonne. Quoiqu'il en soit, cette organisation en bancs mmoires permet parfois d'amliorer les performances si on sait rpartir les donnes en mmoire correctement. Il est en effet possible daccder plusieurs bancs en mme temps. En rpartissant nos donnes dans les diffrents bancs correctement, ou en travaillant sur des donnes de trs grandes taille auxquelles ont accde correctement, le gain peut se faire sentir.

Pipelining des requtes mmoires

Le fait que notre mmoire SDRAM soit relie une horloge (ainsi que quelques autres petites modifications) permet dapporter une amlioration assez sympathique compar aux mmoires EDO et FPM. Pour expliquer quelle est cette fameuses amlioration, quelques rappels s'imposent. La slection d'une case mmoire se fait en tapes : on commence par slectionner la ligne (et le banc qui la contient, ces deux slections tant faites en mme temps), puis on slectionne la colonne, et enfin on peut lire ou crire notre donne. Auparavant, on devait attendre qu'une lecture/criture soit finie avant d'en envoyer une nouvelle, ce qui fait que ces tapes sont effectues les unes aprs les autres. On pouvait ventuellement passer outre certaines tapes inutiles : par exemple, il n'y avait pas besoin de slectionner deux fois la mme ligne depuis les mmoires FPM), mais on devait attendre d'avoir lu ou crit notre donne avant de demander la mmoire daccder la ligne/colonne suivante.

Avec les SDRAM, la situation est diffrente. Avec l'utilisation d'une horloge, ce n'est plus vraiment le cas : vu que la slection d'une ligne ou d'une colonne peut prendre plusieurs cycles d'horloge, on peut envoyer une adresse complte avant mme que la lign ou la colonne soit slectionne. Cela permet d'envoyer notre mmoire une demande de lecture ou d'criture (en envoyant une adresse complte et autres bits de commande) sans attendre que les prcdentes soient finies. Pour faire simple, cela signifie qu'on est pas oblig de laisser les signaux RAS et CAS zro pendant qu'on slectionne une ligne ou une colonne : il suffit de placer ceux-ci zro durant un cycle d'horloge pour la mmoire comprenne ce qu'on lui demande et laisse la place une autre demande. Cela s'appelle faire du pipelining.

www.siteduzero.com

Partie 4 : Mmoires

200/378

Comme vous le voyez sur le schma du dessus, une lecture/criture, une slection d'une colonne, ainsi qu'une slection de ligne se font en mme temps, mais dans des circuits diffrents. Cela est rendu possible en utilisant notre Row Buffer et en ajoutant quelques petits registres au bon endroit. Nanmoins, il y a parfois des situations assez particulires pour lesquelles il n'est pas forcment possible d'effectuer des accs en mmoire ainsi. Pour tre plus prcis, sachez que la slection d'une colonne ou d'une ligne peuvent prendre plusieurs cycles d'horloge et ne durent pas le mme temps, ce qui complexifie la chose, sans compter qu'on peut parfois se retrouver avec des tapes supplmentaires.

Ordre des requtes d'accs mmoire

Autre dtail : afin de profiter au mieux de ce pipelining , il est possible qu'en interne, dans la mmoire, les requtes d'accs mmoire ne soient pas traites dans l'ordre dans lequel elles sont reues. Il est ainsi possible que le contrleur mmoire change l'ordre d'accs aux lignes et aux colonnes histoire daccder le plus possible des donnes places sur une mme ligne ou dans des bancs diffrents. Mais cela ne doit avoir aucun effet l'extrieur de la mmoire, et notre mmoire doit maintenir l'illusion que tout se passe normalement. En clair, du point de vue de ce qui se passe sur les bus de donnes ou d'adresse, rien ne change : les requtes de lecture ou d'criture sont envoyes dans le bon ordre, et les rsultats de ces requtes le sont aussi. Simplement, en interne, notre contrleur mmoire ne traitera pas les requtes dans l'ordre et ira lire ou crire dans un ordre diffrent. Pour ce faire, ces requtes sont accumules dans une petite mmoire tampon, et un circuit intgr dans notre contrleur mmoire va alors dcider quelle requte place dans cette mmoire tampon excuter. Ce circuit s'appelle le Scheduler ou l'Arbiter.

Mode Burst
Les mmoires SDRAM possdent aussi un mode Burst, qui a toutefois t amlior compar au Burst des mmoires EDO : il est devenu programmable ! Pour cela, notre mmoire RAM contient un petit registre, le register mode, qui permet de configurer notre mmoire RAM et plus prcisment le fonctionnement de son mode Burst. Il existe ainsi un bit qui permettra de prciser si on veut effectuer des accs normaux (le bit est alors mit 1), ou des accs en Burst (le bit est mit zro). Qui plus est, il existe deux types d'accs en Burst sur les SDRAM : l'accs interleaved , let l'accs squentiel. le mode squentiel est le mode Burst normal : on accde des octets conscutifs les uns aprs les autres. Un bit du register mode permet de slectionner le type de burst voulu. Le mode interleaved le fait dans un ordre lgrement diffrent qu'on ne va pas voir ici (celuici n'apporte rien de vraiment utile). Avec les SDRAM, on peut spcifier le nombre d'octets conscutifs auxquels on veut accder. Sur les mmoires EDO, on devait absolument lire 4 octets uns par uns, sans pouvoir faire plus ou moins, mais les mmoires SDRAM corrigent ce problme. D'autres bits vont ainsi permettre de configurer le nombre de cases mmoires conscutives auquel on doit accder lors d'un accs en Burst. On peut ainsi accder : 1 octet (un peu inutile) par accs ; ou alors 2 octets ; ou 4 ; ou 8 ; ou parcourir toute la ligne de la mmoire sans sarrter. Pour le cas dans lequel on parcourt toute une ligne, on peut dcider d'interrompre l'accs en rafle en positionnant les signaux RAS et CAS 1, ainsi qu'en plaant les bits CS et RW 0.

Burst ordering
Pour les autres cas, l'accs des cases mmoires conscutives doit rpondre certaines contraintes : cela ne marche que dans des blocs dont la taille est celle du bus de donne et qui sont placs des adresses bien prcises. Dans le cas contraire, il y a quelques petites subtilits qui font leur apparition. En fait, tout se passe comme si notre ligne tait dcoupe en blocs ayant la mme taille que le bus de donnes, ce qui donne des blocs de 8 cases mmoires. Dans ce qui va suivre, on va noter les cases mmoires appartenant un de ces blocs 1, 2, 3, 4, 5, 6, 7, 8 et 9. Un accs en mode Burst n'est pas oblig de commencer par lire ou crire le bloc 1 : on peut trs bien commencer par lire ou crire au bloc 3, par exemple. Mais que ce passe-il lorsque l'on veut effectuer un accs en Burst sur 8 cases mmoires ?

www.siteduzero.com

Partie 4 : Mmoires

201/378

Et bien regardons ce qui se passe. On commence par accder la case mmoire numrote 3, puis la 4, la 5 , la 6 et la 7. Il reste encore 3 cases mmoires lire, mais on arrive au bout de notre bloc de 8 cases mmoires. On pourrait imaginer divers scnarios : passer au bloc suivant semble tre le plus logique. Mais ce n'est pas ce qui se passe : l'accs reprend au bloc 1, et on accde aux blocs 1, 2 et 3. En clair : une fois arriv au bout de notre bloc de 8 cases mmoires, on reprend au dbut. Avouez que vous tes surpris.

Mmoires DDR
Quelques annes aprs l'invention des mmoires SDRAM, une nouvelle mmoire a fait son apparition : la mmoire DDR. La diffrence entre une mmoire DDR et une SDRAM est trs faible : la mmoire fonctionne simplement une frquence double de celle du bus mmoires qui la relie au processeur. D'autres diffrences mineures existent entre les SDRAM et les mmoires DDR. Par exemple, la tension d'alimentation des mmoires DDR est plus faible que pour les SDRAM. Ces mmoires DDR ont ts dclines en plusieurs versions : DDR1, DDR2, DDR3, etc. Les diffrences tiennent dans la tension d'alimentation, le nombre de bancs, et la frquence du contrleur mmoire, qui est double compar la version prcdente. Ces mmoires sont standardises, et seuls certaines frquences sont autorises et agres. L'organisme charg de spcifier et de standardiser les mmoires s'appelle le JEDEC : c'est un consortium dont le rle est des standardiser certains composants lctroniques mis sur le march.

DDR1
Les mmoires DDR1 peuvent transmettre des donnes la fois sur les fronts montants de l'horloge (comme pour les SDRAM), mais aussi sur les fronts descendants. Tout se passe comme si ces mmoires fonctionnaient des frquences doubles d'une mmoire SDRAM quivalente. Ainsi, les oprations internes la mmoire sont synchronises entre elles par une horloge dont la frquence est le double de la frquence du bus. En consquence, leur dbit parait doubl compar une mmoire SDRAM de mme frquence : elles peuvent transmettre deux fois plus de donnes dans des conditions favorables. La quantit maximale de donne qui peut tre transmise par seconde par notre mmoire s'appelle son dbit thorique maximal. Sur les mmoires SDRAM, ce dbit thorique maximal se calculait en multipliant la largeur du bus de donnes (le nombre de bits qu'il peut transmettre en une fois) par sa frquence. Par exemple, une mmoire SDRAM fonctionnant 133 Mhz, et utilise en simple channel utilisera un bus de 8 octets, ce qui fera un dbit de octets par seconde, ce qui fait environ du 1 giga-octets par secondes. Pour les mmoires DDR1, il faut multiplier la largeur du bus mmoire par la frquence, et multiplier le tout par deux pour obtenir le dbit maximal thorique. En reprenant notre exemple d'une mmoire DDR fonctionnant 200 Mhz, et utilise en simple channel utilisera un bus de 8 octets, ce qui donnera un dbit de octets par seconde, ce qui fait environ du 2.1 giga-octets par secondes. a peut sembler beaucoup, et c'est normal : c'est beaucoup ! Mais ce qui compte dans les performances d'un ordinateur, c'est surtout le temps d'accs. Certains programmes sont en effet trs sensibles au temps mit pour accder notre mmoire : les jeux vidos, par exemple, on besoin daccder rapidement la mmoire. Une mmoire ayant un temps d'accs faible permettra d'viter au processeur d'attendre les donnes qu'il doit manipuler. Il existe bien certains programmes qui ont besoin daccder de grosses donnes, et pour lesquels avoir un dbit lev est important, mais ceux-ci ne sont pas vraiment une majorit. Il existe quatre types de mmoires DDR officialiss par le JEDEC.

Nom standard Nom des modules Frquence du bus DDR 200 DDR 266 DDR 333 DDR 400 PC-1600 PC-2100 PC-2700 PC-3200 100 Mhz 133 Mhz 166 Mhz 200 Mhz

Dbit 1,6 gibioctets seconde 2,1 gibioctets seconde 2,7 gibioctets seconde 3,2 gibioctets seconde

Tension d'alimentation 2,5 V olts 2,5 V olts 2,5 V olts 2,6 V olts

DDR2
Les mmoires DDR2 poussent le principe de la mmoire DDR1 encore plus loin : les oprations internes la mmoire sont synchronises entre elles par une horloge dont la frquence est le quadruple de la frquence du bus. En consquence, leur dbit

www.siteduzero.com

Partie 4 : Mmoires

202/378

parait quadrupl compar une SDRAM de mme frquence. Pour obtenir leur dbit thorique maximal, il faut multiplier la largeur du bus mmoire par la frquence, et multiplier le tout par quatre pour obtenir le dbit maximal thorique. Avec les mmoires DDR2, 5 types de mmoires sont officialises par le JEDEC.

Nom standard Nom des modules Frquence du bus DDR2 400 DDR2 533 DDR2 667 DDR2 800 DDR2 1066 PC2-3200 PC2-4200 PC2-5300 PC2-6400 PC2-8500 100 Mhz 133 Mhz 166 Mhz 200 Mhz 266 Mhz

Dbit 3,2 gibioctets par seconde 4,2 gibioctets par seconde 5,3 gibioctets par seconde 6,4 gibioctets par seconde 8,5 gibioctets par seconde

Diverses amliorations ont ts apportes sur les mmoires DDR2 : la tension d'alimentation est notamment passe de 2,5/2,6 V olts 1,8 V olts.

DDR3
Les mmoires DDR3 poussent le principe de la mmoire DDR1 et de la DDR2 encore plus loin : les oprations internes la mmoire sont synchronises entre elles par une horloge dont la frquence est 8 fois la frquence du bus. En consquence, leur dbit parait multipli par 8 compar une SDRAM de mme frquence. Pour obtenir leur dbit thorique maximal, il faut multiplier la largeur du bus mmoire par la frquence, et multiplier le tout par huit pour obtenir le dbit maximal thorique. Avec les mmoires DDR3, 6 types de mmoires sont officialises par le JEDEC.

Nom standard Nom des modules Frquence du bus DDR3 800 DDR3 1066 DDR3 1333 DDR3 1600 DDR3 1866 DDR3 2133 PC2-6400 PC2-8500 PC2-10600 PC2-12800 PC2-14900 PC2-17000 100 Mhz 133 Mhz 166 Mhz 200 Mhz 233 Mhz 266 Mhz

Dbit 6,4 gibioctets par seconde 8,5 gibioctets par seconde 10,6 gibioctets par seconde 12,8 gibioctets par seconde 14,9 gibioctets par seconde 17 gibioctets par seconde

Diverses amliorations ont ts apportes sur les mmoires DDR3 : la tension d'alimentation est notamment passe 1,5 V olts.

GDDR
Il existe enfin d'autres types de mmoires DDR : les mmoires GDDR, utilises presque exclusivement sur les cartes graphiques. Contrairement aux autres, celles-ci ne sont pas vraiment standardises par le JEDEC. Il en existe plusieurs types pendant que j'cris ce tutoriel : GDDR, GDDR2, GDDR3, GDDR4, et GDDR5. Mais attention : une mmoire GDDR2 n'a pas grand chose voir avec une mmoire DDR2, par exemple. Il y a des diffrences (sauf pour la GDDR3 qui est identique de la DDR3, mais c'est une exception) et il ne faut pas laisser piger par les noms de ces mmoires, qui ressemblent leur congnres cres sous la forme de barrettes. Gnralement, les mmoires GDDR ont une frquence plus leve que leur congnres utilises en tant que mmoire principale. Par contre, certains de leurs temps d'accs sont beaucoup plus levs et peuvent aller jusqu 10 cycles d'horloge : slectionner une ligne ou une banque prend du temps. L'exception vient du temps de slection d'une colonne, qui est assez faible : 1 cycle dhorloge, gure plus. Cela permet ainsi nos cartes graphiques daccder rapidement des donnes conscutives en mmoire, tandis que les autres types d'accs sont vraiment lents. Qui plus, les mmoires GDDR sont souvent des mmoires multiports, ce qui permet daccder plusieurs cases mmoires (pas forcment conscutives) en lecture ou en criture en une seule fois.

www.siteduzero.com

Partie 4 : Mmoires

203/378

Gnralement, nos cartes graphiques supportent des accs spciaux, en plus des lectures et critures normales (n'impliquant qu'une seule case mmoire). Elles peuvent ainsi : soit lire plusieurs cases mmoires en une seule fois, ce qui s'appelle un accs en gather ; soit crire plusieurs cases mmoires en une seule fois, ce qui s'appelle un accs en scatter. Ces accs mmoires n'existent pas que sur les mmoires GDDR, mais sont aussi disponible sur pas mal de dispositifs ou processeurs qui utilisent des mmoires multiports. De plus, d'autres types d'accs la mmoire peuvent ventuellement exister.

Format DIMM et SO-DIMM

Les barrettes de mmoires SDRAM et DDR sont diffrentes des barrettes de mmoire FPM et EDO. Le format de celles-ci varie suivant la barrette, ainsi que le nombre de broches utilises. Gnralement, les barrettes utilises sur les PC de bureau sont des barrettes au format DIMM : les deux cots de la barrette sont utiliss pour placer les broches diffrentes, ce qui permet d'en mettre deux fois plus.

Le nombre de broches d'une barrette au format DIMM peut varier suivant la barrette utilise, ainsi que le type de mmoire. On peut ainsi avoir entre 168 et 244 broches sur une seule barrette. Je suppose que vous comprendrez le fait que je ne souhaite pas vraiment en faire la liste, comme je l'ai pour les mmoires FPM 30 broches. Mais je vais quand mme vous donner le nombre de broches par barrette en fonction du type de mmoire.

Mmoire SDRAM DDR DDR2

Nombre de broches 168 184 214, 240 ou 244 suivant la barrette ou la carte mre

www.siteduzero.com

Partie 4 : Mmoires
DDR3 204 ou 240 suivant la barrette ou la carte mre

204/378

Les barrettes de mmoire des ordinateurs portables utilisent souvent un autre format de barrette : le SO-DIMM, et parfois un de ses concurrent : le Micro-DIMM.

Mmoire SDRAM DDR1 et DDR2 DDR3

Nombre de broches 144 200 204

Les timings mmoires

www.siteduzero.com

Partie 4 : Mmoires

205/378

Comme je l'ai brivement mentionn plus haut, il faut un certain temps pour slectionner une ligne ou une colonne. Mais dans notre mmoire, il existe d'autres temps de d'attente plus ou moins bien connus, qu'il est parfois important de connaitre. Dans cette partie, je vais vous lister quels sont ces temps de latence. Certains d'entre vous qui sont familiers avec l'overcloking connaissent ces temps d'attente sans le savoir : ces fameux temps d'attente, ou timings mmoires sont en effet trs important pour eux. Aussi nous allons les voir en dtail.

Quelques timings connaitre

La faon de mesurer ces timings varie : sur les mmoires FPM et EDO, on les mesure en units de temps (secondes, millisecondes, micro-secondes, etc), tandis qu'on les mesure en cycles d'horloge sur les mmoires SDRAM. Ainsi, si je vous dit qu'une mmoire DDR de marque xxxx et de numro de srie a un tRAS de 5, cela signifie qu'il faut attendre 5 cycles d'horloge avant que la ligne soit slectionne. Timing Description Le premier de ces timings s'appelle le tRAS : c'est le temps mit pour slectionner une ligne et un banc mmoire. Le second timing s'appelle le tCAS et correspond au temps mit pour slectionner une colonne. Comme le tRAS (et comme tous les autres timings), on le mesure en cycles d'horloge sur les SDRAM et les DDR.

tRAS

tCAS

Il faut prciser une petite chose assez amusante : le CAS est un timings qui est programmable sur les toutes les mmoires SDRAM et DDR. Le fameux mode register vu plus haut contient des bits qui permettent de prciser le tCAS en cycles d'horloge. Nos mmoires RAM sont des mmoires Row Buffer. Pour rappel, cela signifie que pour slectionner une case mmoire lire ou crire, il faut slectionner la ligne lire et la recopier dans une mmoire tampon nomme le Row Buffer, et slectionner la colonne. En fait, j'ai pass un dtail sous silence : dans certains cas, il faut aussi penser vider le Row Buffer. Lorsque l'on souhaite accder deux cases mmoires qui ne sont pas sur la mme ligne, on doit vider le Row Buffer, qui contient encore la ligne prcdente, avant de pouvoir slectionner la ligne et la colonne. Le temps mit pour vider la ligne et la faire revenir son tat initial est appel le tRP.

tRP

tRCD tWTR tCAStoCAS

Vient ensuite le temps mit entre la fin de la slection d'une ligne, et le moment o l'on peut commencer slectionner la colonne, qu'on appelle le tRCD. Une fois qu'on a crit une donne en mmoire, il faut un certain temps avant de pouvoir lancer une lecture qu'on appelle le tWTR.

C'est le temps minimum entre deux slections de deux colonnes diffrentes.

Le SPD
videmment, ces timings ne sont pas les mmes suivant la barrette de mmoire que vous achetez. Certaines mmoires sont ainsi conues pour avoir des timings assez bas et sont donc plus rapides, et surtout : beaucoup plus chres que les autres. Le gain en performances dpend beaucoup du processeur utilis et est assez minime compar au prix de ces barrettes. Les circuits de notre ordinateur chargs de communiquer avec la mmoire (ceux placs soit sur la carte mre, soit dans le processeur), doivent connaitre ces timings et ne pas se tromper : sans a, lordinateur ne fonctionne pas. Pour cela, notre barrette de mmoire contient une petite mmoire ROM qui stocke les diffrents timings d'une faon bien dtermine : cette mmoire s'appelle le Serial Presence Detect , aussi communment appel le SPD. Ce SPD contient non seulement les timings de la mmoire RAM, mais aussi diverses informations, comme le numro de srie de la barrette, sa marque, et diverses informations. Le contenu de ce fameux SPD est standardis par un organisme nomm le JEDEC, qui s'est charg de standardiser le contenu de cette mmoire, ainsi que les frquences, timings, tensions et autres paramtres des mmoires SDRAM et DDR. Cette mmoire ROM est lue au dmarrage de l'ordinateur par certains circuits de notre ordinateur (le fameux BIOS, allez voir ici, pour les curieux : le BIOS, qu'est-ce que c'est ?), afin de pourvoir configurer ce qu'il faut. Pour plus d'informations techniques sur le contenu de cettte mmoire, je conseille la lecture de l'article wikipdia anglais sur ce fameux SPD. Nanmoins, faites attention : le contenu de cette page est assez bourrin.

www.siteduzero.com

Partie 4 : Mmoires

206/378

Quelques exemples d'accs

Ces timings influencent grandement la vitesse laquelle on accde une donne dans la mmoire. Et oui, car suivant la disposition des donnes dans la mmoire, l'accs peut tre plus ou moins rapide. Il existe ainsi quelques possibilits plus ou moins diffrentes, qu'on va vous citer.

Row Buffer Hit

Premier cas : la donne que l'on cherche lire est prsente sur la mme ligne que la donne qui a t accde avant elle. Cela se produit souvent lorsque l'on doit accder des donnes proches les unes des autres en mmoire. Dans ce cas, la ligne entire a t recopie dans le Row Buffer et on n'a pas la slectionner : on doit juste changer de colonne. Ce genre de situation s'appelle un Row Buffer Hit . Le temps ncessaire pour accder notre donne est donc gal au temps ncessaire pour slectionner une colonne (le tCAS auquel il faut ajouter le temps ncessaire entre deux slections de deux colonnes diffrentes (le t-CAS-ToCAS).

Empty Row Buffer

Dans le second cas, on accde une donne qui est situe dans une banque diffrente : c'est un Row Buffer Empty. On est donc oblig de slectionner notre banque ainsi que la ligne (les deux tant faits en mme temps), recopier la ligne dans le Row Buffer, et slectionner la colonne. Le temps d'accs notre donne est donc gal au tRAS auquel on ajoute le tCAS.

Row Buffer Miss

Et enfin, on accde une donne situe dans la mme banque, mais sur une ligne diffrente : c'est un Row Buffer Miss. Et l, c'est une catastrophe ! Dans ce genre de cas, il faut en effet vider le Row Buffer, qui contient la ligne prcdente, en plus de slectionner la ligne et la colonne. On doit donc ajouter le tRP au tRAS et au tCAS pour avoir le temps d'accs total notre donne.

www.siteduzero.com

Partie 4 : Mmoires

207/378

Disques durs et mmoires FLASH

Dans les chapitres prcdents, nous avons vu comment fonctionnaient les mmoires RAM et nous les avons vues en dtail. C'est maintenant au tour des mmoires de masse et des mmoires de stockage d'avoir leur quart d'heure de gloire. Dans ce chapitre, nous allons aborder les mmoires FLASH et le disque dur.

Le disque dur
Et maintenant, j'ai le plaisir de vous annoncer que nous allons tudier la plus clbre des mmoires de masse : j'ai nomm, le disque dur ! Tout le monde connait cette mmoire de masse, utilises par tous comme mmoire de stockage. Non-volatile, pouvant contenir beaucoup de donnes, cette mmoire s'est impose partout o l'on avait besoin d'elle. Ce soir, nous allons entrer dans l'intimit de cette star, voir ce qu'il peut y avoir dedans, et on va se rendre compte qu'un disque dur, c'est quand mme franchement plus simple qu'une mmoire RAM (du moins, en apparence).

C'est fait en quoi ?

Un disque dur est tout de mme quelque chose d'assez rempli, et on trouve beaucoup de composants divers et varis : des plateaux, de llectronique de commande, des moteurs, etc. Et si on ouvrait un peu notre disque dur pour voir ce qu'il y a dedans ?

Plateaux
Ce disque dur est compos de plusieurs plateaux, fabriqus dans un matriau magntique et sur lesquels on inscrit des donnes. Ces plateau sont composs d'une espce de plaque, fabrique dans un matriau peu magntisable, recouvert de deux couches de matriau magntique : une couche sur chaque face. Chacune de ces couches de matriau magntique est dcoupe en petits blocs de donnes, chacun capable de contenir un bit. Sur les anciens disques durs, le stockage d'un bit dans une de ces cellules est trs simple : il suffit d'aimanter la cellule dans une direction pour stocker un 1 et dans l'autre sens pour stocker un 0. Les nouveaux disques durs fonctionnent sur un principe lgrement diffrent. Les disques durs rcents utilisent deux cellules pour stocker un bit. Si ces deux cellules sont aimantes dans le mme sens, c'est un zro, et c'est un 1 sinon. Les disques durs bass sur ce principe permettent de stocker plus de donnes surface gale. Cela vous paraitra surement bizarre, mais il faudra me croire sur parole. Expliquer pourquoi serait assez compliqu, et je ne suis pas sur que parler de Giant Magneto Resistance vous aiderais. Quoiqu'il en soit, la faon dont on aimante ces blocs diffre suivant le disque dur. Certains aimantent ces blocs la verticale, et d'autres l'horizontale. Pour simplifier, on va simplement dire que pour des raisons techniques, les disques durs rcents utilisent l'aimantation verticale. Cela permet de prendre moins de place pour stocker un bit, et donc d'avoir des disques durs contenant plus de donnes pour la mme taille.

www.siteduzero.com

Partie 4 : Mmoires

208/378

Petite remarque pour ceux qui nauraient pas remarqus : les deux faces d'un plateau sont utilises pour stocker des donnes. Ces plateaux entourent un axe central autour duquel les plateaux vont tourner. Plus ces plateaux tournent vite, plus le disque dur sera rapide. Les disquettes fonctionnent sur un principe semblable celui du disque dur, une diffrence prs : il n'y a qu'un seul plateau.

Ttes de lecture/criture
Notre disque dur contient aussi de petits dispositifs mobiles capables de lire ou crire une donne sur le disque dur : les ttes de lecture criture. Chacune de ces ttes de lecture-criture est un dispositif assez simple. Il s'agit d'un espce de bras mcanique dans lequel passe un fil lectrique. Ce fil lectrique affleure lgrement au bout de ce bras en formant une espce d'hlice, formant un petit lectroaimant qui va servir lire ou crire sur le plateau. Lorsque l'on veut crire, il suffira d'envoyer un courant lectrique dans le fil de notre tte de lecture : cela crera un champ magntique autour de llectroaimant qui est au bout du bras, ce qui permettra d'aimanter le plateau. Pour lire, il suffira d'approcher la tte de la cellule lire : le champ magntique de la cellule aimant va alors crer une tension dans notre lectroaimant, qui se propagera dans le fil et qu'on pourra interprter comme un zro (tension normale) ou un 1 (tension plus leve que prvu). Ces ttes de lecture se dplacent au-dessus des plateaux, et sont entraines par un moteur capable de les faire tourner autour des plateaux : cela permet de dplacer les ttes de faon les placer au dessus des donnes lire ou crire. A larrt, les ttes de lecture sont ranges bien sagement dans un emplacement bien particulier : pas question de les arrter sur place ! Si une tte de lecture-criture touche la couche magntique, alors l'endroit sur lequel la tte de lecture-criture a atterri est dfinitivement endommag. On trouve entre une et deux ttes de lecture-criture pour chaque plateau : gnralement, on trouve une tte de lecture sur chaque face, pour pouvoir lire et crire sur les deux faces d'un plateau. Pour s'y retrouver et choisir quelle tte de lecture-criture utiliser, celles-ci sont numrotes par un numro unique qui permet de les identifier.

lectronique de commande
Positionner nos ttes de lecture juste au-dessus de la cellule mmoire lire ou crire ne se fait pas comme par magie. Pour cela, il faut commander les moteurs qui entrainent les plateaux et les ttes de lecture de faon ce que les ttes se positionnent correctement. Pour cela, on trouve divers circuits lectroniques qui sont chargs de calculer quelles sont les tensions envoyer aux moteurs de faon faire acclrer ou dclrer nos ttes correctement. Notre disque dur contient aussi des circuits chargs de grer ou de lire la tension prsente dans le fil, pour effectuer des lectures ou des critures. Et enfin, on trouve des circuits chargs de communiquer avec le bus ils reoivent les ordres et les donnes en provenance du bus, et peuvent envoyer une

www.siteduzero.com

Partie 4 : Mmoires
donne lue depuis le disque dur sur le bus. L'ensemble forme llectronique de commande du disque dur.

209/378

Adressage d'un disque dur

Notre plateau est donc capable de stocker des donnes sans aucun problmes. Reste savoir comment slectionner les bits et les octets inscrits sur notre plateau. Et on va voir que ce n'est pas une mince affaire : les concepteurs de disques durs ont organis l'intrieur de notre disque dur suivant un schma bien tabli, plus ou moins ncessaire pour retrouver nos donnes sur celui-ci. On va donc devoir apprendre comment nos donnes sont organises en pistes et secteurs sur le disque dur pour pouvoir comprendre comment sont adresses nos donnes.

Pistes
Ces bits sont tous regroups sur une face de notre plateau en cercles concentriques qu'on nomme des pistes. Toutes ces pistes contiennent le mme nombre de bits ! Cela peut paraitre bizarre, mais il y a une explication cela. Au bord du disque, la taille d'une piste est cense tre plus grande qu'au centre : on devrait pouvoir y stocker plus de bits. Sauf que notre plateau tourne, et que la vitesse des bords est plus grande la priphrie qu'au centre. Vu que lire ou crire prend toujours le mme temps, on est oblig de stocker nos bits sur une surface plus grande pour viter de changer de bits en plein milieu d'une lecture/criture parce que le plateau tourne trop vite. Ces pistes sont toutes numrots dans une face d'un plateau : chaque face contenant pistes, chaque piste aura un numro compris entre et . Mais attention : deux pistes peuvent avoir le mme nombre si celles-ci sont sur des faces ou des plateaux diffrents. Ces pistes ayant le mme numro seront alors la verticale les unes des autres : elles formeront ce qu'on appelle un cylindre.

Secteurs
Ces pistes sont dcoupes en blocs de taille fixe qu'on appelle des secteurs. Quand on veut lire ou crire sur notre disque dur, on est oblig de lire ou d'crire l'intgralit de notre secteur. Pour simplifier le travail de l'lectronique du disque dur, on prfre utiliser des paquets ayant une taille de la forme . Sur les disques durs actuels, un secteur a une taille de 512 octets, soit 4 096 bits. Ces secteurs contiennent des donnes, mais pas seulement. Le dbut de chaque secteur est identifi par un prambule, qui permet de dlimiter le secteur sur une piste. Ce prambule est suivi des donnes du secteur proprement dit, puis de bits de correction d'erreur, qui servent dtecter et corriger d'ventuelles corruptions de donnes du secteur.

Toutes les pistes contiennent le mme nombre de secteurs, et chaque secteur d'une piste est numrot : cela permet de retrouver un secteur en particulier dans une piste. Ainsi, si une piste possde secteurs, chacun de ces secteur est numrot de . Mais attention : deux secteurs peuvent avoir le mme numro si ceux-ci sont sur des plateaux ou sur des pistes distinctes.

www.siteduzero.com

Partie 4 : Mmoires

210/378

Sur ce schma, le machin rouge reprsente tous les secteurs ayant le mme numro sur le mme plateau, et sur des pistes diffrentes.

Adressage CHS
Pour localiser un secteur sur un disque dur, il suffit de prciser le plateau, la face de celui-ci, le numro de la piste (en fait, c'est le numro du cylindre, mais passons) et le numro du secteur. Ainsi, chaque secteur possde une adresse compose des numros de la tte de lecture (qui sert identifier la plateau et la bonne face), de piste et de secteur vus plus haut : c'est ce qu'on appelle l'adresse CHS. Historiquement, nos ordinateurs utilisaient 10 bits pour coder le numro de piste, 8 bits pour la tte de lecture (parfois 4) et 6 bits pour le numro de secteur : nos adresse CHS taient limites 24 bits. Cela limitait la taille maximale possible du disque dur environ 500 mbi-octets. Pour contrer cette limite, on a invent diverses astuces. Une de ces astuces consiste transformer les coordonnes CHS codes sur 24 bits (10 bits pour la piste + 8 pour le plateau + 6 pour le numro de secteur) en coordonnes de 28 bits.

Adressage LBA
Avec la progression de la taille des disques durs, on a invent l'adressage LBA. Celui-ci numrote simplement chaque secteur du disque dur par un nombre, sans se proccuper de son numro de tte, de cylindre ou de secteur. Il est donc identifi par un simple nombre : l'adresse LBA, qui peut tre traduite en une adresse CHS code sur suffisamment de bits pour pouvoir adresser toutes les cellules de notre disque dur.

Requtes d'accs au disque dur

La communication avec le disque dur se fait via un bus particulier qui dpend fortement de votre ordinateur : ce peut tre un bus P-ATA, S-ATA, SCSI, etc. Quoiqu'il en soit, ce que notre processeur va envoyer sur ces bus, ce ne sont rien d'autre que des ordres, des requtes du style : "va lire telle adresse", ou encore "va crire telle adresse". Ces requtes sont envoyes au disque dur et sont gres par llectronique de commande du disque dur. Sur les disques durs anciens, on devait attendre qu'une requte soit termine avant d'en e,voyer une autre. Vu que l disque dur est assez lent, le temps entre l'envoi de deux requtes tait assez long. Pour limiter la casse, les disques durs "rcents" permettent d'envoyer de nouvelles requtes, mme si le disque dur est en train d'en traiter une autre. Ces requtes anticipes sont alors mises en attente et commenceront tre traite quand le disque dur en aura termin avec la requte en cours. Pour cela, nos disques durs incorporent une sorte de mmoire dans laquelle on va stocker les requtes en attente dans l'ordre d'arrive. Cette Request Queue va aussi accumuler les requtes anticipes, qui seront traites dans leur ordre d'arrive. Bien sur, cette Request Queue a une taille limite : si jamais elle est pleine, le disque dur enverra un signal spcial au processeur, afin de dire celui-ci darrter d'envoyer des requtes.

www.siteduzero.com

Partie 4 : Mmoires

211/378

Les disques durs S-ATA rcents dots de la bonne carte mre permettent de faire quelques optimisations sur le contenu de cette Request Queue. Ils peuvent changer l'ordre de traitement des requtes afin de diminuer la distance que la tte de lecture doit parcourir pour trouver la donne. Llectronique de commande peut ainsi changer l'ordre de traitement des requtes pour accder le plus possible des donnes proches. Au lieu de faire sans cesse des aller et retours, notre disque dur peut tenter daccder de prfrence des donnes proches dans un ordre diffrent. Cela s'appelle du Native Command And Queing. Enfin, dernire optimisation, nos disques durs incorporent une sorte de mmoire cache qui permet de diminuer le temps d'accs des donnes accdes rcemment. Ainsi, toute donne lue (ou crite) est place dans cette mmoire tampon. Si le disque dur veut relire cette donne dans un avenir proche, le disque dur n'a pas aller relire cette donne sur le disque dur : pas besoin de dplacer des tte de lecture et d'attendre qu'elles se mettent en place, la donne est immdiatement disponible dans cette mmoire cache ultra-rapide.

Mmoires FLASH
Les mmoires FLASH sont utilises comme mmoires de masse un peu partout de nos jours : SSD, cls USB, BIOS, et dans des tas d'autres composants dont vous ne souponnez mme pas l'existence. Ce sont des mmoires EEPROM, contrairement ce que certains croient. En effet, pas mal de personnes croient tort que certaines mmoires FLASH sont des mmoires RAM, ou du moins utilisent leur technologie. C'est faux, mme si certaines caractristiques de certaines de ces mmoires FLASH peuvent faire croire le contraire.

Cellule mmoire de FLASH

Mais avec quoi sont fabrique ces mmoires FLASH ? On sait comment sont fabriques nos bonnes vielles SRAM et DRAM, mais qu'en est-il de ces FLASH ?

Elles sont fabriques avec des transistors. Plus prcisment, on utilise un seul transistor pour fabriquer une cellule mmoire de FLASH. Mais ce transistor est un peu particulier. Il ne s'agit pas d'un bon vieux transistor MOSFET comme on en a vu au chapitre 2 : il s'agit d'un floating gate transistor qui possde deux armatures et deux couches d'isolant !

Comme vous le voyez sur ce schma, on retrouve bien deux armatures en mtal. C'est dans la seconde armature qu'on stockera notre bit : il suffira de la remplir dlectrons pour stocker un 1, et la vider pour stocker un 0. Ce remplissage est assez compliqu et parler d'effet tunnel ou des divers phnomnes physiques qui permettent d'crire dans ces mmoires FLASH serait surement un peu compliqu, aussi je me permet de passer tout cela sous silence. Sachez juste que ce remplissage ou vidage se fait en faisant passer des lectrons entre la grille et le drain, et en plaant une tension sur la grille : les lectrons passeront alors dans la grille en passant travers l'isolant.

www.siteduzero.com

Partie 4 : Mmoires

212/378

Mmoires FLASH MLC

Il existe deux autres types de mmoire FLASH : les Single Level Cell , ou SLC ; et les Multi Level Cell ou MLC. S'il n'y a pas grand chose dire sur les mmoires SLC, nos mmoire FLASH MLC sont diffrentes de tout ce qu'on a pu voir jusqu' prsent. V ous vous souvenez que, dans un ordinateur, nos bits sont reprsents sous la forme d'une tension avec un intervalle pour le 1, et un autre pour le zro ?

Dans nos mmoires FLASH SLC, c'est la mme chose, cette tension sera simplement celle mesurable sur notre seconde armature : elle dpendra du remplissage ou de la vacuit de l'armature.

Nos mmoires SLC fonctionnent ainsi. Pour les mmoires FLASH MLC, c'est la mme chose un dtail prt : elles utilisent plus de deux intervalles, et peuvent ainsi stocker des informations code en base 3 ou 4 avec une seule tension ! Une simple cellule mmoire peut ainsi stocker plusieurs bits.

www.siteduzero.com

Partie 4 : Mmoires

213/378

Ainsi, on peut utiliser une seule cellule mmoire MLC pour stocker plusieurs bits au lieu de plusieurs cellules mmoires SLC : a prend beaucoup moins de place !

Les mmoires FLASH ne sont pas des RAM !

Personnellement, j'ai souvent entendu dire que les mmoires FLASH taient des mmoires RAM, ou encore qu'elles utilisaient leur technologie, et autres affirmations gratuites. Ce genre d'ides reues est assez rpandue, et quelques prcisions simposent : non, les mmoires FLASH n'ont rien voir avec les mmoires RAM, et on va expliquer pourquoi. La diffrence tient dans la faon dont les mmoires FLASH vont crire leurs donnes.

Programmation versus effacement

Une mmoire FLASH est divise en blocs dont la taille varie entre 16 et 512 kibioctets. Notre mmoire FLASH est intgralement remplie de 1 par dfaut. Mettre un bit 0 est facile sur notre mmoire FLASH, et ne pose pas de problme. A cot, on trouve l'opration inverse : l'effacement qui consiste remettre ce bit 1. Programmer un bit individuel est parfaitement possible au niveau des circuits de notre mmoire, ce qui fait qu'on peut accder un octet en criture si on met certains ou la totalit de ses bits zro, sans mettre aucun bit 1. Par contre, remettre un bit individuel 1 est impossible : on est alors oblig de rcrire tout le bloc ! Pour ce genre de raisons, on considre que les FLASH sont considres comme des mmoires EEPROM : on ne peut pas toujours accder un octet en criture sans devoir reprogrammer un gros morceau de la mmoire. Sur une mmoire RAM, on aurait pu modifier notre octet et seulement celui-ci : on est oblig de reprogrammer tout un bloc de mmoire FLASH.

Une RAM interne

Cette reprogrammation pose un gros problme : comment reprogrammer un bloc entier sans perdre son contenu ? Pour cela, le contrleur du disque dur va utiliser une mmoire RAM interne notre mmoire FLASH, afin d'viter tout problme. V comment se droule la reprogrammation d'un bloc complet de mmoire FLASH : oici les circuits de la mmoire FLASH vont alors lire toute la cellule qui contient la donne modifier et stocker son contenu dans une petite mmoire RAM interne ; la donne va tre modifie dans cette mmoire RAM interne ; les circuits de la FLASH vont ensuite effacer totalement la cellule de mmoire EEPROM avant de la reprogrammer avec le

www.siteduzero.com

Partie 4 : Mmoires
contenu de la RAM interne, qui contient la donne modifie.

214/378

FLASH NAND et NOR

Nanmoins, ce que je viens de dire plus haut est nuancer quelque peu. Il existe deux types de mmoires FLASH qui diffrent par la faon dont sont relies les cellules mmoires : les FLASH NOR et les FLASH NAND ; et ces deux types accdent diffremment leurs donnes.

FLASH NOR
Ces mmoires tirent leur nom de la faon dont sont cbles leurs cellules mmoires, qui ressemble fortement au cblage d'une porte NOR constitue de transistors CMOS. Elles sont assez rapides, mais ont une mauvaise densit : leurs cellules mmoires prennent de la place et on ne peut pas en mettre beaucoup sur surface fixe. Dans les mmoires FLASH de type NOR, chacun des octets prsents dans un bloc possde une adresse. La reprogrammation ou la lecture ne posent pas vraiment de problmes : elles peuvent se faire octets par octets. Par contre, l'effacement se fait par blocs, sans qu'on ne puisse y faire quoique ce soit. Comme je l'ai dit, chaque bloc est adressable, ce qui fait que les FLASH NOR ressemble beaucoup aux mmoires EEPROM ou RAM courantes.

FLASH NAND
Ces mmoires tirent leur nom de la faon dont sont cbles leurs cellules mmoires, qui ressemble fortement au cblage d'une porte NAND constitue de transistors CMOS. Contrairement aux FLASH NOR, ces FLASH NAND peuvent avoir une grande capacit sans problme. Mais par contre, l'accs est plus lent et ne se fait pas octets par octets pour le lecture ou la programmation. Pour les FLASH NAND, lecture, programmation, et effacement se font sur des morceaux de blocs ou des blocs entiers. Il faut savoir que dans ces mmoires FLASH NAND, les blocs sont eux-mmes dcoups en pages, d'environ 4 kibioctets, qu'on peut lire ou programmer individuellement. Mais l'effacement se fait toujours bloc par blocs. L'accs ces pages ou blocs n'est pas direct comme pour une FLASH NOR : tout se fait par l'intermdiaire d'une mmoire RAM interne (c'est la RAM interne vue plus haut, qui sert entre autres pour l'effacement). Toute donne lire ou crire est ainsi copie dans cette RAM avant d'tre copie sur le bus (lecture) ou dans un bloc/page (criture).

Les SSD
Les disques durs magntiques sont encore des composants trs utiliss dans nos ordinateurs. Mais cela risque de changer l'avenir. De nouveaux types de disques durs ont fait leur apparition il y a de cela quelques annes, et ceux-ci pourraient bien remplacer nos bons vieux disques durs magntiques. Ces SSD ne sont pas fabriqus avec des dispositifs magntiques comme nos bons vieux disques durs, mais sont justement cres avec de la mmoire FLASH. Ce sont les Solid State Drive, plus connus sous le nom de SSD. Pourquoi avoir invent ces SSD, alors que nos disques durs ne semblent pas avoir de problmes ?

En fait, ces SSD ont plusieurs avantages qui pourraient leur permettre de prendre le pas sur leurs concurrents magntiques. Ceux-ci sont des dispositifs purement lectroniques : il n'y a pas de pice mcanique en mouvement, susceptible de se casser en rendant notre disque dur inutilisable. Faites tomber votre disque dur par terre, et vous pouvez tre certain que la tte de lecture-criture sera morte. Ce qui fait que ces SSD sont plus fiables que les disques durs. Autre avantage : leur temps d'accs. Celui-ci est bien plus faible que le temps d'accs d'un disque dur. Avec un SSD, on n'a pas besoin de dplacer des pices mcaniques, positionner la tte de lecture, etc : on accde notre donne directement, ce qui est plus rapide. Et enfin, dernier avantage : ils consomment beaucoup moins d'nergie.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

215/378

Partie 5 : Priphriques, bus, et entres-sorties

Un processeur et une mmoire seuls ne servent pas grand chose. Un programme, quel qu'il soit, doit pouvoir se rendre utile, et il faut bien que celui-ci puisse finir par communiquer avec lextrieur de l'ordinateur. Pour cela, on a invent de nombreux priphriques, rattachs notre ordinateur, ainsi que des bus qui vont permettre notre processeur et notre mmoire d'changer avec eux. Dans ce chapitre, nous allons voir un peu comment nos priphriques vont communiquer avec notre processeur.

Bus, cartes mres, chipsets et Front Side Bus

Dans notre ordinateur, tous les composants (mmoire, processeurs...), sont fabriqus sparment. Pour relier tout ces composants ensemble, on place ces composants sur un gros circuit imprim nomm la carte mre sur laquelle on trouve un ou plusieurs bus pour relier le tout. En somme, une carte mre n'est donc rien qu'un gros tas de fils relis des connecteurs sur lesquels on va brancher des composants. Enfin presque, il y a des trucs en plus dessus : le BIOS, de quoi crer les signaux d'horloge servant cadencer les priphriques, etc. Mais ces composants ne communiquent pas que par un seul bus. Il existe un bus pour communiquer avec le disque dur, un bus pour la carte graphique, un pour le processeur, un pour la mmoire, etc. De ce fait, de nombreux bus ont ts invents et un ordinateur "lambda", avec sa souris, son cran et son unit centrale contient un nombre impressionnant de bus. Jugez plutt : le SMBUS, un bus invent par Intel en 1985 qui est utilis pour communiquer avec les ventilateurs, les sondes de tempratures et les sondes de tension prsentes un peu partout dans notre ordinateur : la vitesse des ventilateurs ne se rgle pas toute seule comme par magie ; les bus USB, que vous connaissez tous et pour lequel je ne dirais rien sinon qu'il existe un tutoriel sur ce bus sur le Siteduzro : Comprendre l'USB et bricoler un priphrique; le bus PCI, utilis pour le cartes sons et qui servait autrefois communiquer avec les cartes graphiques ; le bus AGP, autrefois utilis pour les cartes graphiques ; le bus PCI-Express, utilis pour communiquer avec des cartes graphiques ou des cartes sons ; le bus P-ATA, reli au disque dur ; le bus S-ATA et ses variantes : eSATA, eSATAp, ATAoE , utilis pour communiquer avec le disque dur ; le bus Low Pin Count, qui permet d'accder au clavier, aux souris, au lecteur de disquette, et aux ports parallles et sries ; le bus ISA et son cousin le bus EISA, autrefois utilis pour des cartes d'extension ; l'Intel QuickPath Interconnect et l'HyperTransport, qui relient les processeurs rcents au reste de l'ordinateur ; le FireWire (1394) ; le bus SCSI et ses variantes (SCSI Parallel, Serial Attached SCSI, iSCSI) qui permettent de communiquer avec des disque durs ; le bus MIDI, une vritable antiquit oublie de tous qui servaient pour les cartes sons ; notre fameux RS-232 utilis dans nos ports srie ; et enfin le bus IEEE-1284 utilis pour le port parallle. Et encore, je crois que j'en ai oubli un ou deux ! De plus, chacun de ces bus est souvent mis jour, et de nouvelles versions apparaissent, qui sont plus rapides, moins nergivores, etc. Par exemple, le bus PCI est dclin en 7 versions, la dernire en date datant de 2002. Autre exemple : l'USB, dclin en 4 versions (1.0, 1.1, 2.0, 3.0). Tous ces bus sont trs diffrents les uns des autres, et ont des caractristiques trs diffrentes. Pourtant, premire vue, rien de plus simple qu'un bus : c'est juste un tas de fils. Mais alors, qu'est-ce qui peut bien les diffrencier ?

Un bus, c'est rien qu'un tas de fils...

Il suffit de demander : Caractristique Dfinition C'est le nombre de bits qui peuvent tre transmis simultanment sur notre bus. C'est le nombre de bits que notre bus peut transmettre par seconde. Plus celui-ci est lev, plus le bus est

Sa largeur Son dbit

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

216/378

binaire Sa latence Son caractre Half Duplex, Full duplex ou Simplex Son caractre synchrone ou asynchrone

rapide. C'est le temps d'attente que met une donne tre transfre sur le bus. Ce temps de latence dpend de la frquence du bus et d'autres paramtrs. Plus il est bas, plus le bus est rapide.

V ous verrez ce que a signifie dans la suite du chapitre.

Certains bus possdent un fil sur lequel circule un signal d'horloge permettant de synchroniser les diffrents composants : ce sont les bus synchrones. D'autres se passent de signal d'horloge, et synchronisent leurs composant par dautres mthodes.

Le protocole d'un bus dfinit comment celui est gr. Ce protocole dfinit quand et comment les donnes doivent tre envoyes sur le bus.

Son protocole

Mais a ne se limite pas a : en effet, certains bus ont besoin de mcanismes assez sophistiqus pour fonctionner correctement. Pour donner un exemple, on peut citer le cas dans lequel plusieurs composants lectroniques doivent transmettre leurs donnes sur un seul et unique bus. Le protocole doit alors intgrer des mcanismes permettant aux composants de ne pas se marcher sur les pieds en monopolisant le bus ou en crivant des donnes en mme temps. Ceux-ci varient normment suivant le bus :

Son bus de commande

certains se contentant d'un seul bit ; d'autres ont besoin de beaucoup de bits pour grer pleins de paramtres diffrents ; et d'autres s'en passent. Gnralement, la complexit du bus de commande est fortement influenc par le protocole utilis pour le bus.

Et encore, on vous a pargn avec cette liste assez courte ! Suivant l'utilisation d'un bus, on choisit chacune de ces caractristiques en fonction des besoins. Par exemple, pour relier un clavier notre ordinateur, on l'utilisera pas le mme bus que pour relier une carte graphique sur la carte mre. La carte graphique aura besoin de transfrer beaucoup de donnes par seconde et aura besoin d'un bus rapide, contrairement au clavier qui aura d'autres besoins. Il y a peu dire sur la frquence, le dbit binaire et la latence d'un bus, sinon que la latence doit tre la plus faible possible et la frquence et le dbit binaire levs si on veut gagner en rapidit. Par contre, il faut prciser certaines choses importantes sur la largueur du bus.

Bus srie et parallles

Il existe des bus qui ne peuvent changer qu'un seul bit la fois. On appelle ce genre de bus un bus srie. D'autres bus peuvent changer plusieurs bits en mme temps et sont appels bus parallles. Dans nos ordinateurs, les bus qui relient le processeur la mmoire (ou la mmoire aux priphriques) sont des bus parallles. Ils sont gnralement diviss en trois sous-bus : le bus d'adresse par lequel les adresses transitent le bus de donne par lequel les donnes s'changent entre composants. le bus de commande, qui contient au moins le bit R/W et qui gre les changes d'informations sur le bus.

Diffrence de vitesse entre bus srie et parallle

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

217/378

Vu qu'ils peuvent transfrer plusieurs bits en une fois, les bus parallles sont bien plus rapides que les bus sries, non ?

a dpend de la dure durant laquelle un bus ne peut pas changer d'tat. En effet, un bus doit toujours attendre un certain moment avant d'envoyer la donne suivante. La donne prsente sur le bus va y rester durant un moment, et sera mise jour aprs un certain temps. Pour un bus srie, il s'agit du temps d'envoi d'un bit, par exemple. Pour les bus parallle, c'est le temps que la donne envoye restera sur ses fils avant d'tre mise jour par une nouvelle donne. Pour information, si le contenu d'un bus parallle d'une largeur de bits est mis jour fois par secondes, alors son dbit binaire (le nombre de bits transmis par seconde) est de . On pourrait alors croire que les bus parallles sont plus rapides, mais ce n'est pas forcment vrai. En effet, il est difficile pour un bus parallle de mettre jour son contenu et d'envoyer la donne suivante rapidement. Un bus srie n'a pas ce mal : la dure de transmission d'un bit est trs faible. Pourquoi ?

V l'explication : Lorsque la tension l'intrieur du fil varie (quand le fil passe de 0 1 ou inversement), le fil va mettre des oici ondes lectromagntiques qui vont aller perturber la tension dans les fils d' cot. Il faut donc attendre que la perturbation lectromagntique se soit attnue pour pouvoir lire le bit sans se tromper. Et ces temps d'attente limitent le nombre de changement d'tat du bus effectus par seconde ! D'o un nombre de donnes envoy par seconde plus faible. Autre problme : les fils d'un bus parallle ne sont pas tous identiques lectriquement : il n'est pas rare que la rsistance des fils ou d'autres proprits lectriques changent trs lgrement d'un fil l'autre. Consquence : un bit va se propager d'un bout l'autre d'un fil des vitesse qui varient suivant le fil. Et on est oblig de se caler sur la vitesse la plus basse pour viter des problmes techniques la rception. Un bus srie n'a pas ce genre de problmes et peut donc envoyer un grand nombre de bits trs rapidement. Cela peut compenser le fait quun bus srie ne peut envoyer qu'un bit la fois assez facilement.

Dans nos PC
Je suis certains que vous connaissez l'USB, au moins de nom. Mais savez-vous ce que c'est ? Il s'agit d'une norme, qui dfinit un bus, le bus USB. Ce bus est un bus srie, un peu particulier. Notre bus USB dfinit 4 fils, nots 1, 2, 3 et 4 dans le schma suivant.

Numro du fil 1 2 3 4

Fonction

Contenu

Couleur

Tension d'alimentation Tension gale +5 volts Rouge D+ DMasse Donne Donne 0 volts Vert Blanc Noir

De ce qu'on voit de ce bus, c'est qu'il possde une masse et un fil d'alimentation, ce qui permet d'alimenter le priphrique qui est connect sur le port USB. Ben oui, votre souris USB, elle nest pas relie au 220 volts, et doit bien tre alimente en lectricit quelque part ! On pourrait croire qu'un bus ne pouvant transmettre qu'un seul bit la fois ne contient qu'un seul fil pour transmettre les donne, mais ce bus en est un parfait contre-exemple : celui-ci possde 2 fils pour transmettre le bit en question. Le truc, c'est que notre donne n'est pas code en utilisant un codage NRZ. On ne va pas rentrer dans les raisons qui ont

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

218/378

pousses les crateurs de l'USB a faire ce choix. Tout ce qu'il faut savoir, c'est que notre bus USB transmet un 1 en mettant une tension de -5 volts sur la broche D- (la broche D+ contient alors un joli petit zro volt), et transmet un 0 en mettant une tension de +5 volts sur la broche D- (la broche D- contient alors un joli petit zro volt). Autre exemple de bus srie que vous connaissez surement : le bus S-ATA. Celui-ci sert communiquer avec nos disques durs. Il a t invent pour remplacer le bus P-ATA, un bus plus ancien, servant lui aussi communiquer avec nos disques durs, mais qui avait un dfaut : c'tait un bus parallle.

Simplex, Half duplex ou Full duplex

Un autre paramtre important concernant nos bus est le sens des transferts de donne. Pour expliquer cela, on va devoir clarifier quelques notions assez simples. V ous ts prt ? On commence ! Un composant qui envoie une donne sur le bus est appel un metteur Ceux qui se contentent de recevoir une donne sur le bus sont appels rcepteur.

Simplex
Sur un bus simplex, les informations ne vont que dans un sens. On a donc deux cas : Soit les informations sont transmises d'un priphrique vers un autre composant (par exemple le processeur). L'autre sens est interdit ! Soit les informations sont transmises d'un composant vers le priphrique. L'autre sens est interdit ! Il n'y a qu'un seul des composants qui puisse tre metteur et l'autre reste tout jamais rcepteur.

Half-duplex
Sur un bus half-duplex, Il est possible d'tre metteur ou rcepteur, suivant la situation. Par contre, impossible d'tre la fois metteur et rcepteur.

Full-duplex
Un bus full duplex permet d'tre la fois rcepteur et metteur. L'astuce des bus full duplex est simple : il suffit de regrouper deux bus simplex ensemble ! Il y a un bus pour l'mission et un pour la rception. Ces bus sont donc plus rapides, vu qu'on peut mettre et recevoir des donnes en mme temps, mais ncessitent plus de fils cbler, ce qui peut tre un dsavantage.

Bus synchrones et asynchrones

Bus synchrones
Certains bus sont synchroniss sur un signal d'horloge : ce sont les bus synchrones. Sur de tels bus, un fil est spcialement ddi l'horloge, cette fameuse tension priodique vue il y a quelques chapitres. Quand nos composants, ils sont relis au bus via des bascules, afin de synchroniser les lectures/critures des composants sur le bus. Avec ce genre de bus, le temps de transmission d'une donne sur le bu est fix une fois pour toute. Ainsi, le composant qui cherche effectuer une lecture ou un criture sait combien de cycles d'horloge sa demande va prendre. Exemple avec une lecture

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

219/378

L'avantage de ces bus est que le temps que va mettre un rcepteur ou un metteur pour faire ce qu'on lui demande est fix une bonne fois pour toute. Par contre, ces bus posent des problmes quand on augmente la frquence ou la longueur des fils du bus : notre signal d'horloge va mettre un certain temps pour se propager travers son fil, ce qui induit un lger dcalage entre les composants. Si ce dcalage devient trop grand, nos composants vont rapidement se dsynchroniser : il faut que ce dcalage soit trs petit compar la priode de l'horloge. Plus on augmente la longueur des fils, plus l'horloge mettra de temps se propager d'un bout l'autre du fil qui lui est ddi, et plus ces dcalages deviendront ennuyeux. Et la frquence pose un problme similaire : plus on augmente la frquence, plus cette priode diminue compar au temps de propagation de l'horloge dans le fil, et plus ces dcalages risquent de poser problme. Mine de rien, ce genre de phnomnes fait qu'il est trs difficile d'atteindre des frquences de plusieurs centaines gigahertz sur les processeurs actuels : le fil d'horloge est trop long pour que ces dcalages soient ngligeables.

Double Data Rate

Sur certains bus, le contenu du bus n'est pas mit jour chaque front montant, ou chaque front descendant, mais au deux : fronts montants et descendants. De tels bus sont appels des bus double data rate. Le but ? Cela permet de transfrer deux donnes sur le bus (une chaque front) en un seul cycle d'horloge : le dbit binaire est doubl sans toucher la frquence du bus. Pour information, les bus mmoires qui relient des mmoires DDR1 au processeur sont de ce type : ils peuvent rellement transfrer deux donnes par cycle d'horloge.

Bus asynchrones
Et maintenant, j'ai une rvlation vous faire : certains bus se passent compltement de signal d'horloge. Ces bus ont un protocole conu spcialement pour faire communiquer deux priphriques/composants sans les synchroniser sur une horloge. Pour cela, ces bus permettent deux composants de se synchroniser grce des fils spcialiss du bus de commande, qui transmettent des bits particuliers. Gnralement, ce protocole utilise deux fils supplmentaires : REQ et ACK.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

220/378

Lorsqu'un composant veut envoyer une information sur le bus un autre composant, celui-ci place le fil REQ 1, afin de dire au rcepteur : "attention, j'ai besoin que tu me fasse quelque chose". Les autres composants vont alors ragir et lire le contenu du bus. Le composant qui la donne ou l'ordre est destin va alors ragir et va faire ce qu'on lui a demand (les autres composants se rendorment et se dconnectent du bus). Une fois qu'il a termin, celui-ci va alors positionner le fil ACK 1 histoire de dire : j'ai termin, je libre le bus ! Exemple avec une lecture

Ces bus sont trs adapts pour transmettre des informations sur de longues distances (plusieurs centimtres ou plus), ou pour communiquer simplement avec des composants au besoin, sans avoir les synchroniser en permanence. Sans compter qu'ils sont parfois plus rapides : on n'a pas attendre un dlai fix avant de recevoir le rsultat d'une lecture/criture. Ds que la demande est effectue, on libre le bus. Sur un bus synchrone, on aurait eu besoin d'attendre la fin du dlai fix par le protocole du bus, mme si le rcepteur/metteur a fait ce qu'il lui tait demand.

Va falloir partager !
Comme je l'ai dit plus haut, un bus est un ensemble de fils qui relie plusieurs composants. Mais le nombre de composants connects au bus est variable suivant le bus. Certains bus se contentent de connecter deux composants entre eux, pour leurs permettre de communiquer. Le bus n'a pas besoin d'tre partag entre plusieurs composants, et est rserv ces deux composants. Ce sont les bus ddis.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

Sur d'autres bus, on peut connecter un nombre plus important de composants, qui peut tre assez lev dans certaines situations : le bus doit donc tre partag entre ces composants. Ce sont les bus multiplexs.

221/378

Conflit d'accs
Si on cble plusieurs composants sur le mme bus, rien n'empche ces deux composants de vouloir envoyer ou recevoir une donne sur le bus en mme temps. C'est ce qu'on appelle un conflit d'accs au bus. Cela pose problme si un composant cherche envoyer un 1 et l'autre un 0 : quand on envoie plusieurs bits en mme temps, tout ce que lon reoit l'autre bout du fil est un espce de mlange incohrent des deux donnes envoyes sur le bus par les deux composants. En clair, a ne ressemble plus rien l'autre bout du fil ! Pour rsoudre ce petit problme, il faut obligatoirement rpartir l'accs au bus de faon ce qu'un seul composant utilise le bus la fois. Ainsi, chaque composant va pouvoir envoyer des donnes sur le bus et dmarrer une communication tour de rle. Les composants ne pourront donc pas toujours mettre quand ils le souhaitent : si un composant est dj en train d'crire sur le bus, et qu'un autre veut l'utiliser, on devra choisir lequel des deux pourra mettre ses donnes sur le bus. Ce choix sera effectu diffremment suivant le protocole du bus et son organisation, mais ce choix nest pas gratuit : certains composants devront attendre leur tour pour avoir accs au bus. Ces temps d'attente ralentissent quelque peu les transferts. Un bus ddi n'a pas ce problme, et est donc plus rapide, plus simple. Pour limiter les problmes dus ces temps d'attente, les concepteurs de bus ont invents diverses mthodes pour grer ces conflits daccs, et choisir le plus quitablement et le plus efficacement possible quel composant peut envoyer ses donnes sur le bus. C'est ce qu'on appelle l'arbitrage du bus. Divers types d'arbitrage existent. Dans l'arbitrage centralis, un circuit spcialis s'occupe de l'arbitrage du bus, et aucun composant n'a quoique ce soit dire : ils doivent se contenter dobir aux ordres du circuit charg de grer l'arbitrage. Dans l'arbitrage distribu, chaque composant se dbrouille de concert avec tous les autres pour viter les conflits daccs au bus : les composants sont relis par des fils entre eux, et chacun dcid d'mettre ou pas suivant l'tat du bus. Dans ce qui va suivre, on va vous montrer deux exemples de mthodes d'arbitrages du bus particulirement simples.

Arbitrage par multiplexage temporel

Cet arbitrage peut se rsumer en une phrase : chacun son tour ! Avec cet arbitrage, chaque composant a accs au bus tour de rle durant un temps fixe. Cet arbitrage est trs simple : on laisse le bus durant quelques millisecondes un composant avant de passer au suivant et ainsi de suite avant de revenir au point de dpart. Cet arbitrage est nanmoins peu adapt aux cas pour lesquels certains composants effectuent beaucoup de transactions sur le bus et dautres trs peu : la rpartition de laccs au bus est fixe et ne tient pas compte du fait que certains composants utilisent peu le bus et d'autres beaucoup : tous ont la mme part.

Arbitrage par requte

Mais rassurez-vous, il y a moyen de faire nettement mieux et plus simple comme mthode d'arbitrage du bus : premier arriv, premier servi ! L'ide est que tout composant peut accder au bus si celui-ci est libre et se le rserver. Par contre, si jamais le bus n'est pas libre, le composant qui souhaite accder au bus doit attendre que celui qui utilise le bus le libre. Certains protocoles d'arbitrage ont amlior le principe de base. Avec ces protocoles, il est possible de librer le bus de force, et interrompre brutalement une transmission pour laisser la place un autre composant. Sur certains bus, certains composants sont prioritaires, et les circuits chargs de la gestion du bus (peut importe leur localisation), vont pouvoir librer de force le bus si jamais un composant un peu plus prioritaire veut utiliser le bus. D'autres font en sorte de prempter le bus, c'est dire qu'ils donnent l'accs au bus un composant durant un certain temps fixe. Si le composant dpasse ce temps fixe, la transmission est interrompue pour laisser la place un autre composant. Par contre, un composant qui n'utilise pas totalement le temps qui lui est attribu peut librer le bus prmaturment pour laisser la place un de ses camarades.

Implmentation
C'est bien beau d'avoir cre un protocole d'arbitrage du bus un peu mieux, mais encore faut-il que nos composants puissent savoir que le bus est occup pour que ce protocole puisse fonctionner. Pas de panique : le bus de commande est l pour ! Il suffit de lui rajouter un fil qui sert indiquer que le bus est occup et qu'un composant l'utilise : le fil Busy. Cet arbitrage peut tre implant aussi bien en une version centralise qu'en une version distribue.

Chipset, back-plane bus, et autres

L'organisation des bus de nos ordinateurs a volue au cours du temps pendant que de nombreux bus apparaissaient.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

On considre qu'il existe deux gnrations de bus bien distinctes : une premire gnration avec un bus unique, la plus ancienne ; une seconde gnration avec des bus segments .

222/378

Premire gnration
Pour les bus de premire gnration, un seul et unique bus reliait tous les composants de notre ordinateur. Ce bus s'appelait le bus systme ou backplane bus.

Ce bus tait partag entre tous les composants : chacun d'entre eux monopolisait le bus durant un moment, et le librait quand il avait fini de transmettre des donnes dessus. Ces bus de premire gnration avaient le fcheux dsavantage de relier des composants allant des vitesses trs diffrentes : il arrivait frquemment qu'un composant rapide doive attendre qu'un composant lent libre le bus. Le processeur tait le composant le plus touch par ces temps d'attente.

Seconde gnration
Pour rgler ce genre de problmes, on a dcid de diviser le bus systme en deux bus bien spars : un bus pour les priphriques lents, et un autre pour les priphriques rapides. Deux composants lents peuvent ainsi communiquer entre eux sans avoir utiliser le bus reliant les priphriques rapides (et vice-versa), qui est alors utilisable volont par les priphriques rapides. Les composants rapides et lents communiquent chacun de leur cot sans se marcher dessus. Ces deux bus taient relis par un composant nomm le chipset , charg de faire la liaison et de transmettre les donnes d'un bus l'autre.

Comme vous le voyez sur cette image, les composants considrs comme rapides sont le processeur et la mmoire. Ceux-ci sont souvent associs la carte graphique. Le reste des composants est considr comme lent.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

223/378

Northbridge et southbridge
Sur certains ordinateurs, le chipset est divis en 2 : Le northbridge : une partie qui s'occupe de tous les bus relis aux composants rapides : processeurs, RAM, carte graphique (et oui !) ; Le southbridge : et une partie qui s'occupe de grer les bus des priphriques lents, comme les disque durs, les ports USB, le clavier, etc.

De nos jours
De nos jours, nos ordinateurs contiennent bien plus que deux bus, et presque chaque composant ou contrleur de priphrique est connect sur le chipset par un bus. Le preuve par l'exemple :

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

224/378

Sur les ordinateurs ayant des processeurs rcents (2009-2010), le northbridge a disparu : celui-ci est intgr directement dans le processeur.

Front side bus

Parmi tout ces bus, un bus fait l'objet d'une attention particulire : le Front side bus. C'est le bus qui relie le processeur au chipset. Plus celui-ci est rapide, moins le processeur a de risque d'tre ralenti par la mmoire et les oprations de communications avec le chipset. Ce Front side bus, ou FSB, est cadenc une frquence qui est considr comme l'horloge de base, de laquelle toutes les autres frquences dcoulent. Ainsi, la frquence du processeur est un multiple de la frquence du FSB : on obtient la frquence du processeur en multipliant la frquence du FSB par un coefficient multiplicateur. Mais le processeur n'est pas le seul avoir ce luxe : toutes les autres frquences de notre ordinateur sont dduite de la frquence du FSB par dautres coefficients multiplicateurs. Sur certaines cartes mres, il est possible de modifier la frquence du FSB et/ou les coefficients multiplicateurs : on peut ainsi faire varier la frquence de notre processeur ou de notre mmoire. Certains prfrent l'augmenter pour avoir un processeur ou une mmoire plus rapide, et font ce qu'on appelle de l'overcloking (surfrquenceage en franais). D'autre pratiquent l'undercloking , et diminuent la frquence de leur processeur pour que celui-ci chauffe moins et pour gagner quelques euros en faisant baisser leur facture EDF. Mais il s'agit l de pratiques trs dangereuses qui peuvent faire rendre lme prmaturment votre processeur : il s'agit de manipulations qui doivent tre faites par des professionnels qualifis et des personnes qui savent ce qu'elles font.

Back side bus

Moins connu que le le FSB, il existe un autre bus qui avait autrefois son importance sur certaines carte mres : le Back Side Bus. Autrefois, la mmoire cache tait (totalement ou en partie) spare du processeur : le Back Side Bus tait charg de relier le processeur la mmoire cache.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

225/378

Architectures sans Front side bus

Rcemment, le FSB a subit quelques volutions. Sur les cartes mres rcentes, le northbridge est en effet intgr au processeur, ce qui a ncessit quelques modifications. L'organisation des bus sur nos ordinateurs rels ressemble plus au schma qui suit.

En clair, on a un bus qui relie le processeur la mmoire, et un autre qui relie le processeur au southbridge, avec parfois un autre bus pour la carte graphique, mais passons. Ces nouveaux bus reliant le processeur au southbridge vous sont peut-tre connus si vous allez souvent sur des sites parlant de l'actualit du hardware : il ne s'agit ni plus ni moins que des bus Intel QuickPath

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

Interconnect de chez Intel, et l'HyperTransport d'AMD.

226/378

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

227/378

Communication avec les Entres-Sorties

Dans ce chapitre, on va voir comment nos priphriques vont faire pour communiquer efficacement avec notre processeur ou notre mmoire. Et on va voir que la situation est plus complique qu'il n'y parait. On a beaucoup parl de mmoire et de processeur ces derniers chapitres, ce qui me pousse commencer ce chapitre par quelques rappels. On sait dj que nos entres-sorties (et donc nos priphriques) sont relis au reste de l'ordinateur par ce qu'on appelle un bus. Ce bus est constitu de fils lectriques dans lesquels "circulent" des signaux lectriques (tensions ou courants) interprts en 0 ou en 1. Ce bus est divis en plusieurs sous-bus qui ont chacun une utilit particulire : Le bus d'adresse permet au processeur de slectionner l'entre, la sortie ou la portion de mmoire avec qui il veut changer des donnes. Le bus de commande permet la gestion des changes de donnes. Le bus de donne par lequel s'changent les informations. Pour communiquer avec un priphrique, le processeur a juste besoin de configurer ces bus avec les bonnes valeurs. Mais communiquer avec un priphrique n'est pas aussi simple que a, comme ce chapitre va vous le montrer.

Interfacage Entres-sorties
Dans la faon la plus simple de procder, le processeur se connecte au bus et va directement envoyer sur le bus : l'adresse, les donnes, et autres commandes envoyer l'entre-sortie ou au priphrique. Ensuite, le processeur va devoir attendre et reste connect au bus tant que le priphrique n'a pas trait sa demande correctement, que ce soit une lecture, ou une criture. Cette mthode a beau tre simple, elle a un gros problme : nos priphriques sont trs lents pour un processeur. Le processeur passe normment de temps attendre que le priphrique aie reu ou envoy sa donne. Et il a donc fallu trouver des solutions plus ou moins lgantes.

Interfaage
Pour faciliter la communication entre processeur et entres-sorties/priphriques, une solution toute simple t trouve : intercaler des registres entre le processeur et les entres-sorties. Ces registres servent faciliter la communication avec le processeur : il suffit au processeur de lire ou crire dans ces registres pour communiquer avec le priphrique . Le processeur peut crire des donnes sur une sortie sans monopoliser le bus en attendant que la sortie ou le priphrique aie reu la donne. Il crit sa donne dans les registres dinterfaage et n'attend pas que le priphrique aie reu la donne. Cette sortie aura juste lire le contenu du registre de faon rgulire (ou quand elle aura dtect une criture dans ce registre) pour voir si le processeur ou un autre composant lui a envoy quelque chose. Pour les entres, la situation ne s'amliore pas vraiment pour le processeur : il doit continuer lire le contenu des registres dinterfaage rgulirement pour voir si un priphrique lui a envoy quelque chose. C'est plus rapide que devoir scruter en quasi-permanence le bus : les processeur peut faire ce qu'il veut comme calcul, entre deux lecture du contenu du registre. Mais le problme demeure. Bien sr, on va bientt voir que diverses techniques peuvent permettre des amliorations parfois notables.

Registres d'interfaage
Ces registres sont appels des registres d'interfaage et permettent au priphrique de communiquer avec "l'extrieur". C'est dans ces registres que le processeur va lire les informations que le priphrique veut lui transmettre, ou qu'il va crire les donnes et ordres qu'il veut envoyer au priphrique.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

228/378

Le contenu de ces registres dpend fortement du priphrique et on peut difficilement tablir des rgles gnrales quand leur contenu. Pour simplifier, on peut dire que ces registres peuvent contenir des donnes tout ce qu'il y a de plus normales ; ou des "ordres". Ces ordres sont transmis au priphrique par des bits ou des groupes de bits individuels localiss dans des registres dinterfaage. Le priphrique est conu pour effectuer un ensemble d'actions prprogrammes. Suivant la valeur de ces bits ou groupes de bits, une de ces actions parmi toutes les autres sera slectionne, et ces bits ou groupes de bits peuvent donc servir transmettre un "ordre". On peut comparer ces ordres avec les instructions d'un processeur, sauf qu'ici, ces ordres seront destins un priphrique.

Contrleur de priphrique
Bon maintenant que notre processeur a crit dans les registres dinterfaage, qu'est-ce que se passe ?

A ce moment, un petit circuit nomm contrleur de priphrique va alors prendre le relai. Celui-ci est un petit circuit lectronique qui va lire les donnes et informations envoyes par le processeur, les interprte, et va piloter le priphrique de faon ce que celui-ci fasse ce qui lui est demand. Ce circuit peut tre plus ou moins compliqu et dpend du bus utilis, ainsi que du priphrique. Vu que les ordres et les informations envoyes par le processeur sont stocks dans les diffrents registres relis au bus, le contrleur a juste lire le contenu de ces registre et le traiter pour faire ce qui lui est demand.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

229/378

Comme vous le voyez, le boulot du contrleur de priphrique est de gnrer des signaux de commande qui dclencheront une action effectue par le priphrique. Ces signaux sont gnrs partir du contenu des registres. L'analogie avec le squenceur d'un processeur est possible, bien que limite. Il faut bien remarquer qu'un contrleur de priphrique travaille la demande : on lui donne un ordre, il obit et gnre les signaux de commande. Les contrleurs de priphriques peuvent tre trs diffrents les uns des autres. Cela peut aller du simple circuit compos de quelques centaines de transistors un petit micro-contrleur, avec sa RAM, son CPU et son programme intgr. De plus, le contrleur de priphrique peut trs bien tre spar du priphrique qu'il va commander. Certains priphriques intgrent en leur sein ce contrleur : les disques durs IDE, par exemple). Mais dautres sont commands par un contrleur spar du priphrique. Dans certains cas, ce contrleur est plac sur la carte mre et peut mme commander plusieurs priphriques en mme temps : c'est le cas du contrleur de bus USB. Une prcision assez importante s'impose : certains contrleurs de priphriques peuvent permettre au processeur de communiquer avec plusieurs priphriques en mme temps. C'est notamment le cas pour tout ce qui est contrleurs PCI, USB et autres : ces contrleurs sont relis un bus sur lequel plusieurs priphriques sont connects. Le contrleur se contente de prendre en charge l'change dinformations via le bus en question et peut ainsi communiquer avec plusieurs priphriques.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

230/378

Dans ce genre de cas, on peut parfaitement considrer que le contrleur sert plus d'interface entre un bus spcialis et le processeur.

Registre d'tat
Certains de ces contrleurs intgrent un registre qui contient des informations sur l'tat du contrleur, du priphrique ou du bus qui relie ces registres au priphrique. Ils peuvent tre utiles pour signaler des erreurs de configuration ou des pannes touchant un priphrique.

Pilotes de priphriques
Lorsqu'un ordinateur utilise un systme d'exploitation, celui-ci ne connait pas toujours le fonctionnement d'un priphrique et/ou de son contrleur ( par exemple, si le priphrique a t invent aprs la cration de l'OS). Il faut donc installer un petit programme qui va s'excuter quand on souhaite communiquer avec le priphrique et qui s'occupera de tout ce qui est ncessaire pour le transfert des donnes, l'adressage du priphrique, etc. Ce petit programme est appel driver ou pilote de priphrique. La "programmation" d'un contrleur de priphrique est trs simple : il suffit de savoir quoi mettre dans les registres pour paramtrer le contrleur. Et un pilote de priphrique ne fait que cela. Pour simplifier au maximum, un pilote de priphrique est un ensemble de petits sous-programmes qui ont chacun une utilit particulire. Chacun de ces sous-programmes sexcute la demande, quand un programme en a besoin. Ces sous-programme vont alors configurer les registres dinterfaage de faon ce que ceux-ci contiennent les ordres et donnes ncessaires pour que le contrleur de priphrique fasse ce qu'on lui demande.

Problmes
Avec les registres dinterfaage, l'criture est nettement plus rapide : le processeur crit dans le registre adquat et peut continuer son travail dans son coin en attendant que le priphrique aie fini. La seule contrainte, c'est que le processeur ne peut pas forcment (sauf cas particuliers) envoyer une autre commande au contrleur de priphrique tant que la premire commande n'est pas traite. Tant que le contrleur de priphrique n'est pas "libre", le processeur devra attendre. Aprs avoir envoy un ordre au contrleur, le processeur ne sait pas quand le contrleur redeviendra libre, et doit donc vrifier priodiquement si le contrleur est prt pour un nouvel envoi de commandes/donnes. Gnralement, il suffit au processeur de lire le registre d'tat du contrleur : un bit spcial de celui-ci permet d'indiquer si le contrleur est libre ou occup. Pour la lecture, la situation est similaire : le processeur doit lire rgulirement son contenu pour voir si le priphrique ne lui a pas envoy quelque chose.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

231/378

Cette mthode consistant vrifier priodiquement si le priphrique a reu ou envoy quelques chose s'appelle le Pooling. Cette technique permet de ne pas rester connect en permanence durant le temps que met le priphrique pour effectuer une lecture ou une criture, mais ce n'est pas parfait : ces vrifications priodiques sont autant de temps perdu pour le processeur. Pour solutionner ce problme, on a dcid dutiliser des interruptions !

Interruptions
Encore un terme barbare ! Qu'est-ce que c'est qu'une interruption ?

Ces interruptions sont des fonctionnalits du processeur qui vont interrompre temporairement lexcution d'un programme afin de ragir un vnement extrieur (matriel, erreur fatale dexcution d'un programme...) et de le traiter en temps voulu, avant de rendre la main au programme interrompu. Notre interruption va donc devoir effectuer un petit traitement (ici, communiquer avec un priphrique). Ce petit traitement est fait par un petit programme au auquel on a donn un nom technique : routine d'interruption. On les utilise pour quelques cas bien prcis, qui ncessitent un traitement ne pouvant attendre trop longtemps. Communiquer avec des priphriques est un de ces cas. Ainsi, pour communiquer avec une carte graphique, un disque dur ou encore avec le clavier, vous allez devoir utiliser des interruptions. Ces interruptions sont aussi utilises pour permettre plusieurs programmes de s'excuter sur un processeur : on switche constamment d'un programme un autre, l'aide d'interruptions ; et pour bien d'autres choses encore. Il existe des processeurs qui ne grent pas les interruptions, mais ceux-ci sont vraiment trs rare, vu leurs nombreuses utilisations diverses et varies.

Droulement d'une interruption

Lorsqu'un processeur doit excuter une interruption, celui-ci : Arrte l'excution du programme en cours d'excution et sauvegarde une partie ou l'intgralit de l'tat du processeur (registres, cache, piles...) Excute un sous-programme assez simpliste nomm routine d'interruption. (et donc, on doit effectuer une instruction de branchement vers ce sous-programme). Restaure l'tat du programme sauvegard afin de reprendre l'excution de son programme l ou il en tait.

En quoi ces interruptions permettent de communiquer efficacement avec des entres-sorties ?

Trs simplement : avec elles, le processeur n'a pas vrifier priodiquement si le contrleur de priphrique est libre ou a bien envoy sa donne. Les interruptions vont tre utilises pour prvenir que le contrleur de priphrique a envoy une donne au processeur ou qu'il est libre. Ainsi, le processeur se contente d'crire dans les registres dinterfaage et ne fait rien de plus : on n'utilise le processeur que quand on en a besoin.. Prenons le cas d'une lecture ou un cas dans lequel le priphrique envoie une donne au processeur (du genre : une touche a t tape au clavier). Dans ce cas, le priphrique enverra une interruption au processeur pour le prvenir qu'une donne lui est destine. Le processeur traitera l'interruption en copiant le contenu des registres dinterfaage contenant la donne signale par l'interruption et fera ce qu'il faut avec.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

232/378

Dans le cas d'une criture ou d'un envoi de commande quelconque, le processeur se contentera d'crire dans les registres dinterfaage : le contrleur prviendra qu'il est enfin prt pour une nouvelle commande via une interruption.

Registres, again
Ce sous-programme va fatalement utiliser certains registres du processeur lors de son excution. Comme pour les fonctions, il faut alors sauvegarder certains registres du processeur pour viter que notre routine dinterruption vienne craser des donnes qui ne doivent pas l'tre. Ainsi, les registres utiliss par notre routine d'interruption seront sauvegards au sommet de la pile de notre ordinateur. Cette sauvegarde n'est pas toujours faite automatiquement par notre processeur. Parfois, c'est le programmeur qui doit coder luimme la sauvegarde de ces registres dans la routine d'interruption elle-mme. Il peut ainsi dcider de ne pas sauvegarder certains registres qui ne sont pas destins tre utiliss par la routine, afin de gagner un peu de temps.

Vecteur d'interruption
Comme on l'a dit, une interruption a t conue pour ragir un vnement, mais ce sont avant tout des programmes comme les autres, qui peuvent tre excuts comme n'importe quelle autre programme. Dans notre cas, ces interruptions seront simplement considres comme des programmes simplistes permettant d'agir sur un priphrique. Bien sr, devant la multiplicit des priphriques, on se doute bien qu'il n'existe pas d'interruption tout faire : il va de soi qu'un programme envoyant un ordre au disque dur sera diffrent d'un programme agissant sur une carte graphique. Dans chaque cas, on aura besoin d'effectuer un traitement diffrent. On a donc besoin de plusieurs routines d'interruption. Mais il faut bien dcider quelle est l'interruption excuter suivant la situation. Par exemple, excuter l'interruption de gestion du clavier alors qu'on souhaite communiquer avec notre disque dur donnerait un rsultat plutt comique. On va donc devoir stocker plusieurs de ces routines dans sa mmoire. Mais comment les retrouver ? Comme les autres donnes ! Chaque routine est donc place dans la mmoire un certain endroit, localisable par son adresse : elle indique sa position dans la mmoire. Pour retrouver la position de notre routine en mmoire et savoir laquelle excuter, certains ordinateurs utilisent une partie de leur mmoire pour stocker toutes les adresses de dbut de chaque routine d'interruption. En gros, cette partie de la mmoire contient toute les adresse permettant de localiser chaque routine. Cette portion de la mmoire s'appelle le vecteur d'interruption. Pour chaque interruption, une partie fixe de la mmoire contiendra l'adresse de dbut de l'interruption effectuer.

Priorit des interruptions

Et quand deux interruptions de dclenchent en mme temps ? Genre, quand le disque dur et le clavier souhaite informer le processeur qu'une lecture est finie et qu'il faut excuter la routine correspondante ?

Et bien, dans ce cas l, on ne peut excuter qu'une seule interruption. On doit donc choisir d'excuter une interruption et pas l'autre. Le truc, c'est que certaines interruptions seront prioritaires sur les autres. Chaque interruption possde une priorit. Cette priorit est code par un nombre : plus le nombre est lev, plus l'interruption a une priorit faible ! Quand deux interruptions souhaitent s'excuter en mme temps, on choisit d'excuter celle qui est la plus prioritaire (celle dont le nombre est le plus faible). L'autre interruption n'est pas excute, et doit attendre. On dit que cette interruption est masque. Le masquage d'interruption empche l'excution d'une interruption et la force attendre un vnement prcis pour pouvoir enfin s'excuter. On peut nanmoins masquer des interruptions sans que cela soit du l'excution de deux interruptions simultanes, mais passons cela sous le tapis pour le moment. Bien videment, il faut dcider quelles sont les interruptions les plus prioritaires sur les autres . Cela se fait par leur utilit : certaines interruptions sont plus urgentes que les autres. Une interruption qui gre l'horloge systme est plus prioritaire qu'une interruption en provenance de priphriques lents comme le disque dur ou une cl USB.

Les diffrents types d'interruptions

Il y a trois moyens pour dclencher une interruption : une interruption dclenche par une instruction de branchement un peu spciale du processeur, les exceptions, qui se produisent automatiquement lorsque le processeur rencontre une erreur (du style une division par zro), les requtes d'interruptions, qui sont dclenches par un vnement d'origine matrielle.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

233/378

Comme vous le voyez, les interruptions peuvent non-seulement tre appeles par un programme quelconque, grce l'instruction int, mais elles permettent aussi de ragir des vnements purement matriels, comme l'appui d'une touche au clavier.

IRQ
Les IRQ sont des interruptions qui sont dclenches par un priphrique. Dans une implmentation simple des IRQ, notre priphrique est reli notre processeur sur une de ses entre. Si on envoie un 1 sur cette entre, le processeur excute une interruption parmi toute les autres. Ainsi, notre processeur contient autant d'entre supplmentaires qu'il peut excuter d'interruption. Cela utilise un petit peu trop d'entres qui pourraient tre utilises autre chose. Pour viter cela, on a invent le contrleur d'interruptions. Ce contrleur d'interruptions est un petit circuit sur lequel on va connecter tous les fils d'IRQ. Ce contrleur va recevoir sur ses entres les IRQ envoyes par les priphriques. Ce contrleur possde : une sortie sur laquelle on envoie un signal sur une entre du processeur qui va signaler qu'il faut excuter une interruption ; un registre qui contient l'adresse de la routine sur laquelle il faut brancher ; et une "mmoire" ou un circuit qui contient (mmoire) ou dduit (circuit) pour chaque interruption, l'adresse de branchement de la routine excuter.

Le droulement d'un interruption est alors trs simple : une ou plusieurs signal d'IRQ arrivent en entre du contrleur d'interruptions. le contrleur regarde si une des interruption doit tre masque ; il choisit la plus prioritaire ; il stocke dans son registre des informations permettant au processeur didentifier le priphrique ou le contrleur de priphrique qui a envoy l'interruption ; il envoie un signal d'interruption au CPU ; le CPU lit le contenu du registre et en dduit quelle est la routine dinterruption effectuer (son adresse dans le vecteur d'interruption par exemple) ; il excute l'interruption. Avec ce contrleur, on vite au processeur de devoir grer les priorits et les masquages, et on conomise des entres. Ce contrleur est parfois plac l'extrieur du processeur, et intgr dans le processeur pour les autres cas, comme l'on pouvait s'en douter.

Interruptions logicielles
Ces interruptions ont une cause diffrente : elle sont dclenches par un programme en cours d'excution sur notre ordinateur. Ces interruptions sont des instructions qui sont excutables par un programme. Ainsi, le jeu d'instruction du CPU contient une instruction d'interruption. Un programmeur peut donc dcider d'utiliser des interruptions un certain moment de ce programme, pour des raisons particulires.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

234/378

Par contraste, les IRQ ne sont pas des instructions appartenant au jeu d'instruction, et ne sont excutes que quand une entresortie en fait la demande. D'ailleurs, certains processeurs grent les IRQ, mais pas les interruptions logicielles. Ces interruptions logicielles sont beaucoup utilises par les pilotes de priphriques : ces interruptions logicielles peuvent tre excutes au besoin. Ainsi, les programmes d'un systme d'exploitation utilisent des interruptions pour dlguer la communication avec les priphriques au pilotes de priphriques. Ces interruptions logicielles vont faire excuter des routines charges de lire ou crire dans les registres dinterfaage. Il va de soit que ces routines sont celles du pilote de priphrique. Ceux qui veulent en savoir plus peuvent aller lire mon tutoriel sur les systmes d'exploitation.

Exceptions
Et maintenant, une petite digression, pour vous prouver que les interruptions peuvent servir beaucoup de choses et pas seulement communiquer avec des priphriques. On va parler des exceptions matrielle. Ne pas confondre les exceptions matrielles et celles utilises dans les langages de programmation, qui n'ont rien voir !

Une exception matrielle est aussi une interruption, mais qui a pour raison un vnement interne au processeur, par exemple une erreur d'adressage, une division par zro...Pour pouvoir excuter des exceptions matrielles, notre processeur doit pouvoir dclencher une interruption lorsqu'une erreur particulire survient dans le traitement d'un instruction. Il faut donc que ce CPU intgre des circuits ddis cette tache. Lorsqu'une exception matrielle survient, il faut trouver un moyen de corriger l'erreur qui a t la cause de l'exception matrielle : la routine excute va donc servir corriger celle-ci. Bien sur, une exception matrielle peut avoir plusieurs causes. On a donc plusieurs routines.

Direct Memory Access

Avec nos interruptions, seul le processeur gre l'adressage de la mmoire. Impossible par exemple, de permettre un priphrique d'adresser la mmoire RAM ou un autre priphrique. Il doit donc forcment passer par le processeur, et le monopoliser durant un temps assez long, au lieu de laisser notre CPU excuter son programme tranquille. Pour viter cela, on a invent le bus mastering. Grce au bus mastering , le priphrique adresse la mmoire directement. Il est capable d'crire ou lire des donnes directement sur les diffrents bus. Ainsi, un priphrique peut accder la mmoire, ou communiquer avec dautres priphriques directement, sans passer par le processeur.

Arbitrage du bus
Le bus mastering n'est pas sans poser quelques petits problmes : le processeur et/ou plusieurs priphrique peuvent bouloir accder au bus en mme temps. Manque de chance : on ne peut laisser deux composants tenter d'crire des donnes en mme temps sur le mme bus : si on laissait faire ce genre de choses, on se retrouverait vite avec n'importe quoi sur notre bus ! V pourquoi : si on cble plusieurs composants sur le mme bus, rien n'empche ces deux composants de vouloir envoyer ou oici recevoir une donne sur le bus en mme temps. C'est ce qu'on appelle un conflit d'accs au bus. Cela pose problme si un composant cherche envoyer un 1 et l'autre un 0 : le niveau logique du bit envoyer est alors inconnu. Et quand on envoie plusieurs bits la suite, tout ce que lon reoit l'autre bout du fil est un espce de mlange incohrent des deux donnes envoyes sur le bus par les deux composants. En clair : a ne ressemble plus rien l'autre bout du fil ! Il faut donc trouver diverses mthodes pour grer ces conflits daccs, et choisir le plus quitablement et le plus efficacement possible quel composant peut envoyer ses donnes sur le bus. C'est ce qu'on appelle l'arbitrage du bus. La technique du bus mastering est une technique assez gnrale, aussi je vais vous prsenter, assez rapidement, une version de cette technique nomme le direct memory acces.

Direct Memory Acces

Le Direct Memory Acces est une technologie de bus mastering assez simple, qui permet vos priphriques d'accder la mmoire RAM de votre ordinateur. Avec elle, le processeur n'est pas utilis, ce qui rend la communication entre la mmoire et le priphrique plus rapide. Elle peut mme servir transfrer des donnes de la mmoire vers la mmoire, pour effectuer des copies de trs grosses donnes, mme si cela ne marche qu'avec du matriel particulier. Nanmoins, avec le Direct Memory Acces, le processeur doit tout de mme intervenir au dbut et la fin d'un transfert de donnes entre la mmoire et un priphrique. Mais comment a marche ?

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

235/378

Sans Direct Memory Acces, les priphriques et leurs contrleurs ne peuvent pas modifier le contenu du bus d'adresse ou le bit R/W afin de demander une lecture ou une criture : ils n'ont accs qu'aux registres dinterfaage et peuvent dclencher des interruptions, mais le bus leur est interdit. Ainsi, les contrleurs de priphriques ne peuvent adresser la mmoire et demander des oprations de lecture et/ou criture directement : il doivent passer par un intermdiaire, savoir notre bon vieux processeur.

Contrleur DMA
Avec la technologie DMA, un circuit spcial souvent intgr notre priphrique (ou son contrleur), le contrleur DMA est reli au bus mmoire et peut modifier le contenu des bus d'adresse, de commande et de donnes. L'change de donne entre le priphrique et la mmoire est intgralement gr par celui-ci. Ce contrleur DMA est similaire un contrleur de priphrique : il possde des registres dans lesquels le processeurs peut crire et chacun de ces registres contient des donnes utiles au contrleur pour faire ce qu'on lui demande. Ce contrleur DMA est capable de transfrer un gros bloc de mmoire entre un priphrique et la mmoire. Le transfert peut aller dans les deux sens : du priphrique vers la RAM, ou de la RAM vers le priphrique. Le sens du transfert, ainsi que les informations sur le bloc de mmoire transfrer, sont prciss dans un des registres du contrleur DMA. Ce contrleur incorpore donc des registres chargs de contenir : une adresse qui va dfinir le dbut du segment de la mmoire ; la longueur de ce segment de mmoire ; et parfois un ou plusieurs registres de contrle. Ces registres de contrle peuvent contenir beaucoup de chose : avec quel priphrique doit-on changer des donnes, les donnes sont-elles copies du priphrique vers la RAM ou l'inverse, et bien dautres choses encore. Le travail du contrleur est assez simple. Celui-ci doit se contenter de placer les bonnes valeurs sur les bus, pour effectuer le transfert. Il va donc initialiser le bus d'adresse l'adresse du dbut du bloc de mmoire et initialiser le bus de commande selon la valeur du bit/registre spcifiant le sens de la transaction. Puis, chaque fois qu'une donne est lue ou crite sur le priphrique, il va augmenter l'adresse de ce qu'il faut pour slectionner le bloc de mmoire suivant.

Modes DMA
Il existe trois facon de transfrer des donnes entre le priphrique et la mmoire. On peut ainsi citer le mode block, le mode cycle stealing , et le mode transparent. Ces trois modes diffrent par la faon dont le processeur est laiss libre de ses mouvements. Dans le mode block, le contrleur mmoire se rserve le bus mmoire, et effectue le transfert en une seule fois, sans interruptions. Cela a un dsavantage : le processeur ne peut pas accder la mmoire durant toute la dure du transfert entre le priphrique et la mmoire. Alors certes, a va plus vite que si on devait utiliser le processeur comme intermdiaire, mais bloquer ainsi le processeur durant le transfert peut diminuer les performances. Dans ce mode, la dure du transfert est la plus faible possible. Il est trs utilis pour charger un programme du disque dur dans la mmoire, par exemple. Et oui, quand vous dmarrez un programme, c'est souvent un contrleur DMA qui s'en charge ! Dans le mode cycle stealing , on est un peu moins strict : cette fois-ci, le contrleur ne bloque pas le processeur durant toute la dure du transfert. En cycle stealing , le contrleur va simplement transfrer un byte (un octet) la fois, avant de rendre la main au processeur. Puis, le contrleur rcuprera l'accs au bus aprs un certain temps. En gros, le contrleur transfre un byte;, fait une pause d'une dure fixe, puis recommence, et ainsi de suite jusqu' la fin du transfert. Et enfin, on trouve le mode transparent, dans lequel le contrleur DMA accde au bus mmoire uniquement quand le processeur ne l'utilise pas.

Un peu dlectricit
Premier bmol : le processeur et le contrleur DMA sont tous deux relis au bus. Et Cela pose problme ! Il faut arbitrer le bus et trouver viter que le processeur et un priphrique envoient des donnes sur le bus en mme temps. Les concepteurs de la technologie DMA sont des malins : ils ont trouvs une solution, base sur les interruptions. La solution retenue par le DMA est la suivante : le processeur et chaque priphrique est reli au bus par un transistor, un composant lectronique qu'on utilisera en tant qu'interrupteur ; de plus, un fil relie directement le priphrique au bus, et donc la mmoire (indirectement).

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

236/378

Tant que le priphrique n'accde pas la mmoire, tout les interrupteurs reliant le priphrique au bus sont dconnects : le priphrique n'est pas reli au bus. Par contre, le processeur est connect au bus mmoire et peut faire ce qu'il veut dessus, du moment que c'est dans son programme.

Lorsqu'un priphrique souhaite accder la mmoire ou qu'un programme veut envoyer des donnes un priphrique, il dclenche l'excution d'une interruption. Pour qu'un priphrique puisse dclencher cette interruption, il suffit d'envoyer un bit sur le fil qui le relie au processeur. Dans le cas prsent, la routine d'interruption va alors demander au processeur d'ouvrir ses interrupteurs ce qui le dconnecte du bus, tandis que le priphrique ferme ses interrupteurs. Le priphrique peut alors accder la mmoire.

Le contrleur DMA s'occupera alors de l'change de donnes, laissant le processeur libre d'excuter ses calculs dans son coin, sans accder au bus. A la fin de la transaction, le contrleur DMA dconnecte le priphrique du bus. Pour prvenir le processeur de la fin d'un change de donne entre priphrique et mmoire, le contrleur DMA enverra une interruption vers le processeur qui permettra alors celui-ci de se reconnecter au bus.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

237/378

Adressage des priphriques

Le chapitre prcdent a t assez instructif : maintenant, vous savez que nos priphriques sont relis au processeur par lintermdiaire d'un contrleur de priphrique. Ce contrleur de priphrique peut grer un ou plusieurs priphriques en mme temps, sans que cela ne pose problme. Mais il nous reste beaucoup de choses expliquer, et certaines questions restent encore en suspend. Comment faire pour accder aux registres de ce contrleur de priphrique ?

Ben oui, pour communiquer avec les registres du contrleur, il doit bien exister un moyen pour pouvoir les localiser et les slectionner ! Ce chapitre va vous montrer les diffrentes mthodes utilises pour pouvoir "adresser" notre contrleur de priphrique. Elles sont au nombre de trois et se nomment : la connexion directe ; les entres-sorties mappes en mmoire ; et l'espace d'adressage spar.

Connexion directe
Dans le cas le plus simple, le contrleur est reli directement sur des entres et des sorties du processeur : certaines entressorties du processeur sont spcialement ddies la communication avec un priphrique ou un contrleur de priphrique particulier. On se retrouve donc avec un bus supplmentaire, qui s'occupe de relier processeur et contrleur de priphrique : le bus d'entres-sorties.

En faisant ainsi, on peut accder un contrleur de priphrique et la mmoire en mme temps : on accde la mmoire par le bus mmoire, et on accde notre priphrique via le bus d'entres-sorties. Dans ce genre de cas, le contrleur n'a pas d'adresse qui permettrait de lidentifier. Le bus d'entres-sorties se rduit donc un bus de donne coupl un bus de commande. Les problmes commencent lorsqu'on se retrouve avec plusieurs contrleurs de priphriques cbler sur le processeur : on doit cbler autant de bus qu'on a des priphriques ! La quantit de fils utiliss, ainsi que le nombre de connexions ajouter sur le processeur augmente beaucoup trop pour que ce soit possible. On doit donc trouver un moyen qui permette de grer un grand nombre de priphriques et de contrleurs qui soit viable techniquement parlant.

Bus d'entres-sorties multiplex

La premire solution ce problme est trs simple : tous les contrleurs de priphriques sont relis au processeur par le mme bus. On se retrouve donc avec deux bus : un spcialis dans la communication avec les entres-sorties, et un spcialis dans la

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

communication avec la mmoire.

238/378

Avec cette solution, on doit trouver un moyen pour slectionner le contrleur de priphrique avec lequel on souhaite changer des donnes. Pour cela, on est oblig dutiliser l'adressage : chaque contrleur de priphrique se voit attribuer une adresse, qui est utilise pour l'identifier et communiquer avec lui. Notre bus d'entres-sorties se voit donc ajouter un bus d'adresse en plus du bus de donne et de commande. En faisant ainsi, on peut accder un contrleur de priphrique et la mmoire en mme temps : on accde la mmoire par le bus mmoire, et on accde notre priphrique via le bus d'entres-sorties. Par contre, impossible d'accder plusieurs contrleurs de priphriques en mme temps : avec des bus spars pour chaque contrleur, on aurait ventuellement pu le faire, au prix d'un nombre de fils et de connexions impressionnant et trs couteux. Il va de soit qu'avec cette solution, on conomise beaucoup de fils : on n'a plus qu'un bus d'entres-sorties cbler sur le processeur, au lieu de devoir utiliser autant de bus d'entres-sorties que de contrleurs de priphriques. L'conomie est norme ! Sans compter que le processeur n'a pas devoir grer plusieurs bus d'entre-sortie : il est moins complexe, ce qui fait gagner pas mal de transistors.

Espace d'adressage spar

On l'a vu, avoir deux bus spars pour la mmoire et les entres-sorties est une bonne solution pour conomiser des fils. Mais cela ne suffit malheureusement pas : on peut encore faire nettement mieux. En effet, on peut remarquer une chose assez vidente : le bus mmoire et le bus d'entres-sorties possdent chacun leur bus d'adresse. Pourquoi ne pas mutualiser les deux ?

Et bien c'est une trs bonne ide : on peut dcider de partager les bus d'adresse du bus mmoire et du bus d'entres-sorties sans problmes. Ainsi, le mme bus d'adresse sera utilis pour les accs aux priphriques et pour les accs mmoires.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

239/378

Par contre, les bus de donnes et de commande sont toujours spars : on ne les mutualise pas ! Et quand une case mmoire et un contrleur de priphrique ont la mme adresse, il se passe quoi ?

Aie ! Effectivement, cela arrive : on n'est pas l'abri de ce genre de chose. Mais il y a une solution trs simple : rajouter un fil sur le bus d'adresse qui servira dire qu'on veut communiquer avec un contrleur de priphrique, ou avec la mmoire. Ainsi, on rajoute un bit supplmentaire notre adresse qui servira distinguer la nature du composant avec lequel on veut communiquer : mmoire ou entres-sorties. Ce bit sera appel le bit IO dans la suite de ce tutoriel.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

240/378

Notre processeur est tout de mme un peu perdu : comment faire pour que celui-ci positionne la valeur du bit IO la bonne valeur et utilise le bon bus de donne suivant qu'il veuille communiquer avec un priphrique ou avec la mmoire ?

Et bien on n'a pas vraiment le choix : on doit utiliser des instructions diffrentes suivant le composant avec lequel on communique. Ainsi, l'instruction qui crira dans une adresse ddie un contrleur de priphrique ne sera pas la mme que celle charge d'crire dans une adresse en mmoire. Suivant l'instruction utilise, le bit IO sera automatiquement positionn la bonne valeur, et le bon bus de donne sera slectionn vitant toute confusion. Cela a une consquence : il est difficile de crer des instructions capables de transfrer des donnes entre un priphrique et la mmoire directement. Gnralement, les processeurs ne disposent pas d'instructions aussi spcialises : cela demanderait beaucoup de circuits pour pas grand chose. Pour transfrer des donnes d'un priphrique vers la mmoire, on est donc oblig de se servir d'un intermdiaire : les registres du processeur. Par exemple, prenons un transfert de donne d'un priphrique vers la mmoire : on est oblig de copier la donne du priphrique vers un registre du processeur, avant d'crire le contenu de ce registre dans la case mmoire de destination. videment, cela est tout aussi vrai pour les transferts qui vont dans l'autre sens. Pour viter de devoir passer par un registre, on peut aussi utiliser la technique du Direct memory acces, qui rsout totalement le problme. Mais il faut que notre priphrique ou notre carte mre incorpore un tel dispositif, ce qui n'est pas toujours le cas : a peut couter cher ce genre de machin.

Entres-sorties mappes en mmoire

Mine de rien, on a russit conomise pas mal de fils en partageant le bus d'adresse. Mais on se retrouve toujours avec un nombre de fils assez impressionnant cbler. De plus, notre processeur doit disposer d'instructions de transfert de donnes diffrentes pour l'accs la mmoire et l'accs aux priphriques : impossible de positionner le bit IO sans cette magouille. Mine de rien, partager le bus d'adresse complexifie pas mal la conception d'un processeur : doubler le nombre d'instructions d'accs mmoire impose de rajouter des circuits, ce qui n'est pas gratuit en terme de transistors et d'argent. Pour viter ce genre de dsagrment, on a trouv une autre solution : mapper les entres-sorties en mmoire. Bon, cette phrase a l'air impressionnante, mais rassurez-vous : l'explication arrive.

Memory Mapped I/O

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

241/378

Le principe est simple : on n'utilise pas d'adresses spares pour les priphriques (ou leurs contrleurs) et la mmoire. Certaines adresses mmoires, censes identifier une case mmoire de la mmoire principale (la RAM), vont tre rediriges vers les priphriques. En gros, tout se passe comme si le priphrique (ou son contrleur) se retrouvait inclut dans l'ensemble des adresses utilises pour manipuler la mmoire. Bien sr, le processeur n'a pas vraiment moyen de savoir qui est l'autre bout du fil : il ne manipule que le contenu du bus, sans aucun moyen de savoir qui va recevoir la donne.

Ainsi, certains "blocs" d'adresses mmoires seront invalides en dur par des circuits lectroniques chargs de grer le bus, et renverront vers le priphrique slectionn. On peut remarquer un petit dfaut inhrent cette technique : on ne peut plus adresser autant de mmoire qu'avant. Avant, toutes les adresses permettaient de slectionner une case de la mmoire principale. Plus maintenant : certaines adresses mmoire sont rserves aux priphriques et ne peuvent plus tre utilises pour adresser la mmoire. Les cases mmoires en question deviennent inaccessibles. Bon, a peut paraitre thorique, et il faut bien avouer que l'on peut aisment penser que a ne risque pas de nous concerner de sitt. Et pourtant, ce problme touche nos ordinateurs modernes. V ous avez dj entendus parler du problme des 4 gigaoctets ?

C'est un problme souvent rencontr sur les forums : certaines personnes installent 4 gigaoctets de mmoire sur leur ordinateur et se retrouvent avec "seulement" 3.5-3.8 gigaoctets de mmoire. Ce "bug" apparait sur les processeurs x86 quand on utilise un systme d'exploitation 32 bits. Avec ce genre de configuration, notre processeur utilise des adresses mmoires de 32 bits, ce qui fait 4gigaoctets de mmoire adressable. Et bien parmi certaines de ces adresses, une partie est utilise pour adresser nos priphriques et ne sert pas adresser de la mmoire RAM : on perd un peu de mmoire. Et mine de rien, quand on a une carte graphique avec 512 mgaoctets de mmoire intgre (cette mmoire est adresse directement et ca fait 512 Mo en moins d'un coup), une carte son, une carte rseau PCI, des ports USB, un port parallle, un port srie, des bus PCI-Express ou AGP, et un BIOS stocker dans une EEPROM FLASH, a part assez vite. V ous pouvez aussi tenter de regarder ce que a donne pour d'autres machines qui ne sont pas des PC, vous trouverez exactement le mme problme. Essayez de regardez sur le net ce que a donne pour des ordinateurs tels que la Gamecube, les vielles consoles Atari, une Gameboy color, ou d'autres machines plus ou moins bizarres : cela vous montrera d'autres exemples assez intressants.

Processeurs priphriques

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

242/378

Avec certains priphriques, cette technique qui consiste mapper nos entres-sorties en mmoire est pousse lextrme. C'est souvent le cas pour certains priphriques possdant une mmoire RAM intgre dans leurs circuits : cartes graphiques, cartes sons, etc. Cette mmoire est directement accessible directement par le processeur en dtournant suffisamment d'adresses mmoires. La mmoire de notre priphrique est accessible via des adresses mmoires normales : elle est ainsi en partie (voire totalement) partage entre le processeur principal de l'ordinateur et le priphrique (et plus globalement avec tout priphrique pouvant adresser la mmoire). Certains de ces priphriques intgrant une mmoire RAM vont mme plus loin et possdent carrment un processeur pour des raisons de rapidit. Une grande partie de la gestion des entres-sorties est ainsi dlgue au processeur intgr dans le priphrique et n'a pas tre gre par le processeur principal de l'ordinateur. On peut considrer que ces priphriques sont des mini-ordinateurs, relis notre processeur. Ce processeur intgr pourra ainsi xecuter des programmes chargs de commander ou configurer le priphrique. Ces programmes sont souvent fournis par les pilotes du priphrique ou le systme d'exploitation. Ces programmes sont souvent recopis par le processeur principal ou via un contrleur DMA dans la mmoire du priphrique (partage). Ainsi, adresser de tels priphriques pourra se faire assez directement en recopiant des programmes dans leur mmoire et en configurant quelques registres. Cela peut paraitre bizarre, mais sachez que c'est exactement ce qui se passe pour votre carte graphique si celle-ci a moins de vingts ans.

Bus unique
Cette technique a un gros avantage : on peut utiliser un bus unique, sans rien dupliquer : fini le bus de donne prsent en double ! Avec cette mthode, on peut se contenter d'un seul bus qui relie le processeur aussi bien avec la mmoire qu'avec les priphriques.

Avec cette technique, on conomise beaucoup de fils. Par contre, impossible d'accder la fois la mmoire et un contrleur d'entres-sorties : si le bus est utilis par un priphrique, la mmoire ne pourra pas lutiliser et devra attendre que le priphrique aie fini sa transaction (et vice-versa).

Et pour le CPU ?
www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

243/378

Autre avantage : on n'a pas besoin d'instructions diffrentes pour accder aux priphrique et la mmoire. Tout peut tre fait par une seule instruction : on n'a pas besoin de positionner un quelconque bit IO qui n'existe plus. Notre processeur possde donc un nombre plus limit d'instructions machines, et est donc plus simple fabriquer.

www.siteduzero.com

Partie 5 : Priphriques, bus, et entres-sorties

244/378

Partie 6 : Hirarchie mmoire

V ous savez depuis le chapitre sur la mmoire qu'il n'existe pas qu'une seule mmoire dans notre ordinateur. A la place, on utilise diffrentes mmoires, de tailles et de vitesses diffrentes, afin d'viter d'utiliser une seule mmoire grosse et lente. Mais malgr cela, les mmoires sont aujourd'hui les composants qui limitent le plus les performances de nos programmes. De nombreuses optimisations existent pour faire en sorte que la lenteur de la mmoire ne soit pas un frein. Dans ce chapitre, nous allons voir lesquelles.

La mmoire virtuelle
De nombreuses instructions ou fonctionnalits d'un programme ncessitent pour fonctionner de connaitre ou de manipuler des adresses mmoires qui sont censes tre fixes (accs une variable, pointeurs, branchements camoufls dans des structures de contrles, et d'autres). De nombreux modes d'adressages permettent de manipuler ou de calculer des adresses mmoires, plus ou moins efficacement. Sur les ordinateurs qui nexcutent qu'un seul programme la fois, cela ne pose aucun problme : on sait exactement o va tre charg notre programme dans la mmoire. Mais sur des ordinateurs un peu plus compliqus, c'est rarement le cas : l'adresse laquelle on va charger un programme dans notre mmoire RAM n'est presque jamais la mme d'une excution sur l'autre. Ainsi, les adresses de destination de nos branchements et les adresses de nos donnes ne sont jamais les mmes. Il nous faut donc trouver un moyen pour faire en sorte que nos programmes puissent fonctionner avec des adresses qui changent d'une excution l'autre. De plus, un autre problme se pose : un programme peut tre excut sur des ordinateurs ayant des capacits mmoires diverses et varies et dans des conditions trs diffrentes. Et il faut faire en sorte qu'un programme fonctionne sur des ordinateur ayant peu de mmoire sans poser problme. Aprs tout, quand on conoit un programme, on ne sait pas toujours quelle sera la quantit mmoire que notre ordinateur contiendra, et encore moins comment celle-ci sera partage entre nos diffrentes programmes en cours dexcution : s'affranchir de limitations sur la quantit de mmoire disponible est un plus vraiment apprciable. Et d'autres problmes existent encore : nos processeurs ne grent pas la mmoire de la mme faon. Si on devait prendre en compte cette gestion de la mmoire par le processeur lors de la conception de nos programmes, ceux-ci se seraient adapts qu' certains processeurs et pas d'autres.

Principe de base
V ous l'avez compris, tous les dtails concernant l'organisation et la gestion de la mmoire sont assez compliqu grer et faire en sorte que nos programmes n'aient pas s'en soucier est un plus vraiment apprciable. Ce genre de problme a eu des solutions purement logicielles : il suffit de concevoir son programme d'une certaine faon pour faire en sorte qu'un programme assez gros rentre dans un ordinateur ayant trs peu de mmoire. On peut citer par exemple l'overlaying . C'est compliqu, long et donne des programmes utilisables sur un ordinateur en particulier et presque aucun autre : la compatibilit de ces programmes sur d'autres ordinateurs que celui pour lequel ils ont ts conus est difficile voire impossible. Mais d'autres techniques rglent ces problmes. Leur avantage : elles sont en partie voire totalement prises en charge par notre matriel, et c'est celles-ci qu'on va sintresser. Ces solutions sont ce qu'on appelle la mmoire virtuelle.

Le principe
Le principe de la mmoire virtuelle est simple : donner aux programmes une reprsentation simplifie de la mmoire qui contient plus de mmoire qu'installe sur notre ordinateur, et qu'un programme peut manipuler sans avoir connaitre l'organisation exacte de la mmoire. La fameuse reprsentation simplifie de la mmoire dont on parle consiste simplement en une mmoire fictive, compose d'autant (voire plus) d'adresses que ce que le processeur peut adresser. Ainsi, on se moque des adresses inaccessibles, rserves aux priphriques, de la quantit de mmoire rellement installe sur l'ordinateur, ou de la mmoire prise par d'autres programmes en cours dexcution. Tout se passe comme si notre programme tait seul au monde et pouvait lire et crire toutes les adresses disponibles partir de l'adresse zro. Bien sr ces adresses sont des fausses adresses, des adresses fictives, mais c'est ces qu'on retrouvera dans notre programme : toutes les adresses de destination de nos branchements, de nos donnes (modes d'adressages), et autres ; seront ces adresses fictives.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

245/378

V ous remarquerez que notre programme a accs plus d'adresses fictives que d'adresses relles. Pour viter que ce surplus de fausse mmoire pose problme, on utilise une partie des mmoires de masse (disque durs) d'un ordinateur en remplacement de la mmoire physique manquante. Alors bien sr, cette reprsentation fictive de la mmoire, cette mmoire virtuelle, n'est pas utilisable en l'tat : on voit bien que notre programme va pouvoir utiliser des adresses auxquelles il n'a pas accs. Mais notre programme a malgr tout accs une certaine quantit de mmoire dans la mmoire relle. Pour que cette fausse mmoire devienne utilisable, on va transformer les fausses adresses de cette fausse mmoire en adresses rellement utilisables. Ces fausses adresses sont ce qu'on appelle des adresses logiques : ce seront les adresses manipules par notre programme, grce aux divers modes d'adressages vus plus haut, et qu'on retrouvera dans nos registres. Par contre, les adresses relles seront ce qu'on appelle des adresses physiques.

La MMU
Mais comment traduire ces adresses logiques en adresses physiques ?

Comme chaque fois : on rajoute un circuit. Ici, le circuit qu'on va rajouter va se charger de traduire automatiquement les adresses logiques manipules au niveau du processeur en adresses physiques qui seront envoyes sur le bus d'adresse. Un tel circuit sera appel la Memory Management Unit. Un des rles qu'elle va jouer dans notre ordinateur sera de faire la traduction adresses logiques -> adresses physiques. Et j'ai bien dit un des rles : elle en a d'autres, plus ou moins complexes. Il faut prciser qu'il existe diffrentes mthodes pour grer ces adresses logiques et les transformer en adresses physiques : les principales sont la segmentation et la pagination. La suite du tutoriel va dtailler ces deux techniques, et quelques autres.

Segmentation
La premire technique de mmoire virtuelle qu'on va aborder s'appelle la segmentation. Cette technique consiste dcouper notre mmoire virtuelle en gros blocs de mmoire qu'on appelle segments. Gnralement, on ne dcoupe pas ces blocs n'importe comment : on prfre que ce dcoupage soit logique et reflte un peu l'organisation du programme qu'on est en train de dcouper en segments. Par exemple, il est assez courant de dcouper nos programmes en plusieurs zones bien distinctes :

www.siteduzero.com

Partie 6 : Hirarchie mmoire

246/378

Segment

Utilit Il sert stocker la suite d'instructions qui consiste notre programme : il s'agit d'un segment qui rassemble tout le contenu de la mmoire programme (souvenez-vous des premiers chapitres de la partie 2). Ce segment a presque toujours une taille fixe. Le segment data contient des donnes qui occupent de la mmoire de faon permanente.

Text

Data

Ce segment Data est un segment dans laquelle on stocke des donnes dfinitivement. Impossible de librer la mmoire de ce segment pour faire de la place. En consquence, ce segment a toujours une taille fixe. Il s'agit de notre pile : celle-ci possde un segment rien que pour elle. Le Heap, ou tas, est un segment qui sert stocker des donnes, un peu comme le segment Data. Mais l'inverse de ce dernier, on peut effacer les donnes qu'il contient lorsqu'elles deviennent inutiles. Ce tas a donc une taille variable.

Stack Heap

Grosso modo, on retrouve cette organisation dans beaucoup de programmes conus pour utiliser la segmentation, quelques dtails prt. Par exemple, on peut trouver d'autres segments supplmentaires plus ou moins utiles comme des segments d'tat de tche, mais cela nous entrainerait trop loin. Comme vous le voyez, ce dcoupage est assez cohrent avec l'organisation d'un programme en mmoire.

Adresse virtuelle
Pour donner un aperu de la technique de segmentation, je vais prendre un petit exemple assez simple : la technique de segmentation telle qu'elle est utilise sur les processeurs x86. Sur ces processeurs x86, la mmoire virtuelle est bien plus grande que l'espace d'adressage du processeur. Sur un processeur 32 bits, capable d'adresser bytes de mmoire, cette mmoire virtuelle utilise des adresses de 48 bits. Cette mmoire virtuelle peut tre dcoupe en segments de taille variable, pouvant faire jusqu' maximum 4 gibi-octets. Chaque segment commence donc une adresse bien particulire : cette adresse est un multiple de 4 gibi. En clair, les 32 bits de poids faible de l'adresse de dbut d'un segment valent tous 0. En clair, tout se passe comme si un segment avait droit un espace mmoire de bits rien que pour lui, qu'il peut utiliser loisir : on en revient notre description de dpart de la mmoire virtuelle.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

247/378

Toute donne localise dans le segment peut donc tre localise partir de l'adresse de base du segment : si on connait le segment, et la position de la donne dans le segment, on peut en dduire l'adresse finale de notre donne. Pour identifier un segment, seuls les 16 bits de poids forts de l'adresse 48 bits sont utiles. Ceux-ci permettent de prciser le segment dont on parle : on les appelle le slecteur de segment. A ce descripteur de segment, on rajoute donc un offset, qui permet de dterminer la position de notre donne dans le segment. V donc quoi ressemble une adresse logique 48 bits : oici Slecteur Offset 16 bits 32 bits

Mais dans la ralit, notre processeur ne manipule que des adresses de 32 bits. Aussi, toutes les adresses manipules par notre programme seront les 32 bits de poids faible de notre adresse virtuelle (en clair, on ne garde que l'offset). Pour obtenir une valeur correcte, notre processeur gardera dans un registre quel est le segment en cours d'utilisation, pour pouvoir savoir quelle adresse logique il est en train daccder.

Relocation
Mais comment ce dcoupage en segments va-il nous aider rsoudre nos problmes concernant la gestion de la mmoire ?

Chacun de ces segments peut tre plac n'importe o en mmoire physique. C'est le premier avantage de la segmentation : un segment n'a pas d'adresse bien fixe en mmoire physique et peut tre dplac comme bon nous semble. Mais par contre, l'organisation des donnes dans un segment n'est pas modifie.

Gnralement, lorsqu'on veut charger un segment en mmoire partir du disque dur, celui-ci sera plac quelque part en mmoire RAM, une certaine adresse. C'est le systme d'exploitation qui gre le placement des segments dans la mmoire physique : il dcide o placer le segment dans la mmoire RAM.

Calcul de l'adresse physique

www.siteduzero.com

Partie 6 : Hirarchie mmoire

248/378

Pur calculer l'adresse d'une donne en mmoire physique, il nous suffit donc d'ajouter l'adresse de base de notre segment en mmoire physique, et l'offset (qui est, rappelons-le, la position de notre donne dans le segment). Il nous faut donc se souvenir pour chaque segment de son adresse de base, l'adresse laquelle il commence. Cette correspondance segment-adresse de base est stocke soit dans une table de correspondance en mmoire RAM, soit dans des registres du processeur.

Gnralement, notre processeur contient un registre qui stocke en permanence l'adresse de base du segment qu'on est en train de manipuler : il s'agit du registre de base. Il faut prciser que cette table de correspondance est unique pour chaque programme : chaque programme manipule les mmes adresses virtuelles. Ce qui fait que deux programmes peuvent manipuler des adresses logiques identiques dans leur mmoire fictive qui leur est attribue. Pourtant, les donnes correspondant ces adresses logiques seront diffrentes et seront stockes dans des adresses mmoires physiques diffrentes. Pour viter les problmes, on n'a pas le choix : il faut soit utiliser des tables de correspondances diffrentes pour chaque programme.

Allocation dynamique
Attention toutefois : nos segments peuvent avoir des tailles variables ! Certains segments peuvent ainsi grossir ou diminuer au fil du temps. Cela permet de rserver juste ce qu'il faut de mmoire au lancement d'un programme, et augmenter ou diminuer la quantit de mmoire rserve celui-ci suivant les besoins. Si notre programme a besoin de plus de mmoire quand il est en train de sexcuter, le programme peut alors demander de grossir le segment qu'il est en train d'occuper, grce une interruption logicielle spcialement conue pour. Bien sr, quand un programme n'a plus besoin d'une portion de mmoire, il peut "drserver" celle-ci et la rendre utilisable par notre systme d'exploitation en diminuant la taille du segment qu'il occupe : on dit que notre programme libre la mmoire.

Quelques problmes
Bien sr, a ne marche pas toujours. Imaginons le cas suivant : deux programmes sont lancs et sont stocks dans deux segments diffrents. Ces programmes vont alors rgulirement avoir besoin de mmoire et vont prendre de la mmoire quand ils en ont besoin. Imaginez qu'un programme aie tellement grossit qu'on en arrive la situation suivante :

www.siteduzero.com

Partie 6 : Hirarchie mmoire

249/378

Imaginez maintenant que le programme N1 aie besoin de plus de mmoire, que se passe-il ?

Je suppose que vous voyez bien qu'il y a un problme : il n'y a pas de mmoire libre la suite du programme N1, et son segment ne peut pas grossir. Pour le rsoudre, notre systme dexploitation va devoir dplacer au moins un programme dans la mmoire et rorganiser la faon dont ceux-ci sont rpartis en mmoire afin de faire de la place la suite du premier segment. Ce qui signifie que au moins un des deux segments sera dplac : a demande de faire beaucoup d'accs mmoire et prend donc pas mal de temps.

Fragmentation externe
La segmentation pose toutefois un petit problme : de la mmoire est gche un peu btement et est difficilement rcuprable. Cela vient du fait que nos segments ne sont pas "colls les uns au autres", et qu'il existe des vides de mmoires, qu'on ne peut pas forcment remplir facilement. Pour expliquer la situation, on va prendre un exemple : on lance un programme, avec 4 segments, qui voient leur taille bouger au fil du temps et sont allous par le systme d'exploitation. Leur taille augmente, et on aboutit la situation dcrite dans le schma ci-dessus.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

250/378

Comme on le voit, il reste des vides de mmoires entre les segments. Ce n'est pas un mal : si des segments veulent augmenter leur taille, il leur reste un peu de marge. Et maintenant, dans la situation dcrite par le schma du dessus, imaginez qu'on lance un programme qui a besoin de 700 mgaoctets de mmoire pour charger ses segments text et data a la suite. On aura suffisamment de mmoire libre pour les caser : on a bel et bien 1.1 gibi-octet de libre, mais aucun bloc de mmoire libre ne sera suffisamment gros pour rpondre la demande. C'est ce qu'on appelle le phnomne de fragmentation externe : on dispose de suffisamment de mmoire libre, mais celle-ci est disperse dans beaucoup de petits segments vides, qui peuvent difficilement stocker un segment eux tout seuls. Si aucun bloc de mmoire vide n'est suffisamment gros pour combler une demande d'un programme, notre systme d'exploitation va devoir regrouper les morceaux de mmoire utiliss par les diffrents programmes et les dplacer pour crer des vides plus gros. En clair, il va devoir dplacer des segments entiers dans la mmoire, ce qui prend beaucoup de temps inutilement.

Protection mmoire
La segmentation nous permet donc de relocaliser nos programmes o l'on veut en mmoire RAM. Mais la segmentation ne permet pas que cela : elle permet aussi d'interdire certaines manipulations dangereuses sur la mmoire. Gnralement, plusieurs programmes sont prsents en mme temps dans notre ordinateur. Bien sur, on ne peut, sur une machine un seul processeur, excuter plusieurs programmes en mme temps. Mais les autres programmes dmarrs par l'utilisateur ou par le systme d'exploitation, doivent absolument se partager la mmoire RAM, mme s'il ne sexcutent pas. La cohabitation de plusieurs programmes pose en effet quelques problmes. Si un programme pouvait modifier toute donne place dans la mmoire RAM de notre ordinateur, mme si cette donne a t dclare au lancement d'un autre programme, on se retrouverait rapidement avec une situation non-prvue par le programmeur. Cela a des consquences qui vont de comiques catastrophiques. Gnralement cela fini par un joli plantage. Comment viter qu'un programme accde une donne d'un autre programme ?

Trs simple : on dfinit pour chaque programme des portions de la mmoire dans laquelle il pourra crire ou lire. Le reste de la mmoire sera inaccessible en lecture et en criture, part quelques petites parties de la mmoire, partages entre diffrents programmes. Aucun autre programme ne pourra alors lire ou crire dans cette partie rserve de la mmoire. Cette gestion des droits sera prise en charge par la MMU, qui empchera aux programmes d'aller crire ou lire des donnes qu'ils n'ont pas le droit de toucher. Ces droits sont diffrents pour chaque programme et peuvent tre diffrents pour la lecture et l'criture : on peut ainsi autoriser un programme de lire une partie de la mmoire, mais pas d'y crire, ou autoriser lecture et

www.siteduzero.com

Partie 6 : Hirarchie mmoire

251/378

criture, ou interdire les deux. Toute tentative d'accs une partie de la mmoire non-autorise dclenchera ce qu'on appelle une exception matrielle (rappelez-vous le chapitre sur les interruptions) qui devra tre traite par une routine du systme d'exploitation. Gnralement, le programme fautif est sauvagement arrt et supprim de la mmoire, et un message d'erreur est affich l'cran. La segmentation va ainsi permettre d'implanter des mcanismes permettant de supprimer ces manipulations dangereuses. Bien sr, on pourrait les implmenter sans avoir utiliser la segmentation, mais ce serait plus difficile. On va voir comment la segmentation nous permettra de grer facilement cette protection de la mmoire.

Gestion des accs hors segment

Comment viter que notre programme aille lire ou crire des donnes situes en dehors du segment ?

Pour cela, il nous faut connaitre les adresses de base de fin de notre segment. L'ide est de tester si l'adresse physique calcule en ajoutant offset et adresse de base va sortir du segment et dpasser l'adresse de fin de notre segment. La solution a t d'implanter un registre limite. Ce registre contient la fameuse adresse de fin de notre segment. Quand un programme cherche accder la mmoire, l'adresse physique laquelle il veut accder va tre compare celle contenue dans ce registre limite. Si elles est plus grande, notre processeur va lever une exception matrielle qui devra tre traite par une routine de notre systme d'exploitation.

Droits d'accs
Vient ensuite la gestion des droits d'accs en lecture et en criture. Chaque segment se voit attribuer sa cration un certain nombre d'autorisations d'accs. Par exemple, le segment Text est souvent mit en lecture seule, pour viter des failles de scurit potentielles. Ces droits indiquent si l'on peut : lire ou crire dans un segment, mais aussi considrer que celui-ci contient des donnes ou des instructions : on peut ainsi excuter le contenu d'un segment ou au contraire interdire cette excution. Par exemple, le segment Text peut tre excutable : on peut considrer son contenu comme un programme, qui ne doit pas tre modifi ou lu comme le serait une donne : on peut le rendre executable only, et interdire de copier son contenu dans les registres gnraux, ou d'crire dedans. De mme, on peut dcider d'interdire de charger le contenu d'un segment dans le registre d'instruction ou le registre d'adresse d'instruction pour viter dexcuter des donnes (ce qui rend plus difficile certaines failles de scurit ou lexcution de certains virus). De plus chaque segment est attribu un programme en particulier : un programme n'a pas besoin daccder aux donnes localises dans un segment appartenant un autre programme, alors autant limiter les erreurs potentielles en spcifiant quel programme appartient un segment. Lorsqu'on veut excuter une opration interdite sur un segment, il suffira la MMU de dclencher une exception matrielle pour traiter l'erreur. Pour cela, pas de miracle : il faut retenir les autorisations pour chaque segment. Toutes ces informations sont rassembles dans ce qu'on appelle un descripteurs de segment. Celui-ci contient pour chaque segment des informations comme : son adresse de base ; son adresse de fin ou sa longueur ; les diffrentes autorisations de lecture ou d'criture ; et d'autres choses encore. Quand on dcide daccder aux donnes ou aux instructions prsentes dans un segment, ce descripteur sera charg dans des registres du processeur (dont le fameux registre de base et le registre limite). Notre processeur pourra ainsi accder toutes les informations ncessaires pour grer la protection mmoire et la traduction des adresse logiques en adresses physiques. Pour se simplifier la tache, les concepteurs de processeur et de systme d'exploitation ont dcide de regrouper ces descripteurs dans une portion de la mmoire, spcialement rserve pour l'occasion : la table des descripteurs de segment.

Partage de segments
Pour terminer cet aperu de la segmentation, on peut signaler que des morceaux de segments peuvent tre partags. Rien ne lempche : il suffit de donner deux segments des adresses de base et des longueurs convenablement tudies pour.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

252/378

Pagination
De nos jours, la segmentation est considre comme obsolte et n'est plus vraiment utilise, malgr ses atouts de taille concernant la protection mmoire. On utilise la place une autre technique de mmoire virtuelle nomme la pagination. Que ce soit avec la segmentation ou avec la pagination, notre mmoire virtuelle et notre mmoire physique sont toujours dcoupes en gros blocs de donnes. La diffrence entre ces deux techniques tient dans la taille des blocs et ce qu'on met dedans. Avec la segmentation, nos segments avaient des tailles variables et taient souvent utiliss pour stocker quelque chose de prcis : un programme, des donnes, la pile, etc. Avec la pagination, tout ces blocs ont une taille fixe et ne sont pas organiss de faon vraiment logique. Ces blocs de mmoire de taille fixe sont appels des pages mmoires. Autre dtail : la mmoire physique et la mmoire virtuelle sont dcoupes en pages. Ces pages sont toutes de la mme taille, que ce soit en mmoire physique ou dans la mmoire fictive. Cette taille varie suivant le processeur, le systme d'exploitation, et peut parfois tre rgle manuellement. Cette taille tourne souvent autour de 4 kibi-octets : c'est la taille la plus couramment employe par les systme d'exploitation comme Windows ou Linux, voire Mac OS. Toute page mmoire de la mmoire fictive peut tre place n'importe quelle page mmoire de la mmoire physique. Ainsi, une page dans la fausse mmoire sera place dans une page de la mmoire physique, qui peut tre n'importe laquelle. Une page en mmoire physique correspond donc une page dans notre fausse mmoire.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

253/378

Swapping
V ous aurez remarqus que notre mmoire physique contient moins de pages que la mmoire fictive. Pourtant, rien nempche d'utiliser plus de pages que notre mmoire contient : si on doit partager cette mmoire physique avec plusieurs programmes, ce genre de situation peut arriver, aprs tout. Il nous faut donc trouver un moyen de faire en sorte que cela ne pose pas de problme. La solution consiste utiliser des mmoires de stockage comme mmoire d'appoint : si on besoin de plus de page mmoires que la mmoire physique n'en contient, alors certaines pages mmoires vont tre dplaces sur le disque dur (ou toute autre mmoire de stockage) pour faire de la place. Cela implique que certaines pages mmoires sont localises sur le disque dur. Et l'on ne peut y accder directement : on doit d'abord les charger dans la mmoire RAM, avant de pouvoir les modifier. Il faut donc les rapatrier en mmoire RAM, ce qui peut prendre du temps. Lorsque l'on veut traduire l'adresse logique d'une page mmoire qui a t dplace sur le disque dur, notre MMU ne va pas pouvoir associer l'adresse logique une adresse en mmoire RAM. Elle va alors lever une exception matrielle, une sorte d'interruption que le processeur excute automatiquement lorsque certains vnement arrivent. Cette exception matrielle dclenchera lexcution d'une routine (souvent fournie par le systme d'exploitation) qui rapatriera notre page en mmoire RAM.

Algorithmes de gestion mmoire

Charger une donne depuis le disque dur ne pose aucun problme tant qu'il existe de la mmoire RAM disponible. On charge alors la donne dans une page qui est inoccupe et vierge de donnes : c'est juste lent, sans plus. Mais il se peut que la RAM disponible soie insuffisante pour accueillir la page mmoire charger depuis le disque dur (quand toute le RAM est pleine, par exemple). Dans ce cas, il faut dplacer le contenu d'une page mmoire localise sur le disque dur pour faire de la place pour l'autre page charger depuis le disque dur. Tout cela est effectu par la fameuse routine du systme d'exploitation dont j'ai parl plus haut. Il existe diffrents algorithmes qui permettent de dcider quelle donne supprimer de la RAM. Ces algorithmes ont une importance capitale en terme de performance. Si on supprime une donne dont on aura besoin dans le futur, il faudra recharger celle-ci, et donc excuter une interruption, accder au disque dur, charger la page, etc. Et cela prend du temps induisant une perte de performance. Pour viter cela, le choix de la page doit tre fait avec le plus grand soin. Il existe divers algorithmes pour cela. FIFO : on supprime la donne qui a t charge dans la mmoire avant toute les autres.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

LRU : on supprime la donne qui t lue ou crite pour la dernire fois avant toute les autres. LFU : on vire la page qui est lue ou crite le moins souvent compar aux autres.

254/378

Translation d'adresse
Par contre, le contenu d'une page en mmoire fictive est rigoureusement le mme que le contenu de la page correspondante en mmoire physique. Deux donnes qui se suivent l'intrieur d'une page de la mmoire fictive se suivront dans une page de la mmoire relle. Ainsi, on peut parfaitement localiser une donne dans une page par un numro, qui sera le mme que cette page soit la page en mmoire physique ou la page de la fausse mmoire. Pour numroter une case mmoire l'intrieur d'une page, on utilise quelques bits de poids fort de l'adresse (physique ou logique). Une adresse (qu'elle soit logique ou physique) se dcompose donc en deux parties : une partie qui identifie la page dans la mmoire (fictive ou physique suivant la nature de l'adresse), et un numro permettant d'identifier la donne dans la page.

Traduire notre adresse logique en adresse physique consiste simplement remplacer le numro de la page logique en un numro de page physique.

Page Table Entry

Pour faire cette traduction, on n'a pas vraiment le choix : il faut se souvenir des correspondances entre page en mmoire physique et page en mmoire fictive pour toutes les pages. Ces correspondances sont stockes dans une sorte de table, nomme la table des pages. Ainsi, pour chaque numro (ou chaque adresse) de page logique, on stocke le numro ou l'adresse de base de la page correspondante en mmoire physique.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

255/378

Il faut prciser que cette table des pages est unique pour chaque programme : chaque programme manipule les mmes adresses virtuelles. Ce qui fait que deux programmes peuvent manipuler des adresses logiques identiques dans leur mmoire fictive qui leur est attribue. Pourtant, les donnes correspondant ces adresses logiques seront diffrentes et seront stockes dans des adresses mmoires physiques diffrentes. Pour viter les problmes, on n'a pas le choix : il faut soit utiliser des tables des pages diffrentes pour chaque programme. Cette table des pages est souvent stocke dans la mmoire RAM, un endroit bien prcis, connu du processeur. Accder la mmoire ncessite donc daccder d'abord la table des pages en mmoire, puis de calculer l'adresse de notre donne, et enfin daccder la donne voulue.

TLB
Pour viter d'avoir lire la table des pages en mmoire RAM chaque accs mmoire, les concepteurs de processeurs ont dcids d'implanter une petite mmoire cache dans le processeur, qui stocke une partie de la table des pages : gnralement, on conserve dans ce cache le morceau de la table des pages qui sert traduire les dernires adresses ayant t accdes. Cette mmoire cache s'appelle le Translation Lookaside Buffer, aussi appel TLB. Ainsi, notre processeur va vrifier si le morceau de la table des pages stock dans ce TLB permet de calculer l'adresse physique laquelle accder. Si c'est le cas, le processeur n'a pas accder la mmoire RAM et va lire directement la donne depuis ce TLB. Mais dans le cas contraire, l'accs la RAM est invitable. Cet accs est gr de deux faon : soit le processeur gre tout seul la situation ; soit il dlgue le traitement de la situation un programme particulier ou au systme dexploitation. Dans le premier cas, le processeur est conu pour lire lui mme le contenu de la page des tables en mmoire et y trouver la bonne correspondance dans celle-ci. Une fois trouve, le processeur va alors copier celle-ci dans le TLB et recalculer l'adresse physique. Dans le second cas, si l'adresse cherche n'est pas dans le TLB, le processeur va lever une exception matrielle qui excutera une routine d'interruption charge de grer la situation.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

256/378

Allocation dynamique
Comme avec la segmentation, nos programmes peuvent demander au systme d'exploitation l'accs un peu plus de mmoire de temps autre. Si jamais un programme a besoin de plus de mmoire, notre systme d'exploitation va lui rserver une page mmoire supplmentaire, qu'il pourra manipuler loisir. Bien sr, si notre programme n'a plus besoin de la page qui lui a t confie, il peut la librer : elle sera alors disponible pour n'importe quel autre programme qui en aurait besoin. Il faut remarquer que le problme mentionn avec des segments conscutifs, "qui se touchent", n'apparait pas avec la pagination. On peut fragmenter notre programme dans des pages disperses dans la mmoire sans aucun problme, ce qui fait qu'on n'est pas oblig de dplacer des pages mmoires pour compacter la mmoire libre. Cela fait qu'avec la pagination, il n'y a pas vraiment de fragmentation externe, vu qu'on peut fragmenter notre programme dans des pages diffrentes pour utiliser au mieux la mmoire libre disponible au lieu de tout devoir caser dans un seul gros segment. Mais cela nempche pas certaines pertes de mmoire utilisable. En effet, quand un programme demande un surplus de mmoire, le programme qui gre la gestion de la mmoire (c'est souvent le systme d'exploitation), va rserver une page mmoire complte : il ne peut pas faire autrement, mme si notre programme n'a besoin que de quelques octets. Si un programme a besoin d'une quantit plus petite que ce que la page lui offre, une partie de notre page sera rellement utilise pour stocker des donnes. Par exemple, un programme voulant rserver 2 kibi-octets se verra attribuer le double (en supposant une page de 4 kibi-octets) : de l'espace mmoire est perdu. Et la mme chose arrive lorsque notre programme a besoin d'une quantit de mmoire qui n'est pas multiple de la taille d'une page. Si un programme a besoin de 5 kibi-octets, il se verra attribuer deux pages de 4 kibi-octets : 3 kibi-octets ne serviront rien. Ce genre de pertes du au fait que la mmoire est alloue par pages s'appelle la fragmentation interne.

Protection mmoire
La pagination permet elle aussi de protger la mmoire et son contenu de manipulations potentiellement dangereuses sur nos pages ou sur leur contenu. Avec la pagination, on peut parfaitement autoriser ou interdire la lecture ou l'criture, voir lexcution du contenu d'une page. Pour cela, il suffit de rajouter des bits dans la table des pages : chaque numro de page virtuelle/physique se verra attribuer des droits, reprsents par des bits d'une certaine valeur. Suivant la valeur de ces bits, la page sera accessible ou non, en lecture, en criture, excutable, etc. De plus chaque page est attribue un programme en particulier : un programme n'a pas besoin daccder aux donnes localises dans une page rserve par un autre programme. Autant limiter les erreurs potentielles en spcifiant quel programme appartient une page. Pour cela, des bits permettant didentifier le programme possesseur de la page sont ajout en plus des adresses et des bits de gestion des droits d'accs en lecture/criture dans la table des pages.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

257/378

Les mmoires caches

Les mmoires caches sont des mmoires intercales entre le mmoire et un processeur ou un priphrique. Ces mmoires peuvent contenir assez peu de donnes et sont assez rapides. Elles sont souvent fabriques avec de la mmoire SRAM. Ces mmoires sont facultatives : certains processeurs ou priphriques se passent compltement de mmoires caches alors que d'autres en ont plusieurs. Dans ce chapitre, on va parler des caches ddis au processeur, et pas des caches prsents dans les priphriques. Mais quoi sert ce cache ddi au processeur et pourquoi on en a besoin ?

Sans lui, on se croirait l'age de pierre tellement nos PC seraient lents ! Il faut dire que la mmoire d'un ordinateur est quelque chose de vraiment trs lent, compar un processeur. Cela pose problme lorsque le CPU cherche accder la mmoire (aussi bien en lecture qu'en criture). Le temps mit pour enregistrer ou rcuprer des donnes depuis la mmoire est du temps durant lequel le processeur nexcute pas d'instructions (sauf cas particuliers impliquant un pipeline et l'excution out-oforder). Il a bien fallu trouver une solution pour diminuer le plus possible ce temps d'attente, et on a dcid d'intercaler une mmoire entre le CPU et la mmoire. Comme cela, le processeur accde directement une mmoire cache trs rapide plutt que d'accder une mmoire RAM qui rpondra de toute faon trop tard.

Accs au cache
Notre mmoire cache est, comme toutes les autres mmoires, divises en cases mmoires, qu'on peut modifier individuellement. Dans un cache, ces cases mmoires sont regroupes en blocs de taille fixe qu'on appelle des lignes de cache. Gnralement, ces blocs ont une taille assez grosse compar aux cases mmoires : cela peut varier de 64 256 octets. Petite prcision : impossible de copier 8 bits individuels de la RAM vers le cache, on est oblig de transfrer une donne du cache vers la mmoire (ou l'inverse), ligne de cache par ligne de cache. Par contre, chaque case mmoire d'une ligne de cache peut tre accde individuellement. En clair, on peut modifier une case mmoire l'intrieur d'une ligne sans problme. Le regroupement en lignes de cache ne compte que pour les transferts entre mmoire RAM et cache, pas pour les transferts entre cache et registres.

Accs au cache
Comme je l'ai dit et rpt plus haut, une case mmoire du cache ne possde pas d'adresse. Aussi bizarre que cela puisse paraitre, nos mmoires caches ne sont pas les seules mmoires ne pas pouvoir tre adressables, mais passons. Cela a une consquence : notre processeur ne va pas accder directement la mmoire cache. Il peut juste demander une lecture ou criture dans la RAM, qui aboutira ou non une lecture/criture partir du cache. Notre processeur va donc accder la mmoire RAM et cet accs mmoire sera intercept par le cache, qui vrifiera si la donne demande est prsente ou non dans le cache. Tout se passe comme si le cache n'existait pas pour le processeur. Et vu que notre processeur ne peut pas grer lui-mme le cache, on se doute bien que notre cache se "gre tout seul" : il possde un ou plusieurs circuits lectroniques conus pour grer le cache automatiquement. Les donnes prsentes dans le cache sont t (pr)charges depuis la mmoire : toute donne prsente dans le cache est la copie d'une donne en mmoire RAM.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

258/378

On a donc une correspondance entre une ligne de cache et une adresse mmoire, mmorise par les circuits lectroniques qui s'occupent de la gestion de la mmoire cache.

Contenu de la ligne de cache Adresse mmoire correspondante 0100 1110 1001 1011 1111 0000 1111 1111 1100 1100 1010 1001 ... 1001 0000 0000 0001 0110 1111 0101 1011 0000 0000 1000 0000 ...

Lorsqu'un processeur cherche accder la mmoire (que ce soit pour une lecture ou une criture), celui-ci va envoyer l'adresse mmoire laquelle il veut accder vers un circuit qui permet d'crire ou de lire en mmoire RAM. Cette adresse va d'abord tre intercepte par les circuits de gestion du cache, qui vont vrifier si cette adresse mmoire correspond une ligne de cache. Si c'est le cas, la donne voulue est prsente dans le cache : on a un cache hit et on accde la donne depuis le cache. Sinon, le donne n'est pas dans le cache : on a un cache miss et on est oblig daccder la RAM ou de recopier notre donne de la RAM dans le cache. Le nombre de cache miss par nombre d'accs mmoire est appel le hit ratio . Plus celui-ci est lev, plus on accde au cache la place de la RAM et plus le cache est efficace. Ce hit ratio varie beaucoup suivant le processeur, l'organisation des caches, ou le programme en cours dexcution : de nombreux paramtres peuvent influencer celui-ci.

criture dans un cache

La lecture d'une donne prsente dans le cache ne pose aucun problme (sauf cas particuliers) : il suffit d'accder au contenu du

www.siteduzero.com

Partie 6 : Hirarchie mmoire

259/378

cache, et on reoit la donne voulue assez rapidement. Mais les choses changent pour l'criture. L'criture dans un cache fait face diverses situations, qu'il faut grer au mieux. Pour grer certaines situations embarrassantes, deux stratgies d'critures sont couramment implmentes dans les circuits de gestion du cache. Ces deux stratgies sont le Write Back ; et le Write Throught.

Write back
Si la donne qu'on veut mettre jour est prsente dans le cache, on crit dans celui-ci sans crire dans la mmoire RAM : on attend que la donne soit efface du cache pour l'enregistrer en mmoire. Cela vite de nombreuses critures mmoires inutiles. Mais peut poser des problmes dans les architectures multiprocesseurs ! Si deux processeurs doivent manipuler la mme donne, des cas litigieux peuvent survenir. Imaginons que deux processeurs manipulent une donne : ceux-ci ont une copie de la donne dans leur cache qu'ils manipulent et modifient loisir. Si un processeur modifie cette copie de la donne et que celle-ci est enregistre dans son cache ou en mmoire, elle sera alors diffrente de celle prsente dans le cache de l'autre processeur. Ce qui fait qu'un processeur peut continuer manipuler une donne prime qui vient d'tre mise jour par l'autre processeur. Hors, un processeur doit toujours viter de se retrouver avec une donne prime et doit toujours avoir la valeur correcte dans ses caches : cela s'appelle la cohrence des caches. La seule solution pour arriver un rsultat correct est d'utiliser des mcanismes permettant de faire en sorte que ce genre de cas n'arrivent pas. Ces mcanismes se chargent de dterminer quelles sont les donnes primes, et ensuite les remplacer par des donnes valides. Ces mcanismes se chargent de faire mettre jour les donnes dans les diffrents caches, en copiant les donnes mises jour du cache d'un processeur vers un autre, en passant ventuellement en se servant de la mmoire comme intermdiaire. Les caches Write Back rendent plus difficile l'implantation de ces mcanismes de gestion de la cohrence des caches. C'est pourquoi il existe un autre type de cache : le cache Write Trought ; mieux adapt ce genre de situations.

Write Through
Toute donne crite dans le cache est crite en mme temps dans la mmoire RAM. Ces caches sont appels No Write Allocate : si on souhaite crire en mmoire une donne qui n'a pas t prcharge dans le cache, on crit en mmoire RAM, mais pas dans le cache. Leur utilit ? Les ordinateurs avec plusieurs processeurs, comme dit plus haut. Mais cela a fatalement un cout en terme de performance. Ces caches ont tendance commettre beaucoup d'critures dans la mmoire RAM, ce qui peut saturer le bus reliant le processeur la mmoire. De plus, on ne peut crire dans ces caches lorsqu'une criture en RAM a lieu en mme temps : cela forcerait effectuer deux critures simultanes, en comptant celle impose par l'criture dans le cache. Dans ces conditions, on doit attendre que la mmoire RAM soit libre pour pouvoir crire dans notre cache. Pour viter ces temps d'attentes, certains processeurs intgrent un Write Buffer : une espce de mmoire tampon dans laquelle on place temporairement les donnes transfrer du cache vers la RAM en attendant que la RAM soit libre. Ces donnes crire sont places dans l'ordre d'arriv dans ce Write Buffer et sont automatiquement crites en mmoire RAM quand celle-ci est libre. On n'a pas se soucier du fait que la mmoire soit occupe vu qu'on crit les donnes crire non pas en RAM, mais dans ce Write Buffer : on peut continuer crire dedans tant que celui-ci n'est pas plein, vitant les temps d'attente dus la RAM.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

260/378

Par souci d'efficacit, les caches Write Trough implmentent parfois des techniques de Write Combining dans le Write Buffer. Le Write Combining est une technique assez simple comprendre : si jamais deux critures sont en attente dans le Write Buffer, seule la plus rcente est prise en compte, et l'ancienne est abandonne. Comme a, au lieu d'crire une donne avant de la remplacer immdiatement aprs par une autre, autant crire directement la donne la plus jour et ne pas crire l'ancienne inutilement. Cela fait un peu de place dans le Write Buffer, et lui permet d'accumuler plus d'criture avant de devoir bloquer le cache. Et oui, une fois le Write Buffer plein, le cache n'est plus accessible en criture : il n'y a plus de place pour une criture supplmentaire. On doit donc bloquer le cache, histoire d'attendre qu'il y aie un peu de place dans le Write Buffer pour accueillir une nouvelle criture.

Cache bloquant et non-bloquant

Un cache bloquant est un cache auquel le processeur ne peut pas accder aprs un cache miss. Il faut alors attendre que la donne voulue soit lue ou crire en la RAM avant de pouvoir utiliser de nouveau le cache. Un cache non-bloquant n'a pas ce problme. On peut l'utiliser mme immdiatement aprs un cache miss. Cela permet d'accder la mmoire cache en attendant des donnes en provenance de la mmoire. Tous les caches non-bloquants peuvent ainsi permettre de dmarrer une nouvelle lecture ou criture alors qu'une autre est en cours. On peut ainsi excuter plusieurs lectures ou critures en mme temps : c'est ce qu'on appelle du Memory Level Parallelism. Ces caches non-bloquants peuvent aussi permettre de pipeliner nos accs au cache. Mais cela ne marche que tant qu'on ne veut pas trop faire d'accs au cache : au-del d'un certain nombre, le cache va saturer et va dire "stop". Il ne peut supporter qu'un nombre limit d'accs mmoires simultans (pipelins). Pour votre information, le Write Buffer permet un cache Write Trough d'tre non-bloquant ! En effet, sans lui, le cache serait immobilis chaque criture : on devrait copier la donne qui a t crite dedans du cache vers la mmoire, ce qui ncessite d'utiliser le cache. Avec le Write Buffer, la donne crire en RAM est lue non pas depuis le cache,mais depuis le Write Buffer, ce qui libre le cache et le rend accessible aussi bien en lecture qu'en criture. C'est pour cela qu'on les a aussi ajout sur les caches Write Back.

Localit spatiale et temporelle

Mais pourquoi les caches fonctionnent ?

La question peut paraitre compltement stupide, mais pour expliquer cela correctement, il faut prendre conscience de quelques proprits que beaucoup de programmes ont tendance respecter.

Localit temporelle
Un programme a tendance rutiliser les instructions et donnes qui ont ts accdes dans le pass : c'est la localit temporelle. Bien videment, cela dpend du programme, de la faon dont celui-ci est programm et accde ses donnes et du traitement qu'il fait, mais c'est souvent vrai en gnral. Lorsqu'on excute une instruction ou qu'on accde donne pour le premire fois, celle-ci (linstruction ou la donne) n'a pas encore t charge dans le cache. Le cache miss est invitable : ce genre de cache miss s'appelle un Cold Miss. Mais on peut tre presque sr que cette donne sera rutilise plus tard, et on pourra alors utiliser la version de la donne charge dans le cache au lieu d'accder en mmoire. Il suffit alors de garder cette donne dans le cache : d'aprs le principe de localit temporelle, elle sera surement rutilise plus tard et sera alors disponibles dans le cache. videment, cette technique des limites. Si on doit accder beaucoup de donnes, le cache fini par tre trop petit pour conserver les anciennes donnes : de nouvelles donnes sont ajouts dans ce cache au fil du temps, et le cache doit bien finir par faire de la place en supprimant les anciennes donnes (qui ont peu de chances d'tre rutilises). Ces anciennes donnes prsentes en cache, qui peuvent tre accdes plus tard, devront cder la place d'autres. Elles vont quitter le cache et tout prochain accs cette donne mnera un cache miss. C'est ce qu'on appelle un Capacity Cache Miss. Les seules solutions pour viter cela consistent augmenter la taille du cache, faire en sorte que notre programme prenne moins de mmoire cache et amliorer la localit du programme excut. Sachez qu'un programmeur peut parfaitement tenir compte de la localit spatiale lorsqu'il programme pour gagner normment en performance. Pour donner un exemple, les boucles sont des structures de contrle qui respectent le principe de localit temporelle : les instructions d'une boucle seront r-excutes plusieurs fois.

Localit spatiale
Autre proprit : un programme qui s'excute sur un processeur tendance utiliser des instructions et des donnes qui ont des

www.siteduzero.com

Partie 6 : Hirarchie mmoire

adresses mmoires trs proches, c'est la localit spatiale.

261/378

Pour donner un exemple, les instructions d'un programme sont places en mmoire dans lordre dans lequel on les excuts : la prochaine instruction excuter est souvent place juste aprs l'instruction en cours (sauf avec les branchements). La localit spatiale est donc respecte tant qu'on a pas de branchements qui renvoient assez loin dans la mmoire (appels de sousprogrammes). De plus, on ne charge pas des donnes individuelles dans notre cache, mais des lignes de cache compltes. On charge donc la donne voulue, mais aussi des donnes/instructions situe dans des adresses mmoires proches : cela permet de gros gains lorsque le principe de localit spatiale est respect.

L'influence du programmeur
De nos jours, le temps que passe le processeur attendre la mmoire devient de plus en plus un problme au fil du temps, et grer correctement le cache est une ncessit, particulirement sur les processeurs multi-cores. Il faut dire que la diffrence de vitesse entre processeur et mmoire est tellement importante que les Cache Miss sont trs lents compares aux instructions machines usuellement employes : alors qu'une simple addition ou multiplication va prendre entre 1 et 5 cycles d'horloge, un cache miss fera plus dans les 400-1000 cycles d'horloge. Tout ce temps sera du temps de perdu que notre processeur tentera de remplir avec des instructions ayant leurs donnes disponibles (dans un registre voire dans le cache si celui-ci est non-bloquant), mais cela a une efficacit limite. Autant dire que supprimer des Caches Miss sera beaucoup plus efficace que virer des instructions de calcul normales. Bien videment, optimiser au maximum la conception des caches et de ses circuits ddis amliorera lgrement la situation, mais n'en attendez pas des miracles. Il faut dire qu'il n'y a pas vraiment de solutions anti-Cache Miss qui soit facile implmenter. Par exemple, changer la taille du cache pour contenir plus de donnes aura un effet dsastreux sur son temps d'accs qui peut se traduire par une baisse de performance. Par exemple, les processeurs Nehalem d'Intel ont vus leurs performances dans les jeux vidos baisser de 2 3 % malgr de nombreuses amliorations architecturales trs volues : la latence du cache L1 avait augmente de 2 cycles d'horloge, rduisant nant de nombreux efforts d'optimisations architecturales. Non, une bonne utilisation du cache (ainsi que de la mmoire virtuelle) repose en ralit sur le programmeur qui doit prendre en compte les principes de localits vus plus haut ds la conception de ses programmes. La faon dont est conue un programme joue normment sur sa localit spatiale et temporelle. Un programmeur peut parfaitement tenir compte du cache lorsqu'il programme, et ce aussi bien au niveau : de son algorithme : on peut citer l'existence des algorithmes cache oblivious ; du choix de ses structures de donnes : un tableau est une structure de donne respectant le principe de localit spatiale, tandis qu'une liste chaine ou un arbre n'en sont pas (bien qu'on puisse les implmenter de faon limiter la casse); ou de son code source : par exemple, le sens de parcourt d'un tableau multidimensionnel peut faire une grosse diffrence. Cela permet des gains trs intressants pouvant se mesurer avec des nombres deux ou trois chiffres. Je vous recommande, si vous tes programmeur, de vous renseigner le plus possible sur les optimisations de code ou algorithmiques qui concernent le cache : il vous suffira de chercher sur Google. Quoiqu'il en soit, il est quasiment impossible de prtendre concevoir des programmes optimiss sans tenir compte de la hirarchie mmoire. Et cette contrainte va se faire de plus en plus forte quand on devra passer aux architectures multicurs. Il y a une citation qui rsume bien cela, prononce par un certain Terje Mathisen. Si vous ne le connaissez pas, cet homme est un vieux programmeur (du temps durant lequel on codait encore en assembleur), grand gourou de loptimisation, qui a notamment travaill sur le moteur de Quake 3 Arena. Citation : Terje Mathisen

almost all programming can be viewed as an exercise in caching

Programmeurs, faites de cette citation votre manire de programmer !

Prefetching
J'ai mentionn plus haut le principe de localit spatiale, qui stipule que nos programmes ont tendance accder des donnes proches en mmoire. Pour profiter au maximum de ce principe de localit spatiale, il est plutt avantageux de dcider de prcharger l'avance les instructions ou donnes proches de celles charges il y a peu : on permet au processeur de trouver plus souvent les donnes qu'il cherche dans le cache. Ce prchargement s'appelle le prefetching, et peut tre effectu par le programmeur ou directement par le processeur. Le tout est de dterminer quelle donne prcharger, et quand ! Certains processeurs mettent disposition du programmeur une instruction spciale capable de prcharger des donnes partir d'une certaine adresse. Cela permet aux programmeurs de grer quelque peu le contenu du cache. Le problme, c'est qu'il faut programmer en assembleur pour pouvoir en profiter. Et soyons franc, les programmeurs actuels refusent de programmer en assembleur ou d'utiliser ces instructions dans leurs programmes, pour des raisons de portabilit.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

262/378

Mais il existe une autre solution : laisser le processeur prcharger lui-mme les donnes. Pour ce faire, celui-ci contient souvent un circuit nomm prefetcher qui s'occupe de prcharger des donnes/instructions. Presque tous les processeurs grand public actuels possdent un prefetcher. Il faut dire que les gains de performances apport par ce circuit sont assez impressionnants : se priver d'un tel avantage serait du suicide. Qui plus est, on peut utiliser la fois des instructions de prefetch et un prefetcher matriel intgr au processeur : les deux solutions en sont pas incompatibles. Nanmoins, ce prefetcher n'est pas prsent sur tous les processeurs car son utilisation peut parfois diminuer les performances dans certains cas bien particuliers : il augmente le nombre d'accs mmoire et qui plus est, il peut se tromper et gaspiller des accs mmoire en prchargeant des donnes inutiles. Mais comment ce prefetcher peut-il fonctionner ?

Tout d'abord, il faut prciser qu'il existe plusieurs types de prefetchers. Certains sont assez rudimentaires, tandis qu d'autres sont plus volus, plus efficaces.

Prefetchers squentiels
Commenons par les prefetcher squentiels. Ces prefetchers se contentent de prcharger les donnes immdiatement conscutives de la donne venant tout juste d'tre lue ou crite.

Les Prefetchers de ce type sont vraiment stupides et ne fonctionnent que lorsqu'on accde des donnes conscutives en mmoires, les unes aprs les autres. Mine de rien, ce genre d'accs la mmoire est assez courant : cela arrive souvent quand on doit manipuler des tableaux. Ces tableaux, vus il y a pas mal de chapitres, sont en effet couramment utiliss par les programmeurs, et il est assez courant de parcourir nos tableaux lment par lment.

One Block Lookahead

Le plus simple de ces Prefetchers sont ceux qui utilise le Prefetching de type One Block Lookahead. Le terme est barbare, je me doute. Mais le pricipe est trs simple. Cela consiste simplement prcharger le bloc de mmoire qui suit. Ainsi, si vous accdez un bloc de mmoire, le Prefetcher commencera charger le bloc immdiatement suivant le plus tt possible.

Nanmoins, cette technique peut simplmenter de deux faons diffrentes. Tout dpend de quand on Prefetche. La premire

www.siteduzero.com

Partie 6 : Hirarchie mmoire

263/378

solution consiste Prefetcher le bloc suivant que lors d'un cache miss. Ainsi, si j'ai un cache miss qui me force charger le bloc B dans le cache, le Prefetcher chargera le bloc immdiatement suivant avec.

Autre solution : chaque accs un bloc de mmoire dans le cache, on charge le bloc de mmoire immdiatement suivant. Pour cela, on doit mmoriser quelle est la dernire ligne de cache qui a t accde. Cela se fait en marquant chaque ligne de cache avec un bit spcial, qui indique si cette ligne a t accde lors du dernier cycle d'horloge. Ce bit vaut 1 si c'est le cas, et vaut 0 sinon. Ce bit est automatiquement mit zro au bout d'un certain temps (typiquement au cycle d'horloge suivant). Le Prefetcher se contentera alors de charger le bloc qui suit la ligne de cache dont le bit vaut 1.

K-Bloc Lookahead Prefetching

Ce qui peut tre fait avec un seul bloc de mmoire peut aussi l'tre avec un nombre de bloc plus grand, fix une bonne fois pour

www.siteduzero.com

Partie 6 : Hirarchie mmoire

264/378

toute. Rien nempche de charger non pas un, mais deux ou trois blocs conscutifs dans notre mmoire cache. Ce qu'on a dit plus haut s'adapte alors. Mais attention : le nombre de blocs de mmoire chargs dans le cache est fixe : il ne varie pas. Le processeur va ainsi charger uniquement les 2, 3, etc; blocs conscutifs suivants. Et le nombre de blocs prchargs est toujours le mme. Cela fonctionne bien si l'on utilise des donnes avec une bonne localit spatiale. Mais dans le cas contraire, cette technique fonctionne nettement moins bien et prcharge beaucoup de blocs inutiles dans le cache. En comparaison, la technique qui ne charge qu'un seul bloc fonctionne nettement mieux dans ces cas l.

Adaptative Prefetching
Pour limiter la casse, on peut amliorer notre Prefetcher de faon ce que celui-ci puisse faire varier le nombre de blocs de mmoire prchargs dans le cache. Pour cela, le Prefetcher va calculer une moyenne du nombre de blocs prchargs qui ont ts utiles. Ce calcul de cette moyenne se fera sur un chantillon contenant les N derniers blocs prchargs, histoire d'avoir une estimation locale. En clair : il va calculer le rapport entre le nombre de blocs qu'il a prcharg dans le cache, et le nombre de ces blocs qui ont ts accds. Si jamais ce rapport diminue trop, le Prefetcher dcidera alors de prcharger moins de blocs en une fois. Le processeur peut mme dcider de dsactiver temporairement le Prefetching si jamais le nombre de blocs prchargs utilement tombe trop prt de zro. Par contre, si jamais ce rapport dpasse une certaine limite, le Prefetcher dcidera d'augmenter le nombre de blocs prcharger.

Quand Prefetcher ?
V ous aurez aussi remarqu que ces Prefetcher ne fonctionnent que pour des accs des zones conscutives de la mmoire. Le seul problme, c'est que beaucoup d'accs mmoire ne se font pas des zones de mmoire proches. L'utilisation d'un Prefetcher squentiel est alors contre-productive. Pour limiter la casse, les Prefetcher sont capables de reconnaitre les accs squentiels et les accs problmatiques. Il suffit de garder un historique des derniers accs mmoires et de voir s'ils accdent des zones conscutives de la mmoire. Si c'est le cas, le Prefetcher prefetche, et dans le cas contraire, il ne prefetche pas.

History based prefecther

D'autres prefetchers sont un peu plus intelligents et sont capables de dduire quoi prefetcher en fonction des accs mmoires effectus juste avant. A partir de ces accs, ils peuvent voir s'il n'y a pas des rgularits plus ou moins visibles dans ces accs qui pourraient les aider dduire quelle sera la prochaine donne accde. Ces prefetchers doivent pour cela conserver un historique des accs mmoires effectus prcdemment. Pour ce faire, ils utilisent une sorte de mmoire, qui stocke les dernires adresses mmoires accdes, qu'on appelle la Reference Prediction Table.

Accs en stride
Les premiers prefetchers de ce type sont ceux qui sont capables de grer les accs en stride. Pour comprendre quoi ils servent, revenons sur les prefetchers squentiels. Les prefetcher fonctionnent bien quand on utilise des tableaux. Mais il arrive que les programmeurs n'accdent qu' certains lments du tableaux, tous spars par une mme distance. Par exemple, si on fait des calculs de gomtrie dans l'espace, on peut trs bien ne vouloir traiter que les coordonnes sur l'axe des x, sans instructionner sur l'axe des y ou des z. Dans ce genre de cas les accs mmoires ressemblent ceci :

On le voit, ces accs se font sur des donnes spares par une distance constante. On appelle de tels accs des accs en kstride, avec k la distance entre deux donnes accdes. Avec ce genre d'accs, un prfecther squentiel a tendance faire son travail et va charger des donnes inutiles (en blanc), situes entre les donnes utiles (celles en jaune). Cela fait pas mal de cache gaspill, et parfois, on peut avoir des baisses de performances : le processeur peut trs bien accder une donne utile alors que le prefetcher ne l'a pas encore charge, n'ayant pas fini de prcharger les donnes prcdentes inutiles. Pour plus d'efficacit, de nouveaux prefetchers durent invents, capables de charger uniquement les donnes utiles.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

265/378

Nanmoins, il faut savoir que ces prefetchers ne peuvent fonctionner que si les accs la mmoire sont assez rapprochs: si les donnes sont trop loignes en mmoire, le prefecther ne peut rien faire et ne prchargera pas correctement les donnes. En dessous de cette limite, gnralement, toutes les distances sont supportes. Le prefecther peut ainsi choisir s'il faut prcharger les donnes situes 250 adresses plus loin ou 1024 adresses plus loin, de faon sadapter le plus possible la situation. Toutes les distances intermdiaire entre 0 et la limite maximale supportes par le prefetcher sont possibles.

Un peu mieux
Le gain apport par les prefetchers capable de prdire des accs en stride est apprciable. Mais on pourrait certainement faire mieux. Par exemple, on peut vouloir faire en sorte que nos prefetchers fonctionnent la perfection sur des accs cycliques ou rptitifs. Exemple d'accs rptitifs.

Pour cela, on a invent des prefetchers plus volus, capables de ce genre de prouesses. Il en existe de plusieurs types, avec des performances diffrentes, mais on en parlera pas ici : le principe de fonctionnement de ces prefetchers est assez compliqu, et je ne suis pas sur que vous parler de chaines de Markov puisse vous intresser. Mais malheureusement, ces prefecthers possdent les dfauts des prefecthers prcdents : si on effectue des accs pas vraiment rguliers, notre prefetcher ne peut rien faire : il n'est pas devin.

Le Futur
Les techniques vues au-dessus sont celles qui sont couramment utilises dans les processeurs actuels. Mais il en existe d'autres, qui n'ont pas encore ts utilises couramment dans nos processeurs. Il existe ainsi des prefetchers plus volus, capables de dcider quelle donne ou instruction charger en utilisant des mthodes plus compliques. Ces prefetchers essayent de trouver des tendances, pas forcment rptitives, dans les accs mmoires prcdents, et essayent de dduire quelle seront les adresses manipules prochainement en effectuant des calculs statistiques plus ou moins volus sur ceux-ci.

Runahead
Enfin, il existe une dernire mthode purement matrielle pour prcharger nos donnes. Il s'agit du prchargement anticip. Cette technique est utile dans le cas o un processeur doit arrter lexcution de son programme parce que celui-ci attend une donne en provenance de la mmoire. En clair, cette technique est utile si un cache miss eu lieu et que le processeur n'est pas conu pour pouvoir continuer ses calculs dans de telles conditions (pas de caches non-bloquants, pas dexcution Out Of Order , etc). Dans un cas pareil, le processeur est cens devoir stopper intgralement lexcution de son programme. Mais la place, on va continuer lexcution des instructions suivantes de faon spculative : on les excute, mme si on n'est pas cens avoir ce droit. Si elles accdent la mmoire, on laisse ces accs sexcuter (sauf en criture pour viter de modifier des donnes alors qu'on n'aurait pas du): cela permettra d'effectuer des accs en avance et donc de prcharger les donnes qu'elles manipulent. On continue ainsi tant que l'instruction qui a stopp tout le processeur a enfin reue sa donne. Le seul truc, c'est que tout doit se passer comme si ces instructions excutes en avance n'avaient jamais eu lieu. Dans le cas contraire, on a peut-tre excut des instructions qu'on aurait peut-tre pas du, et cela peut avoir modifi des registres un peu trop tt, ou mis jour des bits du registres d'tat qui n'auraient pas du tre modifi ainsi. Il faut donc trouver un moyen de remettre le processeur tel qu'il tait quand le cache miss a eu lieu. Pour cela, le processeur doit sauvegarder les registres du

www.siteduzero.com

Partie 6 : Hirarchie mmoire

266/378

processeur avant dexcuter spculativement les instructions suivantes, et les restaurer une fois le tout termin. Qui plus est, il vaut mieux viter que ces instructions excutes en avance puissent modifier ltat de la mmoire : imaginez qu'une instruction modifie une ligne de cache alors qu'elle n'aurait pas du le faire ! Pour cela, on interdit ces instructions d'crire dans la mmoire. Les processeurs qui utilisent ce genre de technique sont redoutablement rares l'heure o j'cris ce tutoriel. On trouve pourtant quelques articles de recherche sur le sujet, et quelques universitaires travaillent dessus. Mais aucun processeur ne prefetche ses donnes ainsi. Il y a bien le processeur Rock de la compagnie Sun, qui aurait pu faire l'affaire, mais celui-ci a t annul au dernier moment.

Prefetching des instructions

Au fait : sur certains processeurs, on utilise deux prefetchers spars : un pour les instructions, et un autre pour les donnes. Cela permet d'adapter plus facilement les stratgie de prchargement. En effet, les instructions ont parfois besoin de techniques de prchargement spcialises qu'on va voir dans ce qui suit. Les prefetchers spcialiss pour les instructions peuvent donc se contenter de techniques de prfetching adaptes, assez simples, tandis que ceux spcialiss pour les donnes peuvent utiliser des techniques plus compliques. Cela vite au prefetcher de confondre accs aux instructions et accs aux donnes : si jamais le prefetcher confond un accs une instruction et utilise une technique pas adapte, cela pourrait lui faire rater un prchargement.

Prefetching squentiel, le retour !

Le prefetching squentiel est parfaitement adapt au prchargement des instructions d'un programme, vu que ses instructions sont places les unes aprs les autres en mmoire. Nanmoins, il arrive que dans certains cas, le processeur doivent sauter un endroit diffrent du programme, et ne passe pas directement l'instruction conscutive en mmoire : lorsque l'on excute un branchement. Avec un prefetcher purement squentiel, on peut se retrouver avec quelques problmes lorsque l'on excute un branchement : celui-ci aura tendance prcharger les instructions situe aprs le branchement, qui ne sont pas cense tre utilises si le branchement renvoie le processeur ailleurs.

Les branchements qui posent ce genre de problmes sont : tous les branchements inconditionnels, et notamment les appels et retour de sous-programmes, ainsi que les branchements conditionnels pris (qui envoient le processeur ailleurs, et non la suite du programme). Autant le dire tout de suite : ils sont assez nombreux.

Target Line Prefetching

Il serait judicieux de trouver des moyens qui permettent de limiter la casse. Pour ce faire, il faudrait trouver un moyen de savoir o va nous faire atterrir notre branchement. Ainsi, notre prefetcher aurait un moyen de savoir s'il faut charger les instructions places immdiatement aprs le branchement ou les instructions situes ailleurs. Si on ne connait pas l'adresse de destination du branchement, le prefetcher ne sait pas quoi prcharger, et doit se rabattre sur du prefetching sequentiel. Pour limiter la casse, les processeurs modernes disposent d'un circuit spcialis qui se charge de savoir si un branchement est pris ou non, et quelle adresse celui-ci va nous envoyer. Ce circuit s'appelle une unit de prdiction de branchements. On verra celle-ci plus en dtail dans la suite de notre tutoriel, mais pour le moment, tout ce que vous avez savoir est que cette unit va tenter de prdire l'adresse de destination du branchement du mieux qu'elle peut. Et sur certains processeurs, cette unit de prdiction de branchement peut communiquer avec la mmoire cache et lui donner des

www.siteduzero.com

Partie 6 : Hirarchie mmoire

267/378

informations. Le prefetcher peut ainsi utiliser les informations fournies par lunit de prdiction de branchements pour s'adapter si un branchement est trouv. L'unit de prdiction de branchement dira alors au prefetcher quelle adresse se situent les bonnes instructions prcharger. Exemple avec un branchement pris.

C'est ce qu'on appelle le Target Line Prefetching

Wrong Path Prediction

D'autres mthodes un peu plus labores existent, qui permettent de s'adapter au mieux aux branchements conditionnels. Ces techniques permettent de charger les instructions correspondant aux deux cas suivants : branchement conditionnel qui est pris, qui envoie l'autre bout du programme ; ou branchement conditionnel non-pris, pour lequel on poursuit lexcution du programme squentiellement.

On appelle cette technique la Wrong Path Prefetching .

Suppression des lignes de cache

Comme on l'a dit plus haut, avoir un cache, c'est bien. Savoir quelles donnes charger dedans, c'est mieux ! Et l, c'est la catastrophe ! Une mauvaise utilisation du cache peut parfaitement le rendre inutile. Seul problme, le cache est une mmoire trs petite, et il vaut mieux faire en sorte qu'un maximum de donnes utiles se trouve dans ce cache, sans gaspiller son prcieux espace vital avec des donnes qui seront inutiles. Il faut donc : choisir le mieux possible les donnes charger dans le cache : cela permet d'viter le plus possible que le processeur doive aller chercher en RAM une donne qui n'est pas prsente dans le cache ;

www.siteduzero.com

Partie 6 : Hirarchie mmoire

supprimer les donnes devenues inutiles pour laisser la place des donnes utiles.

268/378

Le choix des donnes charger dans la mmoire est ddi au prefetcher, qui possde des algorithmes parfois assez sophistiqus capable de dduire quelles donnes seront accdes dans un futur proche. Ces algorithmes se basent souvent sur la simple localit spatiale : on prcharge les donnes les plus proches en mmoire. Parfois, le prefetcher peut se baser sur la localit temporelle : il peut enregistrer quelles sont les donnes ou instructions accdes rcemment ainsi que lordre dans lequel elles sont ts accdes et se baser dessus.

Algorithmes de suppression des lignes de cache

Vient ensuite le choix des donnes garder dans le cache et le choix des donnes qui doivent quitter le cache pour tre enregistres dans la mmoire RAM. Lorsqu'une mmoire cache est intgralement remplie et qu'on doit charger une donne dans ce cache (en effectuant une lecture en mmoire RAM), il faut que certaines donnes prsentes dans une ligne de cache laissent la place pour les nouvelles donnes. videmment, le choix des donnes rapatrier en mmoire RAM ne peut pas tre fait n'importe comment : rapatrier une donne qui sera surement utilise sous peu est inutile, et il vaudrait mieux supprimer des donnes qui ne serviront plus ou dans alors dans longtemps. Il existe diffrents algorithmes spcialement ddi rsoudre ce problme efficacement, directement cbls dans les units de gestion du cache. Certains sont vraiment trs complexes, aussi j vais vous prsenter quelques algorithmes particulirement simples. Algorithme de remplacement Dtails La donne efface du cache est la plus ancienne : c'est celle qui a t charge dans la mmoire cache avant les autres. C'est le moins performant de tous, mais le moins couteux en transistors(et donc en dgagement thermique). Avec cet algorithme, les performances peuvent se dgrader si l'on augmente la taille du cache : c'est ce qu'on appelle l'anomalie de Belady. La donne efface du cache est choisie au hasard !

FIFO : First Input First Output

Alatoire

Cet algorithme est trs simple, mais niveau efficacit... Cet algorithme particulirement stupide a une efficacit assez proche du FIFO mine de rien. Peu de processeurs utilisent cet algorithme pour grer leur cache, mme si cet algorithme est facile implmenter dans un processeur. La donne qui est efface est celle qui a t utilise le moins rcemment.

LRU : Last Recently Used LFU : Last Frquently Used

Pour cela, il faut enregistrer tous les accs au cache pour chaque donne pour savoir quelle a t la ligne de cache utilise le moins rcemment, ce qui est assez contraignant. Et pour slectionner la ligne de cache la moins rcemment utilise, il faut parcourir toutes les lignes de cache pour trouver celle qui a t le moins rcemment utilise : a prend un temps fou de comparer un grand nombre de lignes de cache. Nanmoins, le hit ratio augmente sacrment. normment de variantes de cet algorithme existent. La donne supprime est celle qui est utilise le moins frquemment. Cela a un cout en terme de transistors, sans compter que slectionner la bonne ligne de cache est plutt lent : il faut bien retenir les accs chaque ligne de cache et comparer pour toutes les lignes de cache laquelle est celle qui a t accde le moins souvent. Mais le hit ratio augmente compar aux algorithmes LRU et FIFO.

Dans la ralit
Avoir un trs bon hit-ratio est certes une bonne chose, mais cela ne suffit pas pour obtenir un cache efficace : le temps mit pour choisir l'infortune ligne de cache ne doit pas tre trop grand et doit mme tre le plus petit possible. Il faut dire que le temps mit pour rcuprer une donne dans le cache est loin d'tre ngligeable et certains programmes y sont trs sensibles. Nos processeurs actuels utilisent des variantes particulirement optimises du LRU. Il faut dire qu'utiliser un vritable algorithme de type LRU rendrait le cache assez lent : comparer toute les lignes de cache pour trouver celle-ci qui a t le moins rcemment

www.siteduzero.com

Partie 6 : Hirarchie mmoire

269/378

utilise prend pas mal de temps. Mais diverses optimisations permettent de rsoudre ce problme. On peut par exemple dcouper le cache en deux : pour slectionner quelle ligne de cache virer, on choisit alatoirement un des deux morceaux de cache, et on vire la moins frquemment utilise de morceau. Il existe d'autres algorithmes beaucoup volus, comme le Pseudo-LRU, qui permettent d'obtenir un hit-ratio similaire au LRU, mais qui ne prennent pas trop de temps pour slectionner la ligne de cache remplacer.

Correspondance Index - Adresse

Pus haut, j'ai dit que notre cache tait capable de faire la correspondance entre un index et une adresse mmoire. Maintenant, on va voir que cette correspondance dpend beaucoup du cache, et on va aussi voir comment notre cache peut retrouver les donnes qu'on a stockes dedans.

Tag d'une ligne de cache

Pour faire la correspondance entre une ligne de cache et l'adresse mmoire correspondante, on utilise une petite bidouille un peu complique. On ajoute des bits supplmentaires notre ligne de cache qui contiennent une partie (voir la totalit) des bits de l'adresse mmoire qui correspond notre ligne. Ces bits supplmentaires forment ce qu'on appelle le Tag.

Quand notre cache reoit une demande de lecture ou criture, il va comparer le Tag de chaque ligne avec les bits de poids fort de l'adresse lire ou crire. Si une ligne contient ce Tag , alors c'est que cette ligne correspond l'adresse demande et un cache hit lieu. Mais si aucune ligne de cache n'a ce Tag , alors c'est un cache miss. Mine de rien, cela demande de comparer le tag avec un nombre de ligne de cache qui peut tre consquent, et qui varie suivant l'organisation du cache : certains caches n'ont pas besoin d'effectuer cette vrification du Tag pour toutes les lignes de caches, comme on le verra tout l'heure. Quoiqu'il en soit, on peut se poser une question : ces adresses mmoires dont on parle depuis tout l'heure, ce sont des adresses physiques ou des adresses virtuelles ?

Et bien a dpend du cache !

Virtually Tagged
Sur certains caches, la correspondance se fait entre une adresse virtuelle et une ligne de cache. Notre cache peut donc tre plac avant la MMU dans notre processeur.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

270/378

Ce genre de cache n'a donc pas besoin d'attendre que la MMU aie finie de traduire l'adresse logique en adresse physique pour vrifier si la donne laquelle accder est prsente ou non dans le cache : ces caches sont plus rapides. Mais les problmes arrivent facilement quand on utilise plusieurs programmes avec ce genre de cache. En effet, plusieurs programmes peuvent utiliser la mme adresse logique : pour eux, toute la mmoire est strictement libre, sans aucun programme qui viendrait prendre des adresses. Ils sont donc autoriss utiliser toutes les adresses logiques depuis l'adresse 0, et rien ne dit qu'un autre programme n'aura pas choisit la mme adresse logique pour autre chose. Cela ne pose pas problme en temps normal, vu que la mme adresse logique peut correspondre plusieurs adresses physiques suivant le programme (on dit merci la MMU). Mais avec notre cache, comment savoir quel programme appartient la ligne de cache qui correspond une adresse virtuelle ?

On n'a pas vraiment le choix : soit on rajoute dans notre ligne de cache des bits de contrle qui permettront d'identifier le programme qui possde la ligne de cache ; soit on vide totalement le cache en changeant de programme.

Physically Tagged
Sur d'autres caches, c'est l'adresse physique qui est utilise pour faire la correspondance entre une ligne de cache et une adresse mmoire. Notre cache doit donc tre plac aprs la MMU dans notre processeur.

Ce genre de caches est plus lent en terme de temps d'accs : il faut attendre que la MMU traduise l'adresse logique en adresse physique pour qu'on puisse enfin demander au cache si la donne laquelle accder est dans le cache ou pas. Par contre, on n'a strictement rien faire pour partager le cache entre plusieurs programmes.

Les caches direct mapped

J'ai dit plus haut que certains caches n'avaient pas besoin de faire un grand nombre de comparaisons pour vrifier qu'une ligne de cache correspondait bien une adresse accde en lecture ou criture. Et bien il est temps que je vous explique comment raliser une prouesse pareille. Dans ce qui va suivre, on va comment sont organiss nos lignes de cache et comment les faire correspondre avec une adresse mmoire. Il faut savoir que cela varie suivant le cache et que divers types de caches existent. On va tout d'abord voir le cas des caches direct mapped . Avec ce genre de cache, le contenu d'une adresse mmoire sera charge dans une ligne de cache prdfinie et impossible modifier : ce sera toujours la mme, quelques soient les circonstances.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

271/378

L'accs au cache est trs rapide vu qu'il suffit de vrifier une seule ligne de cache : celle qui est prdfinie pour l'adresse laquelle on souhaite accder. Si le Tag est le bon, c'est un cache hit, sinon, c'est un cache miss. Les circuits chargs de grer un cache direct mapped sont particulirement simples : pas besoin de faire une recherche dans tout le cache lors de laccs un lment (un seul circuit comparateur peut suffire), pas besoin de beaucoup "rflchir" pour savoir o charger une donne dans le cache, etc. En consquence, ces caches ont un temps d'accs trs faible, et chauffent trs peu.

Conflit miss
Juste une remarque : le cache est plus petit que la mmoire, ce qui fait que certaines adresses mmoires devront se partager la mme ligne de cache. Si on a besoin de manipuler frquemment des donnes qui se partagent la mme ligne de cache, chaque accs une donne supprimera l'autre du cache. Et tout accs l'ancienne donne, qui a quitt le cache, se soldera par un cache miss. Ce genre de cache miss du au fait que deux adresses mmoires ne peuvent utiliser que la mme ligne de cache s'appelle un conflit miss. Cela fait que le hit ratio de ce genre de cache est quelque peu...comique ! Par contre, les circuits de gestion de ce genre de cache ncessitent trs peu de transistors et l'accs aux donnes prsentes dans le cache est trs rapide.

Une implmentation
Gnralement, les concepteurs de mmoire cache s'arrangent pour que des adresses conscutives en mmoire RAM occupent des lignes de cache conscutives. Cela permet de simplifier fortement les circuits de gestion du cache, sans compter que c'est plus logique. Sur les caches direct mapped , chacune de ces lignes de cache possde un index, un nombre entier positif ou nul qui permet de l'identifier et la slectionner parmi toutes les autres lignes. Il ne s'agit pas d'une adresse ! Une ligne de cache n'a pas d'adresse et n'est pas adressable via le bus d'adresse : l'index qui va identifier cette ligne reste confine dans les circuits qui s'occupent de grer notre mmoire cache sans jamais quitter notre processeur. Notre cache n'est pas non plus mapp dans la mmoire RAM, pas plus qu'il n'existe un espace d'adressage spar pour le cache : aucune adresse ne permet de slectionner une ligne de cache, c'est le processeur qui gre celui-ci en interne et utilise une sorte d' "adresse interne" pour slectionner nos lignes de cache: l'index. Avec cette implmentation, notre adresse mmoire peut donc permettre de spcifier l'index de notre donne. Le Tag correspond

www.siteduzero.com

Partie 6 : Hirarchie mmoire

272/378

aux bits de poids forts de l'adresse mmoire correspondant notre ligne de cache. Le reste des bits de l'adresse reprsente l'index de notre ligne, et la position de la donne dans la ligne.

Les caches Fully associative

Avec les caches Fully Associative, toute donne charge depuis la mmoire peut tre place dans n'importe quelle ligne de cache, sans aucune restriction.

En clair, l'adresse mmoire ne peut pas servir identifier une ligne en particulier : le format de l'adresse ne contient pas de quoi spcifier l'Index. Elle est donc dcoupe en un Tag , et de quoi identifier la position de la donne dans la ligne de cache correspondante.

Ces caches ont un hit ratio trs lev, vu qu'il y a pas de possibilit d'avoir le moindre conflit miss : deux donnes diffrentes ne peuvent pas avoir l'obligation de se partager la mme ligne, vu qu'on peut placer nos donnes n'importe o.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

273/378

Sans compter que le temps mit pour accder une donn dans le cache est "long" : pour vrifier qu'une adresse correspond bien un index du cache, il faut vrifier pour chaque ligne de cache si celle-ci correspond notre adresse. Ce qui peut prendre du temps, beaucoup trop. Pour viter de trop perdre de temps effectuer des comparaisons, on effectue celles-ci en mme temps, dans des circuits diffrents : ce genre de cache a besoin d'un grand nombre de comparateur pour tre suffisamment rapide. a ncessite normment de transistors et a chauffe !

Les caches N-way associative

Nos caches Direct Mapped et Fully Associative ont chacun leurs dfaut : un hit ratio mdiocre pour les premiers, et un temps d'accs trop long pour les autres. Les deux influent normment sur les performances et certains caches implmentent une sorte de compromis destin trouver un juste milieu : ce sont les caches N-way associative. Pour simplifier, ces caches sont composs de plusieurs ensembles de lignes de caches. On peut dcider ce choisir dans quelle bloc une donne peut tre charge, mais pas la ligne de cache exacte dans laquelle charger notre donne : les lignes de cache l'intrieur d'un ensemble sont associes des adresses mmoires en utilisant la stratgie Direct Mapped .

En clair, il s'agit d'un regroupement de plusieurs caches Direct Mapped , avec comme particularit le fait qu'on peut choisir dans quel cache stocker notre donne. Avec ce genre de cache, il suffit de vrifier pour chaque ensemble, la ligne de cache prdestine accueillir notre adresse mmoire. On effectue autant de comparaisons qu'il y a d'ensembles, ce qui est relativement rapide (ces comparaisons peuvent tre faites en parallle).

Conflit miss : le retour

Bous aurez remarqus que dans un ensemble de ligne de cache, nos lignes sont accdes en direct mapped : deux donnes peuvent se partager la mme ligne de cache si on les charge dans le mme ensemble. Bien sr, ces cas sont beaucoup plus rares qu'en direct mapped : il suffit simplement de placer nos deux donnes dans deux ensembles diffrents pour viter tout conflit. Mais cela n'est pas toujours possible, et dans certains cas rares, les conflits miss sont possibles sur un cache N-ways associative.

On n'a pas qu'un seul cache !

On pourrait croire qu'un seul gros cache est largement suffisant pour compenser la lenteur de la mmoire. Hlas, nos processeurs sont devenus tellement rapides que nos caches sont eux mmes trop lents ! Pour rappel, plus une mmoire peut contenir de donnes, plus elle est lente. Et nos caches ne sont pas pargns. Aprs tout, qui dit plus de cases mmoires adresser dans un

www.siteduzero.com

Partie 6 : Hirarchie mmoire

274/378

cache dit dcodeur ayant plus de portes logiques : les temps de propagation qui s'additionnent et cela fini par se sentir. Si on devait utiliser un seul gros cache, celui-ci serait beaucoup trop lent. La situation qu'on cherche viter avec la mmoire principale (la RAM) revient de plus belle. Mme problme, mme solution : si on a dcid de diviser la mmoire principale en plusieurs mmoires de taille et de vitesse diffrentes, on peut bien faire la mme chose avec la mmoire cache.

Caches L1, L2 et L3
Depuis environ une vingtaine d'annes, nos caches sont segments en plusieurs sous-caches : les caches L1, L2 et parfois un cache L3. Certains de ces caches sont petits, mais trs rapides : c'est ceux auxquels on va accder en priorit. Viennent ensuite d'autres caches, de taille variables, mais plus lents.

Le L1 est le cache le plus petit et le plus rapide. C'est celui dans lequel le processeur va d'abord chercher les donnes/instructions voulues. On trouve ensuite un cache L2, de vitesse et de taille moyenne, et parfois un cache L3, assez lent mais assez gros. Laccs au cache est simple : on commence par vrifier si notre adresse correspond une donne du cache le plus rapide (qui est souvent le plus petit) : j'ai nomm le cache L1. Si elle ne l'est pas , on effectue la mme vrification pour le cache de niveau infrieur (le L2). Si une donne est prsente dans un des caches, on la charge directement dans le squenceur (instruction) ou en entre des units de calcul (donne). Dans le cas contraire, on vrifie le cache du niveau infrieur. Et on rpte cette opration, jusqu avoir vrifi tous les caches. : on doit alors aller chercher la donne en mmoire. Avec une telle organisation, le prefetcher doit tre un peu adapt : il doit tenter de placer les donnes ou instructions qu'il prcharge dans le bon cache. Par exemple, il dcidera si la donne prcharge doit atterrir dans le cache L1 ou dans le L2. Il peut aussi se charger de migrer des donnes/instructions d'un cache vers un autre. Cela permettra ainsi une donne frquemment utilise de quitter le L2 pour aller dans le L1, histoire de diminuer son temps d'accs en la plaant le plus prs possible du processeur.

Caches inclusifs
Ces caches sont organiss diffremment, et leur contenu varie suivant le cache. Dans le cas des caches inclusifs, le contenu d'un cache est recopi dans les caches de niveau infrieur. Par exemple, le cache L1 est recopi dans le cache L2 et ventuellement dans le cache L3.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

275/378

Ce genre de cache a un avantage : le temps d'accs une donne prsente dans le cache est plus faible. Cela est du en partie la prsence des copies des caches de niveau suprieurs dans les caches de niveau infrieurs (mais pas que). Pour expliquer pourquoi, prenons un exemple : si la donne voulue n'est pas dans le cache L1, on n'est pas oblig de vrifier la partie du cache L2 qui contient la copie du L1. Ainsi, les circuits qui doivent vrifier si une adresse correspond bien une donne place dans le cache peuvent tre simplifis et ne pas vrifier certaines portions du cache. Ce qui donne un rsultat plus rapide. En contrepartie, une partie des caches de niveau infrieur contient les donnes contenues dans le cache de niveau suprieur, qui sont donc en double. Exemple, le cache L2 contient des donnes prsentes dans le L1. De mme, le cache L3 contient une copie du L2. Une partie du cache est donc un peu inutilise, ce qui fait que c'est comme si le cache tait plus petit. Celui-ci pouvant contenir moins de donnes utiles (on ne compte pas les donnes prsentes en double dans les diffrents niveaux de cache), on a parfois un plus grand risque de cache miss, quand le cache est trs utilis. De plus, la mise jour du contenu d'un niveau de cache doit tre rpercute dans les niveaux de cache infrieurs et/ou suprieurs. On doit donc transfrer des informations de mise jour entre les diffrents niveaux de caches.

Caches exclusifs
Dans les caches exclusifs, le contenu d'un cache n'est pas recopi dans le cache de niveau infrieur. Chaque cache contient des donnes diffrentes.

Ainsi, le cache ne contient pas de donne en double et on utilise 100% de la capacit du cache. Le cache contenant plus de donne, on a plus de chance d'avoir un cache hit.

www.siteduzero.com

Partie 6 : Hirarchie mmoire

276/378

Par contre, le temps d'accs une donne prsente dans le cache est plus long : il faut vrifier l'intgralit du contenu des caches de niveau infrieur. Par exemple, si une donne n'est pas dans le cache L1, on doit vrifier l'intgralit du cache L2, puis du cache L3. De plus, assurer qu'une donne n'est prsente que dans un seul cache ncessite aux diffrents niveaux de caches de communiquer entre eux pour garantir que l'on a pas de copies en trop d'une ligne de cache. Et ces communications peuvent prendre du temps.

Caches non-inclusifs et non-exclusifs

Et enfin, je me dois de parler des caches qui ne sont ni inclusifs, ni exclusifs. Sur ces caches, chaque niveau de cache gre luimme ses donnes, sans se proccuper du contenu des autres caches. Pas besoin de mettre jours les niveaux de caches antrieurs en cas de mise jour de son contenu, ou en cas d'viction d'une ligne de cache. La conception de tels caches est bien plus simple.

Caches d'instruction
Au fait, sur certains processeurs, le cache L1 est segment en deux sous-caches : un qui contient des instructions, et un autre qui ne contient que des donnes.

Ces deux caches tant dans des mmoires spares et tant relis au reste du processeur par des bus spars, on peut charger une instruction et manipuler une donne en mme temps, ce qui est un gros avantage en terme de performances.

Cache d'instruction et Self-Modifying Code

Le cache L1 ddi aux instructions est souvent en "lecture seule" : on ne peut pas modifier son contenu dedans, mais juste lire son contenu ou charger des instructions dedans. Cela pose parfois quelques lgers problmes quand on cherche utiliser du self-modifying code, c'est dire un programme dont certaines instructions vont aller en modifier d'autres, ce qui sert pour faire de l'optimisation ou est utilis pour compresser voire cacher un programme (les virus informatiques utilisent beaucoup de genre de procds). Quand le processeur excute donc ce code, il ne peut pas crire dans ce cache L1 d'instructions, mais va devoir crire en mmoire cache L2 ou en RAM, et va ensuite devoir recharger les instructions modifies dans le cache L1, ce qui prend du temps ! Et pire : cela peut parfois donner lieu des erreurs dans certains cas. Mais bref, passons.

Decoded Instruction Cache

Sur certains processeurs, l'tape de dcodage est assez complexe, voire lente. Pour acclrer cette tape, et viter qu'elle ralentisse tout le processeur, certains concepteurs de processeurs ont dcids d'utiliser la (ou les) mmoire cache ddie aux

www.siteduzero.com

Partie 6 : Hirarchie mmoire

277/378

instructions pour acclrer ce dcodage. Lorsque ces instructions sont charges depuis la mmoire ou les niveaux de cache infrieurs, celles-ci sont partiellement dcodes. On peut par exemple rajouter des informations qui permettent de dlimiter nos instructions ou dterminer leur taille : c'est trs utile pour les processeurs qui utilisent des instructions de taille variable. On peut aussi dtecter la prsence de branchements, pour informer les divers prefetchers, histoire qu'ils fassent leur travail correctement. On peut aussi faire beaucoup de transformations de ce genre sur nos instructions, comme harmoniser le opcodes, etc. Bref, notre cache d'instructions peut se charger d'une partie du dcodage des instructions, grce un petit circuit spcialis, spar de l'unit de dcodage d'instruction.

Caches spcialiss
Il existe parfois des caches spcialiss internes au processeur, et qui ne servent pas forcment acclrer les accs mmoire.

Loop Buffer
Pour donner un exemple, nos processeurs rcents utilisent un cache spcialis qu'on Loop Buffer. Il sert acclrer lexcution des boucles (pour rappel, les boucles sont des structures de contrle qui permettent de rpter une suite d'instruction). Il est charg de stocker les ops correspondant des instructions machines qui ont dj ts dcodes et excutes, dans le cas o elles devraient tre r-excutes plus tard. Sans Loop Buffer, si une instruction est excute plusieurs fois, elle doit tre charge depuis la mmoire et dcode, chaque fois qu'on veut lexcuter. Le Loop Buffer permet d'viter de devoir Fetcher et dcoder cette instruction plusieurs fois de suite. Avec ce Loop Buffer, notre instruction est charge et dcode en micro-oprations une seule fois, et le rsultat est stock dans ce fameux Loop Buffer. Si notre instruction doit tre r-excute, il suffit d'aller chercher le rsultat du dcodage de l'instruction directement dans le Loop Buffer au lieu de recharger l'instruction et la redcoder. Si notre instruction est excute dans une boucle contenant trs peu d'instructions machines, le trace cache va fonctionner. De mme, si une instruction micro-code est mule par une suite de ops contenant une boucle (l'instruction REP SCACB du jeu d'instruction x86, par exemple), ce Loop Buffer va aider. Nanmoins, ce cache ne peut stocker qu'un nombre limit d'instruction. Si une boucle dpasse ce nombre d'instruction maximal, l'utilisation du trace cache ne donne strictement aucun gain, dans l'tat actuel de nos technologies. Les programmeurs pourront en dduire une des innombrables raisons qui font que drouler des boucles (Loop unrolling ) est le mal incarn.

Le victim cache
Ce cache est un petit cache qui vient en supplment du cache principal (ou des caches L1, L2 et L3) et n'est prsent que sur les caches de type Write Back. Il a t invent pour limiter les dfauts des caches direct mapped . Pour rappel, sur les caches direct mapped , chaque adresse mmoire est assigne une seule et unique de cache : le contenu d'une adresse mmoire ne peut aller que dans cette ligne, et pas dans une autre. Cela pose quelques problmes : il arrive souvent que certaines adresses mmoires qui se partagent la mme ligne de cache soient manipule simultanment. Dans ce cas, tout accs une de ces adresses va virer le contenu de l'autre adresse du cache. Nos deux adresses seront expulses puis recharges dans le cache continuellement : c'est ce qu'on appelle des conflits miss. Pour limiter ces conflits miss, des scientifiques ont alors eu l'ide d'insrer un cache permettant de stocker les toutes dernires donnes vires du cache. En faisant ainsi, si une donne est vire du cache, on peut alors la retrouver dans ce cache spcialis. Ce cache s'appelle le Victim Cache. Il va de soit que cette technique peut aussi tre adapte aux caches N-Ways Associatives. V oyons comment est gr ce cache. Si jamais on veut accder une donne qui n'est ni dans le cache, ni dans le Victim Cache : on charge notre donne dans le cache, aprs avoir sauvegarde le contenu de celle-ci dans le Victim Cache. Ce Victim Cache est gr par un algorithme de suppression des lignes de cache de type FIFO : les donnes les plus anciennes du cache sont celles qui sont supprime en cas de besoin. Si jamais on veut lire une donne, et que celle-ci n'est pas dans le cache, mais qu'elle est dans le Victim Cache : on change le contenu du Victim Cache avec la ligne de cache correspondante. Petit dtail : ce cache utilise un Tag lgrement plus long que celui du cache Direct Mapped au-dessus de lui. L'index de la ligne de cache doit en effet tre contenu dans le Tag du Victim Cache, pour bien distinguer deux adresses diffrentes, qui iraient dans la mme ligne du cache juste au-dessus.

Le TLB
V ous vous souvenez du Translation Lookaside Buffer, ou TLB, vu au chapitre prcdent ? Et bien celui-ci est aussi un cache spcialis, au mme titre que le Trace cache ou le Victim cache. Ce cache est parfois lui aussi dcoup en plusieurs sous-caches, L1, L2, L3, etc. Sur les architectures Harvard, on trouve parfois

www.siteduzero.com

Partie 6 : Hirarchie mmoire

deux TLB spares : une pour les accs aux instructions, et une pour les accs aux donnes.

278/378

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

279/378

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

Pour commencer notre exploration des diverses amliorations inventes par les fabricants de composants informatiques, on va commencer par notre processeur. Et on va voir que c'est ce processeur qui a subit le plus d'amliorations au fil des ans. A chaque nouveau processeur mit en vente par Intel ou AMD, il y a toujours une amlioration de faite, plus ou moins importante. Dans ce chapitre, on ne va pas tout passer en revue, mais on voir les amliorations les plus importantes. V ous allez voir que la majorit des amliorations du processeur tournent autour de deux concepts : excuter un maximum d'instructions en parallle (simultanment).

Le pipeline : qu'est-ce que c'est ?

Concevoir un processeur n'est pas une chose facile. Et concevoir un processeur rapide l'est encore moins, surtout de nos jours. Dans les chapitres prcdents, on a voqu le fonctionnement d'un ordinateur, mais on n'a pas encore parl de ses performances, de sa rapidit. Nous allons malheureusement devoir enfin parler de performances et mettre les mains dans le cambouis pour comprendre comment fonctionnent les processeurs modernes. En effet, toutes les optimisations des architectures actuelles rpondent toutes au mme besoin : crer des processeurs plus rapides. Pour commencer, nous allons devoir dterminer ce qui fait qu'un programme lanc sur notre processeur va prendre plus ou moins de temps pour sexcuter.

Un besoin : le paralllisme d'instruction

Le temps que met un programme pour sexcuter dpend de pas mal de choses. Il dpend du temps mit au processeur pour excuter ses instructions, du temps pass attendre des donnes en provenance de cette feignasse de mmoire, et du temps pass attendre que ces lourdeaux de priphriques fassent ce qu'on leur demande ! Dans la ralit, vous pouvez tre certains que votre programme passera les 3/4 de son temps attendre la mmoire et les priphriques : ceux-ci sont hyper-lents compars la mmoire, tel point qu'il est impossible de crer des programmes rapides sans prendre en compte la hirarchie mmoire. Mais dans ce chapitre, on ne va s'intresser qu'au temps ncessaire pour excuter les instructions d'un programme, en considrant que le temps mit pour accder la mmoire ou aux priphriques ne comptent pas, afin de se simplifier la vie ! Mais rassurez-vous : les temps d'attentes dus la mmoire et aux priphriques auront un chapitre rien que pour eux. Le temps pris par notre programme pour excuter ses instruction, qu'on notera , dpend :

du nombre moyen d'instructions excutes par notre programme (ce nombre peut varier suivant les donnes manipules par le programme, leur taille, leur quantit, etc) : celui-ci porte un petit nom : il s'appelle l'Instruction path length) ; du nombre moyen de cycles d'horloge ncessaires pour excuter une instruction, qu'on notera (ce qui est l'abrviation de Cycle Per Instruction) ; et de la dure d'un cycle d'horloge. Ce temps T est gal :

Quand on sait que la frquence n'est rien d'autre que l'inverse de la priode d'un cycle d'horloge, on peut rcrire cette quation comme ceci :

Comme on le voit, il existait trois solutions pour rendre un programme plus rapide : Que faire ? Pour cela, il existe plusieurs solutions : Diminuer son nombre d'instructions N compter sur le programmeur pour optimiser son programme : un bon choix d'algorithme et une implmentation efficiente de celui-ci peut donner des gains assez intressants ; amliorer le jeu d'instruction. Cela peut se faire en crant des instructions plus complexes, capables de remplacer des suites d'instructions simples : il n'est pas rare qu'une grosse instruction complexe fasse exactement la mme chose qu'une suite d'instructions plus lmentaires. C'est la raison mme de l'existence des Comment ?

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

processeurs CISC.

280/378

Il existe diffrentes solutions pour diminuer CPI. Tout d'abord, on peut concevoir notre processeur de faon diminuer le temps mis par notre processeur pour excuter une instruction. C'est particulirement difficile et ncessite de refaire les circuits de notre processeur, trouver de nouveaux algorithmes matriels pour effectuer une instruction, amliorer le fonctionnement de notre processeur et sa conception, etc. De ce point de vue, les processeurs RISC sont avantags : leurs instructions sont toutes simples, et peuvent souvent s'effectuer en quelques cycles d'horloges. On est vraiment loin des anciens processeurs CISC : si certaines instructions de base taient simples et rapides, d'autres instructions trs complexes pouvaient Diminuer CPI mettre une bonne dizaine voire centaine de cycles d'horloge pour sexcuter. Un autre solution consiste mieux choisir les instructions utilises. Comme je l'ai dit plus haut, le nombre CPI est un nombre moyen : certaines instructions sont plus rapides que d'autres. En utilisant de prfrence des instructions rapides au lieu d'instructions plus lentes pour faire la mme chose, on peut facilement diminuer le CPI. De nos jours, les programmeurs n'ont que trs peu d'influence sur le choix des instructions utiliser : les langages de haut niveau comme le C++ ou le Java se sont dmocratiss et ont dlgus cette tache aux compilateurs (qui se dbrouillent particulirement bien, en passant). Pour cela, il faut utiliser des composants lectroniques plus rapides. Gnralement, cela ncessite de miniaturiser les transistors de notre processeur : plus un transistor est petit, plus il est rapide (rappelez vous Augmenter la le chapitre sur les transistors). Durant un temps, cela fonctionnait merveille, grce la loi de Moore. Mais de frquence nos jours, le Heat wall et le Memory wall ont finis par diminuer les effets de la monte en frquence, rendant celle-ci de plus en plus inutile en terme de performances.

Mais avec le temps, il est devenu de plus en plus difficile de monter en frquence. Le coup de grce fut celui port par le Heat wall et le Memory wall : la monte en frquence devenant de plus en plus difficile, malgr les amliorations des processus de fabrication des composants lectroniques, et les performances ont commences stagner. La solution consistant rajouter des instructions et modes d'adressage complexes ne fonctionnait pas non plus : ces instructions taient souvent assez complexes et les occasions de les utiliser taient assez rares. Pourtant les performances pouvaient tre au rendez-vous, mais utiliser ces instructions est souvent difficile pour un compilateur. Mais le principal problme de cette solution n'est pas l : modifier un jeu d'instruction est quelque chose qui doit se faire sur le long terme, avec le poids de la compatibilit, ce qui n'est pas sans poser quelques problmes. Par exemple, un programme qui utiliserait des instructions toutes nouvelles ne peut pas fonctionner sur les anciens processeurs ne possdant pas ces instructions. Ainsi, on a beau rajouter des tas d'instructions dans nos processeurs, il faut attendre assez longtemps pour que celle-ci soient utilises : le temps que presque tout le monde aie un processeur capable dexcuter ces nouvelles instructions. Pour donner un exemple trs simple : votre avis, sur les nouvelles instructions rajoutes dans chaque nouveau processeur Intel, AMD, ou ARM, combien sont rellement utilises dans les programmes que vous utilisez ? Combien utilisent les instructions SSE, AVX ou autres extensions rcentes ? Surement peu. Il ne restait plus qu'une solution : diminuer le CPI. Cela n'tait pas facile, et diverses solutions ont ts mises en place : amliorer les circuits de calcul et le squenceur de notre processeur, fabriquer des circuits plus rapides, etc. Quoiqu'il en soit, les concepteurs de processeurs ont cherch optimiser au mieux les instructions les plus utilises et se sont plus ou moins heurts un mur : leurs oprations taient dj diablement rapides au point qu'il tait assez difficile de leur faire prendre moins de temps. En clair, les solutions orthodoxes visant toucher au jeu d'instruction, la frquence ou aux circuits de lunit de calcul ont atteint une sorte de mur difficile dpasser. Les concepteurs de processeurs ont donc dt ruser et ont du trouver dautres mthodes. Il est devenu vident au fil du temps qu'il fallait rflchir hors du cadre et trouver des solutions innovantes, ne ressemblant rien de connu. Ils ont fini par trouver une solution assez incroyable : excuter plusieurs instructions en mme temps ! Comme a, pas besoin de gaspiller son nergie rendre nos instructions encore plus rapides en amliorant des circuits proches de l'optimum : avec cette mthode, le CPI devenait infrieur 1 pour les instructions rapides, ce qui donnait de gros gains en performances. Pour excuter plusieurs instructions en mme temps, il a bien fallu trouver quelques solutions diverses et varies. Le pipeline est une de ces solutions. Pour expliquer en quoi il consiste, il va falloir faire un petit rappel sur les diffrentes tape d'une instruction.

Le pipeline : rien voir avec un quelconque tuyau ptrole !

Ceux qui se souviennent du chapitre sur la micro-architecture d'un processeur savent qu'une instruction est excute en plusieurs tapes bien distinctes. Suivant son mode d'adressage, ou les manipulations qu'elle doit effectuer, notre instruction va devoir passer travers plusieurs tapes. Gnralement, on trouve 7 grandes tapes bien distinctes : il faut charger d'instruction depuis la mmoire : c'est l'tape de Fetch ;

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

puis il faut la dcoder : c'est l'tape de Decode ; puis, certains modes d'adressages demandent de calculer l'adresse laquelle aller lire nos oprandes ; si besoin, nos oprandes sont lues depuis la mmoire : c'est l'tape d'Operand Fetching ; notre instruction effectue un calcul ou un change de donne entre registres : c'est l'tape d'Exec ; puis, certains modes d'adressages demandent de calculer l'adresse laquelle aller stocker notre rsultat ; et enfin, le rsultat est crit en mmoire : c'est l'tape de Writeback.

281/378

Ces tapes sont parfois elles mme dcoupes en plusieurs sous-tapes. De mme, l'tape de dcodage peut tre scinde en deux sur les processeurs utilisant des instructions de taille variable : on rajoute une tape pour dterminer la taille de notre instruction avant de la dcoder. De mme, rien nempche de regrouper certaines de ces sous-tapes : on peut par exemple, regrouper l'tape d'Operand Fetching avec celle qui est charge de calculer l'adresse de la donne charger. Et enfin, rien ne nous empche de rajouter des tapes supplmentaires : on le fera dans la suite de ce tutoriel. Dans ce qui va suivre, on va utiliser un processeur qui utilise 5 tapes : Fetching : on charge l'instruction depuis la mmoire ; Dcodage : on dcode l'instruction ; Operand Fetching : on effectue une lecture en mmoire ; Excution : on effectue un calcul ; Write back : on crit le rsultat de l'instruction dans un registre ou en mmoire. On va donc se simplifier grandement la vie.

Sans pipeline
Quoiqu'il en soit, ces tapes sont plus ou moins indpendantes, mais sont excutes l'une aprs l'autre, dans l'ordre, sur un processeur sans pipeline. Sans pipeline, on est oblig d'excuter les instructions les unes aprs le autres. Ce n'est qu'une fois une instruction termine qu'on peut passer la suivante. Dit autrement, on ne peut commencer excuter une instruction que lorsque la dernire tape de l'instruction prcdente est termine.

Et dieu inventa le pipeline

En fait non, c'est pas lui ! Linventeur du pipeline s'appelle David Patterson : ceux qui ont une bonne mmoire se rappelleront que cet homme est l'inventeur des architectures RISC, qui furent parmi les premiers processeurs incorporer un pipeline. Le pipeline rpond un but prcis : avec un processeur sans pipeline, on doit attendre qu'une instruction soit finie pour excuter la suivante. Avec un pipeline, on peut commencer xecuter une nouvelle instruction sans attendre que la prcdente soit termine. Pour voir comment c'est possible, il faut remarquer que les tapes de nos instructions sont totalement indpendantes. Ainsi, la premire tape d'une instruction peut commencer pendant que l'instruction prcdent passe la suivante. Par exemple, on pourrait fetcher la prochaine instruction pendant que l'instruction en cours dexcution en est l'tape d'Exec. Aprs tout, ces deux tapes sont compltement indpendantes et utilisent des circuits spars. En regardant bien, on remarque que chaque tape d'une instruction est indpendante des tapes prcdentes. Il est donc possible de faire en sorte que chaque tape puisse commencer traiter une nouvelle instruction pendant que la prcdente passe l'tape suivante. C'est le principe du pipeline : excuter plusieurs instructions diffrentes, chacune tant une tape diffrente des autres. Avec un pipeline, chaque instruction est dcoupe en plusieurs tapes, chacune tant effectue par une (ou plusieurs) unit de calcul spares. Cela permet d'avoir des tapes rellement indpendantes : si deux instruction dans des tapes diffrentes ont besoin du mme circuit, on ne peut pas excuter les deux dans des tapes diffrentes en mme temps, et une d'entre elles doit tre choisie. Crer des circuits spcialiss pour chaque tape est donc un premier pas. Chacun des circuits permettant d'effectuer une des tapes d'une instruction est alors appel un tage du pipeline.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

282/378

Dans l'exemple du dessus, on a un pipeline 5 tages. Comme vous le voyez, durant le cycle not 4, 4 instructions diffrentes sexcutent : la premire est l'tape MEM, la seconde l'tape EX, la troisime l'tape ID, la quatrime l'tape IF, et un tage ne sert rien (il aura pu servir et on aurait alors eu 5 instructions excutes en mme temps). Le nombre total d'tapes ncessaires pour effectuer une instruction (et donc le nombre d'tages du pipeline) est appel la profondeur du pipeline. Plus ce nombre est grand, plus notre pipeline peut excuter d'instructions en mme temps. Du moins en thorie, parce qu'on va voir qu'il y a quelques petites subtilits qui viennent mettre leur grain de sel. Par exemple, dans l'exemple du dessus, un tage tait inutilis : et bien sachez que pour diverses raisons qu'on abordera plus tard, ce genre de cas est possible, et est mme frquent. Pour les curieux, voici les longueurs de pipeline de certains processeurs plus ou moins connus. Processeur Motorola PowerPC G4 MIPS R4400 Intel Itanium Intel Pentium II Intel Pentium 3 Longueur du pipeline 7 8 10 14 10

Intel Pentium 4 Prescott 31 Intel Pentium 4 AMD Athlon AMD Athlon 64 IBM PowerPC 970 Sun UltraSPARC IV 20 12 16 16 14

Implmentation hardware
Concevoir un processeur incorporant un pipeline ne se fait pas simplement et ncessite quelques modifications de l'architecture de notre processeur.

Un besoin : isoler les tages du pipeline

Tout d'abord, chaque tape d'une instruction doit tre excute indpendamment des autres. Pour cela, nos tages, chargs

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

283/378

chacun de lexcution d'une tape, doivent utiliser des circuits indpendants : impossible de rutiliser un circuit dans plusieurs tapes. Dans un processeur sans pipeline, plusieurs tapes diffrentes d'une mme instruction peuvent utiliser le mme circuit. Par exemple, le circuit charg d'effectuer l'addition (l'additionneur) peut tre utilis : pour augmenter la valeur du registre d'adresse d'instruction durant l'tape de fetch, afin de le faire pointer sur l'adresse de l'instruction suivante ; pour calculer l'adresse d'une oprande si besoin est (gnralement, les calculs d'adresses sont des bases sur des additions, des multiplications et ventuellement des dcalages) ; puis pour effectuer l'addition lors de l'tape d'exec; pour calculer l'adresse laquelle sauvegarder le rsultat de l'instruction d'addition si besoin. Cela ne pose pas le moindre problme : aprs tout, ces tapes ne sont jamais simultanes sur de tels processeurs et partager le mme circuit pour des tapes diffrentes permet d'viter de dupliquer des circuits. Dans notre exemple avec l'additionneur, cela permet d'utiliser un seul additionneur au lieu de 3 ou 4. Mais sur un processeur dot de pipeline, on ne peut se permettre ce genre de chose. Il est prfrable que chaque tape aie son propre unit de traitement ddie pour viter diffrentes tapes de se partager le circuit. Imaginez que deux instructions dans des tapes diffrentes aient besoin du mme circuit : il est impossible de partager le circuit en deux et d'en donner la moiti chaque instruction. Un processeur utilisant un pipeline utilisera donc beaucoup plus de transistors et de portes logiques pour fonctionner, ce qui a un certain cout.

Mine de rien, cette sparation ne fait pas tout : certaines ressources, comme les registres ou le bus mmoire peuvent tre partages entre instructions : sur un processeur dot de pipeline, deux instructions peuvent vouloir manipuler le mme registre ou le bus mmoire, et il faudra grer ce genre de cas avec des techniques plus ou moins labores. On comprend qu'il est important de sparer les units en charge de chaque tape. Il existe pour cela diverses approches qu'on va

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

vous dtailler dans ce qui suit.

284/378

Comment on fait ?
Certains pipelines intercalent des registres entre chaque tage du pipeline pour les rendre indpendants. Ces registres jouent le rle de tampon et isolent chaque tage des autres. Exemple avec un pipeline 4 tages.

Ces registres sont des registres compltements invisible pour le programmeur : on ne peut pas manipuler ceux-ci avec des instructions du type load, store, ou d'autres instructions cense pouvoir manipuler le contenu d'un registre. Il n'ont donc pas de nom, et sont accessibles que par les units en charge de chaque tape. Quand une unit fini son travail, elle crit son rsultat dans le registre. Quelques instants plus tard, l'unit en charge de l'tape suivante lira le contenu de ce registre et pourra alors effectuer l'tape qui lui est attribue. Le tout est de savoir quand lunit suivante lira le contenu de ce registre.

Buffered Synchrones
Sur certains processeurs, le pipeline est synchronis sur l'horloge de notre processeur. Chaque tage du pipeline met donc un cycle d'horloge pour effectuer son travail. Il va lire le contenu du registre qui le relie l'tape qui le prcde au dbut du cycle et va dduire le rsultat qu'il crira dans le registre qui le relie lunit suivante juste avant le prochain cycle d'horloge.

Pour viter les ennuis, on fait en sorte que la frquence de l'horloge soit suffisamment petite pour viter que le contenu d'un registre n'aie pas fini d'tre lu (par l'tage le suivant) avant d'tre modifi par l'tage qui le prcde. Ce sont ce genre de pipeline que l'on trouve dans les processeurs Intel et AMD les plus rcents.

Buffered Asynchrones
Sur d'autres pipelines, il n'y a pas d'horloge pour synchroniser le passage des rsultats d'un tage un autre. Sur ces

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

processeurs, chaque tage est reli par deux fils l'tage suivant : on nommera ces fils REQUEST et ACK.

285/378

Quand un tage a fini son travail, il envoie un 1 l'tage suivant sur le fil REQ, pour lui dire : " j'ai fini mon travail, et j'ai quelques donnes pour toi " . Il va alors attendre que l'tage suivant soit libre et que celui-ci lui rponde : " je suis libre, je m'occupe de tes donnes " en mettant le fil ACK 1. Suite cela, ces deux fils sont remis zro et nos tages peuvent se remettre au travail chacun de leur cot.

Unbuferred pipeline
D'autres pipelines se dbrouillent sans registres intercals entre chaque tage, mais ceux-ci sont beaucoup plus rares.

Une histoire de frquence...

Revenons un peu sur les buffered synchronous pipelines... Mais si : les pipelines fabriqus avec des registres et cadencs par une horloge !

Une sorte de paradoxe

Comme je l'ai dit, une tape d'une instruction s'effectue en un cycle d'horloge. Ainsi, sur un pipeline n tages, notre instruction mettra n cycles d'horloge sexcuter. Par contre, notre instruction sexcuterait en 1 seul cycle d'horloge sur un processeur sans aucun pipeline. contre un auparavant : on pourrait croire que notre processeur dot de pipeline est n fois plus lent. Mais vu que notre pipeline pourra excuter n instruction en un cycle d'horloge: on ne perd pas de performances. Visiblement, un processeur utilisant un pipeline de ce genre n'est pas cens tre vraiment plus rapide qu'un processeur sans pipeline. Alors quoi peut bien servir notre pipeline ?

En fait, il y a anguille sous roche : qui vous a dit que la frquence tait la mme ? Car c'est un fait : possder un pipeline permet d'augmenter la frquence du processeur ! Et l, je suis sr que vous ne voyez pas vraiment le rapport entre le pipeline et la frquence, et que quelques explications seraient les bienvenues. C'est une histoire de temps de propagation.

Temps de propagation et pipeline

Comme vous le savez tous depuis le second chapitre, un circuit met toujours un certain temps ragir et mettre jour sa sortie quand on modifie son entre. Plus un circuit contient de portes logiques, plus ce temps sera long : le mot binaire plac sur lentre devra "parcourir" plus de portes avant d'arriver sur la sortie (en se faisant modifier au passage). Chaque porte ayant un temps de propagation plus ou moins fixe, plus on traverse de portes, plus cela prend du temps. La dure d'un cycle du signal d'horloge servant cadencer un circuit doit absolument tre suprieure au temps de propagation

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

286/378

de notre circuit : sans cela, celui-ci ne sera pas synchronis avec les autres composants et notre processeur ne fonctionnera pas ! Hors, un tage de pipeline est un mini-circuit capable d'effectuer un morceau d'instruction : il contient nettement moins de portes logiques qu'un circuit capable dexcuter une instruction complte. Donc, un tage de pipeline possde un temps de propagation nettement plus faible qu'un gros circuit capable d'effectuer une instruction rien qu' lui tout seul ! Vu que le temps de propagation d'un tage est nettement plus petit que le temps de propagation de notre circuit sans pipeline, on peut alors augmenter la frquence sans risques. Gnralement, plus un processeur possde d'tages, plus il est facile d'augmenter sa frquence. Certains fabricants de processeurs n'ont d'ailleurs pas hsit crer des processeurs ayant un nombre d'tages assez lev dans le but de faire fonctionner leurs processeurs des frquences assez leves. C'est ce qu'a fait Intel avec le Pentium 4. A l'poque, la frquence d'un processeur tait un excellent argument marketing : beaucoup de gens croyaient que plus un processeur avait une frquence leve, plus il tait puissant. Les fabricants de processeurs cherchaient donc des moyens d'augmenter au maximum la frquence de leurs processeur de manire sure, pour s'assurer de vendre beaucoup de processeurs. Le pipeline d'un Pentium 4 faisait ainsi entre 20 tages (pour les Pentium 4 bass sur l'architecture Willamette et Northwood), 31 tages (pour ceux bass sur l'architecture Prescott et Cedar Mill). Pour un exemple plus rcent, les processeurs AMD bass sur l'architecture Bulldozer suivent un peu la mme approche.

Mais...
On pourrait croire que dcouper un processeur en x tages permet de multiplier la frquence par x. Pour vrifier ce qu'il en est, on va vrifier cela avec un raisonnement simple. On va comparer le temps mit par notre instruction pour sexcuter sur deux processeur identiques un dtail prt : le premier sera pipelin, et l'autre non. Sur notre processeur sans pipeline, une instruction met un temps pour sexcuter.

L'autre processeur possde un pipeline de tages. On notera le temps mit pour excuter notre instruction sur ce processeur. Pour se simplifier la vie, on va supposer que le dcoupage des circuits du processeur en tages est trs bien fait : chaque tage contient autant de portes logiques que les autres et a le mme temps de propagation que ses collgues. Exemple avec un pipeline 5 tages.

La dure

d'un cycle d'horloge est donc cense tre de :

Vu que notre instruction met cycles pour sexcuter, on en dduit que le temps dexcution de notre instruction est donc gal au nombre de cycles ncessaires pour excuter une instruction dure d'un cycle. Ce qui donne :

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

287/378

Ce qui est gal T, pas de changements. Mais il faut ajouter un dtail : on doit rajouter des registres dans notre pipeline, qui ont eux aussi un temps de propagation qui doit tre pris en compte. Un pipeline tages possdera registres intercals entre ses tages. Si on note le temps de propagation d'un registre, alors le temps mit pour excuter notre instruction sera de

En simplifiant notre quation par x en haut et en bas, on trouve alors que

Ce qui est suprieur . On voit donc que le pipeline augmente lgrement le temps mit pour excuter une instruction toute seule. Mais en contrepartie on excute plusieurs instructions en une fois, ce qui donne un gros avantage au processeur pipelin. On peut aussi dduire une autre chose de cette formule : plus un pipeline possde d'tages, plus il faut rajouter de registres entre les tages et plus le temps augmente. Ainsi, la dure d'une instruction augmente avec le nombre d'tages. Ce qui peut tre fortement dsavantageux et nuire la performance de notre processeur. De plus, il y a aussi un problme avec notre hypothse de base ; le dcoupage de notre processeur en tages n'est pas si simple, et certains tages possdent beaucoup de portes logiques que les autres. La dure d'un cycle d'horloge devra tre suprieure au temps de propagation de l'tage le plus fourni en portes logiques, ce qui fait augmenter encore plus la dure d'une instruction. Gnralement, c'est le dcoupage du squenceur qui pose le plus de problme.

Un pipeline pas parfait

Il y a malgr tout quelques problmes avec ce pipeline qui limitent ses performances (c'tait trop beau :p). Notre pipeline atteint son efficacit maximale sous certaines conditions assez restrictives. Quelques phnomnes assez embtants ont en effet tendance rduire l'utilisation qui est faite du pipeline. On a vu plus haut que des bulles, les fameuses Pipeline Bubble, pouvaient apparaitre dans notre pipeline. Et bien sachez qu'il existe de nombreuses raisons pour que ces bulles apparaissent, et que les exceptions ne sont pas les seules fautives.

Les dpendances d'instructions

Pour utiliser le pipeline de faon optimale, les oprandes d'une instruction ne doivent pas dpendre du rsultat d'une instruction prcdente. Il serait en effet bien difficile dexcuter une instruction alors que les donnes ncessaires son excution manquent. Prenons un exemple simple : deux instructions qui se suivent sont charges l'une aprs l'autre dans notre pipeline. La seconde instruction doit attendre le rsultat de la premire pour commencer son excution. J'ai colori sur le schma en jaune les tapes des instructions durant lesquelles l'unit de calcul est utilise. La situation idale serait celle-ci.

Mais la ralit est plus cruelle : le rsultat de notre instruction n'est disponible qu'aprs avoir t enregistr dans un registre, soit aprs l'tape de Writeback. La ralit est tout autre.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

288/378

On voit bien que la seconde instruction doit attendre l'autre. C'est un fait : si deux instructions ont une dpendance de donne, alors on va perdre du temps dans ce fameux temps d'attente.

Les accs mmoires

Des problmes similaires apparaissent lors des accs mmoires. Si une donne attend des donnes en provenance de la mmoire, on se retrouve aussi avec ce genre de vides. Quand un tage du pipeline cherche accder la mmoire, il doit souvent attendre longtemps (enfin, longtemps pour un CPU c'est quelques microsecondes hein...!), la mmoire RAM d'un pc tant souvent trs lente. Ce qui fait que durant tout ce temps, l'instruction qui accde la mmoire va squatter un tage du pipeline en ne faisant rien pendant qu'elle attend sa donne.

L'ala structurel
Il se peut que deux instructions en cours d'excution dans le pipeline aient besoin d'accder au mme registre, la mme unit de calcul ou la mme adresse mmoire en mme temps. Une des deux instructions devra alors attendre que la ressource voulue soit libre, en patientant dans un tage du pipeline. Prenons un exemple : on va charger une instruction devant aller chercher une donne dans la mmoire dans notre pipeline de 5 tages vu au-dessus. V le rsultat : oici T T+1 T+2 T+3 Exec Read Operand Decode Fetch T+4 Writeback Exec Read Operand Decode Fetch

Fetch Decode Read Operand Fetch Decode Fetch

Regardez ce qui se passe sur les colonnes : on doit effectuer une tape de Fetch, et l'tape de Read Operand simultanment. Or, ces deux tapes doivent aller effectuer des lectures en mmoire. On est en plein alas structurel : notre mmoire ne peut logiquement effectuer qu'un seul accs la fois. Seule solution : permettre notre mmoire d'effectuer des accs simultans. C'est pour cela que le cache L1 est coup en deux caches (un pour les instructions et un autre pour les donnes). L'unit de Fetch peut ainsi charger une (voire plusieurs) instruction depuis le cache L1 sans tre gne par le fait que l'tage d'Operand Fetching doive aussi accder la mmoire : chacun de ces tages pourra accder un cache spar (L1 instruction pour l'unit de Fetch, et L1 donne pour l'unit d'Operand Fetching ). Ce genre d'alas se rgle souvent en dupliquant la ressource partager. On l'a bien vu avec notre exemple de la duplication du cache L1 en deux caches distincts. Dupliquer une unit de calcul, des registres, ou tout autre circuit est quelque chose d'assez commun pour viter d'avoir partager une ressource, et viter ainsi les alas structurels. D'autres formes de duplications peuvent apparaitre : on a vu plus haut que dupliquer certains circuits comme l'additionneur permettait de bien sparer les tages. On verra bien d'autres formes de duplications dans la suite du tutoriel (units de calcul, registres, etc), et il faudra bien garder l'esprit que ces duplications serviront supprimer des dpendances structurelles.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

289/378

Les branchements
Lorsqu'on charge un branchement dans le pipeline, on ne sait pas quelle adresse le branchement va demander au programme de poursuivre son excution, et donc quelles seront les prochaines instructions charger. On doit donc attendre que le branchement aie fini de s'excuter pour savoir quelles sont les instructions charger dans le pipeline. Prenons le cas o l'adresse laquelle brancher est connue l'tape de dcodage (ce qui est trs tt). Dans ce cas, si un branchement vient juste d'tre charg dans notre pipeline, on ne pourra pas continuer charger des instructions dans le pipeline immdiatement aprs : on devra attendre que l'adresse laquelle brancher soit connue.

Durant ce temps, aucune instruction n'est cense tre charge dans le pipeline, sauf si le processeur est capable d'effectuer de la prdiction de branchement (on verra ce que c'est dans la suite du tutoriel). C'est des cycles d'horloge perdus rien.

Conclusion
Ces divers phnomnes ont tous le mme effet : certaines tapes d'une instruction doivent attendre durant un moment qu'une autre instruction (branchement, accs mmoire ou autre) aie termin son excution avant de poursuivre. L'instruction en tat d'attente a tendance bloquer toutes les instructions qui sont charges aprs elles. Quoiqu'il en soit, les processeurs actuels incorporent de nombreuses techniques permettant d'augmenter au maximum l'efficacit du pipeline en essayant de corriger ces dfauts. Plus le pipeline a une profondeur (un nombre d'tapes par instructions) grand, plus ces dfauts deviennent importants et pnalisent les performances : on a des performances meilleures que sur un CPU sans pipeline, mais le rsultat n'est pas optimal. A l'inverse un pipeline pas assez long ne permet pas d'excuter suffisamment d'instruction en parallle, d'o une perte de performance. La profondeur d'un pipeline est une histoire de compromis. De nombreux chercheurs ainsi que les fabricants de processeurs sintressent la longueur optimale d'un pipeline, et de nombreux travaux sur le sujet ont vu le jour. De nos jours, les pipelines des processeurs actuels ont une profondeur d'environ 14-15 tages, ce qui semble un bon compromis. Le pipeline le plus long connu ce jour dans un processeur "grand public" est le Pentium 4 : 31 tages, comparer avec les autres processeurs qui ont en moyenne 14 tages. Cette longueur de pipeline lui a plomb ses performances !

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

290/378

Interruptions et Pipeline
Maintenant, nous devons parler un peu des interruptions et des exceptions. Pour rappel, ces interruptions sont des fonctionnalits de notre processeur qui permettent d'interrompre temporairement lexcution d'un programme pour xecuter un morceau de code. Il existe divers types d'interruptions : logicielles, matrielles, et les exceptions. Les interruptions logicielles peuvent tre vus comme des appels de sous-programmes spciaux, tandis que les interruptions matrielles servent grer nos priphriques. Quand aux exceptions, elles servent traiter des erreurs exceptionnelles qui ne devraient pas arriver dans un code bien conu : un opcode non reconnu, une division par zro, une erreur de protection mmoire, etc. Sur un processeur purement squentiel, ces interruptions et exceptions ne posent aucun problme. Mais si on rajoute un pipeline, les choses changent : nos interruptions et exceptions vont alors jouer les troubles ftes. Dans cette sous-partie, nous allons rpondre la question qui suit. Comment nos interruptions et exceptions sont gres par notre pipeline ?

Interruptions prcises ou imprcises

Mais pour commencer, il faudrait peut-tre savoir quel est le problme avec nos interruptions. V oyons cela par l'exemple. Imaginons que je charge une instruction dans mon pipeline. Celle-ci va alors gnrer une exception quelques cycles plus tard. Cette exception est indique en rouge sur le schma.

Seul problme, avant que l'exception aie eu lieu, notre processeur aura continu charger des instructions dans notre pipeline. Il s'agit des instructions en jaune. Et ces instructions sont donc en cours dexcution dans notre pipeline...alors qu'elles ne devraient pas. En effet, ces instructions sont places aprs l'instruction qui est l'origine de notre exception dans l'ordre du programme. Logiquement, elles n'auraient pas dues tre excutes, vu que l'exception est cense avoir fait brancher notre processeur autre part. Que faire de ces instructions excutes trop prcocement ? Dans ce cas, il y a deux solutions : soit on s'en moque, et on laisse ces instructions finir leur excution, soit on trouve un moyen pour que ces instructions ne fassent rien. Dans la premire solution, on se moque de ce problme, et on ne prend aucune mesure. Tout se passe comme si l'exception avait eu lieu avec du retard : on dit que l'exception est imprcise. Certains processeurs se contentent d'utiliser des interruptions et exceptions imprcises : certains processeurs MIPS ou ARM sont dans ce cas. Mais cela pose quelques problmes pour les programmeurs, qui doivent faire avec ces interruptions dcales. Autant dans la majorit des cas cela ne pose pas de problmes, autant cela peut devenir un vritable enfer dans certaines situations. Pour faciliter la vie des programmeurs, certains processeurs ont dcids de supporter des interruptions prcises. Par interruptions prcises, on veut dire que ces interruptions ne se font pas aprs un temps de retard. Lorsque ces interruptions sexcutent, le processeur fait en sorte que tout se passe bien, en remettant le pipeline en ordre. Pour ce faire, il existe diverses solutions. Certaines de ces solutions ne permettent que de grer des interruptions logicielles et des exceptions prcises, mais se foutent des interruptions matrielles. D'autres de ces techniques sont plus polyvalentes et grent tous les types d'interruptions de faon prcise.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

291/378

Techniques conservatrices
La toute premire de ces techniques est une solution assez conservatrice. Celle-ci s'occupe de grer les exceptions et les interruptions logicielles. Elle ne peut rien pour rendre les interruptions matrielles prcises, ce qui n'est pas si grave : que ces interruptions soient retards ou pas ne change as grand chose. Elle consiste ne pas charger de nouvelle instruction dans notre pipeline quand une interruption ou une instruction susceptible de lever une exception sexcute.

Implmentation
Implmenter cette technique est assez simple : il suffit d'identifier les interruptions logicielles et les instructions susceptibles de lever des exceptions dans le pipeline, et ragir en consquence. Tout se passe dans les units de dcodage. Savoir si une instruction est une interruption ou si elle est susceptible de lever une exception est possible ds le dcodage. Pour les exceptions, il faut dire que seules certaines instructions peuvent en lever. Par exemple, une division peut lever une exception : division par zro. Pareil pour les instructions de lecture de certains processeurs, qui ne grent pas les accs non-aligns. Mais cot, des instructions comme des additions, multiplications, etc, ne lvent jamais d'exceptions. Lorsque notre unit de dcodage dcode une instruction, ses circuits vont regarder si celle-ci peut lever une exception ou s'il s'agit d'une interruption logicielle. Rien de bien sorcier : il suffit de se baser sur son opcode. Si elle peut lever une exception, ou s'il s'agit d'une interruption logicielle, l'unit de dcodage d'instruction l'envoie l'tage suivant avant de se bloquer. Par bloquer, on veut dire qu'il n'envoie pas de nouvelle instruction aux ALU tant que cette instruction n'est pas termine. V ce que cela donne dans notre pipeline. Sur ce schma, chaque couleur reprsente une instruction. oici

On remarque qu'en plus de bloquer l'unit de dcodage, il faut aussi bloquer l'unit de Fetch, pour viter qu'elle n'envoie une nouvelle instruction une unit de dcodage mise en pause, qui ne pourra grer cette nouvelle instruction.

Pipeline Bubble
Autre remarque trs importante : des vides apparaissent dans notre pipeline, des tages qui nexcutent aucune instruction. Ce

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

292/378

sont ceux les bulles en gris sur le schma. Ces vides, on les appelle des Pipeline Stall, ou encore des Pipeline Bubble. Il apparaissent chaque fois qu'une instruction doit attendre dans un tage du pipeline. Tous les tages prcdents sont alors "bloqus", et des vides apparaissent la suite de l'instruction mise en attente. On verra dans la suite du tutoriel que ces Pipeline Stall peuvent survenir dans d'autres circonstances, et qu'il existe diverses techniques pour supprimer ou remplir ces vides. Mais passons. En utilisant cette technique pour grer nos exceptions et interruptions logicielles, on fait apparaitre de nombreuses Pipeline Bubble. Et ces Pipeline Bubble, ces vides dans le pipeline, sont autant d'tages gaspills ne rien faire, qui nexcutent pas d'instructions. En clair : lorsqu'une Pipeline Bubble apparait, notre pipeline est sous-utilis, et on perd en performances btement. Vu que les instructions susceptibles de lever une exception sont nombreuses, c'est un vrai dsastre en terme de performances. Au moins, cette technique a le bon gout de ne pas gaspiller beaucoup de circuits et d'tre simple implmenter. Mais en terme de performances, elle est la ramasse.

In-Order Completion
Pour limiter la casse, d'autres techniques de gestion des exceptions ont ts inventes. Et celles-ci sont spculatives. Par spculatives, on veut dire que le processeur va faire des paris, et excuter des instructions en spculant quelque chose. Ici, le processeur va spculer que les instructions qu'il vient de charger ne lvent aucune exception, et qu'il peut les excuter sans aucun problme. Si la spculation tombe juste, le processeur continuera excuter ses instructions, et aura vit des Pipeline Bubbles inutiles. Mais si jamais cette prdiction se rvle fausse, il va devoir annuler les dommages effectus par cette erreur de spculation. Au final, ce pari est souvent gagnant : les exceptions sont quelque chose de rare, tandis que les instructions capables d'en lever son monnaies courantes dans un programme. Beaucoup d'instructions peuvent lever des exceptions, mais elles en lvent rarement. On peut gagner en performance avec cette technique. Il faut toutefois signaler que cette technique ne marche que pour les exceptions, pas pour les interruptions logicielles. Ces dernires vont toujours crer des vides dans le pipeline. Mais elles sont rares, et cela ne pose pas de problmes.

Ordre des critures

Pour implmenter cette technique, notre processeur doit trouver un moyen pour que les instructions excutes grce la spculation ne fassent aucun mal si jamais la spculation est fausse. En clair, toutes les instructions qui suivent une exception dans l'ordre du programme ne doivent pas finir leur excution, et tous les changements qu'elles peuvent faire doivent tre annuls ou empchs. Ces instructions ne doivent pas aller modifier la mmoire, ou modifier les registres. Et elles ne doivent pas aller toucher au Program Counter : sans cela, on ne saura pas quelle adresse notre programme doit reprendre une fois l'exception traite. Pour rsoudre ce problme, on utilise deux grandes mthodes. Pour rgler ce problme, on doit d'abord faire en sorte que les modifications effectues par une instruction se fassent dans l'ordre du programme. En clair : les critures dans la mmoire, les registres, et le Program Counter doivent se faire dans le mme ordre que celui qui est spcifi dans le programme. On pourrait croire que c'est dj le cas avec notre pipeline tel qu'il est actuellement : les instructions sont charges dedans, et sexcutent dans l'ordre impos par le programme. Mais en fait, ce n'est pas le cas. La raison est simple : les instructions ne prennent pas le mme nombre de cycles, certaines tant plus rapides que d'autres.

Exemple
Prenons cet exemple : je charge deux instructions l'une la suite de l'autre dans mon pipeline. La premire est une lecture en mmoire et prend 8 cycles pour sexcuter, tandis que la seconde est une multiplication qui prend 4 cycles.

Ces deux instructions sont indpendantes, et pourtant, on est face un problme. On a beau avoir dmarr les instructions dans l'ordre, les rsultats de ces instructions ne sont pas enregistres dans les registres ou la mmoire dans l'ordre impos par le programme. En clair : si la premire instruction lve une exception, les rsultats de la seconde auront dj t enregistrs dans les registres. Le mal est fait : tout se passe comme si l'exception avait t retard d'une instruction. Cela peut donner n'importe quoi. On est donc face un problme : comment maintenir l'ordre d'arrive des rsultats dans les registres/la mmoire ?

How to deal with ?

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

293/378

La premire solution est la plus simple : elle consiste ajouter des Pipeline Bubbles pour retarder certaines instructions. Si une instruction est trop rapide et risque d'crire son rsultat avant ses prdcesseurs, il suffit simplement de la retarder en ajoutant quelques Pipeline Bubbles au bon moment.

Result Shift Register

Nous allons donc voir comment faire pour implmenter la premire solution, savoir : ajouter des Pipeline Bubbles pour retarder les instructions fautives. Pour ce faire, on utilise un circuit spcial, qu'on appelle le Result Shift Register .

Maintien de l'ordre
Dans sa version la plus simple, il s'agit de ce qu'on appelle un registre dcalage. Ce n'est rien de moins qu'un registre un peu spcial, qui dcale son contenu vers la droite chaque cycle d'horloge. J'ose esprer que vous vous souvenez des dcalages, vu dans le chapitre sur l'ALU. Ce registre dcalage contient autant de bits qu'il y a d'tages dans notre pipeline. Chacun de ces bits signifiera que cet tage est utilis par une instruction dmarre prcdemment. A chaque cycle d'horloge , ce registre est dcal d'un cran vers la droite. Cela permet de prendre en compte le fait que chaque instruction progresse d'un tage chaque cycle d'horloge. Il va de soit que ce dcalage est un dcalage logique, qui remplit les vides par des zros. Lorsque l'unit de dcodage veut dmarrer lexcution d'une instruction, celle-ci va alors vrifier le nombre de cycles que va prendre l'instruction pour sexcuter. Il va alors vrifier le bit numro i (en partant de la droite) de ce registre. Si il est 1, cela signifie qu'une autre instruction est dj en cours pour cet tage. L'instruction va devoir attendre que cet tage soit libre dans lunit de dcodage. En clair : on ajoute des Pipeline Bubbles. Si ce bit est 0, lunit va alors le placer 1, ainsi que tous les bits prcdents. Cela permet d'viter qu'une instruction plus courtes aille sexcuter avant que notre instruction soit finie. Et l'instruction sexcutera.

Version amliore
Dans ses versions plus labores, ce Result Shift Register contient, pour chaque instruction envoye dans le pipeline, non seulement un bit qui prcise si l'tage est occup, mais aussi des informations sur l'instruction. L'unit de calcul qu'elle utilise, le registre dans lequel elle veut stocker son rsultat, et l'adresse de l'instruction. Ces informations permettent de piloter l'criture des rsultats de nos instructions en mmoire, et sont utile pour d'unit de dcodage : cette dernire a besoin dinformations pour savoir s'il faut gnrer ou non des Pipeline Bubbles. Par exemple, on stocke l'adresse de l'instruction pour remettre le Program Counter sa bonne valeur, si une exception arrive. Et oui, ce Program Counter est modifi automatiquement par l'unit de Fetch chaque cycle. Et si une exception arrive, il faut trouver un moyen de remettre le Program Counter la bonne valeur : celle de l'instruction qui a leve l'exception, afin de pouvoir savoir o brancher au retour de l'exception. On stocke le registre de destination pour savoir dans quel registre cette instruction doit crire, et aussi pour savoir quels sont les registres utiliss par les instructions en cours dans le pipeline. J'avais dit plus haut que pour l'unit de dcodage devait vrifier si l'instruction qu'elle sapprte lancer va lire une donne crite pas une instruction encore dans le pipeline. Si c'est le cas, l'unit de dcodage doit alors insrer des Pipeline Bubbles. Et bien la liste des registres crit pas les instructions prsentes dans notre pipeline se trouve dans ce Result Shift Register. En tout cas, notre Result Shift Register est un peu plus complexe. Celui-ci est compos d'entres, des espces de blocs de mmoire qui stockent toutes les informations pour une instruction. Unit de calcul utilise, registre de destination, Program Counter, et bit indiquant que l'tage est occup. Auparavant, avec la version simplifie du Result Shift Register, seul les bits indiquant l'occupation d'un tage taient dcals vers la droite. Mais avec la version volue du Result Shift Register, ce sont toutes les entres qui sont dcales d'un cran chaque cycle d'horloge.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

294/378

Speculation Recovery
Maintenant, il nous reste savoir quand traiter et dtecter ces exceptions. Et pour cela, il n'y a pas de miracle : ces exceptions sont dtectes dans le pipeline, quand elles sont leves par un circuit. Mais elles ne sont prises en compte qu'au moment d'enregistrer les donnes en mmoire, dans l'tage de Writeback. Mais pourquoi ?

Imaginez que dans l'exemple du dessus, les deux instructions lvent une exception des tages diffrents. Quelle exception traiter en premier ?

Il va de soit qu'on doit traiter ces exceptions dans l'ordre du programme, donc c'est celle de la premire instruction qui doit tre traite. Mais les deux exceptions ont lieu en mme temps. En traitant les exceptions la fin du pipeline, on permet de traiter les exceptions dans leur ordre doccurrence dans le programme. C'est trs utile quand plusieurs exceptions sont leves dans le pipeline.

Prise en compte des exceptions

Lorsqu'une exception a lieu dans un circuit de notre processeur, ce circuit va devoir prvenir qu'il y a eu une exception. Mais vu que celle-ci doit tre prise en compte une fois que l'instruction fautive arrive la fin du pipeline, il faut trouver un moyen de mettre en attente celle-ci. Pour cela, nos circuits vont disposer de quelques bits, qui indiquent si une exception a eu lieu et qui permettent de prciser laquelle. Ces bits vont ensuite passer d'un tage un autre, en mme temps que l'instruction qui a leve l'exception.

Une fois arriv la fin, un petit circuit combinatoire va alors vrifier ces bits (pour voir si une exception a t leve), et va agir en consquence.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

295/378

Annulation des critures fautives

Maintenant, comment faire pour remettre le pipeline en bon tat si une exception arrive ? Aprs tout, il faut bien viter que nos instructions excutes trop prcocement, celles qui suivent l'exceptions et ont ts charges dans notre pipeline, ne fassent pas de dgts. On doit remettre notre pipeline comme si ces instructions n'avaient pas ts charges. La solution est trs simple . Il suffit de rajouter un dernier tage dans le pipeline, qui sera charg d'enregistrer les donnes dans les registres et la mmoire. Si jamais une exception a lieu, il suffit de ne pas enregistrer les rsultats des instructions suivantes dans les registres, jusqu ce que toutes les instructions fautives aient quittes le pipeline. Ainsi, ni la mmoire, ni les registres, ni le Program Counter ne seront modifis si une exception est leve. Tout se passera comme si ces instructions excutes trop prcocement ne s'taient jamais excutes.

Out Of Order Completion

On a vu plus haut que pour grer correctement nos exceptions et interruptions prcises, nous sommes obligs de maintenir l'ordre des critures en mmoire ou dans nos registres. Nous avons vu une premire solution qui consistait retarder lexcution de certaines instructions en ajoutant des Pipeline Bubbles. Mais il existe d'autres solutions. Ces solutions vitent de devoir retarder certaines instructions, et vite ainsi d'insrer des Pipeline Bubbles dans notre pipeline. Notre pipeline pourra excuter des instructions la place : on gagne ainsi en performances. Nous allons voir certaines de ces techniques dans ce qui suit. Il existe plusieurs solutions ce problme. On peut utiliser : Un History Buffer ; Un Future File ; ou autre chose.

Re-Order Buffer
La premire solution consiste excuter nos instructions sans se proccuper de l'ordre des critures, avant de remettre celles-ci dans le bon ordre. Le tout sera d'envoyer dans le bon ordre les rsultats des instructions dans les registres. Pour remettre en ordre ces critures, les rsultats des instructions seront mis en attente dans une sorte de mmoire tampon, avant d'tre autoriss tre enregistrs dans les registres une fois que cela ne pose pas de problmes.

Cette mmoire tampon s'appelle le Reorder Buffer, et elle fera l'objet d'un chapitre dans la suite du tutoriel. On la laisse de cot pour le moment.

History Buffer
Autre solution pour retrouver les bonnes valeurs de nos registres : on laisse nos instructions crire dans les registres dans l'ordre qu'elles veulent, mais on garde des informations pour retrouver les bonnes valeurs de nos registres. Ces informations sont stockes dans ce qu'on appelle l'History buffer.

Une file
Cette sauvegarde doit tre faite pour chaque instruction. Ainsi, notre History buffer est organis en plusieurs entres, des espces de blocs de mmoire qui de quoi revenir la normale pour chaque instruction. A chaque fois qu'on veut dmarrer une instruction, on rserve une entre pour notre instruction, et on la rempli avec les informations qu'il faut. Une fois qu'on sait que notre instruction s'est termine sans exception, on libre l'entre occupe par notre instruction. Pour grer nos instructions dans l'ordre du programme, ces entres sont tries de la plus ancienne a la plus rcente. V oyons comment cela est fait.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

296/378

Notre History buffer contient un nombre d'entre qui est fix, cbl une fois pour toute. Chacune de ces entres est identifie par un nombre, qui lui est attribu dfinitivement.

Ces entres sont gres par leur identifiant. Le numro de l'entre la plus ancienne est ainsi mmoris dans une petite mmoire. Cela permet de pointer sur cet entre, qui contient la prochaine donne enregistrer dans les registres ou la mmoire.

Quand cette entre quitte le History buffer, le numro, le pointeurs sur la dernire entre est augment de 1, pour pointer sur la prochaine entre. De mme, le numro de l'entre la plus rcente est aussi mmoris dans une petite mmoire. Il faut bien savoir o ajouter de nouvelles entres. Ainsi, le History buffer sait quelles sont les entres valides : ce sont celles qui sont situes entre ces deux entres.

Quand on ajoute une instruction dans le History buffer, il ne faut pas oublier d'augmenter ce numro de 1. Petit dtail : quand on ajoute des instructions dans le History buffer, il se peut que l'on arrive au bout, l'entre qui a le plus grand nombre. Pourtant, le History buffer n'est pas plein. De la place se libre dans les entres basses, au fur et mesure que le History buffer. Dans ce cas, on n'hsite pas reprendre depuis le dbut. Exemple : je prends l'exemple prcdent, avec l'entre 4 occupe. Si je rajoute une instruction, je remplirais l'entre 5.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

297/378

La prochaine entre tre remplie sera l'entre numrot 0. Et on poursuivra ainsi de suite.

Contenu des entres

Lorsqu'une instruction sexcute, elle va souvent modifier le contenu d'un registre. Si jamais notre instruction a t excute alors qu'elle n'aurait pas due, on perdra l'ancienne valeur de ce registre et on ne pourra pas la remettre la normale. La solution est de sauvegarder cette ancienne valeur dans notre History buffer. Ainsi, quand on envoie notre instruction l'ALU, on va lire le contenu du registre de destination, et le sauver dans l'History buffer. Ainsi, en cas d'exception, on sait retrouver la valeur modifie par notre instruction. Mais cette valeur, dans quel registre la remettre en place ? Et bien on n'a pas trop le choix : on doit aussi se souvenir quel registre t modifi par notre instruction. Ensuite, il faut savoir si lexcution de l'instruction est termine. On va donc rajouter un bit Valid, qui indique si l'instruction est termine. De mme, il faut savoir si celle-ci s'est termine sans exception. Et on rajoute un bit Exception qui indique si l'instruction a leve une exception. Avec cette technique, les exceptions sont encore une fois gres la fin de l'instruction : la dtection des exceptions se fait au dernier tage de notre pipeline, exactement comme dans les techniques prcdentes. Et enfin, si notre instruction lve une exception, on doit savoir o reprendre. Donc, on sauvegarde l'adresse de notre instruction. Celle-ci est disponible dans le Program Counter.

Principe
Lorsqu'une instruction situe dans l'entre la plus ancienne a lev une exception, celle-ci est dtecte grce au bit Exception dans l'entre qu'elle occupe. Il suffit alors d'annuler toutes les modifications faites par cette instruction et les suivantes. Pour annuler les modifications d'une instruction, il suffit de remettre le registre modifi par l'instruction a son ancienne valeur. Pour cela, on utilise les informations stockes dans l'History buffer. Pour remettre les registres dans leur tat valide, on vide l'History buffer dans l'ordre inverse d'ajout des instruction. En clair : on commence par annuler les effets de linstruction la plus rcente, et on continue de la plus rcente la plus ancienne jusqu' vider totalement l'History buffer. Une fois le tout termin, on retrouve bien nos registres tels qu'ils taient avant l'xecution de l'exception.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

298/378

Future File
L'History Buffer possde un grand dfaut : en cas d'exception ou d'interruption, on est oblig de remettre les registres leur bonne valeur. Et cela se fait en copiant la bonne valeur de l'History Buffer dans les registres. Et cela peut prendre du temps. Cela peut trs bien ne pas poser de problmes : aprs tout, les exceptions sont rares. Seul problme : on verra dans les prochains chapitres que les branchements posent des problmes similaires aux exceptions et que les solutions utilises pour nos exceptions sont rutilisables. Mais les branchements sont beaucoup plus nombreux que les exceptions : environ une instruction sur 10 est un branchement. Et dans ces conditions, l'History Buffer et ses remises en l'tat des registres sont trop lentes. On doit donc trouver une autre alternative.

Deux Register Files

La solution est celle du Future File. Cette solution consiste avoir deux Register File. Le premier Register File contient les valeurs les plus rcentes, celles qu'on obtient en supposant l'absence d'exceptions. On l'appelle le Future File. L'autre va servir stocker les donnes valides en cas d'exception, et il s'appelle le Retiremment Register File. Avec cette technique, nos instructions sont excutes sans se proccuper de l'ordre de leurs critures. Leur rsultat sera enregistr dans le Future File. Les oprandes de nos instructions seront aussi lues depuis le Future File, sauf en cas d'exception. En cas d'exception, les oprandes sont alors lues depuis l'autre Register File, celui qui contient les donnes valides en cas d'exception. Pour que ce dernier contiennent les bonnes donnes, on doit lui envoyer les rsultats des instructions dans le bon ordre. Pour remettre en ordre ces critures, les rsultats des instructions seront mis en attente dans une sorte de mmoire tampon, avant d'tre autoriss tre enregistrs dans les registres une fois que cela ne pose pas de problmes. Cette mmoire tampon est un History Buffer modifi qu'on appelle le Re-Order Buffer. Celui-ci contient exactement la mme chose qu'un History Buffer normal, un dtail prt : au lieu de stocker l'ancienne valeur d'un registre (celle avant modification), il stockera le rsultat de l'instruction.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

299/378

Et compar l' History Buffer ?

Cette technique a deux gros avantages compar l'History Buffer. En cas d'exception, pas besoin de remettre les registres leur bonne valeur : ces bonnes valeurs sont directement disponibles depuis le Retiremment Register File. On supprime ainsi de nombreuses oprations de copie, qui peuvent plomber les performances. Ensuite, on n'a plus besoin d'ajouter un port au Register File, qui servait lire l'ancienne valeur du registre modifier pour la stocker dans l'History Buffer. Et des ports en moins, a signifie Register File plus rapide et qui chauffe moins. Par contre, l'utilisation d'un Future File requiert pas mal de circuits.

Autre solution
Pour donner un exemple d'autre solution, on pourrait faire des sauvegardes rgulires de nos registres de temps autre, et rcuprer cette sauvegarde lors d'une exception. Il suffirait alors de poursuivre lexcution partir de notre sauvegarde jusqu' retomber sur l'instruction qui lve l'exception, et agir en consquence. Seul problme, cette solution est lente : sauvegarder tous les registres du processeur n'est pas gratuit. En consquence, cette solution n'est donc jamais utilise.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

300/378

Les branchements viennent mettre un peu d'ambiance !

On a vu dans le chapitre sur le pipeline que les branchements avaient un effet plutt dltre sur celui-ci. En effet, avec les branchements, on ne peut pas savoir l'avance quelle sera la prochaine instruction charger dans le pipeline (qui n'est autre que l'adresse de destination du branchement) : cette adresse de destination est connue au minimum une fois l'instruction dcode, et parfois plus loin. On ne sait donc pas quoi charger l'tape de fetch suivante. Cela ne poserait pas le moindre problme si ces branchements n'taient pas nombreux, mais ce n'est pas le cas : diverses analyses faites dans les annes 1985 ont montres que dans un programme, environ une instruction sur 15 tait un branchement dont plus de la moiti taient des appels ou retours de sous-programme. Et depuis, la situation est devenue encore pire avec la prminence de la programmation objet : celle-ci est souvent l'origine d'un plus grand nombre d'appels de fonctions (dans ce genre de langages, les sous-programmes sont plus courts mais plus nombreux, avec moins d'instructions) et plus de branchements indirects. Autant dire que les branchements posent un srieux problme et empchent d'obtenir de bonnes performances avec notre pipeline. Pour rsoudre ce problme, il a fallu trouver des techniques plus ou moins efficaces pour limiter la catastrophe. Ce chapitre va parler des diffrentes techniques inventes pour rsoudre ce problme.

Effet des branchements sur le pipeline

Mais que se passe-il dans le pipeline quand on excute un branchement ?

Pour expliquer quel est le problme avec les branchements, on va prendre un exemple et voir ce qui se passe tapes par tapes. V notre exemple : oici

Dans notre exemple, on a un branchement qui est localis l'adresse 2500, qui veut faire reprendre lexcution de notre programme l'adresse 1600. Il est suivi d'instructions, qui sont censes ne pas tre excutes si le branchement est pris (on va supposer qu'il l'est). On va donc charger ce branchement dans notre pipeline.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

301/378

Premier dtail : on ne connaitra l'adresse de destination qu'une fois le branchement dcod. En effet, c'est lors de l'tape de dcodage (ou dans l'tape suivante, qui permet de calculer des adresses) que les modes d'adressages sont grs par le squenceur, et que le processeur va "comprendre" que l'instruction est un branchement et dduire l'adresse de destination. Avant la fin de l'tape de dcodage, le processeur ne sait pas que le contenu du registre d'adresse d'instruction va tre modifi et il continue l'incrmenter pour pinter sur l'instruction suivante. Ce registre ne sera mit jour que quand l'adresse du branchement sera connue, ce qui arrive aprs l'tape de decode ou l'tape de calcul d'adresse de l'oprande : notre registre d'adresse d'instruction continuera donc de fonctionner comme s'il n'y avait pas eu de branchements ! Vu ce qu'on vient de dire, au cycle dhorloge suivant, le processeur chargera dans le pipeline l'instruction qui suit ce branchement dans la mmoire, au lieu de fetcher l'instruction vers laquelle brancher. Et il continuera tant que l'adresse de destination ne sera pas connue. Quelques instructions suivant notre branchement en mmoire seront ainsi charges dans notre pipeline pour tre excutes. Ainsi, nos instruction Add RO R1 et Shr R0 R1 seront charges dans le pipeline, alors qu'elles n'auraient pas du tre excutes. Fetch JMP 1600 Predecode Decode Exec Writeback -

Add RO R1 JMP 1600 Shr RO R1 Imul R5 R4

Add RO R1 JMP 1600 Shr RO R1

Add RO R1 JMP 1600 -

On saperoit qu la situation fini par revenir la normale, une fois le branchement dcod : on fini bien par brancher l'adresse 1600, qui semble contenir une instruction Imul. Quand l'adresse de destination du branchement est connue, le registre d'adresse d'instruction est modifi et les choses reviendront la normale : le processeur fetchera alors l'instruction vers laquelle brancher. Le seul problme, c'est qu'entre le moment o le branchement est fetch dans le pipeline et le moment o le branchement est dcod, notre processeur a commencer excuter des instructions qui n'auraient pas du l'tre ! Et il est dj trop tard : les instructions excutes par erreur auront peut-tre modifies des registres et modifies les donnes utilises plus tard par des instructions, ou commit quelques autres mfaits : notre processeur ne peut garantir que le programme se comportera comme le programmeur l'a prvu et de nombreux bugs peuvent apparaitre.

Les solutions de base

Comme on vient de le voir, nos branchements posent quelques problmes, et il a bien fallu trouver une solution. Pour cela, quelques solutions simplistes ont t trouves, et c'est celles-ci dont on va parler en premier lieu.

Dlai de branchements
La solution la plus simple est...de ne rien faire en attendant de connaitre l'adresse vers laquelle brancher. Il nous faut donc inclure des instructions qui ne font rien la suite du branchement : c'est ce qu'on appelle un dlai de branchement. En rajoutant juste ce qu'il faut d'instructions qui ne font rien et en connaissant la longueur du pipeline, le compilateur pourra viter les problmes. On peut limiter la casse en remplissant le vide d'instructions qui suit le branchement par des instructions indpendantes du branchement, mais cela a ses limites : a n'est pas toujours possible. Dj, il faut que notre compilateur sache quel tage du pipeline l'adresse du branchement est connue. Et cela varie suivant les processeurs, mme pour des processeurs ayant un jeu d'instruction identique : par exemple, cet tage n'est pas le mme entre un Core 2 Duo et un Pentium 4 ! Certains connaissent cette adresse tt, d'autres plus tard. Autant vous dire qu'avec cette solution, il faudrait recompiler ou reprogrammer tous nos programmes pour chaque processeur.

Les processeurs malins

Dautres processeurs dcident de prendre le problme bras le corps. Ils arrivent dtecter les branchements dans le tout premier tage du pipeline, et arrtent de charger les instructions tant que l'adresse vers laquelle brancher nest pas connue. Cela demande de rajouter quelques circuits, mais rsout le problme rencontr au-dessus. Quoiqu'il en soit, cette solution n'est pas parfaite : un programme contient toujours beaucoup de branchements et beaucoup de temps est gch ne rien faire juste avant ces branchements. Il nous faut donc trouver d'autres solutions.

Branch Free Code

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

Une premire solution pour viter les problmes avec les branchements est tout simplement de les remplacer par dautres instructions assez simples qui ne poseront pas de problme lexcution.

302/378

Certains calculs souvent utiliss dans un programme peuvent ainsi utiliser des branchements inutilement. Par exemple, le calcul de la valeur absolue d'un nombre, ou le calcul du maximum de deux nombres. Gnralement, ces calculs sont effectues via des instructions de branchements. Vu que ces calculs sont assez communs, le processeur peut fournir des instructions capables d'effectuer ces calculs directement : le jeu d'instruction du processeur peut ainsi contenir des instruction ABS, MIN, MAX, etc. On peut ainsi se passer de branchements pour ces calculs. Si jamais le processeur ne fourni pas ces instructions, on peut quand mme se passer de branchements pour effectuer ces calculs. Il arrive parfois qu'on puisse remplacer certains morceaux de code utilisant des branchements par des morceaux de programmes utilisant des instruction arithmtiques et logiques, sans branchements. Divers hacks plus ou moins efficaces (et surtout plus ou moins affreux) existent : allez voir sur google et renseignez-vous sur les diffrentes techniques de bit twiddling ou de bit hacking , vous verrez que de nombreux calculs simples peuvent se passer de branchements. Bien sr, ces techniques ont aussi d'autres qualits : plus on supprime de branchements, plus le compilateur sera apte modifier l'ordre des instructions pour grer le pipeline au mieux, et plus il pourra utiliser les registres bon escient. Utiliser ces technique peut donc tre utile, au cas o. Du moins, si vous n'avez pas peur de nuire la lisibilit de votre programme.

Instructions prdicats
Ceci dit, fournir des instructions pour supprimer des branchements est une bonne ide qui va plus loin que ce qu'on a vu plus haut. Certains concepteurs de processeurs ont ainsi voulu crer des instructions plus gnrale, capables de supprimer un plus grand nombre de branchements. Ainsi sont nes les instructions prdicat ! Ces instructions prdicat sont des instructions "normales", comme des additions, copie d'un registre dans un autre, multiplication, accs mmoire, etc ; avec une diffrence : elles ne font quelque chose que si une condition est respecte, valide. Dans le cas contraire, celles-ci se comportent comme un nop, c'est dire une instruction qui ne fait rien !

Utilit
Leur but ? Rendre les branchements inutiles pour la construction de petites structures de contrle de type Si...Alors ou Si...Alors...Sinon. Avec ces instructions, il suffit dutiliser une instruction de test et de placer les instructions excuter ou ne pas excuter (en fonction du rsultat de l'instruction de test) immdiatement la suite. Si la condition teste par l'instruction de test est ralise, nos instructions feront ce qui leur est demand tandis qu'elles ne feront rien dans le cas contraire : c'est bien ce qu'on attend d'un Si...Alors ou d'un Si...Alors...Sinon

Dfauts
videmment, ces instructions ont quelques dfauts : elles ne sont utiles que pour des Si...Alors ou des Si...Alors...Sinon contenant peu d'instructions. Si ceux-ci contiennent beaucoup d'instructions, nos instructions prdicat ne feront rien durant un moment alors qu'un branchement aurait permis de zapper directement les instructions ne pas excuter. De mme, ces instructions entrainent l'apparition de dpendances de donnes : les instructions qui les suivent seront dpendantes de leur rsultat. Ce ne serait pas le cas avec d'autres techniques comme la prdiction de branchement. Autant dire que ces instructions ne rsolvent pas grand chose et que d'autres techniques doivent imprativement tre trouves.

L'exemple du processeur Itanium d'Intel

Pour donner un exemple d'instructions prdicats, je vais vous parler des instructions de l'Itanium, un processeur invent par Intel dans les annes 2000. Ce processeur avait une architectures et un jeu d'instruction assez rvolutionnaire, avec de nombreuses fonctionnalits innovantes, mais cela n'a pas empch celui-ci de faire un bide. L'Itanium ne possde pas de registre d'tat. A la place, l'Itanium possde plusieurs registres d'tats de un bit ! Il y en a en tout 64, qui sont numrots de 0 63. Chacun de ces registres peut stocker une valeur : vrai (un) ou faux (zro). Le registre 0 est en lecture seule : il contient toujours la valeur vrai, sans qu'on puisse le modifier. Ces registres sont modifis par des instructions de comparaison, qui peuvent placer leur rsultat dans n'importe quel registre prdicat. Elle doivent tout de mme prciser le registre dans lequel stocker le rsultat. C'est assez diffrent de ce qu'on trouve sur les processeurs x86. Sur un processeur x86, il n'y a pas de registre prdicat. A la place, les instructions prdicat prcisent implicitement un bit dans le registre d'tat. Une instruction prdicat est ainsi conue pour ne lire qu'un seul bit du registre d'tat en particulier, et ne peut lire les autres. Mais revenons l'Itanium. Chaque instruction prdicat va prciser quel est le registre qui contient la valeur vrai ou faux permettant d'autoriser ou d'interdire son excution en utilisant un mode d'adressage spcial. L'instruction sexcutera normalement si ce registre contient la valeur vrai, et elle ne fera rien sinon. Petite remarque : une instruction peut carrment spcifier plusieurs registres. Ainsi, une instruction peut sexcuter si deux registres prdicats sont vrais. Par exemple, elle peut faire un ET logique sur ces deux bits

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

et dcide de sexcuter si jamais le rsultat est true. Elle peut aussi faire un OU logique, un XOR, un NAND, etc.

303/378

Prdiction de branchement
Pour viter ces temps d'attente, les concepteurs de processeurs ont invent ce qu'on appelle lexcution spculative de branchement. Cela consiste essayer de deviner l'adresse vers laquelle le branchement va nous envoyer suivant sa nature, et lexcuter avant que celui soit dcod et que l'adresse de destination soit connue. On va donc devoir essayer de prdire quel sera le rsultat du branchement et vers quelle adresse celui-ci va nous envoyer. Ce ncessite de rsoudre deux problmes : savoir si un branchement sera excut ou non : c'est la prdiction de branchement ; dans le cas o un branchement serait excut, il faut aussi savoir quelle est l'adresse de destination : c'est la prdiction de direction de branchement. Pour rsoudre le premier problme, notre processeur contient un circuit qui va dterminer si notre branchement sera pris (on devra brancher vers l'adresse de destination) ou non-pris (on poursuit lexcution de notre programme immdiatement aprs le branchement) : c'est l'unit de prdiction de branchement. La prdiction de direction de branchement fait face un autre problme : il faut dterminer l'adresse de destination de notre branchement. Cette prdiction de direction de branchement est dlgue un circuit spcialis : lunit de prdiction de direction de branchement. Ces deux units sont relies lunit en charge du fetch, et travaillent de concert avec elle. Dans certains processeurs, les deux units sont regroupes dans le mme circuit.

Erreurs de prdiction
Bien videmment, une erreur est toujours possible : le processeur peut se tromper en faisant ses prdictions : il peut se tromper d'adresse de destination par exemple. Et le processeur doit viter tout problme. On a alors deux cas : soit les instructions charges en avance sont les bonnes : le processeur a donc gagn du temps et continue simplement son excution ; soit les instructions prcharges ne sont pas les bonnes : c'est une erreur de prdiction. Que faire lors d'une erreur de prdiction ?

Vider le pipeline
Dans ce cas, notre pipeline aura commenc excuter des instructions qui n'auraient pas du tre excutes. Il faut donc faire en sorte que ces instructions n'enregistrent pas leurs rsultats et soient stoppes si possible. La gestion des mauvaises prdiction dpend fortement du processeur, et certains sont plus rapides que d'autres quand il s'agit de grer ce genre de cas : certains peuvent reprendre lexcution du programme immdiatement aprs avoir dtect la mauvaise prdiction (ils sont capables de supprimer les instructions qui n'auraient pas du tre excutes), tandis que d'autres ne peuvent le faire immdiatement et doivent attendre quelques cycles. Dans le pire des cas, ces instructions qui n'auraient pas du tre charges ne peuvent pas tre interrompues et on doit attendre qu'elles aient fini leur excution : elles vont poursuivre leur chemin dans le pipeline, et progresser tage par tage jusqu' leur dernire tape. On est donc oblig d'attendre que celle-ci arrivent leur toute dernire tape avant de pouvoir faire quoique ce soit : il faut que ces instructions quittent le pipeline et que celui-ci soit vid de ces instructions poubelle. Tant que ces instructions ne sont pas sorties du pipeline, on est oblig d'attendre sans pouvoir charger d'instructions dans notre pipeline. Ce temps d'attente est du temps de perdu. Exemple : un pipeline 5 tages : Fe : Fetching ; De : Dcodage ; Of : Operand Fetching ; Ex : Excution ; Wb : Write back.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

On suppose que l'adresse de destination est connue l'tape Ex.

304/378

On suppose que l'on excute un branchement JMP dans notre pipeline et que celui-ci est mal prdit : le processeur se trompe d'adresse de destination. Ce qui fait que tant que notre adresse destination relle n'est pas connue, notre processeur continue charger les instructions partir de la fausse adresse de destination qu'il a prdit. Dans le tableau qui va suivre, X reprsente des instructions qui doivent tre excutes normalement et Ix reprsente des instructions qui n'auraient pas du tre executes. Les tirets reprsentent des tages qui ne font rien.

tat du pipeline Normal Normal Vidage du pipeline Vidage du pipeline Vidage du pipeline Vidage du pipeline Vidage du pipeline Restauration du pipeline Normal

Fe Jmp I1 I2 Jmp

De X1 Jmp I1 I2 X1

Of X2 X1 Jmp I1 I2 X2 X1

Ex X3 X2 X1 Jmp I1 I2 X3 X2

Wb X4 X3 X2 X1 Jmp I1 I2 X4 X3

X265 Jmp

A la ligne 3, le processeur repre une erreur de prdiction : au cycle d'horloge suivant, il ne chargera pas d'instruction et commencera vider le pipeline. Une fois la pipeline vid, il faudra restaurer celui-ci son tat originel (avant lexcution du branchement) pour viter les problmes, et recommencer excuter les bonnes instructions.. On remarque une chose importante dans notre exemple : cela prend 5 cycles pour vider le pipeline, et notre pipeline possde 5 tages. Ce temps d'attente ncessaire pour vider le pipeline est gal au nombres d'tages de notre pipeline. Sachez que c'est vrai tout le temps, et pas seulement pour des pipelines de 5 tages. En effet, la dernire instruction tre charge dans le pipeline le sera durant l'tape laquelle on dtecte l'erreur de prdiction : il faudra attendre que cette instruction quitte le pipeline, et qu'elle passe par tous les tages de celui-ci.

Restaurer le pipeline
De plus, il faut remettre le pipeline dans l'tat qu'il avait avant le chargement du branchement dans le pipeline. Tout se passe lors de la dernire tape. Et pour cela, diverses solutions existent, suivant le processeur. Premire solution : faire en sorte que les modifications et calculs effectues par les instructions fautives ne soient pas enregistres en mmoire ou dans les registres : il faut donc faire en sorte que la dernire tape de ces instructions ne fasse rien et n'enregistre pas les rsultats de ces instructions. Pour cela, nos instructions vont utiliser des registres tampons spcialement ddis pour stocker leurs rsultats temporaires et les oprandes qu'elles doivent modifier, ce qui vite de manipuler les donnes originales. Le rsultat de l'instruction, est recopi dans le registre final lors de leur dernire tape si aucune erreur de prdiction n'a eu lieu. Dans le cas contraire, les modifications et manipulations effectues par notre instruction ne sont pas crites dans le registre ou la case mmoire voulue et le tout est simplement oubli et perdu. Deuxime solution : on laisse nos instructions crire leurs rsultats et manipuler leurs rsultats et on restaure les donnes valides, qui auront pralablement ts sauvegardes quelque part dans le processeur. Quoiqu'il en soit, ces deux solutions sont assez lourdes et demandent ce que notre processeur dtecte automatiquement les erreurs de prdiction : a utilise pas mal de circuits assez complexes.

Prdiction de direction de branchement

Quand un branchement est non-pris, on sait exactement quelles instructions charger : celles qui suivent en mmoire. Il n'y a alors pas de difficult.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

Mais dans le cas o on considre un branchement pris, que faire ? A quelle adresse le branchement va-t-il nous envoyer ?

305/378

Sans la rponse cette question, impossible de charger les bonnes instructions, et on doit alors attendre que l'adresse de destination soie connue : en clair, effectuer un dlai de branchement. La prdiction de direction de branchement sert compenser ce manque en prdisant quelle sera l'adresse de destination. Bien sur, une unit de prdiction de direction de branchement n'est pas un circuit extralucide, mais utilise quelques algorithmes simples pour dduire l'adresse de destination. Cette prdiction est plus ou moins facile suivant le type de branchements. La prdiction de branchement se moque qu'un branchement soit conditionnel ou inconditionnel, ce qui l'intresse c'est de savoir si le branchement est : un branchement direct, pour lequel l'adresse de destination est toujours la mme ; ou un branchement indirect, pour lequel l'adresse de destination est une variable et peut donc changer durant excution du programme. Les branchements directs sont plus facilement prvisibles : l'adresse vers laquelle il faut brancher est toujours la mme. Pour les branchements indirects, vu que cette adresse change, la prdire celle-i est particulirement compliqu (quand c'est possible). V oyons maintenant comment notre unit de prdiction de direction de branchement va faire pour prdire quelle sera l'adresse de destination de notre branchement.

Branch Barget Buffer

Une solution ce problme a t trouve dans certains cas : lorsqu'un branchement direct est excut plusieurs fois dans un programme dans un court intervalle de temps. L'ide consiste se souvenir de l'adresse de destination du branchement lors de sa premire excution. Si notre branchement est un branchement direct, cette adresse de destination sera toujours la mme (sauf cas particuliers tellement anecdotiques qu'on ferait bien de ne pas en parler) : ainsi, lors des excutions suivante du mme branchement, on saura d'avance quelle est l'adresse de destination. Pour se souvenir de l'adresse de destination d'un branchement, on a besoin d'une petite "mmoire" capable de retenir pour chaque branchement, l'adresse vers laquelle celui-ci nous fait brancher : le Branch Target Buffer. Ce branchement est une instruction qui est place une adresse bien prcise. Notre branchement est ainsi identifi dans le Branch Target Buffer par son adresse en mmoire. Celui stocke l'adresse du branchement, et l'adresse de destination. Ne pas confondre les deux adresses !

Ce Branch Target Buffer est souvent implment comme un cache fully associative : il est dcoup en lignes de cache qui contiennent l'adresse de destination du branchement et dont le tag contient l'adresse du branchement. Pour prdire l'adresse de destination d'un branchement, il suffit de vrifier les tags de chaque ligne et de comparer avec l'adresse du branchement excuter : si un tag correspond, on a alors un Branch Target Buffer Hit et le Branch Target Buffer contient l'adresse de destination du branchement. Dans le cas contraire, on ne peut pas prdire l'adresse de destination du branchement : c'est un Branch Target Buffer Miss. Le fonctionnement de lalgorithme de prdiction de branchement bas sur un Branch Target Buffer est simple. A la premire excution du branchement, on attend donc que le branchement s'excute et on mmorise l'adresse du branchement ainsi que l'adresse de destination. A chaque nouvelle excution de ce branchement, il suffit de lire l'adresse de destination contenue dans le Branch Target Buffer et continuer l'excution du programme cette adresse. Il va de soit que cette technique ne peut rien lors de la premire excution d'un branchement. De plus, cela ne marche pas dans certains cas impliquant des branchements indirects, pour lesquels l'adresse de destination peut varier. Lorsque cette adresse de destination change, le Branch Target Buffer ne sert rien et une erreur de prdiction a lieu. Pour information, sachez que notre Branch Target Buffer ne peut stocker qu'un nombre limit d'adresses. Sur les processeurs x86 actuels, le nombre d'adresses est d'environ 64, et varie suivant le processeur. Quand le Branch Target Buffer est rempli et qu'un nouveau branchement sexcute, on supprime les informations d'un branchement du Branch Target Buffer pour faire de la place. Cela peut poser un problme : un branchement qui aurait pu tre excut dans un futur proche peut se retrouver supprim du Branch Target Buffer. On ne peut prdire l'adresse vers laquelle il branchera alors qu'avec un Branch Target Buffer plus grand, on aurait pu. Cela s'appelle un BTB Miss.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

306/378

Pour limiter la casse, certains Branch Target Buffer ne mmorisent pas les branchements non-pris (du moins, ceux qui n'ont jamais t pris auparavant). Cela permet de faire un peu de place et vite de remplacer des donnes utiles par une adresse qui ne servira jamais. D'autres optimisations existent pour viter de remplir le Branch Target Buffer avec des adresses mmoires de branchement inutiles, et permettre de garder un maximum de contenu utile dans le Branch Target Buffer. Pour cela, quand un branchement doit tre stock dans notre Branch Target Buffer et que celui-ci est plein, il faut choisir quel branchements enlever du Branch Target Buffer avec le plus grand soin. Si vous vous souvenez, notre Branch Target Buffer est une mmoire cache : et bien sachez que les algorithmes vus dans le chapitre sur la mmoire cache fonctionnent merveille !

Prdiction des branchements indirects

Sur les processeurs qui n'implmentent pas de techniques capables de prdire l'adresse de destination d'un branchement indirect, le processeur considre qu'un branchement indirect se comporte comme un branchement direct : le branchement va brancher vers l'adresse destination utilise la dernire fois qu'on a excut le branchement. Et c'est normal : seule l'adresse de destination valide lors de la dernire excution du branchement est stocke dans le Branch Target Buffer. A chaque fois que ce branchement change d'adresse de destination, on se retrouve avec une mauvaise prdiction. Tous les processeurs moins rcents que le Pentium M prdisent les branchements indirects de cette faon. Certains processeurs haute performance sont capables de prdire l'adresse de destination d'un branchement indirect. A une condition cependant : que l'adresse destination change de faon rptitive, en suivant une rgularit assez simple. Ces techniques de prdiction de branchement indirect utilisent un Branch Target Buffer amlior. Ce Branch Target Buffer amlior est capable de stocker plusieurs adresses de destination pour un seul branchement. De plus, ce Branch Target Buffer amlior stocke pour chaque branchement et pour chaque adresse de destination des informations qui lui permettent de dduire plus ou moins efficacement quelle adresse de destination est la bonne. Mais mme malgr ces techniques avances de prdiction, les branchements indirects et appels de sous-programmes indirects sont souvent trs mal prdits, mme avec un branch predictor optimis pour ce genre de cas. Pour information, ce type de branchement est devenu plus frquent avec l'apparition des langages orients objets, les langages procduraux utilisant peu de branchement indirects (c'est d'ailleurs une des raisons qui font que les langages orients objets sont plus lents que les langages procduraux).

Return Fonction Prdictor

Certains processeurs peuvent prvoir l'adresse laquelle il faudra reprendre lorsqu'un sous-programme a fini de sexcuter : si vous vous souvenez, notre sous-programme fini par un branchement inconditionnel indirect qui fait reprendre notre programme o il en tait avant lexcution de notre sous-programme. Si vous vous souvenez, cette adresse de retour est stocke sur la pile, ou dans des registres spciaux du processeurs dans certains cas particuliers. Certains processeurs possdent un circuit spcialis capable de prdire l'adresse de retour d'une fonction : le Return Fonction Prdictor. Lorsqu'une fonction est appele, ce circuit stocke l'adresse de retour d'une fonction dans des "registres" internes au processeur organiss sous forme d'une pile. Avec cette organisation des registres en forme de pile, on sait d'avance que l'adresse de retour du sous-programme en cours d'excution est au sommet de cette pile. Quand on tombe donc sur une instruction de retour de sous-programme, il suffit de lire l'adresse au sommet de cette pile de registre pour savoir vers o brancher. Ce nombre de registres est limit : le Return Fonction Prdictor ne peut conserver les adresses de retour que d'un nombre limit de branchements. Gnralement, la limite tourne autour de 8 (c'est le cas du processeur Atom d'Intel) ou 16 (sur les processeurs les plus performants). Imbriquer trop de sous-programmes l'un dans l'autre peut parfois poser quelques problmes : certains de ces sous-programmes seront alors mal prdits.

Prdiction de branchement
Maintenant, voyons comment notre processeur fait pour prdire si un branchement est pris ou non.

Prdiction statique
L'ide derrire la prdiction statique est simple. Suivant le branchement, on considre que celui-ci est soit toujours pris, soit jamais pris. L'ide est de faire une distinction entre les diffrents types de branchements qui ont beaucoup de chance d'tre pris et ceux qui ne seront jamais ou presque jamais pris. Il faut savoir que : un branchement inconditionnel est toujours pris, de mme qu'un branchement conditionnel dont la condition de saut est vrifie ; et qu'un branchement conditionnel dont la condition de saut n'est pas respecte est non-pris.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

307/378

Ainsi, si on prdit qu'un branchement est non-pris, on pourra continuer lexcution des instructions qui suivent le branchement dans la mmoire sans problme. A l'inverse si le branchement est prdit comme tant pris, le processeur devra recourir l'unit de prdiction de direction de branchement. L'algorithme de prdiction statique le plus simple est de faire une distinction entre branchements conditionnels et branchements inconditionnels. Par dfinition un branchement inconditionnel est toujours pris, tandis qu'un branchement conditionnel peut tre pris ou ne pas tre pris. Ainsi, on peut donner un premier algorithme de prdiction dynamique : les branchement inconditionnels sont toujours pris ; les branchements conditionnels ne sont jamais pris. Lors de lexcution d'un branchement conditionnel, le processeur continue dexcuter les instructions qui suivent le branchement dans la mmoire programme jusqu' ce que le rsultat du branchement conditionnel soit disponible. Si la prdiction tait fausse, on recommenait partir de l'adresse vers laquelle pointait le branchement et continuait sinon. Cette mthode est particulirement inefficace pour les branchements de boucles, o la condition est toujours vraie, sauf en sortie de boucle ! Il a donc fallu raffiner lgrement l'algorithme de prdiction statique. Une autre manire dimplmenter la prdiction statique de branchement est de faire une diffrence entre les branchements conditionnels ascendants et les branchements conditionnels ascendants. Un branchement conditionnel ascendant, aussi appel forward branch , est un branchement qui demande notre programme de reprendre une instruction dont l'adresse est suprieure l'adresse du branchement. En clair, le branchement demande au processeur de reprendre plus loin dans la mmoire. Par exemple, prenons une structure de contrle Si...Alors : le branchement conditionnel est un forward branch . Ce branchement renvoie des instruction ayant une adresse plus leve : l'instruction vers laquelle on branche est place aprs le branchement.

Un branchement conditionnel descendent, aussi appel backward branch , est un branchement qui demande notre programme de reprendre une instruction dont l'adresse est infrieure l'adresse du branchement. En clair, le branchement demande au processeur de reprendre plus loin dans la mmoire.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

308/378

Par exemple, regardons la conception en assembleur d'une boucle Do...While : celle-ci est fabrique avec un backward branch . Ce branchement renvoie des instruction ayant une adresse plus faible, plus haute : l'instruction vers laquelle on branche est place avant le branchement.

Hors, si vous regardez la traduction en assembleur des structures de contrle utilises dans les langages de programmation structurs actuels, vous remarquerez que sous quelques hypothses (condition d'un if toujours pris et que les boucles excutent au moins une itration), les forward branch sont rarement pris et les backward branch sont presque toujours pris. On peut ainsi modifier lalgorithme de prdiction statique comme suit : les branchements inconditionnels sont toujours pris ; les backward branch sont toujours pris ; les forward branch ne sont jamais pris . Bien sr, cette prdiction statique est base sur quelques hypothses, comme mentionn plus haut : un Si...Alors a sa condition vrifie et le branchement conditionnel n'est pas pris, par exemple (gnralisable au Si...Alors...Sinon, avec quelques subtilits). Un programmeur peut ainsi, s'il connait la traduction de ses structures de contrle en assembleur, tenter de respecter au maximum ces hypothses afin d'optimiser ses structures de contrle et leur contenu pour viter que les branchements de ses structures de contrle soient mal prdits. Sur certains processeurs, certains bits de l'opcode d'un branchement peuvent permettre de prciser si notre branchement est majoritairement pris ou non-pris : ces bits spciaux permettent d'influencer les rgles de prdiction statique et de passer outre les rglages par dfaut. Ainsi, un programmeur ou un compilateur peut donner lunit de prdiction de branchement des informations sur un branchement en lui disant que celui-ci est trs souvent pris ou non-pris. Ces informations peuvent faire passer outre les mcanismes de prdiction statique utiliss normalement. On appelle ces bits des Branch Hints.

Compteurs saturation
Avec la prdiction dynamique, il n'y a pas besoin de supposer que le branchement est pris ou pas suivant sa nature : l'unit de prdiction de branchement peut le deviner dans certains cas. L'implmentation la plus simple de la prdiction dynamique est base sur la technique des compteurs saturation. Pour cela, on mmorise chaque excution du branchement si celui-ci est pris ou pas, et on effectue une moyenne statistique sur toutes les excutions prcdentes du branchement.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

309/378

Par exemple, un branchement qui a dj t excute quatre fois, qui a t pris une seule fois et non-pris les 3 autres fois, a une chance sur 4 d'tre pris et trois chances sur quatre d'tre pris. L'ide est donc de se souvenir du nombre de fois qu'un branchement a t pris ou non-pris pour pouvoir dduire statistiquement la probabilit que ce branchement soit pris. Si cette probabilit est suprieure 50%, le branchement est considr comme pris. Dans le cas contraire, notre branchement est considr comme non-pris. L'ide, c'est d'utiliser un compteur ddi pour chaque branchement prsent dans le Branch Target Buffer, qui mmorisera le nombre de fois qu'un branchement est pris ou non-pris. Ces compteurs sont des circuits lectroniques qui stockent un nombre entier de N bits, dont la valeur est comprise entre et . Ce nombre entier peut tre augment ou diminu de 1 selon le rsultat de lexcution du branchement (pris ou pas). Lorsqu'un branchement doit tre excut, l'unit de prdiction de branchement regarde si celui-ci a son adresse dans le Branch Target Buffer. Si ce n'est pas le cas, on rserve une partie de cette mmoire pour ce branchement et le compteur est initialis une certaine valeur, gnralement gale peu-prt la moiti de . Par la suite, si ce branchement est pris, le compteur sera augment de 1. Dans le cas contraire, le compteur sera diminu de 1.

Pour dcider si le branchement sera pris ou pas, on regarde le bit de poids fort du nombre stock dans le compteur : si vous regardez le schma au-dessus, vous remarquerez que le branchement est considr comme pris si ce bit de poids fort est 1. Dans le cas contraire, notre branchement est donc considr comme non-pris. Certains processeurs ont une unit de branchement qui se limite un seul compteur saturation auquel on a jout un Branch Target Buffer et de quoi effectuer de la prdiction statique si jamais le branchement n'a jamais t excut ou si celui-ci n'est pas un branchement conditionnel. C'est le cas du processeur Intel Pentium 1, par exemple. Pour la culture gnrale, il faut savoir que le compteur saturation du Pentium 1 tait lgrement bugg.

Two level adaptative predictor

Le seul problme avec un compteur saturation unique, c'est que celui-ci ne marche bien que lorsqu'un seul branchement est excut la fois : ce compteur ne stocke les probabilits d'tre pris ou non-pris que pour un seul et unique branchement. En clair, celui-ci ne fonctionne bien que pour les boucles ! Par exemple, un branchement qui est excut comme suit : pris, non-pris, pris,

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

310/378

non-pris, etc ; sera mal prdit une fois sur deux par notre compteur saturation. Mme chose pour un branchement qui ferait : pris, non-pris, non-pris, non-pris, pris, non-pris, non-pris, non-pris, etc. Une solution pour rgler ce problme est de se souvenir des 2, 3, 4 (ou plus suivant les modles) excutions prcdentes du branchement. Ainsi, un branchement qui ferait pris, non-pris, pris, non-pris, etc ; sera parfaitement prdit si l'unit de prdiction de branchement est capable de se souvenir des deux excutions prcdentes du branchement. Un branchement qui ferait : pris, non-pris, non-pris, non-pris, pris, non-pris, non-pris, non-pris, etc ; demandera une unit de prdiction de branchements capable de se souvenir des 4 dernires excutions d'un branchement. Pour cela, on va utiliser un registre qui stockera l'historique des derniers branchements excuts. Ce registre est ce qu'on appelle un registre dcalage. Ce registre dcalage fonctionne exactement comme un registre qu'on aurait coupl un dcaleur (ici, un dcaleur par 1), qui est charg de dcaler le contenu de notre registre. A chaque fois qu'un branchement sexcute, on dcale le contenu du registre et on fait rentrer dans celui-ci un 1 si le branchement est pris, et un zro sinon.

Pour chaque valeur possible contenue dans le registre, on trouvera un compteur saturation qui permettra de prdire quelle est la probabilit que le prochain branchement soit pris. Ce registre est donc coupl plusieurs compteurs saturations : pour un registre de n bits (qui se souvient donc des n derniers branchements excuts), on aura besoin de compteurs saturation.

Chacun de ces compteurs permettra mmoriser le nombre de fois qu'un branchement a t pris chaque fois que que celui-ci a t excut aprs s'tre retrouv dans une situation telle que dcrite par le registre. Par exemple, si le registre contient 010, le compteur associ cette valeur (qui est donc numrot 010), sert dire : chaque fois que je me suis retrouv dans une situation telle que le branchement a t non-pris, puis pris, puis non-pris, le branchement a t majoritairement pris ou non-pris. En utilisant une unit de prdiction de branchement de ce type, on peut prdire tout branchement qui suivrait un schma qui se rpte tous les branchements ou moins, en utilisant un registre d'historique de bits (et les compteurs saturation qui vont avec).

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

311/378

Certains processeurs se payent le luxe d'avoir un registre (et le jeu de compteurs saturation qui vont avec) diffrent pour chaque branchement qui est plac dans le Branch Target Buffer : on dit qu'ils font de la prdiction locale. D'autres, prfrent utiliser un registre unique pour tous les branchements : ceux-ci font de la font de la prdiction globale. C'est par exemple le cas du Pentium 4E qui utilise une unit de branchement capable de se souvenir des 16 derniers branchements prcdents. Les processeurs AMD 64 utilisent quand eux un two level adaptative predictor avec un registre d'historique de 8 bits.

Agree Predictor
Le Two level adaptative predictor possde toutefois un lger problme : avec celui-ci, on prdit qu'un branchement est pris ou non-pris en fonction des branchements qui le prcdent et qui ont chacun mit jour les compteurs saturation dans notre Two level adaptative predictor. Ces compteurs saturation ne sont pas rservs un branchement et sont partags : seul le contenu du registre d'historique permet de slectionner un de ces compteurs saturation. Et le problme vient de l : deux branchements diffrents, excuts des moments diffrents peuvent devoir modifier le mme compteur saturation : il suffit que les branchements qui prcdent ces branchements aient positionns le registre d'historique la mme valeur. Et dans ce cas l, un branchement sera prdit non pas en fonction de son historique (est-ce que celui-ci a dj t pris ou non-pris beaucoup de fois), mais aussi en fonction des excutions de branchements qui lui sont indpendants et qui ont modifis le mme compteur. Et ces interfrences ont tendance entrainer l'apparition de mauvaises prdictions qui auraient pus tre vites. Il faut donc trouver un moyen de limiter la casse. Pour cela, 4 chercheurs ont dcids d'inventer une nouvelle unit de prdiction de branchements capable de rsoudre de problme : l'agree predictor. Cet agree predictor va permettre de se souvenir pour chaque branchement individuel si celui-ci est plus souvent pris ou non-pris en stockant cette information dans un bit spcial nomm le biasing bit . Ainsi, notre agree predictor est divis en deux circuits : un Two level adaptative predictor normal, et un circuit qui va calculer le biasing bit . Ce biasing bit est calcul avec l'aide d'un compteur saturation, reli au branch target buffer. Chaque branchement sera identifi par son adresse dans le Branch target buffer (ce qui permet dindividualiser la prdiction en fonction du branchement pour viter les interfrences) et chaque branchement aura un compteur saturation rien que pour lui, qui permettra de savoir si notre branchement est souvent pris ou pas.

Le dcision prendra compte des deux circuits de prdiction de branchement en vrifiant que ces deux units de branchement sont d'accord. Lorsque les deux units de branchement ne sont pas daccord, c'est qu'il y a surement eu interfrence. Cette

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

312/378

dcision se fait donc en utilisant une porte XOR suivie d'une porte NON entre les sorties de ces deux units de prdictions de branchement : faites la table de vrit pour vous en convaincre !

Loop Prdictor
Maintenant, il faut savoir que les units de prdiction de branchement des processeurs haute performance modernes sont capables de prdire la perfection les branchements de certaines boucles : les boucles FOR, ainsi que quelques autres boucles devant sexcuter fois ( pouvant varier lexcution). De telles units de prdiction de branchement sont mmes capables de prdire correctement le branchement qui fait sortir de la boucle en le considrant comme pris ! Comment ces units de prdiction de branchement sont capables d'une telle prouesse ?

C'est trs simple : leur unit de branchement contient un circuit spcialis dans la prdiction des branchements de ce genre de boucles. Pour rappel, pour une boucle devant sexcuter fois ( dpendant de la boucle), les branchements permettant d'implmenter cette boucle vont devoir sexcuter fois : ils vont tre pris fois, le dernier branchement tant mal prdit. Donc, la solution est d'utiliser un compteur qui compte de de un en un partir de zro. A chaque fois que le branchement est excut, on augmente la valeur contenue dans le compteur de 1. Tant que la valeur stocke dans le compteur est diffrente du nombre , on considre que le branchement est pris. Si le contenu de ce compteur vaut , le branchement n'est pas pris. Mais comment savoir la valeur de ce nombre ?

Lorsqu'une boucle est excute la premire fois, ce nombre est stock quelque part dans le Branch Target Buffer. Cette technique a donc une limite : il faut que la boucle soit excute plusieurs fois sans que les informations du branchements ne soient crases par d'autres dans le Branch Target Buffer. La premire fois, les branchements de la boucle sont prdits en utilisant la prdiction statique ou les compteurs saturation ou toute autre mthode de prdiction de branchement. De plus, doit rester la mme chaque excution de la boucle. De plus, le Loop Prdictor, qui ne peut prdire correctement qu'un nombre limit dexcution d'un branchement, gal au nombre maximal de valeurs diffrentes stockables dans son compteur. Exemple : si un branchement utilis pour concevoir une boucle doit sexcuter plus que 64 fois (au hasard 5000 fois), et que le Loop Predictor utilise un compteur pouvant compter jusqu 64 (valeur la plus grande connue ce jour, valable pour un core 2 duo), alors on aura une mauvaise prdiction tout les 64 excution du branchement. Autre dtail : les branchements lintrieur des boucles interfrent avec le fonctionnement du Loop Predictor et empchent celui-ci de voir qu'il a affaire une boucle : une autre mthode de prdiction des branchements sera utilise.

Eager execution
Comme vous le savez, un branchement peut tre pris ou non-pris. Le principe de la prdiction de branchement est de choisir une de ces deux possibilits et de commencer lexcuter en esprant que ce soit la bonne. Les units de prdiction de branchement se sont donc amliores de faon viter de se tromper, et choisissant la possibilit la plus probable. Mais si on rflchit bien, il y a une autre manire de faire : on peut aussi excuter les deux possibilits sparment, et choisir la bonne une fois qu'on connait l'adresse de destination du branchement. C'est ce qu'on appelle l'Eager Execution. Pour information, sachez qu'il s'agit d'une technique assez avant-gardiste, qui n'est pas encore prsente dans les processeurs de nos ordinateurs. V ous pouvez considrer que ce tutoriel est la pointe de la technologie. Bien sr, on est pas limit un seul branchement, mais on peut poursuivre un peu plus loin.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

313/378

On peut remarquer que cette technique ne peut pas se passer totalement de la prdiction de branchement. Pour pouvoir charger les deux suites d'instructions correspondant un branchement pris et non-pris, il nous faut forcment savoir quelle est la destination du branchement. On a donc encore besoin de notre unit de prdiction de direction de branchement. Mais on peut thoriquement se passer de lunit de prdiction de branchement, charge de savoir si le branchement est pris ou non-pris. J'ai bien dit thoriquement...

Quelques limites pratiques

Le seul problme, c'est qu'on fini rapidement par tre limit par le nombre d'units de calculs dans le processeur, le nombre de registres, etc. L'eager execution est donc une bonne solution, mais elle ne peut suffire elle seule. Prenons cet exemple : on a dj rencontr un branchement. On en rencontre un deuxime, mais on ne peut pas lancer les deux suites d'instructions correspondant aux cas pris et non-pris. On ne peut plus en lancer qu'une.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

314/378

Que faire ? La solution est trs simple : on peut dcider de nexcuter qu'un seul des cas (pris ou non-pris, histoire d'utiliser notre processeur au mieux. Et oui : on peut coupler l'eager execution avec des units de prdictions de branchement. Gnralement, on prfre commencer par xecuter les premiers branchements rencontrs via eager execution, et si trop de branchements sont rencontrs alors qu'on a beaucoup de branchements encore en attente (on ne sait pas encore vers o ils branchent), alors on prdit les branchements suivants via la prdiction de branchements. Cela permet d'viter de trop utiliser dunits de calculs ou de registres en excutant deux suites d'instructions.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

315/378

Disjoint Eager Execution

D'autres techniques existent, et quitte parler d'eager execution, autant parler de la plus efficace : la Disjoint Eager Execution . C'est la technique qui est cense donner les meilleurs rsultats d'un point de vue thorique. Avec celle-ci, on n'excute pas les suites d'instructions correspondant un branchement pris ou non-pris si leur probabilit est trop faible. Cela permet d'conomiser un peu plus de ressources . On peut ainsi demander une unit de prdiction de branchement de calculer la probabilit qu'un branchement soit pris ou non-pris. Ensuite, le processeur nexcute pas les branchements qui ont les probabilits dexcution les plus faibles.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

316/378

A chaque fois qu'un nouveau branchement est rencontr, le processeur refait les calculs de probabilit. Cela signifie que d'anciens branchements qui n'avaient pas ts excuts car ils avaient une probabilit trop faible peuvent tre excut si des branchements avec des probabilits encore plus faibles sont rencontrs en cours de route. Il existe encore d'autres techniques de prdiction de branchements, qu'on a pas encore vu ici : par exemple, on n'a pas abord l'alloyed predictor. Et l'on a pas abord les diverses optimisations possibles sur les circuits vus prcdemment. Pour vous en donner une ide, sur certains processeurs, on utilise carrment deux units de prdiction de branchements : une trs rapide mais pouvant prdire les branchements "simples prdire" , et une autre plus lente qui prend le relais quand la premire unit de prdiction de branchement n'arrive pas prdire un branchement. La prdiction est ainsi plus rapide pour certains branchements. Il existe aussi divers projets de recherche, plus ou moins bien avancs, qui cherchent des moyens de prdire encore plus efficacement nos branchements. Certains pensent ainsi utiliser des units de prdiction de branchement bases sur des rseaux de neurones : le rsultat serait assez lent, mais trs efficace sur certains branchements. Enfin, certains cherchent adapter les diffrentes mthodes de prdiction de branchement sur les instructions prdicat, afin de pouvoir rendre celle-ci plus efficaces. La recherche est encore en cours, et on peut s'attendre quelques gains dans les annes qui suivent, mme si ces gains seront surement relativiser. Les marges de manuvre sont assez faibles, et les branchements resteront un problmes durant un moment encore.

Conclusion
Pour tout ceux qui veulent savoir comment nos branchements sont grs par les processeurs actuels, tlchargez donc le troisime fichier PF prsent sur ce site : http://www.agner.org/optimize/. A l'intrieur ce celui-ci vous aurez de nombreuses informations sur le fonctionnement des processeurs "rcents", avec notamment une revue des diffrentes techniques de prdiction de branchements utilises.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

317/378

Dpendances de donnes
Dans le chapitre prcdent, j'ai parl des dpendances dinstructions et j'ai dit qu'il s'agissait de situations dans lesquelles une instruction avait besoin du rsultat d'une ou de plusieurs instruction prcdentes pour sexcuter. J'ai aussi parl des dpendances structurelles, qui ont tendance mettre un peu d'ambiance. Ces dpendances sont un des points faibles des processeurs possdant un pipeline. Et pour que nos pipelines deviennent vraiment intressants, il a bien fallu trouver des solutions pour supprimer l'effet de ces dpendances. Dans ce chapitre, on verra que l'imagination des ingnieurs et des chercheurs a permit de trouver de trs belles solutions ce genre de problmes. Nous verrons les techniques de bypass, dexcution out-of-order, et le register renamming , ainsi que quelques autres technologies de pointes que les processeurs modernes implmentent dans leurs circuits. Mais tout d'abord, parlons un peu plus prcisment de ces fameuses dpendances : il faut bien commencer par les bases !

Dpendances d'instructions
Une...dpendance ? Nos instructions sont drogues ?

Mais non ! Bien que le terme soit un peu bizarre, il a une signification simple : deux instructions ont une dpendance quand elles cherchent manipuler la mme ressource. Il existe divers types de dpendances, qui ont toutes des origines ou des proprits diffrentes. Nous allons voir ces diffrentes dpendances dans ce qui suit.

Dpendances structurelles
Il se peut qu'un circuit du processeur doive tre manipul par plusieurs instructions la fois : deux instructions peuvent ainsi vouloir utiliser l'unit de calcul en mme temps, ou accder la mmoire simultanment, etc. Il s'agit alors d'une dpendance structurelle. Dans ce genre de cas, il est difficile un circuit de traiter deux instructions la fois alors qu'il n'est pas conu pour : allez demander une unit de calcul dexcuter deux instructions la fois (OK, javoue que certaines en sont capables, mais elles sont rares). Dans ce cas, on a pas le choix : on doit faire patienter une instruction, qui attendra que l'autre aie finie d'utiliser le circuit. viter ce genre de situation est relativement simple : il suffit de dupliquer le circuit partager : au lieu de partager un circuit, on en rserve d'avance un par instruction, et c'est rgl ! Mais quelles peuvent tre ces dpendances structurelles ?

Pour vous montrer quoi peut ressembler une dpendance structurelle, rien de mieux que de parcourir le pipeline et de lister quelles sont les dpendances qui peuvent survenir.

Fetch
Pour le Fetch et le dcodage, il n'y a pas beaucoup de dpendances structurelles possibles. A la rigueur, il peut y avoir des problmes lors du chargement d'une instruction : la mmoire peut tre occupe pour autre chose. Aprs tout, difficile de charger une instruction si la mmoire est dj occupe pour lire une donne. Pour rsoudre ce problme, on peut ajouter une Prefetch Input Queue, vue il y a quelques chapitres. On peut aussi sparer la mmoire cache en deux : un cache pour les instructions, et un autre pour les donnes. Cela limiter la casse. Mais attention : il se peut malgr tout que sur les processeurs disposant de toute une hirarchie de caches (L1, L2, etc), cela ne suffissent pas, surtout quand on se trouve face des branchements. Mais ce cas est rare. Bref, passons.

Dcodage
Pour l'unit de dcodage, il n'y a presque pas de dpendances structurelles. A la rigueur, certaines instructions peuvent mettre plus de temps dcoder que d'autres, et on doit parfois attendre qu'une instruction complexe soit dcode, mais c'est tout. Dans un cas pareil, il suffit de stopper le fonctionnement de l'tape de Fetch et lempcher de charger une instruction pour les cycles suivants.

ALU
Ensuite, rien nempche deux instructions de vouloir utiliser la mme unit de calcul simultanment. Cela arrive souvent quand on excute des instructions multi-cycle : l'instruction qui arrive juste aprs une instruction multi-cycle peut parfaitement vouloir utiliser la mme unit de calcul. Dans ce cas, pas trop le choix : on est oblig de dupliquer nos units de calculs en plusieurs exemplaires.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

318/378

En thorie, on peut supprimer ces dpendances structurelles totalement en ajoutant autant d'ALU que notre instruction met de cycles pour sexcuter. Si on vouloiat garder des ALU multifonction, il faudrait dupliquer cette grosse ALU en normment d'exemplaire pour seulement une instruction. Autant dire qu'avec des divisions de 80 cycles, c'est pas la peine d'essayer : c'est trop couteux en circuits. Pour grer une instruction multi-cycles, on lui fournit souvent des units de calcul part. Prenons un exemple : toutes mes instructions arithmtiques prennent un cycle, part la multiplication qui prend 5 cycles et la division qui prend 40 cycles. Je peux supprimer toute dpendance structurelle en utilisant une ALU pour les oprations en 1 cycle, 5 ALU capable de faire une multiplication, et 40 ALU capables ddies aux division. Mais dupliquer des ALU n'est pas la seule solution. On peut aussi pipeliner nos units de calculs. Si jamais vous avez une opration qui prend 5 cycles, pourquoi ne pas lui fournir un seul circuit, et le pipeliner en 5 tages ? Pour certains circuits, c'est possible. Par exemple, on peut totalement pipeliner une unit de multiplication. En pipelinant totalement une unit de calcul, on peut ainsi supprimer ce genre de dpendances structurelles.

On peut aussi mlanger pipelining des units de calcul et duplication. Bref ! Ceci dit, certaines instructions se pipelinent mal, et leur dcoupage en tages se fait assez mal. Il n'est ainsi pas rare d'avoir grer des units de calcul dont chaque tage peut prendre deux trois cycles pour sexcuter. Par exemple, voici ce que cela pourrait donner avec une ALU spcialise dans les divisions, dont chaque tage fait 20 cycles.

Avec une telle ALU, il faut attendre un certain temps (20 cycles) avant de pouvoir envoyer une nouvelle division dans notre pipeline. Et des dpendances structurelles sont encore possibles. Ceci dit, cela ne pose pas souvent de problmes. Autant dupliquer des ALU pour des instructions courantes est utile, autant dupliquer des units de division ou des units spcialises dans des instructions rares ne sert pas grand chose. Les divisions sont trs rares, et il est rare qu'on en lance deux moins d'une centaine de cycles dintervalle. Dans cette latence de 20 cycles joue trs peu. Et c'est aussi valable pour d'autres instructions assez rares.

Dpendances de contrles
Comme dpendances, on trouve aussi les dpendances de contrles, qui sont dues aux branchements, aux interruptions, et aux exceptions matrielles. Le chapitre sur les branchements a t trs instructif : nous avons vu une grande partie des techniques qui permettent de supprimer les effets de dpendances dues aux branchements.

Dpendances de donnes
Cette fameuse ressource partager peut aussi tre un emplacement mmoire. Dans ce cas, on parle de dpendance de donnes. Deux instructions ont une dpendance de donne quand elles accdent (en lecture ou criture) au mme registre ou la mme

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

319/378

adresse mmoire. Suivant l'ordre dans lequel on effectue des instructions ayant une dpendance de donnes, le rsultat peut changer. Ainsi, un programme devra absolument suivre l'ordre d'accs la mmoire impos par le programmeur (ou le compilateur), histoire de donner le bon rsultat. Diffrents cas se prsentent alors, suivant que les deux instructions crivent ou lisent cette donne. La localisation de la donne n'a pas d'importance : celle-ci peut tre en RAM ou dans un registre, on s'en moque ! On se retrouve alors avec quatre possibilits : Dpendance de donnes Effets

Read after Read Read after write Write after Read Write after Write

Nos deux instructions doivent lire la mme donne, mais pas en mme temps ! Dans ce cas, on peut mettre les deux instructions dans n'importe quel ordre, cela ne pose aucun problme.

La premire instruction va crire son rsultat dans un registre ou dans la RAM, et un peu plus tard, la seconde va lire ce rsultat et effectuer une opration dessus. La seconde instruction va donc manipuler le rsultat de la premire. la premire instruction va lire un registre ou le contenu d'une adresse en RAM, et la seconde va crire son rsultat au mme endroit un peu plus tard. Dans ce cas, on doit aussi excuter la premire instruction avant la seconde. Nos deux instructions effectuent des critures au mme endroit : registre ou adresse mmoire. Dans ce cas aussi, on doit conserver l'ordre des instructions et ne pas rordonnancer, pour les mmes raisons que les deux dpendances prcdentes.

Pipeline Bubble
Comme vous le voyez, ces dpendances vont imposer un certain ordre dexcution pour nos instructions. Cet ordre est un ordre qui est impos : excutez les instructions dans un ordre diffrent, et votre programme donnera un rsultat diffrent. Prenons le cas d'une dpendance RAW : on a une lecture suivie par une criture. Si on dcide de changer l'ordre des deux accs mmoires et que l'on effectue l'criture avant la lecture, la lecture ne renverra pas la valeur prsente avant l'criture, mais celle qui a t crite. Toutes les lectures de notre registre ou adresse mmoire prcdant notre criture devront tre termines avant de pouvoir lancer une nouvelle criture.

Temps d'attente
A cause de ces dpendances, certaines instructions doivent attendre que toutes les instructions avec lesquelles elles ont une dpendance se terminent avant de pouvoir sexcuter. Et ces temps d'attente vont crer des vides dans le pipeline. Ces instructions vont rester bloques dans un tage du pipeline en attendant que les instructions qui leur sont dpendantes finissent totalement. Et il va de soit que les tages prcdents sont eux-aussi bloqus. Durant ce temps d'attente, on se retrouvera avec des vides dans le pipeline : certains tages seront inoccups parce qu'une instruction dans un des tages prcdents.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

320/378

Alors certes, on verra dans ce chapitre qu'il y a des techniques pour remplir ces vides, ces temps d'attentes. Dans la suite du tutoriel, on verra que certains processeurs sont capables de changer l'ordre des instructions pour gagner en efficacit, et on verra que ces dpendances limitent fortement les possibilits d rorganisation de l'ordre de nos instructions. Mais pour le moment, nous allons parler des processeurs qui ne remplissent pas ces vides en changeant l'ordre des instructions. Nous allons commencer par parler des processeurs qui excutent les instructions dans l'ordre impos par le programme. Ces processeurs sont appels des processeurs In-Order. Sur ceux-ci, seules les dpendances RAW sont importantes, et les dpendances WAR et WAW n'ont pas vraiment d'effets. Les dpendances WAR et WAW sont rserves pour plus tard, quand on verra des processeurs un peu plus volus.

Implmentation
On doit donc faire attendre certaines instructions, si elles ont une dpendance RAW, et marquer un temps d'attente. Soit ! Mais ce temps d'attente n'apparait pas comme pas magie. Il faut concevoir notre processeur pour qu'il fasse ce qu'il faut. Par dfinition, une instruction a une dpendance de donne avec une autre si celle-ci va lire un registre ou une adresse mmoire qui est manipule par une autre. Si nos instructions sexcutent dans l'ordre impos par le programme, les dpendances WAW et WAR ne gnent alors pas trop. Pipeline ou pas, les critures et lectures se font dans l'ordre impos par le programme, naturellement. Mais par contre, les dpendances RAW vont sacrment gner. Il est possible qu'une instruction charge dans le pipeline aille lire une ancienne version d'une donne. Il suffit pour cela que la version la plus rcente n'aie pas encore t crite par une instruction prcdente : cela arrive si celle-ci est encore dans le pipeline. Pour grer les dpendances sur les processeurs In-Order, il suffit simplement d'viter cela. Pour grer ces dpendances RAW, notre unit de dcodage va mmoriser les registres qui seront crits par les instructions qui sont dans le pipeline. Lors de l'tape de dcodage, le processeur pourra ainsi vrifier si l'instruction qu'il vient de dcoder va aller lire un de ces registres. Si ce n'est pas le cas, c'est que l'instruction qu'il vient de dcoder n'a pas de dpendances RAW avec les instructions en cours dexcution. En clair : pas de temps d'attente. Mais dans le cas contraire, l'unit de dcodage va se bloquer tant que l'instruction n'est pas prte tre excute. L'unit de dcodage va aussi envoyer un signal pour bloquer l'unit de Fetch, histoire qu'elle ne lui envoie pas une nouvelle instruction (ce

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

321/378

qui effacerait l'instruction en attente), et pour viter que celle-ci ne charge une nouvelle instruction( ce qui effacerait l'instruction qu'elle a charge au cycle prcdent, et qui attend bien sagement dans l'unit de Fetch). Ce blocage se fait simplement en empchant l'horloge d'arriver aux registres prsents entre les tages de Fetch et de Dcodage.

Ainsi, les registres entre les tages ne seront pas mis jour, et garderont leur valeur qu'ils avaient au cycle prcdent. Cette inhibition de l'horloge se fait en activant un simple interrupteur ou en utilisant un vulgaire petit circuit base de portes logiques. Aprs avoir bloqu les tages prcdents, l'unit de dcodage va ensuite insrer une instruction nop dans le pipeline, histoire que la Pipeline Bubble ne fasse rien.

Instructions ALU multicycles

Une autre source de dpendances vient de certaines instructions. Il n'est pas rare que certaines instructions monopolisent une unit de calcul durant plusieurs cycles d'horloge. Par exemple, une division peut prendre jusqu' 80 cycles d'horloge, et rester dans son ALU durant tout ce temps. Et cette ALU est inutilisable pour une autre instruction. On est donc en face d'une belle dpendance structurelle, qu'il faut rsoudre. Pour cela, l'ALU va devoir fournir des informations l'unit de dcodage, qui permettront celle-ci de dcider si elle doit insrer une Pipeline Bubble ou non. Notre unit de dcodage devra connaitre l'utilisation de chaque unit de calcul (occupe ou non), afin de dcider.

Accs la mmoire
De plus, cette technique pose un problme lors des instructions d'accs la mmoire. Ces instructions n'ont pas une dure bien dfinie. La donne charger peut se trouver aussi bien dans la mmoire cache, que dans la mmoire RAM, et les temps d'accs ne sont pas les mmes. On pourrait ventuellement insrer des Pipeline Bubbles dans notre pipeline tant que la lecture ou criture n'est pas termine. C'est trs simple implmenter. Premire implmentation : si l'unit de dcodage envoie une instruction qui accde la mmoire dans le pipeline, elle se bloque, et attend que l'unit qui accde la mmoire lui envoie un signal lectrique pour lui dire : dbloque toi, j'ai fini. Seconde implmentation : l'unit charge daccder la mmoire va bloquer elle-mme tous les tages prcdents du pipeline si elle doit accder la mmoire, et elle les libre une fois la donne lue ou crite. Mais dans les deux cas, ce serait un vrai dsastre en terme de performances. En tout cas, on verra que ce genre de problme peut facilement tre vit avec certaines structures de donnes matrielles. Mais le moment de parler des ReOrder Buffers n'est pas encore arriv.

Que faire ?
Par chance, cet ordre ne permet pas d'ordonner toutes les instructions : autant dans l'ordre dexcution impos par le programme toutes les instructions sont ordonnes et doivent sexcuter les unes aprs les autres, autant l'ordre des dpendances de donnes n'est pas total et est celui qui laisse le plus de liberts. Si deux instructions n'ont pas de dpendances de donnes, c'est qu'elle ne manipulent pas les mmes donnes et qu'elles sont indpendantes. Il est parfaitement possible pour notre processeur de profiter du fait que deux instructions soient indpendantes. Si deux instructions sont indpendantes, le processeur peut les xecuter en parallle ou changer leur ordre dexcution sans problme. Il existe diverses techniques pour ce faire : Excution Out

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

322/378

Of Order, Superscalarit, etc. Mais pour le moment, voyons un peu quel est l'effet de ces dpendances sur notre pipeline, et comment on peut limiter la casse.

Bypass et Forwarding
Comme on l'a vu plus haut, les dpendances posent de sacrs problmes. Alors certes, on peut profiter du fait que nos instructions soient indpendantes pour les xecuter en parallle, dans des tages diffrents du pipeline, mais cela ne rsout pas le problme dus nos dpendances. Diminuer l'effet des dpendances sur notre pipeline est une bonne ide. Et pour ce faire, diverses techniques ont ts inventes. La premire de ces technique s'occupent de diminuer l'impact des dpendances de type RAW. Cette dpendances indique qu'une instruction a besoin du rsultat d'une autre instruction pour pouvoir sexcuter.

Effet des dpendances RAW

Prenons deux instructions qui se suivent et qui possdent une dpendance RAW. J'ai colori sur le schma en jaune les tapes des instructions durant lesquelles l'unit de calcul est utilise. La situation idale serait celle-ci.

Mais la ralit est plus cruelle : notre pipeline, tel qu'il est actuellement, possde un lger dfaut qui peut crer ces temps d'attentes inutiles. Avec le pipeline tel qu'il est actuellement, on doit attendre qu'une instruction soit totalement termine pour pouvoir rutiliser son rsultat. Ainsi, le rsultat de notre instruction n'est disponible qu'aprs avoir t enregistr dans un registre, soit aprs l'tape de Writeback, note W sur le schma.

On voit bien que la seconde instruction doit attendre l'autre.

Mais pourquoi ?
Pourtant, son rsultat est calcul bien avant que l'instruction ne termine, mais il n'est pas rutilisable immdiatement. Et pour cause : il doit tre enregistr dans les registres, et cela ne se fait pas sans prcautions. Sans prcautions signifie que certaines modifications faites sur les registres ne doivent pas tre enregistres. Par exemple, on ne doit pas enregistrer les rsultats calculs aprs un branchement mal prdit. Il faut aussi grer les exceptions et les interruptions. Par exemple, si une exception a eu lieu dans le pipeline, on ne doit pas enregistrer les modifications faites tord par les instructions excutes aprs l'exception. Pour cela, il y a des tages qui permettent (ou non) d'enregistrer un rsultat en mmoire ou dans les registres.

Bypass
Une ide vint alors : pourquoi ne pas faire en sorte que le rsultat d'une l'instruction soit le plus rapidement disponible ? Pas besoin d'attendre que l'instruction termine pour avoir accs au rsultat : ds qu'un rsultat est calcul, il vaut mieux qu'il soit utilisable par d'autres instructions le plus vite possible.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

323/378

Et si jamais notre instruction rutilise un rsultat qui n'est pas bon, il suffit de ne pas enregistrer son rsultat.

Quelles instructions ?
Mais cela n'est pas possible pour toutes les instructions. Gnralement, il y a deux types d'instructions qui donnent un rsultat : les instructions de lecture en mmoire, et les instructions de calcul. Quand on charge une donne depuis la mmoire, le rsultat n'est autre que la donne lue depuis la mmoire. Et pour les instructions de calcul, il s'agit simplement du rsultat du calcul. Pour les accs mmoires, on peut limiter la casse en utilisant des mmoires caches, en jouant sur le pipeline, et utilisant diverses techniques plus ou moins volues. Mais On verra cela plus tard. Toujours est-il que ces accs mmoire ont tendance tre trs longues, ce qui cre des gros vides dans notre pipeline, difficile supprimer. Mais on peut toujours jouer sur les instructions de calculs : celle-ci ont des temps d'attente plus faibles, sur lesquels il est facile de jouer.

Principe
D'ordinaire, ce calcul est effectu par notre unit de calcul, et est ensuite crit dans un registre ou en mmoire aprs un certain temps. Pour rduire le temps d'attente, on peut faire en sorte que le rsultat de notre instruction, disponible ne sortie de l'unit de calcul, soit directement rutilisable, sans devoir attendre qu'il soit crit dans un registre ou dans la mmoire.

Pour cela, on a juste modifier les circuits du processeur. Ce rsultat peut tre directement accd par la seconde instruction sans devoir tre enregistr dans un registre. Ainsi, la seconde instruction peut donc s'excuter avant que la premire aie termin son tape de Writeback.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

324/378

Il s'agit de la technique du bypass, aussi appele forwarding .

Implmentation
Implmenter la technique du bypass dans un processeur n'est pas tellement compliqu sur le principe. Il suffit simplement de relier la sortie des units de calcul sur leur entre quand une instruction a besoin du rsultat de la prcdente. Il faut pour cela ajouter quelques circuits charg de dcider si le contenu de la sortie de lunit de calcul peut tre envoy sur son entre. Cela se fait en utilisant des multiplexeurs : on relie la sortie de notre ALU un multiplexeur dont la sortie sera relie l'entre de cette mme unit de calcul, l'autre entre tant relie au bus interne au processeur. On pourra ainsi relier (ou pas) la sortie de l'ALU une de ses entres en configurant ce multiplexeur.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

325/378

En faisant comme ceci, il suffit alors de commander le multiplexeur en utilisant son entre de commande pour que celui-ci recopie ou non la sortie de l'ALU sur son entre. Cette entre de commande est relie au squenceur, qui se charge de dduire si le multiplexeur doit, ou non, relier la sortie de l'unit de calcul sur son entre. Et croyez-moi, c'est nettement plus compliqu que de simplement placer un multiplexeur au bon endroit.

Clusters
Sur les processeurs ayant beaucoup d'units de calculs, on trouve souvent un systme de bypass (forwarding ) assez toff. Aprs tout, rien ne dit que deux instructions dpendantes seront rparties sur la mme unit de calcul. Le Scheduler peut trs bien envoyer deux instructions ayant une dpendances RAW sur des units de calcul diffrentes. Pour cela, il n'y a qu'une solution : chaque sortie d'une unit de calcul doit tre relie aux entres de toutes les autres ! Je ne vous raconte pas la difficult cbler un rseaux d'interconnexions pareil. Pour units de calcul, on se retrouve avec pas moins de interconnexions. Autant dire que cela fait beaucoup de fils et que sur certains processeurs, cela peut poser problme. Sur certains processeurs, on arrive se dbrouiller sans trop de problmes. Mais quand on commence mettre un peu trop dunits de calculs dans le processeur, c'est termin : on ne peut pas forcment, ou l'on a pas envie, de cbler un rseau de bypass aussi touffu et complexe. Pour limiter la casse, on utilise alors une autre mthode : on ne relie pas toutes les units de calcul ensemble. A la place, on prfre regrouper ces units de calcul dans diffrents blocs spars qu'on appelle des clusters. Le bypass est alors rendu possible entre les units d'un mme cluster, mais pas entre les units appartenant deux clusters diffrents.

Bypass Cache
Avec la technique prcdente, seul le dernier rsultat calcul est conserv pour tre disponible au cycle d'horloge suivant. Cela permet de rgler le cas de deux instructions conscutives qui seraient dmarres au bon moment. Mais il se peut qu'une instruction doive rutiliser un rsultat un peu plus ancien que le tout dernier rsultat sorti de l'ALU. Gnralement, ce rsultat doit alors tre lu depuis les registres, ce qui peut prendre un peu de temps. Surtout quand on trouve divers intermdiaires entre les registres et l'ALU. Pour cela, il existe diverses solutions. La plus simple consiste utiliser des Bypass Cache, des mmoires caches relies aux entres et sorties d'une ALU. Ces Bypass Cache stockent les derniers rsultats fournis par l'ALU. Une ligne de cache de ces caches va ainsi stocker le rsultat de l'ALU. Ils contiennent parfois un tag qui permet de dduire de quelle instruction provient le rsultat stock.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

326/378

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

327/378

Execution Out Of Order

On l'a vu, nos instructions multicyles entrainent d'apparition de dpendances structurelles et de dpendances de donnes assez embtantes. Si deux instructions indpendantes sont charges la suite dans le pipeline, pas de problmes. Mais dans le cas contraire, on va se retrouver avec un problme sur les processeurs In-Order. Les dpendances vont crer des temps d'attentes. De nombreuses techniques ont ts inventes pour supprimer ces temps d'attentes, dont le Bypassing . Mais cette dernire ne suffit pas toujours. Pour supprimer encore plus de temps d'attentes, on a invent lexcution Out Of Order . V oyons en quoi celle-ci consiste.

Principe
Introduisons le problme par un exemple. Prenons deux instructions qui se suivent et qui possdent une dpendance de donnes. La seconde devant attendre le rsultat de la premire pour commencer son excution. J'ai colori sur le schma en jaune les tapes des instructions durant lesquelles l'unit de calcul est utilise.

On voit bien que la seconde instruction doit attendre l'autre. C'est un fait : si deux instructions ont une dpendance de donne et que celle qui prcde l'autre est une instruction multicycle, alors on va perdre du temps dans ce fameux temps d'attente. Des problmes similaires apparaissent lors des accs mmoires. Si une donne attend des donnes en provenance de la mmoire, on se retrouve aussi avec ce genre de vides, sauf que l'unit de calcul est libre. Les deux types de dpendances, structurelles ou de donnes, ainsi que les accs mmoires, on exactement le mme effet sur notre pipeline : ils forcent certains tages du pipeline attendre qu'une donne ou qu'un circuit soit disponible. Dans ce cas, on est oblig de modifier lgrement le comportement de notre pipeline : on doit stopper l'tage qui attend et l'immobiliser, ainsi que celui de tous les tages prcdents. En clair, notre tage ne fait rien et attend sagement, sans passer l'instruction suivante. Et les tages prcdents font pareils. C'est la seule solution pour viter les catastrophes. Et pour cela, on doit rajouter des circuits qui vont dtecter les dpendances dans notre pipeline et qui vont stopper le fonctionnement de l'tage devant attendre ainsi que les tages prcdents. C'est le rsultat des dpendances de donne : certains tages ne font rien, pendant que certaines instructions attendent la donne voulue. L'instruction va devoir attendre que ses oprandes soient disponibles dans un tage et va bloquer tous les tages prcdents dans le pipeline : cela retarde le chargement des instructions suivantes. Au final, notre pipeline excute moins dinstructions en simultan que prvu.

Une ide gniale

Un jour, quelqu'un a eu une ide pour viter de perdre du temps dans ces vides, et a dcid que ce temps d'attente pouvait tre remplis par des instructions indpendantes. Au lieu dexcuter des instructions dans l'ordre du programme, il suffit simplement de changer l'ordre des instructions du programme pour remplir ces vides avec des instructions indpendantes. On profite ainsi du fait que l'ordre induit par les dpendances de donnes est moins strict que l'ordre impos par le programmeur et par le Program Counter. Et pourtant, ces deux ordres donnent lieu au mme programme, qui effectue les mmes choses. Les moyens pour rpartir correctement nos instructions pour combler les vides sont assez restreints, et il n'en existe plusieurs. On peut par exemple stocker nos instructions dans la mmoire en incorporant l'intrieur des informations sur leurs dpendances de donne. Cela permet de laisser le processeur grer ces dpendances tout seul et dcider de l'ordre dans lequel xecuter nos instructions tout seul. Il peut ainsi parallliser automatiquement un programme et xecuter ses instructions dans l'ordre des dpendances de donnes tout seul. C'est ce qui se fait sur les architectures dataflow, mais cela n'est pas utilis sur les processeurs modernes. Les architectures dataflow ont en effet divers dfauts qui plombent leurs performances.

OOO et processeurs squentiels

A la place, on part d'un programme purement squentiel, dans lequel les instructions sexcutent les unes aprs les autres. Et on change l'ordre des instructions pour remplir les vides. Ce r-ordonnancement peut se faire de deux faons diffrentes : soit on le fait la compilation, soit c'est le processeur qui va dterminer les dpendances entre instructions et qui va changer lui-mme l'ordre des instructions du programme. Quand c'est le processeur qui s'en occupe, aucune information ne lui est fournie

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

328/378

explicitement dans les instructions (comme c'est le cas sur les architectures dataflow), et il doit dduire les dpendances entre instructions tout seul, en regardent les registres ou adresses mmoires utilises par linstruction. Une fois ces dpendances connues, il change lui-mme l'ordre des instructions et dcide de leur rpartition sur les diffrentes units de calcul. Chacune de ces solutions a ses avantages et ses inconvnients. Par exemple, le compilateur peut travailler sur des morceaux de programmes plus gros et ainsi rordonnancer les instructions un peu mieux que le processeur, qui ne traitera qu'une dizaine ou une vingtaine dinstruction la fois. Mais par contre, le processeur peut virer certaines dpendances qui apparaissent lexcution (branchements) : cela est impossible pour le compilateur. Bien sr, rien nempche de faire les deux, pour avoir un maximum de performances. La dernire solution qui consiste rorganiser l'ordre dans lequel s'excutent les instructions du programme pour gagner en efficacit s'appelle l'excution Out-Of-Order. Avec cette solution, si une instruction doit attendre que ses oprandes soient disponibles, on peut remplir le vide cre dans le pipeline par une autre instruction indpendante de la premire : on excute une instruction indpendante au lieu de ne rien faire. Cette instruction pourra sexcuter avant l'instruction qui bloque tout le pipeline et n'aura donc pas attendre son tour : on excute bien des instructions dans le dsordre. Petit dtail : quand je parle d'instructions, il peut s'agir aussi bien d'instructions machines (celle que notre processeur fourni au programmeur), que de micro-instructions (celles qu'on a vue dans le chapitre sur la micro-architecture d'un processeur, quand on a parl de squenceurs micro-cods). Si votre processeur utilise un squenceur micro-cod, la rorganisation des instructions se fera non pas instructions machines par instructions machines, mais micro-oprations par micro-oprations. Cela permet d'avoir plus de possibilits de rorganisations.

Une dpendance structurelle rsoudre

Mais pour cela, il lui fallait rsoudre un premier problme. L'ide consistant remplir les vides du pipeline par des instructions indpendantes revient faire ce qui suit.

Problme : l'unit de calcul n'accepte qu'une seule instruction, et la situation du dessus est impossible. On est donc oblig de retarder lexcution de notre seconde instruction. On va donc appliquer la solution de base en cas de dpendances structurelle : on dupliquer le circuit fautif, qui est ici l'unit de calcul, et on rpartit nos instructions sur les diffrentes units de calcul. Le seul problme, c'est que rien nempche une instruction charge dans le pipeline aprs une autre de finir avant celle-ci. Les instructions ayant des temps dexcutions variables, les rsultats peuvent arriver dans le dsordre. Et dans un cas pareil, il faut absolument grer correctement les dpendances de donnes entre instructions correctement.

Deux types d'Out Of Order

Il existe diffrents types d'Out-Of-Order, dont les deux plus simples sont le scoreboarding , et l'algorithme de Tomasulo. Ce dernier a t invente par Robert Tomasulo, un chercheur travaillant chez IBM, et fut utilis pour la premire fois dans la FPU des processeurs IBM 360. Autant dire que cela remonte loin : 1970 ! Ces deux techniques d'Out Of Order sont bases sur un pipeline normal, mais auquel on a ajout diverses modifications. Ces deux techniques ont malgr tout une caractristique commune : avec elles, les instructions sont dcodes les unes aprs les autres, dans l'ordre du programme, et sont ensuite excutes dans un ordre diffrent. Et il faut avouer qu'il est difficile de faire autrement. Qui plus est, on ne dcode qu'une instruction la fois. Dans le prochain chapitre, on verra que certains processeurs arrivent passer outre cette limitation. Sur ces processeurs, on pourra ainsi dcoder plusieurs instructions simultanment sans aucun problmes. Mais nous n'en sommes pas encore l !

Scoreboarding
Commenons par la premire de ces techniques : le scoreboarding. Avec le scoreboarding , la gestion des dpendances de donnes est effectue par un seul circuit, nomm le scoreboard : il se chargera ainsi de grer l'ensemble des units de calcul et se chargera de tout ce qui a rapport lexcution Out Of Order . Son rle est de dtecter les dpendances de donnes entre instructions et dexcuter au mieux les instructions en consquence. Mais ce scoreboard n'est pas le seul circuit ncessaire pour pouvoir xecuter nos instructions dans un ordre diffrent de celui impos par le programme.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

329/378

Pipeline d'un processeur Scoreboard

videmment, rajouter un circuit de ce genre ncessite de modifier quelque peu le pipeline. Il faut bien rajouter des circuits chargs de modifier l'ordre dexcution de nos instructions. Le pipeline d'un processeur utilisant le scoreboarding est illustr par les schma ci-dessous.

N'ayez pas peur : les explications arrivent !

tape d'issue
Au moins une tape supplmentaire apparait : l'tape d'issue. Cette tape remplace l'tape de dcodage de l'instruction, ou plutt elle la complte. L'tape d'issue va non-seulement dcoder notre instruction, mais elle va aussi dcider si notre instruction peut dmarrer son excution ou non. Pour cela, notre tape d'issue va vrifier quels sont les registres utiliss pour stocker le rsultat de notre instruction et va vrifier que notre instruction n'a aucune dpendance WAW (elle n'a pas besoin d'crire son rsultat au mme endroit qu'une autre instruction qui la prcde dans l'ordre du programme). Elle va aussi vrifier si une unit de calcul est disponible pour lexcuter. Si notre instruction possde une dpendance WAW ou qu'aucune unit de calcul disponible ne peut lexcuter, alors notre instruction va attendre son tour bien sagement. Dans le cas contraire, elle va pouvoir progresser dans le pipeline : le scoreboard sera alors mis jour. Attention, toutefois : nos instructions sont dcodes et envoyes aux units de calculs les unes aprs les autres, en srie. On peut ventuellement en envoyer plusieurs (il suffit d'adapter un peu l'tape d'issue), mais cet envoi vers les ALU se fera dans l'ordre impos par le programme. Vu comme cela, on se demande bien o est l'Out Of Order . Mais celui-ci vient aprs, plus loin dans le pipeline.

L'tape Read Operand

Notre instruction n'a donc aucune dpendance WAW, et une unit de calcul est prte lexcuter. Visiblement, tout va bien dans le meilleur des mondes, et notre instruction est donc surement bien partie pour fournir un rsultat dans pas longtemps. Mais la ralit est un peu plus cruelle : il n'y a certes pas de dpendances WAW, mais les autres dpendances doivent tre prises en compte. Les dpendances RAW, notamment : rien n'indique que les donnes que notre instruction doit manipuler sont prtes ! Aprs tout, notre instruction peut trs bien attendre une oprande en provenance de la mmoire ou calcule par une autre

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

330/378

instruction. Dans ce cas, notre instruction doit attendre que la donne en question doit lue depuis la mmoire ou calcule par l'instruction avec laquelle elle partage une dpendance. Il faut donc trouver un moyen pour viter de commencer excuter notre instruction alors que seulement la moiti de ses donnes sont dj disponibles. Mais qu' cela ne tienne, envoyons-la quand mme lunit de calcul ! Heu... excuter une instruction sans avoir ses oprandes, c'est pas un peu casse-cou ?

Si, effectivement. Mais rassurez-vous, les concepteurs de processeurs Out Of Order ont penss tout (en mme temps, on les paye pour a !). Pour viter les problmes, une seule solution : notre instruction va tre mise en attente en attendant que ses oprandes soient disponibles. Pour ce faire, on ajoute une tape dans notre pipeline, gre par notre scoreboard . Cette tape se chargera de retarder lexcution de notre instruction tant que ses donnes ne seront pas disponibles. Notre scoreboard va ainsi stocker notre instruction dans une petite mmoire tampon (avec ventuellement ses oprandes), et la fera attendre tant que les oprandes ne sont pas prtes.

Excution
Une fois ses oprandes prtes, l'instruction est envoye une unit de calcul et est excute. C'est cet endroit du pipeline que l'on peut vraiment parler d'Out Of Order : notre processeur contiendra obligatoirement plusieurs units de calcul, dans lesquelles on pourra xecuter des instructions en parallle. Sur un processeur sans scoreboarding et sans Out Of Order , lorsqu'une instruction n'a pas fini de sexcuter (si elle prend plusieurs cycles ou attends des donnes), on doit attendre que celle-ci se termine avant de pouvoir en dmarrer une autre. Avec le scoreboarding , ce n'est pas le cas : si une instruction prend plusieurs cycles pour sexcuter ou attend des donnes, on peut dmarrer une nouvelle instruction au cycle suivant dans une autre unit de calcul disponible. Pas besoin d'attendre : une instruction indpendante peut ainsi commencer son excution au cycle suivant sans attendre la fin de l'instruction prcdente. videmment, cela marche uniquement si une instruction prend plus d'un cycle pour sexcuter : si elles attend des donnes depuis la RAM, ou si il s'agit d'une instruction complexe demandant beaucoup de temps. Si toutes les instructions mettent un cycle d'horloge pour sexcuter (accs mmoires compris), le scoreboarding ne sert rien vu qu'on dcode nos instructions unes par unes. Lexcution de l'instruction va prendre un ou plusieurs cycles d'horloge, et on doit absolument prendre en compte cet tat de fait : toutes les instructions ne prennent pas le mme temps pour sexcuter. Ainsi, leur rsultat sera disponible plus ou moins tardivement, et les scoreboard doit en tenir compte. Pour cela, quand le rsultat de notre instruction est calcul, le scoreboard est prvenu par l'unit de calcul et il se mettra jour automatiquement.

Writeback
Enfin, le rsultat de notre instruction est prt. Il ne reste plus qu' le sauvegarder dans un registre ou dans la mmoire...enfin presque ! Ben oui, il reste les dpendances WAR : il faut attendre que toutes les lectures dans le registre que l'on va crire soient termines. Pour cela, il n'y a pas vraiment de solution : on doit encore une fois attendre que ces lectures soient finies pour autoriser l'criture du rsultat. Seule solution : placer nos rsultats dans une file d'attente, et autoriser l'criture du rsultat dans le register file une fois que toutes les lectures de la donne prsente dans le registre crire soient termines. Bien videmment, c'est le scoreboard qui autorisera ou non cette criture.

Scoreboard
On a vu prcdemment que le scoreboard a tout de mme pas mal de responsabilits : il doit faire patienter les instructions possdant une dpendance WAW dans l'tage d'issue, faire patienter notre instruction dans l'tage de Read Operand tant que ses donnes ne sont pas disponibles, et temporiser l'criture du rsultat d'une instruction tant que les lectures prcdentes dans le registre crire ne sont pas effectues. Cela ncessite de commander pas mal d'tage du pipeline, ainsi que quelques circuits annexes. Mine de rien, notre scoreboard va devoir avoir accs pas mal dinformations pour grer le tout efficacement. Celui-ci devra retenir : les dpendances entre instructions ; quelles sont les instructions en cours dexcution ; des units de calcul charge de lexcution de celles-ci ; et les registres dans lesquels nos instructions en cours dexcution vont crire leur rsultat.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

331/378

Pour cela, notre scoreboard va contenir : une table des registres, qui indiquera dans quel registre stocker le rsultat fourni par une unit de calcul (par une instruction, quoi) ; une table stockant l'tat de chaque instruction : est-elle en cours dexcution, attend-elle ses oprandes, son rsultat est-il en attente d'criture, etc ; et une table d'instruction qui contient des instructions sur chaque instruction xecuter : son opcode, o placer le rsultat, dans quels registres sont stockes les oprandes, et est-ce que ces oprandes sont disponibles.

Final
Au final, on saperoit que cette forme d'Out Of Order est assez rudimentaire : les instructions sont toujours dcodes dans l'ordre du programme et sont rparties sur une ou plusieurs units de calcul. Par contre, celles-ci sont ensuite rparties sur des units de calculs spares dans lesquelles elles peuvent sexcuter dans un ordre diffrent de celui impos par le programme. Pire : elles peuvent enregistrer leurs rsultats dans un ordre diffrent de celui impos apr le programmeur : elles fournissent leur rsultat ds que possible. Nanmoins, on observe quelques limitations assez problmatiques : les dpendances RAW, WAW et WAR vont faire patienter nos instructions. Et il serait bien de limiter un peu la casse propos de ces dpendances !

Out Of Order Issue

Notre Scoreboard est un algorithme assez sympathique, capable de fournir de bonnes performances. On peut esprer obtenir des gains proches de 10 30 % suivant les programmes. Mais celui-ci a toutefois un lger dfaut. Ce dfaut n'est pas visible immdiatement. Pour le voir, il faut bien regarder l'tape d'Issue. Le problme vient du fait que notre unit d'Issue va envoyer nos instructions l'tape suivante dans l'ordre du programme. Ces instructions pourront alors sexcuter dans le dsordre, mais leur envoi aux units de calcul s'effectue dans l'ordre du programme. Cela pose un problme si jamais deux instructions se suivent dans notre programme. Si jamais ces deux instructions ont une dpendance structurelle ou une dpendance WAW, l'tape d'Issue devra alors insrer des Pipeline Bubbles et bloquer les units de Fetch et de Decode. C'est ncessaire pour que notre programme fasse ce pour quoi il a t programm : sans cela, des dpendances WAW seront violes et le programme qui sexcute ne fera pas ce pour quoi il a t programm. Limiter ces Pipeline Bubbles dues des dpendances entre instructions est un moyen assez intressant pour gagner en performances. Encore une fois, nous allons devoir trouver un moyen pour limiter la casse, en amliorant notre algorithme de Scoreboarding . L'ide est trs simple : au lieu de bloquer notre pipeline l'tape d'Issue en cas de dpendances, pourquoi ne pas aller chercher des instructions indpendantes dans la suite du programme ? Aprs tout, si jamais j'ai une dpendance entre une instruction I et une instruction I+1, autant aller regarder l'instruction I+2, voire I+3. Si cette instruction I+2 est indpendante de l'instruction I, je pourrais alors Issue linstruction I+2 dans mon pipeline deux cycles plus tard. Cela limite fortement la casse.

Centralized Instruction Window

Pour que cela fonctionne, on est oblig de faire en sorte que notre tape d'Issue puisse mmoriser plusieurs instructions. Dans notre exemple du dessus, si l'instruction I est charge dans notre pipeline, je devrais mettre en attente l'instruction I+1 dans l'tape d'Issue, et y charger l'instruction I+2. Notre tape d'Issue devra pouvoir stocker plusieurs instructions. Cela permettra mettre en attente les instructions ayant une dpendance WAW ou structurelle avec les instructions en cours dexcution. Nos instructions seront donc charges dans notre pipeline et dcodes les unes aprs les autres. Elles seront alors mises en attente dans l'tape d'Issue, et quitteront celle-ci une fois que toute dpendance problmatique sera supprime. Cette mise en attente se fait grce ce qu'on appelle une Instruction Window . Pour cela, les instructions prcharges (et ventuellement dcodes) seront places dans une sorte de mmoire tampon, qui stockera les instructions en attente de traitement. L'unit charge de rpartir les instructions et de vrifier leurs dpendances sera relie cette mmoire tampon et pourra donc manipuler ces instructions comme il le souhaite. Cette mmoire tampon s'appelle l'instruction window .

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

332/378

Cette instruction window est gre diffremment suivant le processeur. On peut par exemple la remplir au fur et mesure que les instructions sont excutes et quittent donc celle-ci. Ou on peut attendre que celle-ci soit vide pour la remplir intgralement en une fois. Les deux faons de faire sont possibles. V ous remarquerez que j'ai plac les units du squenceur sur le schma. Mais le dcodeur d'instruction peut tre plac de l'autre cot de l'instruction window. En fait, celles-ci peuvent se retrouver des deux cots de l'instruction window. On peut en effet dcoder les instructions avant leur passage dans l'instruction window : c'est ce qui se fait surement dans vos processeurs x86 actuels et dans la majorit des processeurs utilisant la micro-programmation horizontal (pour ceux qui ont oublis, allez voir ici : le chapitre sur la micro-architecture d'un processeur de ce tutoriel). Mais on peut aussi se dbrouiller pour faire autrement, en plaant les units de dcodage aprs l'instruction window. Pour choisir quelle instruction xecuter, il suffira de rajouter un circuit qui se chargera de lire le contenu de cet Instruction Window, et qui dcidera quelles sont les instructions excuter. Ce circuit, le Scheduler, regardera quelles sont les instructions dans cet Instruction Window qui sont indpendantes et dcidera alors de les rpartir sur les units de calcul inutilises au besoin.

Au fait : ce Scheduler n'est rien d'autre que le circuit en charge de l'tape d'Issue, auquel on permet de traiter plusieurs instructions. C'est lui qui vrifiera les dpendances entre instructions et qui sera charg de rpartir des instructions sur plusieurs units de calcul.

Instructions Windows Multiples

Sur certains processeurs, cette gestion des dpendances et la rpartition des instructions lexcution sur les ALU sont spares dans deux circuits distincts, spars par une mmoire tampon. On appelle Schelving cette sparation entre Issue et vrification des dpendances.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

333/378

Sur un processeur implmentant le Schelving , on ne trouve non pas une, mais plusieurs Instructions Windows. Gnralement, on trouve une Instruction Window par ALU. L'unit d'Issue va simplement vrifier qu'une unit de calcul est libre pour excuter notre instruction, et va l'envoyer dans une de ces Instruction Window, attache la bonne ALU.

Une fois place dans cette Instruction Window, notre instruction va attendre que toutes les dpendances soient rsolues avant de sexcuter. A chaque cycle d'horloge, un circuit va vrifier que notre instruction a ses oprandes de prtes, que l'unit de calcul est libre, et vrifie aussi les dpendances WAR et WAW. Une fois que notre instruction n'a plus aucune dpendance, elle est directement envoye l'ALU et elle sexcute. Dans le cas contraire, elle patiente dans l'Instruction Window. Gnralement, ces Instructions Windows spcialises sont parfois appeles des Reservations Stations. Utiliser du Shelving a un avantage : les Schedulers attachs aux Reservations Stations sont souvent beaucoup plus simples et consomment nettement moins de circuits. Plusieurs raisons cela. Pour commencer, chaque Reservation Station est pluis petite qu'une grosse Instruction Window : la slection de la prochaine instruction envoyer l'ALU est donc plus simple. Aprs tout, entre slectionner une instruction parmi 100, et une parmi 10, un des deux cas est le plus simple, et vous avez devin lequel. Ensuite, une Reservation Station ne peut librer qu'une entre par cycle, vu qu'elle envoie une instruction la fois sur l'ALU. Mais avec une grosse Instruction Window, plusieurs instructions peuvent quitter cele-ci durant un seul cycle : il suffit que plusieurs ALU dmarrent une nouvelle instruction. Mais les Reservations Stations ont aussi des inconvnients. Elles sont souvent sous-utilises et partiellement remplies. Il est rare que la totalit d'une Reservation Station soit utilis, tandis qu'une Instruction Window n'a pas ce problme et est souvent remplie en totalit. Niveau rentabilit circuits/remplissage, l'Instruction Window est la grande gagnante.

Quelques dtails
Ces Instruction Window sont composes d'entres, des blocs de mmoires qui servent stocker une instruction dcode. Lorsqu'une instruction est dcode, elle rserve une entre rien que pour elle. Cette entre est libre dans deux cas : soit quand l'instruction est envoye aux ALU, soit quand elle termine son excution. Cela dpend du processeur et de son pipeline. Le rle du Scheduler est de vrifier le contenu des entres pour savoir quelle instruction Issue. Si plusieurs instructions sont prtes tre issue sur la mme ALU, ce dernier doit faire un choix. Et gnralement cela signifie "issue la plus ancienne". Il existe deux grands types d'Instruction Window. Ces deux types dpendent du contenu de celle-ci. Dans le premier type, l'Instruction Window ne stocke pas les oprandes de l'instruction : une entre ne contient que notre instruction, et puis c'est tout. Le Scheduler sait quand les oprandes d'une instructions sont disponibles et quand il n'y a plus de dpendances grce au Scoreboard . Dans le second type, l'Instruction Window contient aussi les oprandes d'une instruction, celles-ci tant envoye

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

l'Instruction Window par le rseau de Bypass. Les dpendances sont alors dtectables sans aucun Scoreboard .

334/378

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

335/378

L'algorithme de Tomasulo et le renommage de registres

Dans le chapitre prcdent, on a vu un premier algorithme dexcution Out Of Order qui permettait de remplir certains vides dans notre pipeline. Mais celui-ci tait toujours limit par certaines dpendances de donnes, qui avaient tendance crer pas mal de vides, et contre lesquels notre scoreboarding ne pouvait pas faire grand chose. Pour limiter la casse, les concepteurs d'ordinateurs se sont creuss les mninges et ont fini par trouver une solution et ont russit un exploit : virer la grosse majorit des dpendances de donnes lors de lexcution.

Le renommage de registres
Dans ce que j'ai dit prcdemment, j'ai voqu trois types de dpendances de donnes. Certains d'entre elles sont des dpendances de donnes contre lesquelles on ne peut rien faire : ce sont de "vraies dpendances de donnes". Une vraie dpendance de donne correspond au cas o une instruction a besoin du rsultat d'une instruction prcdente pour fonctionner : il s'agit des dpendances Read After Write. Ces dpendances sont aussi appeles des dpendance de donne vritables ou une True Dependency, ce qui montre bien leur caractre invitable. Il est en effet impossible dexcuter une instruction si les donnes ncessaires son excution ne sont pas encore connues. Quelque soit la situation, on est oblig de tenir compte de ces dpendances, qui imposent un certain ordre dexcution de nos instructions, limitant ainsi les possibilits pour notre Out Of Order.

Des dpendances fictives

videmment, si on qualifie ces dpendances de dpendances vritables, c'est forcment que les autres sont un peu moins mchantes que prvu. Les dpendances, Write After Write et Write After Read sont en effet de fausses dpendances : elles viennent du fait que nos deux instructions doivent se partager le mme registre ou la mme adresse mmoire, sans pour autant que l'une aie besoin du rsultat de l'autre. Ces dpendances viennent simplement du fait qu'une adresse mmoire (pardonnez mon abus de langage en confondant l'adresse et le byte qu'elle slectionne), un registre, ou toute autre portion de la mmoire, est rutilise pour stocker des donnes diffrentes des instants diffrents. De telles dpendances sont appeles des name dependencies. Et rutiliser une portion de la mmoire et remplacer une donne devenue inutile par une autre ne pose pas de problmes quand on excute des instructions l'une aprs l'autre, mais ce n'est pas le cas quand on veut parallliser ces instructions ou changer leur ordre. Supprimer ces dpendances est donc une ncessit si on veut parallliser nos instructions. Tirer parti des architectures Out Of Order ncessite de virer au maximum ces dpendances de donnes fictives afin de laisser un maximum d'opportunit pour xecuter des instructions indpendantes en parallle, ou pour changer l'ordre des instructions le plus facilement possible. Mais comment faire ?

Ces dpendances apparaissent si on lit ou crit des donnes diffrentes au mme endroit : si ce n'est pas le cas, on peut trouver une solution ! Et cette solution est assez simple : on doit faire en sorte de ne pas rutiliser une portion de mmoire qui contient une donne. C'est bien plus facile dire qu' faire, et rarement faisable : quand on est limit 4 ou 8 registres sur un processeur, rutiliser au maximum les registres est au contraire une ncessit si on veut viter de devoir accder la RAM ou au cache pour tout et n'importe quoi. Bien videmment, limagination dbride des concepteurs de processeur a dj trouve une solution ce problme dans le cas de dpendances dues un partage de registres entre deux instructions. Cette solution s'appelle le renommage de registre, et permet d'liminer ces fausses dpendances de donnes Write after Read ou Write after Write.

Le renommage de registres
Prenons le cas d'une dpendance WAR : on a une lecture suivie par une criture. Si on dcide de changer l'ordre des deux accs mmoires et que l'on effectue l'criture avant la lecture, la lecture ne renverra pas la valeur prsente avant l'criture, mais celle qui vient d'tre crite. Il est donc strictement impossible de changer l'ordre des lectures/critures dans ce cas prcis : si on le fait, le rsultat enregistr en mmoire change et notre programme ne fait pas ce qu'il faut. Toutes les lectures de notre registre ou adresse mmoire prcdant notre criture devront tre termines avant de pouvoir lancer notre criture. Plus gnralement, si on change l'ordre de deux instructions ayant une dpendance de donne WAW ou WAR, nos deux instructions vont utiliser le mme registre pour stocker des donnes diffrentes en mme temps. Manque de chance, un registre ne peut contenir qu'une seule donne, et l'une des deux sera perdue. Du moins, c'est le cas si on lit ou crit au mme endroit. Si ce n'est pas le cas, on n'observe pas d'apparition de dpendances.Et une solution simple vient alors l'esprit. Il suffit de conserver ces diffrentes versions du mme registre dans plusieurs registres

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

336/378

spars, et choisir le registre adquat l'utilisation. Ainsi, les oprations de lecture seront rediriges vers la copie de l'ancienne valeur (celle lire), tandis que notre criture crira son rsultat dans un autre registre. Une fois que toutes les lectures prcdant notre criture (dans l'ordre des instructions impos par le programmeur) seront termine, il suffira de remplacer l'ancienne valeur (la copie utilise pour les lectures) par la nouvelle valeur (celle qui a t crite). Lide est donc de stocker plusieurs versions d'un mme registre dans des registres spars. A chaque fois qu'on veut crire ou modifier le contenu d'un registre, cette criture est redirige vers un autre registre. A chaque criture, on utilise un nouveau registre pour stocker temporairement notre donne crire. Et toutes les lectures vers cette version du registre sont rediriges vers ce registre supplmentaire. Une fois qu'une donne, une version d'un registre, devient inutile, celui-ci devient rutilisable. Tout ce qui peut tre lu ou crit peut subir ce genre de modification, mais en pratique, seuls les registres subissent ce genre de traitement. Certains processeurs permettent ainsi de faire la mme chose sur des adresses mmoires, mais sont vraiment rares.

Des registres en double !

On voit bien qu'un seul registre architectural correspondra en ralit plusieurs registres rellement prsents dans notre processeur, chacun contenant le rsultat d'une criture. On a besoin non seulement de nos registres architecturaux, mais aussi de registres supplmentaires. Ainsi, sur les processeurs implmentant le renommage de registres, il faut bien faire la distinction entre : les registres architecturaux, qui sont ceux dfinis par l'architecture extrieure du CPU, mais qui sont fictifs ; et les registres physiques, rellement prsents dans notre CPU, bien plus nombreux que les registres architecturaux. Le renommage de registres consiste attribuer un ou plusieurs registres physiques pour chaque registre architectural lors de lexcution d'un programme, en fonction des besoins, cette correspondance pouvant varier au cours du temps. Le renommage de registre permet ainsi de dupliquer chaque registre architectural en plusieurs exemplaires, chacun utilisant un registres physique. Petite remarque : le nombre des registres physiques correspondant un registre architectural variera dans le temps, suivant le nombre d'instructions qui doivent crire dans un mme registre. Reprenons notre exemple de deux instructions devant utiliser le mme registre. Le renommage de registres permet deux registres physiques de devenir le mme registre architectural : un de ces registres architecturaux sera utilis par la premire instruction, et l'autre par la seconde instruction. Les deux instructions nutilisent plus les mmes registres, et peuvent travailler chacune sur leur registre, indpendamment de l'autre : les dpendances de donnes disparaissent et les deux instructions peuvent alors s'excuter en mme temps.

C'est fait comment ?

Dans nos processeurs, les registres sont identifis par ce qu'on appelle un nom de registre. Ce terme doit vous rappeler quelque chose, et ce n'est pas un hasard : on a vu cela dans le chapitre sur l'assembleur. Quoiqu'il en soit, nos registres sont donc identifis par ces noms de registres qui ne sont autre que des suites de bits dont la valeur va permettre d'identifier un registre architectural parmi tous les autres. Nos registres physiques sont eux aussi identifis par un nom de registre, mais qui est seulement connu du processeur : le Tag. Pour attribuer un registre architectural un registre physique, il suffit de remplacer le nom du registre architectural par le tag du registre physique qui lui est attribu. On dit alors que le registre architectural est renomm. Ce remplacement est effectu dans un tage supplmentaire du pipeline. Celui-ci va prendre sur ses entres le nom des registres architecturaux manipuler, et va fournir sur sa sortie les tag des registres physiques correspondant.

Bien sr, cette unit doit prendre en compte le fait qu'on souhaite lire ou crire dans le registre architectural : si c'est une lecture, elle doit renvoyer le tag du registre physique qui contient la donne ; tandis que si c'est une criture, elle devra gnralement choisir un registre physique inutilis (dans lequel on peut donc crire librement), et renvoyer son tag .

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

337/378

Dans un processeur utilisant le renommage de registres, il y a bien plus de registres physiques que de registres architecturaux. Donc, le tag d'un registre physique est plus grand que le nom d'un registre architectural.

Reservations stations
Le Scoreboarding est un algorithme assez simple. Mais il a un petit dfaut : il ne gre pas le renommage de registres. Pour grer le renommage de registre, il existe un autre algorithme dexcution Out Of Order . Il s'agit de l'algorithme de Tomasulo. Cet algorithme a un autre avantage : il essaye d'utiliser du forwarding ds que possible afin de limiter la casse ! V oyons un peu comment est effectu le renommage de registre avec cet algorithme.

Aperu
Pour commencer, voici un aperu du pipeline d'un processeur utilisant cet algorithme, ci-dessous.

Nous verrons dans la suite quoi ces tapes correspondent. Mais je tiens prciser une chose : les tapes marques en jaune sont des tapes qui ne sont pas concerns par l'Out Of Order . C'est dire que les instructions sont charges depuis la mmoire, dcodes, et Issues dans l'ordre du programme. C'est la suite de ces tapes que les instructions pourront sexcuter dans le dsordre. A premire vue, rien n'a chang compar au pipeline d'un processeur normal. Seul petit ajout : Reservations Stations. Tout l'algorithme se base sur les Reservations Stations. Ce sont elles qui servent de registres virtuels. Et cela aura des consquences sur le reste du processeur. Par exemple, l'tage d'Issue sera maintenant en charge du renommage de registres. Pour comprendre le fonctionnement de cet algorithme, nous allons voir en dtail chaque tape du pipeline, dans l'ordre.

Issue
L'tape d'Issue a deux utilits. Pour commencer, c'est elle qui devra renommer les registres. C'est elle qui dcidera de donne un Tag aux rsultats de nos instructions, notamment. Ensuite, c'est elle qui vrifiera si on disposera des ressources ncessaires pour sexcuter. Si ce n'est pas le cas, l'unit d'Issue va bloquer les tages prcdents du pipeline, afin de faire patienter notre instruction l'tage d'Issue. On remarque tout de mme une petite chose assez amusante avec cette unit d'Issue. Celle-ci va dcider d'envoyer une instruction dans la suite du pipeline, mais elle ne va pas vrifier les dpendances. Aprs tout, on pourrait trs bien imaginer une unit d'Issue qui vrifie si toutes les oprandes sont disponibles. Mais ici, ce n'est pas le cas. La gestion de l'Issue est spare de la dtection des dpendances. Cette sparation entre Issue et dtection des dpendances s'appelle le Schelving. Il existe d'autres

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

338/378

techniques de Schelving , dont certaines se foutent du renommage de registres. Mais toutes ces techniques ncessitent de stocker les instructions entre l'tage d'Issue et celui de vrification des dpendances. Ce stockage va se faire dans une sorte de mmoire tampon, qui stockera les instructions dont on doit s'occuper des dpendances. Tout ce qu' faire l'tape d'Issue, c'est renommer les registres et vrifier qu'il y a suffisamment de place dans cette mmoire tampon.

Reservation Stations
Mais voyons plus en dtail le rle de cette mmoire tampon. Une fois qu'une instruction a t dcode et que ses registres ont ts renomms, celle-ci est alors libre de toute dpendance WAR ou WAW. Le renommage de registre, effectu par l'tage d'Issue, a bien fait son travail. Mais rien n'indique que ses oprandes sont prtes. Il se peut qu'une dpendance RAW vienne jouer les trouble-fte. Pour rsoudre cette dpendance RAW, l'instruction est mise en attente en attendant que ses oprandes soient disponibles. Jusque-l, pas grande diffrence avec le scoreboarding . Mais la nouveaut vient de la faon dont cette instruction est mise en attente. Avec le Scoreboarding , notre instruction tait mise en attente, mais ses oprandes taient lues depuis les registres architecturaux, une fois disponibles. On ne pouvait pas lire depuis un registre virtuel. Avec l'algorithme de Tomasulo, notre instruction sera stocke dans une grosse mmoire tampon, situe juste avant les units de calcul. Chaque unit de calcul se voit attribuer une de ces mmoires tampon, qui lui est propre et laquelle elle seule peut accder. Cette mmoire tampon va servir stocker aussi les signaux de commande de nos instructions en attente, ainsi que leurs oprandes. Pour cela, notre mmoire tampon est compose de blocs bien organiss. Chacun de ces blocs s'appelle une Reservation Station .

Chaque Reservation Station peut stocker toutes les informations ncessaires pour xecuter une instruction. C'est dire ses signaux de commande, et ses oprandes.

Empty Bit
Lorsque notre unit d'Issue va vouloir xecuter une instruction, elle va d'abord devoir vrifier si une Reservation Station est libre devant l'unit de calcul devant xecuter notre instruction. Si ce n'est pas le cas, l'unit d'Issue va devoir se bloquer, et bloquer aussi les tages du pipeline qui la prcdent. Dans le cas contraire, si une Reservation Station est libre, l'unit d'Issue va la remplir avec les informations ncessaires sur son excution. Reste savoir comment fait notre unit d'Issue pour savoir que nos Reservation Stations sont libres. Pour cela, chaque Reservation Station possde un bit nomm Empty qui indique si celle-ci est vide ou remplie par une instruction. Quand une Reservation Station se remplie, elle positionne automatiquement ce bit 1. L'unit d'Issue a juste lire des bits des diffrentes Reservation Station pour savoir lesquelles sont libres.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

339/378

Valid Bit
Une instruction place dans une Reservation Station sera excute une fois que toute ses oprandes seront disponible (sauf optimisations bizarres). Pour xecuter l'instruction au bon moment, il faut trouver un moyen pour savoir que toutes les oprandes d'une instruction sont disponibles. Pour cela, il suffit d'ajouter des bits de prsence qui permettront de savoir si l'oprande est bien crite dans la Reservation Station. Quand une oprande est crite dans la Reservation station, le bit de prsence correspondant sera mis jour. Des circuits relis la Reservation station se chargeront alors de vrifier chaque cycle d'horloge si toutes les oprandes de l'instruction sont disponible.

On remarque facilement une chose : toutes les instructions n'ont pas le mme nombre d'oprandes. Et donc, ces circuits doivent dcider quand dmarrer une instruction en fonction non seulement des oprandes disponibles dans la Reservation Station, mais aussi de l'instruction : on doit donc utiliser l'opcode de l'instruction pour cette dcision.

Tag
Je ne sais pas si vous avez remarqus, mais ces Reservation Station sont des registres virtuels. Ces sont elles qui stockent les oprandes de nos instructions. Au lieu de lire des donnes depuis le Register File, non donnes peuvent tre lues directement depuis la sortie de l'ALU. Reprenez le schma dcrivant l'algorithme de Tomasulo, que j'ai mit au-dessus. V ous verrez qu'il existe une sorte de bus qui relie les sorties des ALUs directement sur leurs entres. Et bien sachez que ce mcanisme permet non seulement de faire du Bypass de faon efficace, mais qu'il permet aussi de faire du renommage de registre une fois coupl aux Reservation Station. En fait, nos Reservation Station vont stocker des donnes directement sorties de l'ALU, et qui ne sont pas forcment enregistres dans le Register File. Sans Reservation Station, on devrait attendre que le registre soit libre, c'est dire attendre que toutes les lectures de ce registre soient termines. A la place, on prfre crire dans une Reservation Station, qui stockera le rsultat temporairement, avant qu'il soit recopi dans le Register File. On voit bien que nos Reservation Stations servent de registres virtuels. Pour grer le processus de renommage, une instruction va devoir indiquer dans quels registres virtuels stocker son rsultat. Pour cela, chaque instruction se voit attribuer un Tag , qui permet d'identifier ce rsultat parmi tous les autres. Ce Tag est stock directement dans la Reservation Station, cot des oprandes, de l'opcode de l'instruction et de tout le reste.

Oprandes Sources
Ce rsultat, une fois fourni par l'unit de calcul, peut tre rutilis par une autre instruction. Si c'est le cas, il doit tre stock dans la Reservation Station attribue l'instruction ayant besoin de ce rsultat. Pour identifier celle-ci, on utilise le fait que chaque Reservation Station stocke les oprandes de l'instruction qu'elle stocke. Chacune de ces oprandes est fournie par une instruction : il s'agit donc d'un rsultat d'instruction comme un autre, qui est fourni par une unit de calcul. Et ce rsultat possde un Tag . Pour chaque oprande stocke dans une Reservation Station, il faut donc ajouter de quoi stocker les Tags de cette oprande.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

340/378

Lorsqu'une instruction renvoie un rsultat, celui-ci est envoy toutes les Reservation Station via le Common Memory Bus. Celles-ci vont alors comparer chacun des Tags de leurs oprandes avec celui-ci de l'oprande qui est disponible sur ce bus. Si il y a correspondance, le rsultat est alors stock dans la Reservation Station.

Dispatch
Une fois passe l'tape d'Issue, les instructions doivent attendre que leurs oprandes soient disponibles dans les Reservations Stations. Elles sont d'abord Issue, puis elles sont autorises sexcuter. Cette autorisation est une tape particulire de l'algorithme de Tomasulo. Il s'agit du Dispatch. Cette tape est gre par un circuit qui regarde la disponibilit des oprandes, et qui dcide quelle instruction envoyer l'ALU. Il faut bien sur traiter le cas o plusieurs instructions ont leur oprandes prtes en mme temps. Dans ce cas, c'est souvent l'instruction la plus ancienne qui passe en premier.

Le Common Memory Bus

Notre instruction a fini de sexcuter. Son rsultat est enfin connu, et il va alors tre distribu tous les circuits qui en ont besoin. C'est l'tape de Completion. Cette compltion se fait dans le dsordre le plus total : ds qu'une instruction fournit un rsultat, elle l'envoie vers les units chargs d'crire dans les Reservations Stations, dans les registres, et dans les units charges de communiquer avec la mmoire.

Bypassing
Avec l'algorithme de Tomasulo, on peut renvoyer ce rsultat dans une Reservation Station et ainsi effectuer du Bypassing . Pour cela, le rsultat va tre envoy sur un bus qui distribuera le rsultat calcul aux circuits de Writeback ainsi qu'aux Reservations Stations. Ce bus s'appelle le Common Memory Bus.

Ce rsultat est envoy sur le Common Memory Bus avec le Tag de linstruction qui l'a calcul.

Producers
Pour viter les problmes sur les processeurs utilisant plusieurs units de calculs, nos units de calcul ne vont pas crire directement sur ce bus : imaginez les problmes d'arbitrage que cela pourrait donner ! A la place, on va en intercaler des registres entre les units de calcul et ce bus. Ces registres sont appels les Producers. Seul un de ces Producers pourra transfrer ces donnes dans le Common Memory Bus un moment donn : si plusieurs Procuders veulent crire sur le bus, seul un seul d'entre

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

eux sera autoris le faire, ce qui limine le problme voqu au-dessus.

341/378

Quand celui-ci est libre, un de ces Producers sera choisit et pourra envoyer son contenu dans le Common Memory Bus. En choisissant correctement le Producer chaque fois, on est certain que les donnes seront envoyes dans le bon ordre.

Accs mmoires
Il faut prciser une chose : les accs la mmoire principale (la RAM) sont traits part des autres instructions. En effet, ces instructions d'accs mmoires doivent sexcuter dans l'ordre impos par le programme. On ne sait pas supprimer les dpendances WAR et WAW sur ces instructions : le renommage de registre ne permet de supprimer de telles dpendances que pour les registres. Pour viter les problmes, notre processeur contient des units spcialiss, qui prennent en charge les instructions de lecture (Load) ou dcriture (Store) en mmoire. Ce sont les Load Unit (pour les lectures) et les Store Unit (pour les critures). Ces units sont relies au Common Memory Bus. Lorsqu'une donne est lue depuis la mmoire, elle atterrit aussi bien dans le Register File que Dans les Reservations Stations. Petite remarque : l'unit charge des lecture est aussi prcde par des Reservations Stations qui lui sont rserves. Elles servent mettre en attente des instructions de lecture dont on ne connait pas encore l'adresse. Linstruction est alors stocke, et dmarre quand la mmoire est libre, et que l'adresse lire est connue. Pour les critures, c'est un peu diffrent. Si jamais une donne doit tre crite, celle-ci est envoye sur le Common Memory Bus et rceptionne par l'unit d'criture. Celle-ci sera alors stocke dans une Reservation Station, place juste devant l'unit ddies aux critures. Une fois que la donne et l'adresse laquelle crire sont connues, et que la mmoire est libre, l'criture est lance.

Bilan
On le voit, cet algorithme se base sur lexistence de Reservations Stations pour effectuer du renommage de registres. Dans la version vue plus haut de l'algorithme de Tomasulo, ces Reservations Stations servent de registres virtuels. On verra dans la suite que ce n'est pas toujours le cas. Lexcution d'une instruction avec cet algorithme de Tomasulo est donc dcoupe en plusieurs tapes. Ce dcoupage en tape peut servir organiser le pipeline d'un processeur. Aussi, il n'est pas rare que les processeurs Out Of Order utilisant le renommage de registres aient un pipeline similaire celui-ci : Fetch ; Decode ; Issue/Rename : renommage des registres et allocation dans les Reservations Stations ; Dispatch : autorisation dexcution, parfois prcde d'un temps d'attente des oprandes dans les Reservation Stations ; Execution ; Completion : le rsultat est disponible sur le Common Memory Bus et enregistr dans les registres. Mais pour le moment, il y a une chose que l'on a oubli de dire. Si nos Reservations Stations sont des registres virtuels, les critures dans le Register File se font l'tape de Completion. C'est lors de cette tape que les critures en mmoire et dans les registres seffectuent. Et cette completion se fait dans le dsordre le plus total.

Re-Orders Buffers
La version de l'algorithme de Tomasulo que l'on a vue a un lger problme : la moindre interruption ou mauvaise prdiction de branchement peut tout casser ! Les mauvaises prdiction de branchements, les interruptions et les exceptions matrielles

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

342/378

peuvent mettre un sacr bazar si l'ordre des lectures/critures n'est pas celui prvu par le programmeur. Si une instruction qui n'aurait pas du tre excute (parce que prcde par un branchement, une interruption, ou une exception dans l'ordre du programme) modifie un registre alors qu'elle n'aurait pas du, on est mal. Pour viter ce genre de problmes et grer les interruptions et branchements correctement, notre processeur va se charger de "remettre les lectures et critures dans l'ordre". Pour cela, les rsultats des instructions vont devoir attendre avant d'tre enregistrs dans les registres ou la mmoire. Cette attente dure jusqu' ce que toutes les instructions qui prcdent l'instruction qui a fournie le rsultat (dans l'ordre normal du programme) soient toutes excutes. Cette attente se fait dans un tage supplmentaire du pipeline, rajout la suite des prcdents. Un nouvel tage fait son apparition : Commit. Le pipeline de notre processeur devient donc : Fetch ; Decode ; Issue/Rename : renommage des registres et allocation dans les Reservations Stations ; Execution ; Completion : le rsultat est disponible sur le Common Memory Bus et mis en attente ; Commit : le rsultat est enregistr dans les registres.

Le Reorder Buffer
Pour s'assurer que les rsultats sont crits dans l'ordre du programme, et pas n'importe comment, notre Reorder Buffer est organis d'une certaine faon. Ce Reorder Buffer est compos de plusieurs entres, des espces de blocs dans lesquels il va stocker des informations sur les rsultats crire, et leur ordre. Ainsi, il saura prendre en charge les critures dans les registres, et les remettre dans le bon ordre. V oyons un peu son contenu.

Tag
Il va de soit que notre Reorder Buffer contient les donnes crire. Mais il doit aussi les remettre dans l'ordre. Lorsqu'une instruction vient d'tre dcode durant l'tape d'Issue, celle-ci est alors ajoute dans le Reorder Buffer la suite des autres. Les instructions tant dcodes dans l'ordre du programme, l'ajout des instructions dans le Reorder Buffer se fera dans

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

343/378

l'ordre du programme, automatiquement. Elle va rserver une entre dans le Reorder Buffer. Pour savoir quelle instruction cette entre est rserve, on y ajoute le Tag de l'instruction. En consquence, une entre de notre Reorder Buffer contient donc de quoi stocker un rsultat, et aussi de quoi placer le Tag d'une instruction.

Lorsque le rsultat de l'instruction est connu, il est disponible sur le Common Memory Bus avec son Tag . A chaque envoi sur ce bus, le Reorder Buffer va regarder s'il y a une correspondance entre ce Tag , et un des Tags qu'il contient. Si c'est le cas, le rsultat est crit dans le Reorder Buffer, dans l'entre dont le Tag correspond.

Valid Bit
Maintenant, prenons un cas particulier. Imaginons que nous ayons une instruction dans notre Reorder Buffer. Toutes les instructions prcdentes ont crit leurs rsultats en mmoire ou dans les registres. Je suis sur que vous pensez que l'on peut crire le rsultat de notre instruction dans les registres sans problme. Elle peut alors quitter le Reorder Buffer. Mais et si son rsultat n'est pas disponible ? Il faut alors garder cette instruction dans le Reorder Buffer. Pour savoir si notre instruction a bien produit un rsultat ou s'il faut attendre, chaque entre du Reorder Buffer contient un bit de presence. Celui-ci est mit 1 quand le rsultat de l'instruction est crit dans l'entre.

Autres informations
Suivant le processeur, le Reorder Buffer peut parfois contenir d'autres informations, comme le registre ou l'adresse o crire. Mais cela dpend du processeur utilis, aussi cela ne sert rien de rentrer dans les dtails.

Une File
Il faut prciser que les instructions ne quittent pas le Reorder Buffer n'importe quand. Un rsultat est enregistr dans un registre lorsque les instructions prcdentes (dans l'ordre du programme) ont toutes crit leurs rsultats dans les registres. Pour cela, notre Reorder Buffer est une sorte de mmoire, trie dans l'ordre d'ajout : les instructions sont tries des plus rcentes aux plus anciennes. Seule l'instruction la plus ancienne peut quitter le Reorder Buffer et enregistrer son rsultat une fois si celui-ci est prsent (pensez au bit de prsence). Les instructions plus rcentes doivent attendre.

Implmentation
V oyons un peu comment grer cet ordre d'criture. Notre Reorder Buffer contient un nombre d'entre qui est fix, cbl une fois pour toute. Chacune de ces entres est identifie par un nombre, qui lui est attribu dfinitivement.

Cet identifiant pourra alors servir configurer un multiplexeur, qui slectionnera la bonne entre dans le Reorder Buffer, pour lire son contenu ou y crire.

End Of Queue
Ces entres sont gres par leur identifiant. Le numro de l'entre la plus ancienne est ainsi mmoris dans une petite mmoire. Cela permet de pointer sur cet entre, qui contient la prochaine donne enregistrer dans les registres ou la mmoire.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

344/378

Quand cette entre quitte le Reorder Buffer, le numro, le pointeurs sur la dernire entre est augment de 1, pour pointer sur la prochaine entre.

Begining Of Queue
De mme, le numro de l'entre la plus rcente est aussi mmoris dans une petite mmoire. Il faut bien savoir o ajouter de nouvelles entres. Ainsi, le Reorder Buffer sait quelles sont les entres valides : ce sont celles qui sont situes entre ces deux entres.

Quand on ajoute des instructions dans le Reorder Buffer, il ne faut pas oublier d'augmenter ce numro de 1. Petit dtail : quand on ajoute des instructions dans le Reorder Buffer, il se peut que l'on arrive au bout, l'entre qui a le plus grand nombre. Pourtant, le Reorder Buffer n'est pas plein. De la place se libre dans les entres basses, au fur et mesure que le Reorder Buffer. Dans ce cas, on n'hsite pas reprendre depuis le dbut. Exemple : je prends l'exemple prcdent, avec l'entre 4 occupe. Si je rajoute une instruction, je remplirais l'entre 5.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

345/378

La prochaine entre tre remplie sera l'entre numrot 0. Et on poursuivra ainsi de suite.

Taille du R.O.B
Quand notre Reorder Buffer est plein, le processeur va automatiquement bloquer les tages de Fetch, Dcodage, et renommage (Issue). Cela vite de charger des instructions dans celui-ci alors qu'il est plein. Consquence : cela empche de charger de nouvelles instructions dans les Reservations Stations. Petite remarque : cela implique que plus un Reorder Buffer peu contenir d'instruction, plus on pourra xecuter d'instructions de faon anticipe. Lexcution Out-Of-Order sera ainsi plus facile et donnera de meilleurs rsultats. Sur les processeurs utilisant un squenceur micro-cod, certaines amliorations au niveau de l'unit de dcodage d'instruction permettent de mieux utiliser ce Reorder Buffer. Ces fameuses amliorations sont celles qui consistent fusionner une ou plusieurs instructions machines en une seule micro-opration. Notre Reorder Buffer va en effet stocker des micro-instruction, et non des instructions machines. En fusionnant plusieurs instructions machines ou micro-oprations en une seule, on diminue le nombre d'instructions stocker dans le Reorder Buffer : on gagne un peu de place.

Spculation Recovery
Dans le chapitre parlant de la prdiction de branchement, j'avais dit qu'il y avait deux solutions pour remettre le pipeline son tat originel en cas de mauvaise prdiction de branchement : empcher nos instructions fautives d'enregistrer leurs rsultats dans les registres (sous entendu, les registres architecturaux), ou remettre les registres leurs valeurs originelles partir d'une sauvegarde de ceux-ci. Le Reorder Buffer permet d'implmenter facilement la premire solution. C'est lui qui empche les instructions excutes de faon anticipes d'enregistrer leurs rsultats dans les registres architecturaux. en cas de mauvaise prdiction de branchement. Si une interruption ou une mauvaise prdiction de branchement a lieu, le Reorder Buffer se dbarrassera des rsultats des instructions qui suivent l'instruction fautive (celle qui a dclench l'interruption ou la mauvaise prdiction de branchement) : ces rsultats ne seront pas enregistrs dans les registres architecturaux. Les rsultats des instructions prcdant l'instruction fautive auront alors dj t sauvegards, laissant le processeur propre. Mais on doit amliorer le Reorder Buffer pour qu'il puisse grer tout cela.

O reprendre ?

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

346/378

Premire chose, dans de telles situations, il faut savoir o reprendre. Pour cela, chaque entre dans le Reorder Buffer contient en plus l'adresse de l'instruction. Par adresse, on veut dire contenu du Program Counter quand linstruction a t Fetche. Le Reorder Buffer utilise cette adresse pour savoir partir de quelle instruction il faut tout r-excuter. Parfois, cette adresse remplace le Tag de l'instruction.

Spculative Bit
Pour cela, on rajoute un bit dans chaque entre du Reorder Buffer. Ce bit servira prciser si l'instruction a leve une exception ou s'il s'agit d'un branchement mal pris. Si ce bit est 1, alors il y a eu une mauvaise prdiction de branchement ou une exception. Les pointeurs sur l'entre la plus rcente et la plus ancienne sont alors rinitialiss, mis zro. Cela permet de vider le Reorder Buffer, et vite d'enregistrer des rsultats faux en mmoire. Sur certains processeurs, on fait une distinction entre branchements et exception, en utilisant un bit pour prciser une mauvaise prdiction de branchement, et un autre pour prciser lexception (et si possible quelques autres pour prciser de quelle exception il s'agit).

Champ type de l'instruction

Nanmoins, il faut prendre attention un dtail : certaines instructions ne renvoient pas de rsultats. Sur certains processeurs, c'est le cas des branchements. On pourrait penser que ceux-ci ont pour rsultat leur adresse de destination, mais ce n'est pas forcment le cas sur tous les processeurs. Tout dpend de comment ils grent leurs branchements. Mais on peut aussi citer le cas des lectures, qui ne fournissent pas de rsultats. La logique voudrait que vu que ces instructions n'ont pas de rsultats, on ne doive pas leur allouer d'entre dans le Reorder Buffer. Mais si on fait cela, nos exceptions et nos mauvaise prdictions de branchement risquent de ne pas reprendre au bon endroit. N'oubliez pas qu'on dtermine quelle adresse reprendre en se basant sur le Program Counter de l'instruction qui quitte le Reorder Buffer. Si on dtecte une exception, c'est celui-ci qui est utilis. Et si on ne place pas une instruction dans le Reorder Buffer, et que celle-ci lve une exception matrielle, on ne reprend pas au bon endroit. Pour viter cela, on ajoute quand mme ces instructions dans le Reorder Buffer, et on rajoute un champ dans lentre. Ce champ stockera le type de l'instruction, afin que le Reorder Buffer puisse savoir s'il s'agit d'une instruction qui a un rsultat ou pas. On peut aussi utiliser cette indication pour savoir si le rsultat doit tre stock dans un registre ou dans la mmoire. Sur certains processeurs, le Reorder Buffer s'occupe de toutes les lectures et critures, qu'elles se fassent dans la mmoire et dans les registres. Et le Reorder Buffer doit trouver un moyen pour savoir s'il faut aller manipuler la RAM ou le Register File. De plus, dans certains Reorder Buffer stockent des informations supplmentaires, comme le registre ou l'adresse destination, dans des blocs de l'entre. Cette indication sur le type de l'instruction permet ainsi d'indiquer au Reorder Buffer s'il doit utiliser le morceau de l'entre qui stocke une adresse ou celle qui contient un registre de destination.

Accs mmoire
Pour remettre les accs mmoire dans l'ordre, certains processeurs utilisent un Reorder Buffer ddi aux lectures/critures. Celuici est spar du Reorder Buffer ddi aux registres. Mais les deux communiquent ensemble. Sur d'autres processeurs, on utilise un seul Reorder Buffer, charg de traiter la fois les instruction qui touchent aux registres et celles qui vont manipuler la mmoire.

Autres formes de renommages

Dans ce qu'on a vu dans l'algorithme de Tomasulo, on a vu l'importance du Reorder Buffer, ainsi que celle des Reservation Station. Ce sont ces dernires qui servent de " registres virtuels ", et qui permettent de faire du renommage de registre. Il ne s'agit pas proprement parler de registres, mais les Reservation Stations ont exactement la mme utilit que les registres virtuels. Le renommage de registres est alors implicite, dans le sens o il n'y a pas vraiment de registres virtuels, mais que quelque chose sert de registres virtuel. Mais il n'y a pas beaucoup de diffrences en terme d'efficacit avec d'autres formes de renommage de registre. Il existe d'autres faons de faire du renommage de registre. La plupart sont des adaptations de l'algorithme de Tomasulo, adaptes afin d'tre plus efficaces, ou moins consommatrices en nergie. Dans ces nouvelles version de l'algorithme de Tomasulo, les Reservation Station ne servent plus de registres virtuels, ces derniers tant stocks ailleurs. Cela peut paraitre bizarre, mais on va voir qu'en ralit, c'est plutt intuitif.

ROB
Commenons par faire une petite remarque sur l'algorithme de Tomasulo, auquel on a jout un Reorder Buffer. Dans cette version de l'algorithme, les rsultats de nos instructions sont stocks en deux exemplaires : dans les Reservation Stations, et dans le Reorder Buffer. Certains chercheurs ont alors eu l'ide de faire en sorte de ne pas copier inutilement nos donnes. Au lieu de

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

347/378

placer nos donnes en double ou triple, ils ont dcids de voir si on ne pouvait pas changer l'algorithme pour n'avoir qu'un seul exemplaire de donnes. L'ide est de stocker toutes les donnes en un seul exemplaire, dans le Reorder Buffer. On se retrouve donc avec un Reorder buffer, qui est quivalent aux registres virtuels, et un Register File qui contient tous les registres architecturaux. Avec ventuellement les fameuses Reservations Stations, mais sans que cela soit obligatoire : on peut trs bien s'en passer et les remplacer par autre chose.

Fonctionnement
Avec cette technique, les Reservation Stations ne contiennent plus de donnes, mais vont stocker de quoi savoir dans quelle entre du Reorder Buffer trouver la donne. Les Tags des oprandes seront remplacs par le numro des entres du Reorder Buffer qui contiendra la donne. Mme chose pour le Tag du rsultat d'une instruction, qui remplac par le numro de l'entre du Reorder Buffer destine laccueillir. Quand une instruction a toutes ses oprandes de prtes, celles-ci ne seront pas dans les Reservation Station, mais elles seront disponibles dans le Reorder Buffer ou dans le Register File. Notre instruction aura juste les lire depuis le Reorder Buffer ou le Register File, et les charger sur les entres de l'unit de calcul. Cela ncessite de connecter notre Reorder Buffer sur les entres des units de calcul, mais le jeu en vaut la chandelle.

Attention : ne prenez pas ce schma trop la lettre. Dans ce schma, on pourrait croire que le Register File ne sert rien. En fait, il faut se souvenir que les oprandes d'une instruction peuvent aussi tre lues depuis le Register File : il n'y a pas que le Reorder Buffer qui peut contenir les oprandes. De plus, je n'ai pas indiqu le Common Memory Bus, pour ne pas surcharger le tout. Et ce sera aussi le cas dans tous les schmas qui vont suivre. De mme, il arrive que certains processeurs fusionnent le Reorder Buffer et les Reservation Stations dans un seul gros circuit. On n'est vraiment pas un dtail prt !

Pipeline
Une petite remarque : cette lecture des oprandes depuis un registre peut prendre un certain temps. Pour viter tout problme, cette lecture est effectue dans un tage du pipeline spar. Le pipeline de notre processeur devient donc : Fetch ; Decode ; Issue/Rename : renommage des registres et allocation dans les Reservations Stations ; Reorder Buffer Read : lecture des oprandes d'une instruction depuis le Reorder Buffer ; Execution ; Completion : le rsultat est disponible sur le Common Memory Bus et mis en attente ;

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

Commit : le rsultat est enregistr dans les registres.

348/378

Pour information, cette version de l'algorithme de Tomasulo tait utilise dans d'anciens processeurs commerciaux, comme les Pentium Pro, le Pentium II, ou encore le Pentium III.

Rename Register File

Avec les deux versions prcdentes de l'algorithme de Tomasulo, le renommage de registre tait implicite : il n'y avait pas de Register File spcialis, qui contenait les registres virtuels. A la place, on utilisait les Reservation Station ou le Reorder Buffer. Mais sur la majorit des processeurs actuels, le renommage de registre est explicite. Cette fois-ci, on se retrouve avec un peu plus de composants. On dispose d'un Register File qui stocke les registres architecturaux, un autre Register File qui contient les registres virtuels, un Reorder Buffer, et ventuellement des Reservations Stations. Le Register File qui stocke les registres virtuels porte un nom : c'est le Rename Register File. Evidemmemnt, le Register File qui stocke les registres architecturaux porte aussi un nom : c'est le Retiremment Register File. Cette fois-ci, le Reorder Buffer subit le mme traitement qu'on a fait subir aux Reservations Stations : il ne contient plus la moindre donne. Avec cette version de l'algorithme, Reorder Buffer et Reservations Stations contiennent la place le nom du registre virtuel ou rel qui contient la donne.

Quand le Reorder Buffer veut crire une donne en mmoire, il a juste la lire depuis le Rename Register File, et l'crire directement dans le Retiremment Register File. Pareil pour les Reservation Stations : quand toutes les oprandes d'une instruction sont disponibles, elles sont lues depuis le Rename Register File ou le Retiremment Register File, et envoyes sur l'entre de l'unit de calcul. Le pipeline du processeur reste identique avec la version du renommage utilisant un Reorder Buffer, part que l'tape de lecture des oprandes s'appelle maintenant Register Read .

Physical Register File

On peut encore amliorer la structure vue au-dessus en utilisant non pas deux Register Files, mais un seul. On utilisera alors un grand Register File qui contient la fois les registres physiques que les registres virtuels. On appelle celui-ci un Physical Register File. Encore une fois, les Reservations Stations et le Reorder Buffer ne stockent plus les oprandes de l'instruction, mais seulement le nom du registre associ la donne.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

349/378

Aujourd 'hui, presque tous les processeurs utilisent ce genre de structure pour faire du renommage de registres. Il faut dire qu'un Physical Register File consomme bien moins d'nergie que ses concurents. Il faut dire que les donnes ne sont pas copies d'un Rename Register File vers un Retiremment Register File. Et de plus, les diverses structures matrielle associes, comme le Reorder Buffer, contiennent des pointeurs vers nos registres, ce qui prend moins de place que stocker directement les donnes, plus longues. C'est pour cela que cette amlioration est utilis sur les derniers processeurs actuels. Autre avantage : certaines oprations deviennent inutiles si le renommage de registres est fait intelligemment. Il s'agit des instructions de copie d'un registre dans un autre (les mov) ou dchange entre deux registres (xchg). Elles peuvent tre supprimes via une application correcte du register renamming . Aprs la copie de notre registre dans un autre, le contenu des deux registres est identique. Ce n'est que lors d'une criture lieu dans des deux registres que leurs contenus diffrents. Au lieu de faire cette recopie, on peut utiliser un seul registre physique pour stocker la valeur recopier et renvoyer toute lecture des deux registres architecturaux vers ce registre physique. Lors d'une criture dans un de ces deux registres, il suffira d'utiliser un registre physique vide pour stocker la donne crire et l'associer avec le nom de ce registre. On peut considrer qu'il s'agit d'une forme de Copy On Write, applique sur des registres, en considrant que le nom d'un registre est un pointeur (il vaudrait mieux parler de rfrence, mais bon...) vers un registre physique.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

350/378

Les optimisations des accs mmoire

Dans tout ce qu'on a vu prcdemment, on a surtout parl des instructions arithmtiques et des branchements. Le chapitre sur lexcution Out Of Order nous a montr que l'on pouvait modifier l'ordre des instructions pour gagner en efficacit. Et avec le chapitre sur le renommage de registre, on a vu comment supprimer certaines dpendances entre instructions lorsque ces instructions utilisant des registres. Ainsi, si deux instructions rutilisaient le mme registre, mais des instants diffrents, on pouvait supprimer les dpendances WAR et WAW qui en rsultait. Le seul problme, c'est que tout cela n'est valable que pour les instructions travaillant sur des registres. Si nos instructions doivent aller lire ou crire dans la mmoire, le renommage de registre ne servira rien ! Dans ce cas prcis, on ne peut donc supprimer les dpendances WAR et WAW avec ce genre de techniques, ce qui diminue les possibilits dexcution Out Of Order. Pour amliorer la situation, il a fallu trouver un moyen de limiter les effets de ces dpendances de donnes entre instructions d'accs mmoires. Pour ce faire, les concepteurs de processeurs et les chercheurs en architecture des ordinateurs ont invents diverses techniques plus ou moins efficaces permettant de grer ces dpendances entre instructions mmoires. Ces techniques sont ce qu'on appelle des techniques de Memory Disambiguation.

Dpendances, le retour !
Modifier l'ordre dexcution des accs la mmoire est une chose assez efficace en terme de performances. Par exemple, il vaut mieux effectuer les lectures le plus tt possible. Il faut dire que ces lectures prennent un certain temps : accder une donne ne se fait pas immdiatement. Cela peut prendre moins de 10 cycles d'horloge pour un accs au cache L1, mais peut facilement monter et atteindre des nombres 2 chiffres pour les accs au L2, et trois chiffres pour les accs la mmoire. Autant dire que ne rien faire durant cet accs au cache ou la mmoire, et faire attendre les instructions suivant une instruction de lecture n'est pas une bonne chose. L'idal serait dexcuter des instructions indpendantes de l'accs en mmoire pendant qu'on attend que la donne voulue soit lue. Pour ce faire, il suffit dexcuter la lecture le plus prcocement possible, et xecuter des instructions indpendantes pendant ce temps. Seul problme : il faut que toutes les instructions ayant une dpendance avec cette lecture aient dj finies de sexcuter avant qu'on puisse lancer la lecture. Si on se trouve dans un tel cas, il se peut que l'on ne puisse dmarrer notre lecture aussi tt que prvu, parce qu'une instruction ayant une dpendance avec notre lecture n'est pas termine : impossible de faire passer notre lecture avant celle-ci. Reste savoir si ces dpendances sont monnaie courante.

Utilit
Dans le chapitre prcdent, on a vu que ces dpendances naissaient lorsque l'on des instructions diffrentes veulent lire ou crire dans des emplacements mmoire identiques. Dans les cas des registres, cela arrive trs souvent : un processeur possde souvent une faible quantit de registres, qui doit donc tre utilise au mieux. Ainsi, nos compilateurs nhsitent pas rutiliser des registres ds que possible, et n'hsitent pas craser des donnes qui ne sont plus ncessaires pour stocker des rsultats utiles. Rutiliser des registres le plus possible fait donc apparaitre de nombreuses dpendances WAR et WAW. Mais pour les accs mmoires, c'est autre chose. Accder la mmoire n'est pas rare, certes, mais rutiliser de la mmoire l'est. Il est en effet trs rare qu'on doive lire ou crire des adresses identiques dans un cours laps de temps, et rares sont les dpendances WAR et WAW. Il faut dire que ces situations correspondent souvent des donnes qui sont stockes temporairement sur la pile, cause d'un manque de registres. On pourrait donc croire que chercher supprimer les dpendances WAR et WAW pour les accs la mmoire ne servirait que marginalement, et ne serait donc qu'un coup d'pe dans l'eau. Mais la situation est beaucoup plus complique que ce que cette prsentation nave vous l'a laiss entendre.

De nouvelles dpendances
Le seul truc, c'est que notre processeur ne peut pas toujours savoir si deux accs la mmoire vont se faire au mme endroit ou pas. Pour les instructions utilisant l'adressage absolu (l'adresse laquelle lire ou crire est stocke dans la suite de bits reprsentant notre instruction), il n'y a pas de problmes. Mais le seul truc, c'est que ce n'est pas le cas pour d'autres modes d'adressages. Par exemple, il n'est pas rare que nos adresses soient stockes dans des registres. Il est en effet monnaie courante de ne pas connaitre l'avance les adresses laquelle lire ou crire, et calculer des adresses est une chose commune de nos jours. Dans des cas pareils, il est impossible de savoir si deux accs la mmoire se font la mme adresse ou pas. Bilan : deux accs la mmoire peuvent tre totalement indpendants, mais le processeur ne peut pas le savoir. Rsultat : il est oblig de supposer par scurit que ces deux accs sont dpendants, ce qui va limiter ses possibilits. Il ne pourra pas changer l'ordre de ses instructions pour gagner en efficacit. Et cela arrive trs souvent : presque chaque accs mmoire ! Il faut noter que ce genre de situations arrive aussi dans un domaine assez loign. Certains compilateurs doivent faire face un problme similaire dans certaines situations : dans certaines conditions, ils ne savent pas si deux adresses mmoire utilises dans un programme sont diffrentes ou pas. Et dans ces conditions, ils doivent viter de modifier l'ordre des accs ces adresses, ce qui limite grandement les possibilits doptimisation. C'est ce qu'on appelle le phnomnes d'aliasing des pointeurs.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

351/378

Autre problme : il arrive qu'il ne soit pas possible de dplacer une lecture avant une autre. Cela arrive dans un cas simple : quand on charge une adresse dans un registre et qu'on chercher lire le contenu de cet adresse. On a obligatoirement besoin de charger l'adresse avant de charger la donne pointe par cette adresse. La premire lecture doit se faire avant l'autre. Une autre dpendance fait son apparition.

Dpendances de nommage
Pour limiter la catastrophe, notre processeur va utiliser des mcanismes permettant de diminuer les effets de nos dpendances, en supprimant ou attnuant celles-ci. Divers mcanismes de Memory Disambiguation ont ainsi ts invents. Ces techniques sont bases sur un principe assez proche de celui qui est derrire le renommage de registres. crire notre donnes au mme endroit que les lectures ou critures prcdentes va faire apparaitre des dpendances. Pour supprimer ces dpendances, on va simplement crire la donne ailleurs, et attendre que les lectures ou critures prcdentes cette adresse mmoire soient termines, avant de dplacer notre donne au bon endroit. Pour ce faire, on pourrait penser utiliser du renommage d'adresses mmoires. Mais ce serait compliqu, et augmenterait le nombre d'critures en mmoire d'une faon assez importante. Mme si certains processeurs utilisent cette technique, elle est tout de mme assez peu utilise, du fait de ses dfauts. D'autres solutions existent, plus efficaces.

Store queue
Si on utilisait le renommage d'adresses mmoires, on devrait utiliser la mmoire pour stocker temporairement des donnes crire, ces donne venant d'instructions excutes en avance compar ce qui tait prvu dans l'ordre du programme. Au lieu d'utiliser la mmoire, on prfre crire ces donnes dans une mmoire intgre au processeur, spcialement conue dans ce but : la store queue. Et oui, j'ose vous sortir un terme barbare sans prvenir : il faudra vous y habituer. Ainsi, on peut enregistrer nos donnes dans cette Store Queue temporairement. Chaque donne prsente dans cette Store Queue va quitter celle-ci pour tre enregistre en mmoire sous une condition bien particulire. Si dans l'ordre des instructions du programme, on trouve des lectures ou des critures qui lisent ou modifient l'adresse laquelle on veut crire cette donne, alors on doit attendre que celles-ci soient termines pour pouvoir dmarrer l'criture de notre donne et la faire quitter la Store Queue. L'utilisation d'une Store Queue a d'autres avantages : on peut xecuter notre criture avant certaines instructions qui pourraient lever une exception matrielle. Par exemple, on peut effectuer notre criture avant une opration de division, qui peut potentiellement lever une exception de division par zro. Sans Store Queue, on aurait excute notre criture et modifi la mmoire alors que notre criture n'aurait jamais t excute, vu que lexception leve par la division aurait alors interrompu le programme et aurait parfaitement pu faire zapper notre criture sous certaines circonstances. Avec une Store Queue, il suffit deffacer la donne crire de la Store Queue, ainsi que les informations qui lui sont associe, sans rien crire dans la mmoire. Cette Store Queue est localise dans les units Store, qui se chargent d'effectuer les oprations d'criture en mmoire.

Bypass Store Queue

Mais utiliser btement une Store Queue sans rflchir risque de poser quelques problmes. Imaginez la situation suivante : on crit une donne dans la Store Queue, et on cherche lire cette donne quelques cycles plus tard. La donne n'a alors pas encore t crite dans la mmoire RAM, et est encore dans la Store Queue. La lecture renverra alors la donne qui est en mmoire, soit une donne diffrente de celle qui est dans la Store Queue. En clair, le programme se met faire n'importe quoi... Pour viter ce genre de petits dsagrments, on doit permettre de lire des donnes dans la Store Queue. Ainsi, si on veut effecteur une lecture, les units en charge des lectures vont ainsi aller chercher la donne au bon endroit : dans la Store Queue, ou dans la mmoire. Cette solution, cette technique s'appelle le Store To Load Forwarding. Pour implmenter cette technique, on construit souvent notre Store Queue sous la forme d'une sorte de mmoire cache, contenant les donnes crire dans la mmoire. Cette mmoire cache a pour tag l'adresse laquelle on cherche crire notre donne. Si jamais une lecture a lieu, on va d'abord vrifier si une criture la mme adresse est en attente dans la Store Queue. Si c'est le cas, alors on renvoie la donne prsente dans celle-ci. Sinon, on va lire la donne en mmoire RAM. Au fait : que se passe-il si jamais deux donnes sont en attente d'criture dans la Store Queue et qu'on souhaite effectuer une lecture la mme adresse ?

Et bien dans ce cas l, la Store Queue se charge de donner la dernire donne avoir t crite, histoire de renvoyer la donne la plus jour. En excutant les lectures dans le bon ordre, cela ne pose aucun problme.

Dependances d'alias
Comme je l'ai dit plus haut, le processeur ne peut pas toujours savoir si deux accs mmoires vont se faire au mme endroit ou non. A cause de cela, des dpendances RAW, WAR, et WAW fictives apparaissent inutilement. Alors certes, l'utilisation d'une

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

352/378

Store Queue permet de supprimer ces dpendances WAR et WAW. Mais pour supprimer les fausses dpendances RAW, il faut trouver d'autres solutions.

Vrifications des adresses

La premire solution pour limiter les catastrophes consiste sparer les accs la mmoire en deux parties, en deux microinstructions : une qui calcule l'adresse laquelle on doit lire ou crire : on gre donc le mode d'adressage durant cette tape ; et une autre qui va accder la mmoire une fois l'adresse calcule. Ainsi, si on veut excuter une lecture de faon anticipe, il suffit de calculer son adresse, et vrifier si toutes les critures prcdant cette lecture dans l'ordre du programme se font une adresse diffrente. Si c'est le cas, c'est que notre lecture va lire une donne qui ne sera pas modifie par les critures en cours ou en attente dans la Store Queue. On peut donc l'effectuer directement. Dans le cas contraire, on doit attendre la fin des critures la mme adresse pour pouvoir dmarrer la lecture en mmoire ou dans la Store Queue. Cette technique n'est pas trs efficace : il est en effet peu probable que toutes les adresses des critures prcdant une lecture soit connue lorsque l'on veut lire notre donne. Autant dire que cette technique n'est pas utilise seule, et elle est complte par d'autres techniques plus ou moins complmentaires. Par exemple, certains processeurs incorporent une unit qui va fonctionner comme une unit de prdiction de branchement, la diffrence qu'elle va chercher prdire les adresses des critures. Ainsi, on pourra alors excuter spculativement une lecture si cette unit nous dit : "j'ai prdit qu'il n'y aura pas d'critures l'adresse que tu veux lire". Bon, videmment, il faut bien prendre en compte le cas o cette unit de prdiction des adresses mmoires se plante, et on gre cela comme pour les mauvaises prdictions de branchement : on vide le pipeline pour viter que cette lecture anticipe ne vienne mettre le bazar dans notre pipeline.

Excution spculative
Les techniques vues prcdemment donnent des rsultats assez bons, et sont des techniques assez utiles. Mais c'est loin d'tre la seule technique qui aie t invente pour diminuer l'effet des dpendances RAW. Parmi ces autres techniques, nombreuses sont celles qui utilisent lexcution spculative. Le terme peut paraitre barbare, mais il consiste simplement xecuter des instructions de faon anticipe, en supposant certaines choses, et en remettant le processeur zro si la supposition se rvle tre fausse. La prdiction de branchement est un cas dexcution spculative assez connu. Dans le cas des lectures et critures en mmoire, rien ne nous empche de rorganiser spculativement l'ordre des lectures et des critures quelque soit la situation, mme si on ne sait pas si les dpendances RAW entre deux accs mmoires sont fictives ou relles. Alors bien sr, on ne doit pas faire cela btement : notre processeur va vrifier si jamais il a fait une erreur en excutant une lecture trop anticipe, en vrifiant les adresses auxquelles il va crire et lire. Si jamais le processeur a excut une lecture trop tt (avant une criture la mme adresse dans l'ordre du programme), il va se charger d'liminer les modifications qui ont ts faites par cette lecture foireuse, et reprendra lexcution du programme convenablement. Pour pouvoir fonctionner correctement, notre processeur doit donc vrifier qu'il n'y a pas d'erreur. Une erreur correspond une lecture la mme adresse qu'une criture, avec la lecture qui est place aprs l'criture dans l'ordre des instructions impos par le programme. Pour faire ces vrifications, le processeur va garder la trace des lectures effectues dans une sorte de mmoire cache, la Load Queue. Cette Load Queue va conserver pour chaque lecture : l'adresse de la lecture effectue, ainsi que la donne lue. Cette Load Queue va conserver ces informations durant un certain temps, jusqu' ce que toutes les instructions prcdant la lecture dans l'ordre du programme soient termines. Une fois que ces instructions sont finies, la lecture est efface de la Load Queue, ou tout simplement oublie. Ainsi, chaque criture, il suffit de vrifier si une lecture a accd la mme adresse se trouve dans cette Load Queue. Rien de bien compliqu : on compare l'adresse de l'criture avec les tags de la Load Queue, qui contiennent l'adresse laquelle notre lecture a accd. Si on ne trouve pas de correspondance, alors il n'y a pas d'erreurs. Mais si c'est le cas, on doit alors supprimer du pipeline toutes les instructions excutes depuis la lecture anticipe fautive. En clair, on fait exactement la mme chose que lors d'une mauvaise prdiction de branchement : on vide le pipeline. Petit dtail : sur certaines processeurs, la Load Queue, et la Store Queue sont fusionnes dans une seul gros circuit.

Memory Dependance Prediction

Certains processeurs utilisent des mcanismes encore plus pousss pour viter le plus possible de passer outre des dpendances RAW. Pour cela, ils essayent de prdire si deux accs la mmoire se font la mme adresse, et si ils ont une dpendance RAW. Si c'est le cas, le processeur se charge dexcuter la l'criture avant la lecture, en nexcutant pas la lecture de faon trop anticip. Mais si ce n'est pas le cas, il excute nos deux instructions dans l'ordre qu'il veut. Bien sur, cela ne permet pas de se passer des techniques vues auparavant, mais cela aide tout de mme viter de payer les couts des erreurs sur des

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

dpendances RAW.

353/378

Wait Table
Une des techniques les plus simple pour prdire les dpendances d'alias est celle de la Wait Table. Le principe de cette technique est diablement simple : si jamais une lecture/criture va aller trifouiller la mme adresse qu'une de ses consurs, on s'en souviens pour la prochaine fois. Pour s'en souvenir, il suffit de rajouter quelque chose qui permettent de se souvenir des instructions mmoire ayant une dpendance RAW avec une de leur consur. Pour cela, il suffit de rajouter une mmoire dans laquelle on va placer les adresses (le Program Counter) des instructions ayant une dpendance. L'adresse de chaque instruction qui sexcute va ainsi tre stocke dans cette mmoire, et va tre associe un bit. Ce bit vaudra 0 si l'instruction correspondante n'a aucune dpendance, et 1 dans le cas contraire. Lunit de dcodage pourra alors dduire les dpendances de nos instructions. C'est cette technique qui tait utilise sur les processeurs Alpha 21264. Pour viter les faux positifs, le bit associ une instruction tait remis zro au bout d'un certain temps. Tous les 100 000 cycles d'horloge, pour tre prcis. On peut aussi amliorer l'ide en se passant du bit, et en ne stockant dans cette mmoire cache que les instructions ayant une dpendance, et pas les autres. Et l encore, on peut dcider de virer une instruction de cette mmoire au bout d'un certain temps pour viter les faux positifs.

Autres
La technique vue au-dessus a un sacr dfaut. Si jamais une instruction mmoire est indique comme ayant une dpendance avec une autre, on ne sait pas avec quelle instruction elle a cette dpendance. Notre instruction doit donc attendre que toutes les lectures et critures qui la prcdent soient termine avant de pouvoir sexcuter. Mme celles avec laquelle notre instruction n'a aucune dpendance. Nos instructions peuvent donc se retrouver attendre inutilement avant de pouvoir sexcuter. Pour viter cela, d'autres techniques de prdiction de dpendances mmoires ont ts inventes.

Load Value Prediction

On l'a vu prcdemment, lexcution spculative est assez efficace. Du moins, elle l'est dans des cas o le rsultat de la prdiction est simple. Par exemple, la prdiction de branchement est de lexcution spculative : on suppose que le branchement sera pris ou non-pris, et on excute les instructions qui correspondent ce qu'on a suppos. Les techniques de Memory Disambiguation qui cherchent prdire si deux instructions accdent la mme adresse, sont aussi de lexcution spculative.

Value prediction
Cette fois-ci, cela va beaucoup plus loin que prvu. Pour diminuer les effets de la Dataflow Limit, certains concepteurs de processeurs sont alls beaucoup plus loin. D'ordinaire, le processeur parie sur des choses simples, pour lesquelles il a peu de chances de se tromper. Un branchement est pris ou non-pris, deux adresses sont dpendantes ou ne le sont pas, etc. Dans les cas prcdemment cits, on n'a que deux possibilits : pris/non-pris, dpendantes/indpendantes. De plus, on peut optimiser ces techniques de faon utiliser certaines rgularits dans nos programmes, afin de prendre de meilleures dcisions, et obtenir au final de bons rsultats. Mais cette fois-ci, on change totalement de plan. Je vais vous parler des techniques de Value Prediction, qui consistent prdire quelle est la valeur prsente dans un registre ou une adresse mmoire laquelle on veut accder. Oui, vous avez bien lus : notre processeur est capable de parier sur la valeur qui sera charge depuis la mmoire et tenter de dcider si cette valeur vaut 0, 1, 1024, etc. Une fois son pari fait, il excute les instructions du programme avec la valeur qu'il a pari de faon spculative. Si le pari est correct, alors on continue lexcution. Sinon, on est oblig de faire comme lorsque l'on se trompe lors d'une prdiction de branchement ou une prdiction de dpendances d'adresses mmoires : on vide le pipeline, et on recommence avec la bonne valeur. Au premier abord, cette technique semble franchement mal parti. Tenter de prdire quelle sera la valeur stocke dans un registre de 32 bits parmi les 4 294 967 296 valeurs que ce registre peut stocker semble tre une aberration. Les chances de se tromper sont tellement normes ! Mais le fait est que dans certains cas, il est possible de spculer correctement. Bon, videmment, ces cas sont plutt rares, et dans la majorit des cas, le processeur refuse de parier. Il ne spcule pas, et nexcute pas d'instructions en pariant sur les donnes qu'elle vont manipuler. Mais dans certains cas bien prcis, on peut spculer sur le rsultat fourni par une instruction. Ces cas bien prcis concernent souvent le rsultat fourni par une instruction de lecture en mmoire. Par exemple, on peut parier qu'une instruction de lecture qui sexcute plusieurs fois de suite la mme adresse peut renvoyer la mme valeur chaque fois : c'est parfaitement possible si il n'y a eu aucune criture cette adresse entre temps. Mais ce n'est pas toujours le cas : on est donc oblig de parier. Cette technique qui consiste parier sur le rsultat d'une lecture s'appelle la Load Value Prediction. Nous allons nous intresser cette technique dans la suite de ce tutoriel, et nous ne parlerons pas des technique qui essayent de prdire le rsultats d'autres instructions (arithmtiques, etc).

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

354/378

Pourquoi a marche ?
On peut se demander quelles sont les raisons qui font qu'une instruction de lecture renvoie la mme valeur chaque fois. Aprs tout, autant lire une seule fois la donne et la garder dans un registre une bonne fois pour toute ! Mais cela n'est possible que dans un monde parfait. Dans la ralit, on fait face quelques limites.

Register Spill Code

Cela notamment arriver quand on n'a pas assez de registres pour stocker toutes nos donnes : certaines donnes doivent temporairement tre dplaces en mmoire pour librer des registres, puis sont remises dans les registres une fois qu'on a des registres de libres. On peut parfaitement spculer que lorsqu'une instruction en lecture sexcute aprs une instructions d'criture la mme adresse, la lecture renverra le rsultat qui a t crit juste avant.

Constant Pool
Cela arrive aussi quand on stocke des constantes en mmoire. Par exemple, sur les processeurs x86, les constantes flottantes ne peuvent pas tre intgres dans nos instructions via le mode d'adressage immdiat. A la place, on les stocke en mmoire et on les charge dans les registres chaque fois qu'on en a besoin.

Compilateurs
Il arrive aussi que les compilateurs n'arrivent pas grer efficacement les accs mmoires. Diverses raisons existent pour cela : certaines dpendances entre instructions forcent certaines donnes tre relues depuis la mmoire. Cela arrive notamment lorsque l'on utilise des pointeurs ou des rfrences : divers phnomnes complexes d'aliasing des pointeurs peuvent gnrer des relectures intempestives de donnes en mmoire. Cela peut aussi venir de machins qui arrivent lorsqu'on compile du code qui provient de plusieurs librairies, bref.

Branchements indirects
Enfin, certains branchements indirects doivent relire l'adresse laquelle il doive brancher depuis la mmoire rgulirement. Quand vous utilisez des switch ou des fonctions virtuelles dans votre langage objet prfr, votre compilateur va relire l'adresse laquelle brancher (l'adresse de la fonction ou du case) depuis la mmoire chaque accs. Il faut dire que cette adresse peut changer a tout moment, et qu'on est donc oblig d'aller la relire chaque fois. Mais vu que cette adresse change peu, et qu'elle est souvent la mme, les techniques de Load Value Prediction fonctionnent bien.

Implmentation
Pour implmenter cette technique, il suffit d'intgrer dans notre processeur une mmoire cache un peu spciale. De la mme faon qu'un utilise un Branch Target Buffer lorsqu'on parie sur les branchements, on doit utilise un cache quivalent pour la spculation sur les lectures.

Load Value Prediction Table

Pour commencer, la premire chose faire, c'est de disposer d'un moyen pour prdire correctement si une lecture va renvoyer le mme rsultat que la dernire fois. Pour cela, notre processeur incorpore une unit de prdiction des valeurs lues, aussi appele Load Value Prediction Table. Cette unit consiste simplement en une mmoire cache, sans tag , couple des compteurs. Cette mmoire cache contient l'adresse de linstruction de lecture. Je ne parle pas de l'adresse laquelle notre instruction va lire, mais de l'adresse laquelle se situe l'instruction, celle contenue dans le Program Counter quand il excute l'instruction de lecture. Cette mmoire cache contient donc des lignes de caches qui stockent ces adresses. Chaque adresse, chaque ligne de cache est relie des compteurs saturation, similaires ceux vus dans les units de prdiction de branchement. Pour tre franc, toutes les techniques vues dans le chapitre sur la prdiction de branchement peuvent s'adapter pour construire une Load Value Prediction Table. On peut aussi utiliser des compteurs saturation simples, ou utiliser des Two level adaptative predictor, voire des Agree Predictors. Quoiqu'il en soit, chaque cycle, le contenu du Program Counter sera compar au contenu de la mmoire cache : si l'adresse contenue dans le Program Counter correspond une adresse stocke dans le cache, cela signifie qu'une instruction de lecture dj excute l'est une fois de plus. Il suffit alors de regarder le rsultat du ou des compteurs saturation pour voir si on peut prdire notre instruction de lecture ou pas.

Load Value Table

Il nous faut aussi se souvenir de quelle tait la valeur lue lors des dernires excutions de notre lecture. Pour cela, rien de plus facile : on utilise une autre mmoire cache, qui contient cette valeur. Cette mmoire caches a pour tag , l'adresse laquelle lire.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

Cette mmoire cache s'appelle la Load Value Table.

355/378

Constant Verification Unit

Et enfin, il faut bien vrifier que notre prdiction tait correcte. Pour cela, rien de plus simple : il suffit de comparer la donne fournie par la Load Value Table, et celle fournie par la lecture. Si elles sont identiques, la prdiction tait correcte. Sinon, la prdiction tait fausse, et on doit vider le pipeline. Dans tous les cas, on prvient la Load Value Prediction Table pour qu'elle mette jour ses estimations et les compteurs saturation. Cette vrification est effectue par une unit spcialise nomme la Constant Verification Unit

Efficacit
A ce stade, je dois prciser que cette technique n'est pas encore tout fait mature, et quaucun processeur ne l'implmente encore. En tout cas, la recherche sur le sujet est encore en cours, et mme si aucun processeur n'a encore implment de technique de ce genre, cela ne saurait tarder. Quoiqu'il en soit, l'efficacit de cette technique a dj t tudies grce des simulateurs. Suivant les tudes ou les programmes, on trouve des rsultats qui varient pas mal. Dans certains cas, la performances baisse un peu, et dans d'autres, on peut avoir des gains de plus de 60% ! Mais dans des cas normaux, on trouve des gains de 4-5% environ. Ce qui est tout de mme pas mal l'heure actuelle. Plus d'information sur l'efficacit des diffrentes techniques ici : A comparative survey of Load Speculation Architectures .

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

356/378

Processeurs Multiple Issue

Dans les chapitres prcdents, on a vu des processeurs qui pouvaient commencer xecuter une nouvelle instruction par cycle, mais pas plus. Si vous regardez bien, les processeurs, y compris les processeurs Out Of Order , ne peuvent commencer xecuter qu'une nouvelle instruction par cycle. Les techniques comme l'Out Of Order ne permettant que de s'approcher le plus possible de l'objectif d'une nouvelle instruction excute par cycle. On dit que tout ces processeurs sont des processeurs Single Issue. Ces processeurs ont un IPC (le nombre d'instructions excutes en un seul cycle d'horloge : c'est l'inverse du CPI), qui ne peut pas dpasser 1, et qui est en pratique en dessous du fait des diffrents problmes rencontrs dans notre pipeline (dpendances, instructions multi-cycles, accs mmoires, etc). Et quand on court aprs la performance, on en veut toujours plus : un IPC de 1, c'est pas assez ! Est-ce un problme ? On va dire que oui. videmment, les concepteurs de processeurs on bien trouv une solution, une parade, bref : de quoi dmarrer lexcution de plusieurs instructions simultanment. De nouveaux processeurs sont apparus, capables d'avoir un IPC suprieur 1 : il s'agit des processeurs Multiple Issue.

Processeurs superscalaires
Ces processeurs fonctionnent comme s'ils avaient plusieurs pipelines. Le nombre de " pipelines " indiquant le nombre d'instructions diffrentes pouvant commencer leur excution simultanment. Par exemple, un processeur superscalaire pouvant dmarrer lexcution de deux instructions chaque cycle dhorloge se comportera comme s'il avait deux pipelines.

Attention : j'ai dit qu'il se comportera comme un processeur ayant deux pipelines, pas qu'il est rellement compos de deux pipelines. Croyez-moi, cette prcaution n'est pas l pour rien. Les processeurs superscalaires ne sont pas vraiment cres avec plusieurs pipelines qu'on aurait colls les uns cot des autres : pour simplifier, tous les circuits en charge d'une tape du pipeline ne sont pas forcment dupliqus. Mais pour expliquer cela, il nous faut rentrer plus profondment dans les circuits d'un tel processeur.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

357/378

Plusieurs units de calcul rentabiliser

Dans les chapitres prcdents, on a vu que nos processeurs Out Of Order utilisaient plusieurs units de calcul spares pour mieux grer les instructions multicycles. Dans le mme genre, il arrive que certains processeurs, qu'ils soient In Order ou Out Of Order, possdent des units de calcul spares pour les nombres flottants (des FPU), ou pour grer des calculs spciaux. Par exemple, un processeur peut contenir une unit de calcul spcialise dans les nombres entiers, un autre dans le calcul d'adresse, une autre pour les flottants, une autre pour les dcalages, etc. Bref, un processeur, Out Of Order ou non, peut contenir un grand nombre d'units de calcul, servant dans certaines situations, mais pas forcment en mme temps : il arrive que certaines de ces units soient inutilises durant un paquet de temps. Et ces units en plus sont trs souvent inutilises : il faut au minimum lexcution d'une instruction multicycle pour que cela fonctionne. Si on a un gros paquet d'instructions un seul cycle, on les excutera les unes aprs les autres, sans pouvoir en lancer plusieurs indpendamment dans des units de calcul spares. Et la raison est trs simple : sur des processeurs pareils, on ne peut lancer qu'une nouvelle instruction par cycle d'horloge, pas plusieurs. Pour rentabiliser ces units de calcul, divers chercheurs et ingnieurs se sont dits qu'ils serait pas mal de les remplir au maximum par des instructions indpendantes chaque cycle d'horloge. Pour cela, ils ont invents des processeurs qui peuvent dmarrer lexcution de plusieurs instructions simultanment, dans des units de calculs spares, pour les remplir au maximum. Pour que cela fonctionne, ces processeur doivent rpartir les instructions sur ces diffrentes units de calcul, et cela n'est pas une mince affaire. Pour cela, deux techniques existent : soit on rpartit les instructions sur les units de calcul lexcution, en faisant faire tout le travail par le processeur ; soit le compilateur ou le programmeur se charge de rpartir ces instructions sur les units de calcul la cration du programme. Ces deux solutions ont leurs avantages et leurs inconvnients, et dcider quelle est la meilleure des solutions est assez difficile. Il existe mme une sorte de querelle entre les partisans de la premire solution et ceux qui prfrent le seconde. Mais ce fameux dbat entre "brainiacs" (ceux qui veulent un processeur intelligent qui fait le caf et te paralllise tout seul des instructions) et "speed demons" (ceux qui veulent que le compilateur fasse le travail la place du processeur, parce que les circuits c'est pas gratuit) est loin d'tre termin. C'est un peu comme la guerre entre processeurs CISC et RISC, ou encore Linux versus Windows : linformatique est pleine de ce genre de querelles stupides, rien d'tonnant ce que le domaine de l'architecture des ordinateurs le soit aussi.

Micro-architecture d'un processeur superscalaire

Pour que notre processeur rpartisse ses instructions sur plusieurs units de calcul tout seul comme un grand (avec un peu d'aide du compilateur si besoin), il suffit juste de modifier le fonctionnement des tapes de dcodage et d'Issue, et toutes les autres tapes ventuelles qu'on trouve entre le Fetch et les units de calcul. C'est ainsi qu'on peut crer un processeur superscalaire : il suffit de modifier le squenceur de faon ce que celui-ci puisse rpartir plusieurs instructions en mme temps sur des units de calcul diffrentes. Sur les processeurs superscalaires, l'unit de Fetch est capable de charger plusieurs instructions depuis la mmoire en mme temps. Gnralement, cette unit va simplement charger une instruction, ainsi que celles qui suivent. Ainsi, notre unit de Fetch va prcharger plusieurs instructions la fois, et le Program Counter est modifi en consquence. Bien sur, les branchements peuvent poser quelques problmes dans ce genre de situations : si un branchement fait partie des instructions prcharge, que faire des instructions qui suivent : peut-on les xecuter ou pas ? On demande alors de l'aide l'unit de prdiction de branchement, videmment. Mais passons cela sous le tapis. Le squenceur est lui aussi modifi : celui-ci est maintenant capable de dcoder plusieurs instructions la fois (et il peut aussi ventuellement renommer les registres de ces instructions). Aprs tout, c'est normal : si on veut xecuter plusieurs instructions en mme temps, il faudra bien charger et dcoder plusieurs instructions simultanment ! Sur ces processeurs, on utilise souvent une seule unit capable de dcoder plusieurs instructions par cycle.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

358/378

Mais il est aussi possible d'utiliser un processeur qui possde plusieurs squenceurs bien spars. On peut se dbrouiller pour faire en sorte de dupliquer tous les circuits du processeur, sauf celui de Fetch. videmment, cela coute pas mal en circuits, mais cela peut tre supportable

Superscalaire In Order
Et oui, vous avez bien compris le titre : certains processeurs superscalaire n'utilisent pas l'Out Of Order . Cela peut paraitre bizarre, mais c'est la vrit. Sur de tels processeurs, on peut dmarrer lexcution d'instructions conscutives simultanment si celle-ci sont indpendantes et qu'il n'y aie pas de dpendance structurelle (genre, les deux instructions doivent utiliser la mme ALU, si les units de calcul adquates sont libres, etc). Le truc, c'est que ces processeurs sont efficaces sous certaines conditions uniquement : il faut que des instructions successives n'aient aucune dpendances. Et ce genre de situations est assez rare. Pour mieux exploiter ce genre de processeurs, on doit faire en sorte que le compilateur se dbrouille pour rordonner les instructions le mieux possible. Le compilateur devient assez complexe, mais cela permet d'viter d'avoir des circuits plus ou moins complexes dans le processeur : c'est que a coute cher en circuits, l'Out Of Order ! Pour donner un exemple, on va prendre le premier processeur grand public de ce type : le fameux Pentium ! Ce processeur possde deux pipelines : un qui s'appelle le U-pipe, et l'autre qui s'appelle le V-pipe. Si deux instructions se suivent dans l'ordre du programme, le processeur est capable de les xecuter simultanment si elles sont indpendantes : une dans chaque pipeline. On pourrait aussi citer les processeurs PowerPC, autrefois prsents dans les macs, et qu'on trouve dans certaines consoles de jeux.

Processeurs superscalaires Out Of Order

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

359/378

Il existe des processeurs plus volus, capables de faire mieux : les processeurs superscalaires Out Of Order. Avec ceux-ci, pas besoin que plusieurs instructions se suivent pour pouvoir tre excutes simultanment. Ces processeurs peuvent excuter des instructions indpendantes, sous certaines conditions. Le processeur a beaucoup de travail faire dans ces conditions. Il doit notamment vrifier quelles sont les instructions indpendantes, comme sur les processeurs superscalaires In Order. Qui plus est, il doit trouver comment rpartir au mieux les instructions sur les diffrentes units de calcul en modifiant l'ordre des instructions. Ce qui n'est pas simple du tout ! Mais les performances s'en ressentent : on peut excuter un plus grand nombre d'instructions simultanes.

Processeurs VLIW
Dans ce qui prcde, on a vu les processeurs superscalaires. Avec ceux-ci, on prenait un processeur, et celui-ci se dbrouillait pour vrifier les dpendances entre instructions et tenter de remplir les units de calcul du processeur. Avec les processeurs superscalaires Out Of Order et In Order, surtout avec les processeurs superscalaires Out Of Order . Bien sr, l'aide du compilateur est prcieuse pour obtenir de bonnes performances : un bon compilateur pourra rorganiser les instructions d'un programme de faon placer des instructions indpendantes le plus prt possible, histoire de donner des opportunits au Scheduler. Le fait est que ces processeurs superscalaires sont tout de mme assez complexes, particulirement les processeurs superscalaires Out Of Order . Une bonne part de leurs circuits permet dexcuter des instructions simultanment, et ces circuits ne sont pas gratuits : ils chauffent, consomment de llectricit, ont un certain temps de propagation qui limite la frquence, prennent de la place, coutent "cher", etc. Certains se sont dits que quitte faire travailler le compilateur, autant que ce soit lui qui fasse tout le boulot ! Si on dporte ce travail de rorganisation des instruction et leur rpartition sur les diffrentes units de calcul hors du processeur, cela fera des circuits en moins, et de la frquence en plus. C'est ainsi que les processeurs VLIW sont ns. Ces processeurs sont des processeurs In Order : ils excutent les instructions dans l'ordre dans lesquelles elles sont envoyes au processeurs. Mais il y a une diffrence avec les processeurs superscalaires habituels : les processeurs VLIW ne vont pas regarder si deux instructions conscutives peuvent tre excutes en mme temps, et ils ne vont pas non plus rpartir eux-mme les instructions sur les units de calculs. Cette tache sera plus ou moins dlgue au compilateur. Pour ce faire, le compilateur va devoir garantir que les instructions qui se suivent sont strictement indpendantes. Qui plus est, il va falloir lui fournir un moyen de prciser sur quelle unit de calcul lancer l'instruction.

Bundles
Pour ce faire, notre compilateur va regrouper des instructions dans ce qu'on appelle des Bundles, des sortes de superinstructions. Ces bundles sont dcoups en Slots, en morceaux de taille bien prcise, dans lesquels il va venir placer les instructions lmentaires faire excuter. Instruction Slot 1 Addition VLIW Slot 2 Multiplication 3 slots Slot 3 Dcalage gauche

0111 1111 0000 0110 1111 0101 0110 1001 0101

Chaque slot sera attribu une unit de calcul bien prcise. Par exemple, le premier slot sera attribu la premire ALU, la second une autre ALU, le troisime la FPU, etc. Ainsi, l'unit de calcul excutant l'instruction sera prcise via la place de l'instruction lmentaire, le slot dans lequel elle se trouve. Qui plus est, vu que chaque slot sera attribu une unit de calcul diffrente, le compilateur peut se dbrouiller pour que chaque instruction dans un bundle soit indpendante de toutes les autres instructions dans ce bundle. Lorsqu'on excute un bundle, il sera dcompose par le squenceur en petites instructions lmentaires qui seront chacune attribue l'unit de calcul prcise par le slot qu'elles occupent. Pour simplifier la tache du dcodage, on fait en sorte que chaque slot aie une taille fixe. Exemple avec plusieurs units de dcodage.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

360/378

Au passage, VLIW est un acronyme pour Very Long Instruction Word . Et cet acronyme nous dit presque tout ce qu'il faut savoir sur ces architectures . Un bundle peut tre vu comme une sorte de super-instruction trs longues : ils font plus de 64 bits de long (plus de 8 octets) ! Et ils peuvent avoir une longueur pouvant aller jusqu' 256 512 bits (64 octets) !

Problmes
C'est le compilateur qui est charg de faire tout le travail en regroupant des instructions pouvant tre excutes en mme temps dans des units de calcul diffrentes dans une seule grosse instruction, un seul bundle. On n'a donc pas besoin de rajouter des circuits lectroniques chargs de rpartir les instructions sur diffrentes units de calculs. Mais on a intrt ce que le compilateur soit de qualit, parce que sinon, on est mort ! Et c'est un peu le problme de ces architectures : si le compilateur ne peut pas trouver de quoi remplir ces bundles avec des instructions indpendantes, il va devoir ruser. Et hormis quelques applications bien spcifiques, il est difficile de remplir ces bundles correctement. Pour les programmes ayant beaucoup d'instructions indpendantes, cela ne pose pas trop de problmes : certains programmes de traitement d'image ou faisant des traitements spcifiques peuvent tirer partie des architectures VLIW. Mais ceux-ci sont loin dtre une majorit. Sur les anciens processeurs VLIW, les instructions VLIW, les bundles, taient de taille fixe. Le compilateur devait donc remplir ceux-ci totalement, et remplissait les vides avec des nop, des instructions qui ne font rien. Dans ce genre de cas, pas mal de bits sont utiliss dans ces bundles pour rien : ils n'encodent pas une instruction et se contentent de dire de ne rien faire lunit de calcul qui leur est attribu. On utilise donc de la place rien. Le programme compil pour une architecture VLIW sera donc plus gros, et prendra plus de place en mmoire ou dans le cache. Ce qui peut rapidement foutre en l'air les performances si on ne peut pas remplir les bundles correctement. Ces processeurs doivent donc tre fournis avec des caches normes, des bus rapides, utilisent une grande quantit de mmoire, etc. Autant dire qu'en terme de consommation nergtique ou de performances, cela peut rduire nant les performances gagnes en simplifiant le processeur. Nanmoins, il faut citer que la majorit des processeurs VLIW rcents arrive rsoudre ce problme, en utilisant les instructions de longueur variable. Ainsi, les bundles vides, non remplit par des instructions, ne sont pas encods dans l'instruction. Les nop ne sont pas stocks dans l'instruction et ne prennent aucune place : le compilateur utilise juste ce qu'il faut pour encoder les instructions utiles, pas plus. Cela aide normment diminuer la code density des programmes compils pour ces architectures VLIW rcentes. Et c'est sans compter que certaines dpendances entre instructions ne peuvent tre supprimes qu' lexcution. Par exemple, le fait que les accs la mmoire aient des dures variables (suivant que la donne soit dans le cache ou la RAM, par exemple) joue sur les diffrentes dpendances. Un compilateur ne peut pas savoir combien de temps va mettre un accs mmoire, et il ne peut organiser les instructions d'un programme en consquence. Par contre, un processeur le peu : on en touchera surement un mot au chapitre suivant. Autre exemple : les dpendances d'instructions dues aux branchements. Les branchements ont en effet tendance limiter fortement les possibilits d'optimisation du compilateur. Alors qu' lexcution, un processeur peut prdire les branchements et supprimer un paquet de dpendances en fonction. Qui plus est, ces processeurs n'ont strictement aucune compatibilit, ou alors celle-ci est trs limite. En effet, le format des super-instructions VLIW, des bundles, est spcifique un processeur. Celui-ci va dire : telle instruction va sur telle ALU, et pas ailleurs. Mais si on rajoute des units de calcul dans une nouvelle version du processeur, il faudra recompiler notre programme pour que celui-ci puisse l'utiliser, voire mme simplement faire fonctionner notre programme. Dans des situations dans lesquelles on se fout de la compatibilit, cela ne pose aucun problmes : par exemple, on utilise beaucoup les processeurs VLIW dans l'embarqu. Mais pour un ordinateur de bureau, c'est autre chose...

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

361/378

Processeurs EPIC
Comme on l'a vu, les architectures VLIW ont quelques problmes. Une faible compatibilit, une code density pouvant tre assez mauvaise. De plus, la performance de ces processeurs dpend fortement de l'efficacit du compilateur. Le but de ces architectures est simple : on dlgue l'ordonnancement des instructions au compilateur, qui remplace totalement l'Out Of Order . En l'aidant un peu si possible. Pas d'Out Of Order , un peu de Register Rennaming , mais pas trop, et peu de techniques volues qui rendent le processeur capable de faire le caf. En 1997, Intel et HP lancrent un nouveau processeur, l'Itanium. Son architecture ressemblait fortement aux processeurs VLIW, mais avec les dfauts en moins. Dans un but marketing vident, Intel et HP prtendirent que l'architecture de ce processeur, bien que ressemblant aux processeurs VLIW, n'tait pas du VLIW. Ils appelrent cette nouvelle architecture EPIC, pour Explicit Parallelism Instruction Computing. Il faut avouer que cette architecture avait tout de mme de fortes diffrences avec le VLIW, mais elle avait aussi beaucoup de points communs. Bien videmment, beaucoup ne furent pas dupes, et une gigantesque controverse vit le jour : est-ce que les architectures EPIC sont des VLIW ou non ? On va passer celle-ci sous silence, et voir un peu ce que peut recouvrir ce terme : EPIC.

Bundles
Pour commencer, la premire diffrence avec les processeurs VLIW vient de ce qu'on met dans les Bundles. Sur les processeurs VLIW, les instructions taient places dans un Slot bien prcis qui spcifiait l'unit de calcul qui devait xecuter l'instruction. Niveau compatibilit, c'tait une catastrophe. Mais les Bundles des architectures EPIC ne fonctionnent pas sur ce principe. Ceux-ci sont simplement des groupes d'instructions indpendantes. Leur place dans l'instruction ne spcifie pas l'unit de calcul qui s'occupera de l'instruction. C'est le processeur qui va dcouper ce Bundles et tenter de rpartir les instructions du mieux qu'il peut sur les diffrentes ALU. En terme de compatibilit, c'est le rve : on peut rajouter des ALU sans avoir besoin de recompiler. Le processeur pourra alors profiter de leur prsence sans rien faire de spcial. Ces Bundles sont en plus de taille variable. Avec les processeurs VLIW, les Bundles avaient souvent une taille fixe. Et quand le compilateur n'arrivait pas les remplir, il laissait des vides. a gchait de la RAM. Mais avec les processeurs EPIC, on n'a pas ce genre de choses. Les Bundles des processeurs EPIC sont dlimits par un petit groupe de bits spcial, qui indique la fin d'un Bundles. Ce petit groupe de bits s'appelle un Stop Bit .

Prdication
Enfin, on peut signaler que les processeurs EPIC possdent un grand nombre d'instructions prdicats. Pour rappel, ces instructions prdicat sont des instructions "normales", comme des additions, copie d'un registre dans un autre, multiplication, accs mmoire, etc ; avec une diffrence : elles ne font quelque chose que si une condition est respecte, valide. Dans le cas contraire, celles-ci se comportent comme un nop, c'est dire une instruction qui ne fait rien !

Utilit
Leur but ? Celles-ci servent remplacer un grand nombre de branchements. Il faut dire que les branchements sont une vritable plaie pour les compilateurs : ceux-ci empchent d'effectuer de nombreuses optimisations. Par exemple, ils gnent fortement la capacit du compilateur dplacer des instructions et changer leur ordre. En supprimer le plus possible permet d'amliorer la situation. En consquence, ces instructions prdicats sont une vritable ncessite sur une architecture qui ne gre pas l'Out Of Order.

Itanium d'Intel
Pour donner un exemple d'instructions prdicats, je vais vous parler des instructions de l'Itanium. L'Itanium possde plusieurs registres d'tats de un bit ! Il y en a en tout 64, qui sont numrots de 0 63. Chacun de ces registres peut stocker une valeur : vrai (un) ou faux (zro). Le registre 0 est en lecture seule : il contient toujours la valeur vrai, sans qu'on puisse le modifier. Ces registres sont modifis par des instructions de comparaison, qui peuvent placer leur rsultat dans n'importe quel registre prdicat. Elle doivent tout de mme prciser le registre dans lequel stocker le rsultat. Chaque instruction prdicat va prciser quel est le registre qui contient la valeur vrai ou faux permettant d'autoriser ou d'interdire son excution en utilisant un mode d'adressage spcial. L'instruction sexcutera normalement si ce registre contient la valeur vrai, et elle ne fera rien sinon. Petite remarque : une instruction peut carrment spcifier plusieurs registres. Ainsi, une

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

362/378

instruction peut sexcuter si deux registres prdicats sont vrais. Par exemple, elle peut faire un ET logique sur ces deux bits et dcide de sexcuter si jamais le rsultat est true. Elle peut aussi faire un OU logique, un XOR, un NAND, etc. Petite remarque : sur l'Itanium, presque toutes les instructions sont des instructions prdicats. Le truc, c'est que toutes les instructions qui sexcutent normalement, de faon inconditionnelles, sont des instructions qui vrifient le registre prdicat r0, qui vaut vrai, et qui est lecture seule. Cela implique aussi pas mal de choses bizarres. Par exemple, des comparaisons, qui crivent donc dans un registre prdicat, peuvent aussi tre prdicates.

Delayed Exceptions
Les branchements ne sont pas les seules instructions qui peuvent gner les compilateurs. Les instructions qui peuvent gnrer des exceptions matrielles leur pose aussi des problmes. La raison est simple : pour qu'une exception sexcute correctement, toutes les instructions qui prcdent l'exception doivent se terminer avant qu'on effectue l'exception. Et inversement, toutes les instructions qui sont aprs l'exception ne doivent pas sexcuter si celle-ci a lieu. En clair, notre compilateur ne peut pas faire passer des instructions avant ou aprs une de leur congnre, si cette dernire peut lever une exception. Cela limite les possibilits de rorganisation des instructions : une instruction qui peut lever une exception est considre par le compilateur comme une sorte de barrire infranchissable. Pour rsoudre le problme, l'Itanium implmente ce qu'on appelle les Delayed Exceptions. Avec la technique des Delayed Exceptions, le compilateur peut crer deux versions d'un mme code : une qui suppose qu'aucune exception matrielle n'est leve, et une autre version qui suppose qu'une exception est leve. La premire version est bien optimise, les instructions sont rorganise en ne tenant pas compte du fait qu'une instruction pouvant lever une exception est cense tre une barrire. La seconde version est compile normalement. Le programme est conu pour xecuter la premire version en premier. Une fois le code de cette version termin, le programme va alors utiliser une instruction pour vrifier que tout s'est bien pass. S'il n'y a pas eu d'exception, alors on continue dexcuter notre programme. Mais sinon, on branche vers la version du code non-optimise, correcte, et on lexcute. Pour vrifier que tout s'est bien pass, chaque registre est associ un bit cach, qui stocke un bit spcial. Ce bit, le bit Not A Thing , est mit 1 quand le registre contient une valeur invalide. Ainsi, si une instruction lve une exception, cette exception est passe sous silence, et notre instruction continue son excution. Elle crira alors un rsultat faux dans un registre, et le bit Not A Thing de ce registre est mit 1. Les autres instructions utiliseront alors cette valeur, et auront comme rsultat une valeur invalide, avec le bit Not A Thing mit 1. Une fois le code fini, il suffit d'utiliser une instruction qui teste ce fameux bit Not A Thing , et qui branche en consquence.

Spculation sur les lectures

Comme on l'a vu, les Delayed Exceptions permettent d'aider le compilateur rorganiser les instructions en spculant quelque chose, et en fournissant un moyen de se rattraper en cas d'erreur. Mais l'Itanium ne sarrte pas aux exceptions : il se charge aussi de fournir une fonctionnalit similaire pour les instructions de lecture en mmoire.

Principe
Pour voir quoi cela peut servir, il nous faut faire un petit rappel. Comme vous le savez, nos instructions de lecture en mmoire prennent un certain temps sexcuter. Cela peut aller de 2 3 cycles bien plus. Pour limiter la casse, le processeur peut parfaitement xecuter des instructions indpendantes de la lecture en attendant qu'elle se termine. Sur un processeur Out Of Order, le processeur et le compilateurs se chargent de dexcuter la lecture le plus prcocement possible, histoire dexcuter un maximum d'instructions indpendantes aprs la lecture. Le seul problme, c'est que sur les architectures EPIC, on est limit par le compilateur. Celui-ci ne peut pas dplacer la lecture trop tt sans changer le comportement du programme. Par exemple, il ne peut pas dplacer la lecture avant une criture si les adresses de ces deux instructions ne sont pas connues : si ces deux instructions travaillent sur la mme adresse, ce dplacement peut changer le comportement du programme. Les dpendances RAW, WAR, et WAW vont venir jouer les trouble-ftes. Et la mme chose arrive avec les branchements : faites passer une lecture avant un branchement, et il y a un risque que a fasse des chocapics ! Pour viter tout problme, un compilateur a interdiction de dplacer une lecture avant une instruction de branchement, une autre lecture, ou une criture.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

363/378

Pour rsoudre ce problme, l'Itanium fournit quelques instructions spciales, qui permettent au compilateur dexcuter des lectures en avance de faon totalement spculative, et de revenir la normale en cas de problme. Avec ces instructions, un compilateur peut dplacer une lecture avant une autre instruction d'accs mmoire ou un branchement. Cette lecture devient alors une lecture spculative. Reste ensuite vrifier que la spculation tait correcte. Si jamais la spculation rate, une dpendance a t viole et la lecture ne renvoie pas le bon rsultat. Vrifier qu'aucune dpendance n'a t viole ne se fait pas de la mme faon selon que la lecture aie t dplace avant un branchement ou avant une autre criture.

Spculation sur le contrle

Si on passe une lecture avant un branchement, la lecture et la vrification sont effectues par les instructions ld.s et chk.s.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

364/378

Si jamais la lecture est effectues alors qu'elle ne devrait pas l'tre, le processeur dtecte automatiquement cette situation. Pour rsoudre ce problme, il lve une Delayed Exception , et le bit Not A Thing du registre contenant la donne lue est alors mit 1. chk.s ne fait rien d'autre que vrifier ce bit. Si jamais la spculation n'a pas march, chk.s va brancher sur un morceau de programme qui traite cette exception lance pas notre lecture trop anticipe.

Spculation sur les donnes

Mais l'Itanium permet aussi de dplacer une lecture avant une autre criture. D'ordinaire, un bon processeur, disposant de mcanismes de Memory Disambiguation pourrait le faire lui-mme, et remettre le pipeline zro en cas d'erreur. Mais la philosophie de l'architecture EPIC est de dlguer cette tache au compilateur. Et c'est donc lui qui doit s'y coller. L'architecture EPIC fournit de quoi aider le compilateur : ce dernier peut ainsi spculer que la lecture et l'criture vont aller lire des adresses mmoires diffrentes, et rparer l'tat du processeur en cas d'erreur. Aprs tout, si les adresses sont dans des registres ou non connues la compilation, le compilateur ne peut pas savoir s'il y a dpendance entre ces deux accs mmoires ou non. Spculer dessus est donc parfois ncessaire. La vrification des dpendances de donnes entre lectures anticipe et criture se fait lexcution. Pour ce faire, le processeur utilise l'Advanced Load Address Table, aussi appele ALAT. C'est une sorte de mmoire cache, qui stocke des informations sur nos lectures anticipes. Elle stocke notamment l'adresse qui a t lue, a longueur de la donne lue, le registre de destination, et quelques autres informations. Tout se passe comme avec les branchements, part que les instructions ne sont pas les mmes. Le processeur va devoir utiliser les instructions ld.a et chk.a.

www.siteduzero.com

Partie 7 : Le paralllisme d'instruction et les processeurs modernes

365/378

Lorsqu'il excute l'instruction ld.a, le processeur va remplir l'ALAT avec les informations sur la lecture, et va dmarrer celle-ci. Puis, le processeur continue dexcuter le programme. Si jamais une criture la mme adresse a lieu, les informations sur la lecture sont supprimes de l'ALAT. Pour vrifier que notre lecture s'est bien passe, on utilise l'instruction chk.a. Celle-ci va vrifier si tout s'est bien pass en lisant ce qui est stock dans l'ALAT. Si il trouve une correspondance dans l'ALAT, alors la lecture s'est passe correctement. Sinon, c'est qu'une criture l'a supprime et que le contenu fourni apr la lecture est prim : on doit recommencer la lecture pour obtenir un rsultat correct.

Large Architectural Register File

Un processeur EPIC n'implmente aucune technique de Register Renamming . Ou alors s'il le fait, c'est pour des cas particuliers, et fans une forme assez btarde, qui concerne trs peu d'instructions. Pour compenser, un processeur EPIC contient un grand nombre de registres architecturaux, afin de faciliter le travail du compilateur. Il faut dire que les compilateurs aiment beaucoup disposer d'un grand nombre de registres : cela leur permet de diminuer le nombre d'accs mmoires, en stockant un grand nombre de variables dans ces registres. Cela leur permet aussi de stocker des donnes dans les registres au lieu de les recalculer sans cesse par manque de place. Bref. Ce grand nombre de registres permet au processeur d'utiliser des instructions 3-adresses. Elles permettent de prciser non seulement les registres des oprandes, mais aussi le registre de destination. Celui qui sert stocker le rsultat.

Bilan
Mettons les choses au point : l'Itanium est aujourd'hui abandonn. Il ne fut pas un franc succs. La raison : cette architecture se basait trop sur le compilateur pour gagner en performances. En thorie, il est possible d'utiliser cette architecture au maximum de ses capacit si on dispose d'un bon compilateur. Le seul problme, c'est qu'aucun compilateur n'est suffisant pour tirer correctement parti d'une telle architecture. Et c'est pas faute d'avoir essay : l'Itanium fournissait pas mal de fonctionnalits pour aider le compilateur. Mais le problme, c'est que le compilateur ne peut pas tout, et que le Hardware a une meilleure capacit optimiser un programme la vole. Dans un code remplit de branchements, avec beaucoup de dpendances, les architectures VLIW et EPIC sont mauvaises, et les processeurs Out Of Order sont les rois. Cependant, la situation s'inverse souvent dans des programmes avec peu de branchements et de dpendances. Bref, la morale de l'Itanium, c'est que le compilateur ne peut pas tout, et que tenter de tout lui dlguer ne marche pas quand on cherche la Performance Ultime, avec un grand P.

www.siteduzero.com

Partie 8 : Annexes

366/378

Partie 8 : Annexes
Dans cette partie, nous allons voir quelques petites choses pas vraiment fondamentales, mais assez intressantes.

Alignement mmoire et endianess

Outre le jeu d'instruction et l'architecture interne, les processeurs diffrent par la faon dont ils lisent et crivent la mmoire. On pourrait croire qu'il n'y a pas grande diffrence entre processeurs dans la faon dont ils grent la mmoire. Mais ce n'est pas le cas : des diffrences existent qui peuvent avoir un effet assez important. Dans ce chapitre, on va parler de l'endianess du processeur et de son alignement mmoire : on va s'intresser la faon dont le processeur va repartir en mmoire les octets des donnes qu'il manipule. Ces deux paramtres sont surement dj connus de ceux qui ont une exprience de la programmation assez consquente. Les autres apprendront ce que c'est dans ce chapitre.

Alignement mmoire
Si vous vous souvenez des chapitres prcdents, vous vous rappelez que le bus de donne a souvent une largeur de plusieurs octets. Le processeur peut ainsi charger 2, 4 ou 8 octets d'un seul coup (parfois plus). On dit que le processeur accde un mot en mmoire. Ce mot n'est rien d'autre qu'une donne qui a la mme taille que le bus de donne. Suivant le processeur, il existe parfois des restrictions sur la place de chacun de ces mots en mmoire.

Accs mmoires la granularit de l'octet

On peut voir la mmoire comme un tableau de cases mmoires, faisant chacune un octet, toutes accessibles individuellement.

On peut parfaitement vouloir lire 1, 2, 4, 8 octets individuellement. Par exemple, on peut vouloir charger un octet depuis la mmoire dans un registre. Pour cela, notre processeur dispose de modes d'adressages, voir d'instruction diffrentes, suivant qu'on veuille lire ou crire 1, 2, 4, 8, 16 octets. Quand on veut charger une donne sur un bus plus grand que celle-ci, les cases mmoires immdiatement suivantes sont aussi copies sur le bus. Mais rassurez-vous : le processeur les ignore. En choisissant la bonne instruction ou le bon mode d'adressage, les bits en trop chargs sur le bus de donne ne seront pas pris en compte. Bien sr, cela marche aussi pour l'criture.

www.siteduzero.com

Partie 8 : Annexes
Exemple : on souhaite charger un octet dans un registre de trois octets, en passant par un bus de trois octets.

367/378

Sur de tels processeurs et mmoires, on peut lire ou crire n'importe quelle adresse, sans aucune restriction. Toute donne est accessible en une seule fois, du moment que celle-ci est plus petite que le bus de donne : elle peut faire 1, 2, 4, 8 octets, si le bus peut contenir celle-ci, on peut la charger en une seule fois quelque soit la situation, quelque soit son adresse. On dit que ces processeurs accdent la mmoire la granularit de l'octet. Pour donner un exemple, je peux parfaitement dcider de charger dans mon registre une donne de 16 bits localise l'adresse 4, puis lire une autre donne de 16 bits localise l'adresse 5 pour la charger dans un autre registre sans aucun problme.

www.siteduzero.com

Partie 8 : Annexes

368/378

Alignement suprieur l'octet

www.siteduzero.com

Partie 8 : Annexes

369/378

Mais d'autres processeurs ou certaines mmoires imposent des restrictions assez drastiques dans la faon de grer ces mots. Certains processeurs (ou certaines mmoires) regroupent les cases mmoires en "blocs" de la taille d'un mot : ceux-ci utilise un certain alignement mmoire. On peut voir chacun de ces blocs comme une "case mmoire" fictive un peu plus grosse que les cases mmoires relles et considrer que chacun de ces blocs possde une adresse. L'adresse d'un de ces groupes est l'adresse de l'octet de poids faible. Les adresses des octets situ dans le groupe (c'est dire autre que l'octet de poids faible) sont inutilisables : on ne peut adresser qu'un groupe, via son octet de poids faible, et charger l'intgralit de ce mot sur le bus, mais pas accder un octet en particulier.

L'adressage de la mmoire est donc moins "fin" : on travaille sur des blocs de plusieurs bits, plutt que sur des petits paquets. Ces blocs sont appels des mots.

Bus d'adresse et alignement

On l'a vu, certaines adresses mmoires deviennent inutilisables : celle qui sont situes dans un mot et qui ne pointent pas vers son octet de poids faible. Par exemple, si on prend un groupe de deux octets, on est certain qu'une case sur deux sera inutile : les adresses impairs pointeront sur l'octet de poids fort de notre groupe. Prenons un autre exemple : un processeur ayant des mots de 4 octets. Rpertorions les adresses utilisables : on sait que l'adresse zro, est l'adresse de l'octet de poids faible de notre premier mot. L'adresse 1 est situe dans notre mot, pareil pour 2, pareil pour 3. L'adresse 4 est utilisable : c'est l'adresse du premier octet du second mot, etc. V ce que vous allez obtenir au final : oici Adresses utilisables 0 4 8 12

www.siteduzero.com

Partie 8 : Annexes
16 20 ...

370/378

Ceux qui sont observateurs remarqueront que seules les adresses multiples de 4 sont utilisables. Et ceux qui sont encore plus observateurs remarqueront que 4 est la taille d'un mot. Dans notre exemple, les adresses utilisables sont multiples de la taille d'un mot. Et bien sachez que cela fonctionne aussi avec d'autres tailles de mot que 4. En fait, a fonctionne mme tout le temps ! Si est la taille d'un mot, alors seules les adresses multiples de seront utilisables. Dans la ralit, ces blocs ont une taille gale une puissance de deux : cela permet de faire quelques bidouilles sur le bus d'adresse pour conomiser des fils. Si la taille d'un mot est gale , seules les adresses multiples de seront utilisables. Hors, ces adresses se reconnaissent facilement : leurs bits de poids faibles valent zro. On n'a donc pas besoin de cbler les fils correspondant ces bits de poids faible et on peut se contenter de les connecter la masse (le zro volt vu dans le second chapitre).

Accs mmoires non-aligns

Bon, maintenant imaginons un cas particulier : je dispose d'un processeur utilisant des mots de 4 octets. Je dispose aussi d'un programme qui doit manipuler un caractre stock sur 1 octet, un entier de 4 octets, et une donne de 2 octets. Mais un problme se pose : le programme qui manipule ces donnes a t programm par quelqu'un qui n'tait pas au courant de ces histoire d'alignement, et il a rpartit mes donnes un peu n'importe comment. Supposons que cet entier soit stock une adresse non-multiple de 4. Par exemple : Adresse Octet 4 Octet 3 Octet 2 Octet 1 Entier Entier

0x 0000 0000 Caractre Entier 0x 0000 0004 Entier 0x 0000 0008 -

Donne Donne -

Pour charger mon caractre dans un registre, pas de problmes : celui-ci tient dans un mot. Il me suffit alors de charger mon mot dans un registre en utilisant une instruction de mon processeur qui charge un octet. Pour ma donne de 2 octets, pas de problmes non plus ! Mais c'est parce que mon processeur est prvu pour. Dans ce genre de cas, il suffit que je donne mon instruction l'adresse laquelle commence ma donne : ici, ce serait l'adresse 0x 0000 0009. Je ne donne pas l'adresse du mot, mais l'adresse relle de ma donne. L'instruction dtectera que ma donne est stocke intgralement dans un mot, chargera celui-ci, et fera en sorte de n'crire que la donne voulue dans mon registre. Mais si je demande mon processeur de charger mon entier, a ne passe pas ! Mon entier est en effet stock sur deux mots diffrents, et on ne peut le charger en une seule fois : mon entier n'est pas align en mmoire. Dans ce cas, il peut se passer des tas de choses suivant le processeur qu'on utilise. Sur certains processeurs, la donne est charge en deux fois : c'est lgrement plus lent que la charger en une seule fois, mais a passe. Mais sur d'autres processeurs, la situation devient nettement plus grave : notre processeur ne peut en effet grer ce genre d'accs mmoire dans ses circuits et considre qu'il est face une erreur, similaire une division par zro ou quelque chose dans le genre. Il va alors interrompre le programme en cours dexcution et excuter un petit sous-programme qui grera cette erreur. On dit que notre processeur effectue une exception matrielle. Si on est chanceux, ce programme de gestion d'erreur chargera cette donne en deux fois : a prend beaucoup de temps. Mais sur d'autres processeurs, le programme responsable de cet accs mmoire en dehors des clous se fait sauvagement planter. Par exemple, essayez de manipuler une donne qui n'est pas "aligne" dans un mot de 16 octets avec une instruction SSE, vous aurez droit un joli petit crash ! C'est pas pour rien que ce genre d'instructions est si peu utilis par nos compilateurs. Pour viter ce genre de choses, les compilateurs utiliss pour des langages de haut niveau prfrent rajouter des donnes inutiles (on dit aussi du padding ) de faon ce que chaque donne soit bien aligne sur le bon nombre d'octets. En reprenant notre exemple du dessus, et en notant le padding X, on obtiendrait ceci : Adresse Octet 4 Octet 3 Octet 2 Octet 1 X X

0x 0000 0000 Caractre X

www.siteduzero.com

Partie 8 : Annexes
0x 0000 0004 Entier 0x 0000 0008 Donne Entier Entier Entier X

371/378

Donne X

Comme vous le voyez, a prend un peu plus de place, et de la mmoire est gche inutilement. C'est pas grand chose, mais quand on sait que de la mmoire cache est gche ainsi, a peut jouer un peu sur les performances. Il y a aussi des situations dans lesquelles rajouter du padding est une bonne chose et permet des gains en performances assez abominables : une sombre histoire de cache dans les architectures multiprocesseurs ou multicores, mais je n'en dit pas plus. Moralit : programmeurs, faites gaffe bien grer l'alignement en mmoire ! Cet alignement se gre dans certains langages (comme le C, le C++ ou l'ADA), en grant l'ordre de dclaration de vos variables. Essayez toujours de dclarer vos variables de faon remplir un mot intgralement ou le plus possible. Renseignez-vous sur le padding , et essayez de savoir quelle est la taille de vos donnes en regardant la norme de vos langages.

Endianness
V ous savez tous, depuis le premier chapitre, comment reprsenter des donnes simples (des nombres entiers, flottants) en binaire sous la forme d'une suite de bits. V ous savez que votre donne sera reprsente sous la forme d'une suite de bits stocke dans des octets qui se suivent dans la mmoire. Mais il y a une chose que vous ne savez pas encore : la faon dont ces bits seront repartis dans des octets varie suivant le processeur ! On peut faire une analogie avec les langues humaines : certaines scrivent de gauche droite (le franais, l'anglais) ; et d'autres de droite gauche. Dans un ordinateur, c'est un peu pareil : ils ont diverses sens d'criture. Lorsqu'ils crivent des donnes prenant plusieurs octets en mmoire, ceux-ci vont les crire de gauche droite dans un octet, ou l'inverse. Quand on veut parler de cet ordre d'criture, on parle d'endianness. Il existe divers endianness, variables suivant le processeur. V oyons lesquels et ce qui peut les diffrencier.

Big Endian
Certains processeurs sont de type Big endian . Sur ces processeurs, l'octet de poids fort de notre donne est stock dans la case mmoire ayant l'adresse la plus faible.

www.siteduzero.com

Partie 8 : Annexes

372/378

Little Endian
Sur les processeurs Little endian, c'est l'inverse : l'octet de poids faible de notre donne est stock dans la case mmoire ayant l'adresse la plus faible.

Un des avantages de ces architectures est qu'on peut accder une donne quelques soit sa longueur sans changer l'adresse de la donne charger, mme avec les contraintes dues l'alignement. En Big endian , il faudrait changer l'adresse laquelle accder en fonction du nombre de bytes lire ou crire.

Bi-Endian
Certains processeurs sont un peu plus souples : ils laissent le choix de l'endianness, et permettent de le configurer de faon logicielle ou matrielle. Ces processeurs sont dits Bi-endian.

www.siteduzero.com

Partie 8 : Annexes

373/378

Autres optimisations de la hirarchie mmoire

On l'a vu il y a de cela quelques chapitres, on n'utilise pas qu'une seule mmoire dans notre ordinateur. A la place, on prfre utiliser toute une hirarchie de mmoires de tailles et de vitesses diffrentes pour des raisons de performances. Il y a de cela quelques chapitres, j'avais dit que cette hirarchie de mmoires ressemblait au schma ci-dessous.

Ce fameux schma est en fait un peu faux, comme on va le voir. Dj, il n'est pas rare que notre processeur contienne des mmoires caches aussi rapides que les registres (on a vu le fameux trace cache par exemple, mais on pourrait aussi citer d'autres exemples), ou au contraire que certains registres soient plus lents que la mmoire principale (ceux utilis pour communiquer avec des priphriques). Mais il est aussi faux pour d'autres raisons : il existe d'autres types de mmoires qui ne sont pas prsentes sur ce schma, et qui ont pourtant leur place dans nos ordinateurs.

Local Stores
Dans le chapitre prcdent, on a vu une optimisation intressante : l'utilisation de mmoires caches. Avec ceux-ci, on peut accder beaucoup plus rapidement certaines donnes en mmoire principale. Mais les mmoires caches ne sont pas la seule solution ! Il existe en effet d'autres solutions pour compenser la lenteur de la mmoire RAM. Ces autres solutions consistent toujours intercaler des mmoires assez petites entre la mmoire RAM et le processeur. Mais attention, il y aura quelques diffrences avec les mmoires caches.

Rappels sur les caches

Pour bien comprendre la diffrence entre ces mmoires et les mmoires caches, il va falloir faire quelques rappels, histoire de bien mettre en valeur certains dtails des mmoires caches. Tout d'abord, on a bien vu que les mmoires caches taient un peu spciales : un cache n'est jamais adressable ! Cela est du au fait que chaque donne prsente dans la mmoire cache est une copie d'un emplacement de la mmoire RAM. On n'accde jamais directement au cache, mais on accde la mmoire, les circuits grant le cache pouvant intercepter la demande d'accs et accder au cache si besoin est (cache hit). Cela explique qu'on aie pas besoin de donner des adresses aux cases mmoires du cache : le contenu du cache est gr par des circuits particuliers qui dcident quoi charger dedans et quand.

Local Store
Sur certains processeurs, on prfre utiliser une autre mthode. A la place de mmoire cache, on utilise la place ce qu'on appelle un Local Store. Ces Local Stores sont des mmoires, souvent fabriques partir de SRAM, comme les mmoires caches. Qui plus est, ce sont des mmoires trs petites et trs rapides, tout comme les mmoires caches. Mais les ressemblances sarrtent l : ces Local Stores sont des mmoires RAM adressables ! Et cela change tout : vu que ces Local Store sont adressables, ils ne sont plus grs automatiquement par le processeur, et ils ne stockent pas forcment des copies de donnes prsentes en mmoires RAM. Ainsi, rien nempche le programmeur de dcider quoi placer dans cette mmoire et quand : il peut s'en servir de mmoires tampon pour stocker des donnes qui seront rutilises assez souvent et dans un intervalle de temps assez proche, sans avoir stocker ces donnes en RAM.

www.siteduzero.com

Partie 8 : Annexes

374/378

Nanmoins, il est parfois possible de transfrer des donnes de la mmoire principale ver ce Local Store. Ces transferts se font grce un contrleur DMA spcial, qui s'occupe de transfrer des donnes entre la RAM et le Local Store. Dans ce cas, c'est le processeur qui configure le contrleur pour que celui-ci effectue le transfert dsir. Dans ce genre de cas, la gestion d'un local store pose les mmes problmes que la gestion d'une mmoire cache : il faut notamment prendre en compte les localits spatiales et temporelles. Dans de telles conditions, on peut voir notre Local Store comme une sorte de mmoire cache gre par le programmeur, qui dcide quand lancer le transfert, quoi transfrer, et o.

C'est pas si rare !

L'utilisation de Local Stores est tout de mme quelque chose d'assez rpandu. Pour donner quelques exemples, voici quelques ordinateur et processeurs assez connus utilisant un Local Store : le processeur SuperH, utilis dans les consoles Sega Saturn, Sega 32X., ainsi que dans la Dreamcast ; les processeurs R3000 qu'on trouve dans la playstation 1; c'est aussi le cas de l'Emotion Engine, le processeur de la Playstation2 ; et tant qu' parler de consoles de jeux, ne parlons pas des processeurs SPE intgrs dans le processeur de la Playstation 3, qui possdent un Local Store de 256 kibioctets ; mais c'est sans oublier les cartes graphiques rcentes pouvant utiliser CUDA : la geforce 8800 utilise un Local Store de 16 kibioctets, et les modles rcents ont un Local Store encore plus gros.

Avantages/inconvnients
Ces Local Stores consomment moins d'nergie que les caches taille quivalente. En effet, ceux-ci sont de simples mmoires RAM, et on n'a pas besoin de circuits compliqus pour les grer : pas besoin de vrifier s'il y a cache miss ou cache hit, pas de tags, pas besoin de rechercher la prsence d'une donne en cache, etc. Ces circuits grant le cache prennent beaucoup de place sur le processeur, et ont un certain temps de latence. Dans la majorit des cas, cela ne pose pas de problmes : on peut faire avec sans trop de casse. Mais les Local Store n'ont pas ces problmes et peuvent tre trs avantageux. Cot inconvnients, ces Local Stores peuvent entrainer des problmes de compatibilit : que faire si jamais on souhaite changer leur taille ? On est oblig de changer certains programmes pour que ceux-ci puissent profiter de local stores plus grands, ou simplement pour que ceux-ci s'adaptent une organisation de la mmoire un peu diffrente. Au final, on utilise ces Local Stores dans des situations pour lesquels on se moque de la compatibilit et pour lesquelles on veut un ordinateur qui chauffe peu et consomme assez peu d'nergie. Ces Local Stores peuvent aussi tre trs avantageux quand il s'agit de partager des donnes entre plusieurs processeurs efficacement. Dans ce genre de cas, l'utilisation de toute une hirarchie de mmoires caches L1, L2, L3, etc ; pose des problmes assez consquents dont je ne parlerais pas ici (Ces fameuses histoires de cohrence des caches voque dans le chapitre prcdent), qui peuvent fortement diminuer les performances. Les Local Stores, eux, ne posent presque aucun problme, et sont donc mieux adapts ce genre de situations.

Prefetch Input Queue

V ous vous souvenez de ces histoires de prefetching ? Logiquement oui, vu que cela date peine du chapitre prcdent ! Pour rsumer, il s'agit simplement de prcharger l'avance les instructions ou donnes proches de celles charges il y a peu, afin de profiter au maximum du principe de localit spatiale. Dans le chapitre prcdent, on avait parl des diffrentes faons de prefetcher des donnes ou des instructions. Les instructions ou donnes prefetches taient alors simplement charges dans la mmoire cache (dans le L1, le L2, etc). Le seul problme, c'est que la mmoire cache a tendance parfois tre assez lente. Ainsi, accder une donne qui est dj dans le cache le plus rapide (le cache L1), prefetche ou non, peut prendre entre deux trois cycles d'horloge sur les processeurs modernes. Est-ce que cela peut poser problme ? Oui, dans certains cas, cela peut ralentir le processeur. Il a donc fallu trouver des solutions pour viter ce genre de dsagrments. Cette solution consiste, pour ne pas changer, placer une nouvelle mmoire ultra-rapide assez petite le plus prs possible du processeur. Cette mmoire va simplement stocker des instructions prcharges l'avance. Cette mmoire est parfois appele la Prefetch Input Queue .

www.siteduzero.com

Partie 8 : Annexes

375/378

A l'intrieur de cette mmoire tampon, le instructions sont souvent stockes dans leur ordre d'arrive, histoire de faciliter la tache au processeur. Les circuits se chargeant de prcharger des instructions dans cette Prefetch Input Queue se contentent de faire du prchargement squentiel : les instructions d'un programme se suivant en mmoire, les accs en Stride ou les accs plus complexes sont inutiles, et se contentent de charger des instructions conscutives fonctionne parfaitement.

Implmentation
Reste que cette architecture peut tre mise en uvre de deux faons diffrentes. On peut par exemple vouloir utiliser un seul processeur : celui-ci se chargera aussi bien de la gestion de cette Prefetch Input Queue que de toutes les autres taches que l'on peut demander un processeur. Gnralement, un circuits spcialis du processeur se charge de la gestion de cette mmoire tampon, et se charge de prefetcher les instructions dedans. Sur certains processeurs, on utilise ainsi deux units : une charge de la gestion de la Prefetch Input Queue, qui s'occupe de prcharger les donnes, et une autre qui contient tout le reste du processeur. Mais certains ordinateurs utilisent une autre mthode : on utilise un processeur spcialis dans la gestion de la Prefetch Input Queue, et un processeur pour le reste. Quand on veut dire deux processeurs, cela signifie clairement deux processeurs, chacun avec leurs registres, jeux d'instructions, etc.

Paye tes branchements !

Les branchements posent toutefois quelques problmes avec cette Prefetch Input Queue : si un branchement a lieu, les instructions qui le suivent en mmoire auront ts prcharges et si l'on ne fait rien, elles seront excutes par le processeur, alors que le branchement aura saut ailleurs dans le programme. En Consquence, quand un branchement est excut par le processeur, le contenu de la Prefetch Input Queue doit imprativement tre vid, histoire de purger celle-ci des instructions qui n'auraient pas dues tre prcharges. Pour finir, sachez que ce tutoriel n'est qu'une misrable petite introduction un domaine franchement vaste. Si vous tes vraiment intresss par le sujet et que ce tutoriel ne satisfait pas vos envies de connaissances les plus primaires, il vous faudra poursuivre votre apprentissage sur le web, ou en lisant des livres de rfrence dignes de ce nom. Tout d'abord, sachez qu'il ne faut pas hsiter aller sur des sites de hardware comme Pcinpact, Hardware.fr, Clubic, voire mieux : Beyond 3d, Anandtech, et autres sites anglophones. A chaque sortie de processeur, ces sites publient souvent des articles dans lesquels ils dtaillent les diffrentes amliorations et innovations apportes au fonctionnement de leurs derniers processeurs ou cartes graphiques. Qui plus est, ces sites disposent d'articles relativement bien vulgariss, et assez accessibles, dtaillant des notions intressantes, parfois non abordes dans ce cours.

Liens sur le Siteduzro

www.siteduzero.com

Partie 8 : Annexes
Pour poursuivre, je me permets de vous prsenter trois tutoriels sur les processeurs, prsents sur le siteduzro, tous complmentaires ce qui a t crit dans ce tutoriel. N'hsitez pas lire ces tutoriels !

376/378

Icne

Titre Technologies de gestion de la consommation lectrique et du TDP d'un processeur Les processeurs orients objet Nombres flottants et processeurs Les processeurs Dataflow : paralllisme et langages fonctionnels Multicoeurs, Hyperthreading, paralllisme : qu'est-ce que c'est ? Le BIOS : qu'est-ce que c'est ?

Description

Ce tutoriel parle des diffrentes techniques permettant de diminuer la consommation lectrique et la chaleur gnre par nos processeurs.

Ce tutoriel parle de processeurs particulirement spciaux, optimiss pour les langages de programmation orients objets. Ce tutoriel parle plus en profondeur de la prise en charge des nombres flottants au niveau du processeur, et dtaille plus particulirement la FPU x87 des processeurs x86. Ce tutoriel parle d'une catgorie de processeurs assez exotique, mais trs intressante, nomme les architectures dataflow. Celles-ci sont voques dans ce tutoriel, mais pas vues en dtails : cet article est l pour cela ! V ous y dcouvrirez des architectures tonnantes et agrables, vraiment diffrentes des autres processeurs. Ce tutoriel parle des architectures conues pour xecuter plusieurs programmes en mme temps, et notamment des processeurs multicurs. Si vous vous demandez comment fait votre ordinateur pour dmarrer, alors ce tutoriel est fait pour vous.

Quelques liens internet

Mais cela ne suffira surement pas assouvir vos instincts les plus primaires de connaissance. Pour cela, il faudra aller un peu plus loin, et aller lire de la vraie documentation. Et pour cela, je me permets de vous donner quelques liens internet. Nom Structure et fonctionnement d'un ordinateur, cours crit par Jean Pierre Meinadier Cours d'architecture avanc, crit par Jurij Silc Et voici les cours de David Patterson, et de krste asanovic : basics of computer architecture Advanced computer architecture The art of computer assembly : ce site est un must pour ceux qui veulent comprendre le fonctionnement des architectures x86 actuelles Architectures des DSP : Processeurs spcialiss dans le traitement de signal Site sur l'optimisation de code contenant normment de renseignements sur le fonctionnement des processeurs actuels V un libre d'arithmtique des ordinateurs assez bien fait : Arithmtique des ordinateurs par Jean-Michel Muller oici Langue

Aussi, n'hsitez pas aller sur Google Scholar, lire des articles scientifiques. V ous verrez, avec un peu d'habitude et un niveau correct en anglais, on peut facilement se dbrouiller et apprendre beaucoup de choses dans ces articles.

www.siteduzero.com

Partie 8 : Annexes

377/378

Ouvrages de rfrence
Titre The indispensable PC Hardware Book Auteur Hans-peter Messmer

Computer organisation and design : the hardware/software interface Hennesy - Patterson Computer Architecture : A Quantitative Approach, 4th Edition Computer organisation and architecture Computer arithmetic Hennesy - Patterson William stallings Behrooz Parhami

Remerciements
Un petit merci : Spacefox pour son travail de validateur attitr du tutoriel, Macros le noir pour sa relecture attentive de mon tutoriel, et Lucas-84, pour l'ensemble de son uvre.

www.siteduzero.com