Danielle Etiemble - Architecture Des Ordinateurs

Architecture des Ordinateurs Premi`re partie e
Ccile Germain e
Daniel Etiemble
Licence dInformatique - IUP Miage - FIIFO
Table des mati`res e

1 Introduction 2 Les 2.1 2.2 2.3 2.4 composantes de lordinateur Le mod`le de Von Neumann . . . . . . . . . e Les faits technologiques . . . . . . . . . . . Lunit centrale . . . . . . . . . . . . . . . . e La mmoire . . . . . . . . . . . . . . . . . . e Les RAM . . . . . . . . . . . . . . . . . . . Les RAM statiques . . . . . . . . . . . . . . Les RAM dynamiques . . . . . . . . . . . . La hirarchie mmoire . . . . . . . . . . . . e e 2.5 Performances . . . . . . . . . . . . . . . . . Lvolution exponentielle des performances e Mesure de performances . . . . . . . . . . . CPI et IPC . . . . . . . . . . . . . . . . . . 3 7 7 9 9 12 12 13 13 14 16 16 16 17 21 21 22 23 23 24 24 25 26 28 32 33 33 34 35
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
3 Reprsentation de linformation e 3.1 Linformation . . . . . . . . . . Quantit dinformation . . . . . e Support de linformation . . . Notations . . . . . . . . . . . . 3.2 Reprsentation des caract`res . e e 3.3 Reprsentation des entiers . . . e Entiers naturels . . . . . . . . . Entiers relatifs . . . . . . . . . Oprations arithmtiques . . . e e Traitement des erreurs . . . . . Reprsentation BCD . . . . . . e 3.4 Nombres rels . . . . . . . . . . e Reprsentation des rels . . . . e e Reprsentation IEEE 754 . . . e
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . . 1
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
2 Oprations ottantes . . . . . . . . . e Traitement des situations anormales Prcision . . . . . . . . . . . . . . . . e Placement mmoire . . . . . . . . . . e Big Endian et Little Endian . . . . . Alignement . . . . . . . . . . . . . . Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tables des mati`res e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 38 40 41 41 42 43 45 46 46 46 49 50 52 52 53 54 55 56 56 60 61 61 63 63 66 66 66 68 70 72 74 75 77 80
3.5
4 Architecture logicielle du processeur 4.1 Mod`le dexcution . . . . . . . . . . . . . . . . . . . . . e e Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . e Les dirents mod`les dexcution . . . . . . . . . . . . e e e 4.2 Format des instructions . . . . . . . . . . . . . . . . . . 4.3 Langage de haut niveau et langage machine . . . . . . . 4.4 Instructions arithmtiques et logiques . . . . . . . . . . e Mode dadressage . . . . . . . . . . . . . . . . . . . . . . Instructions . . . . . . . . . . . . . . . . . . . . . . . . . 4.5 Instructions dacc`s mmoire . . . . . . . . . . . . . . . e e Acc`s entiers . . . . . . . . . . . . . . . . . . . . . . . . e Acc`s ottants . . . . . . . . . . . . . . . . . . . . . . . e Modes dadressage . . . . . . . . . . . . . . . . . . . . . 4.6 Instructions de comparaison . . . . . . . . . . . . . . . . 4.7 Instructions de saut et de branchement . . . . . . . . . . Branchements conditionnels sur registre code-conditions Branchements conditionnels sur registre gnral . . . . . e e Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8 Sous-programmes . . . . . . . . . . . . . . . . . . . . . . Fonctionnalits . . . . . . . . . . . . . . . . . . . . . . . e Appel et retour de sous-programme . . . . . . . . . . . . Passage des param`tres . . . . . . . . . . . . . . . . . . e Pile dexcution . . . . . . . . . . . . . . . . . . . . . . . e Sauvegarde du contexte . . . . . . . . . . . . . . . . . . Etude de cas . . . . . . . . . . . . . . . . . . . . . . . . Edition de liens et chargement dun programme . . . . . Quelques utilitaires . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
Chapitre 1
Introduction
Un cours sur lArchitecture des Ordinateurs demande de dnir ce que sont, dune part e un ordinateur, dautre part larchitecture. Le lecteur qui sapprte ` aborder le troiseme e a millnaire a certainement une intuition sur lordinateur, mais peut-tre pas dide prcise e e e e sur la notion darchitecture. Un ordinateur est un machine qui traite une information fournie par un organe dentre suivant un programme et dlivre une information sur un organe de sortie. e e La partie de lordinateur charge du traitement de linformation est appele Unit Centrale e e e (UC) ou Central Processing Unit (CPU). Lexplosion des jeux informatiques et videos a certainement dius aupr`s du grand e e public une connaissance fonctionnelle de certains composants architecturaux : chacun sait que, pour jouer raisonnablement sur un PC, il vaut mieux quil soit quip dune e e carte 3D, et beaucoup connaissent la hirarchie en termes de rapport qualit/prix de ces e e cartes. En tant que sous-discipline scientique de linformatique, aussi bien quen tant que comptence professionnelle, larchitecture des ordinateurs est plus que cette connaissance e encyclopdique. e Matriellement, un ordinateur est compos de cartes et de priphriques (cran, clavier, e e e e e disques etc.) ; chaque carte est elle-mme construite ` partir de composants lectroniques, e a e qui utilisent depuis les annes 60 la technologie des transistors et depuis les annes 70 la e e technologie des circuits intgrs. e e Ces divers organes doivent tre conus et organiss pour trouver un optimum suivant e c e les crit`res de fonctionnalit, de performances et de prix. Le plus important de ces organes e e est le processeur, qui est compos dun ou dun petit nombre de circuits intgrs. e e e Dans le sens le plus gnral, larchitecture est donc la conception et lorganisation des e e composants matriels de lordinateur bass sur la technologie des circuits intgrs, et plus e e e e particuli`rement du processeur. e Le terme de matriel dans la dnition ci-dessus ne signie pas que larchitecte dessine e e des transistors. Le fonctionnement dun ordinateur peut senvisager suivant la hirarchie des niveaux e 3
Chapitre 1. Introduction
Application Langage de haut niveau Langage machine
Microarchitecture Circuits Intgrs
Figure 1.1: Les niveaux dun syst`me informatique e dcrite dans la g 1.1. Lutilisateur nal voit une application plus ou moins interactive, e par exemple un jeu, ou un logiciel de traitement de texte. Cette couche est ralise e e essentiellement suivant un mod`le de calcul g dans un langage de haut niveau, qui e e utilise des mcanismes gnriques. Par exemple, presque tous les langages connaissent la e e e notion dappel fonctionnel rcursif, qui requiert sur les processeurs un mcanisme de pile e e et un mcanisme de rupture de squence (ceci sera expliqu plus loin). e e e Chaque processeur dispose dun langage spcique, son jeu dinstructions, qui implmente e e ces mcanismes communs. Le jeu dinstruction est galement appel langage-machine, ou e e e encore architecture logicielle. De faon prcise, le jeu dinstruction est une abstraction c e programmable (i.e. utilisable pour la programmation) du processeur. Les niveaux suivants sont gs dans le matriel, et ne sont pas reprogrammables. Le jeu dinstruction est e e donc linterface de programmation, lAPI, du processeur. Le jeu dinstruction est implment par divers circuits logiques : registres, UAL etc. e e Lorganisation et la coordination de ces organes constitue larchitecture matrielle du proe cesseur. De mme quune API est destine ` recevoir plusieur implmentations, ou une e e a e voiture plusieurs motorisations, un jeu dinstruction correspond en gnral ` plusieurs e e a architectures matrielles direntes. Finalement, les circuits logiques abstraits sont ine e stancis dans une technologie donne. e e Linteraction entre les niveaux de la hrarchie nest pas simplement descendante. Une e architecture logicielle est dune part conue pour permettre une compilation commode et c ecace des langages de haut niveau, mais aussi en fonction des possibilits dimplantation e matrielle. Lexemple le plus lmentaire est la taille des mots que le processeur peut e ee traiter : 8 bits dans les anness 70, 32 et plus souvent 64 maintenant. Plus profondment, e e la priode rcente (annes 85- 90) a vu une convergence forte des jeux dinstructions des e e e processeurs non Intel vers un noyau RISC. Un des objectifs de ce cours est de montrer comment ce type darchitecture logicielle dcoule de ltat de la technologie ` cette priode. e e a e
Non Programmable programmable
5 Le terme darchitecture a t initialement dni comme `quivalent a celui de jeu ee e e ` dinstructions. La premi`re architecture en ce sens est lIBM 360, dont le cycle de e vie sest tendu de 64 a 86. De mme, larchitecture 8086 est incluse dans toutes les e ` e architectures Intel qui lui ont succd. Auparavant, les niveaux de spcication (jeu e e e dinstruction) et de ralisation ntaient pas distingus. Lintrt vident est dassurer la e e e ee e compatibilit totale sans recompilation des applications. Cest un aspect supplmentaire, e e et tr`s important, de la fonctionnalit. En particulier, larchitecture logicielle x86 poss`de e e e de nombreuses caractristiques (nombre de registres, modes dadressage) qui expriment les e contraintes technologiques des annes 70, et ne sont plus du tout adaptes ` la technologie e e a actuelle. Cependant, Intel a maintenu la compatibilit binaire jusquau P3, a cause de e ` lnorme base installe. e e La convergence vers les jeux dinstruction RISC a ensuite mis laccent sur laspect organisation, qui est alors devenu le principal enjeu scientique et commercial de larchitecture. La priode qui souvre verra probablement un renouveau de la variabilit des jeux dinstruction. e e En particulier lIA-64 dIntel ore une fonctionnalit nouvelle dans le jeu dinstruction, e qui na jamais exist prdemment dans des ordinateurs commerciaux. e ce Le cours traite les deux aspects de larchitecture. La premi`re partie tudie larchitecture e e logicielle, ` travers le codage de linformation, et les jeux dinstruction. On tudiera a e en particulier la relation entre les structures des langages de haut niveau et le langage machine. La deuxi`me partie tudie larchitecture matrielle, du processeur, de la e e e hirarchie mmoire, et des organes dentres-sortie. Cette partie tudiera en particulier e e e e les consqences des contraintes technologiques sur les mod`les dexcution, la gestion de e e e la mmoire et les entres-sorties. e e Deux excellents livres correspondent ` ce cours [2, 1]. Ils ont t tous deux crits par a ee e les architectes des premiers microprocesseurs RISC. [2] est un synth`se abordable pour un e tudiant de licence, mais quand mme assez dicile. Ce livre a tr`s fortement marqu e e e e la conception darchitectures, en imposant une discipline dapproche quantitative. [1] est plus lmentaire. [3] est une synth`se qui prsente les caractristiques fondamentales des ee e e e architectures RISC.
Chapitre 1. Introduction
Chapitre 2
Les composantes de lordinateur

2.1 Le mod`le de Von Neumann e
Mmoire Bus CPU Entres Sorties
Figure 2.1: Principe de lorganisation dun ordinateur Dnition 1 Lordinateur est une machine lectronique, qui traite linformation dans e e une unit centrale (UC, ou CPU pour Central Processing Unit), selon un programme qui e est enregistr en mmoire. Les donnes fournies en entre par un organe dentre (par e e e e e exemple de type clavier) sont traites par lunit centrale en fonction du programme pour e e dlivrer les rsultats en sortie, via un organe de sortie (par exemple un cran). e e e Cette dnition tr`s gnrale est rsume dans la g. 2.1. Elle implique de dnir ce que e e e e e e e sont linformation et le traitement. Linformation est numrise, cest ` dire limite ` des e e a e a valeurs discr`tes, en loccurence binaires ; les dtails du codage binaire de linformation e e sont traits au chapitre suivant. Par ailleurs, la dnition implique que le comportement e e dun programme qui ne fait pas dentres-sorties ne peut tre spci. e e e e Le traitement suit le mod`le dexcution de Von Neumann. e e La mmoire contient les instructions et les donnes. e e 7
Chapitre 2. Les composantes de lordinateur La mmoire est forme dun ensemble de mots de longueur xe, chaque mot cone e tenant une information code en binaire. Chaque mot de la mmoire est accessible e e par lintermdiaire de ladresse mmoire. Le temps dacc`s ` un mot est le mme e e e a e quelle que soit la place du mot en mmoire : ce type dacc`s est appel alatoire, et e e e e les mmoires sont appeles RAM (random access memory). e e Les instructions sont excutes en squence. Le CPU conserve ladresse de la proe e e chaine instruction a excuter dans un registre, appel PC (Program Counter) ; pour ` e e chaque instruction, le CPU eectue les actions suivantes : lire linstruction a ladresse PC et incrmenter PC ; e excuter linstruction. e
Le premier ordinateur a t la machine ENIAC, construite a luniversit de Pennsylee ` e vannie (Moore School) pendant la seconde guerre mondiale, par les ingnieurs J. P. Eckert e et J. Mauchly. Elle avait t commande par larme amricaine pour le calcul des taee e e e bles de tir pour lartillerie. LENIAC a t la premi`re machine programmable, cest ` ee e a dire dont la squence doprations ntait pas prdnie, contrairement a un automate e e e e e ` du type caisse enregisteuse. Mais la nouveaut radicale de cette approche ntait pas e e compl`tement perue, ce dont tmoigne le nom de la machine : ENIAC signie Electronic e c e Numerical Integrator And Calculator. Cest le mathmaticien John Von Neuman, intgr e e e en 1944 au projet ENIAC, qui formalisa les concepts prsents dans ce premier ordinateur, e et les dveloppa sous le nom de projet EDVAC : Electronic Discrete Variable Automatic e Computer. La cration dun nouveau terme, Computer et non Calculator, correspond a e ` une rupture thorique fondamentale. Comme cela se reproduira souvent dans lhistoire de e linformatique, ce progr`s thorique majeur aboutit dans le tr`s court terme ` un semie e e a chec pratique : lquipe se dispersa, et lEDVAC ne fut oprationnel quen 1952. Von e e e Neumann contribua a la construction dune machine prototype universitaire a Princeton, ` ` LIAS. Eckert et J. Mauchly fond`rent une entreprise qui ralisa le premier ordinateur e e commercial, lUNIVAC-1, dont 48 exemplaires furent vendus. On trouvera un rsum de e e lvolution des calculateurs et des ordinateurs dans [4]. e La ralisation de lorganisation abstraite de la g. 2.1 a fortement vari depuis lorigine e e des ordinateurs. La g. 2.2 dcrit lorganisation matrielle typique dun ordinateur monoe e processeur (ie avec un seul CPU). Les composants matriels ne recoupent pas exactement e lorganisation abstraite : la mmoire est ralise par un ensemble de composants matriels, e e e e depuis un circuit intgrs dans le composant processeur (cache L1), jusquaux disques. Les e e disques appartiennent au domaine des entres-sorties par leur gestion, et en tant que supe port des syst`mes de chiers, mais aussi ` la hirarchie mmoire, car ils contiennent une e a e e partie des donnes et des instructions adressables par le processeur. Les entres-sorties e e incluent des interfaces, qui sont elles-mmes des processeurs programmables. e
2.2. Les faits technologiques

Bus Systme
Cache L2 Mmoire centrale Processeur CPU Cache L1 Adapteur
Bus Entres-Sorties Contrleur Contrleur Contrleur
rseau
Figure 2.2: Architecture dun ordinateur monoprocesseur en 99
2.2
Les faits technologiques
Lvolution des architectures repose sur la loi de Moore : e Dnition 2 Le nombre de transistors dans un circuit double approximativement tous les e 18 mois. Cette volution exponentielle de la capcit de calcul est accompagn dune augmentation, e e e galement exponentielle, de la frquence de fonctionnement, qui est multiplie par un e e e facteur 1,24 tous les ans (g. 2.3). La loi de Moore est tr`s souvent incorrectement interprte comme un doublement des e ee performances tous les 18 mois, ce qui nest pas exact : on verra plus loin que la performance progresse exponentiellement, mais moins vite. La loi de Moore est relie ` deux phnom`nes : dune part laugmentation de la densit e a e e e dintgration, cest ` dire du nombre de transistors intgrables par unit de surface, dautre e a e e part, laugmentation de la taille des circuits intgrs. Elle traduit globalement le nombre e e doprateurs matriels, et donc de fonctionnalits, qui peuvent tre intgres dans un e e e e e e processeur. Le produit du nombre doprateurs par la frquence dactivation traduit donc e e le nombre doprations potentiellement disponibles par seconde. e
2.3
Lunit centrale e
10
Chapitre 2. Les composantes de lordinateur
1000 Intel Motorola 100 Sparc DEC Alpha MIPS 10 78 80 82 84 86 88 90 92 94 96 98

RI Partie contrle
Figure 2.3: Evolution de la frquence des processeurs e Pour excuter un programme, lunit centrale appelle les instructions depuis la mmoire, e e e et les donnes que traitent ces instructions. En eet, dans ltat actuel de la technologie, le e e CPU ne peut travailler que sur des informations physiquement stockes pr`s des organes e e de calcul quelle contient. Lunit centrale se dcompose en une partie oprative, ou chemin de donnes et une e e e e partie contrle (g. 2.4). o Le chemin de donnes est organis autour dune unit arithmtique et logique (UAL) e e e e et doprateurs arithmtiques ottants qui eectuent les oprations sur les donnes. Les e e e e
F0 F1 Fn Units flottantes
R0 R1 Rn
PC
UAL
Chemin de donnes
Figure 2.4: Organisation de lunit centrale e
2.3. Lunit centrale e
11
oprandes, initialement lus en mmoire, et les rsultats des oprations, sont stocks dans e e e e e des organes de mmorisations internes au CPU, les registres. Certains de ces registres sont e visibles : leur nom (ou leur numro) est prsent dans linstruction, et le programmeur e e en langage machine peut dcider quel registre lire ou crire ; par exemple, linstruction e e ADD R1, R2, R3 nomme les trois registres R1, R2 et R3. Dautres registres ne sont pas visibles, et servent ` des besoins de stockage temporaire. Le chemin de donnes dtermine a e e les deux caractristiques fondamentales dune unit centrale, le temps de cycle et la largeur e e du chemin de donnes. e Le temps de cycle Tc est essentiellement le temps dune opration de lUAL ; linverse e du temps de cycle est la frquence ; si lunit de temps de cycle est la seconde, lunit e e e de frquence est le Hertz. Par exemple, un processeur cadenc ` 500MHz a un temps e ea 1 de cycle de 500106 = 2ns = 2 109 s. La largeur du chemin de donnes est la taille de linformation traite par la pare e tie oprative. Les premiers microprocesseurs taient des 8 bits, les processeurs e e gnralistes actuels sont 32 ou 64 bits, le processeur de la Playstation 2 est un e e 128 bits. On a mentionn ci-dessus linstruction ADD R1, R2, R3, alors que les instruce tions sont des mots binaires. En fait, le codage binaire des instructions ntant pas tr`s e e pratique pour lutilisateur humain, les instructions peuvent tre dcrites par un langage e e rudimentaire, le langage dassemblage. Celui-ci comporte des mnmoniques, qui dcrivent e e lopration, et une description des oprandes. Cest aussi le langage quutilise un proe e grammeur humain. Le langage dassemblage na aucune ralit au niveau de la machine e e ; la traduction en binaire est ralise par un utilitaire, lassembleur. La correspondance e e entre instruction binaire et langage dassemblage est tr`s lmentaire, du type traduce ee tion mot-`-mot (contrairement ` la compilation). Le codage est si immdiat quil est a a e rversible : les debogueurs (dbx, gdb) contiennent des dsassembleurs, qui eectuent le e e codage inverse, du binaire vers le langage dassemblage. Dans la suite, on utilisera un langage dassemblage gnrique, o` les registres seront nots R0 ` R31, et la syntaxe est e e u e a du type dest-source, par exemple ADD R1, R2, R3 ; une instruction daddition signie R1 R2 + R3 , le ; signalant le dbut dun commentaire. e La partie contrle eectue le squencement des direntes instructions en fonction des o e e rsultats des oprations et actionne les circuits logiques de base pour raliser les transferts e e e et traitements de donnes. Elle contrle galement la synchronisation avec les autres e o e composants. A cheval entre le chemin de donnes et la partie contrle, on trouve deux registres e o spcialiss : le compteur de programme PC, dont on a dj` parl, et le registre instruction e e ea e RI. Comme les autres informations, linstruction ne peut tre traite par le CPU que e e si elle y est physiquement prsente. La lecture de linstruction consiste donc ` copier e a
12
linstruction depuis la mmoire vers le registre RI. Comme le registre RI peut contenir une e constante oprande, il appartient au chemin de donnes ; comme il contient linstruction, e e que la partie contrle dcode pour activer les circuits logiques qui excutent linstruction, o e e il appartient aussi a la partie contrle. PC contrle la lecture de linstruction, mais il peut ` o o aussi tre modi par les instructions qui ralisent des branchements. e e e
2.4
La mmoire e
Les mmoires contiennent le programme (instructions et donnes). Les informations e e mmorises sont repres par une adresse. On distingue les mmoires ` acc`s alatoires e e ee e a e e (RAM) ralises avec des technologies semiconducteurs, et les mmoires secondaires, ralises e e e e e essentiellement avec des supports magntiques. e Les principes de fonctionnement des mmoires secondaires, comme les disques et les e disquettes, seront prsents dans le chapitre sur les Entres-Sorties. La caractristique e e e e importante est un temps dacc`s tr`s grand par rapport aux temps de cycle de lUC : pour e e les disques, il se chire en dizaines de s.
Les RAM
p lecture/criture 0
adresses m 2m - 1 donnes
Figure 2.5: Schma fonctionnel dune mmoire RAM e e Les RAM sont caractrises par le fait quun mot peut tre lu ou crit en un temps e e e e identique quelle que soit son adresse. Un mot est repr par une adresse : une adresse ee sur m bits permet de reprer un mot de p bits parmi 2m (g. 2.5). Gnralement, la plus e e e petite unit adressable est loctet (8 bits), mais la mmoire peut lire ou crire un mot de e e e plusieurs octets (4 ou 8 pour manipuler en un acc`s 32 ou 64 bits). Les mmoires RAM e e sont caractrises par plusieurs param`tres. e e e
2.4. La mmoire e Introduction 1980 1983 1986 1989 1992 1995 Capacit e 64 Kbits 256 Kbits 1 Mbits 4 Mbits 16 Mbits 64 Mbits Temps de cycle 250 ns 220 ns 190 ns 165 ns 120 ns 90 ns
13
Table 2.1: Evolution des mmoires dynamiques. e Taille, organisation et capacit : nombre de mots, nombre de bits par mot et nombre e total de bits. Temps dacc`s, le temps entre lenvoi de ladresse et lobtention de la donne, et e e temps de cycle, le temps entre deux oprations mmoire successives. e e Les mmoires RAM sont ralises avec les technologies ` semiconducteurs, le plus souvent e e e a a ` base de transistors MOS Il existe deux grandes classes de circuit ralisant une RAM, les RAM statiques (SRAM) e et les RAM dynamiques (DRAM)
Les RAM statiques

Leur point mmoire est constitu avec des portes logiques. La mmorisation est permae e e nente, tant que la mmoire est alimente. La lecture nest pas destructrice et le temps e e dacc`s est identique au temps de cycle. La complexit du point mmoire est denviron e e e 6 transistors MOS. En premi`re approximation, on peut dire que le temps dacc`s des e e SRAM dcro exponentiellement en fonction des annes, les temps dacc`s tant dautant e t e e e plus grand que la taille mmoire utilise est grande. e e Cette information est importante. En eet, le temps de cycle des processeurs dcro e t exponentiellement en fonction des annes. Il est donc possible, en jouant sur la taille e des mmoires SRAM utilises, dadapter le temps dacc`s des mmoires SRAM au temps e e e e de cycle des processeurs. Ladaptation est encore plus facile si lon implante la mmoire e SRAM sur la mme puce que le processeur. e
Les RAM dynamiques

Leur point mmoire est constitu avec une capacit et un transistor, et a une complexit e e e e quivalente a 1,5 transistor MOS. A surface gale, leur capacit est quatre fois plus leve e ` e e e e quune SRAM. Il existe une tr`s grande varit de mmoires dynamiques, quon ne peut e ee e dcrire dans le cadre de ce cours. On trouvera une synth`se rcente dans [6]. e e e
14
La mmorisation est fonde sur un phnom`ne lectrique (conservation de charges dans e e e e e un condensateur). La premi`re consquence est que la lecture tant destructrice, il faut e e e rcrire la valeur que lon lit. Le temps de cycle dune mmoire dynamique est donc au ee e moins le double de son temps dacc`s. La seconde consquence est que la mmorisation e e e nest que transitoire, et il faut rafra chir priodiquement tous les points mmoire. Ce e e rafra chissement est fait automatiquement dans la plupart des bo tiers DRAM. La table. 2.1, dapr`s [2], montre lvolution des temps de cycle et de la capacit des DRAM en e e e fonction des annes. On constate une dcroissance quasi-linaire en fonction des annes, au e e e e lieu dune dcroissance exponentielle pour les SRAM. Dautre part, la capacit quadruple e e tous les trois ans (le taux annuel correspondant est 60%, mais les gnrations successives e e de DRAM stagent en fait par tranches de trois ans). Cest exactement le taux de la loi e de Moore. En rsum, ` une priode donne, les bo e e a e e tiers mmoire DRAM disponibles contiennent e 4 fois plus de bits que les mmoires SRAM de technologie quivalente et sont moins chers, e e mais beaucoup plus lents.
La hirarchie mmoire e e
1000
performance
100
10
1 80 85 90 95 99 anne
Figure 2.6: Lcart de performances entre processeur et DRAM e Les caractristiques (quantit dinformation stocke, temps dacc`s et de cycle, co t par e e e e u bit) des direntes mmoires conduisent ` lutilisation dune hirarchie de mmoires, allant e e a e e de mmoires petites et rapides vers des mmoires plus grosses et plus lentes. Deux niveaux e e sont importants : la mmoire cache (SRAM) ` ct de la mmoire principale (DRAM), e a oe e
2.4. La mmoire e
Vitesse Cot
15
Mmoire principale DRAM
Cache L2
Cache L1
Capacit
Figure 2.7: Hirarchie caches - mmoire principale e e temps dacc`s e 6,7 ns (2Tc ) 20 ns (6Tc ) 26 ns (8Tc ) 253 ns (76Tc ) 60 ns (18Tc ) Dbit e 4800 MO/s 4800 MO/s 960 MO/s 1200 MO/s 30 - 100 M0/s
L1 8 KO, intgr e e L2 96 KO, intgr e e L3 4 MO, externe Mmoire principale e Composant DRAM
Table 2.2: Performances de la hirarchie mmoire de lAlphaServer 8200 ; le processeur e e est un Alpha 21164 a 300 MHz. ` et la mmoire virtuelle, constitu de la mmoire principale (DRAM) a ct de la mmoire e e e ` oe e secondaire (disque). Lvolution des performances des processeurs et des DRAM diverge, car lune est exe ponentielle et lautre linaire (g. 2.6, dapr`s [5]). Mais la ralisation de la mmoire e e e e principale dun ordinateur uniquement a partir de SRAM est exclue, pour des raisons ` conomiques : le cot des mmoires constituant lessentiel du cot des ordinateurs, lutilisation e u e u de mmoires statiques ` la place des mmoires dynamiques se traduirait par un facteur e a e multiplicatif de lordre de 3 ou 4 du prix des machines. Les architectures actuelles rsolvent cette divergence par lintroduction de caches. Les e caches sont des RAM statiques, qui contiennent un extrait, quon esp`re utile, du contenu e de la mmoire principale, ralise en DRAM (g. 2.7). Idalement, les caches permettront e e e e de soutenir le dbit mmoire, en instruction et donnes, gal ` celui du processeur. Le e e e e a cache de premier niveau est en gnral intgr avec le CPU dans le circuit processeur e e e e ; le cache de second niveau peut tre dans le mme circuit (Alpha 21164), ou bien un e e autre circuit, qui peut tre dans le mme bo e e tier que le processeur (Pentium Pro), mais est le plus souvent ` lextrieur. Le passage ` lextrieur du circuit a pour consquence a e a e e que le temps dacc`s ` la mmoire principale peut tre encore plus grand que le temps e a e e
16
100 Intel 10 Motorola Sparc DEC Alpha 1 MIPS
0,1 89 90 91 92 93 94 95 96 97 98
Figure 2.8: Evolution des performances des ordinateurs sur les benchmark SPEC. La ligne continue est une droite de pente 1,5. dacc`s au circuit DRAM correspondant. En revanche, une connexion large entre DRAMs e et processeur permet dquilibrer mieux les dbits. La table 2.2 donne les performances e e dune hirachie mmoire agressive. e e
2.5
Performances
Lvolution exponentielle des performances e

La performances des ordinateurs dpend de lensembles des composantes matrielles (CPU, e e mmoires, entres-sorties) et logicielles (programme, syst`me). La performance des come e e posantes matrielles est elle-mme le rsultat de lvolution exponentielle de la technologie e e e e (loi de Moore) et de larchitecture des processeurs et des ordinateurs. Le rsultat net est e actuellement une croissance exponentielle des performances (g. 2.8) : la performance est multiplie dun facteur environ 1,5 par an (augmentation de 50%). e
Mesure de performances
La dnition et la mesure des performances dun ordinateur sont un probl`me dicile. e e Tout dabord, les performances dun ordinateur dpendent de lutilisation vise. la mesure e e
2.5. Performances
17
la plus courante est le temps dexcution, mais le dbit peut tre plus important, par e e e exemple pour une machine qui joue un rle de serveur. o Ensuite, le temps dexcution dune tche, de son dbut a sa n, comprend le temps e a e ` dexcution du programme par le CPU, mais aussi les acc`s mmoire, les acc`s disque, les e e e e activits dentre-sortie et le temps utilis pour les besoins du syst`me dexploitation. Il e e e e dpend donc des performances de lensemble des composantes matrielles et logicielles du e e syst`me. e Les units de mesure les plus simples sont les MIPS (million dinstructions par seconde) e ou le MegaFLOP (million dinstructions ottantes par seconde). Ces deux performance a souvent t calcule de faon parfaitement trompeuse, comme le nombre dinstructions ee e c (ou dinstructions ottantes) que larchitecture permet dexcuter en 1 cycle divise par e e le temps de cycle. Ce chire reprsente alors seulement la puissance crte, cest ` dire ce e e a que larchitecture ne peut en aucun cas dpasser. La premi`re unit ne permet de toutes e e e faons pas de comparer entre elles les performances de faon absolue, car elle dpend c c e de la quantit de travail queectue chaque instruction. Les MFlops mesurs sur une e e application sont plus signicatifs, car ils mesurent de faon normalise la quantit de travail c e e utile que doit eectuer un algorithme numrique : additions et multiplications ottantes e comptent pour 1 opration ottante, et toutes les autres oprations sont normalises (par e e e exemple, une racine carre est compte pour un certain nombre dadditions ottantes). e e Pour comparer entre eux divers CPU ou divers ordinateurs, il est gnralement admis e e que la seule mani`re correcte est la mesure du temps dexcution sur des programmes e e rels pour des entres dtermines. La dnition de programmes tests reprsentatifs e e e e e e des applications, donc prdictifs des performances sur des applications relles, Les proe e grammes spciques dvaluation de performance ou benchmark, nest pas un probl`me e e e compl`tement rsolu actuellement. De tels programmes, appels benchmarks, sont spcis e e e e e par des consortiums industriels ou des organisations scientiques. Certains, comme la suite des programmes SPEC, sont utiliss par les constructeurs pour valuer la puissance e e de calcul brute des processeurs, sur du calcul entier (SPECint) ou ottant (SPECfp). Les mesures exprimes en SPEC nont de valeur que si les conditions dexprimentation e e (frquence dhorloge, hirarchie mmoire utilise, etc.) sont prcises. Dautres types e e e e e e de benchmarks sont plus orients vers des applications utilisateurs. Cest le cas par exe emple des programmes dvaluation comme TP-1 qui mesurent le nombre de transace tions par seconde (TPS) caractristique de syst`mes transactionnels. Dans ce cas, cest e e lensemble des performances, incluant notamment le dbit dacc`s aux disques et le syst`me e e e dexploitation, qui est value sur une classe dapplication caractristique. e e e
CPI et IPC
Pour mesurer et comparer les performances darchitectures, il faut donc dabord travailler a ` programme utilisateur constant. Les performances dune architecture, pour un programme donn, sont caractrises par le temps coul sur lexcution du programme utilisateur e e e e e e
18
(hors temps syst`me), selon la formule suivante : e Tempsexe = NI CPI Tc o` NI est le nombre dinstructions du programme, CPI est le nombre moyen de cyu cles dhorloge pour excuter une instruction, et T c est le temps de cycle. NI est fonce tion des instructions machine utilisables par compilateur, donc dcrit la fonctionnalit e e de larchitecture logicielle. En premi`re approximation, Tc est fonction de la technoloe gie utilise qui dtermine le temps dexcution des tapes lmentaires, par exemple la e e e e ee traverse de lUAL, et dcrit donc les contraintes technologiques. e e On dnit galement le nombre dinstructions par cycle, IPC : IPC = 1/CPI. Le produit e e CPITc est reli au MIPS par la relation : e Nombre de MIPS = NI 106 = F IPC Tempsexe
si la frquence F est exprime en MHz. e e CPI traduit les performances des architectures matrielles. Il permet dabord de come parer des architectures matrielles qui implmentent la mme architecture logicielle, en e e e liminant linuence de la technologie (Tc ) : typiquement, le CPI a doubl entre le pentium e e Pro et le PII. CPI permet galement de comparer les performances relles avec les performances e e crtes. Par exemple, ltude [5] montre quun syst`me processeur-mmoire ` base de e e e e a 21164 (lAlphaServer 8200) atteint seulement une performance de 3,0 a 3,6 CPI, alors que ` le 21164 est capable dexcuter 4 instructions par cycle, donc un CPI de 0,25. La valeur e du CPI moyen mesur sur des programmes rels, compar au CPI minimum ou CPI optie e e mal (CPIopt), va traduire la dirence entre les performances relles et les performances e e maximales de la machine. La valeur du CPI moyen mesur sur des programmes rels, e e compar au CPI minimum ou CPI optimal (CPIopt), va traduire la dirence entre les e e performances relles et les performances maximales de la machine, suivant la relation : e CPI = CPIopt (1 + a + c + v + s) CPIopt correspond au fonctionnement idal du squencement des instructions quon tudiera e e e aux chapitres 4 et 5 ; le terme a est li ` des alas de fonctionnement ` lintrieur de e a e a e lexcution des instructions quon tudiera au chapitre 5 ; c et v sont des facteurs core e rectifs qui tiennent compte des limitations lies ` lexistence de la hirarchie mmoire e a e e constitue de caches, dune mmoire principale et de mmoires secondaires (chapitres 6 et e e e 7) ; s traduit limpact du syst`me dexploitation, notamment pour les oprations dentrese e e sorties (chapitre 8). CPI permet enn de comparer des architectures de processeur, donc indpendamment e du syst`me mmoire : on compare alors plus prcisment CPIopt , ou CPIopt (1 + a). e e e e Llment dcisif qui a conduit au succ`s des architectures RISC est une valeur du CPI ee e e moyen bien meilleure a celle des architectures CISC. Elle est infrieure ` 1,5 pour les ` e a
2.5. Performances
19
premiers RISC commerciaux (SPARC de la socit Sun, ou R2000 et R3000 de la socit ee ee MIPS), alors quune architecture CISC comme celle du VAX-11 de Digital avait un CPI moyen de lordre de 6 a 8. CPIopt est de lordre de 1/4 a 1/8 actuellement. ` `
20
Chapitre 3
Reprsentation de linformation e
Les types dinformations traites directement par un processeur ne sont pas tr`s nombreux. e e Les donnes : e les entiers, avec deux sous-types, entiers naturels et relatifs ; les ottants, qui dcrivent les rels, avec galement deux sous-types, simple et e e e double prcision. e les caract`res, qui sont plutt traits au niveau du logiciel de base. e o e Le codage de ces trois types est actuellement dnie formellement par des standards, e cest ` dire des normes contraignantes spcies par des organisations internationales. a e e Les instructions, dont le codage est spcique dun processeur. e Toute cette section traite de linformation par rapport aux mcanisme dun ordinateur, e et na donc pas de rapport avec la thorie de linformation utilise dans la thorie du e e e codage.
3.1
Linformation
Dans un ordinateur, linformation est numrise (digitale) : e e Dnition 3 Linformation est la connaissance dun tat parmi un nombre ni dtats e e e possibles. Une information non numrise est une information analogique : une grandeur physique e e continue, par exemple tension ou courant. 21
22
Chapitre 3. Reprsentation de linformation e
Etat France GB Allemagne Espagne Italie Portugal Gr`ce e Irlande
b2 0 0 0 0 1 1 0 1
b1 0 0 1 1 0 0 1 1
b0 0 1 0 1 0 1 0 1
Table 3.1: Reprsentation de huit Etats e
Quantit dinformation e
Lunit de mesure de linformation est le bit. e Dnition 4 1 bit est quantit dinformation lie ` la connaissance dun tat parmi deux. e e e a e 1 bit dinformation peut tre reprsent commodment par un digit binaire, prenant e e e e les valeurs 0 ou 1. Avec n bits, on peut reprsenter 2n congurations. La table 3.1 montre comment on e peut reprsenter 8 tats avec 3 bits. e e Proposition 1 La quantit dinformation contenue dans la connaissance dun tat parmi e e N est log2 (N ) bits. I = log2 (N ) Pour avoir une ide intuitive des grandeurs mises en jeu, il sut de remarquer que e e 210 = 1024, encore not 1K. 220 est donc de lordre du million : 220 (102 )3 = 106 . La caractristique la plus fondamentale, mais aussi la plus lmentaire dun ordinateur e ee est la taille de linformation quil est capables de manipuler. Le nombre dtats distincts e reprsents dans un ordinateur moderne est grand. En 74, le premier microprocesseur, e e le 8080 dIntel, tait un ordinateur 8 bits, correspondant a 256 tats. En 99, tous les e ` e processeurs existants sont 32 bits ou 64 bits. 32 bits correspondent a 232 = 22 230 , soit ` 4 milliards. Bien que ce nombre soit grand, il nest pas inni. Une partie des applications informatiques travaille sur des ensembles nis : un diteur de texte traite les caract`res, un e e programme de gestion dcran des pixels. A linverse, les applications numriques travaile e lent sur des ensembles non borns : entiers naturels ou relatifs, rationnels, rels. e e Les calculs dordinateurs sont donc par construction susceptibles derreur. On verra plus loin comment contrler ces erreurs, mais les supprimer est impossible. o
3.1. Linformation
23
V Etat haut Etat bas Seuil Haut Seuil Bas
t1
t3
t2
temps
Figure 3.1: Information : tat et temps. e
Support de linformation
Bien que linformation soit numrise, son support est physique, donc analogique : type e iquement, dans la technologie actuelle des CI, la tension. La connaissance dun tat dpend e e donc de deux seuils, haut et bas. La gure 3.1 illustre cette notion avec un signal lectrique. Elle montre quil y a deux e tats signicatifs, ltat bas lorsque la tension est infrieure ` une rfrence basse, et un e e e a ee tat haut lorsque la tension est suprieure ` une rfrence haute. Le troisi`me tat, situ e e a ee e e e entre les rfrences basse et haute, ne peut tre utilis comme support dinformation. ee e e Donc, pour quil y ait information, il faut prciser linstant auquel on regarde ltat du e e signal. : par exemple, en t1 le signal est haut et en t2 , le signal est bas. En revanche, a ` linstant t3 , le signal ne fournit aucune information et ne doit donc pas tre chantillon. e e e
Notations
Mots binaires Dnition 5 Un mot de n bits est une suite (ai ), 0 i n 1 ; a0 est le bit de poids e faible, an est le bit de poids fort.
La notation hexadcimale e La notation hexadcimale est une mani`re simplie dcrire des mots binaires. Un mot e e e e binaire de n bits peut tre crit ` laide de n/4 digits hexadcimaux, en remplaant e e a e c chaque groupe de 4 digits binaires par le digit hexadcimal correspondant (table 3.2). e Actuellement, lusage de la notation hexdcimale ne correspond ` aucun support matriel e a e : il nexiste pas dadditionneur travaillant sur des digits hexadcimaux. En revanche, il e est plus agrable decrire dans un programme C 0x1234 que son quivalent binaire. e e
24
Chire Hexa Code binaire Chire Hexa Code binaire
0 0000 8 1000
1 0001 9 1001
2 0010 A 1010
3 0011 B 1011
4 0100 C 1100
5 0101 D 1101
6 0110 E 1110
7 0111 F 1111
Table 3.2: Correspondance entre chires hexadcimaux et quartets binaires e
3.2
Reprsentation des caract`res e e
De nombreux standards existent. Le plus simple est le code ASCII (American Standard Code for Information Interchange) [7]. Il permet de reprsenter sur un octet des donnes e e alphanumriques, dont les caract`res latins et les chires dcimaux, et quelques autres e e e informationscomme le retour chariot. Par exemple, la lettre A est code par 41H et le e chire 9 par 39H La reprsentation utilise en fait 7 bits, plus un bit de parit. Ce code e e a t tabli par lANSI. Il a volu vers le standard ISO 8859-1 (Latin-1), qui utilise les eee e e 8 bits pour reprsenter entre autres les caract`res accentus : par exemple, le code CAH e e e reprsente E. e Dautres standards existent, en particulier Unicode [8]. Il utilise deux octets pour encoder aussi des jeux de caract`res non latins, cyrilliques, hbreu, asiatiques. Unicode a e e t tabli par le Unicode consortium. Un encodage proche dUnicode, lUCS (Universal eee Character Set), est lobjet de la norme ISO 10646.
3.3
Reprsentation des entiers e
La plupart des langages de programmation permettent de distinguer le type entier naturel du type entier relatif. Par exemple, C propose unsigned int et int. Pourquoi cette distinction ? Certains objets sont intrins`quement des entiers non signs : une adresse mmoire e e e ou un age ne peuvent prendre des valeurs ngatives. e La capacit de reprsentation est limite, comme on la vu ci-dessus. Sur un budget e e e de 4 bits, par exemple, on peut reprsenter soit 16 entiers naturels, soit 16 entiers relatifs, e donc 8 positifs et 8 ngatifs si on souhaite une repsentation raisonnablement quilibre. e e e e Le codage des naturels et des relatifs est donc dirent. e
3.3. Reprsentation des entiers e Code Entier Code Entier 0000 0 1000 8 0001 1 1001 9 0010 2 1010 10 0011 3 1011 11 0100 4 1100 12 0101 5 1101 13 0110 6 1110 14 0111 7 1111 15
25
Table 3.3: Reprsentation des entiers [0 15] sur un quartet e
Entiers naturels
Reprsentation e Un syst`me de reprsentation des nombres fond sur la numration de position utilise e e e e une base b, par exemple 10 ou 2, et b symboles qui reprsentent les nombres entre 0 et e b 1 : en base 2, on na donc que deux symboles, 0 et 1. Dnition 6 La reprsentation en base 2 est fonde sur lgalit suivante : e e e e e
n1
an1 an2 . . . a0 =
i=0
ai 2i
Par exemple, la table 3.3 donne la reprsentation des entiers naturels de 0 ` 15 sur 4 bits. e a Proposition 2 Sur n bits, on peut reprsenter les entiers naturels N tels que 0 N < e 2n 1. En eet, le plus grand nombre reprsentable est e
n1
2i = 2n 1.
i=0
Avec un octet, on peut donc reprsenter tous les entiers naturels entre 0 et 255. Un e mot de 32 bits permet de reprsenter tous les entiers naturels entre 0 et 4 294 967 295 e Ladditionneur Ladditionneur dune UAL est capable deectuer lopration daddition de deux entiers e naturels. Il faut souligner ici que ladditionneur est loprateur fondamental de lUAL : e toutes les autres oprations, soustraction de naturels, addition et soustraction de nombres e relatifs devront tre conues pour exploiter ecacement ladditionneur naturel. On note e c A B linterprtation en entier naturel du rsultat de laddition UAL. e e Laddition UAL fournit galement une retenue, qui ne fait pas partie du rsultat, mais e e est conserve. Dans la suite, on note C la retenue. On a donc : e
26
Proposition 3 Si A et B sont des entiers naturels, A+B =A B + C2n .
Si laddition de deux naturels produit une retenue, le rsultat est faux : le rsultat est e e trop grand pour tre reprsent. Par exemple, sur 4 bits, laddition UAL de 0111 et 1100 e e e donne 0011, avec retenue 1. En eet, 7 + 12 = 19, qui ne peut tre reprsent sur 4 bits. e e e
Entiers relatifs
Une reprsentation raisonnable des entiers relatifs doit tre symtrique, en permettant e e e de reprsenter autant dentiers positifs que ngatifs. Ceci pose un probl`me li au zro. e e e e e En eet, il y a un nombre pair de congurations associes ` n bits, a rpartir entre e a ` e nombres positifs, nombres ngatifs et la valeur 0. La reprsentation ne peut donc pas tre e e e compl`tement symtrique. e e La reprsentation universelle actuelle est la reprsentation en complment ` 2. e e e a Complment ` 2 e a
000 111 110 -2 3 -1 0 1 001 2 010 011
=0 =0 =0
101 -3
-4 100
Figure 3.2: Reprsentation des entiers relatifs sur 3 bits e Un exemple du codage en complment ` 2 sur 3 bits est dcrit g. 3.2. On pourra srement e a e u dcrire 0, 1, 2 et 3 et -1, -2, -3. Pour utiliser ecacement ladditionneur, la reprsentation e e des ces nombres en tant quentiers positifs doit tre identique a leur reprsentation en e ` e tant quentiers naturels. Pour la mme raison, il faut dnir la reprsentation des ngatifs e e e e de telle sorte que laddition UAL de N et N ait pour rsultat 0. Il ny a quune soe lution possible. En fait laddition UAL donne 0 avec retenue, cest a dire que laddition ` 3 mathmatique donne 8 = 2 e On remarque que le bit de poids fort des positifs est a 0, et celui des ngatifs ` 1. Cette ` e a caractrisation peut tre exploite facilement en matriel pour tester le signe dun nombre e e e e entier relatif. Il reste une conguration non attribue : 100. Elle peut tre attribue, soit e e e a ` 4, soit a -4. Pour rester cohrent avec la caractrisation du signe par le bit de poids ` e e fort,elle est associe ` -4. e a
3.3. Reprsentation des entiers e
27
non -2n reprsentable
-2n-1
2n-1
2n non reprsentable
Figure 3.3: Reprsentation des entiers relatifs sur n bits e Dnition 7 La reprsentation en complment ` 2 sur n bits est dnie par : e e e a e 1. les entiers reprsents sont [2n1 , 2n1 1]; e e 2. la reprsentation des entiers positifs est identique a celle des entiers naturels ; e ` 3. la reprsentation dun entier ngatif N est la reprsentation en naturel de 2n N e e e Cette dnition est illustre g. 3.3. Par exemple, la reprsentation sur 3 bits de 3est e e e la reprsentation du naturel 8 3 = 5 sur 3 bits, soit 101. La dnition est consistante : e e si N est ngatif et reprsentable, 2n1 N < 0, donc 2n1 2n N < 2n ; 2n N e e est donc un entier naturel et reprsentable sur n bits, puiquil est plus petit que 2n . e On a les proprits suivantes : ee Proposition 4 En complment ` 2 e a 1. Laddition UAL des reprsentations dun entier relatif N et de N est gale a 0. e e ` 2. Le bit de poids fort de la reprsentation des positifs est 0, le bit de poids fort de la e reprsentation des ngatifs est 1. e e 3. La reprsentation de -1 est le mot o` tous les bits sont a 1 e u ` La premi`re proprit vient du fait que laddition UAL des reprsentations de N et de e ee e N est celle (en supposant N 0) des naturels N et 2n N . Le rsultat est donc 0 avec e retenue 1. Soit N 0 un positif reprsentable. 0 < N < 2n1 , donc an1 = 0. Soit N un e ngatif reprsentable. 0 < N 2n1 , donc 2n N 2n1 , ce qui prouve la deuxi`me e e e proprit. 2 ee La dnition prcdente dcrit comment coder les nombres relatifs, ce qui est par e e e e exemple la tche dun compilateur. Lopration inverse, dinterprtation dune cha de a e e ne bit vers un nombre relatif, est dcrite par la proprit suivante : e ee Proposition 5 Si un entier relatif N est reprsent sur n bits par an1 an2 . . . a0 , alors e e
n2
N = an1 2
n1
+
i=0
ai 2i .
28
Soit M = an1 2n1 + n2 ai 2i . On va montrer que M a pour reprsentation an1 an2 . . . a0 . e i=0 Dabord, M est reprsentable : e
n2 n2
(1)2n1 +
i=0
0.2i M 0 +
i=0
2i ,
e e e donc 2n1 M 2n1 1. Si an1 = 0, M est reprsent par an1 an2 . . . a0 dapr`s la dnition 7.2. Si an1 = 1, M < 0, donc sa reprsentation est celle du naturel 2n + M . e e
n2 n2
2n + M = 2n 2n1 +
i=0
ai 2i = 2n1 +
i=0
ai 2i ,
qui se reprsente comme 1an2 . . . a0 .2 e Autres reprsentations e Plusieurs reprsentations des entiers relatifs ont t utilises dans le lointain pass de e ee e e linformatique, mais la seule reprsentation utilise actuellement pour les entiers relatifs est e e la reprsentation en complment ` 2. En revanche, dautres reprsentations sont utilises e e a e e indirectement, en particulier pour les exposants des ottants (cf 3.4). Dans toutes les reprsentations, les nombres positifs sont reprsents par leur criture en base 2, qui est e e e e compatible avec laddition UAL.
Oprations arithmtiques e e
On a vu que lUAL eectue laddition de deux entiers naturels. Le calcul de loppos dun e nombre relatif, laddition et la soustraction de nombres relatifs, doivent tre des oprations e e ralisables facilement avec ladditionneur de lUAL. e Oppos e Proposition 6 Si N est un entier dans [2n1 + 1, 2n1 1], la reprsentation de N e sobtient en complmentant bit ` bit la reprsentation de N et en ajoutant 1. Lopration e a e e de complmentation bit ` bit et ajout de 1 est appele la complmentation ` 2. e a e e a Par exemple, sur 4 bits, la reprsentation de 3 est 0011. La reprentation de -3 sobtient e s en calculant sur 4 bits 1100 1 = 1101. En recommenant lopration, on retrouve 0011. c e Supposons N > 0 (sinon, on inverse les rles de N et N ). Si N est not an1 an2 . . . a0 , o e alors
n1 i=0
N=
ai 2i .
Le nombre M obtenu par complmentation a 2 est e `

n1 n1
M =1
i=0
ai 2 = 1 +
i=0
ai 2i ,
3.3. Reprsentation des entiers e car lopration ne produit jamais de retenue pour N > 0. Donc e
n1
29
N +M =1+
i=0
(ai + ai ) = 2n ,
donc M est la reprsentation de N . e Extension de signe Proposition 7 Si N est un entier relatif reprsent sur n bits par an1 an2 . . . a0 , N est e e reprsent sur m (m > n) bits par an1 . . . an1 an2 . . . a0 . e e e Cette opration est appele extension de signe : le bit de poids fort an1 est recopi sur les e e m n bits manquants. Par exemple, 7 est reprsent par 0111 sur 4 bits, et par 00000111 e e sur un octet ; 2 est reprsent par 1110 sur 4 bits, et par 11111110 sur un octet. e e La proposition est vidente si N 0. Si N < 0, les deux nombres ont le mme e e complment ` 2. e a Addition et soustraction La premi`re question est de savoir si laddition UAL est compatible avec la reprsentation e e en complment ` 2, ie si e a codage(A) codage(B) = codage(A + B)
Ce nest pas toujours vrai : le nombre de congurations possibles tant limit, le e e rsultat peut tre erron. Par exemple, sur 4 bits, 7 est reprsent par 0111, 2 est reprsent e e e e e e e par 0010, et laddition donne 1001, qui reprsente 8 + 1 = 7 et non 9. De mme e e laddition UAL de 7 (1001) et 6 (1010) donne 0011, soit 3 et non 13. Le probl`me e est que le rsultat est trop grand en valeur absolue pour tre reprsent sur 4 bits. e e e e Le probl`me est donc de dterminer un algorithme simple, qui sera implment en e e e e matriel, pour dtecter lerreur. On a vu que, pour laddition des naturels, lindicateur est e e le bit de retenue. Pour laddition des relatifs, la proposition suivante fournit un crit`re de e correction. Proposition 8 Laddition UAL de deux relatifs N et M fournit toujours un rsultat e correct si N et M ne sont pas de mme signe. Si N et M sont de mme signe, le rsultat e e e est correct si le bit de signe est gal a la retenue. e ` Addition dans lUAL des relatifs N et M signie interprtation en relatif du rsultat de e e laddition UAL des codages de N et M . On veut donc vrier que e codage(N ) codage(M ) = codage(N + M ), (3.1)
30
si et seulement si la condition de la proposition est vraie. Pour pouvoir eectuer des calculs, on choisit une interprtation univoque des deux membres de cette galit, celle e e e des entiers naturels. Premier cas : N 0 et M < 0 Alors, 2n1 N + M < 2n1 , car 0 N < 2n1 et 2n1 M < 0 Donc, N + M est reprsentable. codage(N ) = N, codage(M ) = 2n + M . Donc, e codage(N ) codage(M ) = 2n + N + M C2n ,
o` C est la retenue (prop 3). u Il y a retenue si N + 2n + M 2n , donc si N + M 0 ; dans ce cas, codage(N + M ) = N + M car N + M 0 et reprsentable; codage(N ) codage(M ) = N + M car C = 1. e Il ny a pas retenue si N + 2n + M < 2n , donc si N + M < 0 ; dans ce cas, codage(N + e M ) = 2n +N +M car N +M < 0 et reprsentable; codage(N ) codage(M ) = N +M +2n car C = 1. Deuxi`me cas : N 0 et M 0 e e Alors, 0 N + M < 2n . Donc, N + M est reprsentable si 0 N + M < 2n1 et non reprsentable sinon. e codage(N ) = N, codage(M ) = M . Laddition UAL ne produit jamais de retenue : les bits de poids fort sont tous deux a 0 ; donc ` codage(N ) codage(M ) = N + M C2n = N + M,
puisque C = 0. Dautre part, codage(N + M ) = N + M si N + M est reprsentable, e puisque N + M 0. Donc, lgalit (3.1) est vraie si et seulement si N + M < 2n1 , donc e e si le bit poids fort est 0, comme la retenue. Troisi`me cas : N < 0 et M < 0 e e Alors, 2n N + M < 0. Donc, N + M est reprsentable si 2n1 N + M < 0 et non reprsentable sinon. e codage(N ) = 2n + N, codage(M ) = 2n + M . Laddition UAL produit toujours une retenue : les bits de poids fort sont tous deux a 1 ; donc ` codage(N ) codage(M ) = 2n + N + 2n + M C2n = 2n + N + M,
puisque C = 1. Dautre part, codage(N + M ) = 2n + N + M si N + M est reprsentable, e puisque N + M < 0. Donc, lgalit (3.1) est vraie si et seulement si N + M > 2n1 , e e donc si 2n + N = M > 2n1 , donc si le bit de poids fort est a 1, comme la retenue. 2 ` Dcalages e Un oprateur de lUAL indpendant de ladditionneur eectue les dcalages logiques, e e e sll(shift logical left) et slr(shift logical right) et le dcalage arithmtique, sar(shift arithe e metic right).
3.3. Reprsentation des entiers e

a3 b3 a2 b2 a1 b1 a0 b0
31
Additionneur 1 bit
Additionneur 1 bit
Additionneur 1 bit
Additionneur 1 bit
O s3
N s2
Z s1 s0
Figure 3.4: Gnration des code-conditions e e Dnition 8 e sll(an1 an2 . . . a0 ) = an2 . . . a0 slr(an1 an2 . . . a0 ) = 0an1 . . . a1 sar(an1 an2 . . . a0 ) = an1 an1 . . . a1 Le dcalage arithmtique droit tend le bit de poids fort, le dcalage logique droit remplit e e e e le bit manquant par un 0. Proposition 9 Linterprtation arithmtique des dcalages est donn par les proprits e e e e ee suivantes: 1. Si un entier naturel N est reprsent par an1 an2 . . . a0 , sll(an1 an2 . . . a0 ) = 2N e e et slr(an1 an2 . . . a0 ) = N/2, le quotient tant le quotient entier. e 2. Si un entier relatif N est reprsent par an1 an2 . . . a0 , sll(an1 an2 . . . a0 ) = 2N e e e et sar(an1 an2 . . . a0 ) = N/2, le quotient tant le quotient entier. Par exemple, sur 4 bits, 7 est reprsent par 0111 ; sll(0111) = 1110, qui reprsente 14 e e e ; slr(0111) = 0011, qui reprsente 3. 3 est reprsent par 1101 ; sll(1101) = 1010, qui e e e reprsente 6 ; sar(1101) = 1110, qui reprsente 2 (rappel : le quotient entier de a par e e b est le plus grand entier infrieur ou gal au rel a/b, donc (3)/2 = 2, et non 1. e e e
32
Traitement des erreurs

Une opration UAL gn`re, outre le rsultat sur n bits, plusieurs informations que le code e e e e peut vouloir tester par la suite (g. 3.4). Ces informations sont : C : retenue (carry) P : parit, rsultat pair ou impair e e Z : rsultat 0 e N : rsultat ngatif e e 0 : dpassement de capacit (overow) e e C correspond a un dpassement de capacit quand lopration est interprte dans le ` e e e ee champ des entiers naturels. 0 correspond a un dpassement de capacit quand lopration ` e e e est interprte dans le champ des entiers relatifs. ee Ces informations sont appeles Code-conditions, ou drapeaux (ags). Elles sont soue vent conserves dans un registre dtat du processeur, le registre code-conditions RCC, et e e accessibles par des instructions conditionnelles, par exemple BE = brancher si drapeau Z positionn. Dautres architectures (MIPS, Alpha, IA64) conservent ce rsultat dans un e e registre adressable. Ce probl`me sera tudi plus en dtail au chapitre suivant. e e e e Que se passe-t-il lors dun dpassement de capacit ? Pour beaucoup darchitectures e e (x86, SPARC) , rien dautre que le positionnement du code-condition associ. Dautres e (MIPS) peuvent dclencher une exception (trap), qui dclenche elle-mme lexcution dun e e e e gestionnaire dexception (trap handler) cest a dire lexcution dune routine associe ` ` e e a lv`nement. Le processeur fournit un support matriel en lanant lexcution de la routine e e e c e sans intervention de lapplication. Le logiciel de base fournit le contenu de la routine. Dans ce cas prcis, la routine va en gnral signaler lerreur et arrter lexcution du programme. e e e e e Le comportement de ces architecture est donc tr`s dirent, par exemple sur le calcul de e e 100! : les premi`res fournissent un rsultat faux, 100! modulo 2n ; les secondes signalent e e lerreur. Certains langages, comme ADA, requi`rent la dtection de toutes les erreurs e e arithmtiques. Sur les architectures qui ne dclenchent pas dexception, le compilateur doit e e insrer un code de test de dbordement apr`s chaque opration arithmtique susceptible e e e e e den produire. Lexemple le plus cl`bre derreur arithmtique catastrophique est la perte de la fuse ee e e Ariane 5 apr`s quarante secondes de vol en 96 [9]. La dfaillance tait due a un comportee e e ` ment aberrant du syst`me de guidage de la fuse. Ce syst`me tait forme dun syst`me e e e e e de rfrence inertiel (SRI) aliment par des capteurs et fournissant des informations a ee e ` un calculateur embarqu (ORB, on board computer) qui commandait les mouvements de e rotation de la fuse. Lensemble SRI plus ORB tait rpliqu en deux exemplaires pour e e e e assurer la redondance. A environ 37 secondes, les SRI1 et SRI2 ont envoy un message e derreur aux OBC1 et 2 ; larrive dun tel message ntait pas prvue dans le code excut e e e e e par les OBC, qui lont interprt comme des coordonnes. La fuse a tangu brutalement, ee e e e puis a commenc ` se briser. Le dispositif dautodestruction, destin ` viter que la fuse ea eae e retombe dangereusement sur la terre, a dtect la rupture fuse-boosters, et dtruit la e e e e fuse en vol. e Le message derreur est intervenu lorsque les syst`mes de rfnces inertiels eectuaient e ee
3.4. Nombres rels e Chire dcimal e 0 1 2 3 4 5 6 7 8 9 code 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001
33
Table 3.4: Dcimal cod binaire e e la conversion dun ottant x vers un entier 16 bits, avec arrondi videmment (par exemple e 10,3 10). La valeur de x tait trop grande pour tenir sur un entier 16 bits, et le code e ADA a signal le dpassement de capacit. . . . Or, ce fragment de code de conversion, e e e hrit dAriane 4, tait inutile pour Ariane 5 ; dans Ariane 4, la valeur de lentier tait e e e e reprsentable sur 16 bits. Cette erreur lmentaire a cot plus de 4 milliards de francs. . . e ee ue
Reprsentation BCD e
Certaines applications, notamment en gestion, exigent des calculs dcimaux exacts, e sans arrondi, ce qui implique de travailler avec des nombres dcimaux. En eet, avec un e nombre x de bits, il est impossible de convertir de mani`re exacte des nombres binaires e e en nombres dcimaux et rciproquement. On utilise alors la reprsentation dcimale code e e e e e binaire (binary coded decimal, BCD), dans laquelle chaque chire dcimal (0 - 9) est cod e e avec 4 chires binaires, en codage naturel 3.4. On distingue le BCD non compact, avec e 1 octet par chire, et le BCD compact, avec 1 octet pour 2 chires. e Le BCD nest pas compatible avec laddition UAL : codageBCD (1) car 0001 1010 = 0011, mais codageBCD (6) , qui nest pas un code BCD. codageBCD (8) = 1110 codageBCD (2) = codageBCD (3)
3.4
Nombres rels e
La reprsentation et le traitement des nombres rels sont appels reprsentation et traitee e e e ment ottants. Lexplication est que la virgule na pas une position xe, comme on le
34 verra par la suite.
Reprsentation des rels e e

Mantisse et exposant La reprsentation ottante est base sur la reprsentation dun nombre sous forme mantisse e e e et exposant : x = m B e Par exemple, en notation dcimale, 2, 76 peut scrire 2, 76 100 , et aussi 276 102 . e e Dans la suite, certains exemples seront prsents en dcimal (m, e en base 10, B = 10) e e e pour allger les notations. En machine, tout est en base 2. e Un nombre dcimal a une innit de reprsentations mantisse-exposant, par exemple e e e 2, 76 = 0, 276 101 = 27, 6 101 etc. La reprsentation normalise se dnit par lexistence dun seul chire, qui ne doit pas tre e e e e 0, avant la virgule. Dans lexemple prcdent, cette reprsentation est donc 2, 76 100 . e e e En base 2, le chire avant la virgule est ncssairement 1. Il nest donc pas utile de e e gaspiller un bit pour lindiquer. La mantisse comportera donc souvent un 1 implicite. Dicults de la reprsentation des rels e e e La reprsentation des nombres rels pose un probl`me plus dicile que celle des nombres e e e entiers : les nombres rels sont continus. Lordinateur ne travaillant que sur un nombre e limit de digits, il doit arrondir les reprsentations. Il ne peut pas non plus reprsenter e e e des rels abitrairement grands ou petits en valeur absolue. e Tous les nombres rationnels ne peuvent pas scrire sous forme mantisse-exposant. Par e exemple en base 10 et en base 2, 1/3. Les nombres rationnels qui scrivent sous cette forme e en base 10 sont les nombres dcimaux, mais le terme quivalent en base 2, deuxcimaux, e e nest gu`re usit. Les nombres reprsentables en machine sont donc un sous-ensemble des e e e nombres deucimaux. La reprsentation des rels, les crit`res de prcision (arrondi) requis des processeurs, et e e e e le traitement des dpassements de capacit (nombres trop grands ou trop petits) ont t e e ee un sujet de longues polmique parmi les constructeurs de machines et les utilisateurs du e calcul scientique : le standard actuel, la norme IEEE 754, fut mis en chantier en 1977, mais son adoption dnitive date de 1985. e La norme IEEE 754 comporte deux aspects : la dnition dune reprsentation come e mune des rels, et des contraintes sur la prcision des calculs. e e On mesure mieux la dicult du probl`me si lon sait que Von Neumann tait oppos e e e e a ` lide mme de larithmtique ottante en matriel. Cette opposition tait fonde sur la e e e e e e complexit du matriel requis, et sur lencombrement mmoire supplmentaire. e e e e
3.4. Nombres rels e Simple prcision e 8 23 E (exposant) f (mantisse) Double prcision e 11 52 E (exposant) f (mantisse)
35
1 s 1 s
Table 3.5: Formats IEEE 754 simple et double prcision. e
Reprsentation IEEE 754 e

Il existe quatre formats : simple et double prcision, et simple et double prcision e e tendue. Nous ne prsentons que simple et double prcision. La g. 3.5 prsente les e e e e formats correspondants. En simple prcision e est linterprtation de E en exc`s ` 128 : e e e a e = interprtation de E en naturel - 127. e Donc, en simple prcision, emin = 0 127 = 127, emax = 255 127 = 128. e En double prcision, e est linterprtation de E en exc`s ` 1023 : emin = 1023, emax = e e e a 1024 Cas normalis e Pour emin < e < emax , le codage sinterpr`te de la faon suivante : e c le bit de plus fort poids donne le signe du nombre ; la mantisse utilise un 1 implicite ; donc, pour une partie fractionnaire f1 f2 . . . fn , la mantisse m est dnie par : e
n
m = 1, f1 f2 . . . fn = 1 +
i=1
fi 2i = 1f1 f2 . . . fn 2n ;
au total, le nombre svalue par : e x = (1)s 1, f1 f2 . . . fn 2e . Par exemple, C8900000 code 218 (1 + 23 ). En eet, on a : bit de signe 1 E = 10010001 = 145, donc e = 17 2 f = 0010. . . 0, donc m = 1, 001 = 1 + 23
36
1/4 0 1/2
1 2 4 8
Figure 3.5: Echelle de reprsentation des ottants e Nom Normalis e Dnormalis e e Zro e Inni NaN e emin < e < emax e = emin e = emin e = emax e = emax f quelconque =0 0 0 =0 valeur 1, f 2e s 0, f 2emin (1) (1)s 0 (1)s NaN (1)s
Table 3.6: Interprtation des champs dans le format IEEE 754 e La reprsentation normalise permet de reprsenter les nombres de faon quilibre. e e e c e e Considrons un exemple plus simple, avec 2 bits de mantisse et 3 bits dexposant (ce e qui nest pas un choix raisonnable !). Lexposant est donc interprt en exc`s ` 3, et ee e a 2 e 3. La gure 3.5 dcrit les nombres positifs reprsents. Entre ces nombres, on e e e a les rels non deucimaux de lintervalle, qui devront tre approxims. Les barres paisses e e e e correspondent aux cas o` m = 1, donc x = 22 , 21 , 20 , 21 , 22 , 23 . On voit que dans chaque u intervalle, lespacement est double de celui du prcdent. La dirence entre deux nombres e e e reprsents conscutifs nest pas constante, mais lerreur relative cre par un arrondi est e e e ee constante. Cas exceptionnels La table 3.6 montre que les valeurs extrmes sont rserves pour une reprsentation e e e e synthtique des nombres non reprsentables en normalis. e e e Il existe un plus grand nombre exactement reprsentable en normalis : e e xm = 1, 1 . . . 1 2emax 1 . Les nombres plus grands sont reprsents par les mots o` le signe est positif, e = emax e e u et f = 0. Linterprtation de tous ces mots est identique : +. Pour les nombres ngatifs, e e on a une reprsentation analogue de . e Il existe un plus petit nombre strictement positif reprsentable en normalis. Cepene e dant, la reprsentation dnormalise permet de reprsenter des nombres plus petits. On e e e e
3.4. Nombres rels e
37
notera que le bit implicite nest plus 1, mais 0, do` lappellation dnormalis. u e e Il existe deux reprsentations de 0, suivant le bit de signe. e Enn, un code est rserv pour reprsenter le rsultat dune opration aberrante, par e e e e e exemple 0/0. Ce code est not NaN. e Lobjectif de cette reprsentation est dcrit en 3.4. e e
Oprations ottantes e
Les oprations ottantes impliquent un traitement simultan des mantisses (cest ` dire e e a des parties fractionnaires) et des exposants. Les principales oprations sont les come paraisons et les oprations arithmtiques : addition, soustraction, multiplication, division. e e Dans tous les microprocesseurs gnralistes actuels, les oprations daddition, soustraction, e e e multiplication et division sont raliss par des oprateurs matriels spciques, intgrs e e e e e e e dans le CPU. On trouvera une prsentation de ces oprateurs dans [2, 10]. Lensemble de e e ces oprateurs est applele Floating Point Unit (FPU). En revanche, les oprations plus e e e complexes, racine carre, fonctions trigonomtriques, sont raliss par logiciel. e e e e Le standard IEEE 754 dcrit dans cette section ne prescrit rien sur limplmentation. Il e e spcie simplement les bits dune reprsentation, et du rsultat des opration arithmtiques e e e e e ottante. Ainsi, le langage Java ore un calcul ottant conforme IEEE 754 indpendamment e de toute plate-forme matrielle. e Comparaisons Lutilisation du bit de signe permet le test rapide du signe. La notation en exc`s pour e lexposant permet de comparer les ottants en utilisant la comparaison de entiers naturels. Addition et soustraction Laddition implique une dnormalisation du nombre le plus petit pour que les exposants e deviennent gaux, suivie dune addition des mantisses, qui est suivie ventuellement dune e e renormalisation. La dnormalisation et la renormalisation peuvent entra e ner une perte dinformation. Laddition peut entra ner la sortie du champ des nombres reprsentable en normalis : par e e exemple xm + xm . Multiplication Soit deux nombres ottants x1 = s1 m1 2e1 et x2 = s2 m2 2e2 . Le produit x1 x2 est donn e par s1 s2 m1 m2 2e1 +e2 . Il y a multiplication des mantisses, ce qui correspond a une multiplication enti`re, ` e o` lon arrondit pour obtenir un rsultat correspondant au nombre de bits de la partie u e fractionnaire. Compte tenu du codage en exc`s, laddition des exposants correspond a e ` lopration E1 + E2 c, o` les Ei sont interprts comme des entiers naturels, c = 127 e u ee
38
en simple prcision et 1023 en double prcision. L` encore, il peut il y avoir perte e e a dinformation, lors de larrondi, ou sortie du champ des nombres reprsentables, lorsque e lexposant est trop grand ou trop petit.
Traitement des situations anormales

Comme on vient de le voir, les calculs peuvent entra ner soit un dpassement de capacit, e e le rsultat nest pas reprsentable en format normalis, ou erreur, le rsultat est arrondi. e e e e La norme IEEE 754 vise a permettre ` un programme dadopter un comportement adquat ` a e dans ce type de situation anormale. Cette section en prsente les aspects lmentaires. e ee On trouvera un traitement exhaustif dans [11]. Les rsultats non reprsentables sont pris en compte par larithmtique tendue et e e e e la reprsentation dnormalise. Les erreurs sont prises en compte par une contrainte de e e e prcision. e Arithmtique tendue e e Lide de larithmtique tendue est quil peut tre protable de laisser survivre un proe e e e gramme qui a, par exemple, eectu une division par 0. Lexemple plus simple est un e solveur qui cherche les zeros dune fonction dont lensemble de dnition nest pas come modment calculable. le solveur travaille en valuant la fonction en divers points. Sil e e tombe sur une valeur hors de lensemble de dnition de la fonction, il peut fort bien e calculer 0/0 ou 1. Cette erreur nest pas ncessairement gnante, si le solveur peut e e recommencer en un autre point indpendamment. e La norme dnit dabord une arithmtique tendue a trois valeurs supplmentaires, e e e ` e et NaN. Ce sont les r`gles usuelles, par exemple : e (+) + (+) = (+) (+) + () = NaN () () = () avec r`gle des signes. e Toute opration dont un des oprandes est NaN a pour rsultat NaN. e e e Du point de vue de lapplication, si une opration produit un rsultat trop grand e e en valeur absolue, ou bien est mathmatiquement incorrecte (0/0), le rsultat tombe dans e e lensemble {+, , NaN }, et les calculs peuvent se poursuivre en utilisant larithmtique e tendue. e Tout FPU conforme IEEE 754 doit implanter cette arithmtique tendue. e e Reprsentation dnormalise e e e La dirence de deux nombres normaliss peut ne pas tre reprsentable en format nore e e e malis. Par exemple, en simple prcision (emin = 127), x = 1, 1 . . . 11 2126 et e e y = 1, 1 . . . 10 2126 sont reprsentables en normalis (par 00FFFFFF et 00FFFFFE). e e 126 nest pas reprsentable en normalis. e e Mais x y = 0, 0 . . . 01 2
3.4. Nombres rels e
39
On pourrait tout simplement arrondir le rsultat, au plus proche reprsentable, soit e e 0. Mais supposons que le FPU ralise correctement la comparaison de deux ottants, en e testant lgalit de tous leurs bits. Le test x = y donne faux, et le test x y = 0 donne e e vrai. Deux codes identiques du point de vue mathmatique auront des rsultats dirents e e e : le code if not (x=y) then z = 1/(x-y) pourrait aboutir a une division par 0, et le code if ` not (x-y = 0) then z = 1/(x-y) ne produit pas derreur. La reprsentation dnormalise permet prcisment la reprsentation de ces nombres e e e e e e trop petits : 0, 0 . . . 01 2126 = 0, 0 . . . 10 2127 , qui se reprsente comme 00000002. e Dans ce cas, les deux tests ont le mme rsultat. e e La dirence de deux nombres dnormalise peut elle-mme tre trop petite pour e e e e e tre reprsente, mme en dnormalis, et donc tre arrondie a 0. On verra plus loin le e e e e e e e ` traitement de ce type dv`nement. e e Drapeaux et gestionnaires dexceptions Le standard IEEE 754 fournit un fonctionnement par dfaut, qui est de continuer le calcul e dans larithmtique tendue. Continuer lexcution est souvent la solution approprie, e e e e mais pas toujours. Sur erreur arithmtique ottante, une application peut donc souhaiter e trois comportements : arrt immdiat, ou contrle par elle-mme ou non-traitement. e e o e Un exemple typique dapplication qui demande un arrt immdiat est celui du calcul e e x de 1+x2 . En simple prcision, quand x = 265 (reprsentable par 60000000), x2 produit e e et le rsultat est 0, alors quil est de lordre de 1/x, qui est parfaitement reprsentable ; e e le rsultat est donc compl`tement erron et continuer lexcution en gnral sans intrt e e e e e e ee (et ventuellement coteux en temps machine). Un exemple typique dapplication qui e u demande un traitement nuanc est une application qui gn`re des nombres dnormaliss e e e e e : elle ne souhaite pas sinterrompre prmaturment ` chaque rsultat dnormalis, mais e e a e e e elle veut sinterrompre si elle obtient un 0 comme rsultat de la soustraction de nombres e dnormaliss. e e Le standard prescrit que les v`nements anormaux soient enregistrs, dans des drae e e peaux (ag), et recommande fortement que des gestionnaires dexceptions soient installs. e Les drapeaux permettent un traitement personnel a lutilisateur (ventuellement rien) ; ` e les gestionnaires dexception fournissent un traitement par le logiciel de base (syst`me), e qui permet en particulier larrt immdiat. e e La gure 3.7 prsente ces drapeaux. Des instructions du processeur permettent de e les tester. Finalement, des routines des biblioth`ques numriques orent une interface e e utilisateur vers ces instructions, par exemple la libm, qui est la librairie numrique standard e associe au langage C. Lutilisateur peut donc choisir de ne pas tester les drapeaux, ou de e les tester et dappliquer un algorithme de son choix. La norme prescrit que les drapeaux soient persistants (sticky) : ` la dirence des drapeaux entiers, un drapeau positionn ne a e e sera remis ` ` que par une instruction explicite. Les drapeaux et les librairies numriques aa e permettent donc le contrle par lapplication. o Un traitement gnrique, en gnral larrt immdiat est rendu possible si chaque e e e e e e
40
Flag Underow Overow Division par 0 Invalid Operation Inexact
Condition Nombre trop petit Nombre trop grand division par 0 Le resultat est NaN et les oprandes = NaN e Resultat arrondi
Resultat 0, emin ou nombre denormalise ou xmax NaN Resultat arrondi
Table 3.7: Ev`nements anormaux dans la norme IEEE 754. la premi`re colonne dcrit e e e le drapeau, la seconde lopration qui cre cet v`nement, la troisi`me le rsultat dans le e e e e e e comportement par dfaut. e dpassement de capacit ottant peut dclencher une exception. Le drapeau nest alors e e e pas positionn. e Le choix entre positionnement des drapeaux (avec poursuite de lexcution du proe gramme utilisateur) et exception est programmable. Les microprocesseurs orent des bits de contrle, qui font gnralement partie dun mot de contrle du processeur, et des ino e e o structions pour les positionner, qui permet ce choix. Il y a un bit de contrle par exception. o Lorsque lerreur ne produit paslappel dun gestionnaire dexception, on dit que lexception est masque. Par exemple, lexception Rsultat Inexact est presque toujours masque : la e e e plupart des calculs eectuent des arrondis et le programme doit continuer. Linterface dun langage de haut niveau vers les instructions de masquage est ralis par des options e e du compilateur.
Prcision e
Les oprations dalignement et darrondi perdent de linformation, ce qui peut tre sans e e eet ou catastrophique. Par exemple, sur 3 digits dcimaux de mantisse, soient x = 2, 15 1012 et y = 1, 25 e 5 . En alignant y sur x et en arrondissant, y = 0 et x 10 y = 2, 15 1012 , ce qui est le rsultat arrondi correct ( est loprateur de soustraction sur 3 digits). e e 1 et y = 9, 93, en alignant y sur x et en arrondissant, Mais, pour x = 1, 01 10 y = 0, 99101 et x y = 0, 02, alors que le rsultat exact sur 3 digits est 10, 19, 93 = 0, 17. e Deux digits sont donc faux : lerreur sur le dernier digit sest propage. e Une mesure de la prcision est le ulp (units in last postion). Dans le calcul prcdent, e e e lerreur est 15 ulp. Le standard IEEE impose que les oprations daddition, soustraction, multiplication e et division soient arrondies exactement : tout se passe comme si le rsulat tait calcul e e e exactement, puis arrondi au plus pr`s. Ceci requiert que lunit de calcul dispose de plus e e de bits que le format, pour stocker temporairement des informations. On a montr que 3 e
3.5. Placement mmoire e
41
bits susent (garde, garde supplmentaire et sticky bit). e Le contrat assur par le standard IEEE ne garantit videmment rien sur le cumul des e e erreurs dans une squence de calculs. Ltude de la la qualit numrique des rsultats dun e e e e e algorithme est une branche de lanalyse numrique. e Lexemple le plus simple est lassociativit, que le calcul ottant ne respecte pas. e Considrons lexemple suivant, toujours avec une mantisse 3 digits dcimaux : e e 2, 15 1012 (2, 15 1012 1, 25 105 ) = 2, 15 1012 2, 15 1012 = 0 (2, 15 1012 2, 15 1012 ) 1, 25 105 = 1, 25 105
3.5
Placement mmoire e
Big Endian et Little Endian

La mmoire est en gnral organise par octets, cest ` dire que la plus petite unit e e e e a e adressable est loctet. Ainsi, la dclaration : e char c = A; correspond a la rservation dun octet, dont ladresse est par dnition celle de la variable ` e e c, et qui est initialis ` 0x41 (rservation signie simplement que le compilateur nallouera ea e pas cet octet pour une autre variable ; on verra dans le chapitre suivant comment seectue cette rservation). On notera dans la suite @x ladresse mmoire dune variable x e e Comme la mmoire est organise par octets, les types reprsents sur plus dun octet e e e e est plus dicile ` grer ; par exemple, la dclaration : a e e int x = 0x12345678 ; demande que lensemble doctets {12, 34, 56, 78} soit plac en mmoire dans lensemble e e dadresses {@x, 1+@x,2+@x, 3+@x}, mais dans quel ordre ? En fait, deux solutions existent (g. 3.6). Big Endian : loctet de poids fort est a ladresse @x ; on commence par le gros bout. ` Little Endian : loctet de poids faible est a ladresse @x ; on commence par le petit ` bout. Initialement, lun des formats tait caractristique des architectures x86 (Intel), et e e lautre des architectures 68x00 (Motorola). Actuellement, les processeurs peuvent tre e congurs pour supporter les deux formats. Les noms Big Endian et Little Endian sont e une allusion littraire. Dans les annes 80, les news ont t encombres par dinterminables e e ee e polmiques portant sur les mrites respectifs des deux formats, pour lesquels aucun argue e ment dcisif nexiste. Le nom fait allusion a un pisode des voyages de Gulliver, o` une e ` e u guerre est dclare entre les partisans du gros bout et du petit bout pour entamer les ufs e e a ` la coque.
42 Adresse @x 1+@x 2+@x 3+@x Big Endian 12 34 56 78 Little Endian 78 56 34 12
Figure 3.6: Plan mmoire en Big Endian et Little Endian e
Alignement
Les deux dclarations suivantes sont smantiquement quivalentes. e e e (a) (b) int x = 0x12345678; char c = A; char c = A int x = 0x12345678; Cependant, elles produisent deux occupations mmoire direntes (g. 3.7, en Big e e Endian, en supposant que les variables sont implantes ` partir de ladresse 0x1000). e a Dans les deux cas, la variable x, qui occupe quatre octets, est implante ` une adresse e a multiple de 4 ; dans le deuxi`me cas, le compilateur est contraint de laisser inoccups e e quelques octets pour respecter cette contrainte. Plus gnralement, e e Dnition 9 On dit quune donne de taille p mots mmoire est aligne si son adresse e e e e est multiple de p.
Adresse 1000 1001 1002 1003 1004 1005 1006 1007
(a) 12 34 56 78 41 -
(b) 41 12 34 56 78
Figure 3.7: Alignement mmoire e Lalignement dcoule de larchitecture matrielle : les acc`s aux circuits qui sont le e e e support matriel de la mmoire sont organiss pour permettre un acc`s rapide aux enseme e e e bles doctets aligns. Le surcot en encombrement mmoire est compens par la rapidit. e u e e e La plupart des processeurs, a lexception des architectures Intel, nautorisent pas lacc`s ` e non align, le surcot en encombrement mmoire tant compens par la rapidit. Un acc`s e u e e e e e
3.5. Placement mmoire e
43
non align provoque alors une exception, qui conduit en gnral a la n prmature du e e e ` e e programme. En particulier, une erreur dexcution interviendra si un pointeur sur un type e multi-octets (par exemple sur un entier), se retrouve pour une raison quelconque contenir une adresse non aligne. Lorsque lacc`s non align est permis, il est souvent plus coteux e e e u en temps quun acc`s align. Les compilateurs actuels crent donc toujours un code align. e e e e
Types
Les LHN dnissent des types, qui permettent un calcul sur le type des expressions, donc e sur le rsultat des aectations (par exemple entier + ottant ottant). Le type dune e variable dnit aussi son encombrement mmoire. On ne consid`rera ici que les structures e e e de donnes les plus courantes, scalaires et tableaux. e Types scalaires On a vu ci-dessus la reprsentation des types scalaires. e Tableaux
a00 a01 a02 a10 a11 a12 a20 a21 a22 RMO
0 1 2 3 4 5 6 7 8
a00 a10 a20 a10 a11 a12 a20 a21 a22 CMO
0 1 2 3 4 5 6 7 8
Figure 3.8: Allocation des tableaux en mmoire e Les tableaux sont raliss en mmoire par une squence implante ` partir de ladresse e e e e e a du premier lment du tableau. Pour un tableau unidimensionnel A, ladresse de A[i] est ee u ee @A + i sa , o` sa est la taille en octets dun lment de a. Les tableaux multidimensionnels sont linariss par le compilateur (g. 3.8). Les come e pilateurs C et Pascal utilisent lordre ligne dabord (Row Major Order, RMO) ; par exemple, pour un tableau bidimensionnel, les lments dune ligne sont allous conscutivement ee e e en mmoire ; les compilateurs Fortran utilisent lordre colonne dabord (Colum Major Ore der, CMO) o` les lments dune colonne sont allous conscutivement en mmoire. u ee e e e
44
Chapitre 4
Architecture logicielle du processeur

Larchitecture logicielle est la spcication dun processeur. Elle dcrit les units fonce e e tionnelles (UAL, Units de calcul ottant etc.), les registres visibles, les types de donnes e e manipuls et les oprations le processeur eectue sur ces donnes. Cette spcication e e e e est dcrite par le jeu dinstructions. Cest la machine que voit un compilateur, ou un e programmeur en langage machine. Le but de larchitecture logicielle dun processeur gnraliste est de permettre une e e excution ecace des constructions des langages de haut niveau (LHN). Ces constructions e ont une smantique riche, par exemple une boucle, ou un appel de fonction. e Lintroduction a soulign que la prise en compte de lensemble des contraintes teche nologique a des consquences majeures ` tous les niveaux de larchitecture, matrielle et e a e logicielle. Dans ce chapitre, nous ne consid`rerons que deux contraintes : e le nombre des oprateurs matriels est limit; e e e les calculs ne peuvent seectuer que sur des donnes prsentes dans le processeur. e e Ce chapitre prsente donc une typologie des composants des architecture logicielles, par e rapport aux structures des LHN impratifs. Lobjectif nest ni de prsenter de mani`re e e e exhaustive le jeu dinstructions dune machine (plus de 200 pour le PowerPC !), ni de prsenter toutes les variantes de jeux dinstructions que lon peut trouver dans les archie tectures actuelles, mais dtudier les caractristiques des jeux dinstruction qui permettent e e lexcution des langages de haut niveau. Les chapitres suivants discuteront de faon plus e c approfondie linteraction avec les contraintes technologiques. 45
46
Chapitre 4. Architecture logicielle du processeur
4.1
Mod`le dexcution e e
Dnition e
Le choix du nombre doprandes sur lesquels travaille une instruction machine est une e question cl. Il rsulte dun compromis entre le temps de calcul, le nombre doprateurs e e e matriels utiliss et le nombre de registres disponibles. e e Soit par exemple linstruction Y := A + B + C + D. Elle peut tre excute en une e e e seule instruction si lon dispose de trois oprateurs matriels daddition (additionneurs), e e ou en trois instructions avec un seul additionneur. La frquence dune telle instruction e dans les codes LHN ne ncessite certainement pas le co t de trois additionneurs, alors que e u linstruction suivante sera typique des langages de haut niveau : Resultat = operande1 OP operande2 . Cette instruction correspond a ce que peut raliser une UAL qui eectue une opration ` e e sur deux oprandes et dlivre un rsultat. e e e Trois oprandes spcis par instruction (deux oprandes source et un rsultat) cone e e e e stituent donc un bon compromis entre ecacit et cot du matriel. Cependant, ce come u e promis suppose quon peut eectivement accder ` trois oprandes, ce que le nombre e a e de registres disponible na pas toujours permis. La premi`re caractristique du mod`le e e e dexcution est donc le nombre doprandes. e e Les oprandes considrs peuvent tre situs, soit dans un registre interne a lunit e ee e e ` e centrale, soit dans la mmoire. Pour chaque oprande source ou rsultat, linstruction doit e e e contenir le numro de registre pour les oprandes dans lUC, ou lensemble des informations e e pour calculer ladresse mmoire de loprande. e e Dnition 10 Soit n le nombre total doprandes spcis par instruction, et m le nombre e e e e doprandes mmoire. Le couple (n, m), avec m n , dnit le mod`le dexcution du e e e e e processeur.
Les dirents mod`les dexcution e e e

La gure 4.1 illustre les dirents mod`les dexcution des instructions, sur lexemple A e e e = B + C. La partie (a) prsente le mod`le mmoire-mmoire (3,3), qui est caractristique du e e e e e VAX-11 de Digital. Une instruction peut spcier les deux oprandes source et le rsultat, e e e et chaque oprandes peut tre situ en mmoire. Linstruction A = B + C est excute e e e e e e par une instruction assembleur : ADD @A, @B, @C. La partie (b) prsente le mod`le mmoire-accumulateur (1,1), typique des premiers e e e microprocesseurs 8 bits (Intel 8080 ou Motorola 6800). Linstruction ne spcie quun e oprande ; les autres ssont implicites, contenus dans le registre accumulateur. Linstruction e A = B + C est alors excute par une suite de trois instructions machine : e e
4.1. Mod`le dexcution e e
47
A B C
B C Accu
B C R1
UAL (a) (b)
UAL Accu (c)
UAL R2
A B C R2
A B C
R1
UAL UAL (d) R3 (e)
Figure 4.1: Mod`les dexcution e e
48 LD @B ADD @C ST @A
chargement du premier oprande dans laccumulateur, addition du deuxi`me oprande e e e avec laccumulateur dans lequel est rang le rsultat, et rangement de laccumulateur en e e mmoire. e La partie (c) prsente le mod`le mmoire-registre (2,1), o` laccumulateur unique est e e e u remplac par un ensemble de registres gnraux. Il est caractristique des microprocesseurs e e e e 16 bits (Intel 8086 ou Motorola 68000). Dans les processeurs avec mod`le (2,1), il existera e aussi la variante (2,0) o` les deux oprandes sources sont dans des registres, et le rsultat u e e dans un des deux registres source. LD R1, @B ADD R2, R1, @C ST R2, @A La partie (d) prsente le mod`le registre-registre (3,0), o` les trois oprandes des e e u e oprations UAL sont obligatoirement en registre (0 oprande mmoire). Seules les ine e e structions de chargement (LD) et rangement (ST) acc`dent ` la mmoire pour charger ou e a e ranger le contenu dun registre. Linstruction A = B + C est excute par une suite de e e quatre instructions machine : chargement du premier oprande dans un premier registre, e chargement du deuxi`me oprande dans un deuxi`me registre, addition sur registres, et e e e rangement du rsultat en mmoire. e e LD R1, @B LD R2, @C ADD R3, R1, R2 ST R3, @A Les architectures avec mod`le (3,0) ont donc t appeles architecture chargement-rangement e ee e ou encore registre-registre. La partie (e) prsente le mod`le pile (0,0) pour lequel les oprandes sont successivement e e e empils en sommet de pile. Linstruction ADD ne spcie aucun oprande, puisquelle e e e prend implicitement ses oprandes dentre dans la pile et range le rsultat dans la pile. e e e Le rsultat est ensuite dpil. e e e PUSH @B PUSH @C ADD POP @A Dans tous les cas, le processeur eectue le mme nombre dacc`s mmoire. Dans les e e e cas (a) (b) et (c), les transferts mmoire-registre sont seulement masqus par la syntaxe, e e qui est plus concise.
4.2. Format des instructions
49
(n) 3 2 2 3
(m) 0 1 2 3
Exemples SPARC, MIPS, HP PA, POWER, PowerPC, ALPHA Motorola 68000, IBM 360, Intel 8086 PDP-11 VAX-11
Table 4.1: Les mod`les caractristiques de direntes machines classiques e e e La table 4.1 prsente les mod`les caractristiques de direntes machines classiques. e e e e Cependant, il faut souligner tr`s fortement que les architectures des microprocesseurs e actuels ont totalement converg vers le mod`le (3,0) et sont donc toutes des architece e tures chargement-rangement. Lexception - de taille - a longtemps t les architectures ee Intel. Hriti`res du 8086, elles ont suivi le mod`le (2,1), jusqu` la gamme Pentium (archie e e a tecture IA-32). Depuis 99, la nouvelle architecture Intel, lIA-64, est une architecture chargement-rangement. Les raisons de cette convergence, ainsi que le fait que les architectures chargement-rangement sont plus connues sous le nom darchitectures RISC, seront discutes dans les chapitres suivants. e
4.2
Format des instructions

Poids fort Poids faible 5 Rd 5 Ra 5 Ra 6 Codop 5 Rd 5 Ra 5 Ra 6 Codop 5 Ra 5 Rb 8 Imm 5 Ra 5 Ra 5 Rb 5 Rb 5 Ra 3 X 5 Rb 5 Rd 11 Extension Codop 11 Extension Codop 5 Rd 5 Rb
Power PC MIPS Alpha SPARC Power PC MIPS Alpha SPARC
6 Codop 6 Codop 6 Codop 2 5 CO Rd 6 Codop 6 Codop 6 Codop 2 5 CO Rd
1 7 0 Extension Codop 8 1 0 X 16 Imm 16 Imm 1 7 1 Extension Codop 13 1 1 Imm
5 Rd
Figure 4.2: Les formats dinstructions enti`res pour quelques processeurs RISC e
50
Le format des instructions est leur codage binaire. Il est absolument spcique dune archie tecture logicielle, mais les formats des machines RISC prsentent tous la mme structure. e e Le format doit dcrire lopration et fournir le moyen daccder aux oprandes. La g. e e e e 4.2 prsente trois exemples de formats. On trouve plusieurs champs : le code opration e e (CODOP), qui dcrit lopration eectue par linstruction (addition, soustraction, chargee e e ment, etc.) et des champs registres qui dcrivent les oprandes. Dans lexemple, seuls e e lemplacement des champs numro de registre, et le codage des oprations, di`rent. On e e e voit comment le format dcrit larchitecture logicielle : la largeur des champs numros de e e 5 = 32 registres. registres est 5 bits ; le compilateur dispose donc de 2 Les architectures RISC dnissent toutes un format xe : toutes les instructions e sont codes sur un mot de taille xe, de la taille dun mot mmoire (32 ou 64 bits). e e Larchitecture IA-32 utilse un format variable, o` la taille est adpte ` la quantit dinformation u e a e ncessaire : typiquement, un NOP (non-opration, instruction qui ne fait rien) demande e e un octet ; dautres instructions en demanderont beaucoup plus. Dans la suite, tous les exemples utiliseront une architecture 32 bits, et un format dinstruction galement 32 bits. e On notera que nous navons prsent ci-dessus que les formats des machines chargemente e rangement. En eet, ces formats sont assez simples, plus prcisment orthogonaux : les e e champs CODOP et oprandes sont distincts et indpendants. Le formats des architectures e e Intel jusqu` la gamme Pentium sont hautement non orthogonaux, et donc excessivement a compliqus, car ils devaient rester compatibles avec les formats tr`s contraints du 8086. e e
4.3
Langage de haut niveau et langage machine
La g. 4.3 rsume les principales structures des LHN impratifs (Pascal, C ou Fore e tran). Les caractristiques des langages plus volus (fonctionnels, objets etc.) ntant e e e e pas signicatives dans le contexte des architectures logicielles, ne seront pas considres ee ici. Les constantes des LHN sont intgres au programme. Sinon, on pourrait les modie e er par erreur. Le code nest en principe pas modiable... Les variables des LHN sont ultimement ralises par un ensemble de cases mmoire. e e e Une aectation variable = expression donne lieu a la squence ` e Inst1 ... Instn STxx Registre resultat, @variable o` Inst1, . . . , Instn calculent lexpression. Si les instruction Inst1, ..., Instn font intervenir u des variables, la squence contient des chargements. Ainsi, linstruction LHN A = B + C; e o` A, B et C sont des entiers, se compile (on suppose R1 = @A, R2 = @B, R3 = @C) en u :
4.3. Langage de haut niveau et langage machine Structures de donnes : Variables et constantes. e scalaire: entiers, caract`res, ottants etc. e tableaux enregistrements pointeurs Instructions Aectation : variable = expression Contrle interne o Squence : debut Inst1 ; Inst2 ;. . . ;Instn n e Conditionnelle : Si ExpBool alors Inst vrai sinon Inst faux Repetition : Tant que ExpBool faire Inst Repeter Inst jusqua ExpBool contrle externe : appel de fonction o Figure 4.3: Les composantes des LHN impratifs e LD R12, 0(R2) LD R13, 0(R3) ADD R11, R12, R13 ST R11, 0(R1) ; ; ; ; R12 B R13 C R11 B + C A R11
51
En ralit, le compilateur neectue pas toujours une traduction mot-`-mot du proe e a gramme source. Le degr de dlit est contrl par les options doptimisation de la e e e oe commande de compilation, dont le but est damliorer les performances. Lexemple le e plus simple est la squence : e A=B+C; A = A + D; La dlit absolue implique le code suivant : e e LD R12, 0(R2) LD R13, 0(R3) ADD R11, R12, R13 ST R11 0(R1) LD R11 0(R1) LD R14 0(R4) ADD R11 R11 R14 ST R14 0(R4) ; ; ; ; ; ; ; ; R12 B R13 C R11 B + C A R11 R11 A R14 D R11 A+D A R11
52
Les deux acc`s mmoire intermdiaires (ST R11 suivi de LD R11) sont inutiles, et sont e e e supprims par un compilateur optimisant. Ici et dans la suite, lallocation des registres e nest pas conforme ` celle que gn`rerait un compilateur, pour une meilleure lisibilit. a e e e Plus gnralement, dans les architectures chargement-rangement, un compilateur ope e timisant tentera de supprimer toutes les transactions mmoire inutile : idalement, une e e variable est charge lors de sa premi`re lecture, et crite en mmoire lorsquelle nest e e e e plus utilise, ou aux fronti`res de procdure. En pratique, comme le nombre de rege e e istres disponibles nest pas susant, le compilateur doit eectuer un choix judicieux, cest lallocation de registres. Limportance des options doptimisation est donc considrable. e Les compilateur proposent en gnral une option (-S sous Unix), qui est compatible e e avec les options doptimisation, et qui permet de rcuprer une version du code gnr e e e ee en langage machine, dans un chier sux .s. On peut utiliser cette option pour tudier e e leet des optimisations sur de petits programmes. Lvaluation des expressions enti`res des LHN utilise les instructions enti`res, qui come e e prennent toutes les instructions qui acc`dent aux registres entiers, donc les instructions de e chargement-rangement et les instructions arithmtiques et logiques. Elles travaillent toutes e sur les registres entiers gnraux, en format registre-registre ou registre-immdiat. Les ine e e structions de contrle des LHN utilisent les instructions de comparaison et de branchement. o
4.4
Instructions arithmtiques et logiques e
Ce sont les instructions daddition (ADD) et de soustraction (SUB), de multiplication (MUL), de division (DIV), etc.
Mode dadressage
Le mode dadressage dnit la mani`re dont les instructions acc`dent aux oprandes. e e e e Le terme dadressage ne correspond pas bien au mod`le dexcution (3,0), puisque les e e oprandes sont forcment situs en registre ; nous le conservons cependant, car il est e e e traditionnel. Mode registre Dans ce mode, loprande est situ dans un registre gnral. Par exemple, les trois e e e e oprandes de linstruction e ADD Rd, Rs1, Rs2 ; Rd < Rs1 + Rs2 sont adresss en mode registre. Plus gnralement, dans la premi`re partie de la g. 4.2, e e e e les deux oprandes sont adresss en mode registre. e e
4.4. Instructions arithmtiques et logiques e Mode immdiat e
53
Dans le mode immdiat, loprande est contenu dans linstruction. Limmdiat est disponible e e e dans linstruction, donc dans le registre RI, mais il nest pas de la taille requise : en gnral e e linstruction a la mme largeur que le chemin de donnes, et limmdiat ne peut donc e e e loccuper tout enti`re. Loprande est obtenu soit en ajoutant des 0 en tte de limmdiat e e e e (Alpha), soit par extension de signe (SPARC, Power, MIPS). Dans la deuxi`me partie de e la g. 4.2, le deuxi`me oprande est un immdiat. e e e ADD Rd Rs1 imm ; Rd Rs1 + ES(imm) Le mode dadressage immdiat permet, entre autres, de compiler les constantes. Si R1 = e x et R2 = y, x = y + 0x12, se compile en ADD R1, R2, Ox12. Mais, pour compiler x = y + 0x12348765, on ne peut PAS crire ADD R1, R2, 0x12348765. En eet, limmdiat est limit ` moins e e ea que la taille du plus grand entier reprsentable, car en gnral, linstruction est de la mme e e e e taille que le chemin de donnes. Par exemple, les immdiats Power sont compris entre e e e 215 et 215 1, les immdiats SPARC entre 212 et 212 1, alors que dans les deux cas, les entiers reprsentables sont compris entre 231 et 231 1. La valeur 0x12348765 doit e donc tre pralablement crite dans un registre. Suivant les processeurs et les formats, e e e des instructions spciques pour lcriture en registre dun immdiat de la taille du mote e e processeur, sont dnies. Il faudra nammoins toujours deux instructions au moins pour e e un immdiat trop large. Il est donc utile davoir un champ immdiat aussi grand que le e e format le permet, pour limiter les situations o` deux instructions sont ncessaires. u e Les deux oprandes source ne peuvent pas tre tous deux des immdiats : la taille de e e e linstruction est trop petite pour en accepter deux. En outre, une telle instruction serait inutile : le compilateur peut calculer directement le rsultat dune aectaion du type x = e cst1 + cst2. Les modes registre et immdiat sont galement disponibles, respectivement pour (source e e et destination) et (source seulement) sur les architectures Intel.
Instructions
Les instructions daddition et de soustraction peuvent avoir plusieurs variantes :
54
Chapitre 4. Architecture logicielle du processeur positionnement ou non de certains drapeaux : une version positionne les drapeaux, et lautre ne les positionne pas. Lexistence des deux versions est utile pour les tests, comme on le verra plus loin. sign ou non sign : laddition signe positionne le drapeau doverow, laddition non e e e signe ne le positionne pas. En eet, lorsque les oprandes reprsentent un entier e e e naturel, le drapeau de retenue sut a indiquer un dpassement de capacit, alors que ` e e la situation est plus complique lorque les oprandes reprsentent un entier relatif, e e e comme on la vu au chapitre prcdent. Larchitecture x86 ne calcule quen sign. e e e addition des oprandes et du drapeau de retenue ; cette instruction est par exemple e utile pour additionner des oprandes en multiple longueur. e
La table 4.2 montre les diverses versions de linstruction daddition dans le jeu dinstruction PowerPC. Mmonique e ADDx ADD ADDo ADD. ADDo. ADDcx ADDEx ADDI Syntaxe ADDx Rd, Ra, Rb Eet Rd Ra + Rb Aucun ag aect e Flags Z, E, N aects e Flag O aect e Flags 0, Z, E, N aects e Rd Ra + Rb C Flag aect , x commme pour ADD e Rd Ra + Rb + C C Flag aect , x commme pour ADD e Rd Ra + Imm16 Aucun ag aect e
ADDcx Rd, Ra, Rb ADDcx Rd, Ra, Rb ADDcx Rd, Ra, Imm16
Table 4.2: Instructions daddition du PowerPC On trouve galement des instructions logiques, qui eectuent bit a bit les oprations e ` e logiques Et (AND), Ou (OR), Ou exclusif (XOR), Complment (NEG), etc. et des ine structions de dcalage arithmtique ou logique, circulaires avec ou sans la retenue dentre, e e e a ` droite ou a gauche. ` Laddition et les dcalages sont videmment utilises pour les compiler les instructions e e e de calcul. Elles sont aussi fortement utiliss pour les calculs dadresse (g. 4.4). e
4.5
Instructions dacc`s mmoire e e
On ne traitera ici que les architectures RISC, o` les acc`s mmoires sont limits aux u e e e transferts entre la mmoire et les registres du processeur. Des instructions spciques e e
4.5. Instructions dacc`s mmoire e e
55
int v [N], k ; ... temp = v[k] ; v[k] = v [k+1]; v[k+1] = temp ; Initialement, R1 = @v[0], R2 = k SLL ADD LD LD LD ST R2, R2, R3, R4, R4, R3, 4, R2 R2, R1 0(R2) 4(R2) 0(R2) 4(R2) ;deplacement k k*4 ; R2 @ v[k] ; temp = R3 v[k] ; R4 v[k+1] ; v[k] R4 ; v[k+1] temp
Figure 4.4: Utilisation des instructions arithmtiques pour le calcul dadresse e assurent ce transfert.
Acc`s entiers e
Entiers signie ici tous les acc`s qui echangent entre la mmoire et un registre entier, ie e e un registre sur lequel op`re lUAL, indpendamment du type de la donne. e e e La taille des registres entiers dun processeur est xe (32 ou 64 bits). Il existe donc des instructions de chargement et de rangement, qui copient un mot de la mmoire vers e le registre, ou linverse. LD Rd, @variable ; Rd Mem[@variable] ST Rs, @variable ; Mem[@variable] Rs Les instructions arithmtiques et logiques travaillent sur le format correspondant au nome bre de bits des registres entiers, soit 32 bits ou 64 bits. Mais les variables du LHN peuvent tre plus petites, par exemple un caract`re sur 8 bits. Il peut tre donc tre ncessaire e e e e e de convertir un type vers un autre, lors dun acc`s mmoire en lecture, par exemple le e e chargement dun octet vers un registre 32 bits. Lalternative principale pour la conversion porte sur lextension : loctet tant plac e e dans loctet bas du registre, les bits restants sont, soit forcs ` 0, soit positionns par e a e extension de signe. Les formats de donnes les plus couramment accessibles en mmoire e e de cette faon sont les octets, les demi-mots (2 octets), les mots (4 octets) et, pour les c microprocesseurs 64 bits, les doubles mots (64 bits). On a ainsi, pour un microprocesseur 32 bits, les instructions (g. 4.5) : LDUB (Load Unsigned Byte) pour charger un octet sans extension de signe,
56
Chapitre 4. Architecture logicielle du processeur 82 AB 56 78
1000 1001 On suppose @A = 1000, et le plan mmoire : e 1002 1003 LDUB LDB LDUH LDH LD R1, R2, R3, R4, R5, @A @A @A @A @A ; ; ; ; ; R1 R2 R3 R4 R5
00000082 FFFFFF82 0000AB82 si LE, 000082AB si BE FFFF AB82 si LE, FFFF82AB si BE 7856AB82 si LE, 82AB5678 si BE
Figure 4.5: Les instructions de chargement LDB (Load Byte) pour charger un octet avec extension de signe, LDUH (Load Unsigned Half-Word) pour charger un demi-mot sans extension de signe, LDH (Load Half-Word) pour charger un demi-mot avec extension de signe. Le rangement ne pose pas un probl`me symtrique : on veut seulement, par exemple, e e pouvoir ranger un octet sans perturber les octets voisins. On a donc seulement trois instructions de rangement : ST pour un mot, STH pour un demi-mot et STB pour un octet ; dans tous les cas, cest la partie basse du registre qui est range. e
Acc`s ottants e
Les acc`s ottants sont les transferts entre la mmoire et les registres ottants. Les units e e e ottantes travaillent en gnral en double prcision, et le codage est la standard IEEE 754. e e e On trouvera donc deux instructions de chargement : LDFS , charger un ottant simple prcision (4 octets), avec conversion codage simple prcision vers codage double prcision, e e e et LDF, charger un ottant double prcision (8 octets). Ici, le rangement est symtrique : e e on peut vouloir arrondir un rsultat double prcision vers la simple prcision, le standard e e e dnissant lalgorithme darrondi. e
Modes dadressage
On appelle adresse eective, et on note EA, ladresse de la case mmoire lue ou crite. e e Inclure une adresse mmoire explicite dans une instruction est exclu: ladresse est de la e taille du chemin de donnes, donc doublerait la taille au moins des instructions mmoire. e e Dautre part, un programme utilisateur acc`de rarement ` des donnes qui ont une adresse e a e absolue, mais plutt a des variables locales ` une procdure. Ces variables sont places en o ` a e e

6 Codop 5 Ra 5 Rb 16 Imm
57
Alpha
Figure 4.6: Format des instructions dacc`s mmoire pour larchitecture Alpha e e
Rbase
+
RI dplacement
Zone de travail de la procdure
Figure 4.7: Acc`s ` une variable de procdure e a e mmoire ` partir dune adresse associe ` la procdure et contenue dans un registre (ce e a e a e mcanisme sera dtaill dans la partie appel de sous-programmes). e e e Pour ces deux raisons, les adresses mmoires sont calcules comme somme dun registre e e et dun immdiat ou dun registre ; on parle dadressage indirect. e La table 4.3 rsume les modes dadressage que lon trouve dans un certain nombre e darchitectures RISC, et qui sont dtailles dans la suite. e e Architecture Alpha Power MIPS jusqu` R3000 a MIPS a partir R10000 ` SPARC Base + Dep. oui oui oui oui oui Base + Index oui oui oui Auto-incrment e e oui
Table 4.3: Modes dadressages des architectures RISC Les formats des instructions mmoire sont souvent identiques a ceux des instructions e ` UAL, car les champs sont identiques. Larchitecture Alpha fait exception : limmdiat e tant petit et interprt positif, les instructions mmoire ont le format de la g. 4.6, o` e ee e u limmdiat est obtenu par extension de signe de Imm. e Base + Dplacement e Ladresse est la somme dun registre (registre de base) et dun immdiat, le dplacement, e e positif ou ngatif : e
RbaseT
T[0] T[1]
58
+
Rindex
T[n-1] U[0] U[1]
+
RbaseU U[n-1]
Figure 4.8: Acc`s ` un lment de tableau e a ee EA = Rs1 + ES(Imm) On utilisera dans la suite la syntaxe Imm (Rs1), par exemple : LD R1, 4(R2) ; R1 Mem [R2 +4]. Ce mode dadressage est fondamental. Il permet daccder aux variables dune procdure e e (g. 4.7) : le registre de base contient ladresse de dbut de la zone des variables de la e procdure ; le dplacement donne ladresse de la variable par rapport a la zone de donnes e e ` e de la procdure. e Il permet galement daccder aux variables statiques, dont ladresse est absolue. Il e e faut pour cela que ladresse de la variable soit pralablement charge dans le registre de e e base Rs1 ; on acc`de alors ` la variable par LD/ST 0(Rs1). e a Base + Index Certaines architectures ont un mode dadressage mmoire registre-registre. e EA = Rs1 + Rs2 On utilisera la syntaxe (Rs1 + Rs2), par exemple LD R1, (R2 + R3) ; R1 Mem[R2 + R3] Lutilisation la plus courante est lacc`s ` un lement de tableau (g. 4.8) : le premier e a e registre est utilis comme registre de base qui contient ladresse de dbut dun tableau, e e et le second registre contient lindice i de llment du tableau multiplie par la taille de ee e llment. Pour accder aux lments successifs dun tableau, il sut dincrmenter le ee e ee e registre dindex.Par exemple, le code int i ; for( i = 0 ; i n-1 ; i++) x(i) = . . . ;
59
se traduit, en supposant que R1 soit initialis ` @x[0] et R2 a 0, par une boucle dont le ea ` corps est : LD R10, (R1 + R2) ; R10 x [i] ... ADD R2, R2, 4 ; incrementation index ... Base + Index + Dplacement e Certaines architectures non chargement-rangement, en particulier les architectures Intel, proposent la combinaison des deux modes prcdents e e Il faut noter une dirence majeure avec les cas prcdents : le dplacement peut e e e e stendre jusqu` 32 bits. Ce MA autorise alors ladressage absolu, donc une compilation e a particuli`rement simple et un mode dacc`s ecace aux variables statiques. La combie e naison avec le registre dindex et le registre de base sapplique aux acc`s aux tableaux e statiques ` 1 et 2 dimensions respectivement. a Pour un tableau variable de procdure, ce mode dadressage permet de cumuler les e avantages de base + dplacement et base + index. Le registre de base contient ladresse e de base de la procdure, le dplacement contient ladresse relative dun lment du tableau e e ee par rapport au premier lment du tableau, et le registre dindex stocke lindice, a un ee ` facteur dchelle pr`s. En fait, larchitecture Pentium autorise mme ` introduire le facteur e e e a dchelle, avec le mode dadressage e Base + Index * scale + deplacement, avec scale = 1,2,3 ou 4 EA = Base + Index * /1, 2, 4, 8/ + deplacement Linconvnient de ce mode dadressage est quil ncessite dadditionner trois adresses et e e deectuer un dcalage, ce qui prend beaucoup plus de temps que la simple addition e de deux adresses dans un additionneur rapide. Pour cette raison, lie aux contraintes e temporelles pour la ralisation de pipelines avec des frquences dhorloge leves, ce mode e e e e dadressage nest pas spci dans les architectures RISC. e e Le mode auto-incrment e e Il sagit dune variante des modes base + dplacement et base + index. La seule dirence e e est que le registre Rs1 est aussi modi. On peut par exemple dnir une instruction : e e LDX Rd, (Rs1 + Rs2) ; Rd Mem[Rs1 + Rs2], puis Rd Rs1 + Rs2]. Ce mode permet de balayer successivement les lments dun tableau sans avoir a incrmenter ee ` e le registre dindex par une instruction explicite. Dans des machines des annes 60, on trouvait couramment des adressages indirects via e la mmoire : le contenu dune case mmoire contenait ladresse de loprande. Ces modes e e e dadressage ont disparu au prot des modes indirects via registre.
60
4.6
Instructions de comparaison
Une instruction de comparaison (CMP) eectue la soustraction de ses oprandes. Elle ne e conserve pas le rsultat arithmtique, mais seulement les code-conditions (CC). e e Syntaxe : CMP Ra, Rb Il sagit en fait dinstructions UAL, mais qui sont utilises pour compiler les structures de e contrle. Les instructions de comparaison valuent des prdicats des LHN ; un prdicat est o e e e une variable a valeur boolenne fonction des autres variables du programme, par exemple ` e le rsulat de lvaluation x = y. Les prdicats lmentaires sont : e e e ee lgalit (de variables de types quelconque) ; e e les relations dingalit arithmtiques (>, , <, ) sur les e e e naturels relatifs; ottants les v`nement exceptionnels arithmtiques (Overow entier, drapeaux IEEE754) e e e Un tel prdicat sur un couple (x, y) est en fait un prdicat sur x y : e e x=y xy =0 xy xy 0 etc. On a donc besoin de soustraire les registres contenant le valeurs de x et y. Le rsultat nest pas la valeur de la soustraction, sur n bits, mais un ensemble de boolens, e e les code-conditions, sur quelques bits. Ces boolens sont rangs dans un registre implicite, e e le Registre Code Condition. Un autre type dinstruction de comparaison calcule directement les prdicats, et posie tionne le rsultat dans un registre utilisateur. Cest le cas du jeu dinstruction du MIPS, e avec des instruction du type set conditionnel : Scond Rd, Ra, Rb ; Rd 0 si Ra cond Rb, 1 sinon cond exprime le prdicat. Linconvnient est de consommer un registre 32 bits pour stocker e e un boolen. Larchitecture Alpha a des instructions analogues. e Enn, larchitecture IA 64 dnit 64 registres 1 bit, en plus des registres de travail e arithmtiques, pour mmoriser le rsultat dinstructions de type Scond (CMPScond dans e e e la syntaxe Intel).
4.7. Instructions de saut et de branchement
61
0 4 8 12 16 20
etiq1 : etiq2 :
ADD Branch etiq2 SUB AND OR Branch etiq1
+4
-16
Figure 4.9: Calcul des adresses des branchements relatifs
4.7
Instructions de saut et de branchement
Les instructions en langage machine sexcutent en squence. Des instructions partice e uli`res, les branchements, permettent dimplmenter toutes les structures de contrle ine e o terne des LHN, conditionnelles et boucles. Leet dun branchement est PC nouvelle valeur. Les branchements de squence peuvent tre : e e conditionnels ou inconditionnels ; absolus ou relatifs absolu : PC est charg avec une adresse compl`te, prsente dans un registre ; e e e leet est PC Adresse relatif : la nouvelle adresse est calcule ` partir de la valeur courante de PC e a plus un dplacement : PC PC + dplacement e e Pour les branchements relatifs, la valeur de PC a laquelle sajoute le dplacement ` e est celle de linstruction qui suit le branchement, et non celle du branchement : PC est incrment en mme temps que linstruction est lue. Pour viter des calculs fastidieux, les e e e e programmes en langage dassemblage utilisent des tiquettes symboliques (g. 4.9). e
Branchements conditionnels sur registre code-conditions

Linstruction conditionnelle Si condition alors Bloc I1 sinon Bloc I2 se compile classiquement par le schma de la g. 4.10. e Les instructions de comparaison ont prcisment pour fonction de permette lvaluation e e e des conditions les plus courantes sans polluer les registres de calcul. Cependant, une architecture a RCC permet de calculer implicitement des conditions, sans instruction de ` comparaison ; par exemple, linstruction PowerPC ADDo. positionne tous les bit du RCC. En revanche, MIPS, Alpha et IA-64 imposent une instruction explicite de comparaison. Les instructions de branchement conditionnel nexcutent la rupture de squence que si e e la condition boolenne teste est vraie. Dans le cas contraire, lexcution des instructions e e e
62
Evaluer cond Bcond bloc_vrai Bloc I2 Branch suite bloc_vrai : Bloc I1 suite :
Figure 4.10: Schma de compilation dune conditionnelle e continue en squence. La forme prcise de ces instructions conditionnelles dpend de la e e e mani`re dont sont mmoriss les codes conditions. Dans une architecture ` RCC, les e e e a instructions conditionnelles testent les code-conditions contenues dans ce registre, qui est implicite dans linstruction. La forme gnrale des instructions est alors e e Bcond deplacement cond reprsente la condition teste. e e La g. 4.11 donne un exemple de de ralisation des conditionnelles. e CMP R1, R2 BGT vrai ADD R3, R0, R2 BA suite vrai : ADD R3, R0, R1 suite : ; ; ; ; ; ; 1 2 3 4 5 6 eectue R1 - R2 et positionne RCC Saute les deux instructions suivantes si R1>R2 Transfere le contenu de R2 dans R3 Saute linstruction suivante Transfere le contenu de R1 dans R3 Suite du programme
Figure 4.11: Code de la conditionnelle Si R1 > R2, alors R3 = R1 sinon R3 = R2 sur une architecture a RCC. Si R1 > R2, la suite dinstructions excutes est 1-2-5-6 ; sinon ` e e 1-2-3-4-6. Les conditions testables dpendent de larchitecture, mais on trouve typiquement les e mnmoniques de la table 4.4. La smantique exacte de ces mnmoniques est fournie par e e e la combinaison des codes conditions quils testent, par exemple E correspond au code condition Z = 1, mais leur interprtation est intuitive ; typiquement, la squence du type e e : CMP R1, R2 BGT cible branche si R1 > R2, lorsque R1 et R2 sont interprts comme des entiers relatifs. ee
63
BE BGT BLE BGTU BLEU BA BC BO
Egal Suprieur, sign e e Infrieur ou gal, sign e e e Suprieur, non sign e e Infrieur ou gal, non sign e e e Toujours (branchement inconditionnel Retenue (code condition C = 1) Overow (code condition O = 1)
Table 4.4: Mnmoniques des branchements conditionnels e
Branchements conditionnels sur registre gnral e e

Les architectures qui ne mmorisent pas les codes condition dans un RCC, mais dans des e registres gnraux, ont des instructions de branchement plus simples, du type e e Bcond Rd, deplacement qui branche si Rd vrie la condition. Cest le cas des architectures Alpha et MIPS. e Larchitecture MIPS propose une instruction de branchement-comparaison : BE/BNE Rd, Ra, deplacment, qui branche si Rd = Ra (resp si Rd = Ra).
Discussion
Les branchements conditionnels sur code-condition posent un probl`me de programmation, e et un probl`me decacit. e e Programmation : il faut pouvoir conserver la condition, cest a dire ne pas craser le ` e contenu de RCC par une opration arithmtique qui positionne les CC, ou par une e e nouvelle comparaison. Ecacit : on verra par la suite quavec le mod`le dexcution pipelin, les ruptures e e e e de squence sont potentiellement coteuses. e u Pour rsoudre le premier probl`me, les architectures ` RCC dnissent deux versions e e a e de chaque opration arithmtique, lune positionnant le RCC et lautre pas, comme on la e e vu pour le PowerPC. Les instructions qui ne positionnent pas le RCC sont massivement utilises par les compilateurs, en particulier pour les calculs dadresses. e En outre, dans larchitecture PowerPC, le registre code condition est dcompos en 8 e e champs de 4 bits (CR0 ` CR7) pour les comparaisons, ce qui revient a disposer de 8 sous a ` registres code condition. Enn, les instructions arithmtiques enti`res (ADD., ADDo.) ne e e positionnent que le champ CR0.
64
En revanche, dans larchitecture x86, qui utilise un RCC, toutes les instructions arithmtques e positionnent le RCC. Le jeu dinstruction contient donc des instructions spciques, qui e ne le positionnent pas : DEC, dcrmentation par une constante ; NEG, calcul de loppos e e e ; MOV, transfert. Ce probl`me nexiste pas dans les architectures ou les code-conditions sont mmoriss e e e dans un registre gnral, au prix de lutilisation dun registre gnral. Un avantage ime e e e portant est un moins grand nombre de branchement pour compiler les conditionnelles complexes (g. 4.12). (a) R10 cond1 R20 cond2 AND R30, R10, R20 BR R30 vrai ADD R3, R0, R2 BA suite vrai : ADD R3, R0, R1 suite : (b) evaluation cond1 Bcond faux evaluation cond2 Bcond faux ADD R3, R0, R1 BA suite faux :ADD R3, R0, R2 suite : ; ; ; ; si cond1 fausse cond1 vraie si cond2 fausse condition vraie, R3 R1
; R30 (cond1 et cond2) ; ; condition fausse, R3 R2 ; condition vraie, R3 R1 Suite du programme
; condition fausse, R3 R2 Suite du programme
Figure 4.12: Compilation de la conditionnelle complexe Si (cond1) et cond2) alors R3 = R1, sinon R3 = R2 (a) avec branchements sur registres (b) avec branchements sur RCC. Les deux techniques utilisent nammoins des branchements conditionnels pour implmenter e e linstruction conditionnelle. Les branchements conditionnels peuvent ralentir lexcution e des instructions dans les pipelines quutilisent les processeurs modernes. Certaines architectures logicielles orent donc des instructions de transfert conditionnel, ou instructions prdiques, qui permettent dviter lutilisation de branchement dans certains cas, et noe e e tamment pour lexemple ci-dessus. Soit le transfert conditionnel Mcond Rk, Ri, Rj ;
65
dni de la mani`re suivante: si Rk contient un boolen vrai, alors Rj est transfr dans e e e ee Ri, sinon instruction neutre. La conditionnelle Si R1 > R2, alors R3 = R1 sinon R3 = R2 se compile alors comme dans la g 4.13. Il ny a pas de rupture de squence : linstruction e MGT est quivalente a un NOP si la condition est fausse. e ` CMP R4,R1,R2 ADD R3,R0,R2 MGT R4,R3,R1 ; Positionne les codes conditions dans R4 ; Transfere R2 dans R3 ; Si condition vraie (R1>R2), transfere R1 dans R3
Figure 4.13: Utilisation du transfert conditionnel Les avantages potentiels des instructions prdiques sont considrables. Toutes les e e e conditionnelles peuvent se compiler sans rupture de squence, ` condition que toutes e a les instructions, qui peuvent potentiellement intervenir dans le bloc dinstructions conditionnes, puissent tre prdiques, et pas seulement une instruction de transfert. Ces avane e e e tages, en relation avec des techniques de compilation optimisantes, ont t tudis depuis eee e plusieurs annes, et larchitecture IA-64 dIntel propose un jeu dinstruction compl`tement e e prdiqu, aec 64 registres 1 bit pour abriter le prdicat. Le registre prdicat constitue alors e e e e un oprande supplmentaire e e Les instruction prdiques sont particuli`rement utiles pour dplacer des instructions. e e e e Touours pour lexemple du calcul dun maximum, avec un jeu dinstruction a RCC, on ` peut remplacer les codes de la g. 4.12 par celui de la g. 4.14 ADD R3, R0, R1 CMP R1, R2 BGT suite ADD R3, R0, R2 suite : ; ; ; ; ; 1 2 3 4 5 transfere le contenu de R1 dans R3 eectue R1 - R2 et positionne RCC Saute les deux instructions suivantes si R1>R2 transfere le contenu de R2 dans R3 Suite du programme
Figure 4.14: Code de la conditionnelle Si R1 > R2, alors R3 = R1 sinon R3 = R2 sur une architecture a RCC ` Lintrt de la transformation est dune part la diminution de la taille statique du ee code, ce qui est rarement important, et la suppression dun des deux branchements. Mais si linstruction dplace est susceptible de produire une exception - arithmtique ottante, e e e acc`s non align -, ou de modier ltat du processeur, par exemple en positionnant un e e e drapeau, ce mouvement est impossible : la smantique de la conditionnelle interdit que e la branche non prise puisse avoir un et quelconque. Or cest par exemple le cas pour le code si (R1 < R2) alors x = y sinon x = z
66
si y et z ne sont pas dja en registre : la lecture anticipe de y ou de z peut provoquer e e une exception dacc`s non align ou de protection. En revanche, une instruction prdique e e e e peut tre dplace sans contrainte, puisquelle nest pas excute si le prdicat est faux. e e e e e e En fait, une partie du probl`me nest que dplace : le compilateur a une tche plus facile, e e e a mais le concepteur de microprocesseur doit implmenter cette smantique dannulation, e e ce qui nest pas tr`s simple, comme on le verra par la suite. e
Boucles
Les instructions de boucle peuvent toujours tre implantes ` laide de linstruction cone e a ditionnelle. Il y a deux type de boucles : tant que (incluant faire n fois) et rpter. Leur e e schma de compilation est dcrit g. 4.15 : Dans le cas dune boucle faire, il est ncessaire e e e deb : Tant que test cond Bcond fausse suite code boucle BA deb ... Tant que optimis e BA test deb : code boucle test test cond Bcond vraie deb deb : Rpter e e code boucle test cond Bcond vraie deb
suite :
Figure 4.15: Schmas de compilation des boucles e de grer explicitement un compteur de boucles (nombre ditrations excutes) et de tester e e e e a ` chaque itration si le compteur a atteint la valeur correspondant au nombre ditrations e e a ` eectuer. Certaines architectures logicielles, comme par exemple le Power PC, orent une instruction de gestion de boucle. Essentiellement, il sagit dune version enrichie du branchement conditionnel. Un registre non gnral (registre compte-tour) est initialement charg avec e e e le nombre ditrations a eectuer. Linstruction e ` BCNT Ri, deplacement eectue les actions suivantes: Ri := Ri - 1 Si Ri = 0, CP := CP + deplacement sinon continuer en sequence. Cette instruction est utile pour les boucles for, plus prsentes dans le calcul numrique que e e dans les autres types de code. Larchitecture x86 ore une instruction analogue, LOOP.
4.8
Sous-programmes
Fonctionnalits e
Les sous-programmes sont des units de code indpendantes, fonctions et procdures. e e e Les fonctionnalits ncessaires ` lappel de procdure sont (g. 4.16)) : e e a e
4.8. Sous-programmes
67
Call ProcA adresse retour Ret Call ProcA adresse retour
Figure 4.16: Appel et retour de sous-programme Appel : Branchement ` une adresse. a Retour : Branchement ` linstruction qui suit linstruction dappel. Ladresse de a cette instruction est appele adresse de retour dans la suite. Cest ncessairement e e un branchement absolu (PC adresse), et non relatif (PC PC + dplacement), e car ladresse de retour nest pas connue avant lexcution. e Passage des param`tres : Un sous-programme doit pouvoir se voir passer des argue ments et ventuellement retourner une valeur. e Sauvegarde et restauration du contexte : annuler toute modication de ltat du e processeur due ` lappel. a Il est important de prciser les contraintes pesant sur ces fonctionnalits. e e Compilation spare. Les sous-programmes peuvent tre compils sparment, puis e e e e e e lis ensembles pour constituer un programme. Larchitecture logicielle doit donc e fournir un support pour une situation o` la porte de vision du compilateur est u e limite e Appels embo es. Un sous-programme en appelle dautres ; le niveau dembo t tement nest pas connu a la compilation (rcursivit). Un sous programme qui nen appelle ` e e pas dautre est dit terminal. Les fonctionnalits ci-dessus sont supports partiellement en matriel, partiellement e e e par des conventions logicielles. Toutes les architectures orent un support spcialis e e pour lappel de sous-programme. Pour les trois autres points, la proportion de logiciel et de matriel est variable. Cette section prsentera donc plus dexemples que de principe e e gnraux. e e Il existe cependant une caractristique commune des architectures RISC : elles privilgient e e le cas des sous-programmes terminaux qui passent peu de param`tres. La raison est e
68 Architecture SPARC
Chapitre 4. Architecture logicielle du processeur Syntaxe CALL Dep30 JMPL Ra, Dep13 , Rd JMPL Ra, Rb, Rd BL Dep24 BLA Dep24 BLR BLRL Signication R15 PC ; PC PC + ES (Dep30 *4) Rd PC ; PC Ra + ES (Dep13 *4) Rd PC ; PC Ra + Rb LR PC ; PC PC + ES (Dep24 *4) LR PC ; PC ES (Dep24 *4) PC LR PC LR
Power PC
Table 4.5: Instructions dappel et retour de sous-programme que ceux-ci sont nettement plus frquents que les autres [2]. Privilgier signie que e e larchitecture est organise pour accler lexcution de type de sous-programmes, tout e e e en orant le support ncessaire ` lexcution des sous-programmes plus complexes. e a e
Appel et retour de sous-programme

Fonctionnalits e Lappel et le retour de sous-programme signient une modication du registre compteur de programme : Appel : PC adresse sous-programme Retour : PC adresse de retour Les procdures sont appeles ` partir de nimporte quelle partie dun programme. Pour e e a que le programme appelant puisse continuer son excution apr`s la n dexcution de la e e e procdure, il est ncessaire que linstruction dappel, avant de modier PC, sauvegarde e e ladresse de retour. En outre, lemplacement de cette sauvegarde doit tre connu de e lappele. On a donc deux pseudo-instructions fondamentales : e CALL dep : sauvegarde PC; PC dep RET PC sauvegarde Laction sauvegarde PC ne correspond a aucune instruction dj` vue. Dautre part, ` ea elle na dutilit que pour les appels de procdure. La pseudo-instruction CALL est donc e e implmente dans tous les jeux dinstructions comme une instruction spcique, dirente e e e e des branchements. En revanche, le positionnement de PC est par dnition un saut ou un e branchement. La pseudo instruction RET peut donc tre implmente sans instruction e e e nouvelle.
4.8. Sous-programmes Architectures Chargement-Rangement
69
Ladresse de retour est toujours range dans un registre. Cest, soit dans un registre e gnral (SPARC, MIPS, Alpha), ou bien un registre particulier, nomm LR comme Link e e e Register (Power PC) (table. 4.5). Comme les instructions sont alignes (4 octets), les e deux zros naux des adresses absolues (CALL, BLA) ou relatives (JMPL, BL) ne sont e pas stocks, ce qui permet, ` format constant, de multiplier par 4 la porte des appels. e a e Exemple du SPARC Larchitecture SPARC propose deux instructions dappel, CALL et JMPL. Comme les instructions sont alignes (4 octets), linstruction CALL permet datteindre toute la e mmoire (sur 32 bits). CALL sauvegarde ladresse de retour dans le registre R15. JMPL e sauvegarde dans un registre quelconque, mais limite lamplitude du branchement a 213 ` instructions. Rappelons que larchitecture SPARC ne propose que des branchements du type PC PC + ES(dep22 ). Les branchements ne sont donc pas utilisables pour le retour, car ladresse de retour varie suivant lappel ; elle ne peut pas tre encode dans linstruction. e e La squence typique dappel/retour devrait donc tre e e CALL myproc JMPL R15, 0, R0 ; R0 cable a 0, donc le seul eet est PC R15 (en fait, linstruction est JMPL R15, 8, R0, pour des raisons quon verra dans le chapitre Pipeline) Linstruction CALL myproc peut tre remplace par une instruction du type JMPL e e Ra, Rb ou dep, Rd, le retour tant alors JMPL Rd, 0, R0. Il faut alors une convention e logicielle pour le choix de Rd. Une convention logicielle est un ensemble de contraintes sur ltat du processeur, en e particulier lutilisation des registres, du type la cl est sous le troisi`me pot de eurs. Ici, e e la convention prcisera que le registre destination est toujours, par exemple, R28. Ainsi, e un sous-programme compil sparment a la garantie que lappelante a laiss ladresse de e e e e retour (la cl) dans le registre R28 (le troisi`me pot de eurs). Ces contraintes doivent tre e e e respectes par tous les codes susceptibles dtre intgrs avec dautres, en particulier ceux e e e e cres par un compilateur. En revanche, la convention na pas a tre repecte par un code e `e e destin ` tre excut isolment (stand-alone), par exemple un programme assembleur e a e e e e exercice. Exemple du POWER PC La squence dappel-retour est simplement : e BL ou BLA myfunc BLR CISC Ladresse de retour est range en mmoire, via une pile mmoire. Dans larchitecture x86, e e e le pointeur de pile est un registre spcialis appel SP (stack pointer) ; on dispose des e e e
70
instructions CALL et RET: CALL val ; Empiler (PC) ; PC nouveau PC. Ladresse peut tre absolue ou relative. Le mode dadressage peut tre registre, immdiat e e e ou indirect. Empiler PC signie SP SP - 4, puis Mem [SP] PC. e RET imm16 ; dpiler (PC); SP SP + imm16 octets. Dpiler PC signie PC Mem[SP], puis SP SP + 4. e Lappel/retour simplmente donc par la paire CALL/RET. Chaque appel et chaque e retour de sous-programme implique un acc`s mmoire. e e
Passage des param`tres e

Le passage des param`tres de lappelante vers lappele et le retour dune valeur peut e e deectuer, soit par les registres du processeur, soit par la mmoire. Dans la plupart des e cas, le nombre de param`tres ` passer est rduit, et le passage peut se faire simplement e a e par les registres : lappelante crit, par exemple le registre R5 ; lappele doit savoir que e e le param`tre se trouve dans R5. La compilation spare requiert une convention logicielle e e e qui dcrit lassociation param`tres-registre. e e Ce nest que pour les procdures avec un grand nombre de param`tres que les param`tres e e e en excdent par rapport aux registres disponibles sont passs par la mmoire. e e e Conventions logicielles Pour le MIPS, la convention est dutiliser les registres R4 a R7, dans lordre des param`tres. ` e Ceci autorise donc ` passer par registre jusqu` 4 param`tres. a a e Pour le Power PC, la convention est dutiliser R3 a R10. Ceci autorise donc ` passer ` a par registre jusqu` 8 param`tres. a e Support matriel e Larchitecture SPARC ore un support matriel supplmentaire pour le passage des e e param`tres : le multifentrage. Les 32 registres gnraux sont spcialiss (g. 4.17) en e e e e e e 8 registres globaux (nots g0-g7), 8 registres de sortie (nots o0-07), 8 registres locaux e e (l0-l7) et 8 registres dentre (i0-i7). e Larchitecture SPARC dnit une certain nombre (2 a 8) de fentres de 24 registres. e ` e Les direntes fentres sont recouvrantes, comme dcrit dans la g. 4.18. Une fentre na e e e e en propre que ses registres locaux. Ses registres dentre sont les registres de sortie de la e fentre prcdente, et ses registres de sortie sont les registres dentre de la fentre suivante. e e e e e Dautre part, les registres globaux sont partags par toutes les fen`tres. Ainsi, chaque e e procdure voit 32 registres, mais le nombre de registres physiques est plus lev. Enn, e e e lensemble de fentres est gr comme une pile. La commutation de fen`tre seectue par e ee e deux instructions : SAVE et RESTORE. SAVE dcrmente le pointeur de pile, RESTORE e e lincrmente. e
4.8. Sous-programmes Numro e r31 r30 r29 ... r24 r23 ... r16 r15 r14 r13 ... r8 r7 ... r1 r0 Nom i7 = return ad i6 = fp i5 ... i0 l7 ... l0 07 = tmp 06 = sp 05 ... O0 g7 ... g1 0
71
Figure 4.17: Registres Sparc
Le passage de param`tres et la rcupration des rsultats se fait donc de mani`re e e e e e simple, par le recouvrement entre sortie de fentre appelante et entre de fentre appele. e e e e Les param`tres sont crits par lappelante dans ses registres O0-07. Lappele trouve e e e ses dans les registres i0-i7, et une fonction retourne son rsultat dans le registre O0 de e lappelante. Les param`tres sont crits par lappelante dans ses registres de sortie, et la e e valeur de retour est crite par lappele dans i0. e e Il faut bien noter que lappel de procdure en lui mme (CALL ou JMPL) neectue e e aucune commutation de fen`tre. Cest donc ` la procdure appele de dclencher cette e a e e e commutation au de but de la procdure. Une procdure non terminale commence par une e e instruction SAVE et se termine par une instruction RESTORE. Une procdure terminale e nest pas compile en utilisant le mcanisme de fentrage, mais une convention logicielle e e e analogue aux cas prcdents. e e Enn, si la pile dborde, la fen`tre ` craser est sauvegarde en mmoire avant la e e a e e e commutation, et lv`nement de dbordement est mmoris. Ainsi, lors du dpilement, la e e e e e e fen`tre sauvegarde sera restaure. e e e
72
Appelante i7 i6 i0 l7 l6 l0 o7 o6 o0
Appele i7 i6 i0 l7 l6 l0 o7 o6 o0
Recouvrement
Figure 4.18: Recouvrement des fenetres SPARC
Pile dexcution e
Principe Lappel de procdure est un mcanisme dynamique, cest ` dire non prvisible ` la compie e a e a lation : lors de la compilation spare dune procdure, le compilateur ne peut pas savoir e e e dans quel contexte cette procdure sera appele. Il est donc tr`s souhaitable que les varie e e ables locales de la procdure puissent tre adresses de faon indpendante du contexte e e e c e dexcution. Cest ce que ralise le mcanisme appel pile dexcution. e e e e e La g. 4.19 montre le principe du mcanisme de pile dexcution. Chaque souse e programme dispose dune zone mmoire correspondant a ses variables locales. Le sommet e ` de la pile est toujours repr par une registe appel SP (stack pointer). Le dbut de la ee e e zone des donnes de la procdure courante est souvent repre par un registre appel frame e e ee e pointer (FP). Les variables sont donc adresses en base + dplacement : SP + dlacement e e e positif, ou FP + dplacement ngatif. e e Le calcul de la taille de cette zone est ralis ` la compilation a partir des dclarations e ea ` e de variables. Le compilateur, au dbut dune la procdure, alloue la mmoire ncessaire, en e e e e dcrmentant SP du nombre doctets adquat Dans les machines RISC, SP est un registre e e e gnral : par exemple, pour larchitecture SPARC, SP = O6. e e Le mcanisme de commutation de fentre du SPARC ore galement un support e e e matriel ` la pile dexcution. Dune part, lancien registre SP (O6) devient automae a e
73
SP
SP
FP
FP
zone de travail de lappelante
zone de travail de lappele
Figure 4.19: Principe de la pile dexcution e
tiquement le nouveau registre FP (i6). Dautre part, les instructions SAVE et RESTORE ont des fonctionnalits plus riches que la simple commutation de fen`tres ; leur dnition e e e compl`te est : e
SAVE Ra, Rb/Imm13 , Rd tmp Ra + (Rb ou ES (Imm13 ) CWP CWP -1 Rd tmp RESTORE Ra, Rb/Imm13 , Rd tmp Ra + (Rb ou ES (Imm13 ) CWP CWP +1 Rd tmp
Il faut noter que laddition se faisant avant la commutation de contexte, ce sont les valeurs des registres de lancienne fentre qui sont lus. Lcriture du rsultat se faisant apr`s la e e e e commutation de fentre, le registre aect est celui du nouveau contexte. e e Dans larchitecture x86, SP est un registre spcialis: linstruction PUSH oprande e e e empile loprande et dcrmente SP, linstruction POP destination dpile et incrmente e e e e e SP.
74
Sauvegarde du contexte
Le contexte dexcution dune procdure dcrit ltat du processeur et de la mmoire. Il e e e e e comprend en particulier : les registres gnraux ; e e ladresse de retour dans lappelante ; ltat de ses variables. e Les variables sont sauvegardes par le mcanisme de pile dexcution. e e e Sauvegarde des registres gnraux e e Sauf a tre vide, un sous-programme utilise les registres gnraux. Ces registres pouvaient `e e e contenir a lappel une valeur qui restera utile appr`s le retour du sous-programme. Donc, ` e si celui-ci modie le registre, il doit le sauvegarder a lentre et le restaurer avant de ` e retourner. Pour limiter le nombre de sauvegardes, il existe en gnral une convention logicielle, e e qui partage la sauvegarde entre appelante et appele. Par exemple, dans le MIPS, les e registres R8-R15, R24 et R25 sont en principe rservs ` des valeurs temporaires, dont e e a la dure de vie ne stend pas au del` des appels de procdure, alors que les registres e e a e R16-R23 sont rervs ` des valeurs longue dure. La sauvegarde ventuelle des regsitres e a e e destins aux valeurs temporaires est ` la charge de lappelante, celle des registres destins e a e aux valeurs longue duree est ` la charge de lappele. On a une convention analogue sur e a e le Power PC. Dans le cas du SPARC, le mcanisme de fentrage limite les sauvegardes ncessaires, e e e puisque chaque procdure dispose de 8 registres privs, les registre l0-l7. En revanche, e e les registres I0-I7 de lappele doivent tre sauvegards sils sont utiliss, puisquils sont e e e e en fait les registres O0-O7 de lappelante. La seule exception est le registre I0 lorsque lappele est une fonction : la valeur de retour y est place. e e Adresse de retour Lutilisation dun registre particulier pour ranger ladresse de retour nest susant que pour les procdures terminales : les appels successifs crasent le contenu de lunique registre e e de sauvegarde. Pour pouvoir excuter correctement des procdures non terminales, il existe deux soe e lutions : soit disposer de plusieurs registres dirents pour ranger les adresses de retour ; e soit sauvegarder ladresse de retour en mmoire avant dappeler une nouvelle procdure et e e la restituer lors du retour. Quel que soit le nombre de registres disponibles pour ranger les adresses de retour, il est vident que la seconde solution est toujours indispensable lorsque e le nombre dappels successifs de procdures imbriques dpasse le nombre de registres e e e disponibles.
75
int myfunc (int k) { return (k+1); } void init (int tab [], int i , int j) { int k ; for (k = i ; k < j ; k++) tab [k] = myfunc (k); } void main(void) { int tab [100]; init (tab, 2, 10); printf (%d, tab [4]); } Figure 4.20: Exemple dappels de procdure en C e Larchitecture sparc rend ce passage par la mmoire inutile : ladresse de retour est e sauvegarde dans R15, mais celui-ci est identique ` O7 (cf g. 4.17). Donc, la commutation e a de fentre ore un registre R15 frais pour la sauvegarde, et ladresse de retour appara e t dans i7 !
Etude de cas
Pour illustrer ce qui prc`de, on tudie en dtail la compilation dun petit programme (g. e e e e 4.8), qui contient deux appels de sous-programme, lun non terminal, et lautre terminal. Power PC Le dsassemblage du code rsultant de la compilation spare des trois routines C est e e e e dcrit g. 4.21 e Appel et retour : init et myfunc sont appels par bl (instructions main 7 et init 13). Tous e les retours (main 15 , init 25, myfunc 2) se font par blr. Un dcodage prcis des instructions bl montre que le dplacement est 0 : comme les e e e routines sont compiles sparment, ladresse de branchement nest pas encore calcule (cf e e e e partie Edition de liens). Passage des param`tres Les instructions 4, 5 et 6 de main chargent respectivement dans e R3, R4 et R5 les param`tres de lappel de init (&tab[0], 2 et 10). Dans init, avant lappel e de myfunc, R3 est positionn avec la valeur courante de k contenue dans R31 (init 12). e
76
myfunc retourne son rsultat dans R3, qui est utilis comme argument du rangement e e (init 15). Le param`tre tab est pass par rfrence : la routine init ne conna que R3, qui est e e ee t @tab[0]. Les param`tres entiers sont passs par valeur. e e Pile dexcution Les instruction STWU SP, -n(SP) assurent en mme temps lallocation e e mmoire de la zone de travail de la procdure, et la sauvegarde du pointeur de pile. En e e eet, STWU est un rangement en mode dadressage post-incrment. La variable tab e e du main est adresse en mode base + dplacement (main 4). Comme tab est pass par e e e rfrence, la procdure init modie ltat de la pile dexcution de lappelant (init 15). ee e e e Les instructions main 13 et init 20 dsallouent la zone de la procdure qui se termine en e e modiant SP. La fonction myfunc, qui est terminale, ne dclare pas de variable, et na rien e a ` sauvegarder, nalloue pas de zone de travail. Sauvegarde et restauration du contexte Ladresse de retour est sauvegarde en deux e tapes : mr (Move From Link Register) transf`re le contenu de LR vers R0, qui nest e e pas cbl ` 0. Ensuite, une instruction de rangement sauvegarde ladresse de retour en a ea mmoire, dailleurs dans la zone de travail de lappelante. La restauration est en miroir. e Le transfert entre LR et mmoire doit se faire par lintermdiaire dun registre gnral, car e e e e il nexiste pas dinstruction de transfert entre LR et la mmoire. Une procdure terminale e e se dispense de cette sauvegarde, qui lui serait inutile. Le pointeur de pile SP est sauvegard en mme temps que la zone de travail est alloue. e e e Le procdure init a besoin des registres de travail R29, 30 et 31. Elle les sauvegarde e donc avant de les modier, puis les restaure a la n. la procdure main, qui neectue ` e aucun calcul, ne sauvegarde aucun regsitre de travail. SPARC Le dsassemblage du code rsultant de la compilation spare des trois routines C est e e e e dcrit g. 4.22 e Linstruction jump adresse est une instruction synthtique (ie plus lisible) pour linstruction e jmpl adresse R0. Linstruction synthtique ret quivaut a JMPL R31, 8,R0. De mme, e e ` e linstruction synthtique RESTORE quivaut a RESTORE R0, R0, R0, cest a dire a une e e ` ` ` commutation retour de fentre. e Le code SPARC prsente une particularit, qui sera explique dans le chapitre pipeline e e e : les branchements retards. Toute squence e e Instruction de branchement Instruction A Instruction B a la smantique squentielle : e e Instruction A Instruction de branchement Instruction B
77
Linstruction qui suit syntaxiquement le branchement est excute avant que le branchee e ment prenne eet. Appel et retour Tous les appels utilisent linstruction CALL. Comme pour le code Power PC, les adresses ne sont pas rsolues. e Pour le retour, la fonction myinit est terminale ; il ny a pas de commutation de fentre, e donc myinit partage la fentre de lappelante, et trouve ladresse de retour dans R15 (o7). e Les autres fonctions commencent par une commutation, et trouvent donc ladresse de retour dans R31. Passage de param`tres La procdure main positionne o0, o1 et o2, que la procdure init e e e trouve dans i0, i1 et i2. En revanche, myfunc, au lieu de chercher son param`tre dentre e e et retourner son rsultat dans i0, utilise o0. Ainsi, pour lappelante, le fait que myfunc soit e terminale ou non na pas besoin dtre connu, ce qui est indispensable pour la compilation e spare : init passe son param`tre et retrouve son rsultat dans o0. e e e e
Edition de liens et chargement dun programme

On se limite dans cette section ` un contexte UNIX. a Introduction Le passage dun programme crit en LHN vers un programme qui sexcute comprend e e trois tapes. e Compilation : dun chier LHN vers un chier relogeable. Par exemple, les chiers main.o, init.o, myfunc.o sont produits par la commande gcc -O3 -c main.c init.c myfunc.c Edition de lien : dun ensemble de chiers objets vers un chier excutable (ld comme e Link eDitor). Par exemple, lexcutable prog est produit par e ld -o prog main.o init.o myfunc.o Chargement : Copie de lexcutable en mmoire : les sections du chier excutable correspone e e dant au code sont places dans des pages mmoire avec droits de lecture et e e dexcution, les sections correspondant aux donnes dans des pages avec droit e e de lecture/criture. e Passage des arguments de la ligne de commande (= param`tres du main) si e ncessaire. e Positionnement de PC et du pointeur de pile. La dirence qualitative entre un relogeable et un excutable est le traitement des e e rfrences absolues (variables non locales, adresse des instructions etc.) et des variable et ee
78
procdures non visibles en compilation spare. Dans un relogeable, seules les rfrences e e e ee relatives et visibles sont rsolues : branchements relatifs, variables locales. Les rfrences e ee absolues ou inconnues sont laisses en attente. Dans un excutable, instructions et donnes e e e ont toutes une adresse et toutes les rfrences sont rsolues. ee e La g. 4.23 montre le dsassemblage de lexcutable prog. Les adresses des instruce e tions sont xes (premi`re colonne) ; les sous-programmes sont dans un mme rfrentiel e e e ee mmoire. A partir de cette information, lditeur de liens peut calculer les adresses de e e branchement pour les appels de sous-programme call : la premi`re instruction call est 7f e fA, soit un branchement a PC - (6 inst), cest ` dire myfunc ; la deuxi`me instruction ` a e call est 7f f0, soit un branchement a PC - (16 inst), cest ` dire init. ` a Format dun chier objet Sous Unix, le format actuel est le format ELF (Executable and Linking Format), qui unie les trois types dobjet [12]. Comme les chiers objet participent a ldition de lien ` e (construction dun programme) et a lexcution dun programme, ce format fournit deux ` e vues parall`les du contenu dun chier (g. 4.24). e Len-tte (header), dcrit lorganisation du chier (emplacements des sections/segments) e e et les informations globales sur le type de chier objet (relogeable, excutable, shared, e core). Les sections sont contigues et disjointes, ventuellement vides. Chacune dentre elles e contient un certain type dinformation sur le programme. La table 4.6 prsente les sections e les plus frquentes ; le format en prvoit dautre, ainsi que la possibilit den dnir. e e e e Nom .bss .data .ni .init .rel<name> .symtab .strtab .text Description Donnes non intialises e e Donnes initialises e e Instructions excutes apr`s la n du programme utilisateur e e e Instructions excutes avant lentre dans le programme utilisateur e e e Informations de relocation pour la section name Table des symboles (voir ci-dessous) Table de cha nes de caract`res e Les instructions du programme utilisateur Table 4.6: Quelques sections dun programme objet La table des symboles contient une entre pour toutes les dnitions et rfrences e e ee mmoire symboliques. Chaque entre contient cinq champs : e e st name : un index dans la strtab ; lentre correspondante contient une chaine de e caract`re qui dcrit le symbole. e e
79
st value : essentiellement, ladresse qui contient la valeur du symbole. Dans un relogeable, cest le dplacement par rapport au dbut de la section. Dans un excutable e e e ou un shared, cest ladresse mmoire. e st size : la taille du symbole en octets st info : la porte du symbole, ` ldition de lien. Un symbole local nest visible e a e qu` lintrieur du chier qui le dnit ; des symboles locaux de mme nom peuvent a e e e exister dans plusieurs chiers sans conit. Un symbole global est visible de tous les chiers a ldition de lien, et peut ainsi satifaire les rfrences encore non dnies ` e ee e dun autre chier. un symbole faible (weak) est intermdiaire : il se comporte comme e un symbole global, mais un symbole global de mme nom aura la prcdence. e e e La relocation consiste ` mettre en relation des rfrences symboliques avec leurs dnitions. a ee e Par exemple, la section de relocation de init.o contient les champs suivants : Oset Symndx Type Addend 0x10 myfunc R SPARC WDISP30 0 qui signient que le symbole myfunc, qui est rfrenc ` ladresse 0x10 (cf g 4.22) est ee e a un dplacement destin ` un call pour larchitecture SPARC. Pour les chiers relogeables, e ea cette information est exploite ` ldition de liens, pour transformer les rfrences symbole a e ee iques en adresses mmoire, pas ncessairement absolues. Par exemple, lditeurs de liens e e e rsoudra la rfrence myfunc en la mettant en relation avec sa dnition dans le chier e ee e myfunc.o, et la relogera ainsi. La relocation compre,d donc deux tapes : e le parcours de la tables des symboles des chiers lis permet de rsoudre les symboles e e non dnis (U) ; e les rfrences mmoires symboliques sont values grce ` la section de relocation. ee e e e a a Librairies partages e Outre les chiers relogeables et excutables, il existe un troisi`me type de chier binaire e e dcrivant un programme : les chiers objets partags. Ils contiennent un code et des e e donnes utilisables ` la fois a ldition de lien et a lexcution e a ` e ` e Les chiers relogeables peuvent tre regroups sous forme de librairies, et lis statiquee e e ment ` dautres chiers relogeables pour former un excutable. Dans ce cas, une copie des a e chiers qui satisfont les rfrences non encore rsolues est incorpore dans lexcutable. ee e e e Tout se passe comme si tous les chiers avaient t compils simultanment. La taille ee e e de lexcutable est donc la somme de la taille des composantes, et lexcutable doit tre e e e relink si larchive est modie. e e Une solution intermdiaire entre lexcutable et le relogeoble est la librairie partage et e e e la liaison dynamique (dynamic linking). Les fonctions et procedures utiles sont compiles e et regroupes en un objet partag aussi appel librairie dynamique. Lobjet partag a les e e e e
80
caractristiques dun excutable, en particulier toutes les rfrences internes sont rsolues e e ee e et les rfrences rsolues sont reloges. Lobjet partag est inclus dans lespace mmoire du ee e e e e programme ` lexcution, et cest cette opration qui est appele liaison dynamique. Cest a e e e la fonction dune dition de lien, mais a lexcution : les rfrences externes du programme e ` e ee qui font appel a la librairie partage sont rsolues et reloges ` lexcution. ` e e e a e Il y a deux avantages a la liaison dynamique. ` La possibilit de faire voluer le code sans relinker ; la plupart des librairies standard e e sont maintenant partage, et la liaison dynamique est le comportement par dfaut e e lorsquil existe une version statique et une version dynamique dun librairie. Lconomie dencombrement disque, et la possibilit de partager le code, y compris e e en mmoire, do` conomie dencombrement mmoire. La librairie partage nest e u e e e pas copie dans lexcutable ` ldition de lien. Seules quelques informations de e e a e rsolution sont enregistre. Ainsi, le a.out de chacun ne contient pas une copie du e e code de printf ! En outre, lobjet partag, sil ne requiert pas de modication, peut e tre partag entre plusieurs utilisateurs en mmoire. e e e Que se passe-t-il ` ldition de lien dynamique ? Essentiellement, le code partag est inclus a e e (mapp) dans lespace mmoire de lexcutable qui lappelle. Les rfrences externes de e e e ee lexcutable sont rsolues et reloges. Bien videmment, une librairie partage peut en e e e e e appleler une autre, limage mmoire du programme se construit donc progressivement e et non pas en une seule tape comme au chargement dun excutable construit par lien e e statique. Un objet partag est typiquement compil pour que le code ne dpende pas de sa e e e position. En particulier, il est souhaitable quaucune adresse absolue ny gure, donc que les branchements soient relatifs. Lobjet partag peut alors appara a des adresses e tre ` direntes vu de dirents processus, tout en nexistant qu` un exmplaire en mmoire. e e a e En revanche, si le code contient des adresses absolues, il peut tre utilis en dition de e e e lien dynamique, mais perd lavantage du partage. Chaque processus recoit alors une copie prive du code, o` ldition de lien dynamique aura relog les adresses abolues ` la vole, e u e e a e cest ` dire modi le code dune faon dpendante de chaque processus excutant. Il en a e c e e va de mme si la librairie partage contient des donnes adresses en absolu. e e e e
Quelques utilitaires
On peut visualiser de faon dtaille le code produit par un compilateur et/ou un diteur c e e e de liens grce ` la commande dis : a a dis fichier : dsassemble la section .text e avec ad mmoire, code hexadcimal et assembleur. e e On peut visualiser lensemble des sections dun ELF avec la commande dump. Les options prcisent les sections et le formattage, en particulier -r pour les informations de e relocation. On peut visualiser la table des symboles avec la commande nm
; myfunc 1 00000000 : 2 00000004 : init 1 00000000 : 2 00000004 : 3 00000008 : 4 0000000C : 5 00000010 : 6 00000014 : 7 00000018 : 8 0000001C : 9 00000020 : 10 00000024 : 11 00000028 : 12 0000002C : 13 00000030 : 14 00000034 : 15 00000038 : 16 0000003C : 17 00000040 : 18 00000044 : 19 00000048 : 20 0000004C : 21 00000050 : 22 00000054 : 23 00000058 : 24 0000005C : 25 00000060 : ; main 1 00000000 : 2 00000004 : 3 00000008 : 4 0000000C : 5 00000010 : 6 00000014 : 7 00000018 : 8 0000001C : 9 00000020 : 10 00000024 : 11 00000028 : 12 0000002C : 13 00000030 : 14 00000034 : 15 00000038 :
81
38630001 4E800020 7C0802A6 93E1FFFC 93C1FFF8 93A1FFF4 90010008 9421FFB0 7C7D1B78 9081006C 7CBE2B78 83E1006C 48000018 7FE3FB78 48000001 57E4103A 7C7D212E 3BFF0001 7C1FF000 4180FFE8 80010058 38210050 7C0803A6 83E1FFFC 83C1FFF8 83A1FFF4 4E800020 7C0802A6 90010008 9421FE30 38610038 38800002 38A0000A 48000001 38620000 80810048 48000001 0000000 800101D8 382101D0 7C0803A6 4E800020
addi blr mr stw stw stw stw stwu mr stw mr lwz b mr bl slwi stwx addi cmpw blt lwz addi mtlr lwz lwz lwz blr mr stw stwu addi li li bl addi lwz bl nop lwz addi mtlr blr
r3,r3,1
; R3 k + 1 ; retour ; debut sauvegarde adresse retour ; sauvegarde contexte registre
r0 r31,-4(SP) r30,-8(SP) r29,-12(SP) r0,8(SP) SP,-80(SP) r29,r3 r4,108(SP) r30,r5 r31,108(SP) *+24 r3,r31 .myfunc r4,r31,2 r3,r29,r4 r31,r31,1 r31,r30 *-24 r0,88(SP) SP,SP,80 r0 r31,-4(SP) r30,-8(SP) r29,-12(SP)
; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;
n sauvegarde adresse retour allocation pile dexcution e copie R3 dans registre de travail sauvegarde deuxi`me param`tre e e copie 3eme parametre dans R30 copie 2eme param`tre dans R31 e 00000040 ; sauter au test de boucle passage du param`tre k ` myfunc e a appel myfunc R4 R31*4 (shift left) tab [k] R3 k k+1 test sortie boucle branchement a inst 12 0000002C ` debut restauration adresse retour dsallocation de la zone de travail e n restauration adresse retour restauration du contexte registres
; retour r0 r0,8(SP) SP,-464(SP) r3,SP,56 r4,2 r5,10 .init r3,RTOC,@643 r4,72(SP) .printf r0,472(SP) SP,SP,464 r0
; R3 @tab[0] ; R4 premier param. ; R5 premier param. appel init
Figure 4.21: Code PPC des sous-programmes exemples. La premi`re colonne est le e numro de linstruction ; la deuxi`me son dplacement par rapport au dbut du souse e e e programme ; la troisi`me le code hexadcimal de linstruction ; la quatri`me le code en e e e langage dassemblage.
82
myfunc() 0: 81 c3 e0 08 4: 90 02 20 01 init() 0: 9d e3 bf 90 4: 80 a6 40 1a 8: 16 80 00 09 c: 01 00 00 00 10: 40 00 00 00 14: 90 10 00 19 18: 93 2e 60 02 1c: b2 06 60 01 20: 80 a6 40 1a 24: 06 bf fb 28: d0 26 00 09 2c: 81 c7 e0 08 30: 81 e8 00 00 main() 0: 9d e3 be 00 4: 90 07 be 60 8: 92 10 20 02 c: 40 00 00 00 10: 94 10 20 0a 14: d2 07 be 70 18: 11 00 00 00 1c: 40 00 00 00 20: 90 12 20 00 24: 81 c7 e0 08 28: 81 e8 00 00
jmp add save cmp bge nop call mov sll add cmp bl st ret restore save add mov call mov ld sethi call or ret restore
%o7 + 8 %o0, 1, %o0 %sp, -112, %sp %i1, %i2 0x2c 0x10 %i1, %o0 %i1, 2, %o1 %i1, 1,%i1 %i1, %i2 0x10 %o0, [%i0 + %o1]
; retour ; calcul de k+1 ; ; ; ; ; ; ; ; ; ; ; ; ; commutation fentre e test i j j
appel myfunc passage de k ` myfunc a o1 k*4 k k+1 test sortie de boucle branchement dbut de boucle e tab[k] o0 branchement retour commutation fentre e
%sp, -512, %sp %fp, -416, %o0 2,%o1 0xc 10, %o2 [%fp - 400], %o1 %hi(0x0), %o0 0x1c %o0, 0, %o0
Figure 4.22: Code SPARC des sous-programmes exemples. Compil avec gcc, options -03 e -S -c. La premi`re colonne est le dplacement par rapport au dbut du sous-programme e e e ; la deuxi`me le code hexadcimal de linstruction ; la troisi`me le code en langage e e e dassemblage.
myfunc 10800 : 10804 : init 10808 : 1080c : 10810 : 10814 : 10818 : 1081c : 10820 : 10824 : 10828 : 1082c : 10830 : 10834 : 10838 : main 1083c : 10840 : 10844 : 10848 : 1084c : 10850 : 10854 : 10858 : 1085c : 10860 : 10864 :
83
81 c3 e0 08 90 02 20 01 9d e3 bf 90 80 a6 40 1a 16 80 00 09 01 00 00 00 7f fa 90 10 00 19 93 2e 60 02 b2 06 60 01 80 a6 40 1a 06 bf fb d0 26 00 09 81 c7 e0 08 81 e8 00 00 9d e3 be 00 90 07 be 60 92 10 20 02 7f f0 94 10 20 0a d2 07 be 70 11 00 00 44 40 00 43 5b 90 12 23 a0 81 c7 e0 08 81 e8 00 00
jmp add save cmp bge nop call mov sll add cmp bl st ret restore save add mov call mov ld sethi call or ret restore
%o7 + 8 %o0, 1, %o0 %sp, -112, %sp %i1, %i2 0x10834 gcc2 compiled. %i1, %o0 %i1, 2, %o1 %i1, 1, %i1 %i1, %i2 0x10818 %o0, [%i0 + %o1]
%sp, -512, %sp %fp, -416, %o0 2, %o1 gcc2 compiled. 10, %o2 [%fp - 400], %o1 %hi(0x11000), %o0 printf@@SYSVABI 1.3 %o0, 928, %o0
Figure 4.23: Code excutable SPARC. e

En-tte Table den-tte de programme Section 1 Section n Table des en-ttes de section En-tte Table den-tte de programme Segment 1 Segment n Table des en-ttes de section
Figure 4.24: Format dun chier ELF
84
Bibliographie
[1] D. Patterson, J. Hennessy. Organisation et conception des ordinateurs. Dunod 94 Traduction de Computer Organization and Design : The Harware/Software Interface, Morgan-Kauman 94. [2] J. Hennessy, D. Patterson. Architecture des ordinateurs : une approche quantitative, Deuxi`me dition. Thompson Publishing France, 96. Traduction de Computer Archie e tecture. A Quantitative Approach. McGrawHill 96 [3] D. Etiemble. Architecture des microprocesseurs RISC. Dunod, collection A2I, 92 [4] IEEE Transactions on Computers. Octobre 96. [5] D.Patterson et al. A case for intelligent RAM : IRAM. IEEE Micro. Avril 97. [6] V. Cuppu et al. A Performance comparison of contemporary DRAM architectures. Proc. 26th ISCA. Mai 99. [7] http://www.asc-inc.com/ascii.html [8] http://unicode.org [9] ARIANE 5 Flight 501 Failure, Report by the Inquiry http://www.esrin.esa.it/htdocs/tidc/Press/Press96/ariane5rep.html [10] D. Etiemble. Fondements du matriel. Polycopi de Licence dInformatique. e e [11] D. Goldberg. What every computer scientist should know about oating point arithmetics. ACM Computing Surveys, 23:1, pp 5-48, Mars 91. [12] Mary Lou Nohr. Understanding ELF Objetcs Files and Debugging Tools. Prentice Hall, 94. Board.
85

Danielle Etiemble - Architecture Des Ordinateurs

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Danielle Etiemble - Architecture Des Ordinateurs

Uploaded by

Copyright:

Available Formats

Architecture des Ordinateurs Premi`re partie e

Licence dInformatique - IUP Miage - FIIFO

Table des mati`res e

Tables des mati`res e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 38 40 41 41 42 43 45 46 46 46 49 50 52 52 53 54 55 56 56 60 61 61 63 63 66 66 66 68 70 72 74 75 77 80

Application Langage de haut niveau Langage machine

Microarchitecture Circuits Intgrs

Non Programmable programmable

Les composantes de lordinateur

Mmoire Bus CPU Entres Sorties

2.2. Les faits technologiques

Cache L2 Mmoire centrale Processeur CPU Cache L1 Adapteur

Bus Entres-Sorties Contrleur Contrleur Contrleur

Figure 2.2: Architecture dun ordinateur monoprocesseur en 99

Les faits technologiques

Chapitre 2. Les composantes de lordinateur

1000 Intel Motorola 100 Sparc DEC Alpha MIPS 10 78 80 82 84 86 88 90 92 94 96 98

Figure 2.4: Organisation de lunit centrale e

2.3. Lunit centrale e

Chapitre 2. Les composantes de lordinateur

Les RAM statiques

Les RAM dynamiques

Chapitre 2. Les composantes de lordinateur

Mmoire principale DRAM

Chapitre 2. Les composantes de lordinateur

100 Intel 10 Motorola Sparc DEC Alpha 1 MIPS

Lvolution exponentielle des performances e

Chapitre 2. Les composantes de lordinateur

Chapitre 2. Les composantes de lordinateur

Chapitre 3. Reprsentation de linformation e

Etat France GB Allemagne Espagne Italie Portugal Gr`ce e Irlande

Table 3.1: Reprsentation de huit Etats e

V Etat haut Etat bas Seuil Haut Seuil Bas

Figure 3.1: Information : tat et temps. e

Chapitre 3. Reprsentation de linformation e

Chire Hexa Code binaire Chire Hexa Code binaire

Table 3.2: Correspondance entre chires hexadcimaux et quartets binaires e

Reprsentation des caract`res e e

Reprsentation des entiers e

Table 3.3: Reprsentation des entiers [0 15] sur un quartet e

Chapitre 3. Reprsentation de linformation e

Proposition 3 Si A et B sont des entiers naturels, A+B =A B + C2n .

3.3. Reprsentation des entiers e

non -2n reprsentable

Chapitre 3. Reprsentation de linformation e

Le nombre M obtenu par complmentation a 2 est e `

Chapitre 3. Reprsentation de linformation e

3.3. Reprsentation des entiers e

Chapitre 3. Reprsentation de linformation e

Traitement des erreurs

34 verra par la suite.

Chapitre 3. Reprsentation de linformation e

Reprsentation des rels e e

Table 3.5: Formats IEEE 754 simple et double prcision. e

Reprsentation IEEE 754 e

Chapitre 3. Reprsentation de linformation e

3.4. Nombres rels e

Chapitre 3. Reprsentation de linformation e

Traitement des situations anormales

3.4. Nombres rels e

Chapitre 3. Reprsentation de linformation e

Flag Underow Overow Division par 0 Invalid Operation Inexact

Resultat 0, emin ou nombre denormalise ou xmax NaN Resultat arrondi

3.5. Placement mmoire e