Buisson Concevoir son microprocesseur - Structure des systèmes logiques (Ellipses)

Concevoir son microprocesseur

structure des systèmes logiques

Jean-Christophe Buisson

Collection Technosup

Ellipses

Avant-propos

Ce livre s’adresse aux étudiants en informatique de licence et maîtrise, aux élèvesingénieurs, ainsi qu’aux professionnels de l’informatique - programmeurs ou autres -soucieux de comprendre le fonctionnement des systèmes logiques présents dans lesdispositifs électroniques qui nous entourent, et en particulier les microprocesseurs et lesmicrocontrôleurs. Il est basé sur le cours, les travaux dirigés et les travaux pratiquesd’architecture des ordinateurs dispensés en 1ère année du département informatiquede l’Ecole Nationale Supérieure d’Electronique, d’Informatique, d’Hydraulique et deTélécommunications (ENSEEIHT) de Toulouse, et il est le fruit de plus de 15 ansd’expérience dans ce domaine.

Le livre est organisé en deux grandes parties. La première (chapitres 1 à 3) présented’abord toutes les notions de base préalables à la compréhension : le système denumération binaire et son utilisation dans le codage des nombres entiers naturels et relatifs,des caractères et des nombres réels ; ses propriétés dans les opérations d’addition, decomparaison, etc. On décrit ensuite les atomes de base des systèmes logiques que sont lesportes et les bascules, et on décrit les méthodes d’analyse et de synthèse qui permettentd’assembler de tels éléments pour former des modules de complexité croissante. Lelecteur est ainsi amené à créer des circuits combinatoires et séquentiels, en employantdes méthodes réutilisables dans des contextes variés. On construit des encodeurs et desdécodeurs, des compteurs, des séquenceurs de différents types pour automatismes, etc. Onexamine également en détail des modules qui seront utilisés dans des microprocesseurs :comparateurs, unités arithmétiques et logiques, multiplexeurs, mémoires, etc. Dans toutecette partie, l’accent est mis sur la modularité et la réutilisabilité,notion aussi importante icique dans les disciplines logicielles.

La deuxième partie (chapitres 4 à 6) décrit le fonctionnement des microprocesseurset des microcontrôleurs au travers d’un processeur 32 bits spécifique à ce livre appeléCRAPS, dont tous les organes sont des modules qui auront été étudiés dans la premièrepartie. Son langage machine de type RISC est un sous-ensemble de celui du SPARC, et ilest suffisamment riche pour pouvoir être utilisé dans des applications concrètes, ou pourqu’on y incorpore un système d’exploitation comme Linux. Le but de cette partie est dedévoiler le mystère de l’exécution d’un programme,qu’on pourra observer jusqu’à l’échelledu bit élémentaire. De nombreux programmes écrits en assembleur CRAPS/SPARC sontfournis,qui permettent de mettre en oeuvre des aspects importantsde la vie d’un processeur :déclenchement et prise en compte d’une interruption, dialogue avec des périphériquesd’entrées-sorties, appels de sous-programmes récursifs, etc.

Au delà de la simple compréhension, cet ouvrage a pour objectif de permettre laconception de systèmes logiques digitaux, et il en fournit tous les moyens. De nombreusesméthodes de conception sont présentées, parfois algébriques ou tabulaires, parfoisfonctionnelles ou intuitives ; pour chacune, plusieurs exemples détaillés sont fournis, quiappliquent les techniques présentées à des problèmes concrets, et qui donnent au lecteur lapossibilité de se construire un véritable savoir-faire dans ce domaine. Un outil logiciel desimulation appelé SHDL est présenté, libre et gratuit, à la fois basé sur un langage structurel

de description matérielle,et qui permet de voir fonctionner les dispositifs conçus.Un secondoutil logiciel libre appelé CRAPSEMU permet de programmer le processeur décrit avec denombreux exemples fournis, afin que le lecteur puisse s’imprégner correctement des modesde fonctionnement du processeur CRAPS.

Enfin, des éléments concrets sont fournis au lecteur pour lui permettre d’implémentertous les circuits décrits, jusque et y compris le processeur CRAPS, dans des circuitslogiques programmables de type CPLD ou FPGA, maintenant utilisables à l’aide de cartesd’expérimentation à moindre coût.

iv

Table des Matières

Avant-propos . . . . . . . . . . . . . . . . . . . . . . . iii

Chapitre I . Principes généraux . . . . . . . . . . . . . . . . 1

1. Organisation générale d’un ordinateur . . . . . . . . . . . 1

2. Bits et signaux électriques . . . . . . . . . . . . . . . 3

3. Technologies de fabrication des circuits intégrés . . . . . . . . 5

4. Mots binaires . . . . . . . . . . . . . . . . . . . 6

5. Codage des principaux types de données . . . . . . . . . . 10

6. Exercices corrigés . . . . . . . . . . . . . . . . . . 15

Chapitre II . Éléments de logique combinatoire . . . . . . . . . . . 18

1. Circuits combinatoires . . . . . . . . . . . . . . . . 18

2. Tables de vérité . . . . . . . . . . . . . . . . . . . 20

3. Algèbre et opérateurs de base . . . . . . . . . . . . . . 20

4. Autres portes logiques . . . . . . . . . . . . . . . . . 23

5. SHDL, un langage de description matérielle pédagogique . . . . . 26

6. Circuits logiques reconfigurables ; PLD et FPGA . . . . . . . . 28

7. Méthodes de simplification des fonctions combinatoires . . . . . 30

8. Circuits combinatoires réutilisables . . . . . . . . . . . . 37


Chapitre III . Éléments de logique séquentielle . . . . . . . . . . . 61

1. Définition . . . . . . . . . . . . . . . . . . . . . 61

2. Latch RS . . . . . . . . . . . . . . . . . . . . . 62

3. Fronts et niveaux ; signaux d’horloge . . . . . . . . . . . . 63

4. Circuits séquentiels synchrones et asynchrones : définitions . . . . 63

5. Graphes d’états . . . . . . . . . . . . . . . . . . . 64

6. Tables de transitions . . . . . . . . . . . . . . . . . 66

7. Bascules synchrones . . . . . . . . . . . . . . . . . 69

8. Synthèse d’un circuit séquentiel synchrone . . . . . . . . . . 77

9. Chronologie d’un circuit séquentiel synchrone . . . . . . . . 84

10. Circuits séquentiels réutilisables . . . . . . . . . . . . . 85

11. Exercices corrigés . . . . . . . . . . . . . . . . . 92

Chapitre IV . Éléments fonctionnels d’un processeur . . . . . . . . . 98

1. Sorties haute-impédance . . . . . . . . . . . . . . . . 98

2. Les bus parallèles . . . . . . . . . . . . . . . . . . 101

3. Décodeurs . . . . . . . . . . . . . . . . . . . . 103

4. Multiplexeurs . . . . . . . . . . . . . . . . . . . 104

5. Encodeurs de priorité . . . . . . . . . . . . . . . . . 105

6. Circuit d’extension de signe . . . . . . . . . . . . . . . 107

7. Décaleur à barillet . . . . . . . . . . . . . . . . . . 108

8. L’unité arithmétique et logique . . . . . . . . . . . . . . 111

9. Circuit timer/PWM . . . . . . . . . . . . . . . . . 114

10. RAMs et ROMs . . . . . . . . . . . . . . . . . . 115


Chapitre V . Programmation du processeur 32 bits CRAPS/SPARC . . . 129

1. Le langage machine, à la frontière entre logiciel et matériel . . . . 129

2. Ressources du programmeur CRAPS/SPARC . . . . . . . . . 131

3. Directives d’un programme assembleur . . . . . . . . . . . 145

4. Exemple de programme : crible d’Ératosthène . . . . . . . . . 148

5. Appels de sous-programmes terminaux . . . . . . . . . . . 152

6. Utilisation de la pile . . . . . . . . . . . . . . . . . 153

7. Techniques de programmation diverses . . . . . . . . . . . 158

8. Langages à structure de blocs et ’stack-frames’ . . . . . . . . 159

9. Programmation des entrées/sorties . . . . . . . . . . . . 163

10. Programmation des exceptions . . . . . . . . . . . . . 170


Chapitre VI . Construction du processeur 32 bits CRAPS . . . . . . . 186

1. Les registres . . . . . . . . . . . . . . . . . . . . 186

2. L’unité arithmétique et logique . . . . . . . . . . . . . . 190

3. Les bus du processeur CRAPS . . . . . . . . . . . . . . 195

4. Structure du sous-système mémoire . . . . . . . . . . . . 198

5. Structure du circuit d’entrées/sorties . . . . . . . . . . . . 201

6. Structure du circuit timer/PWM . . . . . . . . . . . . . 203

7. Structure du sous-système d’exceptions . . . . . . . . . . . 205

8. Séquencement des instructions . . . . . . . . . . . . . . 209


Références . . . . . . . . . . . . . . . . . . . . . . . . 219

vi

Annexe A. Tables diverses . . . . . . . . . . . . . . . . . . 220

Annexe B. CRAPS : guide du programmeur . . . . . . . . . . . . 221

B.1. Instructions synthétiques . . . . . . . . . . . . . . . 221

B.2. Jeu d’instructions du processeur CRAPS . . . . . . . . . . 223

B.3. Tables des branchements conditionnels . . . . . . . . . . 228

B.4. Format binaire des instructions de CRAPS . . . . . . . . . 228

B.5. Directives de l’assembleur CRAPS . . . . . . . . . . . 230

B.6. Cartographie mémoire de CRAPS . . . . . . . . . . . . 231

B.7. Programmation des entrées/sorties . . . . . . . . . . . . 231

B.8. Programmation du timer . . . . . . . . . . . . . . . 231

B.9. Liste des exceptions . . . . . . . . . . . . . . . . . 232

Glossaire . . . . . . . . . . . . . . . . . . . . . . . . 233

Index . . . . . . . . . . . . . . . . . . . . . . . . . . 242

vii

Chapitre I

Principes généraux

1. Organisation générale d’un ordinateur

1.1. Le modèle de Von Neumann

La plupart des ordinateurs ont l’organisation générale de la figure I.1.

instruction #1

instruction #2

instruction #3

donnée #1

donnée #2

mémoire centrale

adr#2

adr#3

adr#5

adr#4

adr#1

contrôleurs

de périphériques

instruction

données

unité de contrôle=

processeur

et de calcul

périphériques

donnéesdonnées

registres

r1

r2

r3

Figure I.1. Organisation générale d’un ordinateur; les flèches sont des chemins dedonnées.

Cette organisation est dite de ’Von-Neumann’, car elle ressemble beaucoup à lamachine conçue parJohn Von Neumannsur la machine IAS peu après la deuxième guerremondiale. Elle suppose et implique un certain nombre de propriétés caractéristiques desordinateurs actuels :

La mémoire est un composant central ; c’est un tableau de mots de taille fixe

On voit sur le schéma que lamémoire centraleest au départ et à l’arrivée del’exécution d’un programme.C’est elle qui contient le programme à exécuter et les données

1

2 CHAPITREI. PRINCIPES GÉNÉRAUX

initiales ; c’est dans elle que seront stockés les résultats intermédiaires ou finaux.

C’est un tableau de mots binaires de taille fixe. Chaque mot est repéré par un nombreappelé adresse, et les programmes feront référence aux données et aux instructions enmémoire par leurs adresses.

Le programme exécuté est dans la mémoire centrale

Le programme qu’exécute un ordinateur n’est pas sur le disque dur, comme lepensent beaucoup de gens. Une copie du programme est effectivement souvent stockéesur un CDROM ou un disque dur, mais ce n’est pas avant d’avoir été copié en mémoirecentrale, comme le serait n’importe quelle autre ensemble de données, que son exécutionpeut commencer.

Un programme qu’exécute un ordinateur est composé d’instructionssous forme demots mémoire. Le langage utilisé pour coder les instructions en mots binaires est appelélangage machine, c’est le seul que comprenne le processeur. La taille des instructionsvarie beaucoup selon le type des processeurs. Parfois toutes les instructions ont la mêmetaille, égale à un ou plusieurs mots mémoire ; parfois elles ont des tailles variables selon lacomplexité de l’instruction.

Le processeur est le coordonnateur de l’exécution

Le processeurcontrôle l’exécution des programmes, en organisant le chargementdes instructions et le détail de leur exécution ; c’est aussi lui qui effectue tous les calculs,notamment sur les nombres entiers. Ces deux fonctions sont associées dans la même unitécar le contrôle de l’exécution nécessite souvent des calculs entiers, lorsque par exemple ilfaut faire une somme pour déterminer l’adresse de l’instruction suivante.

Le processeur a besoin de garder la trace d’un certain nombre d’informations pendantl’exécution des instructions : l’adresse de l’instruction en cours par exemple, ou le résultatde la dernière opération arithmétique. Il utilise pour cela desregistres, qui sont des motsmémoire fixes, à accès très rapide.

Le processeur ne dialogue pas directement avec les périphériques

On voit sur la figure que le processeur dialogue avec descontrôleursde périphériqueset non avec les périphériques eux-même. Par exemple un processeur n’a aucune consciencede l’existence d’un disque dur ; il dialogue avec un contrôleur de disque, à l’aided’instructions génériques d’entrées/sorties.

1.2. Organisation en bus

Les flèches entre les composants de la figure I.1 étaient à prendre dans un sensfonctionnel; si elles devaient représenter effectivement les chemins par lesquels transitentles données, le fonctionnement serait très inefficace.En pratique, les données circulent entreles différents sous-systèmes d’un ordinateur sur desbus, sortes d’autoroutes, et des circuitsspécialisés jouent le rôle d’échangeurs aux carrefours de ces bus, de façon à permettre destransferts simultanés dans certaines circonstances. La figure I.2 montre une organisationtypique d’un système de type compatible PC.

Un circuit appelénorth-bridgerègle les échanges à très grande vitesse, notammententre le processeur et la mémoire centrale. Il exploite de façon synchrone le bus FSB (frontside bus), encore appelébus système, dont la vitesse est très corrélée à la puissance générale

1. Organisation générale d’un ordinateur 3

64/256 bits

FSB66/100/133/200 MHz

64 bits

66/100/133/200 MHz64 bits

bus mémoire

533/800 Mo/s

mémoire RAM

cacheniveau 2 processeur

north

bridge

IDEsouth

bridge

LAN

PCI−E

PCI

USB

Figure I.2. Architecture générale des bus d’un ordinateur compatible PC.

de l’ensemble. Un second circuit appelésouth-bridgeeffectue quant à lui des échangesmoins rapides avec des périphériques SATA, réseau, etc.

La figure I.3montre une photo decartemèretypique,avec l’emplacement physique desdifférents bus. La mémoire et le north bridge sont placés très près du processeur, car ils sontsur les bus les plus rapides. Lenorth-bridge est équipé d’un radiateur à cause de l’intensitédu travail de transfert qu’il réalise.

2. Bits et signaux électriques

L’information est stockée et véhiculée dans un ordinateur, logiquement sous forme dechiffres binaires oubits (binary digit), et physiquement sous forme de signaux électriques.La logique binaire est utilisée parce qu’il est plus facile de construire des systèmesélectriques possédant deux états stables, et parce qu’on a maintenant beaucoup de résultatsmathématiques enalgèbre de Boole, mais des implémentations sur des systèmes possédantplus de deux états stables sont envisageables.

Ces deux états sont notés ’0’et ’1’ ; ils correspondent le plus souvent aux deux tensionsélectriques0v et +Vcc respectivement,Vcc valant exactement +5v pour des circuits utilisantla technologie TTL, et une valeur comprise entre 2v et 15v environ en technologie CMOS(des valeurs de Vcc=3.3v, 2.5v et 1.8v étant utilisée de plus en plus souvent). Pour tenircompte du fait que ces signaux électriques vont être déformés lors des transmissions,des plages de valeurs plus larges ont été affectées à ces états. Par exemple, en technologieTTL, elles sont représentées figure I.4. Il faut noter que ces assignations sont légèrementdifférentes selon qu’une tension est considérée en entrée ou en sortie d’un circuit.

Les circuits logiques qui sont utilisés pour combiner et transmettre les signauxélectriques logiques ont des caractéristiques non linéaires qui ont entre autres pour fonctionde remettre en forme un signal déformé par le bruit. On voit figure I.5 une porte ’non’ qui


Figure I.3. Carte mère typique. Les bus rouges (FSB et mémoire), très rapides, sontgérés par le north bridge ; les bus verts (PCI, SATA, etc.), plus lents, sont gérés par lesouth bridge.

’1’ logique

’0’ logique

’1’ logique

0.4v

+ 5v

2.4v

interdit

’0’ logique0v 0v

+ 5v

2.4v

(b)

0.8v

(a)

interdit

Figure I.4. Assignation des tensions électriques aux valeurs logiques (a) en entrée decircuit, (b) en sortie de circuit (technologie TTL).

inverse le bit d’entrée, tout en produisant un signal de sortie de meilleure qualité que le signald’entrée.

Les signaux pourront donc traverser un nombre quelconque d’étages de circuitslogiques sans que les déformations initiales ne soient amplifiées.

On notera sur la figure I.5 la présence d’untemps de propagationtpHL (HL indiquant :de haut vers bas)qui correspond à la durée que met le circuit pour calculer sa sortie aprèsqueses entrées se soient modifiées. Ces temps de propagation se cumulent lors de la traverséede plusieurs étages, et c’est finalement eux qui limiteront la vitesse de fonctionnementmaximale d’un circuit.

2. Bits et signaux électriques 5

2.4v

5v

0.4v

tpHL

E

S

Figure I.5. Remise en forme d’un signal après traversée d’une porte ’non’.

3. Technologies de fabrication des circuits intégrés

Les premiers ordinateurs ont été construits durant la deuxième guerre mondialeavec des tubes cathodiques (des ’lampes’) comme dispositif de commutation. En 1947,les laboratoires Bell inventent le premiertransistor, qui va très vite supplanter la lampeet apporter un facteur de réduction de taille important. Mais la véritable révolutionn’interviendra qu’avec l’invention des circuits intégrésVLSI dans les années 1970, quiamèneront à la réalisation des premiers microprocesseurs.

Un grand nombre de technologies de fabrication de circuits intégrés existent, quise distinguent par des qualités différentes en termes de vitesse de propagation, densitéd’intégration, consommation et dissipation thermique. On va ébaucher rapidement danscette section les trois familles les plus connues, en terminant par celle qui est actuellementla plus répandue et la plus significative, la familleCMOS.

Technologie TTL

La technologieTTL était la technologie standard utilisée à partir des années 1960pour la réalisation de tous les types d’ordinateurs. Elle s’alimente typiquement en +5V, aune consommation modérée, est robuste et a des règles d’interface simples. Une très grandefamille de circuits spécialisés, la famille 7400, est disponible sous forme de circuits enboîtier DIL, et fournit des modules tout prêts :portes,bascules,compteurs,etc.Les capacitésd’intégration de circuits TTL sont faibles, et on ne peut guère mettre plus de quelquesmilliers de portes TTL sur une puce de circuit intégré. On l’utilise encore aujourd’hui pourdes petites réalisations, notamment dans l’interfaçage avec d’autres circuits.

Technologie ECL

La technologieECL est caractérisée par sa très grande rapidité, mais aussi par uneconsommation de courant élevée. Elle est de plus assez difficile à utiliser, notamment enraison de l’emploi de tensions d’alimentation négatives. Elle est utilisée dans des petitesréalisations où la vitesse est critique, mais certains experts prévoient un développement de


la technologie ECL avec l’utilisation de nouveaux types desemi-conducteurs.

Technologie CMOS

C’est la technologie reine actuelle. La technologieCMOSa d’abord été développéeet vendue comme une alternative au TTL, plus lente mais avec une consommation réduite.Comme par ailleurs elle peut utiliser des tensions d’alimentation faibles (jusqu’à 1V), elle aimmédiatement été très utilisée par les fabricants de montres digitales,pour qui la vitesse detraitement importait peu par rapport à la consommation. Mais on a progressivement réaliséque sa grande qualité était son taux d’intégration très élevé ; de plus, des tailles de transistorsde plus en plus petites ont amenées avec elles des temps de commutation de plus en plusfaibles. C’est la technologie CMOS qui est utilisée actuellement pour la fabrication de tousles processeurs et microcontrôleurs du marché, ainsi que pour toutes lesmémoires statiqueset les mémoires flash.

Par ailleurs, un circuit CMOS ne consomme significativement du courant que lors descommutations des transistors. Cette propriété a été à l’origine de circuits qui consommentmoins de courant que leur équivalent TTL, qui eux en consomment au repos et lors descommutations. Néanmoins, au fur et à mesure qu’on diminue leur tension d’alimentation,les courants de fuite des transistors CMOS deviennent de plus en plus proches des courantsde commutation,et par conséquent la consommation de ces circuits au repos n’est plus aussinégligeable qu’auparavant.

4. Mots binairesLes signaux binaires sont souvent regroupés pour former desmots.La largeur d’un

mot binaire est le nombre des signaux qui sont regroupés. On appelle par exempleoctetunmot de 8 bits (un mot de largeur 8). Un mot den bits permet de codern2 valeurs différentes ;256 valeurs par exemple pour un octet. On peut utiliser un octet pour coder un caractèrealphanumérique à la normeISO-8859 ;un mot de 32 bits pour représenter un nombre entierrelatif ; un mot de 16 à 96 bits pour représenter des nombres réels en notation scientifiqueflottante selon la normeIEEE 754. Des structures de données plus complexes (tableaux,listes, ensembles, dictionnaires, etc.) nécessitent une agrégation de ces types simples.

Codage en binaire pur

On écrira les nombres binaires avec le chiffre 2 en indice. Par exemple :011011012.Surn bits, l’intervalle des valeurs représentées est[0, n−12 ]. Comme en décimal, le total estune somme pondérée, plus précisément le produit de chaque chiffre par la puissance de 2 demême rang :

s =n−1∑i =0

i2 bi

oùbi est le bit de rangi du mot.

Par exemple, on a représenté sur la figure suivante les poids respectifs des bits du motde 8 bits100110102 = 15410 :

4. Mots binaires 7

1 0 0 1 1 0 1 0

01234567

2128

16

8

S = 128+16+8+2=154

Poids forts, poids faibles

Par référence à cette notion de pondération des chiffres, on emploie couramment desexpressions telles que ’les n bits depoidsles plusforts’, ou ’les n bits depoidsles plusfaibles’pour désigner les n bits les plus à gauche (respectivement les plus à droite) dans un motbinaire. Dans les documentations en anglais, on trouvera fréquemment des libellés tels queMSB (most significant bits) ouLSB (least significant bits) avec les même sens.

1 Kilo n’est pas 1000 (en informatique)

Lorsque vous achetez un kilowatt-heure d’électricité, il est bien entendu avec votrefournisseur qu’il s’agit de 1000 watts-heure. Ce n’est pas la même chose en informatique !Pour continuer à énumérer en utilisant la base 2, les informaticiens ont décidé d’utiliserl’unité 1K = 102 = 1024, donc un peu plus de 1000. Le suffixe ’méga’est :1M = 1K×1K =

202 ; un ’giga’est :1G = 1K×1M = 302 ; un ’Tera’est :1T = 1K×1G = 402 . Un grand nombrede valeurs usuelles s’expriment alors directement en multiples de 1K, 1M, 1G ou 1T, parexemple la taille des mémoires RAM, car elle est nécessairement une puissance de 2 à causede leur organisation matricielle.

1K, 1M et 1G valent environ mille, un million et un milliard, mais la petite différenceentre 1000 et 1K augmente lorsqu’on passe à 1M et 1G : 1M = 1024 * 1024 = 1 048 576,et 1G = 1024 * 1048576 = 1073 741824, soit presque 1,1milliard. Les vendeurs de disquesdurs exploitent cette ambiguïté : le plus souvent si vous achetez un disque étiqueté ’100giga-octets’, il s’agit d’un disque de 100 milliards d’octets,et non de 107 374 182 400 octets,soit une différence de 7%.

64 bits, la taille idéale pour les données ?

Les microprocesseurs manipulent des mots binaires de taille fixe, les plus petits de 8bits, d’autres de 16 bits, 32 bits et maintenant 64 bits. Un processeur 8 bits, s’il veut ajouter1000 et 1000, doit effectuer deux additions et non une seule, puisque 1000 ne ’rentre’ pasdans un codage 8 bits. Un processeur 16 bits code directement des nombres entiers del’intervalle [-32768,+32767], ce qui ne permet pas de coder des nombres un tant soit peugrands.On semble définitivement à l’aise avec 32 bits, mais ce n’est pas le cas : le plus grandentier qui peut être codé est322 , soit environ 4 milliards, ce qui ne suffit pas à représenter lemontant en euros d’une journée de transactions à la bourse de Paris.

Avec 64 bits, on est définitivement sauvés côté entiers, à moins de vouloir compter lesgrains de sable sur la plage. Pour le codage des nombres réels, 64 bits est la taille de codageen double précision la plus usuelle, qui donne une précision d’une dizaine de chiffres aprèsla virgule, suffisante dans la majorité des applications.Comme on doit aussi souvent stockerdes adresses de mémoire dans des mots, 64 bits est aussi une taille suffisante, alors que 32


bits ne permettent pas de dépasser 4 giga-octets.

Une taille de mot de 64 bits a donc des qualités intrinsèques que n’avaient pas jusque là16 bits ou 32 bits. Utiliser une taille plus grande de 128 bits dans un processeur conduirait àbeaucoup de gaspillage,puisque la plupart des mots manipulés seraient très peu remplis.Maprédiction personnelle est que,dans le futur,cette taille du mot mémoire ne va pas augmenterindéfiniment, mais va se stabiliser à 64 bits du fait des qualités qui viennent d’être décrites.

Nombres binaires à virgule

Comme en décimal, on peut manipuler des nombres à virgule en binaire. Les chiffresplacés après la virgule ont alors des poids qui sont les puissances négatives décroissantes de2. Ainsi,0.12 = −12 = 0.5 ; 0.012 = −22 = 0.25, etc.

Si on cherche la représentation binaire approchée du nombreπ, on trouveraπ =11.001001…(figure I.7).

1 0 −1 −2 −3 −4 −5 −6

1 1 0 0 1 0 0 1 ...

2

,

1

0,1250,015625

pi = 2 + 1 + 0.125 + 0.015625 + ...

Figure I.7. Écriture binaire à virgule (approchée) du nombre Pi.

Pour chaque position, on met 1 ou 0 de façon à ce que la valeur courante ne dépassepas la valeur à représenter, tout en s’en approchant le plus possible. Par exemple après avoirchoisi11.001(total courant = 12 + 02 + −32 = 2 + 1 + 0.125 = 3.125), on ne peut pas mettrede 1 en position -4 ou -5, car cela dépasseraitπ. On doit attendre la position -6, et on a unevaleur approchée de12 + 02 + −32 + −62 = 3.140625.

L’annexe A fournit les valeurs des premières puissances négatives de 2.

Incrémenter et décrémenter en binaire

Une opération fréquente effectuée sur des nombres binaires est le comptage. Parexemple sur 3 bits, passer de 000 à 001, puis 010, etc. Selon quel algorithme une valeur setransforme-t-elle en la suivante ?

On peut essayer de s’inspirer du comptage en décimal, qu’on sait faire depuis notrepetite enfance, et pour lequel on ne nous a pourtant jamais donné l’algorithmique. Pourpasser de 124 à 125,seul le chiffre des unitéss’est incrémenté.En fait ce chiffre s’incrémentetoujours, avec un passage de 9 à 0. Le chiffre des dizaines sera recopié avec incrémentation,si le chiffre des unités vaut 9, comme dans le passage de 129 à 130, sinon il sera recopié sanschangement, comme dans le passage de 124 à 125. On tient notre algorithme : pour passerd’un nombre décimal à son suivant, on considère chaque chiffre un par un, et on le recopieen l’incrémentant si tous les chiffres qui sont à sa droite valent 9, ou sinon on le recopiesans changement. On remarquera que l’ordre de traitement sur les chiffres est indifférent, etqu’on peut effectuer cet algorithme en parallèle sur tous les chiffres.La figure I.8 montre un

4. Mots binaires 9

exemple.

à droitevalent 9

on recopieen incrémentant

tous les chiffresà droitevalent 9

on recopieen incrémentant

tous les chiffresdes chiffresà droitedifférentsde 9

on recopiesans changer

9

0

9

0

2

3

1

1

incrémentetoujours

Figure I.8. Incrémentationd’unnombredécimal.Un chiffreest recopié avec incrémentationsi tous les chiffres à sa droite valent 9 ; sinon il est recopié sans changement.

Le même algorithme s’applique en binaire,mais cette fois l’opération d’incrémentationd’un chiffre est encore plus simple, car elle se résume à une inversion du bit. Pourincrémenter un nombre binaire, on considère chaque bit du mot initial, et on le recopie avecinversion si tous les bits qui sont à sa droite valent 1,ou on le recopie sans changement sinon.Le bit le plus à droite est toujours inversé. La figure I.9 montre un exemple.

à droitevalent 1

on recopieen inversant

tous les bitsdes bitsà droitedifférentsde 1

on recopiesans changer

à droitevalent 1

on recopieen inversant

tous les bits

1

0

1

0

0

1

1

1

inversiontoujours

Figure I.9. Incrémentationd’un nombre binaire.Un bit est inversé si tous les bits à sa droitevalent 1 ; sinon il est recopié sans changement.

Là encore l’algorithme peut s’effectuer en parallèle sur tous les bits, ce qui est unénorme avantage pour un circuit logique, dont c’est le mode de fonctionnement naturel.Attention, il faut noter qu’on ne peut pas incrémenter la valeur ’sur place’: le mot binaire quicontient le nombre de départ et le mot binaire qui contient le résultat doivent être distincts,et ne peuvent pas être confondus.

Un algorithme analogue existe pour le décomptage : on recopie un bit avec inversionsi tous les bits à sa droite valent 0, sinon on le recopie sans changement.Par vacuité, le bit leplus à droite est toujours inversé. Par exemple, on passe de 110 à 101 en inversant les deuxbits de poids faible, car tous les bits qui sont à leur droite valent 0.

Hexadécimal

Les mots manipulés par un ordinateur ont souvent une largeur supérieure à 16 ou32 bits, et sont donc difficiles à transcrire en binaire. Pour obtenir une écriture concise,


on utilise souvent la base 16, appeléehexadécimal, dont les 16 chiffres sont notés :0,1,2,3,4,5,6,7,9,A,B,C,D,E,F.Chaque chiffre hexadécimal permet de coder 4 bits (42 = 16).Pour passer d’une notation binaire à une notation hexadécimale, il suffit de grouper les bitspar paquets de 4, de droite à gauche à partir des poids faibles. Par exemple :

0110.11012 = 6D16 = 10910

0110.1000.1010.11002 = 68AC16

Si l’on considère le dernier exemple, on peut montrer le regroupement par groupes de 4 bitsen utilisant une notation matricielle :

0110.1000.1010.11002 =

0 1 1 0

×

152142132122

+ 1 0 0 0

×

1121029282

+ 1 0 1 0

×

72625242

+ 1 1 0 0

×

32221202

= 0 1 1 0

× 122 ×

32221202

+ 1 0 0 0

× 82 ×

32221202

+ 1 0 1 0

× 42 ×

32221202

+ 1 1 0 0

× 02 ×

32221202

en introduisant les puissances de 16 :

0110.1000.1010.11002 =

0 1 1 0

× 316 ×

32221202

+ 1 0 0 0

× 216 ×

32221202

+ 1 0 1 0

× 116 ×

32221202

+ 1 1 0 0

× 016 ×

32221202

= 6× 316 + 8× 216 + 10× 116 + 12× 016= 68AC16

5. Codage des principaux types de données

5.1. Codage des caractères

Les caractères usuelsanglo-saxons utilisent généralement un code sur 7 bits appelécodageASCII ; les codes varient entre 0 et 127. Comme ces codes de 7 bits sont toujoursplongés dans un octet (mot de 8 bits), des codages étendus sur 8 bits ont été développés,d’abord de façon propriétaire, puis de façon organisée par la normeISO-8859, qui esten fait un ensemble de normes spécifiques à différentes régions du monde : ISO-8859-1(dite aussi ISO-Latin-1, la notre, qui couvre toute l’Europe de l’ouest, y compris lescaractères espagnols, allemands et scandinaves), ISO-8859-2 (Europe de l’est), etc. Il y aactuellement 15 sous normes spécifiques ; chacune d’elles est un sur ensemble du codageASCII ; pour les codes de 0 à 127. Par contre, l’aspect graphique et typographique fin descaractères (ligatures, etc.) n’est pas bien pris en compte par ces codages, qui ont été conçusessentiellement pour l’échange de données.

Pour tenter de résoudre les problèmes de codage de toutes les langues écrites du

5. Codage des principaux types de données 11

monde, le consortiumUNICODE, qui incorpore la plupart des grands constructeurs etéditeurs informatiques, a créé un encodage de caractères universel. Il est maintenant utilisécomme codage interne dans des langages tels que Java, dans les navigateurs Internet et denombreuses applications ; son adoption généralisée permettrait de résoudre définitivementles disparités d’encodages de caractères entre pays. Chaque caractère possède uncodepoint unique, noté par exemple U+03B3 (pour la lettre grecque minuscule gammaγ). Lescodes-points sont dans l’intervalle U+0000 et U+10FFFF (plus d’un million d’entrées !) ;les 256 premiers codes-points sont identiques à l’ISO-8859-1, et d’autres mappings parblocs existent pour faciliter le passage d’anciens codes à UNICODE. La suite d’octetsreprésentant un caractèren’est pas l’écriture binaire du code-point ; un encodage doitêtre utilisé, et plusieurs d’entre eux existent. Le plus répandu est sans doute l’UTF-8, quireprésente chaque code-point par une suite de 1 à 4 octets. Les codes-points inférieurs à0+0080 (les codes ASCII) sont représentés par un unique octet contenant cette valeur :l’UTF-8 est donc rétrocompatible avec l’ASCII et c’est cette qualité qui a provoqué sadiffusion rapide. Les autres codes-points sont encodés par un nombre d’octets entre 2 et4 ; par exemple le caractère U+03B3, qui représente la lettre grecque minuscule gamma,est codé en UTF-8 :CE16, B316. Les codes-points supérieurs à 0+FFFF, les plus rarementemployés, sont encodés par une suite de 4 octets.

5.2. Codage des nombres entiers naturels

On utilise lebinairepur, déjà décrit en section 4.Avecnbits,on peut coder les nombresentiers positifs de l’intervalle[0, n−12 ].

L’addition et la soustraction s’effectuent de la manière habituelle ; il y a débordementde l’addition lorsqu’une retenue doit être propagée au delà du dernier bit de rangn.

Lecteur et imprimeur décimal

Si un programme utilise des nombres entiers naturels codés en binaire pur, lareprésentation externe de ce nombre à l’utilisateur du programme est généralement faitedans une autre base, le plus souvent la base 10. Un sous-programme appeléimprimeur estchargé de convertir une valeur en binaire pur en son écriture décimale, et un autre appelélecteur fait la traduction inverse. On peut examiner rapidement les algorithmes qu’ilsutilisent. Ils seraient bien sûr facilement transposables à d’autres bases.

Traduction du binaire vers le décimal

Considérons par exemple un mot de 8 bitsN = 101101102 ; on cherche la suite descaractères qui représente ce nombre en écriture décimale. C’est un programme d’ordinateurqui réalise cette conversion, et qui dispose donc d’opérateurs arithmétiques (binaires) telsque addition et multiplications, qui sait faire des comparaisons, etc. Cette traduction necomportera pas plus de 3 chiffres décimaux, notons les :XYZ. On choisit pour X le chiffrele plus grand tel que100X ≤ N. Ici X = 1 convient car1×100 ≤N et 2×100 >N. Pourfaire ce choix de X, on peut effectivement réaliser des multiplications, ou utiliser une tablepréconstruite. Il reste à traduireN1 = N − X×100 = 10100102. Pour cette valeur, on cherchela plus grande des valeurs deY telle que10×Y ≤ N1 ; on trouveY = 8, et il reste à convertirN2 = N1 − Y×10 = 000000102 ; on trouve alorsZ = 2. Finalement, les trois chiffresdécimaux cherchés sontXYZ = 182.


Traduction du décimal vers le binaire

On cherche donc à convertir l’écriture décimale d’un nombre en un mot binaire.Le problème n’est pas le symétrique du précédent, car l’ordinateur sait faire toutes lesopérations sur le codage binaire, alors qu’il ne sait en faire aucune directement en base 10.Pour un nombre décimal tel que ’XYZ’ (qui conduit à une valeur binaire sur 8 bits), il suffiten fait de faire le calculn = 100x + 10y + z où x, y et z sont les numéros d’ordre associésaux chiffres ’X’, ’Y’et ’Z’ respectivement.

5.3. Codage des nombres entiers relatifs

Aux débuts de l’informatique, on codait généralement les nombres entiers signés enmettant dans le premier bit le signe (’1’ signifiant ’moins’) et dans les suivants la valeurabsolue.-3 se codait par exemple 10000011 sur 8 bits. L’encodage et le décodage d’un telnombre étaient simple (bien qu’on notera que 0 peut être codé +0 ou -0), mais on ne pouvaitplus réaliser une simple addition comme avec des nombres naturels.Si par exemple on tentede faire l’addition bit à bit de 10000011 (-3) et de 00000100 (+4), on obtient : 10000111,c’est à dire -7, ce qui est absurde.

Codage en complément à 2

Un codage appelécomplément à deuxs’est rapidement imposé dans les années 1970.Il utilise les deux règles suivantes :

• un nombre positif est représenté en binaire pur.

• pour calculer la représentation de l’inverse arithmétique d’un nombre, on inverse tousses bits et on ajoute 1, sans tenir compte de l’éventuelle retenue.

Considérons par exemple le codage des nombres relatifs sur 8 bits. +3 va être codé00000011. Pour obtenir le codage de -3, on inverse tous les bits du codage précédent(00000011→11111100) et on ajoute 1, soit11111101.

Propriétés

On peut prouver que ce codage a les propriétés remarquables suivantes :

• c’est un codage équilibré: surn bits, on représente les nombres relatifs de l’intervallen−1[ − 2 , n−12 − 1]soit autant de nombre positifs ou nuls que de nombres strictement

négatifs.

• 0 se code sous forme d’un champ uniforme de 0 ; il n’a qu’un seul codage.

• le bit de poids fort du codage représente le signe du nombre.

• les opérations d’addition ou de soustraction en binaire pur s’appliquent également avecdes opérandes codés en complément à deux, avec la différence que la retenue n’a pasde sens et doit être négligée lors d’une opération en complément à deux.

Pour illustrer le fait que le même opérateur d’addition est utilisé pour le binaire pur etle complément à 2, considérons l’addition de la figure I.10.


11101001

01000010+

00101011

−23

+66+

+431

233

66+

299

interprétation signéeinterprétation non signée(retenue prise en compte) (retenue ignorée)

Figure I.10. Une même opération ’mécanique’ d’addition s’interprète de deux façons dif -férentes.

La même opération effectuée mécaniquement sur des codages (colonne centrale)s’interprète de deux façons différentes selon qu’on considère les nombres comme étantsignés ou non.

Cercle des nombres

Les différentes propriétés du codage en complément à 2 peuvent être retrouvées avecla métaphore ducercle des nombres, ici représenté pour un codage sur 3 bits (figure I.11).

−1000

0011

011

3100

−4

101−3

limite de franchissementde signe

soustraction

addition

0

111

110−2 010 2

positifs

négatifs

Figure I.11. Cercle des nombres de 3 bits en complément à 2.

On effectue une addition en parcourant le cercle dans le sens des aiguillesd’une montre,et une soustraction dans le sens inverse.

Si on recherche le codage de-3, on part de 0 et on tourne de 3 positions dans le sensinverse des aiguilles d’une montre, pour trouver :1012. Si on veut lui ajouter 5, on tourne de5 positions dans le sens des aiguilles d’une montre, et on trouve :0102, c’est à dire 2.


Si on franchit la limite -4 / +3 pendant une opération, cela signifie qu’il y aeu débordement.

Débordement

Quand y a-t-ildébordementlors d’une addition de deux nombres signés ? Il estclair qu’il ne peut pas se produire lorsque les opérandes sont de signes opposés, puisque lavaleur absolue du résultat est alors inférieure à la plus grande des valeurs absolues des deuxopérandes. Il ne peut donc se produire que s’ils sont de même signe, tous les deux positifs outous les deux négatifs.On démontre facilement qu’alors il y a débordement si et seulement sil’addition des deux donne un résultat de signe opposé au signe commun des deux opérandes.Graphiquement sur lecercle des nombres, cela se produit lorsqu’on traverse la frontière -4→ +3.

Comparaison de nombres en complément à 2

On se pose ici le problème de savoir les positions respectives de deux nombres entierscodés en complément à 2AetB : sont ils égaux, ou l’un est-il plus grand que l’autre ? Il fautexaminer les signes des deux nombres à comparerAetB, c’est à dire leurs bits de poids forts.Si les signes sont différents, la comparaison est immédiate. Si les signes sont identiques, ilsuffit de comparer lesn − 1autres bits, l’ordre étant direct si leur signe commun est positif,inversé si leur signe commun est négatif.

Écriture sous forme d’une somme pondérée du codage en complément à 2

Les propriétés remarquables du codage en complément à 2 peuvent être facilementdémontrées si on remarque qu’en fait, il s’agit également d’une somme pondérée comme enbinaire pur, mais avec un poids particulier de n−1− 2 pour le bit de poids le plus fort de rangn − 1.

s = n−1− 2 bn−1 +n−2∑i =0

i2 bi

oùbi est le bit de rangi du mot.

On peut maintenant démontrer pourquoi le premier bit est un bit de signe. Puisquen−2∑i =0

i2 est toujours plus petit ou égal àn−12 − 1, alorss < 0si et seulement sibn−1 = 1.

5.4. Codes de Gray

Un code de Graysur n bits est tel que deux codes successifs ne diffèrent que d’unseul bit. On s’en sert par exemple pour encoder la position d’un axe en rotation, telqu’un commutateur rotatif ou une girouette. Plusieurs codes de Gray sont possibles pourun nombre donné de bits ; on parle de code de Grayréfléchi lorsqu’il possède certainespropriétés de symétrie. Une méthode récursive pour construire un code de Gray réfléchi surn + 1bits à partir d’un code surn bits est la suivante :

• sous les codes àn bits, on recopie la liste en miroir.

• on ajoute un bit à gauche, valant 0 pour la première moitié, et 1 pour la deuxième.


On a représenté figure I.12 la construction récursive par cette méthode des codes de Grayréfléchis à 2 puis 3 bits. Par construction, les codes ne diffèrent que d’un bit pour chacunedes deux moitiés, au passage entre les deux moitiés, ainsi que de la dernière à la premièreligne : c’est donc un code de Gray.

1

0

1

0

1

0

1

0

0

0

11

1

1

0

1

0

0

0

1

0

11

0 1

00

0

1

et de 1 en deuxièmeen première moitié

sur 1 bitcode de Gray

sur 2 bitscode de Gray

copie en miroir

1

et de 1 en deuxièmeen première moitié

ajouts de 0ajouts de 0

0

0

0

0

1

1

1

1

1

1

1

0

1

0

0

0

1

0

11

0 1

00

code de Gray

sur 3 bits

copie en miroir

Figure I.12. Construction récursive d’un code de Gray sur 2 bits,puis sur 3 bits.

6. Exercices corrigés

6.1. Exercice 1 : conversion

Énoncé

Écrire 54321en binaire, puis en hexadécimal.

Solution

On peut se reporter à la table donnée en annexe A pour obtenir la liste des premièrespuissances de 2. La plus grande qui soit inférieure à 54321 est152 = 32768. On peut écrirealors :

54321 = 152 + 21553.

On recommence avec 21553 : il contient142 = 16384, et il reste 21553- 16384 = 5169,donc :

54321 = 152 + 142 + 5169.

5169 contient 122 = 4096, reste 1073 :

54321 = 152 + 142 + 122 + 1073.

1073 contient 102 = 1024, reste 49 :

54321 = 152 + 142 + 122 + 102 + 49.

En continuant ce processus, on trouve :


54321 = 152 + 142 + 122 + 102 + 52 + 42 + 02 .

L’écriture binaire est alors :

54321 = 11010100001100012

Pour trouver l’écriture hexadécimale, on regroupe les bits par paquets de 4 :

54321 = 1101.0100.0011.00012

On convertit ensuite chaque groupe en un chiffre hexadécimal équivalent :

54321 =D43116

6.2. Exercice 2 : arithmétique binaire

Énoncé

1 Donner l’intervalle des valeurs possibles pour des nombres non signés codés en binairepur sur 11 bits.

2 Donner l’intervalle des valeurs possibles pour des nombres signés codés encomplément à 2 sur 11 bits.

3 Effectuer la somme en binaire :11012 + 01112 et interpréter le résultat en arithmétiquesignée et non signée.

Solution

1 Intervalle des valeurs possibles en binaire pur sur 11 bits.

Avec 11 bits, le nombre de combinaisons possibles est112 = 2048. L’intervalle desvaleurs est donc : [0, 2047].

2 Intervalle des valeurs possibles en complément à 2 sur 11 bits.

On a vu dans le chapitre précédent que le codage en complément à 2 était équilibré,c’est à dire qu’il code autant de nombres strictement négatifs que de nombres positifsou nuls. Pour respecter cet équilibre avec 2048 codes, il nous faut nécessairement1024 codes positifs ou nuls et 1024 codes strictements négatifs, soit l’intervalle :[-1024, +1023].

3 Somme binaire11012 + 01112.En effectuant la somme bit à bit, on trouve01002 avec 1 de retenue sortante.

En arithmétique non signée, la retenue doit être prise en compte, et elle signale undébordement ; on peut tout de même intégrer ce bit de retenue comme bit de poidsfort du résultat. On a donc fait la somme 13 + 7 et on trouve101002, soit la valeurattendue 20.

En arithmétique en complément à 2, la retenue est ignorée.Les nombres ajoutés sont -3et +7et le résultat est +4,ce qui est également correct.Un débordement était impossible

6. Exercices corrigés 17

ici, car on ajoutait un nombre positif à un nombre négatif.

Chapitre II

Éléments de logique combinatoire

1. Circuits combinatoiresEn 1854,Georges Boolepublia son ouvrage séminal sur une algèbre manipulant des

informations factuelles vraies ou fausses. Son travail a été redécouvert et développé sousla forme que nous connaissons maintenant parShannon.Le nom de Boole est entré dansle vocabulaire courant, avec l’adjectifbooléenqui désigne ce qui ne peut prendre que deuxvaleurs distinctes ’vrai’ou ’faux’.

Circuits combinatoires : définition

Uncircuit combinatoireest un module tel que l’état dessortiesne dépend que de l’étatdes entrées. L’état des sorties doit être évalué une fois que les entrées sont stables, et aprèsavoir attendu un temps suffisant à la propagation des signaux. On comprend intuitivementque les circuits combinatoires correspondent à des circuits sans état interne : face à la mêmesituation (les mêmesentrées), ils produisent toujours les mêmes résultats (les mêmessorties).Un module d’addition en est un bon exemple : il a en entrées les signauxAetBà additionner,ainsi qu’une retenueCIN d’un étage précédent ; il fournit en sortie la sommeSet une retenueCOUT pour un étage suivant :

Si un circuit combinatoire est composélui-même de sous-circuits combinatoires,on démontre que la définition de base est équivalente au fait que ces sous-circuits sontconnectés entre eux sans rebouclages.Plus précisément, si on range les signaux de gauche àdroite, en mettant tout a fait à gauche les entrées, puis dans chaque colonne les sous-circuitsqui ont des entrées parmis les signaux produits dans la colonne de gauche, ou de colonnesplus à gauche, alors le circuit est combinatoire si et seulement s’il n’y a aucune liaison quireboucle ’en arrière’, en allant d’un étage à un étage plus à gauche (figure II.2).

L’implication dans le sens ’sans rebouclage’→ ’combinatoire’est facile à démontrer :si les entrées à gauche sont stables, alors par construction toutes les sorties des sous-circuitsde la première colonne sont stables, et ne dépendent que de ces entrées. Donc les sorties dessous-circuitsde la colonne 2 sont stables,et ne dépendent que des entrées.On démontre ainsipar récursion que les sorties des circuits de chaque colonne sont stables et ne dépendent quedes valeurs des entrées, jusqu’aux sorties finales. Le circuit est donc combinatoire.

18

1. Circuits combinatoires 19

...

entrées sorties

...

Figure II.2. Circuit combinatoire : les signaux internes et les sorties ne rebouclent pasen arrière.

Les figures II.3 et II.4 montrent des exemples de circuits combinatoires et noncombinatoires formés à partir de portes logiques, dont on verra dans lessous-sectionssuivantes qu’elles sont elles-mêmes combinatoires.

Figure II.3. Exemples de circuits combinatoires : les éléments internes sont eux-mêmescombinatoires,et il n’y a pas de rebouclage interne.

Figure II.4. Exemples de circuits non combinatoires : il y a des rebouclages internes.

20 CHAPITREII. ÉLÉMENTS DE LOGIQUE COMBINATOIRE

2. Tables de véritéUne des contributionsessentiellesde Boole est latable de vérité, qui permet de capturer

les relations logiques entre les entrées et les sorties d’un circuit combinatoire sous uneforme tabulaire.

Considérons par exemple un circuit inconnu possédant 2 entrées A et B et une sortie S.Nous pouvons analyser exhaustivement ce circuit en lui présentant les22 = 4jeux d’entréesdifférents, et en mesurant à chaque fois l’état de la sortie. Le tout est consigné dans untableau qu’on appelle table de vérité du circuit (figure II.5).

A B S

0 0 0

0 1 0

1 0 0

1 1 1

Figure II.5. Un circuit à deux entrées et une sortie,et sa table de vérité.

Ici, on reconnaît l’opération logique ET : S vaut 1 si et seulement si A et B valent 1.

La construction d’une table de vérité est bien sûr généralisable à un nombrequelconquend’entrées et un nombremde sorties.Elle possédera alorsn2 lignes, ce qui n’estpraticable que pour une valeur den assez petite.

3. Algèbre et opérateurs de base

Plutôt que de décrire en extension la relation entre les entrées et une sortie, on peutla décrire en intention à l’aide d’une formule de calcul utilisant seulement troisopérateursbooléens :NON, ET, OU.

NON

NON (NOT en anglais) est un opérateur unaire, qui inverse son argument. On noteragénéralementNOT(A) = −

A ; et sa table de vérité est :

A −A

0 1

1 0

Figure II.6. Table de vérité du NON,et dessin de la porte correspondante.

On a bien sûr :−−A = A.

3. Algèbre et opérateurs de base 21

ET

ET (AND en anglais) est un opérateur à 2 entrées ou plus, dont la sortie vaut 1 si etseulement si toutes ses entrées valent 1. On le note algébriquement comme un produit, c’està direS = A ⋅ B ouS = AB. La table de vérité d’un ET à deux entrées, et le dessin usuel dela porte correspondante sont représentés figure II.7.

A B A ⋅ B

0 0 0

0 1 0

1 0 0

1 1 1

Figure II.7. Table de vérité du ET,et symbole de la porte correspondante.

De par sa définition, le ET est associatif :A ⋅ B ⋅ C = (A ⋅ B) ⋅ C = A ⋅ (B ⋅ C). Il estégalement idempotent :A ⋅ A = A.

OU

OU (OR en anglais) est un opérateur à 2 entrées ou plus, dont la sortie vaut 1 si etseulement si une de ses entrées vaut 1. On le note algébriquement comme une somme, c’està direS = A + B. La table de vérité d’un OU à deux entrées, et le dessin usuel de la portecorrespondante sont représentés figure II.8.

A B A + B

0 0 0

0 1 1

1 0 1

1 1 1

Figure II.8. Table de vérité du OU,et symbole de la porte correspondante.

De par sa définition, le OU est associatif :A + B + C = (A + B) + C = A + (B + C). Ilest également idempotent :A + A = A.

De la table de vérité à la formule algébrique

On peut automatiquement écrire la formule algébrique d’une fonction booléennecombinatoire dès lors qu’on a sa table de vérité. Il suffit de considérer seulement les lignesqui donnent une sortie égale à 1, d’écrire leminterm correspondant, qui code sous formed’un ET la combinaison de ces entrées. Par exemple, le minterm associé au vecteur(A, B,C) = (1, 0, 1)est :A

−BC. La formule algébrique qui décrit toute la fonction est le OU de tous

ces minterms.


Considérons par exemple la table de vérité de la fonctionmajoritéà 3 entrées,qui vaut1 lorsqu’une majorité de ses entrées (2 ou 3) vaut 1 (figure II.9).

A B C MAJ(A,B,C)

0 0 0 0

0 0 1 0

0 1 0 0

0 1 1 1

1 0 0 0

1 0 1 1

1 1 0 1

1 1 1 1

Figure II.9. Table de vérité de la fonction majorité à 3 entrées.

La table de vérité contient 4 lignes avec une sortie S à 1, ce qui donne :

S = −ABC + A

−BC + −

ABC + ABC

Cette formule est simplifiable, comme on le verra dans une section ultérieure.

Est-on sûr que la formule obtenue par cette méthode est correcte ? Pour unecombinaison des entrées qui doit donner une sortie à 1, la formule possède le mintermcorrespondant,et donne aussi une valeur de 1.Pour toutes les autres combinaisonsd’entrées,la table donne une sortie à 0, et la formule aussi, puisqu’aucun minterm n’est présent quicorresponde à ces combinaisons. La formule donne donc toujours le même résultat quela table.

Corollairement, cela démontre le résultat fondamental suivant :

N’importe quelle fonction combinatoire s’exprime sous forme d’une sommede minterms.

Théorèmes de l’algèbre de Boole

Le tableau de la figure II.10 résume les principaux théorèmeset propriétésde l’algèbrede Boole.On peut les démontrer de façon algébrique, ou en utilisant des tables de vérité.

Lesthéorèmes de De Morganpermettent de transformer les ET en OU et vice-versa.Le couple (ET,NON) ou le couple (OU,NON) suffisent donc à exprimer n’importe quelleformule algébrique combinatoire.

Le théorème d’absorptionA + AB = Amontre qu’un terme plus spécifique disparaît auprofit d’un terme moins spécifique. Par exemple dans l’équation⋅ ⋅ ⋅ + −

AB + −AB

−C ⋅ ⋅ ⋅ , le

terme−AB

−C s’efface au profit de

−AB, moins spécifique et qui donc l’inclut.

3. Algèbre et opérateurs de base 23

relation relation duale Propriété

AB = BA A + B = B + A Commutativité

A(B + C) = AB + AC A + BC = (A + B)(A + C) Distributivité

1 ⋅ A = A 0 + A = A Identité

A−A = 0 A + −

A = 1 Complément

0 ⋅ A = 0 1 + A = 1 Zéro et un

A ⋅ A = A A + A = A Idempotence

A(BC) = (AB)C A + (B + C) = (A + B) + C Associativité−−A = A Involution

−AB = −

A + −B

−A + B = −

A−B Théorèmes de De Morgan

A(A + B) = A A + AB = A Théorèmes d’absorption

A + −AB = A + B A(−A + B) = AB Théorèmes d’absorption

Figure II.10. Propriétés et théorèmes de l’algèbre de Boole.

4. Autres portes logiques

NAND

NAND (= NOT AND) est un opérateur à 2 entrées ou plus, dont la sortie vaut 0 si etseulement si toutes ses entrées valent 1.On le note↑, et on a donc à deux entrées :A↑B =−A ⋅ BLa table de vérité d’un NAND à deux entrées, et le dessin usuel de la porte correspondantesont représentés figure II.11.

A B A↑B

0 0 1

0 1 1

1 0 1

1 1 0

Figure II.11. Table de vérité du NAND,et dessin de la porte correspondante.

Le NAND est un opérateur ditcomplet, c’est à dire qu’il permet à lui seul d’exprimern’importe quelle fonction combinatoire. Il permet en effet de former un NOT, en reliant sesdeux entrées :

−A = A↑A. Les théorèmes de De Morgan assurent donc qu’il peut exprimer un

ET et un OU, et donc n’importe quelle expression combinatoire.

NOR

NOR (= NOT OR) est un opérateur à 2 entrées ou plus, dont la sortie vaut 0 siet seulement au moins une de ses entrées 1. On le note↓, et on a donc à deux entrées :A


↓ B = −A + B La table de vérité d’un NOR à deux entrées, et le dessin usuel de la portecorrespondante sont représentés figure II.12.

A B A↓B

0 0 1

0 1 0

1 0 0

1 1 0

Figure II.12. Table de vérité du NOR,et dessin de la porte correspondante.

Comme le NAND, le NOR est également unopérateur complet. Il permet en effetde former un NOT, en reliant ses deux entrées :

−A = A↓ A. Lesthéorèmes de De Morgan

assurent donc qu’il peut exprimer un ET et un OU, et donc n’importe quelle expressioncombinatoire.

XOR

XOR (= EXCLUSIVE OR) est un opérateur à 2 entrées ou plus. On peut le définir deplusieurs façons ; la définition qui permet le plus directement de démontrer ses propriétésest celle qui consiste à en faire un détecteur d’imparité : sa sortie vaut 1 si et seulement siun nombre impair de ses entrées est à 1. On le note⊕ ; la table de vérité d’un XOR à deuxentrées, et le dessin usuel de la porte correspondante sont représentés figure II.13.

A B A ⊕ B

0 0 0

0 1 1

1 0 1

1 1 0

Figure II.13. Table de vérité du XOR,et dessin de la porte correspondante.

On voit à partir de la table queA ⊕ B = A−B + −

AB. Lorsqu’il a deux entrées, il mériteson nom de OU exclusif puisque sa sortie ne vaut 1 que si l’une de ses entrées vaut 1, maisseulement une. Il possède plusieurs autres propriétés intéressantes :

• lorsqu’on inverse une entrée quelconque d’un XOR, sa sortie s’inverse.C’est évidentpuisque cela incrémente ou décrémente le nombre d’entrées à 1, et donc inverse laparité.

• le XOR à deux entrées est uninverseur commandé.En effet, en examinant la table devérité du XOR (figure II.13)), on constate que lorsque A vaut 0, la sortie S reproduit

4. Autres portes logiques 25

l’entrée B, et lorsque A vaut 1, la sortie S reproduit l’inverse de l’entrée B. L’entréeA peut être alors vue comme une commande d’inversion dans le passage de B vers S.Cette fonction sera très utile lorsqu’on souhaitera corriger une erreur détectée sur uneligne, par exemple.

• le XOR est un opérateur d’addition arithmétique.Cette propriété est valable quel quesoit le nombre d’entrées du XOR. Bien sûr, il n’est question ici que du bit de poidsfaible du résultat (ajoutern termes de 1 bit produit un résultat sur log2(n) bits). Et eneffet, si on regarde la table de vérité du XOR à deux entrées, on constate que la sortieest bien la somme arithmétique des deux entrées.Bien sûr à la dernière ligne, le résultatà une retenue que le XOR à lui seul ne peut pas produire.

On peut démontrer que ce résultat est général par une simple récurrence. Si eneffet on suppose queXOR(e1,e2,…, en) fournit le bit de poids faible de la sommesn =e1 + e2 + … + en, alors :

XOR(e1,e2,…, en,en+1) = sn si en+1 = 0 ; −sn si en+1 = 1= sn avec inversion commandée paren+1

= sn ⊕ en+1

• XOR est un opérateur associatif.Sa définition même, en tant qu’indicateur d’imparité,assure cette propriété.Quelle que soit la façon de grouper les termes, le calcul donnerale même résultat. Ce résultat permet de construire avec un minimum de circuits desXORs à 3 entrées ou plus, en cascadant des XORs à 2 entrées.

Formule algébrique d’un XOR à plus de 2 entrées

Considérons le calcul du XOR de trois variables A, B et C. On sait que son expressionalgébrique peut se mettre sous forme d’une somme de minterms ; on va donc chercher parmitous les minterms possibles ceux qu’il faut inclure dans la formule, et ceux qu’il faut rejeter.Avec ces trois variables A, B et C, il y a 8 minterms possibles :

−A−B−C,

−A−BC,

−AB

−C, …−

A−B−C ne

doit pas être inclus dans le résultat,puisqu’il donne 1pour le vecteur(0,0,0)qui ne comportepas un nombre impair de 1.

−A−BCdoit l’être, car il donne 1pour le vecteur(0,0,1)qui possède

un nombre impair (1) de 1. La règle est simple : on doit inclure seulement les minterms quiont un nombre impair de variables non barrées. Pour le XOR à trois entrées, on peut le fairede façon organisée en mettant d’abord les 3 minterms ayant une variable non barrée, puis leminterm ayant les 3 variables non barrées :

XOR(A, B, C) = A−B−C + −

AB−C + −

A−BC + ABC

On peut montrer que cette formule n’est pas simplifiable en tant que somme de termes.

Pour un XOR à 4 entrées, on inclut les 4 minterms ayant 1 variable non barrée, puis les 4minterms ayant 3 variables non barrées :

XOR(A, B, C, D) = A−B−C

−D + −

AB−C

−D + −

A−BC

−D + −

A−B−CD + ABC

−D + AB

−CD + A

−BCD + −

ABCD

Pour un nombre quelconque d’entrées, on peut montrer que le résultat comporte toujours lamoitié de tous les minterms possibles, et que cette somme n’est jamais simplifiable en tant


que somme de termes.

Le multiplexeur

Le multiplexeurest une porte à trois entrées, qui joue un rôle d’aiguillage.Son dessinindique bien cette fonction (figure II.14).

SEL S

0 A

1 B

Figure II.14. Table de vérité condensée du multiplexeur, et dessin de la porte corres-pondante.

Lorsque la commande de sélection vaut 0, l’aiguillage est du côté de A, et S prend la valeurde A ; lorsqu’elle vaut 1, S prend la valeur de B. Algébriquement, on a donc :

S = −SEL·A+ SEL·B

À partir de la compréhension du rôle du multiplexeur, il est clair que :

−S = −SEL·

−A + SEL·

−B

Or ce n’est pas si facile à établir algébriquement :−S =−−SEL·A+ SEL·B=

−−SEL·A·

−SEL·B

−S = (SEL+ −

A)·(−SEL+ −B) = −

A·−SEL+ SEL·

−B + −

A·−B

On a un terme en trop,−A·

−B ! En fait, on peut le faire disparaître en écrivant

−A·

−B = −

A·−B·

SEL+ −A·

−B·−SEL:

−S = −

A·−SEL+ SEL·

−B + −

A·−B·SEL+ −

A·−B·−SEL

−S = −

A·−SEL(1 + −

B) + SEL·−B(1 + −

A) = −SEL·−A + SEL·

−B

On a ici un exemple où la compréhension d’une fonction a permis de se dispenser decalculs algébriques ou de méthodes de simplification.

5. SHDL, un langage de description matérielle pédagogique

Les langages de description matérielle (HDL)

Un langage de description matérielle, ouHDL (Hardware Description language),permet la description de circuits logiques sous une forme textuelle. Cette description peutensuite être utilisée par un simulateur pour être testée, ou elle peut être traduite par un

5. SHDL,un langage de description matérielle pédagogique 27

programme de synthèse afin d’être utilisée pour la fabrication d’un circuit logique spécifique(ASIC), ou pour pouvoir programmer un circuit logique reconfigurable tel qu’unPLD ouunFPGA (section 6).

Certains langages de description sontstructurelset d’autres sontfonctionnels. Unlangage de description structurel précise explicitement tous les modules et sous modulesqui sont utilisés dans le circuit. Si l’on veut implémenter une addition, il va falloir entrerdans tous les détails de sa conception.À l’inverse,un langage fonctionnel va décrire certainsaspects de son fonctionnement sous forme d’une fonction et donc de façon non explicite niextensive.L’addition de deux registres A et Bsera par exemple écrite A + B, sans entrer dansles détails de sa réalisation matérielle. La plus grande lourdeur des langages de descriptionstructurels doit être tempérée par le fait qu’ils sont généralement tous modulaires,et que descircuits tels que des additionneursexistent déjà sous forme de modules tout prêts disponiblesdans des bibliothèques. Néanmoins, ce sont les langages fonctionnels qui deviennent lesplus largement utilisés, tels queVHDL etVerilog.ABEL etPALASM sont des exemples delangages structurels, ABEL étant le plus populaire. ABEL existe depuis 1983, et il a encoreune grande communauté de concepteurs qui l’utilise.

SHDL, un langage structurel pédagogique

SHDL est un langage de description matérielle issu du langageMDL conçuinitialement par Jean Conter, au département informatique de l’ENSEEIHT de Toulouse.SHDL signifie Simple Hardware Description Language; il est d’une écriture très simple etil encourage en effet une conception hautement modulaire, en supprimant tout simplementles déclarations habituelles à faire pour qu’un circuit déjà conçu puisse être réutilisé en tantque ’boîte noire’ dans un circuit de niveau supérieur. La syntaxe de SHDL est proche decelle d’ABEL, en en étant encore plus simple, et il est comme lui un langage de descriptionstructurel. Comme il a d’abord une visée pédagogique, ce choix permet d’examiner lefonctionnement des circuits conçus, jusqu’à la plus petite échelle.

Un éditeur graphique et un simulateur ont été conçus pour le langage SHDL.Cet environnement est disponible sous forme de licenceGPL, donc gratuit, utilisable etmodifiable à volonté. Le lecteur est fortement encouragé à simuler tous les exemples de celivre dans l’environnement SHDL.

L’environnement libre et complet d’édition graphique et de simulation,ainsi qu’une documentation complète du logiciel sont disponibles à l’adressehttp://diabeto.enseeiht.fr/download/shdl.

Premiers éléments de syntaxe SHDL

La syntaxe de SHDL sera décrite progressivement au fil des chapitres.

Un exemple simple sera plus parlant qu’un long discours :

module half_adder(a,b: s,r)s = /a*b+a*/b ;r = a*b ;end module

Ce module, appeléhalf_adder, possède 2 entrées appeléesa etb, et deux sortiess et r.La première lignemodule half_adder(a,b :s,r) fournit donc le nom et l’interfacedu module.


On notera la présence du signe ’:’ pour marquer la séparation entre les entrées et lessorties ; en réalité ce signe n’est pas obligatoire car le logiciel peut deviner seul lesfonctions de ces signaux, mais ils peuvent rendre l’écriture plus lisible. L’écrituremodulehalf_adder(a,b,s,r) aurait donc été équivalente. On notera également la présence dela dernière ligneend module , qui termine la définition du module. Elle est obligatoire, etelle permet ainsi de placer plusieurs définitions de modules dans un même fichier, chaquedéfinition étant encadrée par un début commençant parmodule et une finend module .

Viennent ensuite des lignes, terminées par le signe ’;’, qui décrivent comment lessignauxs et r sont produits à partir dea etb. Le signe ’/’ indique la négation, et s’appliqueau symbole immédiatement à sa droite./a et /b signifient donc−a et

−b. Les signes ’+’ et ’*’

indiquent les opérations OU et ET respectivement ; les deux lignes s’interprètent donc :s =−ab + a

−b et r = ab.

Les parenthèses sont interdites en SHDL dans les expressions ; elles ne peuventapparaître que dans la description de l’interface. En particulier, on ne peut pas écriredes négations de la forme/(a+b) ; il faudra utiliser le théorème de De Morgan etécrire /a*/b . Cette contrainte n’est pas une limitation, puisqu’on sait que toute formulealgébrique peut se mettre sous forme d’une somme de minterms. Par ailleurs cette écritureest adaptée à la synthèse de circuits logiques reconfigurables de typePLD ouFPGA.

Finalement, l’éditeur graphique de l’environnement SHDL permet d’afficher lecontenu d’un tel module (figure II.15).

module half_adder(a,b: s,r)s = /a*b+a*/b ;r = a*b ;end module

Figure II.15. Demi-additionneur en SHDL.

6. Circuits logiques reconfigurables ; PLD et FPGA

Un circuit logique programmable est un composant électronique qui réalise desfonctions combinatoires et séquentielles, mais dont le contenu est modifiable, décrit lorsd’une phase de programmation (ou reconfiguration).Les premiersmodèlesne pouvaient êtreprogrammés qu’une fois, mais la plupart des modèles actuels permettent plusieurs milliers

6. Circuits logiques reconfigurables ; PLD et FPGA 29

de cycles d’effaçage et réécriture.Un tel circuit est un peu plus lent que le même circuit fixequi aurait été produit spécifiquement (ouASIC), mais son coût est faible pour des petitesproductions, et sa reprogrammmation permet une phase de mise au point interactive, etautorise des mises à jours après déploiement.

PLD

PLD signifie ’Programmable Logic Device’. Un PLD se caractérise par :

• un nombre de composants plus faible qu’un FPGA.

• une consommation plus faible que celle d’un FPGA.

• une absence de phase de ’bootstrap’. Une fois configuré, un PLD conserve saconfiguration même hors tension, et il est opérationnel immédiatement après la misesous tension.

Les premiers PLDs s’appelaient PALs et GALs, et ils n’étaient programmables qu’une fois.Leur programmation nécessitait l’utilisation d’un programmateur spécial,et ils devaient êtreplacés sur un support si on voulait profiter de leur reprogrammabilité.

Les PLDs plus complexes sont souvent appelésCPLDs. Leur configuration est stockéedans uneEEPROM ou mémoire flash, qui peut être mise à jour en utilisant le protocoleJTAG (voir plus loin).

FPGA

Un FPGA (Field Programmable Gate Array) utilise une organisation de type matricede portes, qui permet un nombre de composants plus grands. Sa configuration est stockéedans une RAM, qui doit être rechargée à chaque remise sous tension, généralement à partird’une ROM présente sur la carte. Cette particularité qui semble être un inconvénient luidonne la possibilité très intéressante de pouvoir être reconfiguré dynamiquement, durantson fonctionnement.

Programmation JTAG

La plupart des PLDs et des FPGAs sont configurables directement sur le circuitimprimé où ils vont être placés, sans programmateur, en utilisant un protocole standardde programmation à l’aide d’un flux sériel de données appelé protocole JTAG. Tous lescomposants programmables présents sur le circuit imprimé sont reliés ensemble en ’daisychain’ (figure II.16).

TDI

CPLD FPGA

TMS

TCK

ROMFlash

TDI TDITDI

TDO

TDO TDOTDO

TMS

TCK TCK TCK

TMS TMS

Figure II.16. Chaîne de programmation JTAG.On peut mélanger des circuits de tous types,et même parfois de différents constructeurs.


Un interface très simple permet généralement d’exploiter les 5 signaux du protocole àpartir de l’ordinateur de développement. Un logiciel de programmation permet d’effectuerune opération de lecture ou de configuration sur un ou plusieursdes composantsde la chaîne,sans affecter les autres. Comme ce protocole est standard, il est généralement possible demélanger dans cette chaîne des composants de différents constructeurs.

Des cartes d’expérimentation à base de PLD ou de FPGA, programmables à l’aided’un tel câble JTAG sont maintenant accessibles à faible coût, et permettent de réaliser dessystèmeséquivalentsà plusieurscentainesde milliersde portes.Les outils de développementet de configuration sont tous fermés et propriétaires,et le développement d’environnementsouverts est découragé par la non divulgation des spécifications internes précises descomposants.

7. Méthodes de simplification des fonctions combinatoires

7.1. Tables de Karnaugh

UnetabledeKarnaughest utilisée pour trouver visuellement les simplificationsà fairesur une somme de termes. Elle est très facile à utiliser, pour peu qu’il n’y ait pas plus de 4variables en jeu. Au delà, il vaut mieux employer la méthode deQuine-Mc Cluskey décriteplus bas.

Considérons par exemple la fonction ayant la table de vérité de la figure II.17.

A B C D S0 0 0 0 00 0 0 1 10 0 1 0 10 0 1 1 10 1 0 0 00 1 0 1 10 1 1 0 00 1 1 1 11 0 0 0 01 0 0 1 11 0 1 0 01 0 1 1 11 1 0 0 11 1 0 1 11 1 1 0 11 1 1 1 1

Figure II.17. Table de vérité d’une fonction à simplifier.

On va représenter les valeurs de S dans un tableau 4X4, chaque case correspondant àun des 16 minterms possibles avec 4 variables A,B,C et D (figure II.18).

On remarquera d’abord les libellés des lignes et des colonnes, qui forment uncode deGray :d’une ligne à l’autre ou d’une colonne à l’autre, il n’y a qu’un bit d’entrée qui change.La table a une forme de cylindre dans les deux directions, c’est à dire que les colonnes ’00’et ’10’doivent être considérées comme côte à côte, tout comme les lignes ’00’et ’10’.

7. Méthodes de simplification des fonctions combinatoires 31

0,0 0,1 1,1 1,0

0,1

1,1

1,0

0,0

A,B

C,D

1

1

1

111

1

1

1

1

1

Figure II.18. Table de Karnaugh représentant la table de vérité.

Les 11 sorties ’1’ de la table de vérité ont été reportées dans la table de Karnaugh. Eneffectuant des groupes de ’1’ connexes de 2, 4 ou 8, on réalise une simplification (figureII.19).

0,0 0,1 1,1 1,0

0,1

1,1

1,0

0,0

A,B

C,D

1

1

1

111

1

1

1

11

A B

D

A B C

Figure II.19. Table de Karnaugh avec les regroupements.

Par exemple leregroupement−A

−BC correspond àla simplification

−A

−BCD + −

A−BC

−D

= −A−BC(D + −

D) = −A−BC. De même, le regroupementABcorrespond à la simplification des 4

termes :AB−C

−D + AB

−CD + ABC

−D + ABCD= AB(−C−

D + −CD + C

−D + CD) = AB. On repère

facilement le résultat en regardant les libellés des lignes et des colonnes impliqués dansla simplification. Pour le terme simplifiéD par exemple, il concerne les lignes CD=01 ;11et les colonnes AB=**; seul D = 1 est constant, et toutes les autres variables disparaissent.Finalement on a :

S = D + AB + −A

−BC

Utilisation des combinaisons non spécifiées

Il y a des situationsdans lesquellescertainescombinaisonsdes entrées ne se produisentjamais, qu’on peut appelercombinaisons interditesou combinaisons non spécifiées.Considérons par exemple un décodeur 7 segments, qui convertit un nombre binaire sur 4bits en un vecteur de 7 bits qui commande un afficheur à Leds de type ’calculette’ (figureII.20).

La spécification de ce convertisseur nous précise qu’il ne faut convertir que les chiffresde 0 à 9, c’est à dire les valeurs du vecteur (A,B,C,D) de (0,0,0,0) à (1,0,0,1). Ainsi lefonctionnement du circuit n’est pas spécifié pour les valeurs de (1,0,1,0) à (1,1,1,1), et on va


a

fg

ed c

b

4 7

(a,b,c,d,e,f,g)(A,B,C,D)

Figure II.20. Convertisseur 7 segments pour afficheur de calculette.

exploiter cette latitude pour simplifier les équations.

Si on considère par exemple la table de vérité du segmenta, elle comporte ainsi 6 lignespour lesquelles la valeur de la sortie n’est pas spécifiée, qu’on note ’*’ (figure II.21).

A B C D a0 0 0 0 10 0 0 1 00 0 1 0 10 0 1 1 10 1 0 0 00 1 0 1 10 1 1 0 10 1 1 1 11 0 0 0 11 0 0 1 11 0 1 0 *1 0 1 1 *1 1 0 0 *1 1 0 1 *1 1 1 0 *1 1 1 1 *

Figure II.21. Table de vérité du segment a.

Dans la table de Karnaugh correspondante, les ’*’ peuvent être incluses dans lesregroupements (figure II.22) ce qui conduit à leur donner la valeur ’1’. Bien sûr on ne doitpas chercher à inclure toutes les ’*’dans les regroupements :on cherche à inclure tous les ’1’,mais les ’*’permettent de trouver des regroupements plus grands. Ici par exemple, on trouvele résultat très simple :

a = C + A + BD + −B−D

Détection et correction des glitches

Un autre usage des tables de Karnaugh est la détection desglitchs, c’est à diredes changements très brefs des signaux de sortie d’une fonction combinatoire lors dechangements des entrées. Considérons par exemple la fonction suivante :

S = −A

−B−C

−D + −

AB−C

−D + AB

−C

−D + AB

−CD + ABC

−D + ABCD

On construit directement la table de Karnaugh associée à cette fonction, et on trouve


0,0 1,01,10,1A

B D

BD

C

*

**

*

*

*

1

1

1 1

1

1

1

C,D

1

A,B

0,0

1,0

1,1

0,1

Figure II.22. Table de Karnaugh du segment a, avec les combinaisons non spécifiéesmarquées par des ’*’.On peut inclure les ’*’ pour former des regroupements plus grands.

immédiatement deux regroupements (figure II.23).

0,0 0,1 1,1 1,0

0,1

1,1

1,0

0,0

A,B

1

1

1

1

1 1 baC,D

Figure II.23. Table de Karnaugh avec les regroupements. Un glitch est possible dans lepassage de a à b,car les deux regroupements sont tangents à cet endroit.

L’équation simplifiée est alors :

S = AB + −A−C

−D

Cette équation est plus simple que la première, mais elle va se comporter légèrementdifféremment lors de certains changements de valeurs des entrées.Considérons par exemplele changement du vecteur d’entrées (A,B,C,D) de (0,1,0,0) à (1,1,0,0), qui correspond aupassage dea àb sur la figure II.23. Dans ce cas, seul A a changé, et la sortie S devrait resterà 1, aussi bien pour l’équation initiale que pour l’équation simplifiée. Or pour l’équationsimplifiée, le termeABva passer de 0 à 1 tandis que le terme

−A−C

−D va passer de 1 à 0 ; si ce

changement se fait exactement en même temps, S restera à 1, mais si le premier terme passeà 0 légèrement avant que le deuxième ne passe à 1, un léger glitch sur S apparaîtra (figureII.24).

Ce glitch était prévisiblevisuellementsur la table de Karnaugh, par le fait des deuxregroupements qui sont adjacents sans se recouvrir. On constate également que c’est le seulchangement d’une seule variable qui peut conduire à un tel problème. La solution est derajouter un regroupement qui va faire la liaison entre ces deux groupes, en valant 1pendanttoute la transition (figure II.25).

Finalement, on obtient l’expression simplifiée sans glitch :


A.C.D

A.B

A

glitchS = A.B + A.C.D

Figure II.24. Glitch sur l’équation S= AB+−A−C−D,lors du passage de (A,B,C,D) de (0,1,0,0)

à (1,1,0,0).

0,0 0,1 1,1 1,0

0,1

1,1

1,0

0,0

A,B

1

1

1

1

1 1 baC,D

terme supplémentaire

B.C.D

A.C.D

S = A.B + A.C.D + B.C.D

A

A.B

Figure II.25. Ajout du terme B−C−D pour maintenir S à 1 lors de la transition de a vers b.Le

glitch disparaît sur le signal de sortie S.

S = AB + −A−C

−D + B

−C

−D

7.2. Méthode de Quine-Mc Cluskey

On va montrer son usage en simplifiant la fonction à 5 variables suivante :

f (A, B, C, D, E) = −A

−B−C

−D

−E + −

A−B−CD

−E + −

AB−C

−D

−E + −

AB−CD

−E + −

ABC−D

−E + −

ABC−DE

+ AB−CD

−E + ABC

−DE + ABCD

−E

Une table de Karnaugh serait délicate à utiliser dans ce cas, car elle aurait une taille de 4 x8, et certains regroupements possibles pourraient ne pas être connexes.

Par économie d’écriture, on commence par représenter chaque minterm par le nombreassocié à sa représentation binaire :

f (A, B, C, D, E) = ∑(0, 2, 8, 10, 12, 13, 26, 29, 30)


On place ensuite ces minterms dans un tableau, en les groupant selon le nombre de 1qu’ils possèdent (figure II.26).

nombre de 1 minterm valeur binaire

0 0 00000

1 2 00010

8 01000

2 10 01010

12 01100

3 13 01101

26 11010

4 29 11101

30 11110

Figure II.26. On classe les minterms selon le nombre de 1 de leur valeur binaire.

Les simplifications ne peuvent se produire qu’entre groupes adjacents. Lasimplification entre les minterms 1 et 2 se notera par exemple :000-0, en mettant un tiret àl’endroit où la variable a disparu. Lorsqu’on a effectué toutes les simplifications possibles,on recommence à partir des nouveaux groupes formés, jusqu’à ce qu’aucune simplificationne soit possible (figure II.27).

étape 1 étape 2 étape 3

0 00000 ✓

2 00010 ✓

8 01000 ✓

10 01010 ✓

12 01100 ✓

13 01101 ✓

26 11010 ✓

29 11101 ✓

30 11110 ✓

0-2 000-0 ✓

0-8 0-000 ✓

2-10 0-010 ✓

8-10 010-0 ✓

8-12 01-00

10-26 -1010

12-13 0110-

13-29 -1101

26-30 11-10

0-2-8-10 0-0-0

Figure II.27. On simplifie entre groupes adjacents,étape par étape.Les termes qui ont étéutilisés dans une simplification sont cochés.

Maintenant, il suffit de choisir dans ce tableau les termes qui vont inclure tous lesminterms de départ, en essayant de trouver ceux qui correspondent à l’expression la plus


simple.On peut le faire de façon purement intuitive,en commençant par les termes les plus àdroite :par exemple les groupes0-2-8-10,8-12, 13-29, 26-30 vont inclure tous les minterms.On trouve donc :

S = −A−C

−E + −

AB−D

−E + BC

−DE + ABD

−E

Dans les cas complexes, ou si on veut programmer cet algorithme, on énumère la liste desimplicants premiers, qui sont les termes du tableau précédent qui n’ont été utilisés dansaucune simplification. Dans le tableau précédent, on a coché avec une ’✓ ’ les termes qui ontété utilisés dans une simplification, donc la liste des implicants premiers est : 8-12, 10-26,12-13, 13-29, 26-30, 0-2-8-10. Il est clair que le résultat simplifié ne comportera que destermes de cette liste, et le but est de déterminer parmi eux ceux qu’il est indispensable deplacer dans le résultat,appelésimplicants premiers essentiels.On construit pour cela la tabledes implicants premiers (figure II.28).

0 2 8 10 12 13 26 29 30

8-12 01-00 ✓ ✓

10-26 -1010 ✓ ✓

12-13 0110- ✓ ✓

13-29 -1101 * ✓ ✓

26-30 11-10 * ✓ ✓

0-2-8-10 0-0-0 * ✓ ✓ ✓ ✓

Figure II.28. Table des implicants premiers ; les implicants premiers sont en lignes et lesminterms de départ sont en colonnes.Un implicant premier est dit essentiel s’il est le seulà couvrir un des minterms en colonne ; on le repère avec une marque ’*’.

Parmi les 5 minterms placés en ligne dans le tableau, 3 sont ditsessentiels, parce qu’ilssont les seuls à couvrir un des minterms placés en colonnes : l’implicant premier 13-29 estle seul à couvrir le minterm 29, 26-30 est le seul à couvrir 26 et 30, et 0-2-8-10 est le seul àcouvrir les minterms 0 et 2. 8-12 et 12-13 ne sont pas essentiels, car 8, 12 et 13 sont couvertspar d’autres implicants premiers.

Les implicants premiers essentiels sont nécessaires, mais pas forcement suffisants. Icipar exemple, si on ne prenait qu’eux, le minterm 12 ne serait pas couvert. Il reste donc unephase heuristique de choix parmi les implicants premiers non essentiels pour couvrir tousles minterms non encore couverts.Dans notre exemple, on peut ajouter, soit 8-12, soit 12-13pour couvrir le 12 manquant, ce qui donne les deux possibilités suivantes :

version avec 8-12 :S = −A−C

−E + −

AB−D

−E + BC

−DE + ABD

−E

version avec 12-13 :S = −A−C

−E + −

ABC−D + BC

−DE + ABD

−E

8. Circuits combinatoires réutilisables 37

8. Circuits combinatoires réutilisablesNous cherchons à développer une bibliothèque de circuits combinatoires (et ensuite

séquentiels) qui seront réutilisables dans différents contextes, et notamment celui desmicroprocesseurs et des microcontrôleurs. Parmi eux figurent des opérateurs efficacesd’arithmétique entière : additionneurs, multiplieurs, comparateurs. Un interface adaptépermettra une récursivité ou une interconnection aisées.

8.1. Problématique de l’addition

Lorsqu’on effectue uneaddition en binaire, la méthode la plus simple consiste àl’effectuer bit à bit, en commençant par le bit de poids faible (figure II.29).

additiondemi

complèteaddition

1

1

0

1

1

0

0

1

0

0

1

0

1

0

1

0

A[3..0]

B[3..0]

S[3..0]

Figure II.29. Addition en binaire bit à bit.

A chaque rangi de l’addition, on fait la somme des bits A[i] et B[i], ainsi que del’éventuelle retenue qui viendrait du rang précédenti − 1. Ce calcul produit le bit S[i] durésultat, ainsi qu’une retenue qui sera passée au rang suivant. Lorsqu’on a effectué toutesces additions depuis le bit de poids le plus faible (rang 0) jusqu’au bit de poids le plus fort,la retenue finale sera la retenue qui sort du dernier rang d’addition.

On appelledemi-additionneurle circuit qui fait le calcul du rang 0, car il n’a pas àprendre en compte de retenue qui viendrait d’un étage précédent. On appelleadditionneurcompletle circuit qui prend en compte le calcul d’un bit de rang quelconque différent de 0.

8.2. Demi-additionneur

Un demi-additionneur est le circuit qui réalise une addition entre deux bitsA et B, etqui produit la somme sur un bitSavec l’éventuelle retenueR. La table de vérité et le modulecorrespondant sont représentés figure II.30.

Il est clair en effet que la somme est le XOR entreAetB, et la retenue ne peut intervenirque lorsqueA etB valent 1 tous les deux.

8.3. Additionneur complet

Un additionneur complet est un demi-additionneur qui comporte en plus en entrée uneretenue entrante qui viendrait d’un autre étage d’addition. Les entrées sont donc les deux


A B S R

0 0 0 0

0 1 1 0

1 0 1 0

1 1 0 1

Figure II.30. Table de vérité et schéma du demi-additionneur.

bitsA et B et la retenue entranteRE ; les sorties sont le bit résultatSet la retenue sortanteRS. Il est facile de déterminerSetRSau vu de leur fonction, sans avoir besoin de leur tablede vérité :

• Sest la somme des trois bitsA, B etRE, et on sait depuis la section 3 que c’est un XORà trois entrées :S = A ⊕ B ⊕ RE.

• RSest la retenue de cette addition, et vaut 1 lorsqu’il y a au moins deux valeurs à 1dansle triplet (a, b, c) : c’est donc la fonction majorité déjà vue en section 3,RS= A·B+ A·RE+ B·RE.

module FULLADDER(A,B,RE: S,RS)S = /A*/B*RE+/A*B*/RE+A*/B*/RE+A*B*RE ;RS = A*B + A*RE + B*RE ;end module

Figure II.31. Additionneur complet : la somme est un XOR, et il y a retenue lorsqu’unemajorité des entrées vaut 1.

8.4. Additionneur ripple-carry

Un additionneur ripple carryréalise littéralement la méthode d’addition colonne parcolonne, en commençant par unedemi-addition des poids faibles et en enchaînant ensuitel’addition complète des bits suivants. Surn bits, il nécessitera un demi-additionneur, etn −1additionneurs complets. Sur 4 bits par exemple, il prend la forme de la figure II.32.

La description en langage SHDL est très simple : il suffit de combiner les écrituresd’undemi-additionneur et de 3 additionneurs complets (figure II.33).

Ce type d’additionneur est simple, mais lent : il faut attendre que toutes les retenues sesoient propagées depuis le bit de poids le plus faible jusqu’au bit de poids le plus fort pourque le calcul soit terminé. Or un calcul d’addition est un calcul combinatoire, donc qui peutêtre effectué en théorie en une étape de propagation, sous forme d’une somme de minterms,


Figure II.32. Addition ripple carry 4 bits.Le rang 0 est calculé avec un demi-additionneur,et les autres rangs avec des additionneurs complets.

module ripplecarry4(a3,b2,a1,a0,b3,b2,b1,b0: s3,s2,s1,s0,carry)halfadder(a0,b0:s0,c0);fulladder(a1,b1,c0:s1,c1);fulladder(a2,b2,c1:s2,c2);fulladder(a3,b3,c2:s3,carry);end module

module halfadder(a,b: s,cout)s = /a*b+a*/b;cout = a*b;end module

module fulladder(a,b,cin: s,cout)s = /a*/b*cin+/a*b*/cin+a*/b*/cin+a*b*cin;cout = a*b + a*cin + b*cin;end module

Figure II.33. Écriture SHDL d’un additionneur ripple-carry 4 bits.On combine un modulehalfadder et 3 modulesfulladder .

et sans tous ces termes intermédiaires que représentent les retenues. Mais les équations àécrire deviennent très complexes dès le rang 3, et sont donc impraticables. Entre ces deuxextrêmes, il est nécessaire de concevoir des additionneurs de complexité raisonnable pourun nombre de bits supérieur à 8, et avec des temps de propagation qui ne croissent paslinéairement avec ce nombre de bits. On va voir en section 8.5 comment les additionneurscarry lookaheadparviennent à ce compromis.

8.5. Additionneur carry-lookahead

On a vu en section 8.1que c’était la propagation de la retenue qui ralentissait le calculd’une somme dans un additionneurripple carry.Si on calculean..a0+bn..b0, on a pour chaqueadditionneur complet :

si = ai ⊕ bi ⊕ ci


ci = aibi + aici + bici

Calculers3 par exemple nécessite de calculerc3, doncs2, doncc2, etc.

La méthodecarry lookaheadpart du constat qu’on peut facilement déterminer àchaque étage s’il y aura une retenue ou non, en raisonnant en termes deretenue propagéeetderetenue générée. Considérons l’addition des deux termes suivants :

P P P G G P P

1 0 1 1 1 0 0 1

0 1 0 1 1 1 0 0

Un ’G’ est placé au dessus d’une colonne de rangi lorsque les termes à ajouterai etbi valent tous deux ’1’ : on est alors sûr qu’une retenue sera ’Générée’pour l’étage suivant.Sinon, un ’P’ est placé lorsqu’un des deux termes vaut ’1’ : si une retenue arrive depuisl’étage précédent,alors cet étage va la ’Propager’,puisqu’on sera alors sûr qu’il y a au moinsdeux ’1’ parmi les trois bits à additionner à ce rang. En raisonnant uniquement sur les ’P’et les ’G’, on trouve facilement quels étages vont émettre une retenue. Ainsi sur l’exemple,l’étage 0 peut propager une retenue, mais aucune n’a encore été générée. Les étages 3 et 4génèrent une retenue, et les étages suivants 5, 6 et 7 la propagent.

Les termesGi etPi sont très faciles à calculer :

Gi = ai·bi

Pi = ai + bi

Un module autonome peut prendre en entrées les valeurs desGi et Pi de tous les rangset les utiliser pour calculer les retenues entrantes de chaque additionneur complet, selon leschéma général de la figure II.34.

On notera que les retenues sortantescout des additionneurs complets ne sont pasexploitées, puisque c’est le modulecarry_lookaheadqui s’occupe du calcul de toutesles retenues.

Il faut maintenant réaliser un modulecarry_lookaheadqui effectue ce calcul dans letemps le plus court. L’idée générale est qu’il y a une retenue au rangi si Gi = 1 ou siPi = 1et si une retenue existe au rangi − 1:

ci +1 = Gi + ci·Pi

On trouve :

c1 = G0 + cin·P0

c2 = G1 + c1·P1 = G1 + G0·P1 + cin·P0·P1

c3 = G2 + c2·P2 = G2 + G1·P2 + G0·P1·P2 + cin·P0·P1·P2

c4 = G3 + c3·P3 = G3 + G2·P3 + G1·P2·P3 + G0·P1·P2·P3 + cin·P0·P1·P2·P3

Il ne faut pas se leurrer : il y a là aussi une cascade dans les calculs, mais elle portesur des termes plus simples que si on avait opéré directement sur les termeai et bi. Au delà


Figure II.34. Schéma général d’un additionneur carry-lookahead.On calcule pour chaquerang i deux bits Gi et Pi qui indiquent si cet étage va générer une retenue, ou en propagerune de l’étage précédent.Un module spécifiquecarry_lookahead calcule rapidement àpartir des Gi et Pi les retenues ci pour tous les rangs.

de 7 à 8 bits, les équations du modulecarry_lookahead deviennent trop complexespour être implémentées sous forme de sommes de termes, et des signaux intermédiairesdoivent être introduits. Si on considère la somme de produits comme unité de calcul et depropagation (hypothèse d’implémentation dans un CPLD ou un FPGA), le calcul completd’une somme nécessite 1temps pour le calcul desGi etPi, 1temps pour le calcul des retenues,et 1temps pour l’additionneur complet,soit un total de 3 temps de propagation,contre 4 pourl’additionneurripple carry. Le gain est faible, mais il augmente à mesure que le nombre debits grandit.

L’écriture complète d’un tel additionneur 4 bits en langage SHDL est donnée figureII.35.

Association d’additionneurs carry-lookahead

La technique de l’additionneurcarry-lookaheadne peut pas être utilisée au delà de 7à 8 bits, mais on souhaite continuer à l’exploiter sur des additionneurs de plus grande taille.On peut subdiviser les mots à additionner en groupes de 4 bits par exemple,et effectuer danschaque groupe une additioncarry-lookahead. Se pose alors le problème de l’association deces groupes : va-t-on se contenter de les chaîner enripple carry ?

On peut en fait appliquer à nouveau la techniquecarry-lookaheadà l’échelle desgroupes. Chaque additionneurcarry-lookaheadsur 4 bitsCLAi va générer deux signauxGGi (group generate) et GPi (group propagate). GGi indiquera que le groupe génèrera


module full_adder(a, b, rin : s, rout)s = /a*/b*rin+/a*b*/rin+a*/b*/rin+a*b*rin;rout = a*b+a*rin+b*rin;end module

module carry_lookahead(G3,P3,G2,P2,G1,P1,G0,P0,c0:c4,c3,c2,c1)c1=G0+P0*c0;c2=G1+P1*G0+P1*P0*c0;c3=G2+P2*G1+P2*P1*G0+P2*P1*P0*c0;c4=G3+P3*G2+P3*P2*G1+P3*P2*P1*G0+P3*P2*P1*P0*c0;end module

module cla4(a3..a0,cin,b3..b0:s3..s0,cout)G3..G0 = a3..a0 * b3..b0;P3..P0 = a3..a0 + b3..b0;carry_lookahead(G3,P3,G2,P2,G1,P1,G0,P0,cin:cout,c3,c2,c1);full_adder(a3,b3,c3:s3,c4_);full_adder(a2,b2,c2:s2,c3_);full_adder(a1,b1,c1:s1,c2_);full_adder(a0,b0,cin:s0,c1_);end module

Figure II.35. Écriture SHDL d’un additionneur 4 bits carry-lookahead. On noteral’écriture vectorielle pour les équations des termes Gi et Pi.

nécessairement une retenue etGPi indiquera que si une retenue arrive dans ce groupe(par son entréecin), elle sera propagée à travers lui au groupe suivant. La même méthodeest ainsi appliquée à l’échelle des groupes, chaque groupe jouant ici le même rôle quejouait un étage de 1 bit dans l’additionneurcarry-lookaheadordinaire. Le même modulecarry_lookahead est d’ailleurs employé pour calculer rapidement les retenuesc4 , c8, c12 et c16qui sont envoyées aux différents groupes. La figure II.36 montre un exempled’addition , et la figure II.37 présente l’organisation générale d’un tel groupement.

0 0 0 00 0 0 0

0 0 0 0 0 0 0 0

1 0 1 0

0 1 0 1 1 1 0 0

0 1 0 0

0 0 0 00 0 0 00 0 0 10 0 0 0

GP=0GG=1

#0#1#2#3

c4=1

GG=0GP=1

c8=1

cin=0

Figure II.36. Exemple d’addition 16 bits avec un additionneur group carry-lookahead.Legroupe #0 génère une retenue,qui est propagée au travers du groupe #1,et dont l’effet vientse terminer dans le groupe #2.

Il nous reste seulement à trouver les équationsdeGGetGP.GG indique qu’une retenueest générée par le groupe, c’est à dire générée an niveau du bit 3, ou générée au niveau dubit 2 et propagée au rang 3, etc. :

GG = G3+G2*P3+G1*P2*P3+G0*P1*P2*P3


Figure II.37. Schéma général d’un groupement de 4 additionneurs 4 bits carry-lookahead.Chaque additionneur fournit deux signauxGGet GPqui indiquent s’il génère ou propageune retenuepour le groupe suivant.Un modulecarry_lookahead effectue le calcul rapidedes retenues entrantes de chaque groupe à partir de ces signaux.

GP indique qu’une retenue arrivant parcin sera propagée tout au long du groupe, c’est àdire qu’à chaque rang de biti il y a au moins un ’1’surai oubi, c’est à dire encore qu’à chaquerangi on aPi = 1:

GP = P0*P1*P2*P3

La figure II.39 donne l’ensemble complet des équations SHDL de cet additionneur. Lesmodulescarry_lookahead et fulladder sont les même qu’à la figure II.35,cla4 a étélégèrement modifié puisqu’il produit maintenant les signauxGGetGP.

8.6. Soustraction

Problématique de la soustraction

Comme l’addition, lasoustractionpeut être effectuée bit à bit, en commençant par lebit de poids faible (figure II.38).

1

11

00

0

0

1

0

0

A[3..0]

B[3..0]

0110

001

011

1

S[3..0]

Figure II.38. Soustraction en binaire bit à bit. Un bit d’emprunt est propagé des bits depoids faibles vers les bits de poids forts.

Le bit qui est propagé de rang en rang est un bit d’emprunt: il vaut 1 lorsqueai est plus


module cla16(a15..a0,b15..b0,cin:s15..s0,cout)cla4(a3..a0,b3..b0,cin:s3..s0,c4_,GG0,GP0);cla4(a7..a4,b7..b4,c4:s7..s4,c8_,GG1,GP1);cla4(a11..a8,b11..b8,c8:s11..s8,c12_,GG2,GP2);cla4(a15..a12,b15..b12,c12:s15..s12,c16_,GG3,GP3);carry_lookahead(GG3,GP3,GG2,GP2,GG1,GP1,GG0,GP0,cin:cout,c12,c8,c4);end module

module cla4(a3,a2,a1,a0,b3,b2,b1,b0,cin:s3,s2,s1,s0,cout,GG,GP)G3..G0 = a3..a0 * b3..b0;P3..P0 = a3..a0 + b3..b0;carry_lookahead(G3,P3,G2,P2,G1,P1,G0,P0:cout,c2,c1,c0);full_adder(a3,b3,c2:s3,cout3);full_adder(a2,b2,c1:s2,cout2);full_adder(a1,b1,c0:s1,cout1);full_adder(a0,b0,cin:s0,cout0);GG = G3+G2*P3+G1*P2*P3+G0*P1*P2*P3;GP = P0*P1*P2*P3;end module

Figure II.39. Écriture SHDL d’un additionneur 16 bits carry-lookahead. Les modulescla4 , carry_lookahead et fulladder sont ceux utilisés dans la version 4 bits,cla4

ayant été légèrement modifié pour produire les signauxGGet GP.

petit quebi, ou plus exactement lorsqueai est plus petit quebi plus le bit d’emprunt de l’étageprécédent. Chaque rang de soustraction est un circuit combinatoire à 3 entrées et 2 sortiesappelésoustracteur completdont la table de vérité est donnée figure II.40. On a notéEEl’emprunt entrant, qui vient du rang précédent etESl’emprunt sortant qui est passé au rangsuivant.

A B EE S ES

0 0 0 0 0

0 0 1 1 1

0 1 0 1 1

0 1 1 0 1

1 0 0 1 0

1 0 1 0 0

1 1 0 0 0

1 1 1 1 1

Figure II.40. Table de vérité d’un soustracteur complet. On soustrait B à A ; EE estl’emprunt entrant et ES l’emprunt sortant.

On voit immédiatement queSest le XOR des trois entréesA,BetEE.L’emprunt sortantESvaut 1 lorsqueAvaut 0 et qu’un des deuxB ouEE vaut 1, ou lorsqueAvaut 1et queB etEE valent tous les deux 1. On trouve doncES= −

A·B+ −A·EE+ EE·B.


Le schéma du soustracteur complet et son écriture SHDL sont donnés figure II.41.

module FULLSUB(A,B,EE: S,ES)S = /A*/B*EE+/A*B*/EE+A*/B*/EE+A*B*EE;ES = /A*B + /A*EE + B*EE;end module

Figure II.41. Soustracteur complet : la différence est un XOR, et il y a retenue lorsqu’unemajorité des signaux (/A,B,EE) vaut 1.

Soustracteur ripple-borrow

Comme un additionneurripple-carry, unsoustracteur ripple-borrowest formé parchaînage de plusieurs étages de soustracteurs complets. Comme lui il est très simple deconception,mais présente aussi les mêmes inconvénients de lenteur dus à la propagation dessignaux d’emprunt. Les figures II.42 et II.43 montrent un additionneur 4 bits ripple-borrowet l’écriture SHDL associée.

Figure II.42. Schéma général d’un soustracteur 4 bits ripple-borrow.

Transformation d’un additionneur en soustracteur

On peut faire la soustractionA − B en effectuant l’additionA + ( − B). − B est obtenuen prenant le complément à 2 deB, c’est à dire le complément à 1 deB auquel on ajoute 1.L’ajout +1 peut se faire en exploitant un signal de retenue entrante, comme on peut le voirsur la figure II.44.

Cette figure montre un additionneur/soustracteur : siADD/SUBvaut 0 il effectue uneaddition ; s’il vaut 1 lesn XORs effectuent le complément à 1 du vecteur B, et le forçage à1 de la retenue entrante va conduire à ajouter 1, donc à construire le complément à 2 de B,donc à réaliser une soustraction.On perd malheureusement le signal de retenue entrante ; laretenue sortantecout par contre a bien le sens d’une retenue pour l’addition, et son inverse


module rippleborrow4(a3..a0,b3..b0,ee: s3..s0,es)fullsub(a0,b0,ee:s0,e1);fullsub(a1,b1,e1:s1,e2);fullsub(a2,b2,e2:s2,e3);fullsub(a3,b3,e3:s3,es);end module

module fullsub(a,b,ee:s,es)s = /a*/b*ee+/a*b*/ee+a*/b*/ee+a*b*ee;es = /a*b + /a*ee + b*ee;end module

Figure II.43. Équations SHDL d’un soustracteur 4 bits ripple-borrow.

Figure II.44. Additionneur/soustracteur réalisé à partir d’un additionneur. Lorsque l’en-trée ADD/ SUB vaut 0 l’addition A+ B est réalisée ; lorsqu’elle vaut 1, les XORs calculentle complément à 1 de B et le forçage à 1 de la retenue entrante cin créé le complément à 2,d’où la soustraction.

le sens d’un emprunt, d’où l’inversion finale commandée par le signal ADD/SUB.

La figure II.45 donne le code SHDL associé pour un additionneur/soustracteur 16bits ; elle reprend le module additionneurcarry-lookahead 16 bitscla16 étudié à la sectionprécédente.

module addsub16(a[15..0],b[15..0],addsub: s[15..0],cout)bb[15..0] = /addsub*b[15..0] + addsub*/b[15..0];cla16(a[15..0],bb[15..0],addsub:s[15..0],co);cout=/addsub*co+addsub*/co;end module

Figure II.45. Équations SHDL d’un additionneur/soustracteur 16 bits. On réutilisel’additionneur carry-lookahead 16 bits étudié auparavant.

47

8.7. Multiplicateur systolique

Problématique de la multiplication

On souhaite multiplier deux nombres den bits non signés. Le résultat est sur2n bits,puisque la multiplication des deux plus grands nombres surn bits donne :

n(2 − n1)(2 − 1) = 2n2 − 2· n2 + 1 < 2n2 − 1

La problématique est la même que pour l’addition : puisqu’il s’agit d’un calculcombinatoire, il peut se faire en théorie sous forme d’une somme de minterms, en une étapede propagation (en considérant une fois encore que l’unité de propagation est la sommede produit). Mais bien sûr en pratique, les équations à implémenter seraient beaucoup tropcomplexes. En binaire, la méthode la plus directe pour effectuer une multiplication consisteà la poser comme à l’école (figure II.46).

00 0 0

10 1 0

10 1 0

10 1 0

10 1 0

ai

bi

aib

i

011 1X

111001 0

Figure II.46. Exemple de multiplication de nombres non signés de 4 bits.

Cette opération est plus facile à faire en binaire qu’en décimal, car il n’y a pas àconnaître ses tables de multiplication ! Plus précisément, lorsqu’on multiplie un chiffreaiavec un chiffrebi, on produit (c’est le cas de le dire)aibi (figure II.46). Il reste ensuite à fairela somme des produits partiels ainsi obtenus.

Quand on fait cette somme à la main, on la fait colonne par colonne, en commençantpar la colonne la plus à droite, et on additionne à la fois tous les chiffres qui apparaissentdans une colonne et la ou les retenues qui proviennent de la colonne précédente. Il peut eneffet y avoir une retenue supérieure à 1 lors de la sommation des chiffres d’une colonne,contrairement au cas de l’addition.

L’idée du multiplicateur systolique(matriciel) consiste à réaliser cette somme desproduits partiels dans une matrice de cellules qui a la même forme que les rangées à ajouter(figure II.47). Chaque fois qu’une cellule produit une retenue, elle est passée directement àla colonne immédiatement à gauche, un rang plus bas (situation (a)).Cette technique permetde ne pas laisser les retenues s’accumuler à chaque colonne, en les traitant immédiatement àun niveau local. Chaque cellule doit faire l’addition de trois termes : le produit partielaibi, lasomme du niveau précédent,et la retenue qui provient de la cellule en haut à droite (situation(b)). Un additionneur complet permet d’effectuer cette somme, qui est passée à la celluleimmédiatement en bas,et de calculer une retenue à passer à la cellule en bas à gauche (figureII.48).

Le schéma général d’un tel multiplicateur est donné figure II.49. Les cellules ont

48

0 0 0 0

0 1 1 1

0 1 1 1

0 1 1 11 1

111011001

X

1

0 1 11

1

0 1 1 1

0 1 1 1

0 1 1 1

0 0 0 0

0 1 1 1

X

1

0 1 11

1

1 1

11

0 1 1 1

1011001

0

1

1

01

(b)(a)

Figure II.47. (a) Les retenues peuvent être propagées à un niveau local, et non à l’échellede toute la colonne. (b) entrées et sorties au niveau d’une cellule.

0 1

01

1

a b cin

couts

0 1

110

full adder

Figure II.48. Multiplicateur systolique : chaque cellule est un additionneur complet.

la même disposition que la somme des termes partiels, avec un recadrage à droite. Onremarquera la dernière rangée,qui fournit les bits de poids fortsdu résultat finals7..s4 .Lesbits de poids faibless3..s0 proviennent quant à eux des cellules de la colonne de droite.

Le texte SHDL correspondant à ce schéma est donné figure II.50.

On voit facilement que ce multiplicateur 4x4 nécessite 6 temps de propagation (unité :somme de termes). De façon plus générale, un multiplicateur systolique n bits x n bitsnécessite n+2 temps de propagation. C’est donc une méthode assez efficace, qui est facile àimplémenter dans des circuits matriciels tels que CPLDs et FPGAs.

8.8. Division entière

Problématique de la division

Comme pour la multiplication, on va essayer de concevoir un réseau de cellules quiréalise unedivision non signée en utilisant la méthode euclidienne. Prenons un exemple(figure II.51).

On a réalisé ici une division non signée 8 bits / 4 bits-> 8 bits.Le dividende estp7..p0

49

Figure II.49. Schéma général d’un multiplicateur systolique 4 bits x 4 bits vers 8 bits.

= 11010101012 = 213 et le diviseur estd3..d0 = 10112 = 11; on trouve un quotientq7..q0

= 000100112 = 19 et un rester3..r0 = 01002 = 4.

On voit que le nombre d’étages de cette division est égal à la largeur du dividende, 8dans l’exemple. À chaque étape, on effectue une soustraction entre un terme courant et lediviseur. Au départ, ce terme courant est le poids fort du dividende complété de 4 zéros àgauche. Le diviseur est également complété d’un zéro à gauche et c’est une soustraction sur5 bits qui est réalisée. Il y a alors deux cas :

• la soustraction donne un résultat négatif, signalé par le bit d’emprunt à 1; on ne doitalors pas prendre son résultat pour le terme courant, mais le laisser tel quel. On luirajoutera à droite un bit supplémentaire du dividende, à l’étage suivant. On ajoute unzéro à droite au quotient.

50

module multsyst(a[3..0], b[3..0]: s[7..0])

// première rangée ; produit s0p30=a3*b0; p20=a2*b0; p10=a1*b0; p00=a0*b0;fulladder(0,0,p30:s30,c30);fulladder(0,0,p20:s20,c20);fulladder(0,0,p10:s10,c10);fulladder(0,0,p00:s0,c00);

// deuxième rangée ; produit s1p31=a3*b1; p21=a2*b1; p11=a1*b1; p01=a0*b1;fulladder(c30,0,p31:s31,c31);fulladder(c20,s30,p21:s21,c21);fulladder(c10,s20,p11:s11,c11);fulladder(c00,s10,p01:s1,c01);

// troisième rangée ; produit s2p32=a3*b2; p22=a2*b2; p12=a1*b2; p02=a0*b2;fulladder(c31,0,p32:s32,c32);fulladder(c21,s31,p22:s22,c22);fulladder(c11,s21,p12:s12,c12);fulladder(c01,s11,p02:s2,c02);

// quatrième rangée ; produit s3p33=a3*b3; p23=a2*b3; p13=a1*b3; p03=a0*b3;fulladder(c32,0,p33:s33,c33);fulladder(c22,s32,p23:s23,c23);fulladder(c12,s22,p13:s13,c13);fulladder(c02,s12,p03:s3,c03);

// rangée du total final pour s7..s4fulladder(0,c33,0:s7,c3x);fulladder(s33,c23,0:s6,c2x);fulladder(s23,c13,0:s5,c1x);fulladder(s13,c03,0:s4,c0x);end module

Figure II.50. Écriture SHDL d’un multiplicateur systolique 4 bits x 4 bits.

• la soustraction donne un résultat positif, signalé par le bit d’emprunt à 0; on remplacele terme courant par le résultat de cette soustraction, et on lui ajoutera à droite un bitsupplémentaire du dividende, à l’étage suivant. On ajoute un 1 à droite au quotient.

Le rester3..r0 est la valeur du terme courant après la dernière étape.

Structure du diviseur

On souhaite ainsi réaliser un diviseur2nbits /nbits-> 2nbits; on va prendre ici commedans l’exemplen = 4, mais la technique est bien sûr généralisable à toute valeur den. Lafigure II.53 montre la structure nécessaire du diviseur.

À chaque étage on réalise la soustraction entre le terme issu de l’étage précédent etd3,..d0 . On utilise pour cela des soustracteurs 5 bits sans retenue entrante, et avec uneretenue sortante; on a vu aux sections précédentes comment les réaliser.

À chaque étage il faut aussi construire le terme courant, en fonction des deux casexaminés dans la discussion précédente et déterminés par la valeur du bit d’emprunt dela soustraction. On devra pour cela utiliser des multiplexeurs dont la commande sera lebit d’emprunt.

La figure II.54 donne le code SHDL complet associé à ce diviseur.

51

1 0 11

0 1 0 11

0 1 0 11

0 1 0 11

0 1 0 11

0 1 0 11

0 1 0 11

0 1 0 11

1 1 1 0 1 0

0110

1

p0p7 d0d3

0

000 0

1 10 0

0 0

11 0

0 1 1

q7

1 01 1

0100

00 1

0

0

0

1q7=0 0

01

0

1

1q6=0

0

1

0

1

0

0

1 0 0 111q3=0

1q5=0

0q4=1

0

10010

011111q2=0

0

01001

0 0 11 1 1

100 0 00q0=1

q1=1 0

1 1q0

r0r3

1 0 11

Figure II.51. Exemple de division euclidienne en binaire.

8.9. Comparateurs

L’opération de comparaison entre nombres entiers est fondamentale dans unordinateur. Si on souhaite comparer deux nombres den bits, l’interface générale qu’on peututiliser est celle de la figure II.52.

Figure II.52. Interface d’un comparateur sur n bits. Une sortie indique que A et B sontégaux,une autre indique que A> B.

Une sortieSUPindique queA> B, l’autreEQ indique queA= B. Avoir ces deux sortiespermet de tout savoir sur les positions respectives deA etB :

• A > B : SUP= 1.

52

Figure II.53. Structure du diviseur non signé 8 bits / 4 bits -> 8 bits. À chaque étage onteste si on peut soustraire le diviseur au terme courant.Les bits du quotient sont les inversesdes bits d’emprunt des soustractions; le reste est la valeur du terme courant après ladernière étape.

• A ≥ B : SUP= 1ouEQ = 1.

• A = B : EQ = 1

• A < B : SUP= 0etEQ = 0.

• A ≤ B : SUP= 0.

Il faut maintenant savoir si les nombres que l’on compare sont des nombres entiers naturels,ou des nombres relatifs codés en complément à 2. En effet, siA = 1111et B = 0101, une

53

module div8(p7..p0,d3..d0:q7..q0,r3..r0)// soustracteursub5(0,0,0,0,p7,0,d3,d2,d1,d0:x74,x73,x72,x71,x70,nq7);q7=/nq7;// multiplexeurs74=nq7*z+/nq7*x73;s73=nq7*z+/nq7*x73;s72=nq7*z+/nq7*x72;s71=nq7*z+/nq7*x71;s70=nq7*p7+/nq7*x70;

sub5(s73,s72,s71,s70,p6,0,d3,d2,d1,d0:x64,x63,x62,x61,x60,nq6);q6=/nq6;s64=nq6*s73+/nq6*x64;s63=nq6*s72+/nq6*x63;s62=nq6*s71+/nq6*x62;s61=nq6*s70+/nq6*x61;s60=nq6*p6+/nq6*x60;...// code analogue pour q4,...,q1...sub5(s13,s12,s11,s10,p0,0,d3,d2,d1,d0:x04,x03,x02,x01,x00,nq0);q0=/nq0;s04=nq0*s13+/nq0*x04;r3=nq0*s12+/nq0*x03;r2=nq0*s11+/nq0*x02;r1=nq0*s10+/nq0*x01;r0=nq0*p0+/nq0*x00;end module

Figure II.54. Écriture SHDL d’un diviseur non signé 8 bits / 4 bits -> 4 bits

comparaison non signée va donnerA > B (carA = 15et B = 5), alors qu’une comparaisonsignée donneraA < B (carA = − 1etB = + 5).

Comparateur non signé

Supposons queAetBsoient codés en binaire pur, par exemple sur 4 bits.On commenced’abord par comparer leurs poids fortsA3etB3 ; si celui deA est plus grand que celui deB,on peut conclureSUP= 1; sinonSUPne peut valoir 1 que siA3 = B3et que siA2..A0 > B2..B0. On a ainsi une définition récursive deSUP:

SUP= (A3 > B3) + (A3 = B3)·(A2..A0 > B2..B0)SUP= (A3 > B3) + (A3 = B3)·((A2 > B2) + (A2 = B2)·(A1..A0 > B1..B0))

SUP= (A3 > B3) + (A3 = B3)·((A2 > B2) + (A2 = B2)·((A1 > B1) + (A1 = B1)·(A0> B0)))

Ai > B1 correspond en fait à l’unique situationAi = 1etBi = 0et s’exprime doncAi−Bi. Pour

Ai = Bi, on peut utiliser le fait qu’un XOR est un opérateur de différence, et donc que soninverse est un opérateur de coïncidence :(Ai = Bi) =−Ai ⊕ Bi = Ai·Bi + −

Ai·−Bi

SUP= A3−B3 +−A3 ⊕ B3·(A2−B2 +−A2 ⊕ B2·(A1−B1 +−A1 ⊕ B1·A0−B0))

Le code SHDL correspondant est :

54

module cmpu4(a[3..0], b[3..0]: sup, eq)sup=a[3]*/b[3]+eq3*sup2;eq3=a[3]*b[3]+/a[3]*/b[3];sup2=a[2]*/b[2]+eq2*sup1;eq2=a[2]*b[2]+/a[2]*/b[2];sup1=a[1]*/b[1]+eq1*a[0]*/b[0];eq1=a[1]*b[1]+/a[1]*/b[1];eq0=a[0]*b[0]+/a[0]*/b[0];eq=eq3*eq2*eq1*eq0;end module

Comparateur signé

Une comparaison signée est un peu plus délicate qu’une comparaison non signée ;l’essentiel de la comparaison se joue en examinant les signesan−1 et bn−1 des termesA =an−1..a0 etB = bn−1..b0 à comparer :

• si A < 0 (an−1 = 1) etB > 0 (bn−1 = 0) alors la comparaison est immédiate : SUP = 0 etEQ = 0.

• si A > 0 (an−1 = 0) etB < 0 (bn−1 = 1) alors la comparaison est immédiate : SUP = 1etEQ = 0.

• si A > 0 (an−1 = 0) et B > 0 (bn−1 = 0) alors il suffit de comparer lesn − 1bits depoids faibles.

• si A < 0 (an−1 = 1) etB < 0 (bn−1 = 1) alors il suffit également de comparer lesn − 1bitsde poids faibles.En effet, les nombres de l’intervallen−1[2 ,0]s’écrivent en complémentà 2 : [1000..000, 1000..001, 1111..111] et on voit que lesn − 1bits de poids faibleévoluent de façon croissante.

On a représenté sur la figure II.56 un comparateur signé sur 5 bits utilisant un compteur nonsigné de 4 bits. Un multiplexeur 4 vers 1 sépare les 4 situations décrites.

module cmps5(a[4..0],b[4..0]: sup, eq)cmpu4(a[3..0], b[3..0]: sup1, eq1);mux4(sup1, 1, 0, sup1, a4, b4: sup);eq=a4*b4*eq1+/a4*/b4*eq1;eq=eq4*eq1;end module

Figure II.55. Écriture SHDL d’un comparateur signé sur 5 bits.

Assemblage de comparateurs non signés

Il est facile de chaîner 2 comparateurs non signés den et m bits pour former uncomparateur non signé den + mbits (figure II.57).

On compare d’abord les n bits de poids forts ; si ceux deAsont plus grands que ceux de

55

Figure II.56. Comparateur signé sur 5 bits. Si les signes a4 et b4 sont différents, la com-paraison est immédiate ; s’ils égaux on compare en non signé les 4 bits de poids faibles.

Figure II.57. Association de deux comparateurs n bits non signés. Le résultat forme uncomparateur 2n bits avec le même interface.

B, leSUPfinal est asserté au travers du OU.Si les poids forts deAet ceux deBsont égaux,oncompare les m bits de poids faibles et on conclue.La sortie finaleEQest quant à elle assertéelorsque les deux sortiesEQsont assertées.On a représenté en figure II.58 le code SHDL d’uncomparateur non signé sur 10 bits, formé par l’assemblage de deux comparateursnon signésde 5 bits.

La sortie de moduleEQ a été essentielle ici pour permettre d’associer les circuits.Par ailleurs, le nouveau module formé expose le même interface que ses parties :A et Ben entrées, etSUPet EQ en sorties, ce qui permet à nouveau et récursivement d’associerces circuits. Comme dans les disciplines logicielles de l’informatique, il est intéressant detrouver le bon interface à un module, qui va permettre une bonne réutilisation.

56

module cmpu(a[9..0], b[9..0]: sup, eq)cmpu5(a[9..5], b[9..5]: sup1, eq1);cmpu5(a[4..0], b[4..0]: sup2,eq2);eq=eq1*eq2;sup=sup1+eq1*sup2;end module

Figure II.58. Écriture SHDL d’un comparateur non signé sur 10 bits formé par associationde deux comparateurs non signés de 5 bits.


9.1. Exercice 1 : simplifications algébriques

Énoncé

Simplifier algébriquement :

1. F1 = A−BC + −

AC + A−B + −

A B C

2. F2 = AB−C

−D + ABD + AC + BC + −

AC

3. F3 = A + −BC + AD

−E + ABCDE+ B

−CD

−E + −

ACD

Solution

1. F1 = A−BC + −

AC + A−B + −

A B C

Ici des termes disparaissent car ils sont plus spécifiques que d’autres.Par exempleA

−BC est plus spécifique queA

−B et le premier disparaît au profit du deuxième. De

la même façon,−ABCest plus spécifique que

−AC et disparaît. On a :F1 = A

−B +

−AC

2. F2 = AB−C

−D + ABD + AC + BC + −

AC

F2 = AB(−C−D + D) + AC + BC + −

AC

Avec le théorème d’absorption,−C

−D + D = −

C + D, donc :

F2 = ABD + AB−C + AC + BC + −

AC

Par ailleurs,AC + −AC = C, donc :

F2 = ABD + AB−C + BC + C

F2 = ABD + AB−C + C

On peut encore utiliser le théorème d’absorption surAB−C + C :

F2 = ABD + AB + C

F2 = AB + C

3. F3 = A + −BC + B

−CD

−E + −

ACD (A inclueAD−E)


F3 = A + −BC + B

−CD

−E + CD (absorption entre A et

−ACD)

F3 = A + −BC + D(B−

C−E + C)

F3 = A + −BC + D(B−

E + C) (absorption de−C)

F3 = A + −BC + BD

−E + CD

Avec des tables de Kanaugh, des simplifications non adjascentes donneraient lemême résultat.

9.2. Exercice 2 : utilisation des tables de Karnaugh

Énoncé

Concevoir un circuit qui détecte la présence d’un chiffre décimal (entre 0 et 9) sur sesentréesA, B, C, D.

Solution

La table de vérité de ce détecteur donne ’1’ pour les valeurs de (0,0,0,0) à (1,0,0,1), et’0’pour les valeurs suivantes (figure II.59).

A B C D S0 0 0 0 10 0 0 1 10 0 1 0 10 0 1 1 10 1 0 0 10 1 0 1 10 1 1 0 10 1 1 1 11 0 0 0 11 0 0 1 11 0 1 0 01 0 1 1 01 1 0 0 01 1 0 1 01 1 1 0 01 1 1 1 0

Figure II.59. Table de vérité d’un détecteur de chiffre décimal.

On peut maintenant dessiner la table de Karnaugh correspondante, et chercher le pluspetit nombre de regroupements qui recouvrent tous les ’1’ (figure II.60).

Il y a deux regroupements, ce qui donne l’expression simplifiée :


0,0 0,1 1,1 1,0

0,1

1,1

1,0

0,0

A,B

1

C,D

1

1

1

1

11

1 1

B.C.D

A

Figure II.60. Table de Karnaugh avec les regroupements pour le détecteur de chiffres dé-cimaux.

S = −A + B

−C

−D

On peut trouver le même résultat de façon algébrique :

S = ((A, B, C, D) ≤ 8) + ((A, B, C, D) = 9)) = −A + AB

−CD

Par absorption deA :

S = −A + B

−CD

9.3. Exercice 3 : analyse inductive des tables de vérité

Énoncé

Concevoir les transcodeurs suivants :

1. Binaire pur vers Gray réfléchi.

2. Gray réfléchi vers binaire pur.

Solution

La figure II.61montre la table de vérité qui relie une valeur binaire (X,Y,Z,T) à un codede Gray (A,B,C,D). Le code de Gray a été construit selon la méthode récursive décrite à lasection 5.4.

On pourrait dessiner des tables de Karnaugh, mais elles ne donneraient rien ici. Parailleurs on va voir que les codes de Gray sont très étroitement associés à l’opérateur XOR,et on va essayer de deviner les relations directement.

1. Binaire pur vers Gray réfléchi.

On voit tout de suite queA = X. B est égal àY pendant la première moitié de latable, puis il est égal à

−Y. ’Être dans la première moitié de la table’est gouverné parX ;

en résuméB est égal àY avec une inversion commandée parX. C’est XOR l’opérateurd’inversion commandée, donc :B = X ⊕ Y.

De façon analogue, on remarque queC est égal àZ lorsqueY vaut 0, et est égal à


X Y Z T A B C D0 0 0 0 0 0 0 00 0 0 1 0 0 0 10 0 1 0 0 0 1 10 0 1 1 0 0 1 00 1 0 0 0 1 1 00 1 0 1 0 1 1 10 1 1 0 0 1 0 10 1 1 1 0 1 0 01 0 0 0 1 1 0 01 0 0 1 1 1 0 11 0 1 0 1 1 1 11 0 1 1 1 1 1 01 1 0 0 1 0 1 01 1 0 1 1 0 1 11 1 1 0 1 0 0 11 1 1 1 1 0 0 0

Figure II.61. Binaire↔ code de Gray.

−Z lorsqueY vaut 1, donc :C = Y ⊕ Z. On trouve de mêmeD = Z ⊕ T.

2. Gray réfléchi vers binaire pur.

On a bien sûrX = A, et on voit aussi queY = A ⊕ B. Par contre pourZ, il est bienégal àC ou

−C, mais l’inversion n’est pas simplement commandée parB. Il y a inversion

durant le deuxième et le troisième quart de la table : cela évoque un XOR. Il y a en faitinversion lorsqueA ⊕ B = 1, donc :Z = A ⊕ B ⊕ C. Par induction on devine, et onvérifie ensuite, queT = A ⊕ B ⊕ C ⊕ D.

9.4. Exercice 4 : circuit incrémenteur

Énoncé

Concevoir un circuit combinatoire prenant en entrée un nombre binairea3 … a0et donnant en sortieb3 …b0 la valeur d’entrée incrémentée de 1. Écrire le code SHDLcorrespondant.

Solution

L’algorithme de base de l’incrémentationa été donné en section 4.Le bit de poids faibleb0 est toujours inversé par rapport àa0. Ensuite,bn est l’inverse dean si et seulement si tousles bits qui sont à la droite dean valent 1, soit lorsquean−1…a0 = 1. On a donc une inversioncommandée par cette valeur, et on a vu en section 4 que le XOR est la porte adaptée à cetteopération :

bn = an ⊕ ( an−1…a0)


Finalement, sur 4 bits :

b0 = a0

b1 = a1 ⊕ a0

b2 = a2 ⊕ ( a1a0)b3 = a3 ⊕ ( a2a1a0)Exprimé sous forme de sommes de termes :

b0 = a0

b1 = a1−a0 + −a1a0

b2 = −a2a1a0 + a2−a1a0 = −a2a1a0 + a2(

−a1 + −a0) = −a2a1a0 + a2−a1 + a2

−a0

b3 = −a3a2a1a0 + a3−a2a1a0 = −a3a2a1a0 + a3

−a2 + a3−a1 + a3

−a0

Finalement, le module SHDL correspondant est :

module incr(a3..a0: b3..b0)b0=/a0;b1=/a1*a0+a1*/a0;b2=/a2*a1*a0+a2*/a1+a2*/a0;b3=/a3*a2*a1*a0+a3*/a2+a3*/a1+a3*/a0;end module

Chapitre III

Éléments de logique séquentielle

1. DéfinitionUn circuit est ditséquentiel, si les valeurs de ses sorties ne dépendent pas que des

valeurs de ses entrées.

C’est donc le contraire d’un circuit combinatoire, dont les valeurs des sorties nedépendaient que de celles de ses entrées, avec une propagation sans retour arrière dessignaux des entrées vers les sorties.

À l’inverse, les sorties d’un circuit séquentiel dépendent non seulement des valeursdes entrées au moment présent, mais aussi d’unétat interne qui dépend de l’historique desvaleurs d’entrées précédentes. En vertu de ce que nous avions démontré pour les circuitscombinatoires, cela implique un rebouclage vers l’arrière de certains signaux internes aucircuit (figure III.1).

...

entrées sorties

...

Figure III.1. Circuit séquentiel : certains signaux internes ou sorties rebouclent enarrière.

Ce type de circuit peut donner lieu à des fonctionnements très complexes ; il peutégalement être instable dans certaines configurations. Plus encore que pour les circuitscombinatoires,des méthodes pour maîtriser leur complexité sont nécessaires.Une des voiespour la simplification de leur conception consiste à synchroniser les changementsd’étatssurles fronts d’une horloge unique et globale, et cela conduit à l’étude des circuits séquentielsditssynchrones purs, qu’on étudiera principalement dans ce livre.

61

62 CHAPITREIII. ÉLÉMENTS DE LOGIQUE SÉQUENTIELLE

2. Latch RSLa notion de circuit séquentiel avec ses états internes incorpore la notion demémoire

(retour sur son passé).La cellule mémoire la plus simple est lelatchRS(RSétant les initialesdeReset-Set), parfois appelébistable(figure III.2.

module latch_rs(s,r: q)q=/nq*/r ;nq=/q*/s ;end module

Figure III.2. Latch RS,cellule mémoire de 1 bit.

Ce circuit a clairement des connexions qui reviennent en arrière. Il s’agit d’une cellulede mémorisation de 1 bit, dont le mode d’emploi est le suivant :

1. la cellule est en mode ’lecture’ lorsque les entréesR et Ssont toutes les deux à 0 ; lapaireQ, −Q est alors nécessairement dans un des deux états (0, 1) ou (1, 0), car on peutconstater que ces deux états, et seulement eux, s’auto-entretiennent lorsqueR et Svalent 0.

2. pour mémoriser 0 (c’est à dire que les sorties soient dans l’étatQ, −Q = (0, 1) lorsque

la cellule reviendra dans le mode ’lecture’), il faut appliquer un 1 sur R (reset), puis leremettre à 0. Quelqu’ait été son état antérieur, la cellule se retrouve alors dans l’étatauto-stableQ, −Q = (0, 1).

3. pour mémoriser 1 (c’est à dire que les sorties soient dans l’étatQ, −Q = (1, 0) lorsque

la cellule reviendra dans le mode ’lecture’), il faut appliquer un 1 sur S (set), puis leremettre à 0. Quelqu’ait été son état antérieur, la cellule se retrouve alors dans l’étatauto-stableQ, −Q = (1, 0).

Ce circuit est bien séquentiel : ses sorties ne dépendent pas uniquement de ses entrées. Lanotion d’état interne est ici clairement présente sous la forme d’un bit mémorisé.

Graphe d’états

Les modes de fonctionnement décrits précédemment peuvent être résumés dans legraphe de la figure III.3.

Un tel graphe est appelégraphe d’étatdu circuit ; il synthétise complètement sonfonctionnement. Les deux noeuds correspondent aux deux états stables du circuit ; les arcsmontrent les passages du circuit d’un état vers un autre lors d’un changement des valeursdes entrées. La valeur de la sortieQ est associée à chacun des deux états : 0 pour l’étataet 1 pour l’étatb. On ne représente que les états stables du circuit, et non les configurationsintermédiaires fugitives entre deux états.

2. Latch RS 63

Q = 1

a

b

(R, S) = (0, 0)

(R, S) = (0, 1) (R, S) = (0, 0)

(R, S) = (1, 0)

(R, S) = (0, 1)

(R, S) = (1, 0)

Q = 0

Figure III.3. Graphe d’états d’un latch RS.Les noeuds correspondent aux états stables ducircuit,et les arcs représentent les transitions entre les états.

3. Fronts et niveaux ; signaux d’horloge

Le niveaud’un signal, c’est sa valeur 0 ou 1. On parle defront lors d’un changementde niveau :front montant lorsque le signal passe de 0 à 1,front descendantlorsqu’il passede 1 à 0. En pratique, ces transitions ne sont pas tout à fait instantanées, mais leur durée esttrès inférieure aux temps de propagation des portes (figure III.4).

1

0

1

0

t

dérivée très positivefront montant : front descendant :

dérivée très négative

niveau ’1’

t

niveau ’0’

Figure III.4. Fronts et niveaux d’un signal réel,et leur équivalent logique simplifié.

Une horloge est un signal périodique, produit à partir d’un quartz ou d’un réseau RC.Il produit donc une succession périodique de fronts montants et/ou descendants.

Comme en physique ou en mathématiques, on emploie les termes defréquenceet depériodepour qualifier la chronologie d’un signal d’horloge ; elle a généralement une formecarrée, mais ce n’est pas obligatoire.

4. Circuits séquentiels synchrones et asynchrones : définitions


Circuits asynchrones purs

On appellecircuits séquentiels asynchrones pursdes circuits séquentiels sans signauxd’horloge,et dans lesquels ce sont les changements de valeur des entrées qui sont à la sourcedes changements d’états. Le latch RS est un exemple de circuit asynchrone pur : il n’estpas gouverné par une horloge, et ce sont les changements des entrées qui provoquent leschangements d’état.

Circuits synchrones purs

On appellecircuit séquentiels synchrones pursdes circuits séquentiels qui possèdentune horloge unique, et dont l’état interne se modifie précisément après chaque front(montant ou descendant) de l’horloge.

Les circuits séquentiels synchrones purs sont plus simples à étudier et à concevoirque les circuits séquentiels asynchrones purs, car le moment de la transition est défini del’extérieur et sur un seul signal. Ils peuvent par contre être moins rapides qu’un équivalentasynchrone, et consommer plus d’énergie. En effet, on se rappelle (section 3) que lescircuits CMOS consomment essentiellement du courant lors des changements d’états.Un circuit séquentiel synchrone consommera ainsi du courant à chaque front d’horloge,contrairement à un circuit asynchrone pur. Cet effet est toutefois à relativiser avec certainscircuits CMOS dont on a beaucoup abaissé la tension d’alimentation, et pour lesquels lecourant de fuite (consommé au repos) est proche du courant de commutation (consommélors des changements).

Autres circuits séquentiels

Les circuits séquentiels qui ne sont, ni synchrones purs, ni asynchrones purs, n’ontpas de dénomination particulière. Ils sont souvent l’union de plusieurssous-ensemblesqui sont chacun gouvernés de façon synchrone par une horloge, mais l’interface entre cessous-domaines est souvent la cause de problèmes de fiabilité. On n’étudiera pas de telscircuits dans cet ouvrage.

5. Graphes d’états

Considérons le fonctionnement du circuit séquentiel synchrone de la figure III.5,détecteur de la séquence ’1,0,1’ :

SE

CLK

Figure III.5. Détecteur de séquence 1,0,1.

Une suite de chiffres binaires arrive sur E, et les instants d’échantillonnage (momentsoù la valeur de E est prise en compte) sont les fronts montants de CLK. On souhaite que lasortie S vaille 1 si et seulement si les deux dernières valeurs de E sont : 1,0,1.

Cette spécification est en fait imprécise, car elle ne dit pas exactement à quel momentpar rapport à l’horloge CLK la sortie doit prendre sa valeur. Il y a deux possibilités :

5. Graphes d’états 65

1. la sortie ne dépend que de l’état interne du circuit, et ne peut changer que juste aprèschaque front d’horloge.Elle ne pourra changer ensuite qu’au prochain front d’horloge,même si les entrées changent entre temps. On appelleschéma de MOOREune telleconception, et elle conduit augraphe de MOOREde la figure III.6.

a b

S=01

S=0

...000 ...001

0

1

...010

...011

...100

...101

S=0

S=1

S=0

...110

S=0

1

0

0

1

0

1

0

1

0

1

0

0

S=0

S=0

1

...111

c

e

f

g

h

d

Figure III.6. Détecteur de séquence 1,0,1 de type Moore, non simplifié. Chaque état estassocié à la réception d’une certaine séquence des 3 derniers bits.Seul l’état g provoque lasortie S = 1.

La valeur de la sortie S est clairement associée aux états, et ne peut donc changerqu’avec eux. Les changements d’état se produisent à chaque front de l’horloge CLK,qui n’est pas représentée sur la graphe, mais dont la présence est implicite. Un arclibellé ’0’par exemple indique un changement d’état lorsque E = 0.

2. la sortie dépend de l’état interne du circuitet de ses entrées, et on dit alors qu’il s’agitd’un schéma de MEALY. Pour le détecteur de séquence par exemple, la sortie Spourrait valoir 1dès queE passe à 1 pour la deuxième fois, avant même que sa valeurne soit ’officiellement’ échantillonnée au prochain front d’horloge. Cela conduit augraphe de MEALYde la figure III.7.

L’arc libellé ’1/0’de a vers b par exemple indique un changement d’état de a versb lorsque E = 1, avec une valeur de la sortie S=0. Mais attention : le changement d’étatne se produira qu’au prochain front d’horloge, alors que le changement de sortie seproduit immédiatement après le changement des entrées.

Différences entre les circuits de MOORE et de MEALY

La principale différence tient dans le fait que dans un circuit de MEALY, on obtient lessorties un temps d’horloge plus tôt. Par exemple dans la transition dec versf pourE = 1, lasortieS = 1sera échantillonnable (= mémorisée et utilisable) au front d’horloge suivant, enmême temps que l’état courant passera àf . Dans le circuit de MOORE, la sortie passera à 1aprèsle front d’horloge suivant, et ne sera stable et échantillonnable qu’au front d’horlogeencore ultérieur, c’est à dire un temps plus tard que dans le circuit de MEALY.


a b1/0

...000 ...001 1/0

...010

...011

...100

...101

...110

0/0

0/0

0/0

1/0

0/0

1/0

0/01/1

1/1

0/0

1/0

0/0

0/0

1/0

...111

e

f

c

d

g

h

Figure III.7. Détecteur de séquence 1,0,1 de type Mealy,non simplifié.

Pour certains types de circuits, il est plus facile de dessiner un graphe de MOORE, quicorrespond à une vision plus ’statique’du problème. La bonne nouvelle est qu’il existe uneméthode automatique de transformation d’un graphe de MOORE en graphe de MEALY,lorsque l’on veut profiter des avantages de ce dernier.

Transformation d’un graphe de Moore en graphe de Mealy

On voit sur la figure III.8 comment un arc dans un graphe de MOORE se transforme enun arc dans un graphe de MEALY équivalent.

a b

Se a’ e/S b’

Figure III.8. Un arc d’un graphe de MOORE transformé en un arc équivalent d’un graphede MEALY. Si avec l’entréee on va ena associé à une sortieS,alors cette sortie peut êtredirectement attachée à l’arc :e/S.

On a donc une méthode automatique pour transformer les graphes de MOORE engraphes de MEALY, très utile car les graphes de MOORE sont souvent plus faciles àconcevoir.C’est elle qu’on a utilisée par exemple pour transformer le graphe de MOORE dela figure III.6 en graphe de MEALY (figure III.7).

Transformation d’un graphe de Mealy en graphe de Moore

Ce n’est pas toujours possible, et donc aucune méthode générale ne peut exister. Lescircuits de MEALY sont donc intrinsèquement plus riches que ceux de MOORE.

6. Tables de transitionsLes tables de transitions, encore appeléestables de Huffmanne sont rien d’autre

qu’une version tabulaire des graphes de transitions. Par exemple, les tables associées auxgraphes de MOORE et de MEALY du détecteur de séquence sont représentées figure III.9et III.10.

6. Tables de transitions 67

avant aprèsétat E étata 0 aa 1 bb 0 cb 1 dc 0 ec 1 fd 0 gd 1 he 0 ae 1 bf 0 cf 1 dg 0 eg 1 fh 0 gh 1 h

état Sa 0b 0c 0d 0e 0f 1g 0h 0

Figure III.9. Table de transitions du graphe de MOORE pour le détecteur de séquence1,0,1. À chaque arc du graphe correspond une ligne dans la table. On notera la tablecomplémentaire,qui donne les sorties associées à chaque état.

avant aprèsétat E état Sa 0 a 0a 1 b 0b 0 c 0b 1 d 0c 0 e 0c 1 f 1d 0 g 0d 1 h 0e 0 a 0e 1 b 0f 0 c 0f 1 d 0g 0 e 0g 1 f 1h 0 g 0h 1 h 0

Figure III.10. Table de transitions du graphe de MEALY pour le détecteur de séquence1,0,1.À chaque transition du graphe correspond une ligne de la table.La valeur de la sortieS est associée à chaque transition.

Simplification des tables de transition

Une table de transitionspermet notamment de repérer facilement desétatséquivalents.Un groupeG d’états sont dits équivalents si, pour chaque combinaison possible des entrées,ils conduisent à des états du groupeG avec les mêmes sorties. On peut alors diminuer lenombre d’étatsen remplaçant tous les états du groupeGpar un seul,puis tenter de rappliquer


cette procédure de réduction sur l’ensemble d’états réduit.

Par exemple, sur la table de transitions précédente associée au diagramme de MOORE,on constate que a et e sont équivalents,que c et g sont équivalents,que d et h sont équivalents.Attention : b et f ne sont pas équivalents car, bien qu’ils aient mêmes états suivants, ils sontassociés à des sorties différentes. On peut réécrire la table de transitions en supprimant leslignes associées à e, g et h, et en remplaçant partout e par a, g par c, h par d (figure III.11).

avant aprèsétat E étata 0 aa 1 bb 0 cb 1 dc 0 ac 1 fd 0 cd 1 df 0 cf 1 d

état Sa 0b 0c 0d 0f 1

Figure III.11. Table de transitions du détecteur de séquence 1,0,1après une première phasede simplification.

Sur cette table, on constate que b et d sont équivalents, ce qui ne pouvait pas êtredéterminé à l’étape précédente. La figure III.12 montre la table encore simplifiée.

avant aprèsétat E étata 0 aa 1 bb 0 cb 1 bc 0 ac 1 ff 0 cf 1 b

état Sa 0b 0c 0f 1

Figure III.12. Table de transitions du détecteur de séquence 1,0,1 après une deuxièmephase de simplification.

Le processus de simplification s’arrête ici. Finalement, 4 états suffisent pour cedétecteur de séquence.Ceux-ci ont perdu la signification qu’ils avaient initialement dans legraphe à 8 états. Le graphe simplifié est représenté figure III.13.

Cette procédure de simplification s’applique également aux graphes de MEALY, encherchant des identités dans les couples état/sortie. Sur l’exemple précédent, on constateque a et e sont équivalents, que b et f sont équivalents, que c et g sont équivalents, et que det h sont équivalents. En procédant aux suppressions et substitutions associées, on trouve la

6. Tables de transitions 69

a b1

0S=0

1

S=0 S=1

0

1

0S=0

0

1c f

Figure III.13. Graphe de MOORE simplifié du détecteur de séquence 1,0,1.

nouvelle table (figure III.14).

avant aprèsétat E état Sa 0 a 0a 1 b 0b 0 c 0b 1 d 0c 0 a 0c 1 b 1d 0 c 0d 1 d 0

Figure III.14. Table de transitions de MEALY pour le détecteur de séquence 1,0,1, aprèsune première phase de simplification.

Cette fois, on voit que b et d sont équivalents (figure III.15).

avant aprèsétat E état Sa 0 a 0a 1 b 0b 0 c 0b 1 b 0c 0 a 0c 1 b 1

Figure III.15. Table de transitions de MEALY pour le détecteur de séquence 1,0,1, aprèsune deuxième phase de simplification.

Le processus s’arrête ici. Comme c’est souvent le cas, le graphe de MEALY est plussimple que le graphe de MOORE associé au même problème, ne comportant que 3 états(figure III.16).

7. Bascules synchrones

Notre but est maintenant de réaliser à l’aide de circuits logiques les machinesséquentielles telles qu’elles peuvent être décrites par les graphes d’états. Pour facilitercette synthèse, il a été imaginé de créer des composants appelésbascules, qui formeraient


a b1

0/0 1/0

0/01/1

0/0

c

Figure III.16. Graphe de MEALY simplifié du détecteur de séquence 1,0,1.

les briques de base à utiliser. Une bascule mémorise un seul bit et permet de représenterseulement deux états distincts, mais l’utilisation d’un vecteur den bascules permet de coderjusqu’à n2 états distincts. Par exemple, pour le détecteur de séquence analysé à la sectionprécédente, le graphe de Moore simplifié comportait 4 états, et un vecteur de deux basculesva permettre de les encoder.

Par ailleurs, pour que tout un vecteur de bascules évolue de façon fiable d’état en état,il est souhaitable que chacune d’elles ait une entrée d’horloge reliée à une horloge commune(circuit synchrone), et ne puisse changer d’étatqu’au moment précis d’un front de cettehorloge(montant ou descendant), et jamais entre deux fronts, même si les autres entrées ducircuit sont modifiées plusieurs fois entre temps.De tels circuits sont de conception difficile ;on les présente dans cette section.

7.1. Latch RS actif sur un niveau d’horloge

Dans le but de rendre synchrone le latch RS vu précédemment, on peut limiter lapériode d’écriture (figure III.17).

Figure III.17. Latch RS.

L’état de ce circuit est modifiable lorsque H = 1, c’est à dire sur unniveaudu signalH. Tant que H est au niveau 1, les modifications de S et de R vont avoir un effet sur l’état dubistable.Un tel latch peut avoir certainesapplications,mais il n’est pas adapté à la réalisationde circuits séquentiels synchrones, où les changements d’états de leurs différentes partiesdoivent se produire de façon parfaitement synchronisée, au moment précis défini par unfront d’une horloge commune. La section suivante va présenter un tel circuit.

7. Bascules synchrones 71

7.2. Bascule active sur front d’horloge

Nous avons donc besoin de composants séquentiels qui changent d’état sur un frontd’horloge, et seulement à ce moment précis. Le latch RS vu à la section précédente neremplissait pas cette condition,puisque le bistable pouvait changer de valeur tant que H étaitau niveau 1. Le circuit de la figure III.18, qui réalise ce qu’on va appeler unebascule D(Dpour ’delay’), ne change d’état quant à lui que sur le front descendant de l’horloge H.

module basculeD(h,d: q)s=/h*/r*/ns ;ns=/s*/d ;r=/nr*/h ;nr=/ns*/r ;q=/r*/nq ;nq=/s*/q ;end module

Figure III.18. Bascule D synchrone : l’état du bistable q ne change qu’au moment où hpasse de 1 à 0.

La compréhension détaillée du fonctionnement de ce circuit est difficile,et l’utilisationd’un simulateur tel que celui de SHDL peut y aider. On peut déjà remarquer que lorsque hvaut 1, on a nécessairement R=0 et S=0, et donc le bistable final qui produit q est dans l’étatde repos : tant que h vaut 1, l’état interne q ne peut pas changer, même si d change de valeurun nombre quelconque de fois. Lorsque h passe de 1 à 0, on peut montrer que le bistabledu haut va stocker la valeur de

−D et la placer surR, et que celui du bas va stocker la valeur

deD et la placer surS. On a donc au moment du front descendant un ’set’ ou un ’reset’ dubistable final,dans le sens de la mémorisation de la donnéed en entrée.Enfin,et c’est le pointimportant, on peut montrer également que lorsqueh est maintenu à 0, les valeurs deRet deSne peuvent pas changer même sid change, et donc les changements ded n’affectent pasle bistable final. On a donc bien démontré la propriété essentielle de ce circuit, qui est queson état interneq est affecté durant la période très courte où l’horlogeh passe de 1à 0, c’està dire durant un front descendant de celle ci, et que tous les changements sur d en dehors decette période n’ont pas d’effet surq.

7.3. Bascule D

Une tellebascule Dest représentée couramment par le schéma de la figure ?? On aindiqué également l’écriture SHDL associée à cette bascule.

Le signal de remise à zéroRSTn’était pas présent sur la figure III.18. Il s’agit d’uneremise à zéroasynchrone, qui provoque le forçage à 0 du contenu de la bascule, sansqu’il y ait besoin d’un front d’horloge. Tant que le signalRSTest actif (sur niveau 1 sur lafigure), la bascule est forcée à 0 et son contenu ne peut pas évoluer. Il s’agit du même signalresetque celui qui est présent sur votremicro-ordinateur, votre téléphone portable, etc. : en


module test(e,h,reset: x)x:=e ;x.clk=h ;x.rst=reset ;end module

Figure III.19. Représentation habituelle d’une bascule D synchrone.

l’appliquant, vous remettez dans l’état 0 tous les composants séquentiels de votre machine.

Du point de vue graphique, le triangle devant l’entréeCLK indique un signal d’horloge.S’il était précédé d’un rond, cela indiquerait une horloge active sur front descendant ; en sonabsence elle est active sur front montant. De la même façon, un rond devant l’entréeRSTindique une activité sur niveau bas. La figure III.20 illustre ces différentes situations.

module test(e,h,reset: x)x:=e ;x.clk=/h ;x.rst=reset ;end module

module test(e,h,reset: x)x:=e ;x.clk=h ;x.rst=reset ;end module

module test(e,h,reset: x)x:=e ;x.clk=/h ;x.rst=/reset ;end module

(a) (b) (c)

Figure III.20. Différentes bascules D. (a) horloge sur front descendant. (b) reset actif surniveau bas. (c) horloge front descendant et reset actif sur niveau bas.

Bascules et langage SHDL

En SHDL, la notation ’:=’ est appeléeaffectation séquentielle, et les suffixes ’.clk’ et’.rst’ servent à repérer les signaux d’horloge et de remise à zéro. Des horloges actives surfront descendant, ou des reset actifs sur niveau bas se traduisent par un signe ’/’ devant lenom du signal d’horloge ou de reset.Par ailleurs, on notera qu’on ne peut pas écrire quelquechose comme :

x.clk = a*b ; // incorrect

Cela impliquerait l’existence d’une basculeet d’une porte combinatoire, ce qui doit setraduire par deux équations distinctes :

x.clk = i ;i = a*b ;

Lorsqu’on écrit x.clk = /h ; , on ne fait pas appel à une porte supplémentaired’inversion : on utilise une bascule active sur front descendant, et donc on n’a pas à créer de


ligne supplémentaire. Pour les mêmes raisons, on ne doit pas écrire :x:=a*b ; , mais :

x := i ;i = a*b ;

On a tout de même la possibilité d’écrirex:=/i ; , qui correspond à une bascule D quicharge l’inverse de son entrée, et qui se traduit par la présence d’un rond devant l’entrée D(figure III.21).

module test(e,h,reset:x)x:=e ;x.clk=/h ;x.rst=reset ;end module

module test(e,h,reset:x)x:=/e ;x.clk=h ;x.rst=reset ;end module

(a) (b)

Figure III.21. Les deux formes possibles d’une bascule D. (a) entrée normale. (b) entréeinversée.

Équation d’évolution

L’équation d’évolutiond’une bascule, c’est l’équation de la valeur que prendra l’étataprès le front d’horloge.Dans le cas de la bascule D c’est tout simplement la valeur présenteà son entrée :

Q := D

7.4. Bascule T

Tout comme la bascule D, labascule T(trigger) mémorise également un bit de façonsynchrone, mais elle a des modalités différentes d’utilisation. Son schéma, une table detransitions synthétique et l’écriture SHDL associée sont donnés figure III.22.

L’état mémorisé de la bascule T s’inverse (après le front d’horloge) si et seulement sison entrée T vaut 1.Lorsque son entrée T vaut 0,cet état reste inchangé.Elle est donc adaptéeaux problématiques de changements d’une valeur et non à un simple stockage comme labascule D. En dehors des variations sur les fronts d’horloge et la ligne de reset asynchrone,les deux seules versions possibles de la bascule T sont données figure III.23.


Q := −TQ + T

−Q


avant après

T Q Q

0 x x

1 x −x

module test(e,h,reset: x)x:=/e*x+e*/x ;x.clk=h ;x.rst=reset ;end module

Figure III.22. Bascule T synchrone.Lorsque l’entrée T est à 0 elle ne change pas d’état ;lorsque l’entrée T vaut 1 son état s’inverse.

module test(e,h,reset: x)x:=/e*x+e*/x ;x.clk=h ;x.rst=reset ;end module

module test(e,h,reset: x)x:=e*x+/e*/x ;x.clk=h ;x.rst=reset ;end module

(a) (b)

Figure III.23. Les deux formes possibles d’une bascule T. (a) entrée normale. (b) entréeinversée.On notera la différence d’écriture en langage SHDL.

Le premier terme exprime bien que, si T est à 0, Q ne change pas, et que si T est à 1, Qs’inverse. On retrouve l’écriture SHDL de l’affectation séquentielle.

7.5. Bascule JK

Comme les bascules D et T, labascule JK(Jack-Kilby) mémorise un bit de façonsynchrone. Son schéma, sa table de transitions simplifiée et l’écriture SHDL associée sontdonnés figure III.24.

avant après

J K Q Q

0 0 x x

0 1 - 0

1 0 - 1

1 1 x −x

module test(reset,h,j,k:x)x:=/k*x+j*/x ;x.clk=h ;x.rst=reset ;end module

Figure III.24. Bascule JK synchrone,table de transitions simplifiée et écriture SHDL.Selonles valeurs de ses entrées J et K, elle permet le forçage de son état à 0 ou à 1, mais aussi laconservation ou l’inversion de son état.


Elle fonctionne de façon analogue au latch RS, J jouant le rôle de S et K de R. LorsqueJ et K sont à 0, l’état de la bascule ne change pas au front d’horloge. Si on veut faire unemise à 1ou une mise à 0, on applique 1sur J (respectivement sur K) puis on applique un frontd’horloge. De plus, mettre à la fois J et K à 1est autorisé, et l’état de la bascule s’inverse aufront d’horloge.


Q := −KQ + J

−Q

Elle est moins immédiatement évidente que celle des bascules D et T. On vérifie que danstous les cas, on a le résultat attendu :

• si J = 0et K=0,−KQ + J

−Q = 0 + Q = Q

• si J = 0et K=1,−KQ + J

−Q = 0 + 0 = 0

• si J = 1et K=0,−KQ + J

−Q = Q + −

Q = 1

• si J = 1et K=1,−KQ + J

−Q = 0 +−

Q = −Q

La bascule JK existe également avec des entrées J et K inversées.La figure III.25montre cesdifférentes formes, et l’écriture SHDL associée.

7.6. Choix des bascules

La bascule D est clairement adaptée aux situations où on doit stocker un bit présent.La bascule T est adaptée aux situations qui se posent en termes de changement oud’inversion. La bascule JK semble plus versatile, et elle est d’ailleurs souvent appeléebascule universelle. Par analogie avec les portes combinatoires, on pourrait se demandersi cette bascule JK est ’plus puissante’que les bascules D ou T, c’est à dire s’il est possiblede fabriquer avec elle des circuits que les autres ne pourraient pas faire. La réponse est non.Ces trois types de bascules ont une puissance d’expression équivalente : elle mémorisent unbit, et elles ne diffèrent que par les modalités de stockage de ce bit. Par exemple, on vérifiefacilement qu’on peut fabriquer une bascule JK avec une bascule T et réciproquement(figure III.26).

Dans le cas (a), il est clair qu’en reliant les deux entrées J et K, la bascule reste dans lemême état sit vaut 0, et elle s’inverse sit vaut 1, ce qui correspond bien au fonctionnementd’une bascule T.

Dans le cas (b), on a figuré la solution avec un multiplexeur pour plus de clarté. Lavaleur mise en entrée de la bascule T dépend de la valeur du couplej , k, et on vérifie qu’ona le résultat souhaité dans tous les cas :

1 si jk = 00, on place 0 sur l’entrée de la bascule T et elle ne changera pas de valeur aufront d’horloge.

2 Si jk = 10, on place sur l’entrée de la bascule T l’inverse de son état interne, et il estfacile de voir que cela conduit à la mise à 1 de la bascule au prochain front d’horloge.

3 Si jk = 01, on place l’état courant de la bascule T sur son entrée, ce qui conduit à la


module test(reset,h,j,k: x)x:=/k*x+j*/x ;x.clk=h ;x.rst=reset ;end module

module test(reset,h,j,k: x)x:=/k*x+/j*/x ;x.clk=h ;x.rst=reset ;end module

(a) (b)

module test(reset,h,j,k: x)x:=k*x+j*/x ;x.clk=h ;x.rst=reset ;end module

module test(reset,h,j,k: x)x:=k*x+/j*/x ;x.clk=h ;x.rst=reset ;end module

(c) (d)

Figure III.25. Les différentes formes possibles d’une bascule JK et leurs écritures SHDLassociées. (a) entrée normales. (b) entrée J inversée. (c) entrée K inversée. (d) entrées J etK inversées.

(a) (b)

Figure III.26. (a) construction d’une bascule T avec une bascule JK,(b) construction d’unebascule JK avec une bascule T.

forcer à 0 au prochain front.

4 Enfin si jk = 11, on place 1 en entrée de la bascule T ce qui va déclencher soninversion.


7.7. Schéma général d’un circuit séquentiel synchrone de type MOORE

La figure III.27 montre le schéma général d’un circuit séquentiel synchrone de typeMOORE.L’état interne est mémorisé dans un vecteur den bits ( n2 état au plus) constituéde bascules de type quelconque. Pour que ce circuit soit bien de type synchrone pur, toutesles horloges des bascules ont bien été reliées ensemble directement à l’horloge générale, defaçon à garantir un changement d’état de toutes les bascules exactement au même moment.Les propriétés des bascules garantissent que cet état ne peut pas changer entre deux frontsd’horloge, même si les entrées du circuit changent plusieurs fois entre temps. Par ailleurson voit que les sorties ne dépendent que de l’état interne, étant un simple transcodagecombinatoire decelui-ci.

transcodeurQ

Q

Q

p

mentrées

CLK

sorties

interneétat

n

Figure III.27. Schéma général d’un circuit séquentiel synchrone de type MOORE.

7.8. Schéma général d’un circuit séquentiel synchrone de type MEALY

La figure III.28 montre le schéma général d’un circuit séquentiel synchrone de typeMEALY . Il s’agit également d’un circuit synchrone pur, dans lequel les horloges de toutesles basculessont reliéesentre elles à l’horloge générale.Avec un vecteur d’état composé denbascules,on peut également coder au plusn2 états différents,et la mécanique de changementd’états est analogue à celle d’un circuit de type MOORE. La seule différence est dans lecalcul des sorties : on voit qu’elles ne dépendent pas que de l’état interne, mais qu’ellesdépendent aussi des entrées.C’est ce qui va leur permettre d’obtenir les mêmes sorties qu’uncircuit de MOORE, un temps plus tôt.

8. Synthèse d’un circuit séquentiel synchrone

8.1. Étapes de la synthèse d’un circuit séquentiel synchrone

Lors de la synthèse d’un circuit séquentiel synchrone à l’aide de bascules, qu’il soit detype MOORE ou de type MEALY, on obtiendra le circuit le plus simple en suivant les étapessuivantes :

1 dessin du graphe d’états : il permet une spécification claire du circuit.


Q

Q

Q

mentrées

CLK

transcodeur p sorties

n

interneétat

Figure III.28. Schéma général d’un circuit séquentiel synchrone de type MEALY.

2 table de transitions : forme plus lisible du graphe, qui permet de vérifier qu’aucunetransition n’est oubliée, et prépare la phase de simplification.

3 simplification de la table de transitions : on applique la méthode vue précédemment,parfois en plusieurs étapes.

4 détermination du nombre de bascules : le nombre d’états du graphe simplifié permetd’établir un nombre minimumn de bascules à employer. On ne choisit pas encorele type des bascules à employer, car la phase d’assignation fournira de nouvellesinformations.

5 assignation des états : pour chaque état, un vecteur unique den bits est assigné, appelévecteur d’état. Des règles heuristiques d’assignation permettent de trouver celle quiconduira à des calculs simples.

6 table de transitions instanciée : on réécrit la table de transitions, en remplaçant chaquesymbole d’état par le vecteur associé.

7 choix des bascules : en observant la table de transitions instanciée, certains types debascules peuvent être préférés. On emploiera une bascule D lorsqu’un état suivantest la recopie d’une valeur de l’état précédent, une bascule T lorsque l’état suivant estl’inverse d’un état précédent ; dans les autres cas, la bascule JK peut être employée.

8 calcul des entrées des bascules et calcul des sorties du circuit.

8.2. Synthèse du détecteur de séquence, version MOORE

A titre d’exemple, on va détailler la synthèse du circuit détecteur de la séquence 1,0,1décrit précédemment, en version MOORE. On reprend donc toutes les étapes énuméréesen introduction.

Graphe d’état, table de transitions, simplification

Ces trois étapes ont été réalisées en section 6, et ont abouties au graphe simplifié et à latable de transitions des figures III.29 et III.30.

8. Synthèse d’un circuit séquentiel synchrone 79

a b1

0S=0

1

S=0 S=1

0

1

0S=0

0

1c f

Figure III.29. Graphe de MOORE simplifié du détecteur de séquence 1,0,1.

avant aprèsétat E étata 0 aa 1 bb 0 cb 1 bc 0 ac 1 ff 0 cf 1 b

état Sa 0b 0c 0f 1

Figure III.30. Table de transitions simplifiée du détecteur de séquence 1,0,1.

Détermination du nombre de bascules

Il y a quatre états à coder, donc 2 bascules seront employées, dont on appellera lessorties X et Y.

Assignation des états

La phase d’assignation consiste donc à affecter un vecteur d’état à chacun des étatsdu circuit ; ici un couple (X,Y) pour chacun des 4 états. N’importe quelle assignation peutêtre employée.Néanmoins,on peut toujours affecter à l’état initial le vecteur d’état (0,0,…),qui sera forcé lors d’un RESET asynchrone du circuit. Par ailleurs, certaines assignationsdonnent lieu à des calculs plus simples que d’autres.On les trouve souvent en appliquant lesrègles heuristiques suivantes, par ordre de priorité décroissante :

1 rendre adjacents les états de départ qui ont même état d’arrivée dans le graphe.

2 rendre adjacents les états d’arrivée qui ont même état de départ dans le graphe.

3 rendre adjacents les états qui ont mêmes sorties.

L’idée est de minimiser le nombre de bits qui changent (état ou sorties) lors des changementsd’états.

Appliqué à notre circuit, la première règle préconise d’associer a et c, a et f, b et f ;la deuxième règle préconise d’associer a et b, b et c, a et f ; la troisième règle préconised’associer a, b et c. La figure III.31 propose une assignation qui respecte au mieux cesrègles.


a f

c b

Y 1

0

1

X0

Figure III.31. Assignation des états : chaque état est associé à une configuration binairedes bascules.

Table de transitions instanciée

On recopie la table de transitions précédente,en remplaçant chaque symbole d’état parson vecteur d’état (figure III.32).

avant aprèsX Y E X Y0 0 0 0 00 0 1 1 11 1 0 0 11 1 1 1 10 1 0 0 00 1 1 1 01 0 0 0 11 0 1 1 1

X Y S0 0 01 1 00 1 01 0 1

Figure III.32. Table de transitions instanciée.

Choix des bascules

En observant la table instanciée,on constate que X à l’état suivant reproduit l’entrée E :une bascule D s’impose pour X.Dans le cas de Y, il reproduit presque la valeur de X de l’étatprécédent, sauf pour la deuxième ligne. A titre d’exemple, on va choisir une bascule JK.

Calcul des entrées des bascules et de la sortie du circuit

Plusieurs méthodes sont possibles pour ces calculs. Celle qui sera employée ici estbasée sur une réécriture de la table de transitions, à laquelle on rajoute les entrées desbascules, ici DX pour la bascule X et JY,KY pour la bascule Y (figure III.33).

En fait on connaissait déjà le résultat pour X :DX = E, qui est la raison pour laquelleon avait choisi une bascule D. Pour Y, on trouve facilement queJY = E + X etKY = −

X. Parailleurs, on aS = X

−Y.

La synthèse est terminée,et notre séquenceur se réduit au schéma de la figure III.34.Onnotera l’écriture des affectations séquentielles dex ety : x := e est l’équation d’évolutionde la bascule D,ety := x*y+jy*/y est une équation de la formeq := /k*q+j*/q , pourlaquelle l’entrée K est inversée.

8.3. Synthèse du détecteur de séquence, version MEALY

On effectue ici la synthèse du même détecteur de séquence 1,0,1, cette fois en version


avant aprèsX Y E DX JY KY X Y0 0 0 0 0 * 0 00 0 1 1 1 * 1 11 1 0 0 * 0 0 11 1 1 1 * 0 1 10 1 0 0 * 1 0 00 1 1 1 * 1 1 01 0 0 0 1 * 0 11 0 1 1 1 * 1 1

X Y S0 0 01 1 00 1 01 0 1

Figure III.33. Table de transitions instanciée avec les entrées des bascules choisies.

module seq101(rst,h,e: s)x := e ;x.clk = h ;x.rst = rst ;y := x*y+jy*/y ;y.clk = h ;y.rst = rst ;jy = e+x ;s = x*/y ;end module

Figure III.34. Schéma final synthétisé du détecteur de séquence 1,0,1 (type MOORE) etdescription SHDL associée.

MEALY. Il permettra d’obtenir la sortie un front d’horloge avant la version MOORE, et onpeut espérer un circuit encore plus simple puisque son graphe simplifié comporte un état demoins que celui de MOORE.

Graphe d’état, table de transitions, simplification

Ces trois étapes ont été réalisées en section 6, et ont abouties au graphe simplifié et à latable de transitions des figures III.35 et III.36.

a b1

0/0 1/0

0/01/1

0/0

c

Figure III.35. Graphe de MEALY simplifié du détecteur de séquence 1,0,1.

Détermination du nombre de bascules

Il y a trois états à coder, donc 2 bascules seront employées, dont on appellera les sortiesX et Y.


avant aprèsétat E état Sa 0 a 0a 1 b 0b 0 c 0b 1 b 0c 0 a 0c 1 b 1

Figure III.36. Table de transitions simplifiée du détecteur de séquence 1,0,1.

Assignation des états

La phase d’assignation consiste donc à affecter un vecteur d’état à chacun des étatsdu circuit ; ici un couple (X,Y) pour chacun des 3 états. Afin d’obtenir les résultats les plussimples possibles, on essaie d’appliquer au mieux les heuristiques d’assignation décrites àla section précédente.

Appliquée à notre circuit, la première règle préconise d’associer a et c ; la deuxièmerègle préconise d’associer a et b. La figure III.37 propose une assignation qui respecte aumieux ces règles.

a

c

Y 1

0

1

X0

b

Figure III.37. Assignation des états : chaque état est associé à une configuration binairedes bascules.

Table de transitions instanciée

On recopie la table de transitions précédente,en remplaçant chaque symbole d’état parson vecteur d’état (figure III.38).

avant aprèsX Y E X Y S0 0 0 0 0 00 0 1 1 0 01 0 0 0 1 01 0 1 1 0 00 1 0 0 0 00 1 1 1 0 1

Figure III.38. Table de transitions instanciée.

Choix des bascules

En observant la table instanciée, on constate que X à l’état suivant reproduit l’entréeE : une bascule D s’impose pour X. Dans le cas de Y, il n’y a qu’une ligne où Y passe à 1 ;on peut choisir également une bascule D, dont on appellera l’entrée DY.


Calcul des entrées des bascules et de la sortie du circuit

Ici encore on va réécrire la table de transitions, à laquelle on va rajouter les entrées desbascules, ici DX pour la bascule X et DY pour la bascule Y (figure III.39).

avantX Y E DX DY X Y S0 0 0 0 0 0 0 00 0 1 1 0 1 0 00 1 0 0 1 0 1 00 1 1 1 0 1 0 01 0 0 0 0 0 0 01 0 1 1 0 1 0 0

Figure III.39. Table de transitions instanciée avec les entrées des bascules choisies.

En fait on connaissait déjà le résultat pour X :DX = E, qui est la raison pour laquelle onavait choisi une bascule D.Pour Y,on peut faire une table de Karnaugh qui va nous permettred’exploiter les combinaisons non spécifiées dues au fait que la table d’assignation n’est pascomplètement remplie (figure III.40).

0,0 0,1 1,1 1,0

X,Y

E0

1

1

*

*

Figure III.40. Table de Karnaugh pour le calcul de DX. Le vecteur XY=11 est non spé-cifié.

On trouve doncDX = −EX. Par ailleurs, on aS = EY.

La synthèse est terminée, et notre séquenceur se réduit au schéma de la figure III.41.On voit que cette fois la sortie ne dépend plus seulement de l’état interne comme dans lecircuit de MOORE ; elle dépend aussi de l’entrée E. Avec le simulateur SHDL, on pourrase convaincre que dans le circuit de MEALY on obtient bien la sortie S un front d’horlogeavant le circuit de MOORE.

module seq101(rst,h,e: s)x := e ;x.clk = h ;x.rst = rst ;y := dy ;y.clk = h ;y.rst = rst ;dy = /e*x ;s = e*y ;end module

Figure III.41. Schéma final synthétisé du détecteur de séquence 1,0,1 (type MEALY) etdescription SHDL associée. On voit que la sortie S dépend de l’état interne, mais aussi del’entrée E.


9. Chronologie d’un circuit séquentiel synchrone

9.1. Temps de setup, de hold et de propagation des bascules

Parmi les caractéristiques temporelles d’une bascule figurent les temps desetupet dehold. Le temps de setup est la duréeavant le front d’horloge durant laquelle les entrées dela bascule doivent être stables pour que le basculement se passe correctement. Le temps dehold est la durée analogueaprès le front d’horloge. L’union des deux définit une périodeautour du front d’horloge durant laquelle les entrées doivent être stables, faute de quoi lebasculement ne se produirait pas comme prévu.

Le temps de propagation quant à lui est le temps après lequel on est garanti d’avoir lanouvelle valeur de la bascule, après la période d’instabilité de la transition.

Toutes ces durées sont illustrées sur la figure III.42.

période où les entréesde la bascule doivent être stables

front d’horloge

t

temps de propagation

holdsetup

valeurs stablesde l’état suivant

Figure III.42. Temps de setup,de hold et de propagation d’une bascule.

9.2. Chronologie détaillée d’une transition.

La lecture de cette section n’est pas nécessaire pour qui veut concevoir un circuitséquentiel. Il lui suffit d’admettre qu’après le front d’horloge, au moment où les basculesdu circuit changent éventuellement d’état, on passe sans coup férir des valeurs de l’étatprécédent aux valeurs de l’état suivant.

On peut aussi chercher à comprendre en détail ce qui se passe lors d’une transition, etmême craindre qu’elle ne se passe mal. Même si le front d’horloge est le même pour toutesles bascules, les valeurs des signaux de l’état précédent ne peuvent-elles pas interférer aveccelles de l’état suivant ? C’est en effet possible dans certaines conditions. Considérons parexemple le schéma de la figure III.43.

Si la basculea a une commutation beaucoup plus rapide que la basculeb, la valeur dea va changer durant la période de hold de la basculeb, provoquant ainsi un fonctionnementincorrect.

Le plus souvent, c’est le temps de setup qui est violé, lorsqu’on augmente la vitessed’horloge à un rythme tel qu’un front d’horloge arrive alors que les entrées des bascules,qui sont des fonctions combinatoires des entrées et de l’état courant, n’ont pas eu un tempssuffisant pour se stabiliser.

9. Chronologie d’un circuit séquentiel synchrone 85

Figure III.43. Si la bascule a est trop rapide, le temps de hold de b sera violé.

En pratique, on emploie des bascules aux caractéristiques temporelles analogues.

9.3. Bascules maître-esclave

Une façon de résoudre le problème de timing précédent consiste à séparer clairementle moment de capture (d’échantillonnage) des valeurs de l’état précédent du moment où onlibère les valeurs pour l’état suivant, plutôt que de compter sur des délais de propagationtrop serrés.

On utilise pour cela des bascules spéciales appeléesbascules maître-esclave, câbléesselon le modèle de la figure III.44.

Figure III.44. Bascule maître-esclave.On capture les valeurs de l’état précédent au frontmontant de l’horloge,et on libère les valeurs pour l’état suivant au front descendant.

Sur le front montant de l’horlogeh, les valeurs issues de l’état précédent sont prises encompte, sans être libérées encore vers les sorties, et donc sans risque de rétroaction néfaste.Plus tard, sur le front descendant deh, les nouvelles valeurs des bascules associées à l’étatsuivant sont libérées.

Les basculesmaître-esclave peuvent être employées à peu près partout où sontemployées des bascules ordinaires, mais il faut cette fois bien contrôler les deux fronts del’horloge, et non un seul.

10. Circuits séquentiels réutilisables

On présente dans cette section des circuits séquentiels utilisés dans la conception desmicroprocesseurs ou des microcontrôleurs. Nous continuons notre travail de modularité, encréant des briques réutilisables dans d’autres constructions ; ici encore une interface adaptépermettra une récursivité ou une interconnexion aisés.


10.1. Compteur binaire

Compteur de base

Un compteur binairesurn bits incrémente à chaque front d’horloge une valeur denbits. On pourrait d’abord penser à créer un registre den bits avec des bascules D, puis àrelier leurs entrées à un circuit d’incrémentation, mais il y a une solution plus directe etefficace. On se rappelle en effet (section 4) l’algorithme de comptage : un bit est recopiéavec inversion si tous les bits à sa droite valent 1, et le bit de poids faible est toujours inversé.Cette description en termes d’inversion conduit à une conception à base de bascules T, danslaquelle l’entrée T d’une bascule est reliée au ET de tous les bits qui sont à sa droite. Lafigure III.45 montre un exemple d’un tel compteur sur 4 bits.

module cpt4(rst,h: a,b,c,d)d := /d ;d.clk = h ;d.rst = rst ;c := /d*c+d*/c ;c.clk = h ;c.rst = rst ;b := /tb*b+tb*/b ;b.clk = h ;

b.rst = rst ;tb = c*d ;a := /ta*a+ta*/a ;a.clk = h ;a.rst = rst ;ta = b*c*d ;end module

Figure III.45. Compteur binaire 4 bits. Un bit est inversé lorsque tous les bits situés à sadroite valent 1.

Ce compteur compte bien sûrmodulo n2 : après la valeur ’1111’, suit la valeur ’0000’sans qu’on puisse être prévenu de ce débordement.

On notera l’affectation séquentielle SHDL utilisée pour la bascule de poids faibled :d := /d; , qui se traduit par une bascule T avec un ’1’sur l’entrée T. Pour le bitc, l’écriturec := d*c+/d*/c; se traduit également par une bascule T, mais avec une inversion avantson entrée.Les autres bascules T ont une écriture directement tirée de l’équation d’évolutionstandard d’une bascule T.

Dans la foulée,on peut également créer un circuit décompteur selon la même méthode :un bit est inversé lorsque tous les bits qui sont à sa droite valent 0 (figure III.46).

Ajout d’une entrée de validation

Ces circuits comptent ou décomptent en permanence, et il n’y a aucun moyen desuspendre et de reprendre leur comptage.On va maintenant ajouter une entrée de validationen(pour ’enable’) qui ne permettra au compteur de compter que si elle vaut ’1’. Lorsqu’ellevaudra ’0’, le compteur restera figé sur la dernière valeur produite,malgré l’arrivée de fronts

10. Circuits séquentiels réutilisables 87

module dec4(rst,h: a,b,c,d)d := /d ;d.clk = h ;d.rst = rst ;c := d*c+/d*/c ;c.clk = h ;c.rst = rst ;b := /tb*b+tb*/b ;

b.clk = h ;b.rst = rst ;tb = /c*/d ;a := /ta*a+ta*/a ;a.clk = h ;a.rst = rst ;ta = /b*/c*/d ;end module

Figure III.46. Décompteur binaire 4 bits.Un bit est inversé lorsque tous les bits situés à sadroite valent 0.

d’horloge surh.

Il suffit pour cela d’ajouter une entrée de validation à chaque bascule T. Le langageSHDL autorise l’emploi de l’écriture :q.ena = en; qui réalise exactement cela, et qu’ilsuffit d’employer pour chacune des bascules du compteur. Si on ne dispose que de basculessans entrée de validation, la transformation de la figure III.47 permet de l’obtenir.

module bascten(rst,h,en,t:q)q := /tq*q+tq*/q ;q.clk = h ;q.rst = rst ;tq = en*t ;end module

Figure III.47. Bascule T avec entrée de validation.

Ajout d’une remise à zéro synchrone

On souhaite maintenant ajouter une entréesclr de remise à zéro synchrone, qui remetle compteur à zéroau prochain front d’horloge. Elle n’est bien sûr pas de même natureque l’entrée de reset asynchrone, qui n’est là que pour l’initialisation. Par ailleurs il ne fautpas essayer d’utiliser ce reset asynchrone pour implémenter notre remise à zéro synchrone.La règle d’or des circuits séquentiels synchrones purs, c’est de relierentre-elles toutesles horloges et de relier entre eux tous les signaux de reset asynchrone, sans chercher àles modifier. Nous sommes heureux de pouvoir réinitialiser à tout coup notre ordinateurpersonnel en appuyant sur le bouton de reset, sans que cela ne dépende d’une condition plusou moins bien pensée par un concepteur peu rigoureux.

Comme pour l’entrée de validation, le langage SHDL a une écritureq.sclr = sclr; qui fait exactement ce dont nous avons besoin. Si on ne dispose pas debascules T avec remise à zéro synchrone, la figure III.48 remplira cette fonction.


module tclr(rst,h,sclr,t:q)q := /tq*q+tq*/q ;q.clk = h ;q.rst = rst ;tq = /sclr*t+sclr*q ;end module

Figure III.48. Bascule T avec remise à zéro synchrone.

On notera l’écriture SHDLtq = /sclr*t+sclr*q; qui conduit à l’utilisation d’unmultiplexeur 2 vers 1. Sisclr vaut 0, la bascule T reçoit son entréet normalement ; sisclrvaut 1, la bascule T reçoitqen entrée,qui provoque la remise à 0 au prochain front d’horloge.En effet, si la bascule avait l’état 0, en ayant 0 en entrée elle reste à l’état 0 ; si elle avait l’état1, en recevant 1 en entrée, elle s’inverse et passe à 0 : dans tous les cas elle passe à zéro.

Chaînage de modules de comptage

Nous souhaitons maintenant chaîner plusieurs modules de comptage den bits afin deformer des compteurs dem×n bits. L’algorithmique de comptage par bloc est analogue àcelle par bits : un bloc incrémente sa valeur si tous les blocs qui sont à sa droite sont à leurvaleur maximum. Il nous manque donc pour chaque bloc un signal qui indique qu’il a atteintla valeur maximum. Pour économiser l’usage de portes ET, on va plutôt produire un signalripl qui vaut 1 lorsque le compteur est à la valeur maximumet queen = 1. Pour chaîner lesmodules, il suffit maintenant de relier leripl de l’un auende l’autre.La figure III.50 montrele chaînage de 4 modules de 4 bits pour former un compteur 16 bits.

10.2. Diviseur de fréquence

On souhaite construire un circuit qui fournisse des signaux d’horloge de fréquencesdifférentes et réglables, à partir d’une horloge de base. Dans beaucoup de système réels, ycompris nos ordinateurs de bureau, les signaux d’horloge sont bien souvent divisés avantd’être effectivement exploités. On utilisera aussi un diviseur de fréquence dans le timer denotre processeur CRAPS, pour régler la vitesse de la base de temps.

Plus précisément on souhaite que la fréquence du signal de sortie soit divisée parn2 ,n étant une valeur fournie sur une entrée du circuit. L’interface du diviseur est donné figureIII.49.

Figure III.49. Interface du circuit diviseur de fréquence.La sorties est un signal de mêmeforme queh, avec une fréquence divisée parn2


module cpt4(rst,h,en:a,b,c,d,ripl)d:=/en*d+en*/d ;d.clk=h ;d.rst=rst ;c:=/tc*c+tc*/c ;c.clk=h ;c.rst=rst ;tc=en*d ;b:=/tb*b+tb*/b ;b.clk=h ;b.rst=rst ;tb=en*c*d ;a:=/ta*a+ta*/a ;a.clk=h ;a.rst=rst ;ta=en*b*c*d ;ripl=en*a*b*c*d ;end module

module cpt16(rst,h,en:s15..s0)cpt4(rst,h,en:s3,s2,s1,s0,ripl1)cpt4(rst,h,ripl1:s7,s6,s5,s4,ripl2)cpt4(rst,h,ripl2:s11,s10,s9,s8,ripl3)cpt4(rst,h,ripl3:s15,s14,s13,s12,ripl)end module

Figure III.50. Compteur 16 bits formé avec 4 compteurs 4 bits.La sortie ripl d’un moduleindique qu’il est à la valeur maximum et que tous ceux qui sont à sa droite sont à leurmaximum. Le module qui est à sa gauche a son entrée en reliée à ce signal, et ne peuts’incrémenter que lorsqu’il vaut 1.

On va tirer parti du principe qu’une bascule T dont on relie l’entrée à 1 produit sur sasortie un signal rectangulaire dont la fréquence est égale à la fréquence d’horloge diviséepar 2. On peut s’en convaincre en examinant le chronogramme de la figure III.51.

CLK

Q

Figure III.51. Chronogramme d’évolution d’une bascule T dont on a forcé l’entrée T à 1.La sortie Q a une fréquence égale à la fréquence de l’horloge divisée par 2.

On voit en effet sur le chronogramme que la sortie de la bascule s’inverse, doncchange dedemi-période, à chaque front montant de l’horloge, c’est à dire toutes les deuxdemi-périodes de l’horloge. Il y a bien un rapport de 1 sur 2 entre les deux signaux.

On va ainsi créer une chaîne de trois de ces bascules T avec des entrées forcées à 1, afind’obtenir les 4 fréquencesd’horloge successives :f (la fréquence de l’horloge généraleclk ),f / 2,f / 4 etf / 8. On utilisera un multiplexeur 2 vers 4 commandé par l’entréen1..n0 pour


sélectionner parmi elles celle qui est désirée. On trouvera figures III.52 et III.53 le schémaassocié et son codage en langage SHDL. Ce sera la seule fois dans tout l’ouvrage où onaura fait une entorse au principe de base des circuits séquentiels synchrones qui consiste àrelier entre-eux tous les signaux d’horloge pour toutes les bascules. Mais ici, cela est faitprécisément pour produire un signal d’horloge,qui sera possiblement exploité quant à lui defaçon strictement synchrone.

Figure III.52. Structure du circuit diviseur de fréquence. Une suite de bascules T sontchaînées,divisant par 2 la fréquence à chaque étage.

module divfreq(rst,clk,d1..d0: s)q0 := /q0 ;q0.clk = clk ;q0.rst = rst ;q1 := /q1 ;q1.clk = q0 ;q1.rst = rst ;q2 := /q2 ;q2.clk = q1 ;q2.rst = rst ;s = /d1*/d0*clk + /d1*d0*q0 + d1*/dO*q1 + d1*d0*q2 ;end module

Figure III.53. Écriture SHDL du module diviseur de fréquence.

10.3. Registres

Un registreden bits est un ensemble den bascules D synchrones mises en parallèle etpartageant la même horloge (figure III.54).

On notera l’écriture vectorielle de typed[31..d0] . Elle est strictement équivalente àl’écritured31..d0 qui a été utilisée jusqu’ici ; elle est plus courte lorsque le nom du signalest long, car il n’est mentionné qu’une fois.

Registre avec ligne de sélection

Un registre peut être équipé d’une ligne de sélection qui doit être activée si l’on veutfaire une écriture ; ce type de signal a souvent pour nomen(enable), oucs(chip select) ou


// Description SHDL d’un registre 32 bitsmodule reg32(d[31..0],h,reset: q[31..0])q[31..0] := d[31..0] ;q[31..0].clk = h ;q[31..0].rst = reset ;END MODULE

Figure III.54. Registre de 32 bits avec son écriture SHDL.

encorece(chip enable). On a vu à la section précédente que le langage SHDL disposait del’écriture .ena pour prendre en compte directement un tel signal. La figure III.55 met enoeuvre cette écriture pour notre registre de 32 bits.

// description SHDL directemodule reg32_2(reset,h,en,d31..d0: q31..q0)q[31..0] := d[31..0] ;q[31..0].clk = clk ;q[31..0].rst = reset ;q[31..0].ena = en ;end module

Figure III.55. Registre avec entrée de sélection,écriture SHDL directe.

Pour mieux comprendre son fonctionnement, on peut le réaliser avec un multiplexeuret par rebouclage de la sortie sur l’entrée. La figure III.56 montre cette construction, avec lecode SHDL correspondant.

module reg32_3(reset,h,en,d31..d0: q31..q0)reg32(reset,h,in[31..0]: out[31..0]) ;in[31..0] = d[31..0]*en + q[31..0]*/en ;q[31..0] = out[31..0] ;end module

Figure III.56. Registre avec entrée de sélection construit avec un multiplexeur.

Lorsque l’entréeenest à 0, le multiplexeur reconduit la valeur du registre en entrée :il ne change alors pas de valeur au prochain front d’horloge. Lorsqueen vaut 1, c’est lavaleur présente sur les entréesd31..d0 qui est aiguillée par le multiplexeur, puis mémorisée.


Cette construction est bien sûr moins performante qu’avec des bascules D déjà équipéesd’une entrée de validation ; en particulier elle demande un temps de setup plus long dû à lapropagation au travers du multiplexeur.


11.1. Exercice 1 : système de sécurité

Énoncé

Réaliser un système de mise en marche de sécurité de machine dangereuse.Il est équipéde deux entrées A et B et la mise en marche est contrôlée par la sortie M. Il faut pour celaque la procédure suivante soit respectée :

1 A et B doivent être relâchés initialement ;

2 appuyer sur A,

3 appuyer sur B : la machine se met en marche.

Toute autre manipulation arrête ou laisse la machine arrêtée ; il faut ensuite reprendre laprocédure au point 1 pour la mettre en marche.

Solution

On va adopter une solution de type MOORE. On fera également une conceptionsynchrone, c’est à dire qu’on supposera présente une horloge suffisamment rapide pour nerater aucun événement sur A et B. Le graphe d’état de ce problème est donné figure III.57.

e

M=0

b c

1110

a

00

00

M=0

00

10M=0

11

0111

0110

0100

M=1

Figure III.57. Graphe d’état du système de sécurité, type MOORE.

En partant de l’état a, on progresse jusqu’à l’état c pour lequel M=1 si on respectela séquence de mise en marche. Sur ce chemin, on tombe dans l’état d’erreur e dès qu’ons’écarte de la procédure. Lorsqu’on est en e, on y reste tant que A et B ne sont pas relâchéstous les deux, conformément à la spécification de l’énoncé.

On réécrit ce graphe sous une forme tabulaire pour chercher s’il est simplifiable (figureIII.58).


avant aprèsétat A B étata 0 0 aa 0 1 ea 1 0 ba 1 1 eb 0 0 eb 0 1 eb 1 0 bb 1 1 cc 0 0 ec 0 1 ec 1 0 ec 1 1 ce 0 0 ae 0 1 ee 1 0 ee 1 1 e

état Ma 0b 0c 1e 0

Figure III.58. Table de transitions du graphe de sécurité.

Aucune simplification n’est possible ; le circuit possède donc un nombre minimald’états de 4. Il faut donc 2 bascules pour coder cet état, dont on appellera les sorties X et Y.

Vient maintenant l’étape d’assignation, durant laquelle nous devons choisir uneconfiguration des bascules X et Y pour chacun des états. On assignera à l’état a le vecteurXY=00, associer au reset des bascules. Pour les autres, il est souhaitable pour obtenir descalculs plus simples de respecter les heuristiques d’assignation, qui recommandent deplacer côte à côte les états fortement reliés dans le graphe. On peut par exemple choisirl’assignation de la figure III.59.

a

e

Y 1

0

1

X0

b

c

Figure III.59. Assignation des états du système de sécurité.

On peut maintenant réécrire la table de transition, en remplaçant les états symboliquepar leur vecteur associé (figure III.60).

Aucune bascule ne semble particulièrement adaptée à ces changements d’état. À titred’exemple, on va utiliser deux bascules T. On peut à nouveau écrire la table de transitioninstanciée, en rajoutant 2 colonnes TX et TY qui sont les entrées T des bascules X et Y(figure III.61).

Il suffit maintenant de trouver les formules algébriques pour TX et TY, en fonction deX, Y, A et B. On peut pour cela utiliser des tables de Karnaugh (figure III.62). On trouve :

1 TX = A−B−X

−Y + −

AX + −BXY

2 TY = −A

−B−XY + B

−YX + −

AX−Y


avant aprèsX Y A B X Y0 0 0 0 0 00 0 0 1 0 10 0 1 0 1 00 0 1 1 0 11 0 0 0 0 11 0 0 1 0 11 0 1 0 1 01 0 1 1 1 11 1 0 0 0 11 1 0 1 0 11 1 1 0 0 11 1 1 1 1 10 1 0 0 0 00 1 0 1 0 10 1 1 0 0 10 1 1 1 0 1

X Y S0 0 01 0 01 1 10 1 0

Figure III.60. Table de transitions instanciée du graphe de sécurité.

avant aprèsX Y A B TX TY X Y0 0 0 0 0 0 0 00 0 0 1 0 1 0 10 0 1 0 1 0 1 00 0 1 1 0 1 0 11 0 0 0 1 1 0 11 0 0 1 1 1 0 11 0 1 0 0 0 1 01 0 1 1 0 1 1 11 1 0 0 1 0 0 11 1 0 1 1 0 0 11 1 1 0 1 0 0 11 1 1 1 0 0 1 10 1 0 0 0 1 0 00 1 0 1 0 0 0 10 1 1 0 0 0 0 10 1 1 1 0 0 0 1

X Y S0 0 01 0 01 1 10 1 0

Figure III.61. Table de transitions instanciée du graphe de sécurité,avec les entrées des 2bascules T.

0,0 0,1 1,1 1,0

0,1

1,1

1,0

0,0

X,Y

1

A,B 0,0 0,1 1,1 1,0

0,1

1,1

1,0

0,0

X,Y

1

A,B

TX TY

1

1 1

11

1

1

11

1

Figure III.62. Simplification des équations du système de sécurité.


3 M = XY

11.2. Exercice 2 : compteur/décompteur

Énoncé

Concevoir un circuit séquentiel synchrone avec une entréee et 4 sortiesa,b,c,d , quicompte en binaire sura,b,c,d lorsquee=0 et qui décompte lorsquee=1 .

Solution

On pourrait concevoir ce circuit en construisant un graphe d’états, une table detransitions,etc.Mais cette méthode ne serait pas générique et avec 4 bits le graphe serait déjàde grande taille avec 16 états. Il est préférable ici de combiner deux circuits que l’on connaîtdéjà, le compteur et le décompteur.

On a déjà présenté les compteurs et les algorithmes de comptage et de décomptageen binaire (section 4). On réalise un compteur binaire 4 bits avec 4 bascules T ; la basculede poids faible a pour entrée 1 car elle change d’état à chaque front d’horloge ; les autresbascules ont pour entrée le ET des bits qui sont à leur droite. Un décompteur se faitégalement avec 4 bascules T ; la bascule de poids faible change également à chaque front ;les autres bascules changent d’état lorsque tous les bits qui sont à leur droite sont des 0.

La synthèse des deux est donc simple : la bascule de poids faible est commune, carelle change d’état à chaque front d’horloge dans les deux cas. Pour les autres bits, il s’agitégalement de faire un ET dans les deux cas, mais des bits qui sont à droite pour le comptageet de l’inverse de ces mêmes bits pour le décomptage. Il suffit donc de mettre un inverseurcommandé (un XOR, voir section 4) par le signale devant chacun des bits à prendreen compte dans le ET. Cela conduit au schéma de la figure III.63, avec un code SHDLimmédiat.

11.3. Exercice 3 : utilisation des bascules

Énoncé

Construire une bascule D avec une bascule T, puis une bascule T avec une bascule D.On pourra utiliser des circuits combinatoires.

Solution

1 Bascule D avec une bascule T.

On peut se poser une question simple : comment mettre à 0 une bascule T ? Il suffit demettre la valeur Q de la bascule sur son entrée T. Si elle valait 0 elle y reste et si ellevalait 1 elle s’inverse et passe à 0.

Pour mettre à 1une bascule T, on voit aussi facilement qu’il suffit d’appliquer l’inversede Q sur l’entrée T.

Dans les deux cas, on a appliqué sur l’entrée T la valeur Q de la bascule, avec uneinversion commandée par la valeur D à mémoriser : XOR(D,Q).


module cptdec(rst, h, e : a, b, c, d)// bascule aa := /ta*a+ta*/a;a.clk = clk;a.rst = rst;ta = nb * nc * nd;// bascule bb := /tb*b+tb*/b;b.clk = clk;b.rst = rst;tb = nc * nd;// bascule cc := /tc*c+tc*/c;c.clk = clk;c.rst = rst;tc = nd;// bascule dd := /d;d.clk = clk;d.rst = rst;// inversion de a,b,c,d// commandée par ena = a*/e + /a*e;nb = b*/e + /b*e;nc = c*/e + /c*e;nd = d*/e + /d*e;end module

Figure III.63. Compteur/décompteur : schéma et écriture SHDL.

2 Bascule T avec une bascule D.

La solution est ici plus directe : il suffit d’appliquer sur D l’équation d’évolution de labascule T, qui estQ := −

TQ + T−Q.

Chapitre IV

Éléments fonctionnels d’un processeur

Le présent chapitre décrit les modules combinatoires et séquentiels les pluscommunément utilisés dans les architectures d’ordinateurs, permettant ainsi la transitionavec le chapitre suivant décrivant en détail l’architecture d’un processeur 32 bits. Lescircuits que nous allons étudier à partir de maintenant sont trop complexes pour pouvoir êtreanalysés et synthétisés dans leur ensemble à l’aide des méthodes tabulaires et algébriquesvues aux chapitres précédents. Comme en logiciel, le concept demoduleva être utilisépour circonscrire et donc maîtriser cette complexité ; il prendra même parfois une formerécursive, lorsqu’un module sera défini par l’assemblage de modules semblables, mais avecun nombre d’entrées et de sorties plus petit. Le découpage en modules de l’ensemble d’unsystème complexe va quant à lui faire appel à des méthodes plus intuitives, que nous allonstenter d’introduire au travers de nombreux exemples.

Les microprocesseurs et microcontrôleurs sont des circuits séquentiels synchronescomplexes, dans lesquels nous opérerons ce découpage en modules, chaque partie étant uncircuit combinatoire ou séquentiel standard qui a souvent une structure récursive au sensdéfini précédemment. Par exemple on va voir que l’Unité Arithmétique et Logique (UAL),qui fait les calculs au sein d’un processeur, a la même structure quel que soit le nombre debits des donnéesqu’elle traite,et qu’on pourra associer des ’tranches’d’UAL pour construiredes UALs de plus grosse capacité. Les concepteurs de processeurs peuvent donc faire appelà ce concept de modularité récursive lors de l’augmentation de la taille des données parexemple, en minimisant les temps de conception.

On présente également dans cette partie une nouvelle notion électrique,celle des sortiesen haute impédance, qui facilite la gestion de bus de grande taille. On présente aussi lescircuits mémoire, qui sont au sens strict des circuits séquentiels,mais qui ne se réduisent pasà des assemblages de bascules ou de latchs. Une section entière leur est consacrée, vu leurimportance dans les systèmes informatiques et la diversité croissante de leurs types.

Une fois achevée la compréhension de ces modules de base, la conception d’unprocesseur va ressembler à un jeu de construction avec des blocs qui vont s’emboîterharmonieusement.

1. Sorties haute-impédance

Certains circuits possèdent des sorties ditestrois états(tri-state), c’est à dire qu’enplus de pouvoir être dans l’état ’0’ou l’état ’1’ (c’est à dire dans un état électrique de ’basseimpédance’), elles peuvent être dans un troisième état dit de’haute-impédance’, souventnotéHigh-Z. Lorsqu’une sortie est en haute-impédance, tout se passe comme si elle n’étaitplus connectée, car elle ne produit plus ni ne consomme plus aucun courant. Cette propriétépermettra de relier directement entre-elles plusieurs sorties de ce type, sous réserve de

98

1. Sorties haute-impédance 99

garantir qu’au plus une seule de ces sorties produise du courant à un moment donné (souspeine decourt-circuit !).

Les circuits ayant des sorties trois états possèdent en interne des composants appelésbuffer trois-états, qui se représentent tels que sur la figure IV.1.

E S E S

VALIDE VALIDE

// écriture SHDLS = E:OE ;

Figure IV.1. Buffer 3-états - La sortie est en haute-impédance tant que VALIDE = 0.

La ligneVALIDE qui arrive sur le côté du triangle, souvent notéeOE (pour ’OutputEnable’), commande l’état de la sortie. Tant que cette ligne est inactive, la sortie reste dansl’état High-Z.

Du point de vue de l’écriture SHDL, cette commandeOutput Enablesur un signal telqueSs’indique par l’ajout après le nom du signal d’une commande telle que:OE

Si on considère cet étatHigh-Z comme un troisième état logique (ce qui n’est pas trèsexact sur le plan mathématique), on a la table de vérité de la figure IV.2.

E OE S

* 0 High-Z

0 1 0

1 1 1

Figure IV.2. Table de vérité d’un buffer 3-états.

On peut illustrer l’utilisation de ces buffers lors de la réalisation d’unmultiplexeur(figure IV.3). Les sorties des deux buffers 3-états sont reliées entre-elles, car leurs lignesOEs’activent de façon mutuellement exclusive.L’idée de ce schéma est que, soit on doit laisserpasser le courant qui vient de A (avec l’interrupteur commandé que forme le buffer troisétats), soit on doit le laisser passer depuis B. Comme ces deux conditions sont mutuellementexclusives, on peut relier les sorties des deux buffers en toute sécurité. On économise ainsile circuit OU du schéma classique de droite, qui n’opérait jamais avec ses deux entrées à 1simultanément.

On notera l’écriture SHDL telle que :S = A:/C; . L’équipotentielle s’appelleS, maisdeux sources de courant peuvent y imposer leur potentiel ; on les note alorsA:/C etB:C .

On voit sur la figure IV.4 une configuration électrique particulière de ce circuit : lacommandeC étant à 1, seul le buffer 3-états du bas va être dans un état de basse impédance,et va imposer son état électrique à la sortieS. Le buffer trois états du haut a sa sortie enhaute impédance et n’entre pas en conflit avec l’autre pour l’établissement du potentiel deS ;tout se passe comme s’il était déconnecté du circuit, ce qui a été figuré par les deux lignesbrisées.

100 CHAPITREIV. ÉLÉMENTS FONCTIONNELS D’UN PROCESSEUR

A

B

C

S0

1

A

B

C SA

B

C

S

MODULE MUX_1(A,B,C :S)S = A:/C ;S = B:C ;END MODULE

MODULE MUX_2(A,B,C :S)S1 = /C * A ;S2 = C * B ;S = S1 + S2 ;END MODULE

Figure IV.3. Multiplexeur réalisé à l’aide de buffers 3-états, comparé à sa réalisation enlogique combinatoire classique.On économise le ’ou’ final.

C=1

B=1

A=0

S=1

1

High−Z

Figure IV.4. Fonctionnement du multiplexeur. Dans cette configuration, c’est le buffer dubas qui impose son potentiel.

Si on relie ensemble deux sorties de buffers trois états, et qu’à un moment donné leurslignesOEsont à 1en même temps, le court circuit est réel,et les circuitsse mettent à chaufferdangereusement, entraînant parfois la destruction ou l’endommagement du plus faible.Cela peut se produire dans des réalisations composées de plusieurs circuits intégrés, dontles sorties trois états sont reliées entre elles. Cela peut se produire également à l’intérieurd’un seul circuit comme un FPGA, dans lequel des lignes internes à trois états peuvent êtrereliées entre elles lors de la programmation- configuration. On évite parfois le pire avec unbon odorat, en détectant l’odeur de cuisson de la poussière présente à la surface des circuitsà des températures avoisinant parfois les 100 degrés Celcius, et en débranchant en hâtel’alimentation !

C’est en fait la seule situation dangereuse pour les composants lorsque l’on fait de lalogique digitale. Tant qu’on n’utilise pas de composants avec des sorties trois états, rien nepeut être endommagé si on prend soin de ne relier chaque sortie qu’à des entrées. Avec les

1. Sorties haute-impédance 101

composants ayant des sorties trois états, il faudra impérativement connecter leurs lignesOEà des circuits tels que desdécodeurs(voir section 3) qui vont garantir l’exclusion mutuelleentre les sorties reliées entre elles.

2. Les bus parallèles

2.1. Vocabulaire et concepts

On appelle bus parallèle un ensemble d’équipotentielles électriques quiinterconnectent plusieurs modules à l’intérieur d’un câblage. On voit figure IV.5 commenton représente graphiquement un bus parallèle de largeurm.Le trait est épaissi par rapport àun signal simple, et une barre surmontée d’un nombre indique la largeur du bus. On montre

m m

Figure IV.5. Les deux représentations graphiques d’un bus parallèle de largeur m.

également figure IV.6 les façons habituelles de représenter sur un schéma lessous-bus d’unbus donné.

5

data[15..0]

data[15..11]

data[15..0]1616

data[15..11]

5

1616data[15..0]data[15..11]5

11

data[10..0]

5

11

Figure IV.6. Exemples de scindements / regroupements de bus.

On trouve des bus parallèles à tous les niveaux d’une architecture d’ordinateur : dansles structures internes du processeur, entre le processeur et les autres composants présentssur la carte mère, etc. Ils peuvent être présents partout où plusieurs composants doiventéchanger des données.Un bus large va permettre de transférer en une transaction une donnéede grande taille, mais va occuper beaucoup de place sur les circuits, et donc coûter plus cher.La même donnée pourra être copiée en deux transactions successives, avec un bus deux foismoins large ; un compromis est donc à trouver entre coût et vitesse de traitement.

Pour que des modules puissent dialoguer sur un même bus, sur le plan électrique, il faut


adopter bien sûr les mêmes tensions d’alimentation, courants de sortie et d’entrée, etc. Maisil faut aussi empêcher lescourts-circuitssur les lignes de données, lorsque plusieursmodulesont la possibilité d’y écrire. Par ailleurs, un protocole de communication est indispensable,afin de régler la chronologie des échanges sur le bus. Dans ce domaine, comme dansbeaucoup d’autres de l’architecture des ordinateurs, on peut classer ces protocoles en deuxcatégories : les synchrones et les asynchrones. Dans ces deux catégories, un grand nombrede protocoles différents existent, dont l’étude sort du cadre de ce livre. Les protocolessynchrones sont les plus répandus et les plus simples, car ils règlent tous les échanges sur unsignal d’horloge unique (qui fait partie du bus).

2.2. Exemple de bus synchrone simple

Afin d’illustrer quelques aspects de la communication sur un bus synchrone,considérons le circuit de la figure IV.7. Le bus est composé de 11 lignes : 8 lignes de

8

8

a[7..0]

n1*n0

8

8

c[7..0]

/n1*n0

8

8

b[7..0]

n1*/n0

2

8

compteur 2 bits

maitre

bus

data[7..0]

n[1..0]

clk

8

2

8

8

d[7..0]

/n1*/n0

esclaves

Figure IV.7. Exemple de bus synchrone,à un maître et 4 esclaves.Les sorties des esclavessont des buffers 3-états,dont les lignes OE s’excluent mutuellement.

donnéesdata[7..0] et 3 lignes de contrôlen[1..0] et clk. Le bloc de gauche joue le rôledemaître,c’est à dire qu’il dirige les échanges sur le bus. C’est lui qui génère les signauxde contrôle, gouvernés par l’horlogeclk qui cadence tous les échanges. À chaque front declk, le maître génère à l’aide d’un compteur un nouveau numéro sur les lignesn[1..0]. LeslignesOE de chaque esclave sont associées à un numéro spécifique ; par exemple l’esclavedont la ligneOE est reliée àn1*/n0 est associé au numéro 2 (10 en binaire), et ne placerasa donnéeb[7..0] sur le bus que si ce numéro est présent sur les lignesn[1..0] du sous-busde contrôle.

Dans ce protocole synchrone particulièrement simple, les 4 esclaves placent à tourde rôle leur donnée sur le sous-busdata[7..0], gouvernés par le module maître. Ici lebus est monodirectionnel, les échanges allant toujours dans le sens esclave vers maître ;certains protocoles pourront être bidirectionnels. Il n’y a ici qu’un seul maître, donc pas depossibilité de conflit. S’il y avait plusieurs maîtres, une logique d’arbitrage serait nécessairepour décider quel maître peut prendre le contrôle du bus en cas de requêtes simultanées.Il s’agit d’un protocole à une phase, puisqu’un échange de données est effectué en uncycle d’horloge. Des protocoles complexes peuvent nécessiter de nombreuses phases pourréaliser un échange, plusieurs phases pouvant être nécessaires pour que le maître décrive lesparamètres de sa demande à l’esclave, et plusieurs autres pouvant être nécessaires pour que

2. Les bus parallèles 103

l’esclave transmette la donnée demandée.

2.3. Exemple de bus parallèle, externe et normalisé : le bus PCI

Pour mieux comprendre la problématique des bus, on peut penser au busPCI parallèleprésent sur la plupart des ordinateurs personnels et des stations de travail (même s’il estprogressivement remplacé maintenant par le bus PCI Express, plus rapide). Lorsqu’onouvre une de ces machines, on voit sur la carte mère plusieurs connecteurs exactementidentiques, comportant deux fois 94 broches, disposés parallèlement à quelques centimètresd’intervalle.On peut parfoisapercevoir sur le circuit imprimé une partie des interconnexionsentre ces connecteurs. Elles sont très simples : les broches de même position sont toutesreliées entre elles pour tous les connecteurs. Il y a donc 188 pistes sur le circuit imprimé quirelient entre elles les 188 broches de chaque connecteur (figure IV.8).

Figure IV.8. Bus PCI,avec 4 connecteurs à 188 broches.

Si on considère maintenant une carte placée dans un de ces connecteurs, comme unecarte d’acquisition vidéo, ou une carte réseau, il faut comprendre que ces 188 signaux sontson unique moyen de communication avec le reste du système, et qu’il faut donc trouver unmoyen de dialoguer, rationnel à la fois sur le plan électrique et sur le plan logique. Pour lebus PCI comme pour tous les bus externes standardisés,ce protocole de communication doitêtre très général, utilisable par des cartes de types variés, en nombre non fixé à l’avance, quipeuvent être par exemple principalement émettrices de données (cartes d’acquisition vidéo),ou principalement réceptrices (cartes audio), ou les deux (cartes réseau).

3. DécodeursUn décodeurest un circuit possédantn entrées et n2 sorties numérotées (figure IV.9).

À tout moment, une et une seule sortie est active : celle dont le numéro correspond à lavaleur binaire présente sur lesn entrées. Le décodeur traduit donc la valeur d’entrée en uneinformation de position spatiale.

S1S2S3S4S5S6S7

S0 000000

01

E1E0

E2

EN

110

1

MODULE DECODER3TO8(EN,E2..E0 :S7..S0)S7=EN*E2*E1*E0 ;S6=EN*E2*E1*/E0 ;S5=EN*E2*/E1*E0 ;S4=EN*E2*/E1*/E0 ;S3=EN*/E2*E1*E0 ;S2=EN*/E2*E1*/E0 ;S1=EN*/E2*/E1*E0 ;S0=EN*/E2*/E1*/E0 ;END MODULE

Figure IV.9. Décodeur 3 vers 8.Avec la valeur 6 en entrée (110 en binaire),la sortie numéro6 est activée.

Un décodeur peut être utilisé pour n’activer qu’au plus un composant3-états à la fois,puisqu’au plus une seule de ses sorties est active à la fois.


Les décodeurs peuvent également être utilisés pour implémenter des fonctionslogiques booléennes. Puisque chaque sortie représente un des minterms possibles, et quetoute fonction combinatoire booléenne s’exprime sous forme d’une somme de minterms,on reliera avec un OU les sorties correspondants aux minterms désirés. On peut voir figureIV.10 la réalisation d’un OU exclusif (XOR) à trois entrées avec un décodeur et un OU à4 entrées.

E1E0

E2

000001010011100101110111

Figure IV.10. Un décodeur 3 vers 8 utilisé pour réaliser un OU exclusif à 3 entrées.

4. Multiplexeurs

Ces sont des circuits d’aiguillage pour les signaux logiques. Unmultiplexeurpossèden2 entrées de données, n entrées de commandes, et une seule sortie. On indique sur la

commande le numéro (en binaire) de l’entrée de donnée qui va être aiguillée en sortie. On aen figure IV.11 un exemple de multiplexeur 8 vers 1 sur la commande duquel est écrit1102= 610 ; la sortie reflète alors l’état de la sixième entrée :E6.On donne aussi figure IV.11

l’écriture SHDL de ce multiplexeur, qui est celle d’un circuit combinatoire simple.

E1

E3

E4

E5

E6

E7

E2

0

1

1

1

1

0

0

0 E0

C2..C0

110

1S

MODULE MUX8TO1(E7..E0,C2..C0 :S)S=/C2*/C1*/C0*E0+ /C2*/C1*C0*E1+ /C2*C1*/C0*E2+ /C2*C1*C0*E3+ C2*/C1*/C0*E4+ C2*/C1*C0*E5+ C2*C1*/C0*E6+ C2*C1*C0*E7;END MODULE

Figure IV.11. Multiplexeur 8 vers 1.L’entrée numéro 6 est aiguillée vers la sortie.

Bien sûr, les multiplexeurs peuvent être mis en parallèle pour aiguiller des bus entiers.On mettra alors en commun les lignes de commande, et en parallèle les lignes de données.

4. Multiplexeurs 105

On peut voir figure IV.12 un multiplexeur 2 vers1aiguillant des bus de 32 bits,avec l’écritureSHDL correspondante.

32

32

32S31..S0

B31..B0

A31..A0

C

MODULE MUX2TO1_32(A31..A0,B31..B0,C :S31..S0)S31..S0 = /C*A31..A0 + C*B31..B0 ;END MODULE

Figure IV.12. Multiplexeur 2 vers 1,aiguillant des bus de 32 bits.

Un multiplexeur 2 vers 1 implémente matériellement une situation de typesi-alors-sinon; plus précisément :si C alors S=Asinon S=B (figure IV.13). C’est uneremarque qui peut sembler banale, mais qui en fait va permettre d’organiser le découpageen modules d’un système complexe, dès lors qu’un tel genre de situation aura été identifié.

1

0

n

n

A

B

S

n

C

Figure IV.13. Un multiplexeur 2vers 1implémenteune situation ’si-alors-sinon’ :si C alorsS = A sinon S = B.

Un multiplexeur n2 vers 1 peut également être utilisé directement pour implémenterdes fonctions combinatoires àn entrées. Il suffit de relier les entrées de la fonction à réaliseraux entrées de commande du multiplexeur :chaque combinaison va conduire à un aiguillagespécifique, et il n’y a plus qu’à mettre la valeur 0 ou 1 attendue sur l’entrée de donnéecorrespondante du multiplexeur. Il n’y a cette fois aucun composant supplémentaire àrajouter, et on peut voir figure IV.14 l’implémentation d’une fonction XOR à 3 entrées avecun décodeur 8 vers 1. Bien sûr, cette solution n’est pas optimale en nombre de transistorsutilisés, puisque toutes les entrées forcées à 0 sont reliées à des portes ET inutilisées.

5. Encodeurs de priorité

Un encodeur de prioritépossèden2 entrées etn sorties. Les entrées sont numérotées,et correspondent à des événements de priorité croissante. On verra en particulier commentutiliser les encodeurs de priorité pour gérer l’arrivée d’interruptions simultanées dans unprocesseur, telles que les événements réseau, les événements disque, les événements USB ouclavier ou souris, etc.

La sortieNUM contient le numéro de l’entrée activée la plus prioritaire, c’est à dire denuméro le plus élevé.Une autre sortie (ACTsur la figure)peut aussi indiquer s’il y a au moins


0

1

0

1

E2..E0

XOR3(E2..E0)

1

0

1

0

2

7

6

5

4

3

1

0

Figure IV.14. Un multiplexeur 8 vers 1 utilisé pour réaliser un OU exclusif à 3 entrées.

une entrée active. Le schéma de la figure IV.15 montre un tel encodeur pour32 entrées avecles entrées 0, 3 et 6 activées, et la valeur binaire 6 placée sur les sorties.

1

1

1

00

00

0

E0E1E2E3E4E5E6E7

ACT

3NUM2..0

prioritéde

encodeur110 (6)

1

MODULE ENCODEUR(E[7..0]: NUM[2..0],ACT)NUM2=E7+E6+E5+E4 ;NUM1=E7+E6+/E5*/E4*E3+/E5*/E4*E2 ;NUM0=E7+/E6*E5+/E6*/E4*E3+/E6*/E4*/E2*E1 ;ACT=E7+E6+E5+E4+E3+E2+E1+E0 ;END MODULE

Figure IV.15. Encodeur de priorités à 8 entrées.L’entrée active #6 est la plus prioritaire.

La table de vérité d’un tel circuit à 8 entrées possède 256 lignes ; on peut néanmoins lareprésenter de façon condensée (figure IV.16).

L’entrée #0 est souvent non câblée : l’absence d’entrée active est alors détectée lorsqueNUM = 0, évitant ainsi d’avoir la sortie supplémentaireACT.

Une façon élégante d’obtenir le résultat consiste à utiliser une écriture vectorielle, quipermet d’avoir tous les bits à la fois. On traduit le fait qu’on obtient la sortie 111 lorsqu’ona E7 ; qu’on obtient 110 lorsqu’on a E6 et pas E7, etc. :

NUM2NUM1NUM0

=

111

×E7 +

110

×−E7E6 +

101

×−E7−E6E5 +

100

×−E7−E6−E5E4

+

011

×−E7−E6−E5−E4E3 +

010

×−E7−E6−E5−E4−E3E2 +

001

×−E7−E6−E5−E4−E3−E2E1

5. Encodeurs de priorité 107

E7 E6 E5 E4 E3 E2 E1 E0 NUM2..0 ACT

1 * * * * * * * 1 1 1 1

0 1 * * * * * * 1 1 0 1

0 0 1 * * * * * 1 0 1 1

0 0 0 1 * * * * 1 0 0 1

0 0 0 0 1 * * * 0 1 1 1

0 0 0 0 0 1 * * 0 1 0 1

0 0 0 0 0 0 1 * 0 0 1 1

0 0 0 0 0 0 0 1 0 0 0 1

0 0 0 0 0 0 0 0 0 0 0 0

Figure IV.16. Table de vérité condensée d’un encodeur de priorités à 8 entrées.

NUM2NUM1NUM0

=

E7E7E7

+

−E7E6−E7E6

0

+

−E7−E6E5

0−E7−E6E5

+

−E7−E6−E5E4

00

+

0−E7−E6−E5−E4E3−E7−E6−E5−E4E3

+

0−E7−E6−E5−E4−E3E2

0

+

00

−E7−E6−E5−E4−E3−E2E1

NUM2NUM1NUM0

=

E7 +−E7E6 +−E7−E6E5 +−E7−E6−E5E4E7 +−E7E6 +−E7−E6−E5−E4E3 +−E7−E6−E5−E4−E3E2

E7 +−E7−E6E5 +−E7−E6−E5−E4E3 +−E7−E6−E5−E4−E3−E2E1

Le théorème d’absorption s’applique plusieurs fois, et on obtient finalement :

NUM2NUM1NUM0

=

E7 + E6 + E5 + E4E7 + E6 +−E5−E4E3 +−E5−E4E2

E7 +−E6E5 +−E6−E4E3 +−E6−E4−E2E1

L’écriture SHDL d’un encodeur à 8 entrées est donnée figure IV.15. On reprendra àl’exercice 11.3 le calcul des équations des signauxNUM2..0.

6. Circuit d’extension de signe

Un circuit d’extension de signedep bits versn bits,p < n est un circuit combinatoirequi transforme un nombre signé codé en complément à 2 surpbits en ce même nombre codéen complément à 2 sur un nombre de bitsn plus grand.

Considérons par exemple une extension de signe de 4 bits vers 8 bits, et quelques casparticuliers :

• 00112 (= 3) sera converti en000000112

• 11112 (= -1) sera converti en111111112

• 10002 (= -8) sera converti en111110002


On voit donc que le mot denbits est formé de la recopie du mot depbits, complété à gaucheden − p bits tous égaux à 0 ou à 1 selon le signe du nombre. On recopie en faitn − p fois lebit de signe du mot de départ, c’est à dire le bit de rangp − 1(figure IV.17).

1 0 1 0

1 1 1 1 1 0 1 0

Figure IV.17. Opération d’extension de signe. On duplique les p bits d’entrée et on ajouteà gauche n-p bits de signe.

La figure IV.18 montre à titre d’exemple le code SHDL correspondant à un circuitd’extension de signe de 13 bits vers 32 bits.

module signext13(e12..e0: s31..s0)s12..s0 = e12..e0;s31..s13 = e12;end module

Figure IV.18. Écriture SHDL d’un circuit d’extension de signe 13 bits vers 32 bits. Les 13bits de poids faibles sont recopiés et on ajoute 19 bits de poids forts, tous égaux au bit designee12 du nombre de départ.

7. Décaleur à barilletLe décaleur à barillet(barrel shifter) décale un mot binaire den bits vers la gauche ou

vers la droite,d’un nombre variable de bits.Le sens du décalage est défini par une commandeR (pour right) et le nombre de bits du décalage est donné dans une commandeNB sur pbits (figure IV.19). C’est un circuit directement employé à l’exécution des instructions dedécalage et de rotation des processeurs, telles que les instructionssll etslr de CRAPSquenous verrons au chapitre suivant.Généralement,n = p2 : un décaleur à barillet sur 8 bits auraune valeur de décalage codée sur 3 bits ; un décaleur sur 32 bits aura une valeur de décalagesur 5 bits, etc.

Sur 8 bits par exemple, la figure IV.20 présente la table de vérité condensée d’un telcircuit, avec une valeur décalage sur 3 bits qui permet tous les décalages de 0 à 7 dans le sensdroit (R = 1) comme dans le sens gauche (R = 0).

Un tel circuit est difficile à concevoir directement ; par ailleurs, si on voulait le réalisersous forme d’un seul étage de propagation- ce qui est possible en théorie - les équationsseraient complexes, et ce d’autant plus que les valeurs den etp seraient grandes.

À l’inverse, une conception modulaire et récursive est possible de façon très simple, sion procède par étage, avec des décalages par puissances de 2 successives.Cette organisationgénérale est dite dedécalage à barillet, et elle est montrée figure IV.21 pour un décaleur 8

7. Décaleur à barillet 109

Figure IV.19. Interface général d’un décaleur à barillet.Le mot de n bits est décalé à droite(resp.gauche) si R = 1 (resp.0),d’un nombre de bits NB.Les bits qui sortent sont perdus,etles bits entrants sont des 0.

R nb entrées sorties* 0 0 0 e7 e6 e5 e4 e3 e2 e1 e0 e7 e6 e5 e4 e3 e2 e1 e00 0 0 1 e7 e6 e5 e4 e3 e2 e1 e0 e6 e5 e4 e3 e2 e1 e0 0

0 0 1 0 e7 e6 e5 e4 e3 e2 e1 e0 e5 e4 e3 e2 e1 e0 0 0

0 0 1 1 e7 e6 e5 e4 e3 e2 e1 e0 e4 e3 e2 e1 e0 0 0 0

0 1 0 0 e7 e6 e5 e4 e3 e2 e1 e0 e3 e2 e1 e0 0 0 0 0

0 1 0 1 e7 e6 e5 e4 e3 e2 e1 e0 e2 e1 e0 0 0 0 0 0

0 1 1 0 e7 e6 e5 e4 e3 e2 e1 e0 e1 e0 0 0 0 0 0 0

0 1 1 1 e7 e6 e5 e4 e3 e2 e1 e0 e0 0 0 0 0 0 0 0

1 0 0 1 e7 e6 e5 e4 e3 e2 e1 e0 0 e7 e6 e5 e4 e3 e2 e11 0 1 0 e7 e6 e5 e4 e3 e2 e1 e0 0 0 e7 e6 e5 e4 e3 e21 0 1 1 e7 e6 e5 e4 e3 e2 e1 e0 0 0 0 e7 e6 e5 e4 e31 1 0 0 e7 e6 e5 e4 e3 e2 e1 e0 0 0 0 0 e7 e6 e5 e41 1 0 1 e7 e6 e5 e4 e3 e2 e1 e0 0 0 0 0 0 e7 e6 e51 1 1 0 e7 e6 e5 e4 e3 e2 e1 e0 0 0 0 0 0 0 e7 e61 1 1 1 e7 e6 e5 e4 e3 e2 e1 e0 0 0 0 0 0 0 0 e7

Figure IV.20. Table de vérité condensée d’un décaleur à barillet sur 8 bits.

bits.

Tous les décaleurs ont leurs lignesR reliées ensemble, et donc opèrent dans le mêmesens. Ils sont tous équipés d’une ligne CS, et un décalage n’est effectué que siCS = 1.Ils effectuent chacun un nombre de décalages fixe, 4, 2 ou 1. Leur organisation en barilletpermet d’effectuer toutes les valeurs de décalage entre 0 et 7. Le premier niveau effectue undécalage de 4 bits ou non, selon quenb[2] = 1ou non. Le second niveau effectue ou non undécalage de 2 bits, selon la valeur denb[1]. Le dernier niveau effectue un décalage de 1 bit,selon la valeur denb[0].

Par exemple sinb= 101et siR= 0, le premier niveau va décaler de 4 bits vers la gauche(sa ligne CS est à 1), transformantE = (e7,e6,e5,e4,e3,e2,e1,e0) en(e3,e2,e1,e0, 0, 0, 0, 0). Lesecond niveau va laisser passer ce vecteur sans le transformer.Le niveau du bas va effectuerun décalage de 1, transformant le vecteur en(e2,e1,e0, 0, 0, 0, 0, 0). Au total, c’est donc bien4 + 1 = 5 décalages à gauche qui ont été effectués.

Bien sûr, une telle organisation est généralisable à un nombre quelconque de bits. Un


Figure IV.21. Organisation en 3 niveaux (barillets) d’un décaleur 8 bits. Chaque niveaudécale dans un sens ou un autre d’un nombre de positions égal à une puissance de deux, sisa ligne CS est à 1.Leurs combinaisons permettent toutes les valeurs de décalage.

décaleur 32 bits serait constitué de 5 étages, formés de décaleurs fixes de 16, 8, 4, 2 et 1bits.L’accroissement en complexité et en temps de propagation augmente donc en log(n), ce quiest très satisfaisant.

Il nous reste seulement à résoudre le problème de la fabrication des décaleurs sur unnombre de positions fixes. Ce sont des circuits combinatoires simples ; voici par exemple lecode SHDL d’un décaleur 2 bits :

module shift2(r,cs,e7,e6,e5,e4,e3,e2,e1,e0 :s7,s6,s5,s4,s3,s2,s1,s0)s7=e7*/cs+cs*/r*e5 ;s6=e6*/cs+cs*/r*e4 ;s5=e5*/cs+cs*/r*e3+cs*r*e7 ;s4=e4*/cs+cs*/r*e2+cs*r*e6 ;s3=e3*/cs+cs*/r*e1+cs*r*e5 ;s2=e2*/cs+cs*/r*e0+cs*r*e4 ;s1=e1*/cs+cs*r*e3 ;s0=e0*/cs+cs*r*e2 ;end module

Les termes en/cs recopient l’entrée sur la sortie de même rang, et il n’y a donc pas dedécalage. Les termes encs*/r gèrent le décalage à gauche de 2 positions, et les termes encs*r gèrent le décalage à droite de 2 positions.

Finalement, le code SHDL complet d’un décaleur à barillet sur 8 bits est donnéfigure IV.22.

7. Décaleur à barillet 111

;; Décaleur à barillet 8 bits.;; r = sens décalage (1=droite); amplitude = nb2..0module barrelshifter8(r,nb2,nb1,nb0,e7,e6,e5,e4,e2,e1,e0:s7,s6,s5,s4,s3,s2,s1,s0)shift4(r,nb2,e7,e6,e5,e4,e3,e2,e1,e0:s7,x6,x5,x4,x3,x2,x1,x0);shift2(r,nb1,x7,x6,x5,x4,x3,x2,x1,x0:y7,y6,y5,y4,y3,y2,y1,y0);shift1(r,nb0,y7,y6,y5,y4,y3,y2,y1,y0:s7,s6,s5,s4,s3,s2,s1,s0);end module

;; Décale de 4 bits si cs=1, laisse inchangé sinon. r = sens de décalage (1=droite)module shift4(r,cs,e7,e6,e5,e4,e3,e2,e1,e0:s7,s6,s5,s4,s3,s2,s1,s0)s7=e7*/cs+cs*/r*e3 ;s6=e6*/cs+cs*/r*e2 ;s5=e5*/cs+cs*/r*e1 ;s4=e4*/cs+cs*/r*e0 ;s3=e3*/cs+cs*r*e7 ;s2=e2*/cs+cs*r*e6 ;s1=e1*/cs+cs*r*e5 ;s0=e0*/cs+cs*r*e4 ;end module

;; Décale de 2 bits si cs=1, laisse inchangé sinon. r = sens de décalage (1=droite)module shift2(r,cs,e7,e6,e5,e4,e3,e2,e1,e0:s7,s6,s5,s4,s3,s2,s1,s0)s7=e7*/cs+cs*/r*e5 ;s6=e6*/cs+cs*/r*e4 ;s5=e5*/cs+cs*/r*e3+cs*r*e7 ;s4=e4*/cs+cs*/r*e2+cs*r*e6 ;s3=e3*/cs+cs*/r*e1+cs*r*e5 ;s2=e2*/cs+cs*/r*e0+cs*r*e4 ;s1=e1*/cs+cs*r*e3 ;s0=e0*/cs+cs*r*e2 ;end module

;; Décale de 1 bit si cs=1, laisse inchangé sinon. r = sens de décalage (1=droite)module shift1(r,cs,e7,e6,e5,e4,e3,e2,e1,e0:s7,s6,s5,s4,s3,s2,s1,s0)s7=e7*/cs+cs*/r*e6 ;s6=e6*/cs+cs*/r*e5+cs*r*e7 ;s5=e5*/cs+cs*/r*e4+cs*r*e6 ;s4=e4*/cs+cs*/r*e3+cs*r*e5 ;s3=e3*/cs+cs*/r*e2+cs*r*e4 ;s2=e2*/cs+cs*/r*e1+cs*r*e3 ;s1=e1*/cs+cs*/r*e0+cs*r*e2 ;s0=e0*/cs+cs*r*e1 ;end module

Figure IV.22. Code SHDL complet d’un décaleur à barillet sur 8 bits.Chaque décaleur fixede 4,2 et 1 bits est présent sous forme de module séparé.

8. L’unité arithmétique et logique

8.1. Fonction d’une UAL

Dans un processeur, on regroupe souvent dans la même unité fonctionnelle lesdifférentsopérateursd’arithmétique entière (additionneurs,multiplieurs,etc.), les opérateursde logique booléenne (AND, OR, etc.) et les opérations de décalage et de rotation de bits.On appelle un tel moduleunité arithmétiqueet logique(UAL),et elle a la forme de la figureIV.23 suivante :

Les opérations que réalise l’UAL ont une arité de 2, et parfois 1. Les opérandes sontprésentés sur deux bus A et B de même largeur ; on indique sur F le code d’une opération àeffectuer (par exemple, une addition), et le résultat est disponible sur le bus de sortie F(A,B)après un certain temps de propagation des calculs. Lesflagsou indicateurs, notés souvent


F N,Z,V,C

UAL

A B

F(A,B)

Figure IV.23. Unité arithmétique et logique.F code l’opération à effectuer ; les opérandessont A et B et le résultat est S. Les indicateurs N,Z,V,C donnent des informations sur lanature du résultat.

N, Z, V, C donnent des informations sur le résultat de l’opération. N indique que le résultatest négatif, Z indique qu’il est nul, V indique un débordement et C indique la présenced’une retenue.

Il faut noter que l’UAL est un opérateur combinatoire : il n’a pas d’horloge,et le résultatd’une opération n’est disponible qu’après un temps variable (mais borné).

8.2. UAL par tranches de 1 bit

Assez souvent, une UAL den bits est formée de l’association den UAL de 1 bit,appeléestranches de bit(bit slice). Considérons par exemple les schémas des figures IV.24et IV.25 d’une UAL 1 bit qui effectue l’une des 4 opérations : ET logique, OU logique,complément ou addition sur les deux entréesA etB.

F1 F0

0

10

0

0

11

1 NOT A

ADD

OR

AND

CIN

B

SCOUT

F1,F0

UAL1 bit

A2

Figure IV.24. Unité arithmétique et logique de 1 bit.

CIN et COUT ne sont utilisés que pour l’opération d’addition.CIN est une retenueentrante etCOUT une retenue sortante : lorsque l’addition est sélectionnée (F1F0=11),c’est la sommeA + B + CIN qui est effectuée, et le résultat est disponible surS,avec uneéventuelle retenue sortante placée surCOUT.On voit que l’équation du résultatS est un

8. L’unité arithmétique et logique 113

MAJ3

S1

0

2

3

F1,F0

AB

CIN

COUT

// multiplexeur 4 vers 1MODULE MUX4TO1(E[3..0],C[1..0] :S)S=/C1*/C0*E0+/C1*C0*E1+C1*/C0*E2*C1*C0*E3 ;END MODULE

// majorité à 3 entréesMODULE MAJ3(X,Y,Z :MAJ)MAJ=X*Y+X*Z+Y*Z;END MODULE

MODULE UAL1BIT(F1,F0,A,B,CIN :S, COUT)MUX4TO1(E3,E2,E1,E0,F1,F0 :S);E0=A*B ;E1=A+B ;E2=/A ;E3=/A*/B*CIN+/A*B*/CIN+A*/B*/CIN+A*B*CIN ;MAJ3(A,B,CIN :COUT)END MODULE

Figure IV.25. Structure interne et description SHDL de l’UAL 1 bit.

multiplexeur,commandé par les quatre combinaisonsdeF1etF0.Les quatre termes associésà l’addition représentent le ou exclusif entreA,BetCIN.

Les termes correspondants aux autres opérations parlentd’eux-mêmes ; on voit queseule l’opération de complémentation est unaire.

La figure IV.26 montre l’assemblage de 4 tranches d’UAL 1bit, pour former une UALde 4 bits. Le module traitant les bits d’indice 0 a une retenue entrante forcée à 0 ; ensuitela retenue sortante d’un module devient la retenue entrante du module suivant, jusqu’à laretenue finaleCARRY.

CIN

B

SCOUT

F1,F0

UAL1 bit

A

CIN

B

SCOUT

F1,F0

UAL1 bit

A

CIN

B

SCOUT

F1,F0

UAL1 bit

A2

S0

0

F1,F0

B0 B1 A2 B2 A3

S1 S2 S3

B3A0 A1

CIN

B

SCOUT

F1,F0

UAL1 bit

A

COUT

MODULE UAL4BIT(F1,F0,A3..A0,B3..B0 :S3..S0,CARRY)UAL1BIT(F1,F0,A0,B0,0:S0,C0);UAL1BIT(F1,F0,A1,B1,C0:S1,C1);UAL1BIT(F1,F0,A2,B2,C1:S2,C2);UAL1BIT(F1,F0,A3,B3,C2:S3,CARRY);END MODULE

Figure IV.26. Unité arithmétique de 4 bits formée par assemblage de 4 modules d’UAL1 bit.

Bien sûr, cette technique a ses limites. Elle ne peut pas implémenter des fonctions quiopèrent globalement sur lesnbits, telles que les décalagesou les multiplicationset divisions.Par ailleurs, l’addition est particulièrement inefficace à cause de la propagation de la retenue,et en particulier si le nombren de modules est grand. Pourn = 32par exemple, le calcul


d’une addition prendra32 × p oùp est le temps de calcul de l’addition sur l’UAL 1 bit. Onpeut tout de même dans ce cas adopter la même approche avec de meilleurs résultats, avecdes blocs élémentaires de 4 bits par exemple, dans lesquels on aura optimisé le calcul dela retenue.

9. Circuit timer/PWM

Principe

Un circuittimer/PWMgénère un signal cyclique rectangulairedont les paramètressontprogrammables. Ces paramètres sont :

1 la période P, exprimée en nombre de cycles de l’horloge générale.

2 la durée D à l’intérieur de cette période où la sortie vaut 0, exprimée en nombrede cycles.

La figure IV.27 illustre la forme du signal recherché.

N

P

Figure IV.27. Signal périodique généré par un circuit timer/PWM.

Le terme PWM (Pulse Width Modulation : modulation en largeur d’impulsion) faitréférence à une technique utilisée fréquemment pour moduler l’énergie fournie à certainsdispositifs tels que des lampes, des moteurs à courant continu, etc. Plutôt que de leur fournirune tension variable, difficile à produire avec précision, on leur fournit un signal périodiquedont on fait varier le rapport cyclique entre les moments où la tension est maximale et ceux

où la tension est nulle (P − NP

sur la figure).La fréquence1P

doit être assez élevée pour éviter

les accoups ou les clignotements,mais pas trop élevée pour éviter d’éventuelseffets néfastes.Par exemple, les LEDs à haute luminosité qui équipent les feux de stop et arrière des voituresont leur luminosité commandée de cette manière.

Le circuit sera plutôt appelé ’timer’ si on n’exploite que les fronts montants oudescendants du signal de sortie, pour générer une interruption par exemple.

Organisation

Pour réaliser un timer/PWM surn bits, on utilise un compteurn bits et deuxcomparateursn bits, qui comparent en permanence la valeur du compteur aux deuxparamètresP etN (figure IV.28).

Le compteur dispose d’une remise à zéro synchrone (voir section 10.1), qui est activéedès que le compteur arrive à la valeur P. Ainsi il va compter 0, 1, …, P, c’est à dire avec unepériode de P+1 cycles d’horloge.

9. Circuit timer/PWM 115

Figure IV.28. Organisation d’un timer/PWM sur n bits.La valeur d’un compteur n bits estcomparée aux valeurs de N et P ; quand il atteint P il est remis à 0 ; quand il dépasse N lavaleur de la sortie m change.La bascule D finale prévient d’éventuels glitchs.

Durant cette période P+1, la valeur du compteur est comparée à la valeur de N, et lasortie m est le reflet de cette comparaison. La sortiem n’est pas directement le résultatcombinatoire de la comparaison,mais on le fait passer au travers d’une bascule D, pour deuxraisons :

1 il pourrait être affecté de glitchs dans certainessituations ;en le faisant passer au traversd’une bascule D on est certain d’avoir un signal parfaitement propre.

2 son timing est exactement aligné avec les fronts d’horloge, ce qui améliorela précision.

La figure IV.29 donne le code SHDL d’un tel circuit timer/PWM sur 4 bits.On réutiliseles circuits de comptage et de comparaison déjà décrits en SHDL aux sections 10.1et 8.9.

La périodep est égale àp3…p0 + 1en nombre de cycles de l’horlogeclk ; la valeurn3…n0 définit la valeurn. Le timing précis de ce module est défini par le chronogrammefigure IV.30.

10. RAMs et ROMs

10.1. Introduction

Cette section est consacrée aux circuits utilisés dans la mémoire centrale desordinateurs, qui contient les programmes et les données manipulés par les programmes.L’information y est stockée sous forme de mots de taille fixe, dont la largeur dépend del’architecture utilisée. Ces mots mémoire sont ordonnés et possèdent chacun uneadresse,sous forme d’un nombre. On peut donc voir une mémoire comme un ruban de casesnumérotées :


// période = p3..p0, m à 1 après n3..n0module pwm(rst,clk,en,p3..p0,n3..n0: m)cpt4(rst,clk,eq,en :c3..c0);cmp4(c3..c0,p3..p0 :sup,eq);cmp4(c3..c0,n3..n0 :supn,eqn);m:=dm ;m.clk=clk ;m.rst=rst ;dm=supn+eqn ;end module

// compteur 4 bits avec raz synchrone// utilise des bascules T avec raz sync.module cpt4(rst,clk,sclr,en :a,b,c,d)tclr(rst,clk,sclr,en :d);tclr(rst,clk,sclr,tc :c);tc=en*d ;tclr(rst,clk,sclr,tb :b);tb=en*c*d ;tclr(rst,clk,sclr,ta :a);ta=en*b*c*d ;end module

// comparateur 4 bits non signémodule cmp4(a3..a0,b3..b0 :sup3,eq)eq=eq3*eq2*eq1*eq0 ;sup3=a3*/b3+eq3*sup2 ;eq3=a3*b3+/a3*/b3 ;sup2=a2*/b2+eq2*sup1 ;eq2=a2*b2+/a2*/b2 ;sup1=a1*/b1+eq1*a0*/b0 ;eq1=a1*b1+/a1*/b1 ;eq0=a0*b0+/a0*/b0 ;end module

// bascule T avec raz synchronemodule tclr(rst,clk,sclr,t :q)q:=/t1*q+t1*/q ;q.clk=clk ;q.rst=rst ;t1=/sclr*t+sclr*q ;end module

Figure IV.29. Écriture SHDL d’un timer/PWM sur 4 bits.

50 1 2 3 4 0cpt

m

n3..n0 = 2

p = 6 (p3..p0 = 5)

Figure IV.30. Exemple de chronologie des signaux du timer/PWM sur 4 bits.

0 21 3 4 5 6 7 8

...

n−1n−2 ndonnéesadresses

…ou comme un tableau :

donnée= mem[adresse], adresse∈ [0, n].

De telles mémoires se classent en deux grands types, selon qu’elles sont en lecture seuleou enlecture-écriture : lesRAMs(Random Access Memory) peuvent être lues et écrites, etl’attribut randomindique que ces lectures-écritures peuvent se faire à des suites d’adressestotalement quelconques, par opposition à des mémoires de typeséquentiel(comme lesdisques durs) qui font des séries d’accès à des adresses consécutives.LesROMs(Read Only

10. RAMs et ROMs 117

Memory) sont fonctionnellement identiques aux RAMs, mais ne permettent que la lectureet pas l’écriture. Utilisées dans la mémoire centrale d’un ordinateur, les RAMs pourrontstocker les programmes et les données, alors que les ROMs vont seulement stocker desprogrammes invariables, comme par exemple le programme exécuté au démarrage dela machine, et stocké dans la ROM dite de BIOS. Dans certains ordinateurs plus anciens,tout le système d’exploitation était stocké en ROM, ce qui permettait d’avoir un systèmeincorruptible et au démarrage rapide.

Une RAM peut êtrestatiqueoudynamique.Chaque bit mémoire d’une RAM statique(SRAM) est constitué d’une bascule, et conserve son état tant qu’elle est alimentée. Al’inverse, chaque bit d’une RAM dynamique (DRAM) est composé d’une capacité, qui doitêtre rafraîchie périodiquement par une électronique séparée. Les RAMs statiques ont untaux d’intégration plus faible que les RAM dynamiques, puisqu’un bit mémoire nécessite 6transistors dans un cas, et une capacité plus un transistor dans l’autre.

Une RAM peut être synchrone ou asynchrone, une RAM synchrone étant en faitune RAM asynchrone à laquelle on a ajouté une machine à états finis synchrone qui placeles commandes de lecture et d’écriture dans un pipeline, afin de permettre d’accepter unenouvelle commande avant que la précédente n’ait été complétée.

Les barrettes de RAM de nos ordinateurs personnels sont des SDRAM, c’est à diredes RAM dynamiques synchrones, fonctionnant à des fréquences de 200MHz et plus. Ellessont souvent de type DDR (double data rate), quand les fronts montants et descendants del’horloge sont exploités pour les changements d’état.

Dans beaucoup d’autres appareils (assistants personnels, consoles de jeux, etc.), laRAM est de type statique asynchrone (SRAM), sous la forme de circuits intégrés.

Les ROMs existent également dans un grand nombre de types différents,principalement selon la façon dont on peut programmer leur contenu (invariable, pardéfinition). Il y a d’abord les ROMs programmées par masque à l’usine ; elles sont produitesen grand nombre avec un faible coût à l’unité, mais leur contenu ne peut jamais être mis àjour ultérieurement.

Les PROMs (Programmable Rom) sont programmables par un appareil spécial,qui généralement détruit par un courant fort une liaison interne correspondant à unbit. Les EPROMs (Erasable PROM) fonctionnent de la même façon, mais possèdentune fenêtre transparente et peuvent être effacées par une exposition d’une vingtainede minutes aux rayons ultraviolets. Elles sont maintenant souvent remplacées par desEEPROMs (Electrically EPROM), reprogrammables électriquement. LesmémoiresFlash sont également une forme de mémoires effaçables électriquement, mais on réservegénéralement le terme EEPROM aux mémoires capables d’effacer à l’échelle du mot, etle terme ’mémoires Flash’ à celles qui effacent à l’échelle de blocs. Dans les deux cas, letemps d’effacement est long par rapport au temps de lecture, et elles ne peuvent pas êtreconsidérées comme une forme spéciale de RAM. On trouve de la mémoire EEPROMet flash dans les assistants personnels, dans les sticks mémoire sur ports USB, pour lestockage du firmware de nombreux appareils (BIOS d’ordinateurs, lecteurs de DVD, tunerssatellites, etc.)

10.2. Mode d’emploi des mémoires statiques asynchrones

Les mémoires statiques ont généralement une organisation et un mode d’emploi


spécifique. On a vu à la section précédente que chaque bit d’une telle mémoire étaitstocké dans une bascule, ce qui conduit pour les formes les plus simples à séparer lesdonnées à écrire des données lues, de la même façon que sont séparées l’entrée et la sortied’une bascule.

La figure IV.31montre l’interface d’un tel circuit.

DOUT

ADR

DIN

W

CE

n n

m

Figure IV.31. Interface d’un boîtier de RAM statique asynchrone dem2 mots de n bits,avecséparation des données lues et des données à écrire.

Le mode d’emploi de ce circuit est le suivant :

Lecture d’un mot mémoire

1. activer la ligneCE (Chip Enable), placer l’adresse du mot sur lesm lignes d’adresseADRet garder inactive la ligneW (write).

2. après un certain temps appelétemps d’accès en lecture, le mot mémoire (de largeurn)placé à cette adresse est disponible sur les lignesDOUT (Data Out).

Écriture d’un mot mémoire

1. activer la ligneCE (Chip Enable), placer l’adresse du mot sur lesm lignes d’adresseADR, placer la donnée à écrire sur lesn lignes DIN (DataIn) et activer la ligneW (write).

2. après un certain temps appelétemps d’écriture, le mot (de largeurn) est écrit enmémoire, et pourra être lu ultérieurement.

Le temps d’écriture est généralement voisin du temps d’accès en lecture ; ces temps varientd’une dizaine de nanosecondes pour les mémoires statiques les plus rapides à une centainede nanosecondes.

En pratique, les boîtiers disponibles mettent en commun les lignesDIN et DOUT,defaçon à minimiser le nombre de broches, et à faciliter l’interconnexion de plusieurs boîtiers.De tels circuits ont l’interface et la structure suivante :

Une entrée supplémentaireOE (Output Enable) est nécessaire, qui fonctionne de lafaçon décrite page 98. Lors de l’écriture d’un mot mémoire, la ligneOE doit être inactive,et la donnée à écrire peut être placée surDATA sans risque decourt-circuit. Lors d’unelecture en mémoire, la ligneOE doit être activée après le temps d’accès en lecture pourque la donnée lue soit disponible surDATA.On verra plus loin comment interconnecter cescircuits ; les précautions déjà évoquées doivent être respectées ici, et en particulier le risque


DOUT

ADR

DIN

W

CE

n n

mADR DATA

nm

W

CE

OE CE

W

OE

ADR

DATA

Figure IV.32. Interface d’un boîtier de RAM statique asynchrone dem2 mots de n bits,avecdonnées lues et écrites communes.

qu’il y a d’avoir à la foisOE active et une donnée présente en entrée deDATA,qui peutconduire à la destruction du circuit.

10.3. Structure interne d’une mémoire statique asynchrone

Une mémoire statique dem2 mots den bits est réalisée sous forme d’une matrice dem2 colonnes etn lignes de bascules D. Pour montrer un exemple facilement descriptible en

langage SHDL,on peut la voir également comme une ligne dem2 registresdenbits, tels qu’ilont été décrits au chapitre précédent. La figure IV.33 montre l’implémentation d’une RAMde 4 mots de 8 bits.

CE

OE Q

DCLK

W

A1 A0

CE

OE Q

DCLK

W

A1 A0

CE

OE Q

DCLK

W

CE

OE Q

DCLK

W

A1 A0A1 A0

8

DATA

WCE

OE

mot #0 mot #1mot #2 mot #3

MODULE RAM4X8(A[1..0],DIN[7..0],CE,W,OE: DOUT[7..0])SEL0 = /A0*/A1 ;SEL1 = /A0*A1 ;SEL2 = A0*/A1 ;SEL3 = A0*A1 ;CLK[3..0] = SEL[3..0] * W ;OEG = OE * CE * /W ;OE_R[3..0] = OEG * SEL[3..0] ;REG8(DIN[7..0],CLK0,SEL0,OE_R0:DOUT[7..0]);REG8(DIN[7..0],CLK1,SEL1,OE_R1:DOUT[7..0]);REG8(DIN[7..0],CLK2,SEL2,OE_R2:DOUT[7..0]);REG8(DIN[7..0],CLK3,SEL3,OE_R3:DOUT[7..0]);END MODULE

Figure IV.33. Implémentation en SHDL d’une RAM statique asynchrone de 4 mots de8 bits.


Les sorties des registres sont reliées entre elles, mais il n’y a pas de risque decourt-circuit car leurs lignesOE sont indirectement reliées à quatre termesSEL3..SEL0mutuellement exclusifs. Lorsqu’une adressei est présentée surA1,A0, seul le registred’indicei va avoir sa ligneCEactivée, c’est à dire que lui seul va être sélectionné.S’il s’agitd’une lecture (W = 0), il va fournir son contenu sur sa sortie siOE = 1. S’il s’agit d’uneécriture, le front montant surW va créer un front montant sur l’entréeCLK de la bascule, etdonc écrire la donnée placée surDATAdans le registre.

En fait, chacun de ces registres doit être vu comme une colonne de plusieurs basculesD, ce qui donne en réalité l’organisation matricielle évoquée en début de section, qui dansl’exemple comporterait 8 lignes et 4 colonnes. Ce type d’organisation est idéal pour uneréalisation industrielle ; ajouter une ligne d’adresse revient à multiplier par deux le nombrede colonnes, tout en gardant la même structure générale. C’est ainsi que, la technologies’améliorant, la taille des puces mémoire continue de croître à peut près d’un facteur 2 tousles 18 mois, c’est à dire à la vitesse prévue par la loi de Moore.

10.4. Mode d’emploi des mémoires dynamiques asynchrones

Les mémoires dynamiques ont généralement une organisation légèrement différentedes mémoires statiques, même si cette différence n’est pas à attribuer à leur nature statiqueou dynamique. Leur interface est celui de la figure IV.34.

DOUTn

DIN

WCAS

RAS

ADRm

n

Figure IV.34. Interface d’un boîtier de RAM dynamique asynchrone de2m2 mots de n bits.

On remarque d’abord qu’il n’y a pas de ligne de validation (CE ou CS),et que deuxnouvelles lignesRASet CASsont présentes. La légende de la figure parle de2m2 mots den bits, alors qu’on ne voit quem lignes d’adresses. On va voir qu’en fait, cesm lignes sontmultiplexées, et qu’on y présente successivement un numéro de ligne surm bits, puis unnuméro de colonne surm bits, pour accéder à une cellule mémoire dans une matrice de

m2 x m2 = 2m2 cellules mémoire. La présentation des numéros de ligne et de colonne estsynchronisée par les signauxRASetCAS.

RASsignifiesélection de ligne d’adresse(Row Address Select);CASsignifiesélectionde colonne d’adresse(Column AddressSelection).Le boîtier est inactif tant queRASetCASsont inactifs. Les chronologies de lecture et d’écriture sont montrées figures IV.35 et IV.36.

Pour une lecture ou une écriture, on place d’abord un numéro de ligne surADR,quiest obtenu en prenant la moitié de l’adresse complète, généralement les poids forts et onactive ensuite la ligneRAS(front descendant). On place ensuite surADR l’autre moitiéde l’adresse complète, généralement les poids faibles, et on active ensuite la ligneCAS(front descendant). En cas de lecture (W = 1) la donnée sera disponible surDOUT ;en cas


��

donnéelue

��

��ADR

RAS

CAS

DOUT

W

numéro ligne numéro colonne

Figure IV.35. Chronogramme de lecture dans une mémoire dynamique.

��

��

��ADR

RAS

CAS

DIN

W

donnéeà écrire

numéro ligne numéro colonne

Figure IV.36. Chronogramme d’écriture dans une mémoire dynamique.

d’écriture il faudra placer la donnée surDIN.

Un cycle spécifique de rafraîchissement existe également, qui opère sur des lignesentières de cellules. Chaque ligne doit être rafraîchie typiquement toutes les 5ms, et celan’est pas fait automatiquement par le circuit : c’est la logique de commande qui est autourqui doit s’en charger.

Un tel mode de fonctionnement correspond à la structure interne de la figure IV.37.

On voit que, lorsque le numéro de ligne est présenté surADRet qu’un front descendantest appliqué surRAS,ce numéro de ligne est stocké dans le registre de ligne. Sa valeur estdécodée et sélectionne une desm2 lignes de la matrice.De la même façon, lorsque le numérode colonne est présenté surADRet qu’un front descendant est appliqué surCAS,ce numéroest stocké dans le registre de colonne, dont la valeur est également décodée et sélectionneune des colonnes.Une des cellules mémoire est ainsi sélectionnée.En cas de lecture (W = 1)la donnée sera disponible surDOUT ;en cas d’écriture il faudra placer la donnée surDIN.

La mise en oeuvre de ces circuits est plus complexe que celle des mémoiresasynchrones, puisqu’on ne peut plus présenter l’adresse entière directement. On est obligéde la présenter en deux fois, généralement poids forts d’abord (numéro de ligne) et poidsfaibles ensuite (numéro de colonne), ce qui peut être fait à l’aide d’un multiplexeur.


n n

W DIN DOUT

amplificateurs

m

m

mADR

CAS

RAS

registre + décodeur colonne

regi

stre

+ d

écod

eur

ligne

Figure IV.37. Structure interne d’une mémoire dynamique de2m2 mots de n bits.


11.1. Exercice 1 : association de décodeurs

Énoncé

Associer deux décodeurs 2 vers 4 avec entrée de validation, pour former un décodeur3 vers 8 avec entrée de validation. On pourra ajouter quelques composants combinatoiressimples si nécessaire.

Solution

Posons le problème en termes plus visibles. On cherche en fait à compléter la figuresuivante :


S0

E0

EN

S1

S2

S3E1

S0

E0

EN

S1

S2

S3E1 S3

S2

S1

S0

S4

S5

S6

S7

EN

E2

E1

E0

#2

#1

Il est clair que les sorties du décodeur final seront l’union des sorties des deuxdécodeurs #1et #2. Par ailleurs, lorsqueEN = 0, aucun des deux décodeurs ne doit être actif,ce qui peut être garanti avec une porte ET sur leur entréeEN.Cela donne le schéma partielsuivant :

E2

E1

E0

S7

S6

S4

S3

S2

S1

S0S0

E0

EN

S1

S2

S3E1

S0

E0

EN

S1

S2

S3E1

#1

EN

#2

S5

Considérons maintenant le statut deE2 : lorsqu’il vaut 0, c’est que la valeur présentesur le vecteurE2..E0est comprise entre 0 et 3, et c’est une sortie du décodeur #2 qui doitêtre activée ; lorsqu’il vaut 1, c’est que la valeur deE2..E0est comprise entre 4 et 7, et c’estune sortie du décodeur #1qui doit être activée.Par ailleurs,que ce soit pour le décodeur #1ou#2, il est facile de voir que le numéro de la sortie à activer a pour indice la valeur deE1,E0.Finalement, la solution est visible sur le schéma suivant :


E2

E1

E0

S7

S6

S4

S3

S2

S1

S0S0

E0

EN

S1

S2

S3E1

S0

E0

EN

S1

S2

S3E1

#1

EN

#2

S5

Bien sûr, puisque le module construit a lui même une entrée de validation, il peutêtre associé à un autre pour former un décodeur 4 vers 16, etc. On a ici un bel exemple decascadabilité (ou récursivité matérielle).

11.2. Exercice 2 : fonctions combinatoires booléennes réalisées avec desdécodeurs, multiplexeurs ou mémoires

Énoncé

Réaliser la fonction majorité à trois entrées avec : un décodeur 3 vers 8, ou unmultiplexeur 8 vers 1, ou une ROM 8× 1.

Solution

Le circuit qu’on cherche à implémenter possède trois entrées et une sortie. On rappelleque la fonction majorité à trois entrées vaut 1 si et seulement si au moins deux de sesentrées (sur trois) sont à 1 ; elle est utilisée notamment pour le calcul de la retenue dansles additionneurs. D’un point de vue algébrique, si on appelleE2,E1,E0les entrées, les 4minterms souhaités dans le résultat sont :E2 ∗ E1 ∗ E0,−E2 ∗ E1 ∗ E0, E2 ∗ −

E1 ∗ E0, E2 ∗E1 ∗ −E0.

Avec un décodeur 3 vers 8, il suffit de relier les trois entrées aux entrées du décodeur.Chacune des 8 sorties est associée à chacun des 8 minterms possibles pour une fonctioncombinatoire à 3 entrées. On relie ensuite par unOU les 4 sorties correspondant aux 4minterms désirés.

E1E0

E2

000001010011100101110111

Figure IV.38. Fonction majorité à 3 entrées réalisée avec un décodeur 3 vers 8.


Avec un multiplexeur 8 vers 1 (figure IV.39), on sait que les entrées doivent être reliéesaux lignes de commande, qui sont bien au nombre de 3 pour un multiplexeur 8 vers 1.Chacune des 8 entrées du multiplexeur correspond à un des 8 minterms possibles,et on forceun 1 sur chaque entrée associée à un minterm qu’on souhaite inclure.

0

1

3

4

5

6

7

2

0

1

1

1

1

0

0

0

E2..E0

MAJ3(E2..E0)

Figure IV.39. Fonction majorité à 3 entrées réalisée avec un multiplexeur 8 vers 1.On forceun 1 sur chaque entrée associée à un minterm qu’on souhaite inclure dans la fonction. Levecteur E2..E0 sert à sélectionner cette entrée.

Avec une ROM, on relie les trois entrées aux 3 lignes d’adresse de la mémoire (figureIV.40).Elle en a bien trois, puisque l’énoncé nous parle d’une mémoire de 8 mots, soit32 .Onsait qu’alors la ROM peut implémenter n’importe quelle fonction combinatoire à 3 entrées,pourvu que les mots mémoire qu’elle contient aient les bonnes valeurs. En l’occurrence,chaque vecteur d’entrée est vu comme une adresse, et son contenu (ici un seul bit) doit êtrela valeur attendue pour la fonction. On a indiqué sur le schéma le contenu de la ROM pourchacune des adresses.

000 : 0001 : 0010 : 0011 : 1100 : 0101 : 1110 : 1111 : 1

E2E1E0

ADR

EN

OE

1

1

DATA

Figure IV.40. Fonction majorité à 3 entrées réalisée avec une ROM 8 x 1.Chaque adressecorrespond à un minterm, et le contenu de la ROM à cette adresse est la valeur attenduepour le fonction représentée.

On notera que les entrées de validationEN et de sortieOE sont forcées à 1, pour quela mémoire soit active en permanence.


11.3. Exercice 3 : Équations d’un encodeur de priorité à 8 entrées

Énoncé

Écrire sous forme d’une somme de termes les plus simples possible les équations dessorties d’un encodeur de priorité à 8 entrées.

Solution

On se reportera à la page 106 pour l’usage d’un encodeur de priorité. On rappelle latable de vérité d’un tel encodeur :

E7 E6 E5 E4 E3 E2 E1 E0 NUM2..0 ACT

1 * * * * * * * 1 1 1 1

0 1 * * * * * * 1 1 0 1

0 0 1 * * * * * 1 0 1 1

0 0 0 1 * * * * 1 0 0 1

0 0 0 0 1 * * * 0 1 1 1

0 0 0 0 0 1 * * 0 1 0 1

0 0 0 0 0 0 1 * 0 0 1 1

0 0 0 0 0 0 0 1 0 0 0 1

0 0 0 0 0 0 0 0 0 0 0 0

NUM2 vaut 1 dès lors qu’une des entrées E4, E5, E6 ou E7 est active :NUM2=E7+E6+E5+E4.

NUM1vaut 1 pour deux groupes de lignes dans la table de vérité. On a :

NUM1 = E7 + /E7*E6 + /E7*/E6*/E5*/E4*E3 + /E7*/E6*/E5*/E4*/E3*E2

D’après la loi d’absorption, la variable E7 disparaît de plusieurs termes :

NUM1 = E7 + E6 + /E6*/E5*/E4*E3 + /E6*/E5*/E4*/E3*E2

E7 ayant disparu, la loi d’absorption s’applique pour E6, puis sur E3 :

NUM1 = E7 + E6 + /E5*/E4*E3 + /E5*/E4*/E3*E2

NUM1 = E7 + E6 + /E5*/E4*E3 + /E5*/E4*E2

On procède de façon analogue pour la simplification de NUM0 :

NUM0 = E7 + /E7*/E6*E5 + /E7*/E6*/E5*/E4*E3 + /E7*/E6*/E5*/E4*/E3*/E2*E1

NUM0 = E7 + /E6*E5 + /E6*/E5*/E4*E3 + /E6*/E5*/E4*/E3*/E2*E1

NUM0 = E7 + /E6*E5 + /E6*/E4*E3 + /E6*/E4*/E3*/E2*E1

NUM0 = E7 + /E6*E5 + /E6*/E4*E3 + /E6*/E4*/E2*E1

On retrouve ainsi les équations vues plus haut à la figure IV.15.


11.4. Exercice 4 : association de mémoires statiques asynchrones

Énoncé

Associer deux mémoires asynchrones den2 mots dem bits pour former une mémoirede n2 mots de2mbits, puis une mémoire den+12 mots dembits.

Solution

premièreassociation

Il faut d’abord remarquer que dans les deux cas, la mémoire obtenue a bien un nombretotal de bits mémoire égal à la somme des bits mémoire des deux parties. Chaque boîtierinitial possèdem × n2 bits mémoire, et leur somme fait doncm × n+12 . Dans la premièreassociation, on auran2 mots de2m bits soit2 × m × n2 = m × n+12 ; dans la deuxième onaura aussi lesm × n+12 bits.

Pour former une mémoire den2 mots de2m bits, il faut mettre essentiellement toutesles lignes des deux boîtiers en commun, à l’exception des lignes de données qu’il faut mettreen parallèle. Cela donne le circuit de la figure IV.41.

RAM

CS

OE

W

2 mots

de m bits

n

m

n

CS

OE

2 x m

RAM

CS

OE

R/W

2 mots

de m bits

n

m

n

DataData

Data

W

ADR ADR

ADR

Figure IV.41. Association de mémoires asynchrones, avec doublement de la largeurdes données.

Lorsqu’un accès mémoire (lecture ou écriture) est effectué, les deux boîtiers sontsélectionnés en même temps à la même adresse, et fournissent ou acceptent simultanémentles deux moitiés de largeurmde la donnée globale de largeur2m.

deuxièmeassociation

Pour former une mémoire den+12 mots dem bits, il va falloir mettre en commun lesm lignes de données, et donc il ne va plus être possible de sélectionner les deux boîtiers enmême temps,sous peine decourt-circuit.Pour une moitié des adresses, il faudra sélectionner


le premier boîtier,et l’autre pour l’autre moitié des adresses.La manière la plus simple est icid’utiliser un des bits de l’adresse den + 1bits, par exemple adr[n], pour faire cette sélection(figure IV.42).

de m bits

2 motsn

RAM

2 motsde m bits

n

RAM

CS

addr[n]

addr[n−1..0]n+1

ADR

1:2

0

1

CS

OE

W

OE

CS

WW

OE

Data

ADRn

n

Datam

m mData

ADR

CS

Figure IV.42. Association de mémoires asynchrones, avec doublement du nombred’adresses.

Ce bit est mis en entrée d’un décodeur 1vers 2 : s’il vaut 0, c’est le boîtier mémoire duhaut qui est sélectionné ; s’il vaut 1 c’est le boîtier du bas. Tout cela suppose que le signalCSglobal soit actif, car s’il ne l’est pas, le décodeur ne sélectionne aucun boîtier Le signalOEsuit un traitement particulier :pour chaque boîtier, il ne doit être actif que si leOEglobalest actif, etsi le boîtier est sélectionné (CS = 1). On est alors assuré qu’aucuncourt-circuitn’est possible, puisque lesOE des deux boîtiers sont alors mutuellement exclusifs.

Dans cette configuration, l’espace des adresses de l’ensemble est[ 0 , n+12 − 1] ;la première moitié[0, n2 − 1] correspond au premier boîtier ; la seconden,[2 n+12 − 1]correspond au second. Si on avait utilisé le bit de poids faible de l’adresse globale commeentrée du décodeur, la distribution des adresses entre les boîtiers aurait été différente : l’unaurait contenu les adresses paires, et l’autre les adresses impaires.

Chapitre V

Programmation du processeur 32 bitsCRAPS/SPARC

Le langage machine(et sa forme équivalente symbolique diteassembleur) est exécutédirectement par le processeur,et il est à ce titre l’intermédiaire obligé de tous les composantslogiciels d’un ordinateur. Même s’il est vrai que peu de gens programment directement enassembleur, son étude est éclairante pour la compréhension de la relation entre logiciel etmatériel. Le but de ce présent chapitre est d’initier à la programmation en assembleur duprocesseur CRAPS au travers de programmes de différentes natures, de façon à ensuitemieux comprendre son architecture et son fonctionnement.

1. Le langage machine, à la frontière entre logiciel et matériel

Langage machine et ISA

Les instructions qu’exécute un processeur sont écrites dans un langage appelélangagemachine, et sont formées de codes écrits dans des mots mémoires consécutifs ; on appelleISA (Instruction Set Architecture) ce langage et son organisation. L’informatique utilise ungrand nombre de langages différents : des langages de programmation tels que C ou Javapour les programmeurs, des langages interprétés tels que les langages de macro des suitesbureautiques, des langages de gestion de bases de données, etc. Mais la particularité dulangage machine,c’est d’êtrele langage intermédiaire en lequel tous les autres langagesvontêtre traduits, en une ou plusieurs étapes. Il est situé à la frontière entre le processeur et leslogiciels,entrehardwareetsoftware, et le processeur est l’interpréteurde ce langage (figureV.1), celui qui met en action ses instructions.

ISA générale ou spécialisée ?

Bien sûr, il serait plus efficace d’avoir un processeur qui exécute directementun langage évolué, tout au moins pour les programmes écrits dans ce langage. De telsprocesseurs existent ou ont existé, notamment pour le langage Lisp, et plus récemment pourle langage intermédiaire (bytecode) utilisé en Java. Ces deux langages sont généralistes etpeuvent être utilisés dans toutes les situations concrètes de l’informatique, et l’espoir desconcepteurs de ces processeurs était d’élever au niveau de ces langages la frontière entrematériel et logiciel. Mais le bytecode Java exploite une machine à base de pile, peu adaptéeà la compilation d’autres langages de programmation tels que C. Finalement, le compromisgénéralement adopté lors de la conception d’un nouveau processeur est le développementd’une ISA adaptée à la compilation de la plupart des langages de programmation courants.

129

130 CHAPITREV. PROGRAMMATION DU PROCESSEUR32BITSCRAPS/SPARC

programmeen Javascript

langage machine

de bases de données(langage SQL)

gestionnaire

en langage Cprogramme

processeur

compilation

interprétation

interprétation

matériel

logiciel

interprétation

Figure V.1. Tous les programmes produisent du langage machine, qui est exécuté directe-ment par le processeur.

Évolution des ISA

Comme toute structure située à une frontière, l’ISA est un équilibre entre des forcesopposées.Les concepteursde compilateurssouhaitent une ISA régulière et possédant le plusde possibilités en termes d’adressage mémoire, d’opérations arithmétiques, etc., alors queles architectes des processeurs veulent une ISA simple à implémenter efficacement.

Une force importante qui limite l’apparition de nouvelles ISAs (de nouveaux langagesmachine) est la demande des clients d’unecompatibilité ascendanted’un processeurd’une génération à l’autre, de façon à pouvoir faire fonctionner sans changement leursanciens programmes. Cette force se manifeste de façon très puissante avec les processeursde PC (dont l’ISA est souvent désignée par x86, parce que les noms des processeurs seterminent par 86 : 8086, 80286, etc.), pour laquelle tout changement conduisant à une noncompatibilité est exclu.Ainsi, les processeurs x86 les plus récents continuent à manifester labizarrerie d’écriture en mémoire inversée de typelittle-endian, parce qu’elle était présenteà l’origine sur le processeur 8 bits Intel 8080 pour des motifs de simplicité de conception,et qu’elle s’est transmise pour raison de compatibilité tout le long de la chaîne 8080, 8085,8086, 80286, 80386, Pentium, Pentium 2, etc. jusqu’aux processeurs des PCs actuels.D’autres processeurs moins connus ont également une lignée très longue et respectable. Onpeut citer le processeur ARM, un des premiers processeurs 32 bits commercialisés, qui faitévoluer son ISA de façon ascendante depuis les années 80 jusqu’à maintenant, et qui équipeun grand nombre de téléphones portables, les consoles de jeux portables Nintendo et ungrand nombre d’appareils mobiles.

Processeurs CISC et RISC

Une nouvelle génération de processeurs est apparue dans les années 80, caractérisée parun jeu d’instruction limité à l’essentiel, d’où leur nom de processeursRISC (ReducedInstruction Set Computer). Par ailleurs, leur ISA est généralement très régulière, contientbeaucoup de registres utilisateurs, et les instructions sont codées sous forme d’un motmémoire unique. Tout cela rend heureux les architectes du processeur, qui peuventconcevoir des architectures très efficaces pour cette ISA, et ne rend pas trop malheureux les

1. Le langage machine,à la frontière entre logiciel et matériel 131

concepteurs de compilateurs, qui ont un peu plus de difficulté à traduire les programmes,mais qui apprécient le gain en vitesse d’exécution. Par opposition, les anciens processeurstels que les x86 ont été rebaptisés processeursCISC (Complex Instruction Set Computer),et si ce n’était l’énorme investissement dû au succès du PC avec l’ISA x86, les processeursRISC auraient connus un développement plus immédiat et plus large. On les trouvenéanmoins dans la plupart des stations de travail, dans les processeurs de Macintosh, et dansles consoles de jeux Sony PS[123], avec les performances que l’on sait.

2. Ressources du programmeur CRAPS/SPARC

Le langage machine de CRAPS est un sous ensemble du langage machine du SPARCde SUN (au cas où vous ne l’auriez pas encore remarqué, ’CRAPS’= ’SPARC’à l’envers !),avec un certain nombre de limitations. C’est donc un langage de type RISC, qui seracompatible avec le SPARC au niveau binaire. Néanmoins il n’exploite pas la notion SPARCde fenêtre de registres et il n’a pas d’instruction d’arithmétique flottante.

Figure V.2. Le simulateur du processeur CRAPS.Il permet de développer des programmeset d’observer leur fonctionnement logiciel et matériel jusqu’à l’échelle du bit. Une fois aupoint, ils peuvent être transférés en mémoire et exécutés par le processeur réel.

Afin de rendre plus concrètes les descriptions qui sont suivre, on va progressivementprogrammer le petit algorithme suivant qui fait la somme des 10 éléments d’un tableau :

résultat <- 0 ;pour i de 0 à 9 faire résultat <- résultat + TAB[i] ;fin pour

2.1. Types de données de CRAPS

CRAPS est un processeur 32 bits : cela signifie que les mots mémoire qu’il manipulele plus directement ont 32 bits de large, et que tous ses registres sont de 32 bits. Il peutnéanmoins lire et écrire en mémoire des mots de 8 bits (octets) avec des instructions d’accèsmémoire spécifiques.

Les entiers signés sont codés en complément à 2 et les opérations arithmétiquesdisponibles sont l’addition et la soustraction sur 32 bits, la multiplication 16 bits X 16 bitsvers 32 bits et la division 32 bits / 16 bits vers 32 bits. Il ne dispose pas de registres pourles nombres flottants, ni d’instruction d’arithmétique flottante. Si des calculs sur des réelsdoivent être effectués, ils doivent être exécutés par des librairies logicielles spécialisées.

Aucun autre type de données n’est explicitement supporté. Les chaînes de caractères,les listes etc. devront être assemblées et manipulées en combinant les opérations sur lesoctets et les mots de 32 bits.


2.2. Les registres de CRAPS

Les registres banalisés

CRAPS possède 32registresdirectement accessibles au programmeur (figure V.3). On

pointeurde pile

utilisépar call

%r0

%r1

%r2

...

%r29

%r30

%r31

registresbanalisés

toujours 0

Figure V.3. Les registres du processeur CRAPS.Certains ont déjà des fonctions assignées.

les note %r0, … %r31. Ils sont tous accessibles librement en lecture et en écriture, mais%r0 a un statut spécial : il vaut toujours 0 en lecture, quelles que soient les écritures qu’onfasse dedans. Cette bizarrerie est en fait très commode et on verra par la suite comment elleest exploitée.

%r30 sera généralement utilisé comme pointeur de pile (mais c’est une convention quin’est pas imposée par le matériel), et %r31sert à stocker l’adresse de retour des instructionscall . On utilisera souvent un troisième registre tel que %r29 comme pointeur destackframe(voir plus loin). Si on excepte donc ces 4 registres spéciaux, le programmeur disposede 28 registres qu’il peut utiliser à sa guise dans ses opérations locales, ce qui est un grandconfort et permet de limiter grandement le nombre d’accès à la mémoire centrale.

Notre algorithme se transforme de la façon suivante :

%r1 <- 0;pour %r2 de 0 à 9 faire %r3 <- TAB[%r2] ; %r1 <- %r1 + %r3 ;fin pour

Trois registres utilisateurs sont déjà mobilisés, et ce n’est qu’un début ! On voit l’intérêtqu’offre au programmeur une ISA fournissant beaucoup de registres utilisateurs.

Les registres spéciaux

Les autres registres ne sont généralement pas accessibles directement par le programmeuret sont utilisés pour la gestion du fonctionnement interne du processeur. On trouve :

• %pc (Program Counter), qui contient l’adresse de l’instruction en cours d’exécution.

• %ir (Instruction Register), qui contient l’instruction en cours d’exécution.

2. Ressources du programmeur CRAPS/SPARC 133

• %psr (Program Status Register)qui contient des informationssur l’état de l’exécution.Son format est donné figure V.4, et son rôle détaillé sera décrit dans des sectionsultérieures.

8

S ET

57112031 0

CVZN

23

icc = codes conditions (N, Z, V, C)PIL = niveau d’exécution courant

S = bit superviseurET = enable trap = exceptions autorisées

icc

PIL

Figure V.4. %psr. (Program Status Register)

• %tbr (Trap Base Register), qui contient l’adresse de la table des exceptions. Son rôledétaillé sera décrit dans les sections ultérieures.

2.3. Le modèle mémoire de CRAPS

Comme la plupart des processeurs actuels, l’ISA de CRAPS voit la mémoire sousforme d’un ruban d’octetssitués à des adresses consécutives (figure V.5).

2 −332

2 −232

2 −132

adresse

octets

0 1 2 3 4

...

Figure V.5. La mémoire de CRAPS est un ruban d’octets,numérotés par des adresses allantde 0 à 322 − 1.

Les adresses seront présentes dans CRAPS sous forme de mots de 32 bits, définissantainsi une mémoire centrale pouvant compter jusqu’à322 cases, soit 4 giga-octets, lesadresses allant de 0 à322 − 1. Le fait d’avoir 32 lignes d’adressessera commode dans CRAPSpour manipuler les adresses à l’intérieur des registres.Ce choix n’était pas obligatoire, et onaurait pu imaginer un nombre de lignes d’adresses inférieur ou supérieur à la taille du motmémoire du processeur, ici 32.

En pratique, l’ensemble de cet espace d’adressage n’est souvent pas entièrementoccupé par de la mémoire physique. Un mécanisme de décodage des adresses que l’onétudiera au chapitre suivant permettra d’associer un bloc d’adresses particulier à un boîtiermémoire particulier ; par ailleurs la lecture et l’écriture à certaines adresses ne conduira pasà un simple stockage,mais déclenchera la commande de certainscircuits, tels que le timer oule circuit d’entrées-sorties,selon un mécanisme appeléentrées/sortiesmappéesenmémoire,dont on étudiera l’implémentation au chapitre suivant, mais que l’on apprendra à utiliser entant que programmeur un peu plus loin dans ce chapitre.

Reprenons notre petit algorithme de somme des nombres d’un tableau. On va désignerpar mem[adr] l’octet en mémoire situé à l’adresseadr . Notre tableauTAB en mémoirecentrale est formé de mots de 32 bits situés consécutivement. Comme chaque nombre de


32 bits occupe nécessairement 4 octets, les valeurs du tableau sont espacées de 4 octets en 4octets en mémoire centrale, à des adresses croissantes à partir de l’adresseTABde début dutableau. Les 4 octets qui forment le nombreTAB[i] pour un indicei quelconque sont ainsisitués de l’adresseTAB+ 4i à l’adresseTAB+ 4i + 3(figure V.6).

......

élément i+1élément i

TAB+4i TAB+4i+3

...octets

adresses TAB

Figure V.6. Implantation mémoire d’un tableau de nombres de 32 bits.

Notre algorithme devient :

%r1 <- 0 ;%r4 <- adresse de TAB ;pour %r2 de 0 à 9 faire %r3 <- mem[%r4+4*%r2,...,%r4+4*%r2+3] ; %r1 <- %r1 + %r3 ;fin pour

Pour éviter d’avoir à effectuer la multiplication par 4,on peut incrémenter %r4 de 4 à chaquetour de boucle :

%r1 <- 0 ;%r4 <- adresse de TAB ;pour %r2 de 0 à 9 faire %r3 <- mem[%r4,...,%r4+3] ; %r1 <- %r1 + %r3 ; %r4 <- %r4 + 4 ;fin pour

Écriture en mémoire big-endian et little-endian

Un détail d’implémentation n’a pas été précisé.On a dit qu’un mot de 32 bits était stocké enmémoire centrale sous forme de 4 octets consécutifs à des adressesi , i + 1,i + 2,i + 3, maison n’a pas précisé exactement dans quel ordre. Bien sûr, par des opérations fines d’écritureau niveau de l’octet, notre programme pourrait les stocker dans n’importe lequel des42 =16ordres possibles. Mais un processeur 32 bits est là pour manipuler directement des motsde 32 bits, et en particulier pour lire et écrire en mémoire des mots de 32 bits, et il fait celaselon un ordre qui lui est propre.En pratique, seuls deux tels ordres de stockage sont utilisés.L’ordre dit big-endian, le plus naturel, est utilisé par la grande majorité des processeurs, àl’exception (très notable) des processeurs x86. Il consiste à stocker les octets de telle façonque le mot mémoire se lise dans l’ordre naturel, si on visualise le ruban mémoire de gaucheà droite. Ainsi pour stocker en mémoire le mot de 32 bits 0x11223344, on stockera à desadressescroissantes les octets0x11,0x22,0x33,0x44.L’ordre ditlittle-endian, utilisé par lesprocesseurs x86, stockera ce même mot dans l’ordre inverse 0x44, 0x33, 0x22, 0x11(figureV.7).


...

i+1 i+2 i+3i

0x330x44 0x22 0x11

0

...

...adresse

octets little−endian

...

i+1 i+2 i+3i0

...

...adresse

octets 0x11 0x440x22 0x33 big−endian

Figure V.7. Un même mot de 32 bits 0x11223344 stocké en mémoire centrale dans l’ordrebig-endian et little-endian.

Cet ordre de stockage peu naturel des processeurs x86 prend son origine dans leprocesseur Intel 8080, qui stockait déjà un mot de 16 bits en inversant les deux octets,par commodité de conception. Pour des raison de compatibilité ascendante de leur ISA,Intel a été obligé de conserver cet état de fait dans les successeurs 8 bits du 8080, et mêmede l’étendre de façon logique au stockage des mots de 32 bits, puis de 64 bits dans leursdernières versions de Pentium.

Les termes étrangesbig-endian et little-endian proviennent des ’Voyages de Gulliver’d’Oliver Swift, lorsque Gulliver est au pays des politiciens. Une bataille politique fait ragesur la façon de casser son oeuf à la coque, entre le parti des ’big-endians’, partisans de lecasser par le gros bout, et celui des ’little-endians’partisans du petit bout ! Cette différenced’ordre de stockage est une source d’incompatibilité majeure entre les processeurs x86 etles autres. On peut noter que le SPARC peut modifier son ordre de stockage à la volée, parle positionnement d’un bit de contrôle spécial.

2.4. Les instructions de CRAPS

Toutes les instructions de CRAPS sont constituées d’un seul mot de 32 bits. Cettecaractéristique des instructions d’avoir une taille fixe d’un mot est typique des processeursRISC, et elle facilite grandement certains aspects de leur conception. Les instructions deCRAPS sont formées de plusieurs groupes, chacun ayant une certaine structure de codage(figure V.8).

La valeur du champoppermet d’identifier immédiatement le groupe de l’instruction.À l’intérieur des groupes 2 et 3, ce sont les champs op2 et op3 qui permettent de distinguerles sous-groupes.Ces champsop,op2,op3sont appelésopcodeset sont un moyen de classerles instructions. Le tableau de la figure V.9 donne la signification de leurs valeurs pourle processeur CRAPS. Toutes les instructions du SPARC n’ont pas été reprises, mais on aconservé les mêmes valeurs d’opcodes pour celles qui l’ont été.

Les différentes combinaisons possibles entre ces valeurs d’opcodes sur les formatsd’instructions conduisent au tableau d’instructions de la figure V.10.

Ce tableau est remarquablement réduit ; SPARC/CRAPS mérite véritablementson qualificatif de processeur RISC. Les versions suivantes du SPARC, notammentl’UltraSparc II sur 64 bits, vont ajouter à cet ensemble beaucoup de formats d’instructionssupplémentaires, et perdre de cette élégante simplicité.


0

Format 1 : call

1 disp30

op

0 0 cond op2 disp220

op

0 0 rd op2 imm22

op Format 2 : sethi et branchements

2b

2a

rd1 op3 rs1

rd1 op3 rs1 rs2

simm13 3b

3at

t

− − − − − −

t = 1 : accès mémoire, t = 0 : instruction arithmétique

op Format 3 : accès mémoire, instructions arithmétiques

0 −−

1

Figure V.8. Structure binaire des différents groupes d’instructions de CRAPS.

op2 Instr.

010 branch

100 sethi

op3 (t = 0) Instr.

000000 add

010000 addcc

000100 sub

010100 subcc

011010 umulcc

010001 andcc

010010 orcc

010011 xorcc

010111 xnorcc

110101 sll

110110 srl

111000 jmpl

op3 (t = 1) Instr.

000000 ld

000001 ldub

000100 st

000101 stb

cond Branchement

1000 ba

0001 be

1001 bne

0101 bcs

1101 bcc

1110 bpos

0110 bneg

0111 bvs

1111 bvc

1010 bg

0010 ble

1011 bge

0011 bl

1100 bgu

0100 bleu

Figure V.9. Significations des valeurs d’opcodes.

Langage assembleur

Dans ce tableau V.10, les instructions ont été écrites, non pas en langage machine quiaurait été peu compréhensible, mais dans une écriture symbolique équivalente diteécriture assembleur. Pour chaque processeur, le constructeur fournit le descriptif complet


load/store

ld [%ri+reg/cst],%rj lecture mémoire 32 bits

ldub [%ri+reg/cst],%rk lecture mémoire 8 bits

st %ri,[%rj+reg/cst] écriture mémoire 32 bits

stb %ri,[%rj+reg/cst] lecture mémoire 8 bits

contrôle

call addr appel desous-programme

jmpl addr, %ri jump and link

ba addr branchement inconditionnel

bcc addr branchement si conditionccvraie

système

rdpsr lecture de %psr

wrpsr écriture dans %psr

wrtbr écriture dans %tbr

arithmétiques et logiques

addcc %ri,reg/cst,%rj addition %rj←%ri+reg/cst

subcc %ri,reg/cst,%rj soustraction %rj←%ri-reg/cst

umulcc %ri,reg/cst,%rj multiplication %rj←%ri*reg/cst

udivcc %ri,reg/cst,%rj division %rj←%ri/reg/cst

andcc %ri,reg/cst,%rj AND %rj←%ri and reg/cst

orcc %ri,reg/cst,%rj OR %rj←%ri or reg/cst

xorcc %ri,reg/cst,%rj XOR %rj←%ri xor reg/cst

xnorcc %ri,reg/cst,%rj XNOR %rj←%ri xnor reg/cst

sll %ri,reg/cst,%rj décalage à gauche %rj←%ri << reg/cst

srl %ri,reg/cst,%rj décalage à droite %rj←%ri >> reg/cst

sethi val22, %ri %ri21..0 ← val22

reg/cst : registre ou constante signée sur 13 bits

val22 : constante non signée sur 22 bits

Figure V.10. Les groupes d’instructions du processeur CRAPS.

du jeu d’instruction en langage machine, mais aussi une écriture assembleur conseilléeéquivalente. Les développeurs peuvent alors écrire desprogrammes assembleurs, ditsencoreassembleurs, dont le rôle est de traduire un texte source écrit en langage assembleur,en la suite des codes machine correspondants. Le termeassembleurdésigne donc à lafois le langage du processeur (sous sa forme symbolique) et le programme qui traduit untexte source du langage assembleur vers le langage machine. La figure V.11 montre une


instruction écrite en assembleur, et son code machine équivalent.

addcc %r2, 10, %r3 ↔ 10.00011.010000.00010.1.0000000001010

Figure V.11. Une instruction en assembleur CRAPS/SPARC et le code machine corres-pondant.

Instructions synthétiques

Certaines instructions semblent manquer. Par exemple, il n’y a pas d’instruction de copied’un registre vers un autre, ou d’instruction qui compare 2 registres, ou encore d’instructionqui mette à zéro un registre. En fait, il n’est pas nécessaire que ces instructions existent, carelles sont des cas particuliers d’instructions plus générales. Par exemple la mise à 0 d’unregistre %ri peut se faire par l’instructionorcc %r0, %r0, %ri . On exploite ici le faitque %r0 vaut toujours 0 ; le OR de 0 avec %r0 (qui vaut 0) est ainsi stocké dans %ri, ce quiest le résultat souhaité.

Dans la syntaxe du processeur CRAPS/SPARC figurent ainsi des instructions ditessynthétiques, qui sont en fait remplacées au moment de l’assemblage par la ou lesinstructions équivalentes. Le tableau V.12 montre l’ensemble des instructions synthétiquesdisponibles pour CRAPS.

Initialisation d’un registre par une constante

L’instruction synthétiqueset val,%ri sert à initialiser un registre %ri avec uneconstante diteimmédiate, c’est à dire fournie directement dans le programme. Cetteinstruction synthétique est remplacée par deux instructionssethi val31..10,%ri etorcc%ri, val9..0,%ri qui vont effectivement bien faire cette affectation, en positionnantd’abord les 22 bits de poids fort avecsethi, puis les 10 bits de poids faibles avecorcc. Lefait d’avoir à exécuter deux instructions pour initialiser un registre à une valeur immédiateest typique des processeurs RISC.Ceux-ci ayant des instructions de la taille de leur motmémoire, ils ne peuvent pas dans une seule instruction fournir une donnée immédiate decette taille. On notera la présence de l’instruction synthétiquesetq (rajoutée par rapportau SPARC) qui permet de faire une telle initialisation en une seule instruction lorsque laconstante est petite (13 bits signée, c’est à dire entre -4096 et +4095). Elle est équivalente àorcc %r0, val, %ri qui tire encore parti du fait que %r0 vaut 0.

On notera également la très classique instructionmov %r1,%rj qui en réalité est :orcc %ri,%r0,%rj ,réalisant bien la copie du contenu de %ri dans %rj.

Nous pouvons maintenant mettre un certain nombre d’instructions CRAPS en face deslignes de notre petit algorithme :

clr %r1 ; %r1 <- 0 ;set TAB, %r4 ; %r4 <- adresse de TAB ;

pour %r2 de 0 à 9 faire

ld [%r4], %r3 ; %r3 <- mem[%r4,...,%r4+3];addcc %r1, %r3, %r1 ; %r1 <- %r1 + %r3 ;addcc %r4, 4, %r4 ; %r5 <- %r5 + 4 ;


Instruction Effet Implémentation

clr %ri met à zéro %ri orcc %r0, %r0, %ri

mov %ri,%rj copie %ri dans %rj orcc %ri, %r0, %rj

inccc %ri incrémente %ri addcc %ri, 1, %ri

deccc %ri décrémente %ri subcc %ri, 1, %ri

notcc %ri,%rj %rj <- complément de %ri xnorcc %ri, %ri, %rj

setval31..0, %ri copieval dans %ri sethival31..10, %ri

orcc %ri,val9..0, %ri

setq val, %ri copie val dans %ri orcc %r0, val, %ri

( − 4096 ≤val ≤ 4095)

cmp %ri, %rj compare %ri et %rj subcc %ri, %rj, %r0

tst %ri teste nullité et signe de %ri orcc %ri, %r0, %r0

negcc %ri inverse %ri subcc %r0, %ri, %ri

notcc %ri,%rj complémente %ri en %rj xnorcc %ri, %r0, %rj

nop no operation sethi 0,%r0

jmp %ri branchement à l’adresse absolue %rijmpl %ri, %r0

ret retour de procédure terminale jmpl %r31+4, %r0

push %ri empile %ri sub %r30, 4, %r30

st %ri, [%r30]

pop %ri dépile %ri ld [%r30], %ri

add %r30, 4, %r30

Figure V.12. Les instructions synthétiques de CRAPS. Elles sont traduites en une écritureéquivalente.

fin pour

On peut remarquer la syntaxe des commentaires :un caractère ’;’et tout ce qui le suit jusqu’àla fin de la ligne est ignoré, de façon analogue à la séquence ’//’ du C/C++.

Dans ce programme, ne manquent que les instructions qui vont permettred’implémenter la structure de contrôlepour … fin pour . Toutes les autres instructionssont de nature séquentielle, c’est à dire qu’elles s’exécutent dans l’ordre où elles sontprésentes en mémoire, disposées à des adresses croissantes de 4 en 4.


2.5. Ruptures de séquence en CRAPS

Bien sûr, si un processeur n’était doté que d’instructions séquentielles, il seraitincapable d’exécuter la moindre tâche un peu complexe, puisqu’incapable d’implémenterdes boucles ou des structures de contrôle de typetant que . Il faut donc absolumentqu’il soit doté d’instructions dites derupture de séquence, qui permettent, non seulementde ’sauter’ à une instruction qui n’est pas la suivante, mais aussi de faire ce saut de façonconditionnelle, en fonction des résultats des opérations précédentes.

Un registre spécial de CRAPS/SPARC appelé %pc (program counter), nondirectement accessible au programmeur, contient en permanence l’adresse de l’instructionen cours d’exécution. À la fin de l’exécution d’une instruction séquentielle, %pc estsystématiquement incrémenté de 4, de sorte qu’au cycle d’exécution suivant, le contrôle estpassé à l’instruction suivante en mémoire, placée 4 octets plus loin.

Branchements inconditionnels

Pour effectuer un saut inconditionnel tel queba addr , il suffit que cette instructionn’effectue pas l’incrémentation de %pc de 4, mais au contraire ’force’ la valeur del’adresseaddr dans %pc. Ainsi au cycle d’exécution suivant, le processeur chargeral’instruction située à cette nouvelle adresse, et le contrôle sera dont transféré à ce point dansle programme.

Branchements conditionnels

Ce saut peut également être fait de façon conditionnelle avec les instruction bcc telles quebne, beq, bpos, etc. A chacune de ces instructions est associé un test booléen ; si ce test estvérifié, le saut est effectué (%pc est alors affecté avec l’adresse de saut) ; sinon %pc estincrémenté de 4, c’est à dire que le saut n’est pas fait et que le contrôle continue en séquencedans le programme, à l’instruction qui suit ce branchement.

Le test en question est fait sur la valeur de 4 bits N, Z, V, C appelésindicateursouflags, qui sont positionnés après certaines instructions arithmétiques et logiques. Ils ont lessignifications suivantes :

• N indique que le résultat de l’opération est négatif, c’est à dire que son poids fort està 1.

• Z indique que le résultat de l’opération est nul.

• V indique qu’il y a eu débordement d’une addition ou d’une soustraction signée.

• C indique qu’il y a eu une retenue lors d’une addition ou emprunt lors d’unesoustraction.

Les instructions qui affectent les flags ont un nom qui se termine généralement par ’cc’ :addcc,xorcc,etc.Pour être sûr des flags qui sont affectésou non par une instruction, il faut sereporter à sa description détaillée,présente à la fin de l’ouvrage.Par exemple les instructionsld et ldub de lecture en mémoire affectent les flags Z et N selon que la valeur lue est (ounon) nulle ou négative (respectivement). Ce choix est contraire à celui du SPARC, pourlequel les instructions de lecture en mémoire n’affectent pas les flags.Nous avons jugé quantà nous qu’une lecture en mémoire est souvent suivie d’un test sur la nullité ou le signe de lavaleur, et donc qu’il était intéressant d’avoir les flags positionnés.


Les instructions de branchement conditionnel bcc effectuent le saut pour certainescombinaisons de valeurs des flags. Les tableaux des 3 figures V.13 à V.15 les décrivent,le premier tableau présentant les branchements conditionnels les plus simples qui ne fontintervenir qu’un seul flag, le second présentant les branchementsassociésà une arithmétiquesignée et le troisième les branchements associés à une arithmétique non signée.

instruction opération test

ba Branch Always 1

beq (synonyme : bz) Branch on Equal Z

bne (synonyme : bnz) Branch on Not Equal not Z

bneg (synonyme : bn) Branch on Negative N

bpos (synonyme : bnn) Branch on Positive not N

bcs Branch on Carry Set C

bcc Branch on Carry Clear not C

bvs Branch on Overflow Set V

bvc Branch on Overflow Clear not V

Figure V.13. Branchements conditionnels associés à un seul flag.


bg Branch on Greater not (Z or (N xor V))

bge Branch on Greater or Equal not (N xor V)

bl Branch on Less (Nxor V)

ble Branch on Less or Equal Zor (N xor V)

Figure V.14. Branchements conditionnels associés à une arithmétique signée.


bgu Branch on Greater Unsigned not (Z or C)

bcc Branch on greater than, or equal, unsigned not C

bcs Branch on less than, unsigned C

bleu Branch on Less or Equal Unsigned Zor C

Figure V.15. Branchements conditionnels associés à une arithmétique non signée.

Les branchementsdu premier tableau qui ne font intervenir qu’un seul flag peuvent êtreutilisés dans la plupart des situations simples, et on peut en les combinant n’utiliser qu’euxdans des situations plus complexes.

Les branchements associés à l’arithmétique signée et non signée des deux tableauxsuivants ne se comprennent que si on suppose qu’une comparaison entre deux valeurs vient


d’être faite, c’est à dire dans un programme de la forme :

cmp %ri, reg/valbxx saut

bxx représente une des instructions de branchement conditionnel, et reg/val représente unregistre ou une constante. L’instruction synthétiquecmp %ri,reg/val est équivalente àsubcc %ri,reg/val,%r0 c’est à dire qu’elle effectue la soustraction%ri - reg/val

dans le but d’obtenir, non pas la valeur du résultat en tant que telle (qui est éliminée dans%r0), mais plutôt la valeur des flags après cette soustraction.Ceux-ci permettent en effet detout savoir sur les positions respectives de %ri et de reg/val :

• %ri = reg/val ⇔ %ri − reg/val = 0, soit Z.

• %ri > reg/val ⇔ %ri − reg/val > 0, soit N = 0 et Z = 0, soit−N + Z.

• %ri ≥ reg/val ⇔ %ri − reg/val ≥ 0, soit−N.

• %ri < reg/val ⇔ %ri − reg/val < 0, soit N.

• %ri ≤ reg/val ⇔ %ri − reg/val ≤ 0, soit N = 1 ou Z = 1, soit Z + N.

En arithmétique signée, on doit remplacer N par (N + V) dans ces équations pour tenircompte des situations où on compare des grands nombres en valeur absolue, et où lasoustraction provoque un débordement mais qui permet tout de même de conclure. Celaconduit alors aux équations du tableau V.14.

En arithmétique non signée, on doit remplacer N par C, car C va avoir la même valeurque N lors de la soustraction de petites valeurs, mais va également permettre de concluredans des situations où la soustraction a une grande amplitude et change le signe du résultat,telles que la comparaison de 0x00000001 et 0xFFFFFFFF : leur soustraction donne0x00000002, avec N=0 et C=1. Seul C indique dans tous les cas qu’il a fallu emprunter poursoustraire les deux arguments. Cela conduit aux équations du tableau V.15.

Maintenant, nous sommes prêts à terminer la programmation de notre algorithme :

;;;;;;;;;; somme des éléments d’un tableau ;;;;;;;;; clr %r1 ; %r1 <- 0 ; set TAB, %r4 ; %r4 <- adresse de TAB ; clr %r2 ; pour i de 0 à 9loop: ld [%r4], %r3 ; %r3 <- mem[%r4,...,%r4+3]; addcc %r1, %r3, %r1 ; %r1 <- %r1 + %r3 ; addcc %r4, 4, %r4 ; %r5 <- %r5 + 4 ; inccc %r2 cmp %r2, 9 bleu loop ; fin pour

%r2 est initialisé à 0 au début de la bouclepour … fin pour . En fin de boucle, %r2 estincrémenté (incc %r2 ), puis comparé à 9. En toute rigueur il faut utiliserbleu puisqu’onfait un test ≤ non signé, maisbpos aurait fonctionné également car les valeurs des indicesrestent petites.


Ici l’indice i n’a été utilisé que comme un compteur. On peut raccourcir le programmeen initialisant %r2 à 10, et en le décrémentant à chaque tour de boucle jusqu’à 0 :

;;;;;;;; somme des éléments d’un tableau ;;;;;;;; clr %r1 ; %r1 <- 0 ; set TAB, %r4 ; %r4 <- adresse de TAB ; set 10, %r2 ; compteur à 10loop: ld [%r4], %r3 ; %r3 <- mem[%r4,...,%r4+3]; addcc %r1, %r3, %r1 ; %r1 <- %r1 + %r3 ; addcc %r4, 4, %r4 ; %r5 <- %r5 + 4 ; deccc %r2 ; décrémente compteur bne loop ; reboucle tq compteur <> 0

On n’a rien gagné en nombre d’instructions brut, car l’instruction synthétiqueset10,%r2 occupe en réalité 2 instructions. Mais on a fait passer le corps de la boucle de 5à 4 instructions, soit un gain en vitesse de 20%. L’optimisation est négligeable sur ceprogramme, mais elle peut devenir significative quand les boucles sont parcourues un grandnombre de fois.

Branchements relatifs

Pour tous les branchements que nous venons de voir, ba et bcc, ce n’est pas l’adresse absoluedu saut qui est codée, mais un déplacementrelatif à cette adresse. Si on reprend le codagebinaire de ces instructions (figure V.8), on voit que le branchement est codé dans le champdisp22qui codeun déplacement signé, en nombre de mots. Le déplacement est signé, cequi signifie qu’une valeur négative conduira à un saut en arrière dans le programme, et undéplacement positif à un saut en avant. Le déplacement est codé en nombre de mots, c’està dire qu’il faut le multiplier par 4 pour obtenir le déplacement en nombre d’octets. Ainsi,puisque l’instruction en cours d’exécution a son adresse stockée dans le registre %pc, le sautconduira à faire l’affectation :

%pc← %pc + 4 * disp22

Par exemple, l’instruction de notre programmebne loop décrit un saut (conditionnel)de 4instructions en arrière, soit un saut à une adresse plus petite de 16. C’est la valeur-4 qui estcodée, soit :

00.0.1001.010.1111111111111111111100 bne loop

Coder le saut sous forme d’un déplacement présente deux avantages :

1 c’est plus économique en mémoire, puisque tout le saut est codé en une instructiond’un mot.

2 l’instruction obtenue esttranslatable, c’est à dire qu’un programme qui ne comprendque de telles instructions peut être placé n’importe où en mémoire. C’est unecaractéristique importante des programmes lorsqu’ils doivent être chargés par lesystème d’exploitation à une place libre en mémoire.

Le saut effectué par ces instructions ne peut pas être fait d’une extrémité de la mémoire àl’autre. On peut voir sur le format binaire des instructions figure V.8 que le déplacement estcodé sur 22 bits, et donc on ne peut pas faire un saut de plus de212 instructions en avant ou


en arrière. En pratique c’est une valeur très suffisante tant que le saut est fait à l’intérieurd’un même programme.

Branchements absolus

Dans certaines situations, on peut avoir le besoin de se brancher à une adresse absolue, etnon une adresse locale et relative au bloc de code courant. Le système d’exploitation a cebesoin, lorsque son scheduler de tâches va enlever le contrôle à une tâche pour le donner àune autre par exemple, ou lorsqu’il va exécuter unsous-programme d’interruption.Nous enverrons des exemples plus loin dans ce chapitre.

L’instruction jmpl (jump and link) remplit cette fonction. Elle a la forme :

jmpl %ri+%rj/cst, %rk

L’adresse de saut est%ri+%rj/cst ; dans %rk est stockée l’adresse de l’instructionjmpl ,c’est à dire l’adresse d’où l’on part. Si on désire faire un saut simple à l’adresse contenuedans %ri, on écrira :

jmpl %ri, %r0

Comme d’habitude dans cette écriture, le terme%rj/cst a disparu car il a été choisi égal à%r0 ou à la constante 0, au choix. Cette expression peut s’écrire de façon plus simple avecl’instruction synthétiquejmp %ri .

2.6. Les modes d’adressage de CRAPS

Un mode d’adressageest un type d’accès aux données pour le processeur. PourCRAPS, ils sont au nombre de 4 :

1 l’adressage registre :la donnée est dans un registre, spécifié par son numéro. Parexemple :

addcc %r1, %r2, %r3

Ici les 3 données manipulées sont dans des registres.

2 l’adressage immédiat :l’instruction elle-même, dans son codage en langage machine,contient la donnée. Par exemple :

addcc %r1, 2, %r3

Ici la deuxième donnée (2) est codée dans le champsimm13de l’instruction.

3 l’adressage direct(ou absolu) : l’instruction contient l’adresse de la donnée. Parexemple :

ld [600], %r1

%r1 est chargé avec la donnée située en mémoire à l’adresse 600. Cette adresse 600est codée dans l’instruction elle-même (un peu comme dans un adressage immédiat),dans son champsimm13. Comme cette valeur ne peut pas dépasser 4095, ce moded’adressage est quasiment inutilisable dans CRAPS.


4 l’adressage indirect :l’instruction contient l’adresse de l’adresse de la donnée. Parexemple :

ld [%r1], %r2

%r2 est chargé avec la donnée située à l’adresse contenue dans %r1. ’L’adresse del’adresse’est ici le numéro du registre (1) qui contient l’adresse de la donnée. Ce moded’adressage est indispensable pour accéder aux éléments d’un tableau de taille nonconnue a priori.C’est par exemple celui qu’on a utilisé dans notre programme de calculde la somme des éléments d’un tableau, pour accéder aux nombres en mémoire.

5 l’adressage indirect avec déplacement. Par exemple :

ld [%r1-2], %r2

Ce cas est similaire au précédent, mais on ajoute au contenu du registre une constante(ici -2) pour obtenir l’adresse de la donnée.

3. Directives d’un programme assembleur

Si on cherche à assembler effectivement, à l’aide de CRAPSEMU par exemple, leprogramme de somme des éléments d’un tableau étudié à la section précédente, le symboleTAB sera déclaré comme indéterminé. Il est en effet censé représenter l’adresse de débutdu tableau, mais rien n’a été spécifié pour l’initialiser. Unedirectivedans un programmeassembleur est une ligne qui ne correspond pas à une instruction, mais qui spécifie :

1 la localisation en mémoire d’un bloc d’instructions ou de données.

2 la réservation et/ou l’initialisation d’un bloc de données.

Pour notre tableau TAB, nous avons besoin de spécifier à la fois son adresse, et son contenuinitial, si on suppose qu’il est donné et non qu’il est le résultat d’un calcul antérieur. Leprogramme suivant contient les directives nécessaires :

;;;;;;;;;; zone de programme ;;;;;;;;; .org 0

clr %r1 ; %r1 <- 0 ; set TAB, %r4 ; %r4 <- adresse de TAB ; clr %r2 ; pour i de 0 à 9loop: ld [%r4], %r3 ; %r3 <- mem[%r4,...,%r4+3]; addcc %r1, %r3, %r1 ; %r1 <- %r1 + %r3 ; addcc %r4, 4, %r4 ; %r5 <- %r5 + 4 ; inccc %r2 cmp %r2, 9 bleu loop ; fin pour ba *

;;;;;;;;;; zone de données ;;;;;;;;;


.org 0x1000TAB .word 12, -4, 5, 8, 3, 10, 4, -1, 1, 9

Adresse d’assemblage

La directive.org change l’adresse d’assemblage courante. Avec.org 0 , le programmesera assemblé à partir de l’adresse 0.Le tableau TABsera situé plus loin en mémoire,à partirde l’adresse 0x1000, grâce à la directive.org 0x1000 .

Allocation et initialisation de mots en mémoire

La directive.word fournit une liste de nombres, écrits en décimal, hexadécimal ou binaire,qui seront placés en mémoire à partir de l’adresse d’assemblage courante. Dans notreprogramme exemple, cela nous permet de créer un tableau et de l’initialiser statiquement(c’est à dire avant le lancement du programme)avec 10 mots de 32 bits. Il occupera 40 octets,de 0x1000 à 0x1027 inclus.Voici ce que donne le listing d’assemblage complet,qui imprimetoutes les adresses mémoire (colonne de gauche) et leur contenu :

00000000 .org 0

00000000 82900000 clr %r100000004 12000002 set TAB, %r400000008 8891200000000008 84900000 clr %r20000000C C6010000 loop: ld [%r4], %r300000010 82804003 addcc %r1, %r3, %r100000014 88812004 addcc %r4, 4, %r400000018 8480A001 inccc %r20000001C 80A0A009 cmp %r2, 900000020 08BFFFFB bleu loop00000024 10800000 ba *

00001000 .org 0x100000001000 0000000C TAB .word 12,-4,5,8,3,10,4,-1,1,900001004 FFFFFFFC00001008 00000005 0000100C 0000000800001010 0000000300001014 0000000A00001018 000000040000101C FFFFFFFF00001020 0000000100001024 00000009

Par exemple à l’adresse 0x1000 on trouve 0x0000000C, c’est à dire 12 ; à l’adresse 0x1004on trouve 0xFFFFFFFC, c’est à dire-4, etc.

3. Directives d’un programme assembleur 147

Allocation d’une chaîne de caractères

Si on souhaite allouer une chaîne de caractères ou n’importe quelle séquence d’octets enmémoire, on utilisera la directive.byte . Un exemple fera mieux qu’un long discours :

MESSAGE .byte ’Tapez un nombre : ’, 10, 13, 0

.byte est suivi d’un nombre quelconque d’arguments séparés par des virgules. Cesarguments peuvent être, soit des nombres entre 0 et 255 (comme 10, 13 et 0), soit des chaînesde caractères qui seront remplacées par la suite de leurs codes ASCII. Dans l’exemple, lesoctets suivants seront placés en mémoire à partir de l’adresseTEXT :

00001000 .org 0x100000001000 54977065 TEXT .byte ’Tapez un nombre :’,10,13,000001004 7A20756E00001008 206E6F6D0000100C 6272652000001010 3A0A0D00

10 et 13 sont les codes ASCII des caractères ’retour chariot’et ’line feed’, qui provoquent unretour à la ligne lors d’un affichage sur un terminal.

Utilisation de symboles

On peut utiliser dessymbolespour représenter des valeurs constantes de façon plus lisibledans un programme. On utilise pour cela une écriture du type :

N = 1000

Dans cet exemple, partout où N apparaîtra, il sera remplacé par 1000. Par exemple si onécrit :set N, %r1 , tout se passe comme si on avait écritset N, %r1 .

Par ailleurs,une arithmétique est utilisable sur de tels symboles.Si on voulait initialiserun tableau avec les 3 premiers multiples de 15, on écrirait :

N = 15TAB .word N, 2*N, 3*N

De telles expressions arithmétiques peuvent comporter des signes’-’, ’+’, ’*’, ’/’ et desparenthèses avec la syntaxe et la sémantique habituelle. Bien sûr, on aura compris queles calculs sur ces expressions sont effectués au moment de la phase d’assemblage etqu’ils ne conduisent à aucun de ces calculs par le processeur au moment de l’exécution duprogramme. Si par exemple on écrit :

N = 15 set 2*N+4, %r1

,tout se passe comme si on avait écrit :

set 34, %r1


Réservation d’un zone non initialisée en mémoire

La directive .malloc <n> réserve sans les initialiser <n> octets en mémoire. Ellecorrespond en fait à un simple déplacement de l’adresse d’assemblage <n> octets plusloin. Elle permet de réserver la place pour un tableau, ou n’importe quelle autre structurede données, qui sera initialisée dynamiquement par programme, au lieu d’être définiestatiquement avec des directives.word et .byte .

4. Exemple de programme : crible d’Ératosthène

Afin d’illustrer de façon plus parlante les éléments de programmation en assembleurqui viennent d’être présentés, on va écrire un programme qui recherche tous les nombrespremiers inférieurs à une certaine limiteN, par la méthode du crible d’Eratosthène.

Algorithme

Cette méthode consiste à construire un tableauTAB[ i ], 0 ≤ i ≤ n dans lequelTAB[ i ] = 0signifie quei est premier, etTAB[i] = 1signifie quei n’est pas premier. Pour cela on remplitd’abord tout le tableau de zéros. Ensuite, à partir dei = 2, on met à 1TAB[2 ∗ i ], TAB[3∗ i ], … jusqu’à la fin du tableau, puisque2 ∗ i , 3 ∗ i , …ne sont pas premiers. On chercheensuite, après 2, le premier indicei du tableau pour lequelTAB[i] = 0. En l’occurrence c’est3, qui est nécessairement premier car sinon il aurait été coché précédemment. On met alorsà 1TAB[2i ], TAB[3i ], … jusqu’à la fin du tableau, puisque2i , 3i , …ne sont pas premiers.On recommence ensuite avec la prochaine valeur dei pour laquelleTAB[ i ] = 0, qui estnécessairement première, etc. On peut arrêter ce processus dès quei atteint√N, car on peutfacilement montrer qu’alors tous les nombres non premiers ont déjà nécessairement étémarqués à 1 dans le tableau.

On peut traduire cette méthode par l’algorithme suivant :

pour i de 0 à N-1 TAB[i] <- 0 ;fin pourpour i de 2 à racine(N) si TAB[i] = 0 alors j <- 2*i ; tant que (j < N) TAB[j] <- 1 ; j <- j + i ; fin tq fin sifin pour

Programmation

D’après l’algorithme, les éléments du tableau TAB sont seulement les valeurs 0 ou 1. Untableau de bits aurait fourni le codage le plus compact, mais aurait été difficile à manipuler.Un tableau de mots de 32 bits aurait été le plus facile d’accès, mais cela aurait été ungaspillage de mémoire un peu inutile. On va donc utiliser un tableau d’octets, facile à

4. Exemple de programme : crible d’Ératosthène 149

accéder, et qui occupera quatre fois moins d’espace en mémoire qu’un tableau de mots de32 bits.

On va d’abord mettre en place les directives de déclaration,notamment l’allocation desN octets du tableau :

N = 1000RAM = 0x1000000

.org RAM ; adresse en RAMTAB .malloc N ; allocation de N octets

La valeur de N est définie de façon symbolique (ici avec 1000) ; il suffit de changer cetteligne pour changer toutes les références à ce maximum. De même, le symbole RAMdéfinit le début de la zone de mémoire RAM sur la machine ; on va supposer ici que c’estl’adresse 0x1000000.

La directive.org RAM déplace l’adresse d’assemblage au début de la zone de RAM,de sorte que le tableau TAB sera situé au début de cette zone. La directive.malloc N

réserve un espace de N octets, sans l’initialiser, de sorte que l’adresse d’assemblage suivantcette directive est RAM+N. Ainsi le programme dispose de N octets à partir de TAB, danslesquels il va stocker les éléments du tableau.

Passons maintenant à la mise à zéro des éléments du tableau :

N = 1000RAM = 0x1000000

.org 0erato set TAB,%r1 clr %r2 ; pour i de 0 à N-1loop stb %r0,[%r1+%r2] ; TAB[i] <- 0 inccc %r2 ; élément suivant set N,%r5 cmp %r2,%r5 bcs loop ; fin pour ...


On a implémenté strictement l’algorithme, avec %r2 comme indice dans le tableau et %r1comme pointeur sur le début du tableau. Pour écrire dans le tableau, on ne peut employerqu’une des deux instructions d’écriture en mémoire,st oustb . Puisqu’on écrit seulementun octet, c’eststb qu’il faut employer. La forme générale de cette instruction étant :stb %ri, [%rj+cst/%rk] , le registre à écrire sera nécessairement %r0 (qui vaut 0)et l’adresse de l’octet à écrire sera %r1+%r2 (adresse de début du tableau + indice dans letableau). Avec les choix qui ont été faits avant sur le type du tableau, on est nécessairementconduits à l’instruction :

stb %r0,[%r1+%r2] ; TAB[i] <- 0


Les trois instructions suivantes sont relatives à la recherche de l’indice suivant. Oncommence d’abord par incrémenter l’indice :

inccc %r2 ; élément suivant

Il faut ensuite vérifier qu’il est inférieur à la limiteN − 1:

set N,%r5cmp %r2,%r5

L’instruction synthétiquecmp %r2,N n’est pas possible ici. Elle équivaut en effet àl’instruction subcc %r2, N, %r0 et la valeur de N est trop grande pour la constantepossible à cette place dans le cas général, car elle est limitée à 13 bits, c’est à dire àl’intervalle [ − 4096, 4095]. On doit donc passer par un registre intermédiaire %r5, aveclequel on fait la comparaison.Les flags sont alors positionnés en fonction de la valeur de%r2 − %r5, c’est à dire dei − N. Puisque l’algorithme mentionne une relation d’inégalité, c’estla valeur du flag N qui nous intéresse. On a :

N = 1 ⇔ i − N < 0 ⇔ i < N ⇔ i ≤ N − 1

On doit donc utiliser l’instructionbneg , qui effectue le branchement vers le début de laboucle si N = 1 :

bneg loop ; fin pour

En fait, puisqu’il s’agit d’une comparaison non signée, il est même préférable d’utiliserle branchementbcs , qui fait une comparaison de type inférieur strict, non signée. Ellepermettra en effet d’étendre l’algorithme à des valeursde N très grandes, jusqu’au maximumpossible sur 32 bits. On écrira :

bcs loop ; fin pour

On vient de traduire littéralement l’algorithme qui était donné, à la façon d’un compilateur.On peut néanmoins remarquer que l’indice %r2 n’a pas besoin d’être utilisé de façoncroissante dans cette partie du programme. On peut optimiser ce code en initialisant %r2 àN − 1et en le décrémentant à chaque tour de boucle avant de tester s’il est positif ou nul.Cela donne :

. set TAB, %r1 set N-1, %r2 ; pour i de N-1 à 0loop stb %r0,[%r1+%r2] ; TAB[i] <- 0 deccc %r2 ; élément suivant bpos loop ; fin pour

On ajoute une instruction dans la partie initialisation (set occupe 2 instructions), maisle corps de la boucle passe de 5 à 3 instructions. Le code global est plus petit d’uneinstruction, et on a un gain en vitesse de 40% dans l’exécution de la boucle. On remarqueraque l’instructioncmp n’est plus nécessaire dans cette deuxième version, car le flag N estdirectement utilisable après l’instructiondeccc .

Dans le reste de l’algorithme, la structure de contrôle de plus haut niveau est de la formepour i de 2 à racine(N) ... fin pour . Cette fois l’indice i est utilisé de façoncroissante. On va le traduire comme dans la première version de l’initialisation du tableau :

4. Exemple de programme : crible d’Ératosthène 151

. setq 2,%r2 ; pour i de 2 a racine(N)loopi ... <corps de la boucle> ...nexti inccc %r2 set RN,%r5 cmp %r2,%r5 bleu loopi ; fin pour

On remarquera l’usage dusetq pour initialiser une petite constante, plus économique queset qui utilise deux instructions.

Dans le corps de la boucle, on doit ensuite lire l’élémentTAB[ i ] du tableau, et choisirune autre valeur de i si cet élément de tableau vaut 1 :

. setq 2,%r2 ; pour i de 2 a racine(N)loopi ldub [%r1+%r2], %r6 bne nexti ; si TAB[i] = 0 ...

L’élément de tableau est lu en mémoire, c’est donc une instructionld ou ldub qui doit êtreutilisée, icildub puisque c’est une lecture d’octet. Le tableau commence à l’adresse %r1eton lit l’élément d’indice %r2 : il se trouve donc à l’adresse %r1+%r2. Il est lu dans %r6 etcette lecture modifie les flags (voir détail de l’instructionldub annexe B).L’instructionbnenexti provoque la recherche d’un nouvel indice i siZ = 0, c’est à dire si %r6 est différentde 0, donc égal à 1 ici.

L’instruction j <- 2*i~; s’implémente très simplement sous forme d’uneaddition :

addcc %r2, %r2, %r3 ; j <- 2*i

On a ensuite une structure de contrôletant que (j < N) , qu’on va traduire :

loopj set N,%r5 cmp %r3,%r5 bpos nexti ; tant que (j < N) ... <corps de la boucle> ... ba loopj ; fin tq

Elle est analogue à l’implémentation de la structurepour … fin pour , mais le test est faiten tête de boucle. %r5 est, ici encore, utilisé très temporairement pour stocker N, trop grandpour être manipulé a priori comme une ’petite’constante sur 13 bits.

Le corps de la boucle se traduit ensuite directement :

check setq 1, %r4 stb %r4, [%r1+%r3] ; TAB[i] <- 1 addcc %r3, %r2, %r3 ; j <- j + i


Finalement, le programme complet est donné figure V.16. On notera l’instructiond’arrêt sous forme de boucle infinie (’*’ représente l’adresse de l’instruction courante).

N = 1000RN = 32RAM = 0x1000000

.org 0erato set TAB, %r1 set N-1, %r2 ; pour i de N-1 à 0loop stb %r0, [%r1+%r2] ; TAB[i] <- 0 deccc %r2 ; élément suivant bpos loop ; fin pour

setq 2, %r2 ; pour i de 2 a rac(N)loopi ldub [%r1+%r2], %r6 bne nexti ; si TAB[i] = 0 addcc %r2, %r2, %r3 ; j <- 2*iloopj set N, %r5 cmp %r3, %r5 bpos nexti ; tant que (j < N)check setq 1, %r4 stb %r4, [%r1+%r3] ; TAB[i] <- 1 addcc %r3, %r2, %r3 ; j <- j + i ba loopjnexti inccc %r2 set RN, %r5 cmp %r2, %r5 bleu loopi ; fin pour

ba * ; boucle infinie (arrêt)


Figure V.16. Programme complet du crible d’Ératosthène en CRAPS/SPARC. Il construitun tableau d’octets tel qu’un élément d’indice i valant 0 indique que i est premier.

5. Appels de sous-programmes terminaux

Pour le moment, nous n’avons écrit que des programmes monolithiques, utilisablesune seule fois. Pourtant, il serait utile qu’un programme tel que la somme des élémentsd’un tableau puisse être utilisé plusieurs fois sur différents tableau durant l’exécution d’unprogramme, sans pour autant avoir à dupliquer son code.

CRAPS fournit un tel mécanisme sous la forme des deux instructionscall et ret :

1 call <adresse> sauvegarde l’adresse courante d’exécution dans le registre %r31,puis provoque un branchement à l’adresse spécifiée, où est situé lesous-programmequ’on souhaite appeler.

2 ret provoque le branchement à l’adresse %r31+4. Si le contenu de %r31 n’a pasété modifié depuis l’appelcall , l’exécution reprend à l’adresse quisuit celle del’instructioncall .

5. Appels de sous-programmes terminaux 153

Tout se passe comme sicall <adresse> était une instruction de somme de tableaux. Onmontre sur le programme suivant comment notre programme de somme des éléments d’untableau a été transformé ensous-programme, et invoqué sur deux tableaux différents :

;;;;;;;;;; programme principal ;;;;;;;;; set TAB1, %r4 ; arg. 1er appel call tabsum ; 1er appel set TAB2, %r4 ; arg. 2eme appel call tabsum ; 2eme appel ba * ; arrêt

;;;;;;;;;; sous-programme ;;;;;;;;;tabsum clr %r1 ; %r1 <- 0 ; clr %r2 ; pour i de 0 à 9loop: ld [%r4], %r3 ; %r3 <- mem[%r4,...,%r4+3]; addcc %r1, %r3, %r1 ; %r1 <- %r1 + %r3 ; addcc %r4, 4, %r4 ; %r5 <- %r5 + 4 ; inccc %r2 cmp %r2, 9 bleu loop ; fin pour ret

;;;;;;;;;; zone de données ~;;;;;;;;; .org 0x1000TAB1 .word 1, 2, 3, 4, 5, 6, 7, 8, 9, 10TAB2 .word 2, 4, 6, 8, 10, 12, 14, 16, 18, 20

Ce mécanismecall … ret est appelé appel desous-programmesterminaux, c’est à direde sous-programmes situés au dernier niveau d’appel. On l’aura sans doute déjà compris, iln’est pas possible avec ce mécanisme d’appeler un autre sous-programme à partir du corpsd’un sous-programme appelé, puisque la première adresse de retour serait écrasée par laseconde dans %r31. Il nous manque maintenant un mécanisme qui permette de sauvegardercette valeur ; il est présenté à la section suivante.

6. Utilisation de la pile

Principe

Unepileest une structure de données qui se manipule uniquement avec les deux opérationssuivantes :

1 PUSHdata: sauvegarde (empile)datadans la pile.

2 POP : enlève le sommet de la pile, et le renvoie.

On peut sauvegarder a priori autant de données qu’on le souhaite ; l’inconvénient estqu’on ne peut pas récupérer n’importe quand une donnée sauvegardée : on doit avant avoirrécupéré toutes celles qui ont été empilées après elle.

Une telle pile pourrait être implémentée de plusieurs façons, à commencer par une pile


matérielle à base d’un grand tableau de registres. La méthode la plus simple (mais aussi laplus lente) est de stocker la pile sous forme de mots consécutifs dans la mémoire centrale, etd’utiliser un registre qui pointe sur la dernière valeur empilée, appelépointeur de pile.

Dans le cas de CRAPS, on utilisera le registre %r30, et les opérationspushet popexistent déjà sous forme d’instructions synthétiques :

push %ri : sub %r30, 4, %r30 st %ri, [%r30]

pop %ri : ld [%r30], %ri add %r30, 4, %r30La figure V.17 montre ce qu’on observe en mémoire, après quatre opérations

successives d’empilement et de dépilement.

%r30

fond depile

initialement

−4 5

set 5, %r1push %r1

%r30

set 7, %r1push %r1

5

7

%r30

−8

5

7%r30

pop %r2

%r2

set 9, %r1push %r1

5

9

%r30

(a) (b) (c)

(e)(d)

Figure V.17. Opérations successives d’empilement et de dépilement.

En disposant le ruban mémoire de haut en bas, on observe que les opérationsd’empilement se traduisent visuellement par un empilement des valeurs les unes sur lesautres : le 7 par dessus le 5, etc. Réciproquement un dépilement se traduit par la saisie dela valeur au sommet, c’est à dire celle qui est pointée par %r30. On notera cependant quela valeur dépilée n’est pas effacée de la mémoire, mais qu’elle est laissée telle quelle. Celan’a aucune importance, car elle n’est plus accessible par des opérationpop , et elle peut êtreécrasée par une opérationpush ultérieure. C’est ce qui se passe lors dupush de la valeur 9(situation (e)).

6. Utilisation de la pile 155

La pile de CRAPS, comme celle de la plupart des processeurs, a les deux propriétéssuivantes :

1 lors d’un empilement, le sommet de la pile ’remonte’, c’est à dire que la valeur dupointeur de pile diminue.

2 le pointeur de pile pointe toujours sur la dernière valeur empilée.

Ces indications sont utiles notamment lorsqu’on débogue un programme et qu’on souhaitesavoir précisément ce que la pile contient.

Allocation de l’espace de pile

La pile étant en mémoire centrale, doit être dans une zone de RAM. Par ailleurs, il fautprévoir qu’avec les empilements successifs elle va ’grignoter’ de la place en mémoire, enprogressant vers les adresses basses (figure V.18).

fond de pile

pile

RAM

adresse 0

programme,données

Figure V.18. La pile grandit en mémoire en progressant vers les adresses basses.Elle peutdéborder sur des zones de programme ou de données.

Il y a donc un danger potentiel d’écrasement d’une zone de programmes ou dedonnées par la pile, sicelle-ci grandit trop. Lorsqu’on utilise une pile dans un programme,il faut donc initialiser le pointeur de pile en prenant en compte la position des autresdonnées en mémoire, et la taille maximale que la pile peut prendre au cours de l’exécutiondes programmes.

Sauvegarde de l’adresse de retour de sous-programme

Un premier usage que l’on peut faire d’une pile est de résoudre notre problème desauvegarde de l’adresse de retour lors d’un appel de sous-programme de typecall …ret .

La solution est très simple :

1 juste avant l’appelcall , il faut empiler l’adresse de retour %r31.


2 juste après le retour ducall , on dépile dans %r31cette adresse.

Ainsi, même si %r31 est modifié dans l’appel dusous-programme, on est sûr de retrouverla valeur de %r31que l’on avait avant lecall , c’est à dire l’adresse de retour (sous réserveque la pile soit au même niveau au retour qu’au départ).

On peut illustrer cette méthode par le petit programme suivant :

RAM = 0x1000000STACK = RAM+100 ; 100 octets réservés

;;;; calcul de 2*5+4 par appels successifs ;;;;;;;; de ssprog1 et ssprog2 ;;;;; set STACK, %r30 ; initialisation %r30main: set 5, %r1 ; init. arguments d’appel set 4, %r2adr1: call ssprog1 ; appel ss programme ba * ; arrêt (boucle infinie)

;;;;;; calcule 2*%r1+%r2, résultat dans %r3 ;;;;;;ssprog1: push %r31 ; empile adresse retouradr2: call ssprog2 ; calcul de 2*%r1 pop %r31 ; restaure adresse retour addcc %r1, %r2, %r3 ; ajoute %r2 ret ; retour à main

;;;;;; calcule 2*%r1, résultat dans %r1 ;;;;;;ssprog2: addcc %r1, %r1, %r1 ret

Avant toute chose, il faut initialiser le pointeur de pile. Ici il est placé 100 octets aprèsle début de la zone de RAM, laissant la possibilité de 100/4 empilements.main appellessprog1 , qui va faire le calcul2x + y. Ce n’est pas la peine ici de sauvegarder %r31, caron ne vient de nulle part et donc on n’a pas d’adresse de retour à préserver. %r31 prendpour valeuradr1 , qu’il va falloir préserver si on veut revenir dansmain à la fin.ssprog1

appellessprog2 pour faire le calcul du double. Avant de partir, il sauvegarde son adresseadr1 de retour àmain , qui sera écrasée sinon. En effet à l’exécution decall ssprog2 ,la valeur de %r31 qui étaitadr1 est écrasée, et remplacée paradr2 . Au ret dessprog2

le contrôle reprend à l’adresseadr2+4 , après l’appelcall ssprog2 . L’exécution depop%r31 redonne à %r31 la valeuradr1 qu’il avait avant l’appel, et le retour àmain redevientpossible.

Appels de fonctions récursives

Cette méthode ouvre d’un seul coup la possibilité de réaliser des programmesrécursifset mutuellement récursifs, puisque les sauvegardes/restaurations des adresses de retourpeuvent être faites en nombre quelconque dans la pile.

On va l’illustrer par un calcul de plus grand commun diviseur (PGCD), qui s’obtientpar l’algorithme récursif suivant :

fonction int pgcd(int x, int y)

6. Utilisation de la pile 157

si (x = y) alors val <- x ; sinon si (x > y) alors val <- pgcd(x-y, y) ; sinon val <- pgcd(x, y-x) ; return val ;fin fonction

Par exemple, PGCD(78,143) = PGCD(78,65) = PGCD(13,65) = PGCD(13,52) =PGCD(13,39) = PGCD(13,26) = PGCD(13,13) = 13.

Comme par ailleurs78 = 2×3×13et 143 = 11×13, on vérifie bien que 13 est leur plusgrand commun diviseur.

Pour le programmer récursivement en CRAPS, il nous suffit à l’intérieur dusous-programmepgcd de rappeler parcall le sous-programmepgcd , en prenant soin desauvegarder dans la pile toutl’environnement local nécessaire au calcul, c’est à dire :

1 les valeurs de registres que l’on souhaite conserver au travers de cet appel.

2 l’adresse de retour %r31.

La figure V.19 donne le listing complet du programme.

Le programme est tout à fait simple et lisible, traduction littérale de l’algorithmerécursif. Seule l’adresse de retour est sauvegardée avant l’appel récursif, car il n’y a pas deregistre particulier à sauvegarder à ce moment. Si le calcul nécessiten appels récursifs, lapile va grossir progressivement jusqu’à occupern mots en mémoire, adresses de retoursauvegardéesà chaque appel.Ensuite,nexécutionsde l’instructionret vont remettre la pileà son niveau initial.

L’utilisation de la récursivité dans le cas de ce programme est maladroite, car elle estassez inefficace à l’exécution, vu le grand nombre d’accès mémoire effectués. L’algorithmepeut très simplement être traduit de façon itérative :

fonction int pgcd(int x, int y) tant que (x <> y) faire si (x > y) alors x <- x - y ; sinon y <- y -x ; fin si fin tq ; return x ;fin fonction

Cet algorithme se traduit directement par le programme de la figure V.20.

La leçon à tirer de cet exemple est qu’il ne faut pas abuser de la récursivité dans les


RAM = 0x1000000STACK = 0x1000100

.org 0main set STACK, %r6 ; init pointeur pile set 78, %r1 ; valeur de x set 143, %r2 ; valeur de y call pgcd ; appel pgcd ba * ; arrêt

;; calcule pgcd(x,y) ;; in : x = %r1, y = %r2 ;; out : résultat dans %r3pgcd: cmp %r2, %r1 bne skip ; x=y ? ; x = y : return x mov %r1, %r3 ; val <- x ba retour ; retourskip: bneg sup ; x>y ? ; x < y : préparation de pgcd(x, y-x) subcc %r2, %r1, %r2 ; y <- y - x push %r31 ; sauvegarde @ retour call pgcd ; appel récursif pop %r31 ; restaur. @ retour ba retoursup: ; x > y : préparation de pgcd(x-y, y) subcc %r1, %r2, %r1 ; x <- x - y push %r31 ; sauvegarde @ retour call pgcd ; appel récursif pop %r31 ; restaur. @ retourretour ret

Figure V.19. Programme récursif de calcul du PGCD.Le programmeest très lisible,au prixd’une exécution plus lente.

fonctions de bas niveau, si un algorithme itératif est disponible. Elle est en effet gourmandeen temps et en espace occupé en mémoire. La récursivité est par contre indispensable dansles fonctions de haut niveau, pour des raisons de clarté et de modularité dont la discussionsort du cadre de cet ouvrage.

Enfin on peut noter que lorsqu’on paramètre la compilation d’un programme pourqu’il produise un code plus efficace, il cherche entre autres techniques à dérécursiver lesrécursions terminales comme celles de notre fonction PGCD, afin de les rendre itératives.

7. Techniques de programmation diverses

Multiplication entière par une puissance de 2

Sur notre machine CRAPS, l’opération de multiplication entière occupera un nombre decycles relativement important. Dans le cas assez fréquent où l’on souhaite multiplier parune puissance de 2, on peut utiliser plus efficacement une opération de décalage à gauchesll . À chaque décalage d’un cran à gauche (avec introduction d’un 0 à droite), la valeurdécalée est multipliée par 2,qu’elle soit codée en binaire pur (non signée)ou en complémentà deux (signée).

7. Techniques de programmation diverses 159

RAM = 0x1000000STACK = 0x1000100

.org 0main set 78, %r1 ; valeur de x set 143, %r2 ; valeur de y call pgcd ; appel pgcd ba * ; arrêt

;; calcule pgcd(x,y) ;; in : x = %r1, y = %r2 ;; out : résultat dans %r3pgcd: cmp %r2, %r1 ; tant que x <> y bne skip ; x=y ? ; x = y : return x mov %r1, %r3 ; val <- x ret ; retourskip: bneg sup ; x>y ? ; x < y subcc %r2, %r1, %r2 ; y <- y - x ba pgcdsup: ; x > y subcc %r1, %r2, %r1 ; x <- x - y ba pgcd

Figure V.20. Programme itératif de calcul du PGCD. Il est plus efficace que la versionrécursive car il n’y a plus d’accès en mémoire.

Division entière par une puissance de 2

De la même façon, on peut vouloir calculer le quotient de la division entière d’un nombreN entier signé par un diviseur entier positif égal à une puissance de 2, de façon plus rapideque l’instruction de divisionudivcc .

On utilise pour cela l’instruction de décalage à droitesrl : chaque décalage à droiteest équivalent à une division par 2. Par exemple, si %r1 est positif,srl %r1, 4, %r2 ledivise par 16 et place le résultat dans %r2.

Cette technique ne fonctionne pas si %r1 est négatif, carsrl va introduire des ’0’ parla gauche, et de négatif il va devenir positif, ce qui est absurde.L’instructionsra (shift rightarithmetic) est là pour cela : au lieu de faire rentrer systématiquement un ’0’ par la gauche,elle fait entrer le bit de poids fort du registre en cours de décalage, en préservant ainsi sonsigne. La figure V.21 illustre cette opération.

Ainsi donc sra %r1, 4, %r2 divise %r1 par 16 dans tous les cas, même s’ilest négatif.

8. Langages à structure de blocs et ’stack-frames’

On s’intéresse dans cette section aux problèmes que posent aux compilateurs leslangages à structure de blocs tels que C, Java, etc. lors de la phase degénération de code.Un compilateur est en effet essentiellement un traducteur du langage source vers un langagecible qui est généralement le langage assembleur du processeur visé. On cherche dans cettesection quelles méthodes ces compilateurs mettent en oeuvre de façon systématique pour


0

sra : décalage arithmétique

srl : décalage logique

Figure V.21. Décalage à droite logique et arithmétique.Dans le décalage arithmétique, lesigne de l’opérande est préservé.

implémenter la notion de bloc, ainsi que lors des appels de fonctions.

Implémentation des blocs sous forme de stack-frames

Les programmes écrits dans des langages tels que C et Java sont organisés enblocs, encadréspar des symboles tels que {... } oubegin … end . À l’intérieur de chaque bloc on peutdéclarer de nouvelles variables, dont la portée est limitée au bloc.

Généralement un bloc est associé à une structure de contrôle (bouclefor ou while )ou au corps d’une fonction. On peut néanmoins créer un bloc à tout moment dans unprogramme,et y déclarer les variables localesde son choix : leur portée sera limitée à ce bloc.Ainsi en langage C, on peut écrire le petit programme (inutile) suivant :

int main(int argn,char** args) { int x = 1 ; int y = 10 ; printf("x=%d\n", x) ; { int x = 2 ; int z = x + y ; printf("x=%d\n", x) ; } printf("x=%d\n", x) ;}

À l’exécution, il va produire l’affichage :

x=1x=2x=1

Il y a deux blocs dans ce programme : celui associé au corps de la procéduremain , et unbloc interne situé au beau milieu, et qui n’est là que pour illustrer notre propos. La portéede la variablex située dans le bloc interne est limitée à ce bloc, et elle a temporairement prisla place de la variablex du bloc plus externe. La variablez n’est visible que dans le blocinterne, et la variabley est visible dans les deux blocs.

La pile est utilisée pour mettre en place cette visibilité temporaire des variables.Lors del’entrée dans un bloc, le compilateur crée unstack-framedans la pile, c’est à dire une zone

8. Langages à structure de blocs et ’stack-frames’ 161

de mémoire dans laquelle seront placées les valeurs des variables déclarées dans le bloc. Lesstack-frames associés aux deux blocs de notre programme pourraient être implantés commesur la figure V.22.

z = 12

x = 2

x = 1

prec.

y = 10

prec.pied frame 2

pied frame 1

pile

frame 2

stack

stack

frame 1

Figure V.22. Stack-framesassociés aux deux blocs de code du programme.Chaque variablelocale a sa place dans le stack-frame associé au bloc. On remarquera le pointeur vers lestack-frame précédent.

Un registre est généralement affecté au pointage au pied du stack-frame courant, et lesaccès aux différents éléments du stack-frame se font très simplement par adressage indirectavec déplacement. Par exemple, si on utilise %r29 comme pointeur de stack-frame, on aurale mécanisme d’adressage de la figure V.23.

z = 12

x = 2

x = 1

prec.

y = 10

%r29 prec.%r29

%r29−4

%r29−8

pile

frame 2

stack

stack

frame 1

Figure V.23. Utilisation du registre%r29 comme pointeur à la base du stack-framecourant.Les accès aux variables locales se font par adressage indirect avec déplacement.

Le code assembleur traduisant ce programme pourrait être :


STACK = 0x1000100

main: ;; initialisation pointeur de pile set STACK, %sp

;; création du stack-frame 1 push %r29 ; empile val. prec.de %r29 mov %sp, %r29 ; %r29 reste fixe au pied du stack frame add %sp, 2*4, %sp ; réserve 2 mots dans la pile

setq 1, %r1 st %r1, [%r29-4] ; x <- 1 setq 10, %r1 st %r1, [%r29-8] ; y <- 10

;; création du stack-frame 2 push %r29 ; empile val. prec.de %r29 mov %sp, %r29 ; %r29 reste fixe au pied du stack frame add %sp, 2*4, %sp ; réserve 2 mots dans la pile

setq 2, %r1 st %r1, [%r29-4] ; x <- 2 ;; recherche de la valeur de y par double indirection ld [%r29], %r2 ; %r2 <- "@stack-frame 1" ld [%r2-8], %r1 ; %r1 <- y ld [%r29-4], %r3 ; %r3 <- x addcc %r1, %r3, %r4 ; %r4 <- x + y st %r4, [%r29-8] ; stockage de z ...

La création d’un stack frame consiste essentiellement à réserver la place nécessaire auxvariables locales ; il s’agit d’une simple soustraction sur la valeur de %sp.À chaque créationd’un stack-frame, la valeur courante de %r29 est empilée, et %r29 est positionné au pied dustack-frame.L’accèsà une variable locale à ce bloc se fait directement par référence à %r29 ;par exemple l’accès àx dans le stack-frame 2 se fait par[%r29-4] . Plus délicat est l’accèsà la variabley dans l’expressionz = x + y ; en effety n’appartient pas au bloc courant,mais au bloc de rang inférieur. La référence à la variabley est correcte, mais le compilateurdoit dans ce cas accéder ày par une double indirection, en allant chercher d’abord l’adressedu stack-frame de rang inférieur, puis en faisant à partir de là un accès indirect avecdéplacement. Selon les cas, plusieurs de ces indirections peuvent être nécessaires.

Appel de fonction récursive

Appeler une fonction, c’est créer dynamiquement un stack-frame qui contiendra toutes lesdonnées manipulées par elle, à savoir :

1 les paramètres d’appel,

2 la valeur de retour,

3 les variables locales au bloc principal de la fonction,

4 l’adresse de retour à l’instruction d’appel.

Ainsi, chaque nouvel appel aura son propre contexte de travail sous forme d’un stack-frame,et les appels successifs ne mélangeront pas leurs variables locales et les paramètres d’appel.À la sortie d’un appel de fonction, la valeur renvoyée par la fonction sera récupéréeavant que l’espace du stack-frame ne soit désalloué de la pile (figure V.24). On récupérera

8. Langages à structure de blocs et ’stack-frames’ 163

également l’adresse de retour, valeur de %r31dans le cas de CRAPS.

param #1

pile

param #n

@ prec.

@ retour

val. renvoyee

var. locale #1

var. locale #m

...

frame

stack

...

Figure V.24. Stack-frame créé lors d’un appel de fonction. On y trouve les paramètresd’appel, l’emplacement de la valeur à renvoyer, les variables locales et l’adresse de retour.

9. Programmation des entrées/sorties

Jusqu’ici nous n’avons écrit que des programmes ’autistes’ : ils n’ont effectué aucunéchange avec l’extérieur. Les données sur lesquelles ils travaillaient leurs étaient fourniesdirectement sous forme de zones de mémoire préremplies avec les valeurs du problème et ilsproduisaient des résultats sous forme de données écrites en RAM.

On va considérer que l’interface d’un ordinateur avec l’extérieur est fait au traversd’un ensemble de lignes digitales, chacune d’elle étant à un moment donné une entrée ouune sortie. Si c’est une entrée, le processeur doit être capable de lire son état 0 ou 1 ; si c’estune sortie il doit pouvoir forcer son état à 0 ou à 1. Des amplificateurs ou des atténuateurs enentrée ou en sortie peuvent permettre la lecture ou la commande de courants très forts ou trèsfaibles ; même la commande ou l’acquisition de signaux analogiques rentre dans ce cadre,puisqu’on peut utiliser des convertisseursnumérique/analogiquequi vont faire la conversiond’un monde vers l’autre.

Certaines de ces lignes sont des entrées ou des sorties sans pouvoir changer de nature :ce sera par exemple le cas des sorties des circuits appelés timer/PWM chargés de produiredes signaux paramétrables de forme rectangulaire. Certaines lignes d’usage plus soupleseront des lignes d’entrée/sortie générales,qui pourront être configurées individuellement etpar programme en entrée ou en sortie.

Instructions spéciales d’entrées/sorties

Sur certains processeurs existent des instructions spéciales d’entrées/sorties. Le x86 parexemple possède une instructionIN AL,PORT qui lit un octet dePORTversAL et uneinstructionOUT PORT,ALqui écrit un octet deAL versPORT. PORTdésigne un numéro deport, élément parmi un espace d’adressage spécial, propre aux entrées/sorties. Les écritures


sur des numéros de port particuliers mettent en activité les périphériques associés tels quecontrôleurs USB, contrôleurs de bus PCI Express, etc.

Entrées/sorties mappées en mémoire

Sur d’autres processeurs tels que CRAPS/SPARC, il n’existe pas de telles instructionsspécialisées. Comment alors peuvent-ils faire pour interagir avec l’extérieur ? Ils utilisenten fait un mécanisme appelé entrées/sortiesmappées en mémoire :c’est en lisant et enécrivant à certains emplacements mémoire particuliers, que le processeur va dialoguer avecles périphériques.L’avantage de cette méthode, c’est qu’il n’y a pas d’instructions spécialesà utiliser et que, en CRAPS par exemple, de simplesld et st suffiront. Son inconvénient,c’est de gaspiller certains emplacements de l’espace d’adressage mémoire, qui ne peuventplus être utilisés pour de la véritable RAM ou ROM.

La machine CRAPS, telle qu’elle sera décrite en détail au chapitre suivant, et tellequ’elle est utilisable au travers du simulateur CrapsEmu et de son implantation dans unFPGA, est équipée d’un timer/PWM et de 32 lignes d’entrée/sortie générales. Ces deuxpériphériques sont doncmappés en mémoireet on va décrire maintenant la façon deles programmer.

9.1. Programmation des lignes d’entrées/sorties générales

CRAPS est équipé de 32 lignes d’entrées/sorties générales, qu’on nommeraIOi,0 ≤ i ≤ 31. Par ’générales’, il faut comprendre que chaque ligne peut être configuréeindividuellement en entrée ou en sortie, et ensuite lue ou écrite à volonté. On pourra parexemple les utiliser de la façon décrite figure V.25.

1KVccIO[2]

IO[1]

IO[0]

220

220

CRAPS

1KVccIO[3]

Figure V.25. Exemple d’utilisation des lignes d’entrées/sorties générales de CRAPS.

Les lignesIO[0] et IO[1] doivent être configurées en sorties, et elles servent ici àcommander l’allumage de diodes électroluminescentes : si une de ces lignes est à ’0’, ladiode correspondante est éteinte ; si elle est à ’1’, un courant d’environ 20mA traverse ladiode et l’allume.

Les lignes IO[2] et IO[3] doivent être configurées en entrées, et servent àl’acquisition de l’état de deux interrupteurs.Lorsqu’un des interrupteurs est ouvert, la lignecorrespondante lit ’1’(car la résistance de 1K induit un courant entrant de 5mA si Vcc=5v) ;s’il est fermé elle lit ’0’.

9. Programmation des entrées/sorties 165

Adresses mémoire utilisées

Dans la configuration que nous allons décrire, les lignes d’entrées/sorties de CRAPS sontmappéesaux adresses de 0x600000 à 0x60000C selon le tableau de la figure V.26.

adresse W opération

0x600000 0 lire l’état des entrées

0x600000 1 écrire sur les sorties

0x600004 0 lire configuration lignes

0x600004 1 configurer les lignes

0x600008 0 lire interruptions mémorisées

0x600008 1 raz des interruptions mémorisées

0x60000C 0 lire sens du front d’interruption (0 = front montant)

0x60000C 1 écrire sens du front d’interruption

Figure V.26. Tableau de configuration et d’utilisation des entrées/sorties de CRAPS. W=1indique une écriture.La configuration des lignes se fait par écriture en 0x600004 ; la lectureet l’écriture des lignes se fait par lecture et écriture à l’adresse 0x600000. La lecture etl’écriture en 0x600008 et 0x60000C concernent la gestion des interruptions (section 10).

Les valeurs 0x600000, 0x600004 etc. ne dépendent pas du processeur CRAPS, maisde la façon dont il est interfacé avec les circuits mémoire et d’entrées/sorties. On détailleracomplètement cet aspect de ce qu’on appelle ledécodage des adressesau chapitre suivant.Par contre,on reportera à la section 10 l’utilisation des lignes d’entrées/sortiescomme lignesd’interruption, au travers de la lecture et de l’écriture aux adresses 0x600008 et 0x60000C.

Configuration des lignes

D’après le tableau V.26, la configuration se fait en écrivant à l’adresse 0x600002 un mot de32 bitsval[31..0] .La règle de configuration est simple :sival[i] vaut 0, la ligneIO[i]

sera configurée en entrée ; s’il vaut 1 la ligne sera configurée en sortie.

Ainsi pour configurer les lignesIO[0] et IO[1] en sorties et toutes les autres enentrées, on écrira le mot mémoire000..00001132 en 0x600004, par exemple avec le codesuivant :

BASEIO = 0x600000 ; adresse de base des IO

set BASEIO, %r1 set 0b11, %r2 ; IO[0..1] sorties, les autres en entrées st %r2, [%r1+4] ; écriture configuration

Lecture/écriture sur les lignes

Pour lire l’état des entrées, il suffit de lire en 0x600000, et de tester dans le mot lu les bitsdes rangs correspondants aux entrées. Pour positionner l’état des sorties, il suffit d’écrireen 0x600000 un mot dont les bits correspondent aux valeurs que l’on souhaite placer surles lignes.


Par exemple sur le schéma de la figure V.25, pour lire l’état de l’interrupteur situé surla ligne IO[2]et allumer la diode située sur IO[0] si cet interrupteur est ouvert (IO[2]=1) onécrira le code suivant :


set BASEIO, %r1 set 0b0011, %r2 ; IO[0..1] sorties, IO[2..3] entrées st %r2, [%r1+4] ; écriture configuration

ld [%r1], %r3 ; lecture des IO en entrées andcc %r3, 0b100, %r3 ; isolation du bit 2 srl %r3, 2, %r3 ; déplacement de ce bit au rang 0 st %r3, [%r1] ; écriture sur les IO en sorties

Exemple : programmation d’un jeu de ’pile ou face’

Le programme de la figure V.27 exploite le câblage des entrées/sorties de la figure V.25, etfait allumer en alternance l’une des deux LEDs situées sur IO[0]et IO[1]. Lorsque le joueurappuie sur l’interrupteur situé sur IO[2], l’état des LEDs se fige, faisant apparaître une desdeux combinaisons.


set BASEIO, %r1 set 0b011, %r2 ; IO[0..1] sorties, IO[2] entrée st %r2, [%r1+4] ; écriture configuration

setq 0b10, %r4 ; état des LEDs st %r4, [%r1] ; écriture état des LEDsloop ld [%r1], %r3 ; lecture des IO en entrées andcc %r3, 0b100, %r3 ; isolation du bit 2 bne loop ; attend qu’il vaille 1 ;; interrupteur ouvert : on inverse l’état des LEDs xorcc %r4, 0b11, %r4 ; inversion par xor st %r4, [%r1] ; écriture état des LEDs ba loop ; reboucle éternellement

Figure V.27. Programme d’un jeu de ’pile ou face’. Les LEDs #0 et #1 s’allument enalternance,et un appui sur l’interrupteur #2 fige la configuration.

Les commentaires du programme parlentd’eux-mêmes. On notera l’inversion par lexor des deux bits de poids faibles de l’état des LEDs dans %r4.

9.2. Programmation du timer/PWM

Principe général

CRAPS possède untimer/PWMqui lui permet de générer sur une ligne de sortie dédiée,dessignaux rectangulaires dont la période et le rapport cyclique sont programmables.La formedu signal est donnée figure V.28.


N

P

t

horloge timer

DT = periode

Figure V.28. Forme et paramètres du signal de sortie du timer/PWM de CRAPS.

Les usages d’un timer/PWM sont nombreux. Dans un systèmemulti-tâches, lasortie d’un timer sert à déclencher une interruption qui effectue la commutation entreles différentes tâches. Il fonctionne à une fréquence d’environ 50 hertz, ce qui donne àl’utilisateur l’illusion que ses différents programmes fonctionnent en parallèle.

On s’en sert également pour contrôler avec précision l’énergie communiquée à unappareil de type lampe ou moteur à courant continu (après amplification), celle-ci étant

proportionnelle au rapport cycliqueP − NP

.

Registres de commande

Il s’agit d’un timer 16 bits, c’est à dire que les paramètresP et N sont codés sur 16 bits,et représentent un nombre de cycles de l’horloge du timer. L’horloge du timer est obtenueà partir de l’horloge générale, dont la fréquence peut éventuellement être prédivisée parun facteurpredivcodé sur 4 bits, d’où 16 valeurs de prédivision. Sif est la fréquence del’horloge générale, la fréquence du timer sera programmable parmi les 16 valeurs :f , f /2, …,f /32768. C’est elle qui définit le pas minimal de fonctionnement du timer.

Le timer possède en interne deux registres qui stockent ces valeurs nécessaires à sonfonctionnement. Ils sont appeléscommande #1etcommande #2(figure V.29).

31 16 15 0

N P

31 01

start

commande #1

registre

commande #2

registreprediv

16

Figure V.29. Structure des registres de commande du timer de CRAPS.

Du point de vue du programmeur, le timer/PWM de CRAPS estmappéaux adresses0x400000 à 0x400008 selon le tableau de la figure V.30.

La configuration du timer se fait par écriture dans le registre de commande #1 pourles valeurs deP et deN, et dans le registre de commande #2 pour la valeur deprediv. Lelancement du timer se fait par écriture d’un ’1’ dans le bit 0 du registre de commande #2.À tout moment du fonctionnement du timer, il peut être arrêté par écriture d’un ’0’ dans



0x400000 0 lire le registre de commande #1 (P + N)

0x400000 1 écrire le registre de commande #1 (P + N)

0x400004 0 lire le registre de commande #2 (prediv + start)

0x400004 1 écrire le registre de commande #2 (prediv + start)

0x400008 0 lire bit d’interruption timer

0x400008 1 raz bit d’interruption timer

Figure V.30. Tableau de configuration et d’utilisation du timer/PWM de CRAPS. W=1 in-dique une écriture.La configuration des valeurs de P et N se fait par écriture en 0x400000 ;le lancement du timer et la valeur de prédivision de l’horloge se font par écriture en0x400004.La lectureet l’écritureen 0x400008 concerne l’utilisationdu timer commesourced’interruption (voir section 10).

ce bit.

Si par exemple on souhaite générer un signal carré de période 100 cycles d’horloge, onécrira le code suivant :

BASETIMER = 0x400000 ; adresse de base du timer

set BASETIMER, %r1 ; %r1 = base timer set 0x00320064, %r2 ; N=50 & P=100 st %r2, [%r1] ; écriture commande #1

set 0x00000001, %r2 ; prediv=0 & start=1 st %r2, [%r1+4] ; écriture commande #2 ;; ----> lancement du timer ;; ... st %r0, [%r1+4] ; arrêt du timer ld [%r1], %r3 ; lecture du compteur

%r1 pointe au début de la zone mémoire [0x400000,400008[ et toutes les référencesmémoire sont faites par rapport à lui : [%r1] pour commande #1, [%r1+4] pourcommande #2. La valeur écrite dans commande #1 est 0x00320064, soit N=50 et P=100.On va voir que le facteur de prédivision est ici de 1, donc la période sera bien de 100 cyclesd’horloge, et le timer sera à 0 durant les 50 premiers cycles, puis à 1 les 50 cycles suivants.La valeur écrite dans commande #2 est 0x00000001, soitprediv=0etstart=1 : le facteur deprédivision est 1, et la mise à 1du bitstartprovoque le démarrage du timer. Plus loin dans leprogramme, le timer est arrêté par mise à 0 de ce bit, et la valeur courante du compteur estlue et stockée dans %r4.

Exemple d’utilisation : commande d’un servo-moteur

Un servo-moteur est composé d’un moteur à courant continu avec un ensembled’engrenages démultiplicateurs qui lui donnent un couple très élevé. Il est muni d’uneélectronique de commande qui permet de contrôler avec précision, non pas la vitesse derotation, mais la position angulaire de son axe, qui n’a un débattement que de 180° (figureV.31).


0 degrés180 degrés

Figure V.31. Servo-moteur. La rotation de l’axe est très démultipliée et a un couple élevé.La commande ajuste la position angulaire de l’axe,qui peut varier de 0° à 180°.

La commande se fait sur un seul fil, à la norme TTL (0 ou 5v), et consiste en uneimpulsion périodique dont la largeur code la position angulaire de l’axe (figure V.32).

1 ms < d < 2 ms

période 20ms

1 ms = 0 degrés

2 ms = 180 degrés

Figure V.32. Forme du signal de commande d’un servo-moteur.Il est périodique de période20ms ; l’impulsion a une largeur comprise entre 1ms et 2ms,qui code la position angulairede l’axe entre 0° et 180°.

La période du signal reste constante à 20ms (valeur non critique) ; ce qui varie, c’estla largeur de l’impulsion, entre 1ms et 2ms. Dans cet intervalle il y a proportionnalité entrela largeur de l’impulsion et la position angulaire, de 0° pour une largeur de 1ms à 180° pourune largeur de 2ms.

Détermination de la fréquence de l’horloge du timer

On souhaite avoir environ 1000 pas de précision sur la commande, c’est à dire qu’onsouhaite faire varier la largeur de l’impulsion de 1 ms à 2 ms par pas de 1/1000 ms. C’estdonc cette valeur de 1/1000 ms qui doit être la période de base du timer :DT ∼− −610 s.

On suppose que l’horloge générale est de 50 MHz, soit une période deDH = 2· −810 s.Le rapport de prédivision de DH doit donc êtreDT / DH = 50. La puissance de 2 la plusproche est 64, soit une valeur depredivde 6. Finalement la véritable fréquence de l’horlogesera :

DT = 64DH = 1, 28· −610 s

P restera constant égal à 20 ms /1, 28· −610 s = 15625pour assurer la période générale de20 ms du signal transmis au servo-moteur,etN variera entre 12501et 14063pour faire varierla largeur de l’impulsion entre 1 ms et 2 ms, par 1562 pas.

La figure V.33 donne un sous-programme de positionnement du servo-moteur, auquelon donne comme paramètre l’angle de positionnement dans %r1 en dixièmes de degrés (de0 à 1800).


;; commande de servo-moteurBASETIMER = 0x400000 ; adresse de base du timer

.org 0 ;; main : exemple d’utilisationmain set 900, %r1 ; %r1 <- 90 degrés call cmdservo ba *

;; sous-programme de commande du servo ;; in : %r1=angle en dixièmes de degréscmdservo umulcc %r1, 1561, %r3 ; %r3 = 1561 * angle udivcc %r3, 1800, %r3 ; %r3 = 1561*angle/1800 set 12501, %r1 add %r3, %r1, %r3 ; %r3 = 12501+1561*angle/1800 sll %r3, 16, %r3 ; décalage de 16 positions à gauche set 15625, %r1 ; valeur de P or %r1, %r3, %r3 ; fusion de N et P dans %r3 set BASETIMER, %r2 ; %r2 = base timer st %r3, [%r2] ; écriture commande #1 set 0b1101, %r3 ; prediv=6, start=1 st %r3, [%r2+4] ; écriture commande #2 ret

Figure V.33. Sous-programme de commande de servo-moteur.

Le sous-programmecmdservo effectue d’abord une mise à l’échelle de la valeur de%r1 (de 0 à 1800) : une transformation affine remplace %r1 par une valeur entre 12501 et14063, qui est la valeur qui doit être placée dans le registre N du timer/PWM.On notera queles constantes 1561et 1800 ont été utilisées directement comme constantes immédiates dansles instructionsumulcc %r1, 1561, %r3 et udivcc %r3, 1800, %r3 car elles sontcodables sur 13 bits (voir format des instructions en section 2.4). Cela n’est pas le cas parcontre pour la constante 15625, qui ne tient pas sur 13 bits et qui doit d’abord être mise dansun registre par une instruction synthétiqueset .

On comprend tout l’intérêt de commander un servo-moteur par un tel circuittimer/PWM : le signal périodique est généré de façon autonome et le processeur n’abesoin d’intervenir que lors d’un changement de position ou d’une demande d’arrêt ou delancement, qui se traduisent par une simple écriture en mémoire.

10. Programmation des exceptions

10.1. Définitions

Une exception est un événement exceptionnel qui intervient au cours dufonctionnement du processeur.La prise en compte d’une exception se traduit par l’exécutiond’un sous-programme qui lui est associé, appelégestionnaire d’exception. On pourrait direqu’une exception est un appel de sous-programme inattendu.

On classe les exceptions en deux groupes, selon que leur cause est interne ou externe.

10. Programmation des exceptions 171

Les traps

Lestrapssont des exceptions à cause interne, provoqués par l’exécution d’une instructionpar le processeur. Mieux qu’un long discours, la liste des traps du processeur CRAPS feracomprendre leur nature :

• instruction illégale. Le processeur tente d’exécuter une instruction dont le codemachine ne correspond à aucune instruction connue.

• bus error. Le processeur tente d’effectuer un accès mémoire à une adresse où aucunemémoire n’est implantée.

• division par 0. Le processeur exécute une instruction de division et le diviseurest nul.

• erreur d’alignement. Le processeur tente d’effectuer un accès mémoire à une adressequi n’est pas un multiple de 4 si par exemple il s’agit d’un processeur 32 bits.La plupartdes processeursexigent en effet que la lecture ou l’écriture des mots respectent de tellescontraintes d’alignement.

• instruction privilégiée. Le processeur tente d’exécuter une instruction privilégiée(réservée aux programmes en mode superviseur) mais il n’est pas en modesuperviseur.

On dit de telles exceptions qu’elles sontsynchrones, car elles surviennent à un endroitprévisible du programme. Elles correspondent généralement à un fonctionnement incorrectdecelui-ci et conduisent souvent à l’arrêt de la tâche associée.

Les traps sont ainsi l’équivalent matériel des exceptions logicielles, qui elles aussise déclenchent en cas d’exécution incorrecte d’instructions, et qui ont un gestionnaireassocié.

Les interruptions

Une interruption est une exception à cause externe, généralement liée à un événementd’entrée/sortie.Par exemple :

• la lecture de données par un disque est terminée et le contrôleur de disques envoie auprocesseur une interruption pour l’en informer.

• un paquet de réseau vient d’arriver.

• un événement clavier ou souris vient de se produire.

• un changement est intervenu sur une des lignes d’entrées/sorties.

• un événement est intervenu sur la chaîne USB.

Les interruptions sont ditesasynchrones, car elles surviennent à des moments totalementimprévisibles du fonctionnement du processeur, et non en rapport avec des instructionsprécises. Le processeur est prévenu de l’occurrence de l’interruption par l’activation d’uneligne externe spécifique, souvent commune à plusieurs ou à toutes les interruptions. C’estseulement ensuite que le type de l’interruption sera identifié, et qu’un sous-programme


associé sera exécuté, et ce d’une façon qui devra rester transparente pour le programmeprincipal qui était en cours d’exécution à ce moment. Par exemple lorsque vous appuyezsur une touche de votre clavier d’ordinateur, aucun programme n’attend spécifiquementet activement cette frappe. Lors de la frappe, une interruption est générée par le contrôleurde clavier vers le processeur, etcelui-ci suspend le programme en cours d’exécution, etappelle un sous-programme gestionnaire de cette interruption, dont le rôle va être d’obtenirdu contrôleur de clavier le code de la touche frappée et de le placer dans un buffer situé auniveau du système d’exploitation. L’exécution de ce sous-programme sera très rapide et onverra qu’elle sera faite de façon transparente pour le programme qui a été interrompu.

Dans CRAPS, il n’y a que deux sources d’interruption : le timer et les lignesd’entrées/sorties. On pourra programmer le timer pour qu’il déclenche une interruptionà chaque front montant de sa sortie, et cela permettra par exemple d’implanter unscheduler de tâches ou une horloge temps réel. On pourra également programmer leslignes d’entrées/sorties pour déclencher une interruption à l’arrivée d’un front montant oudescendant (sens programmable au choix) sur une ligne configurée en entrée.

Une interruption = un coup de sonnette

Pour mieux faire comprendre les traps et les interruptions, on peut employer uneanalogie domestique. Supposons que nous soyons en train de faire un gâteau, en suivantles instructions d’une recette : ce sera l’équivalent du programme principal en coursd’exécution. La plupart des instructions de la recette sont sans problème : remuer la pâte,etc. Un petit nombre d’entre-elles peuvent mal se passer : si on doit casser un oeuf maisqu’il n’est pas frais ; si on doit mettre une pincée de sel mais qu’on n’a plus de sel, etc. Cesproblèmes spécifiques sont associés à des instructions spécifiques, ce sont l’équivalent destraps. Le plus souvent, leur prise en compte consistera à abandonner la tâche en cours.

Supposons maintenant que pendant que nous faisons cette recette nous attendions lavisite du facteur, mais que notre sonnette soit en panne. Comme le moment précis de cettevisite n’est pas défini, cela va nous obliger à interrompre sans cesse notre recette pour allerregarder par la fenêtre. Cela sera pénalisant pour la recette, mais aussi pas très efficace : lefacteur peut très bien être venu et reparti en pensant qu’il n’y avait personne, si on laissepasser trop de temps entre deux coups d’oeil. Avec une sonnette, qui joue le rôle d’uneligne d’interruption, on peut réaliser la recette sans penser sans cesse au facteur. Si un coupde sonnette survient, on terminera l’instruction en cours, (par exemple, il faut terminer decasser un oeuf si on a déjà commencé)et on cochera sur la recette l’endroit où on s’est arrêté.On réagira ensuite à l’interruption par une procédure adaptée :aller à la porte, ouvrir, saluer,récupérer éventuellement des données, etc. De retour de cette procédure, dont le traitementaura été court, on reprendra la recette à l’instruction qui suit celle qu’on avait cochée.

Cette analogie permet même de présenter le problème des niveaux de priorité entreexceptions. Comment doit-on faire si par exemple le téléphone sonne alors qu’on est entrain de répondre au visiteur à la porte ? Si on juge que le téléphone est plus prioritaire quela porte d’entrée, alors on interrompra le dialogue en cours avec le visiteur pour effectuerla procédure associée au téléphone. Une fois qu’on aura fini de répondre, on reprendrale dialogue avec le visiteur là où on l’avait arrêté, pour finalement revenir au programmeprincipal (la recette), dont l’exécution n’aura pas été perturbée.


Niveaux de priorité

Ainsi, à chaque exception (trap ou interruption) est associé unniveau de priorité, codégénéralement sous forme d’un nombre entier. Par ailleurs le processeur entretient dans unregistre d’état une valeur de niveau courant d’exécution. Lorsque le processeur exécuteun programme à un niveaup, il ne peut être interrompu que par une exception de niveauq supérieur àp. Lorsque cette interruption est prise en compte et que son gestionnaire estexécuté, le processeur élève son niveau d’exécution àq de façon à ne plus pouvoir êtreinterrompu que par des exceptions de niveau supérieur àq. Lorsque le processeur sort dugestionnaire de cette exception, il reprend le niveau d’exécution qu’il avait avant l’appel. Leprogramme principal s’exécute au niveau 0, et il est par conséquent interruptible par toutesles exceptions.

La figure V.34 montre un exemple de scénario d’exécution du programme principal etde deux gestionnaires d’exception de niveaux de priorité différents.

gestionnaireexcep.#13

gestionnaireexcep.#25

programmeprincipal

priorité

6

3

0

Figure V.34. Niveaux de priorités et gestionnaires d’exceptions. Le programme principalest interrompu par l’exception#25,qui lui même est interrompu par l’exception#13;chaqueinterruption est transparente pour celui qui est interrompu.

Dans CRAPS, il y a 16 niveaux de priorité, codés sous forme d’un entier de 4 bits. Leniveau d’exécution courant du processeur est stocké dans le champPIL du registre %psr(voir section 2.2). Au reset, le niveau d’exécution PIL est à 0.

Numéro de l’exception

À chaque exception est également associé un numéro de type, unique par type d’exception,qui va servir à localiser l’adresse de son gestionnaire d’exception.Ce numéro n’a en principepas de rapport direct avec le niveau de priorité de l’exception.

Dans CRAPS, comme dans le SPARC, le numéro de type d’exception est codé sur 8bits, et il y a donc 256 sortes d’exceptions différentes.Seul unsous-ensemble des exceptionsdu SPARC a été implémenté, donné figure V.35.

Le cas dereset est particulier : il est listé dans le tableau comme l’exception laplus prioritaire, mais elle n’a pas de numéro. En fait, l’occurrence d’unreset matérielva provoquer la remise à zéro de tous les registres, y compris %pc, et le contrôle vareprendre en mode non superviseur à l’adresse 0, avec un niveau d’exécution de 0, ce qui


exception priorité numéro de type (tt)

reset 15 voir texte

bus error 14 14

instruction privilégiée 13 13

instruction illégale 12 12

division par zéro 11 11

erreur d’alignement 10 10

interruption timer 8 8

interruption entrées/sorties 7 7

Figure V.35. Tableau des exceptions,de leurs priorités et de leurs numéros de type.

est le comportement souhaité. Le reset est considéré comme une exception sur un plan’théorique’, mais il est géré d’une façon différente en pratique.

Par ailleurs,afin de simplifier la structure dusous-sytème d’exceptions, les numéros detype d’exception et le niveau de priorité ont été rendus égaux.

Gestionnaires d’exceptions

Lorsqu’une exception est prise en compte, un sous-programme appelégestionnaired’exceptionouhandler d’exceptionest appelé, associé au numéro de typett de l’exception.Il existe généralement unetable de vecteursd’exceptionqui contient les adresses de tous lesgestionnaires d’exception, classée par numéro de typett. Cette table est initialisée lors duchargement du système d’exploitation, ou elle peut être en ROM.

Dans CRAPS, lorsqu’une exception est prise en compte, son numérott est copié dansle champtt du registre%tbr. On rappelle figure V.36 sa structure, déjà présentée section2.2. L’adresse ainsi formée est unique par numérott, et les adresses possibles sont espacées

41131 012

TBA (trap base address) tt zéros

TBA = poids forts adresse table des exceptionstt = trap type = numero de l’exception

Figure V.36. %tbr (Trap Base Register).

de 16 en 16, puisque les 4 bits de poids faibles valent 0. À cette adresse sont placés, nonpas l’adresse du gestionnaire comme c’est le cas dans beaucoup de processeurs, mais lespremières instructions elles-mêmes du gestionnaire associé à l’exception. Comme il n’y aa-priori la place que pour 4 instructions (16 octets), celui-ci doit très vite effectuer un sautvers un autre emplacement en mémoire pour continuer son exécution.

10.2. Prise en compte d’une exception en CRAPS

On va maintenant décrire exactement comment les exceptions sont prises en comptepour le processeur CRAPS, sachant que la procédure est globalement la même pour lesautres processeurs, mais que de nombreux détails peuvent varier. Celle du CRAPS est une


simplification de celle du SPARC, mais en conserve les traits les plus importants.

Conditions de prise en compte d’une exception

Une exception est prise en compte si :

• ET = 1 (trap enable = 1) et

• le niveau de priorité de l’exception est strictement supérieur au niveau courantd’exécution. (champ PIL du registre %psr)

Si une exception se produit pendant que ET = 0, elle est ignorée et non mémorisée ; tout sepasse comme si elle n’avait jamais eu lieu. Si une exception se produit pendant que ET = 1mais que son niveau est inférieur ou égal au niveau d’exécution courant, elle est mémoriséeet sera prise en compte lorsque le niveau d’exécution redescendra au niveau ou au dessousduniveau de l’exception. Par contre si durant cette période une exception de même numéro seproduit, elle sera perdue car celle qui est mémorisée en attente empêchera la mémorisationde la nouvelle.

Procédure matérielle de prise en compte de l’exception

Une fois les conditions de prise en compte réunies, la procédure suivant, ininterruptible, estexécutée automatiquement par le processeur (hardware) :

1 le processeur termine l’instruction en cours.

2 le processeur passe en mode superviseur : S← 1. Le gestionnaire d’interruption auraainsi accès à toutes les instructions.

3 %pc et %psr sont sauvegardés dans la pile.

4 le niveau de priorité de l’exception est copié dans le champ PIL du registre %psr,élevant ainsi le niveau d’exécution du processeur.

5 l’adresse du gestionnaire d’exception est calculée par la formule : %tbr + 16 * numérode type.

6 le contrôle est passé à l’adresse du gestionnaire de l’exception : %pc← adressegestionnaire. On notera qu’à cet endroit, il n’y a la place que pour 4 instructions etqu’un saut vers un autre emplacement est nécessaire.

Contenu du gestionnaire d’exception

L’écriture d’un gestionnaire d’exception est une tâche délicate ; elle est généralementréservée aux concepteurs des systèmes d’exploitation. Sur certainesplates-formes commeLinux, il est possible à un programmeur averti de le faire ; c’est bien sûr possible aussi surla machine CRAPS.

S’il s’agit d’un gestionnaire de trap, c’est à dire d’une exception provoquée parl’exécution incorrecte d’une instruction d’un programme, le code associé va généralementconsister en l’abandon de la tâche en cours. L’écriture de ce code sort du cadre de cettediscussion.


S’il s’agit du gestionnaire d’une interruption, il faut faire en sorte que son exécutionsoit transparente pour le programme en cours de fonctionnement. Cela nécessite plusieursconditions :

• tous les registres que ce gestionnaire va utiliser doivent être sauvegardés (dans la pile)dès l’entrée dans le gestionnaire et doivent être restaurés juste avant d’en sortir.

• le gestionnaire doit être terminé par l’instruction RETE.

L’instruction RETE dépile les valeurs de %pc et %psr qui avaient été empiléesautomatiquement par le processeur lors de la prise en compte de l’interruption, puisincrémente %pc de 4. Les deux aspects cruciaux à comprendre sont, d’une part que larestauration de %pc permet le retour à l’instruction qui suit celle qui a été interrompue,d’autre part que la restauration de %psr permet de retrouver les valeurs de départ du niveaud’exécution et du bit superviseur. Au retour du gestionnaire d’exception, le programmeprincipal n’a aucun moyen de savoir qu’il a été interrompu,car rien n’a changé pour lui entrele moment de l’interruption et celui du retour.

10.3. Exemple 1 : horloge temps réel

À titre d’exemple, on va mettre en place une horloge qui permettra à un programmed’obtenir une heure d’une précision parfaite, sous forme d’une fonctiongetTimeMillis .À chaque appel de cette fonction, on obtiendra dans %r1 le nombre de millisecondesécoulées depuis la mise en route de la machine ; cette valeur s’incrémentera de façonexacte entre chaque appel, sans que le programme principal en cours d’exécution ne s’enoccupe explicitement.

On va pour cela programmer le timer pour qu’il fournisse des impulsions toutes lesmillisecondes, et le déclarer comme source d’interruption. C’est en effet possible dansCRAPS comme on peut le voir dans le tableau de la figure V.35 et cette interruption a lenuméro 8 et la valeur de priorité 8.

10.4. Exemple 2 : programmation d’un scheduler de tâches en CRAPS

La figure V.38 montre un programme complet descheduler de tâchespour CRAPS,qui utilise le timer pour fournir une source d’interruption régulière pour effectuer lacommutation d’une tâche à la suivante. Le programme est initialisé avec 4 tâchesprog0 ,…prog3 qui effectuent infiniment l’inversion et la désinversion d’une chaîne de caractères ;chacune d’elles possède son propre espace de pile.

Le scheduler entretient le numéro de la tâche en cours d’exécution, qui sert d’indexdans une table de pointeurs de pile, TABSP. Lors de l’arrivée d’une interruption timer, legestionnaire de cette exception sauvegarde le contexte d’exécution de la tâche qui va êtresuspendue dans la propre pile de la tâche.%pc et %psr ont déjà été sauvegardés par letraitement de l’exception ; il sauvegarde ensuite tous les registres.Le pointeur de pile de cettetâche en cours de suspension est sauvegardé dans TABSP, le numéro de la tâche courante estincrémenté (modulo 4) et le pointeur de pile de la tâche qui est réveillé est lu. Son contexteest relu à partir de sa propre pile et l’instruction finalerete va restaurer dans%pc l’adressecourante d’exécution de cette tâche.


RAM = 0x1000000 ; début de la RAMSTACK = 0x1000100 ; sommet de la pileTIMER_BASE = 0x400000 ; adresse de base du timerTT_TIMER = 8 ; numéro de type de l’interruption timer

set STACK, %sp ; initialise sommet de pile ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; installe la table des exceptions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; set TABEXCEP, %r1 wrtbr %r1 ; initialisation champ TBA de %tbr ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; initialisation timer ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; set BASETIMER, %r1 ; %r1 = base timer set 0x00320064, %r2 ; N=50 & P=100 st %r2, [%r1] ; écriture commande #1 set 0x00000001, %r2 ; prediv=0 & start=1 st %r2, [%r1+4] ; écriture commande #2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; boucle infinie ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;loop call getTimeMillis ba loop ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; fonction getTimeTicks : renvoie dans %r1 le nombre ; de millisecondes écoulées depuis reset ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;getTimeMillis set TIME, %r1 ld [%r1], %r1 ret ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;TABEXCEP ; table des exceptions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .org TABEXCEP + 2*TT_TIMER ; adresse handler timer .word HDL_TIMER ; branchement à un endroit plus spacieux ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; timer handler : incrementation du mot mémoire TIME ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;HDL_TIMER: ;; sauvegarde de %r1 et %r2 subcc %sp, 2, %sp st %r1, [%sp] subcc %sp, 2, %sp st %r2, [%sp] set BASETIMER, %r1 setq 1, %r2 st %r2, [%r1+8] ; raz int. timer set TIME, %r1 ld [%r1], %r2 ; lecture de TIME inc %r2 ; incrémentation st %r2, [%r1] ; stockage de la valeur incrémentée ;; restauration de %r2 et %r1 ld [%sp], %r2 addcc %sp, 2, %sp ld [%sp], %r1 addcc %sp, 2, %sp rete .org RAMTIME .word 0

Figure V.37. Programme d’horloge temps réel par interruptions.


RAM = 0x1000000STACK0 = 0x1000100STACK1 = 0x1000200STACK2 = 0x1000300 ;; installe la table des vecteurs d’exceptions set 0xF000, %sp set TABEXCEP, %r1 wrtbr %r1 ;; installe les tâches à exécuter set prog1, %r1 setq 1, %r2 call creer_tache set prog2, %r1 setq 2, %r2 call creer_tache ;; lancement du timer qui cadence le scheduling set 0x4000, %r2 ; %r2 = timer base address set 1000, %r1 ; periode = 1000 st %r1, [%r2+2] set 0b11, %r1 ; start + cyclic st %r1, [%r2] ; -> lance le scheduler ; lancement de la première tâche set TABSP, %r1 ld [%r1], %sp ; lecture de son %sp ba prog0 ;;; cree une nouvelle tâche de numéro %r2 et ;;; d’adresse de depart %r1 creer_tache set TABSP, %r3 addcc %r2, %r2, %r4 ld [%r3+%r4], %sp ; lecture du %sp subcc %sp, 2, %sp st %r1, [%sp] ; empilement %pc setq 7, %r5 ; empile 7 x 0loop subcc %sp, 2, %sp st %r0, [%sp] dec %r5 bne loop st %sp, [%r3+%r4] ; sauve %sp dans TABSP ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;TABEXCEP ; exception table ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .org TABEXCEP + 2*3 ; handler timer jmp HDL_TIMER

HDL_TIMER: ; %pc et %psr deja empiles dans la pile ; du process en cours ; sauvegarde dans cette pile ; les registres %r1..%r5,%r7 addcc %sp, -2, %sp st %r1, [%sp] addcc %sp, -2, %sp st %r2, [%sp] addcc %sp, -2, %sp st %r3, [%sp] addcc %sp, -2, %sp st %r4, [%sp] addcc %sp, -2, %sp st %r5, [%sp] addcc %sp, -2, %sp st %r7, [%sp] ; raz int.timer set BASETIMER, %r1 setq 1, %r2 st %r2, [%r1+8] ; sauvegarde du %sp de la tâche courante ; dans TABSP set NUMPROC, %r1 ld [%r1], %r2 addcc %r2, %r2, %r3 set TABSP, %r4 st %sp, [%r4+%r3]

; incrémentation numéro tâche courante modulo 3 inc %r2 subcc %r2, 3, %r0 bneg sav clr %r2sav st %r2, [%r1] ; restauration depuis TABSP du %sp de ; la tâche suivante addcc %r2, %r2, %r3 ld [%r4+%r3], %sp

; restauration des registres %r1..%r5,%r7 ; depuis la nouvelle pile ld [%sp],%r7 addcc %sp, 2, %sp ld [%sp],%r5 addcc %sp, 2, %sp ld [%sp],%r4 addcc %sp, 2, %sp ld [%sp],%r3 addcc %sp, 2, %sp ld [%sp],%r2 addcc %sp, 2, %sp ld [%sp],%r1 addcc %sp, 2, %sp ; restauration des anciens %psr et %pc ; donc retour de la d’ou on etait parti rete

;;;;;;;;;;; TACHES UTILISATEURS ;;;;;;;;;;

;;;;; tâche #0 : inversion et desinversion de STR0prog0: set STR0, %r1l0: call inverse ba l0



inverse: clr %r3 ; i <- 0 sethi 0,%r4rev1 ldub [%r1+%r3], %r4 tst %r4 ; tq (str[i]<>0) be rev2 inc %r3 ; i <- i + 1 ba rev1 ; fin tqrev2 clr %r5 ; j <- 0 dec %r3 ; i <- i - 1rev3 cmp %r5, %r3 bpos outrev ; tq (i>j) ldub [%r1+%r3], %r4 ; x <- str[i] ldub [%r1+%r5], %r2 ; y <- str[j] stb %r4, [%r1+%r5] ; str[i] <- y stb %r2, [%r1+%r3] ; str[j] <- x dec %r3 ; i <- i - 1 inc %r5 ; j <- j + 1 ba rev3 ; fin tqoutrev ret

.org RAM ; numero de la tâche couranteNUMPROC .word 0 ; table des tâchesTABSP .word STACK0, STACK1, STACK2

; chaînes pour inversion en RAMSTR0 .byte ’abcdefg’,0STR1 .byte ’123456789’,0STR2 .byte ’xyz’,0

Figure V.38. Programme complet du scheduler de tâches.



11.1. Exercice 1 : multiplication programmée

Énoncé

Écrire unsous-programme qui effectue la multiplication de deux nombres non signés de 16bits placés dans les poids faibles de %r1 et %r2 respectivement, avec un résultat sur 32 bitsdans %r3.

Solution

On pourrait mettre en place une boucle qu’on effectuerait %r1 fois, et dans laquelle oncumulerait %r2 dans %r3. Cette méthode serait simple, mais particulièrement inefficacepour de grandes valeurs de %r1.On va plutôt utiliser une méthode inspirée de la figure II.46,dans laquelle on prend les bits de %r2 un par un en commençant par le poids faible, et oncumule dans %r3 (initialisé à 0) la valeur de %r1, que l’on décale vers la gauche à chaqueétape. Cela correspond à l’algorithme suivant :

; calcul du produit A x Brésultat <- 0 ;tant que (B <> 0) faire b0 <- poids_faible(B) ; décaler B d’un bit vers la droite ; si b0 = 1 faire résultat <- résultat + A ; fin si décaler A d’un bit vers la gauche ;fin tq

Le programme donné figure V.39 est une traduction littérale de l’algorithme. On notera letestbne noadd qui n’est pas fait immédiatement après l’instructionandcc %r2, 1, %r0

qui positionne le flag Z ; cela est possible car l’instruction qui la suitsrl %r2, 1, %r2

ne modifie pas les flags.

11.2. Exercice 2 : système de sécurité

Énoncé

On souhaite utiliser les lignes d’entrées/sorties de CRAPS pour réaliser un système de miseen marche de machine dangereuse. Les lignes IO[0] et IO[1] seront configurées en entrées ;on supposera qu’elles sont reliées à des boutons poussoirs appelés A et B respectivement,équipés d’un dispositif anti-rebond.La ligne IO[2]sera configurée en sortie,et commanderala mise en marche de la machine. On demande d’écrire un programme qui fonctionne enpermanence,et qui déclenche la mise en marche de la machine lorsque la procédure suivanteest respectée :

1 A et B doivent être relâchés initialement ;

2 appuyer sur A,

3 appuyer sur B : la machine se met en marche.


main ;; programme principal de test set 17, %r1 ; A <- 17 set 14, %r2 ; B <- 14 call mulu16 ; calcul de A x B ba * ; arrêt

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; multiplication non signé ;; calcule %r1.L x %r2.L, résultat dans %r3 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mulu16 clr %r3 ; résultat <- 0loop tst %r2 ; tant que B <> 0 be fin ; andcc %r2, 1, %r0 ; b0 (Z) <- poids faible de B srl %r2, 1, %r2 ; décale B vers la droite bne noadd ; si b0 = 1 faire addcc %r1, %r3, %r3 ; résultat <- résultat + Anoadd sll %r1, 1, %r1 ; décale A à gauche ba loop ; fin tqfin ret

Figure V.39. Sous-programme de multiplication non signée 16 bits x 16 bits vers 32 bits.

Toute autre manipulation arrête ou laisse la machine arrêtée ; il faut ensuite reprendre laprocédure au point 1 pour la mettre en marche.

Solution

On a déjà réalisé une telle commande à l’aide de circuits séquentiels. On demandemaintenant de le réaliser par programme, comme on pourrait le faire avec unmicrocontrôleur.

On rappelle le graphe d’états de ce système figure V.40.

e

M=0

b c

1110

a

00

00

M=0

00

10M=0

11

0111

0110

0100

M=1

Figure V.40. Graphe d’états du système de sécurité.

À chaque état dans le graphe correspondra une position dans le programme. Celaconduit à l’algorithme suivant :

configurer IO[1] (A) et IO[0] (B) en entrées, IO[2] (M) en sortie ;label a: écrire 0 sur M ;


label a1: lire état de A et B ; cas (A,B) (0,0): aller en a1 ; (1,0): aller en b ; autre: aller en e ; fin caslabel b: écrire 0 sur M ;label b1: lire état de A et B ; cas (A,B) (1,0): aller en b1 ; (1,1): aller en c ; autre: aller en e ; fin caslabel c: écrire 1 sur M ;label c1: lire état de A et B ; cas (A,B) (1,1): aller en c1 ; autre: aller en e ; fin cas

Cet algorithme se traduit de façon littérale par le programme donné figure V.41.

11.3. Exercice 3 : inversion d’une chaîne de caractères

Énoncé

Écrire unsous-programme qui inverse ’sur place’une chaîne de caractères ASCII située enRAM et pointée par %r1.

Solution

Les caractères sont ici stockés sous forme de codes ASCII dans des octets consécutifs. Onemploiera donc les instructionldub etstb pour les lire et les écrire en mémoire. L’idée del’algorithme à implémenter est de conserver un pointeur en début de chaîne et d’en placerun autre en fin de chaîne. On intervertit alors les caractères qu’ils pointent, et on les déplaced’un cran l’un vers l’autre. On recommence ensuite l’échange et le déplacement jusqu’à cequ’ils se rencontrent. Cela donne plus précisément l’algorithme suivant :

i <- 0 ;tant que (str[i] <> 0) faire i <- i + 1 ;fin tq ;i <- i - 1 ;j <- 0 ;


IOBASE = 0x600000 ; adresse de base entrées/sorties

main set IOBASE, %r1 ; adresse de base I/O dans %r1 setq 0b100, %r2 ; configuration IO[1..0] entrées st %r2, [%r1+2] ; IO[2] sortie

a: setq 0b000, %r2 ; M <- 0 st %r2, [%r1]a1: ld [%r1], %r2 ; lecture état de A et B andcc %r2, 0b11, %r2 ; isolation des bits 0 et 1 subcc %r2, 0b00, %r0 be a1 ; (A,B) = (0,0) : aller en a1 subcc %r2, 0b10, %r0 ; (A,B) = (1,0) : aller en b bne e ; sinon aller en e ;b: setq 0b000, %r2 st %r2, [%r1] ; M <- 0b1: ld [%r1], %r2 ; lecture état de A et B andcc %r2, 0b11, %r2 ; isolation des bits 0 et 1 subcc %r2, 0b10, %r0 be b1 ; (A,B) = (1,0) : aller en b1 subcc %r2, 0b11, %r0 ; (A,B) = (1,1) : aller en c bne e ; sinon aller en ec: setq 0b100, %r2 st %r2, [%r1] ; M <- 1c1: ld [%r1], %r2 ; lecture état de A et B andcc %r2, 0b11, %r2 ; isolation des bits 0 et 1 subcc %r2, 0b11, %r0 ; (A,B) = (1,1) : aller en c1 be c1 ; sinon aller en ee: setq 0b000, %r2 st %r2, [%r1] ; M <- 0e1: ld [%r1], %r2 ; lecture état de A et B andcc %r2, 0b11, %r2 ; isolation des bits 0 et 1 subcc %r2, 0b00, %r0 ; (A,B) <> (0,0) : aller en e1 bne e1 ba a ; sinon aller en a

Figure V.41. Programme de mise en marche de sécurité pour machine dangereuse.

tant que (i > j) faire x <- str[i]; y <- str[j]; str[i] <- y ; str[j] <- x ; i <- i - 1 ; j <- j + 1 ;fin tq ;

La traduction littérale de cet algorithme est donnée figure V.42.


RAM = 0x10000000 ; adresse début de RAMSTACK = RAM + 0x1000 ; adresse sommet pile

main ;; programme de test set STACK, %sp set STR, %r1 call reverse ba *

reverse clr %r3 ; i <- 0 sethi 0,%r4rev1 ldub [%r1+%r3], %r4 tst %r4 ; tq (str[i]<>0) be rev2 inc %r3 ; i <- i + 1 ba rev1 ; fin tqrev2 clr %r5 ; j <- 0 dec %r3 ; i <- i - 1rev3 cmp %r5, %r3 bpos outrev ; tq (i>j) ldub [%r1+%r3], %r4 ; x <- str[i] ldub [%r1+%r5], %r2 ; y <- str[j] stb %r4, [%r1+%r5] ; str[i] <- y stb %r2, [%r1+%r3] ; str[j] <- x dec %r3 ; i <- i - 1 inc %r5 ; j <- j + 1 ba rev3 ; fin tq ret

.org RAMSTR .byte ’azertyuiop’,0 ; chaîne de test

Figure V.42. Sous-programme d’inversion sur place d’une chaîne de caractères.

11.4. Exercice 4 : conversion binaire / ASCII

Énoncé

Écrire unsous-programme qui convertit un nombre entier placé dans %r1, codé en binairenon signé, en une chaîne de caractères ASCII qui en est sa représentation décimale, à partirde l’adresse mémoire contenue dans %r2.

Solution

On applique un algorithme connu sous le nom de ’schéma de Horner’, qui consiste à diviserle nombre par 10, à conserver le reste, puis à diviser à nouveau le quotient par 10 et àgarder le reste, et ainsi de suite jusqu’à ce que le nombre soit plus petit que 10 ; la suite desrestes obtenus forme la suite inversée des chiffres décimaux cherchés. Plus précisément,l’algorithme est :


i <- 0 ;tant que (n >= 10) faire (q,r) <- n / 10 ; n <- q ; str[i] <- r + ’0’; i <- i + 1 ;fin tqstr[i] <- n + ’0’;i <- i + 1 ;str[i] <- 0 ;inverser sur place str ;

La traduction littérale de cet algorithme est donnée figure V.43.

RAM = 0x10000000 ; adresse début de RAMSTACK = RAM + 0x1000 ; adresse sommet pile

main ;; programme de test set STACK, %sp set 1234, %r1 set STR, %r2 call bin2ascii ba *

bin2ascii clr %r5 ; i <- 0b1 cmp %r1, 10 ; tq (n>=10) bneg b2

udivcc %r5, 10, %r5 sll %r5, 16, %r3 srl %r3, 16, %r3 ; r dans %r3 srl %r5, 16, %r5 ; n <- q

addcc %r3, ’0’, %r3 stb %r3, [%r2+%r5] ; str[i] <- r + ’0’ inc %r5 ; i <- i + 1 ba b1 ; fin tqb2 addcc %r1, ’0’, %r1 stb %r1, [%r2+%r5] ; str[i] <- n + ’0’ inc %r5 ; i <- i + 1 stb %r0, [%r2+%r5] ; str[i] <- 0

mov %r2, %r1 call reverse ret

.org RAMSTR .byte ’azertyuiop’,0 ; chaîne de test

Figure V.43. Programme de conversion binaire vers décimal.

Chapitre VI

Construction du processeur 32 bits CRAPS

Nous avons appris à programmer le processeur CRAPS dans le chapitre précédent,afin d’avoir une idée plus précise de la nature des opérations qu’il va devoir effectuer. Onva maintenant réaliser effectivement CRAPS, uniquement par l’assemblage de modules quiont été présentés au chapitre 4 ; les principes de modularité qui ont été mis en avant danscet ouvrage sont donc effectivement mis en oeuvre d’un bout à l’autre de la conceptiondu processeur.

Au delà de la construction de ce processeur particulier, ce sont les principes de base dela conception de tous les processeurs et microcontrôleurs qui seront abordés.

1. Les registres

CRAPS possède 32 registres banalisés pour le programmeur : %r0, …, %r31, ainsi quedes registres utilisés pour son fonctionnement :

• %pc :program counter, qui contient l’adresse de l’instruction en cours d’exécution.

• %ir : instruction register, qui contient l’instruction en cours d’exécution.

• %psr :program status register, qui contient les flags et des informations relativesaux exceptions.

• %tbr :trap base register, qui contient l’adresse de la table des exceptions.

À cette liste on ajoutera deux registres qu’on appellera %tmp1 et %tmp2, inaccessiblesau programmeur, qui seront utilisés par le processeur lors de l’exécution de certainesinstructions.

Pour uniformiser les accès, on a donné également des numéros à ces derniers registres,dans l’intervalle [32, 63]. Ainsi, tous les registres sont désignés par un numéro codable sur6 bits. Les numéros des registres non banalisés de CRAPS sont :

• %tmp1& %tmp2 : %r32 & %r33

• %tbr : %r60

• %psr : %r61

• %pc : %r62

• %ir : %r63

186

1. Les registres 187

Le sous-ensemble des registres a la structure générale montrée à la figure VI.1.

64

6464

...

%r00

asel[63..0]

1

63

0décodeur

bus B

1

63

0décodeur

bus A

32

breg[5..0]

areg[5..0]

6

6

6

63

10

décodeurbus D

dreg[5..0]

dsel[63..0]

1

2 %r2

%r1

30 %r14

%r1531

32 %tmp1

CLK

bsel[63..0]

dbus[31..0]Bus D Bus BBus A

abus[31..0] bbus[31..0]

32 32

%ir

61

N,Z,V,C (UAL)

4 4

N,Z,V,C

63

60 %tbr

%pc62

op rd rs2rs1

PILNZVC%psr

setNZ,setVC

33 %tmp2

Figure VI.1. Le sous-ensemble des registres du processeur CRAPS. Le programmeur n’aun accès banalisé qu’aux 32 premiers d’entre-eux.

On voit trois bus de 32 bits sur cette figure, qui sont les trois grands bus du processeursur lesquels circuleront toutes les données manipulées.

Les bus A et B

Sur les bus A et B on peut faire venir les valeurs de deux registres simultanément : ilsuffit de mettre leurs numéros surareg etbreg , respectivement.Par exemple,si on souhaiteavoir%tbr sur le bus A et%r1 sur le bus B, on place 60 surareg et 1surbreg . Les valeursdes deux registres apparaissent alors sur les bus A et B respectivement,de façon asynchrone.Les deux bus fonctionnent indépendamment et en parallèle.

Le bus D

Sur le bus D (qui sera souvent un bus de données, d’où son nom) on place une valeurqu’on souhaite écrire dans un registre.On doit placer le numéro de ce registre dansdreg , etenvoyer un front montant sur l’horlogeclk : la valeur sur le bus D est alors écrite dans leregistre de numérodreg .

Le registre %psr et l’écriture des flags

On l’a vu au chapitre précédent, les flags N, Z, V, C sont les valeurs des bits 23 à 20du registre%psr , c’est à dire du registre%r61. Pourtant ils seront positionnés, tantôt parla procédure ’normale’ d’écriture en%r61 (par exemple lors de la restauration de%psr àun retour de gestionnaire d’exception), mais aussi également lors de l’activation de signaux

188 CHAPITREVI. CONSTRUCTION DU PROCESSEUR32BITSCRAPS

dédiéssetN , setZ et setVC . On désire par exemple que, lorsquesetVC vaut 1 au frontd’horloge, les bits V et C mémorisent les valeurs V_UAL et C_UAL qui proviennent del’UAL, et cela concurremment à l’écriture standard dans un autre registre (dont le numéroest surdreg ). V et C sont groupés, car ils sont toujours positionnés ensemble par desinstructions telles queaddcc .N et Z ne sont pas groupés, car une opération commeumulcc

ne positionne que Z.

Les cas particuliers des registres %r0 et %r34 à %r38

Du chapitre précédent sur la programmation de CRAPS on connaît déjà le registre%r0

et son usage très pratique. Il doit nécessairement être traité de façon particulière : il sera parexemple inutile de prévoir des bascules de mémorisation pour lui, et on devra faire en sorteque sa lecture donne toujours 0.

De la même façon, il sera nécessaire de disposer des constantes 2, 4, 8, 16 et 24lors du séquencement des instructions. La constante 4 sera utilisée par exemple lors del’incrémentation de%pcde 4 pour le passage à l’instruction suivante. Les autres constantesont des usages encore plus spécifiques, qui seront décrits plus loin. On a choisi de faire ensorte que ces constantes soient les valeurs des registres%r34 (= 2),%r35 (= 4),%r36 (= 8),%r37 (= 16) et%r38 (= 24) ; de même que pour%r0, l’écriture dans ces registres spéciauxsera sans effet, et leur lecture renverra toujours ces valeurs constantes.

Structure d’un registre ordinaire

On voit figure VI.2 comment est construit un registre ordinaire, c’est à dire avec unindicei qui n’est, ni 0 (pour%r0), ni 34 à 38 (pour les constantes), ni 61 (pour%psr).

Figure VI.2. Structure d’un registre ordinaire.

Un registre est bien composé de 32 basculesD.Une valeur de 1pour le signaldsel[i]

indique qu’une écriture est souhaitée dans le registre d’indice i. Commedsel[i] est

1. Les registres 189

branché sur l’entrée de validation des bascules, les bascules vont se charger avec les valeursprésentes sur les lignesdbus[31..0] , c’est à dire le bus D.

En ce qui concerne la lecture sur les bus A et B,elle s’effectue bien de façon asynchronepar l’intermédiaire des buffers3-états du bas de la figure. Quand par exempleasel[i]

est activée (c’est à dire queareg[5..0] = i), les registres vont placer leurs valeurs sur leslignesabus[31..0] , c’est à dire le bus A. Il n’y aura pas de conflit avec les autres registres,car les lignes qui activent les buffers 3-états sont les sorties d’un même décodeur, et donctoutes mutuellement exclusives.

Cela conduit à l’écriture SHDL suivante, pour %r1par exemple :

// %r1r1[31..0] := dbus[31..0];r1[31..0].clk = clk;r1[31..0].rst = rst;r1[31..0].ena = dsel1;abus[31..0] = r1[31..0]:asel1;bbus[31..0] = r1[31..0]:bsel1;

Structure de %psr

Pour le registre%r61 (%psr), seuls les bits 23..20 (N,Z,V,C),11..7 (PIL),7 (S) et 5 (ET)sont mémorisés. Les bits N,Z,V,C peuvent être écrits de deux façons :

1 directement par écriture dans%r61 (dsel61 = 1).

2 par activation desetN , setZ ousetVC .

La figure VI.3 montre sur le bit 23 (flag N) comment cela peut être implémenté.

Figure VI.3. Structure du bit N du registre %psr.

Si on a, nidsel23 = 1, nisetN = 1, le registre ne peut pas changer de valeur au frontd’horloge (entréeen à 0). SisetN = 1, on voit que le registre va se charger avec la valeurN_UALen provenance de l’UAL.Cette écriture,qui aura lieu au front d’horloge,pourra avoirlieu en même temps qu’une écriture normale dans un autre registre. SisetN = 0 etdsel23


= 1, on retombe dans le cas de l’écriture ’normale’ dans %r61, avec mémorisation du bitdbus23 en provenance du bus D. Les sorties sur les bus A et B sont identiques aux autresregistres ; on notera que le bit N (mémorisé) sort par ailleurs directement vers l’extérieur.

Cette gestion du bit N s’écrit en SHDL :

// %r61 = %psr, bit N (bit #23)dr[23] = dsel61*dbus23+setN*N_UAL; // Nena23 = dsel61 + setN;r61[23] = dr[23];r61[23].ena = ena23;r61[23].clk = clk;r61[23].rst = rst;abus[23] = r61[23]:asel61;bbus[23] = r61[23]:bsel61;

Lecture et écriture dans %r0 et %r34 à %r38.

On rappelle que l’écriture dans les registres%r0 et%r34 à%r38 doit être sans effet etque la lecture doit renvoyer les valeurs constantes 0, 2, 4, 8, 16 et 24 respectivement.Aucunebascule ne doit leur être associée, puisqu’il n’y a rien à stocker. Lorsque leurs lignes desélection sont activées, les valeurs constantes doivent être placées directement sur le bus parl’intermédiaire d’un buffer3-états (figure VI.4).

Figure VI.4. Structure des registres %r0 et %r34 à %r38.L’écriture dans ces registres estsans effet,et la lecture renvoie des valeurs constantes.

Finalement on peut écrire les équations SHDL de tout le sous-système de registres(figure VI.5). Il est nécessaire de dupliquer le même bloc de lignes autant de fois qu’il y a deregistres, car le langage ne permet pas d’autre raccourci que l’écriture vectorielle simple àune dimension.

2. L’unité arithmétique et logique

L’unité arithmétique et logique (UAL) est le sous-système du processeur CRAPS quiva effectuer,non seulement les calculs explicitement associés aux instructionsarithmétiqueset logiques du programme en cours d’exécution, mais aussi tous les calculs implicitementdemandés par leur mise en oeuvre, comme par exemple l’incrémentation de%pcde 4 aprèsl’exécution d’une instruction séquentielle, ou le calcul du déplacement lors d’un saut relatif(typeba), etc.


module registres(rst,clk, areg5..areg0,breg5..breg0, dreg5..dreg0, dbus31..dbus0,setN,setZ,setVC, N_UAL,Z_UAL,V_UAL,C_UAL : abus31..abus0, bbus31..bbus0, N,Z,V,C)

// décodeurs 6 vers 64decodeur6to64(areg5..areg0:asel63..asel0);decodeur6to64(breg5..breg0:bsel63..bsel0);decodeur6to64(dreg5..dreg0:dsel63..dsel0);// %r1r1[31..0] := dbus[31..0];r1[31..0].clk = clk;r1[31..0].rst = rst;r1[31..0].ena = dsel1;abus[31..0] = r1[31..0]:asel1;bbus[31..0] = r1[31..0]:bsel1;...// idem pour %r2..r33; %r60,%r62..%r63...// %r0 = 0abus[31..0] = 0:asel0;bbus[31..0] = 0:bsel0;// %r34 = 2abus[31..0] = 2:asel34;bbus[31..0] = 2:bsel34;...// idem pour %r35 = 4,.., %r38 = 24...

// %r61 = %psrD_N = dsel61*dbus23+setN*N_UAL; // NEN_N = dsel61 + setN;r61[23] := D_N;r61[23].ena = EN_N;D_Z = dsel61*dbus22+setZ*Z_UAL; // ZEN_Z = dsel61 + setZ;r61[22] := D_Z;r61[22].ena = EN_Z;

EN_VC = dsel61 + setVC;D_V = dsel61*dbus21+setVC*V_UAL; // VD_C = dsel61*dbus20+setVC*C_UAL; // Cr61[21] := D_V;r61[20] := D_C;r61[21..20].ena = EN_VC;

r61[11..7,5] := dbus[11..7,5]; // PIL & S & ETr61[11..7,5].ena = dsel[11..7,5];

r61[23..22,11..7,5].clk = clk;r61[23..22,11..7,5].rst = rst;

abus[23..22,11..7,5] = r61[23..22,11..7,5]:asel61;bbus[23..22,11..7,5] = r61[23..22,11..7,5]:bsel61;end module

Figure VI.5. Écriture SHDL du sous-système des registres.

La figure VI.6 montre l’interface de cesous-système. C’est un circuit asynchrone pur,sans horloge. Les bus d’entrée et le bus de sortie ont une largeur de 32 bits ; la commandecmd_ual qui indique l’opération à effectuer est codée sur 6 bits. Les signaux N,Z,V,Csortants donnent des indications sur le résultat de l’opération qui vient d’être effectuée ; lessignauxsetN ,setZ etsetVC indiquent si ces flags doivent être copiés dans les bits N,Z,V,Cdu registre%psr au prochain front d’horloge. Un dernier signaldiv0 indique une tentativede division par 0.

Figure VI.6. Interface de l’UAL.

2.1. Fonctions de l’UAL

On peut énumérer dans un tableau toutes les opérations de l’UAL, avec leurs codes


associés (figure VI.7).Ces codes sont sur 6 bits alors que 5 bits suffiraient ; cela est dû au faitque l’on a rendus égaux les codes du champop3des instructions arithmétiques et logiques(voir figure V.8 du chapitre précédent) avec les codes de l’opération correspondante del’UAL, ce qui introduira une simplification de conception.Par exemple la valeur 010000 duchampop3d’une instructionaddcc est également le code de l’opération d’addition dansl’UAL.

cmd_ual opération setN setZ setVC

010000 ADDCC, addition 1 1 1

010100 SUBCC, soustraction 1 1 1

011010 UMULCC, multiplicationnon-signée 0 1 0

001110 UDIVCC, division non-signée 0 1 0

010001 ANDCC, et logique 1 1 0

010010 ORCC, ou logique 1 1 0

010011 XORCC, xor logique 1 1 0

010111 XNORCC, xnor logique 1 1 0

110101 SLL, shift gauche logique 0 0 0

110110 SRL, shift droit logique 0 0 0

000000 ADD, addition 0 0 0

000100 SUB, soustraction 0 0 0

100000 SIGNEXT13, extension de signe bus A, 13 bits→ 32 bits 0 0 0



101000 NOPB, no operation bus B 0 0 0

111000 INSBYTE0, insertion d’un octet dans un mot 0 0 0




Figure VI.7. Table des opérations de l’UAL. Les codes des opérations arithmétiques etlogiques sont identiques aux valeurs du champop3 dans les instructions de calcul.

La première partie du tableau concerne des opérations directement associées auxfonctions des instructions, bien que certaines seront aussi utilisées pour d’autres tâchesinternes à l’exécution. La deuxième partie ne concerne que ces opérations internes :l’addition et la soustraction sans positionnement des flags sont utilisées pour modifier lavaleur du compteur ordinal par exemple ; l’extension de signe bus A, 13→ 32 bits, consisteà prendre l’entrée A, à conserver les 13bits de poids faibles et à remplacer tous les autres bitsde poids forts par des zéros ou des uns, selon que le nombre sur 13bits était positif ou négatif(respectivement),réalisant ainsi une extension de signe.Cette opération sera nécessaire pourextraire la constante de 13 bits qui est incluse dans une instruction arithmétique ou logiqueavec constante immédiate, telle queaddcc %r1, 5, %r2 . Les deux autres opérationsd’extension de signe fonctionnent de manière analogue sur 22 et 30 bits, et servent à extraire


les valeurs de déplacement dans les instructions de branchement et dans l’instructioncall .La commande NOPB consiste à laisser passer la valeur présente sur le bus B vers la sortie,sans changement.Enfin les commandes INSBYTE0,…,INSBYTE3,qui seront utilisées lorsdes instructionsstb , insèrent l’octet présent sur le bus B dans le mot présent sur le bus A,en position 0, 1, 2 ou 3 respectivement.

2.2. Structure de l’UAL

On pourrait concevoir une UAL en associant 32 tranches d’UAL de 1bits, comme celaa été présenté à la section 8, mais ce serait trop inefficace. On va plutôt chercher à associerdes modules efficaces tels que l’additionneurcarry-lookahead, le multiplicateur systolique,etc. dont on a étudié la conception au chapitre 2.

On suppose donc qu’on dispose de :

• un additionneur/soustracteur 32 bits d’interface SHDL :

addsub32(a31..a0,b31..b0,op:s31..s0,N,Z,V,C)

On pourra utiliser la technique vue en section 8.6 pour mettre en commun unadditionneur 32 bits pour les deux opérations.op=0 indique qu’on fait une addition ;op=1 une soustraction. Les signauxN, Z, V, C ont la signification habituelle.

• un multiplicateur 16 bits x 16 bits→ 32 bits non signé, d’interface SHDL :

mul32(a15..a0,b15..b0:s31..s0,Z)

Seul un indicateur de nullitéZ a un sens dans le contexte d’une multiplication nonsignée, pour laquelle aucun débordement n’est possible.

• un diviseur 16 bits / 16 bits, avec calcul du quotient sur 16 bits et calcul du reste sur 16bits, d’interface SHDL :

div32(a31..a0,b15..b0:q15..q0,r15..r0,Z,DIV0)

Cette fois, on a une indication supplémentaire qui détecte une division par 0.

• un décaleur à barillet 32 bits, d’interface SHDL :

shift32(a31..a0,sens,nb4..nb0:s31..s0)

L’amplitude du décalage est codée dansnb4..nb0 , de 0 à 31bits ; le sens du décalageest codé danssens (0=gauche, 1=droite).

• un circuit d’extension de signe, d’interface SHDL :

signext(a12..a0,b1,b0:s31..s0)

On a déjà étudié ces circuits auparavant; ils effectuent le transcodage d’un nombresigné codé en complément à 2, d’une certaine largeur de bits à une largeur de bitsplus grande, en recopiant autant de fois que nécessaire le bit de signe sur la gauche. Leprésent module est paramétrable : sib1,b0 = 00 (respectivement 01, 10) il effectuel’extension de 13 (respectivement 22, 30) vers 32 bits.


• un circuit d’insertion d’octet, d’interface SHDL :

insbyte(a31..a0,b7..b0,n1,n0:s31..s0)

Ce circuit recopiea31..a0 verss31..s0 , sauf un groupe de 8 bits dont la position estdonnée parn1,n0 (de 0 à 3), qui est le numéro de l’octet dans le mot (0 représentant lesrangs de 31 à 24 et 3 représentant les rangs de 7 à 0), les bits copiés étant alors ceux deb7..b0 . L’écriture d’un tel module est très simple et peut être faite à titre d’exercice.

La figure VI.8 montre comment associer tous ces modules en une seule UAL.

Un décodeur (en haut à droite du schéma) produit les signauxaddsub , etc. quiindiquent le type d’opération à effectuer. Chaque module de calcul est suivi de bufferstrois-états qui sont activés par la sortie correspondante du décodeur ; il est donc garanti queces buffers n’entreront pas en conflit. Par ailleurs le décodeur a une entrée de sélectionCS

qui est reliée au signalOE : si OE=0, aucune sortie du décodeur n’est active et donc tout lebusS est en haute impédance.Enfin le décodeur produit les signauxsetN, setZ, setVC

qui indiquent, selon le code de l’opération, si les flags correspondants ont un sens.

Les sortiesdes buffers trois-étatssont toutes reliéesà la sortieS, qui est donc la synthèseentre tous ces signaux. Si par exemple le code de l’opération estcmd_ual=010011 (xor)et siOE=1, alors seule la sortiexor du décodeur sera activée ; le buffer trois-états associé àl’opérationxor laissera alors passer sur la sortieS le résultat de l’opération.

Comme le moduleaddsubexécute à la fois l’addition et la soustraction, la sortie estcontrôlée par le signaladdsub qui regroupe les 4 codes associés à des opérations d’additionet de soustraction dans la table VI.7. Le choix entre addition et soustraction sur l’entréeop

du moduleaddsubest relié au signalcmd_ual[2] : en effet, si on examine les 4 codesen question, le bit 2 vaut 0 pour les 2 opérations d’addition, et 1 pour les 2 opérationsde soustraction.

De façon analogue le décaleur à barilletshiftera sa sortie contrôlée par le signalshift

qui regroupe les opérationssll etsrl ; c’est le signalcmd_ual[1] qui va faire la distinctionet être relié à l’entréesens du décaleur, car entre les deux opérations de décalage, c’est lebit 1du code qui indique le sens. On notera que l’entréenb (le nombre de bits à décaler) estreliée aux 5 bits de poids faibles de l’entréeB31..B0 , pour une valeur de décalage entre 0et 31.

En ce qui concerne le flag N, il n’a de sens que pour les opérationsadd/sub, and, or,xor, xnor ; il n’a pas de sens pour la multiplication et la division, qui sont non signées ici.Les modules associés produisent ainsi les signauxN1,…,N5 respectivement,qui sont en faitconstitués du bit de poids fort du résultat. Ces signaux sont ensuite synthétisés en un seulsignalNen fonction de l’opération effectivement demandée surcmd_ual .

Un traitement identique est réalisé pour produire le bit Z, qui a un sens pour les mêmesopérations que N, mais aussi pour la multiplication et la division. Chaque module génèreainsi un signalZ1,…,Z7 ; le moduleZEROsert à produire ce signal pour les opérationslogiques.

Les flags V et C quant à eux ne peuvent être produits que par le moduleaddsub, qui lesexporte donc directement.

La figure VI.9 donne l’écriture complète du module d’UAL en langage SHDL.


Figure VI.8. Structure de l’UAL.

3. Les bus du processeur CRAPS

Il nous faut maintenant examiner comment les grandssous-systèmes de CRAPS


module ual(rst,clk, A31..A0, B31..B0, cmd_ual5...cmd_ual0, OE: S31..S0, setN,setZ,setVC, N,Z,V,C, div0)

// decodage de l’opérationaddsub=/cmd_ual5*cmd_ual4*/cmd_ual3*/cmd_ual1*/cmd_ual0 + /cmd_ual5*/cmd_ual4*/cmd_ual3*/cmd_ual1*/cmd_ual0;mul=/cmd_ual5*cmd_ual4*cmd_ual3*/cmd_ual2*cmd_ual1*/cmd_ual0;div=/cmd_ual5*/cmd_ual4*cmd_ual3*cmd_ual2*cmd_ual1*/cmd_ual0;and=/cmd_ual5*cmd_ual4*/cmd_ual3*/cmd_ual2*/cmd_ual1*cmd_ual0;or=/cmd_ual5*cmd_ual4*/cmd_ual3*/cmd_ual2*cmd_ual1*/cmd_ual0;xor=/cmd_ual5*cmd_ual4*/cmd_ual3*/cmd_ual2*cmd_ual1*cmd_ual0;xnor=/cmd_ual5*cmd_ual4*/cmd_ual3*cmd_ual2*cmd_ual1*cmd_ual0;shift=cmd_ual5*cmd_ual4*/cmd_ual3*cmd_ual2*cmd_ual0;sext=cmd_ual5*/cmd_ual4*/cmd_ual3*/cmd_ual2;

// opérationsaddsub32(A31..A0,B31..B0,op:S1_31..S1_0,N1,Z1,V,C);mul32(A15..A0,B15..B0:S2_31..S2_0,Z2);div32(A31..A0,B15..B0:S3_31..S3_16,S3_15..S3_0,Z3,div0);shift32(A31..A0,cmd_ual0,A4..A0:S4_31..S4_0);S5_31..S5_0=A31..A0*B31..B0; // andZERO(S5_31..S5_0:Z4);S6_31..S6_0=A31..A0+B31..B0; // orZERO(S6_31..S6_0:Z5);S7_31..S7_0=A31..A0+/B31..B0+/A31..A0+B31..B0; // xorZERO(S7_31..S7_0:Z6);S8_31..S8_0=A31..A0+/B31..B0+/A31..A0+B31..B0; // xnorZERO(S8_31..S8_0:Z7);signext(A29..A0,B1,B0:S9_31..S9_0);

// gestion du bus trois états S31..S0S31..S0 = S1_31..S1_0:addsub;S31..S0 = S2_31..S2_0:mul;S31..S0 = S3_31..S3_0:div;S31..S0 = S4_31..S4_0:shift;S31..S0 = S5_31..S5_0:and;S31..S0 = S6_31..S6_0:or;S31..S0 = S7_31..S7_0:xor;S31..S0 = S8_31..S8_0:xnor;S31..S0 = S9_31..S9_0:sext;

// gestion des flagssetN=addsub+and+or+xor+xnor;setZ=addsub+mul+div+and+or+xor+xnor;setVC=addsub;N=addsub*N1+and*N2+or*N3+xor*N4+xnor*N5;Z=addsub*Z1+mul*Z2+div*Z3+and*Z4+or*Z5+xor*Z6+xnor*Z7;end module

Figure VI.9. Écriture SHDL de l’UAL du processeur CRAPS.

communiquent entre eux. CRAPS utilise trois bus de 32 bits (figure VI.10) :

• Le bus A, monodirectionnel : seul le bloc des registres peut y déposer une valeur.Il est relié à une des entrées de l’UAL, mais une dérivation part également vers lesous-système mémoire, où il servira de bus d’adresses. Il porte bien son nom : bus Acommebus d’adresses.

3. Les bus du processeur CRAPS 197

UAL

cmd_ual[5..0]

6

32

Bus A Bus B

32

32

Bus D

clkregistres

Bus Dbus d’adresses

Bus Abus de données

vers mémoire centrale

(OE = excep_mode)

d’exceptionsvers sous−système

(OE = read * /excep_mode)

OE = /read * /excep_mode

Figure VI.10. Les bus du processeur CRAPS.

• Le bus B, monodirectionnel. Il sert uniquement à fournir un second argumentpour l’UAL.

• Le bus D,bi-directionnel.C’est sur lui que circulent toutes les données :bus D pourbusde données. Sa valeur est lue par le bloc des registres pour stockage dans un registre aufront d’horloge, et/ou par le sous-système mémoire pour écriture en mémoire.

Le bus D est celui dont la gestion est la plus délicate. En effet, trois sources différentespeuvent y déposer une valeur :

1 l’UAL, pour communiquer le résultat de ses calculs. Son écriture sur le bus estcommandée par :OE=/read*/excep_mode .

2 le sous-système mémoire, qui y déposera la valeur des données lues en mémoire. Cedépôt sera commandé parOE=read*/excep_mode .

3 le sous-système des exceptions, qui pourra y déposer le numéro de l’exception danscertaines circonstances. Ce dépôt est commandé parOE=excep_mode.

Même si nous ne connaissons pas encore le rôle exact des signauxexcep_mode et read ,il est clair que les trois équations des signauxOE de dépôt de valeurs sur le bus D sontmutuellement exclusives ; aucun court-circuit n’est donc possible.


4. Structure du sous-système mémoire

Le sous-système mémoire ne fait pas partie du processeur à proprement parler. Surnos ordinateurs de bureau, il est extérieur au processeur, placé sur la carte-mère, sousforme de barrettes mémoire et de circuits de décodages. Mais c’est un élément centraldont l’importance est telle que nous allons étudier en détail celui qui est associé à lacartographie mémoire que nous avons vue au chapitre consacré à la programmation deCRAPS. On expliquera notamment les phénomènes suivants, visibles du point de vue duprogrammeur :

• les adresses sont des numéros d’octets (alors qu’on manipule des mots de 32 bits, de 4octets de large),

• la ROM commence à l’adresse 0x0, la RAM à l’adresse 0x1000000, etc.

• certaines adresses semblent des ’miroirs’ d’autres : par exemple 0x400000 et0x400010,

• l’accès à des adresses non implantées provoque l’exceptionbus_error.

La cartographie mémoire exacte qu’on souhaite mettre en oeuvre est donnée figure VI.11.On y retrouve les adresses vues dans les exemples de programmation : RAM en 0x1000000,timer en 0x400000, entrées/sorties en 0x600000.

timer

[0000 0000 − 0000 FFFF]

[0060 0000 − 0060 000F]

direction

0060 0000

0060 0004

[0100 0000 − 01FF FFFF]

ROM (64K)

entrées / sorties

RAM (16 Mo)

[0040 0000 − 0040 000B]

0060 0008

0060 000C

données

ITs memorisees

sens front ITs

0040 0004

0040 0000

0040 0008IT timer

commande #2

commande #1

Figure VI.11. Cartographie mémoire de CRAPS.

La structure du sous-système mémoire qui met en oeuvre cette cartographie est donnéefigure VI.12.

Décodage des adresses

Le décodeur situé sur la gauche du schéma prend en entrée les 16 bits de poidsfaibles du bus d’adresse et produit les signaux de décodageROM, RAM, etc. Chacun de cessignaux correspond au décodage de la plage mémoire associée au boîtier correspondant.Précisément :

4. Structure du sous-système mémoire 199

Figure VI.12. Structure du sous-système mémoire.

1 la ROM de 64Ko occupe le segment [0x00000000,0x00010000[. Le signalROMquiindique son décodage vaut 1 lorsque les 16 bits de poids forts de l’adresse sont tous à0 :

ROM = /abus31*/abus30*...*/abus16

2 la RAM de 16Mo occupe le segment [0x01000000,0x02000000[. Le signalRAMquidécode ces adresses vaut 1 lorsque les 8 bits de poids forts de l’adresse sont égauxà 000000012 :

RAM = /abus31*/abus30*...*/abus25*abus24


3 le timer occupe le segment [0x00400000,0x0040000C[. Par souci de simplification,on ne va effectuer qu’un décodage partiel de ces adresses en ne détectant que le faitque les 12 bits de poids forts valent 0x004. Cela conduit à l’équation du signaltimer

suivante :

timer = /abus31*/abus30*...*/abus23*abus22*/abus21*/abus20

4 le circuit d’entrées/sorties occupe le segment [0x00600000,0x00600010[. De façonanalogue au timer, on ne détectera que le fait que les 16 bits de poids forts sont égauxà 0x0060. Cela conduit à l’équation du signalio suivante :

io = /abus31*/abus30*...*/abus23*abus22*abus21*/abus20

5 toutes les autres valeurs des 12 bits de poids forts activeront la lignebus_error , quiindiquera donc que l’adresse présente sur le bus ne correspond à aucun circuit implantédans l’espace d’adressage. Ce signal devra déclencher une exception de niveau 14.

Lecture en mémoire

Les sorties du décodeur sont reliées aux boîtiers qui leurs correspondent, expliquantainsi pourquoi chacun d’eux est activé par les adresses indiquées sur la cartographiemémoire figure VI.11. On notera que l’entrée de sélectionCSdu décodeur est reliée au OUdes signauxread etwrite , c’est à dire qu’aucun des quatre circuits ne sera activé si aucunelecture ni écriture n’est demandée par le processeur.

Si une lecture est demandée (read = 1) et que le processeur n’est pas en train de gérerune exception, alors :

1 OE=1 (en bas à gauche du schéma). On avait déjà étudié l’équation deOE :OE = /excep_mode*read , qui indique qu’un des circuits mémoire va déposer unevaleur sur le bus.

2 CS=1 et OE=1 pour le boîtier mémoire activé par l’adresse présente, en vertu du ETsitué devant l’entréeOEde chaque circuit.

Ainsi, le circuit mémoire sélectionné par l’adresse va déposer une valeur sur le bus D.

Écriture en mémoire

Si une lecture est demandée (write = 1) alors on voit que, pour le circuit activé parl’adresse présente,CS= 1,OE= 0 etW= 1 : le circuit va déclencher une écriture à l’adresseprésente sur ses entréesADR.

Oubliés, les deux bits de poids faibles de l’adresse !

On va étudier enfin la façon dont les lignes d’adresses arrivent sur les circuits mémoire.On constate d’abord que, nulle part sur le schéma, n’apparaissent les 2 bits de poids faiblesde l’adresse,abus1..abus0 ! Par exemple, pour le circuit de ROM, il y a bien 14 lignesd’adresses puisqu’il contient 16K mots, mais ce ne sont pas les bitsabus[13..0] quisont utilisés, maisabus[15..2] . Si par exemple une lecture à l’adresse 0x00000008

4. Structure du sous-système mémoire 201

est effectuée, la ROM verra quant à elle l’adresse 0x0002. En fait, toute adresse entre0x00000008 et 0x0000000B sera vue de la même façon par le circuit de ROM : accès aumot mémoire numéro 2. Mais il faut se souvenir qu’il est interdit de faire des lectures etdes écritures en mémoire à des adresses qui ne sont pas des multiples de 4, sous peine dedéclencher l’exception ’erreur d’alignement’ (numéro de type = 10, voir figure V.35). Parcontre, c’est autorisé dans le cas des instructionsldub et stb dont on verra plus loincomment elles sont gérées.

De la même façon, l’adresse qui est envoyée à la RAM est obtenue par la formule :

adr_ram[21..0] = (abus[31..0] − 0x01000000)/ 4

L’adresse avec laquelle la RAM est adressée s’obtient d’abord par une translation parrapport à l’adresse de base 0x01000000, et cette valeur est divisée par 4. Par exemple, unprogrammeur qui effectue une lecture ou une écriture à l’adresse 0x01000010 va en réalitéadresser la RAM au mot mémoire (de 32 bits) d’indice 5 (0x01000010- 0x01000000) /4). La RAM n’a jamais entendu parler de l’adresse 0x01000000 et ne pensait sans doutepas qu’il existait des adresses aussi grandes (!) : elle ne connaît que des adresses de 0 à0xFFFFFF. De même la RAM croit que tous les mots mémoire ont 32 bits de large ; elleserait étonnée d’apprendre que les adresses manipulées par les programmeurs sont desnuméros d’octets.

C’est encore plus frappant pour les circuits timer et d’entrées/sorties,qui ne possèdentque 2 lignes d’adresse. De leur point de vue il n’existe que 4 mots mémoire, d’indices 0 à3. C’est le système de décodage qui fait apparaître ces mots aux adresses 0x00400000 à0x0040000F pour le timer, et 0x00600000 à 0x0060000F pour les entrées/sorties.

Finalement, l’écriture SHDL de l’ensemble est donnée figure VI.14.On y fait référenceà des modules mémoire ROM et RAM prédéfinis.

5. Structure du circuit d’entrées/sortiesOn va détailler dans cette partie la structure du circuit d’entrées/sortieset on va montrer

comment il peut avoir le mode de fonctionnement qu’on a déjà décrit dans le chapitreconsacré à la programmation. Ils sont résumés dans le tableau VI.13. On rappelle que lecircuit a l’interface de la figure VI.15.

ADR W opération

00 0 lire l’état des entrées

00 1 écrire sur les sorties

01 0 lire configuration lignes

01 1 configurer les lignes

Figure VI.13. Spécification de fonctionnement du circuit d’entrées/sorties.

Il peut être considéré comme la juxtaposition de 32 circuits de 1bits ; la structure pourun bit i est montrée en figure VI.16.


module memoire(rst,clk,abus[31..0],dbus[31..0],read,write,excep_mode, timer_out, io[31..0], bus_error)decode_mem(abus[31..16],cs_mem:cs_rom,cs_timer,cs_io,cs_ram,bus_error);cs_mem=read+write;rom16Kx32(abus[15..2],cs_rom,oe_rom,dbus[31..0]);oe_rom=cs_rom*OE;ram4Mx32(abus[23..2],cs_ram,oe_ram,write,dbus[31..0]);oe_ram=cs_ram*OE;timer_pwm(abus[3..2],cs_timer,oe_timer,write,dbus[31..0],timer_out);oe_timer=cs_timer*OE;io(abus[3..2],cs_io,oe_io,write,dbus[31..0],io[31..0]);oe_io=cs_io*OE;OE=/excep_mode*read;end module

module decode_mem(adr[15..0],CS:ROM,timer,io,RAM,bus_error)commun=/adr15*/adr14*/adr13*/adr12*/adr11*/adr10*/adr9;ROM=CS*commun*/adr8*/adr7*/adr6*/adr5*/adr4*/adr3*/adr2*/adr1*/adr0;RAM=CS*commun*adr8;timer=CS*commun*/adr8*/adr7*adr6*/adr5*/adr4;io=CS*commun*/adr8*/adr7*adr6*adr5*/adr4;bus_error=CS*/ROM*/RAM*/timer*/io;end module

Figure VI.14. Écriture SHDL du sous-système mémoire.

Figure VI.15. Interface du circuit d’entrées/sorties.

La bascule D du haut mémorise le bitdir[i] qui vaut 1 lorsqu’on souhaite que laligne io[i] soit configurée en sortie et 0 lorsqu’on souhaite qu’elle soit une entrée. Labascule ayant comme entrée de sélection le signalCS*W*/ADR[1]*ADR[0] , mémorisera lebit data[i] si et seulement si l’écriture est demandée pourADR = 01 . Du point de vue duprogrammeur, cela correspond à une écriture à l’adresse 0x600004 comme on l’a expliquéà la section 4.

De la même façon, la bascule D du bas mémorise le bitDATA[i] , lorsqu’une écritureest demandée pourADR = 00 ; du point de vue du programmeur cela correspond à uneécriture à l’adresse 0x600000.

Maintenant,dir[i] gouverne bien le fait que la ligneio[i] est une entrée ou unesortie : sidir[i] = 1 , le buffer trois-états de droite fait deio[i] une sortie, dont lavaleur est justement le signalout[i] , ce qui est le comportement spécifié tableau VI.13.Si dir[i] = 0 , le buffer trois-états de droite isoleio[i] deout[i] ; si maintenant unelecture est demandée pourADR = 00 , la conditionCS*/W*OE*/ADR[1]*/ADR[0] vaut 1

5. Structure du circuit d’entrées/sorties 203

Figure VI.16. Structure du circuit d’entrées/sorties,pour un biti .

et io[i] passe sur la ligneDATA[i] .Du point de vue du programmeur,cela équivaut à unelecture à l’adresse 0x600000 et elle lui retourne l’état des 32 lignes d’entrées/sorties.Enfin,si une lecture est demandée pourADR[1..0] = 01 , le buffertrois-étatsdu bas laisse passersurDATA[i] la valeurdir[i] : du point de vue du programmeur, une lecture à l’adresse0x600004 lui renvoie l’état de configuration des entrées/sorties.

On a ainsi expliqué tous les aspects du fonctionnement du circuit d’entrées/sorties dutableau VI.13. Les autres aspects relatifs aux exceptions seront décrits section 7.

Finalement, l’écriture SHDL de l’ensemble est donnée figure VI.17.

6. Structure du circuit timer/PWMLe circuit timer/PWM est un bel exemple de construction modulaire, par assemblage

du module timer/PWM étudié à la section 9 et du module diviseur de fréquence étudiésection 10.2. On l’a déjà utilisé du point de vue du programmeur ; sa spécification estredonnée tableau VI.18 et on rappelle son interface figure VI.19.

Sur la figure VI.20, les registres de 32 bits situés à gauche fonctionnent de la manièrehabituelle : celui du haut mémorise le mot de commande #1 lorsqu’une écriture pourADR = 00est demandée, ce qui correspond à une écriture en 0x400000 du point de vuedu programmeur. Le registre 16 bits en dessous et la bascule D tout en bas mémorisentprediv et start respectivement, lorsqu’une écriture pourADR = 01est demandée, soit


module io(rst,clk,ADR[1..0],CS,OE,W,DATA[31..0],io[31..0])ENA_IO = CS*W*/ADR1*/ADR0;ENA_DIR = CS*W*/ADR1*ADR0;// écriture dans dir[i]dir[31..0] := DATA[31..0];dir[31..0].ena = ENA_DIRdir[31..0].clk = clk;dir[31..0].rst = rst;// écriture dans out[i]out[31..0] := DATA[31..0];out[31..0].ena = ENA_IO;out[31..0].clk = clk;out[31..0].rst = rst;// sortie sur io[i]io[31..0] = out[31..0]:dir[31..0];// lecture de io[i]OE_IO = CS*/W*OE*/ADR1*/ADR0;DATA[31..0] = io[31..0]:OE_IO;// lecture de dir[i]OE_DIR = CS*/W*OE*/ADR1*ADR0;DATA[31..0] = dir[31..0]:OE_DIR;end module

Figure VI.17. Écriture SHDL du circuit d’entrées/sorties.

ADR W opération

00 0 lire le registre de commande #1 (P + N)

00 1 écrire le registre de commande #1 (P + N)

01 0 lire le registre de commande #2 (prediv + start)

01 1 écrire le registre de commande #2 (prediv + start)

Figure VI.18. Spécifications du circuit timer/PWM.

Figure VI.19. Interface du circuit timer/PWM.

une écriture en 0x400004 pour le programmeur.

La valeur deprediv est mise en entrée d’un circuit diviseur de fréquence,qui divise lafréquence de l’horloge généraleclk . La sortie du diviseur de fréquence devient l’horloge decomptage d’un module timer identique à celui étudié section 9. On lui transmet égalementles partiesN et P du mot de commande #1 ; par ailleurs son entrée de sélection est reliée ausignalstart et il ne fonctionne donc que si ce bit est à 1.

6. Structure du circuit timer/PWM 205

Figure VI.20. Structure du circuit timer/PWM.

Enfin, une lecture demandée pourADR = 00 active le premier buffertrois-états dubas et laisse passer la valeur de la commande #1 surDATA(lecture en 0x400000 pour leprogrammeur). Une lecture pourADR = 01 (0x400004 pour le programmeur) donne lavaleur de la commande #2.

Ainsi, tous les aspectsdu fonctionnement du circuit timer/PWM spécifiés tableau VI.18sont expliqués par cette construction.

Finalement, l’écriture SHDL de l’ensemble est donnée figure VI.21.

7. Structure du sous-système d’exceptions

On va décrire dans cette section la structure complète du sous-ensemble effectuant lagestion des exceptions.On a déjà décrit en détails (section 10) dans quelles cironstances uneexception (trap ou interruption) était déclenchée, puis prise en compte. Plusieurs aspects decette prise en compte sont effectués par le matériel :

1 la détermination de l’exception qui a le niveau de priorité le plus élevé.

2 la mémorisation des interruptions timer et entrées/sorties, le temps qu’elles soientprises en compte.

3 la possibilité de remettre à zéro par programme les interruptions timer et entrées/sortiesmémorisées.

4 la possibilité de lire par programme les interruptions mémorisées.

La figure VI.22 montre le schéma complet qui prend en compte tous ces aspects.


module timer_pwm(rst,clk,ADR[1..0],CS,OE,W,DATA[31..0],out)ENA_CMD1 = CS*W*/ADR1*/ADR0;ENA_CMD2 = CS*W*/ADR1*ADR0;// écriture dans P[i]P[15..0] := DATA[31..16];P[15..0].ena = ENA_CMD1;P[15..0].clk = clk;P[15..0].rst = rst;// écriture dans N[i]N[15..0] := DATA[15..0];N[15..0].ena = ENA_CMD1;N[15..0].clk = clk;N[15..0].rst = rst;// écriture dans prediv[i]prediv[3..0] := DATA[19..16];prediv[3..0].ena = ENA_CMD2;prediv[3..0].clk = clk;prediv[3..0].rst = rst;// écriture dans startstart := DATA[0];start.ena = ENA_CMD2;start.clk = clk;start.rst = rst;//diviseur de fréquencedivfreq(rst,clk,prediv[3..0]: h);// timer/PWMpwm(rst,h,start,P[15..0],N[15..0]: out);// lecture du mot de commande #1OE_CMD1 = CS*/W*OE*/ADR1*/ADR0;DATA[31..16] = P[15..0]:OE_CMD1;DATA[15..0] = N[15..0]:OE_CMD1;// lecture du mot de commande #2OE_CMD2 = CS*/W*OE*/ADR1*ADR0;DATA[19..16] = prediv[3..0]:OE_CMD2;DATA[0] = start:OE_CMD2;end module

Figure VI.21. Écriture SHDL du circuit timer/PWM.

Détermination de l’exception la plus prioritaire

Cette détermination est faite dans la partie droite du schéma de la figure VI.22. Ony trouve le circuit encodeur de priorité, qui reçoit les signaux de détection des différentesexceptions. On retrouve les numéros de priorité de chacune d’elles : 14 pourbus_error ,13 pourinstr_priv (viol de privilège instruction), etc. L’occurrence d’une interruptiontimer est signalée partimer_int et a la priorité 8 ; les interruptions d’entrées/sorties sontsignalées par le vecteurio_int[31..0] ; elles sont toutes reliées à un OR pour en fairela synthèse au niveau 7.

La sortie de l’encodeur de priorité donne le numéro de l’exception la plus prioritaireet cette valeur est ensuite comparée au niveau courant d’exécutionPIL , valeur issue d’unchamp du registre d’état%psr . Une demande de prise en compte d’exceptionexcep_req

n’est faite que si le numéro de l’exception la plus prioritaire est plus élevé que le numérod’exécution courant.

7. Structure du sous-système d’exceptions 207

Figure VI.22. Structure du sous-système d’exceptions.

Masquage des interruptions

On se souvient (section 10) que les interruptions sont ignorées lorsque le bitET

du registre%psr est à 0. C’est bien le cas sur le schéma : les deux sources d’interruptiontimer_out (en provenance du circuit timer) etio[31..0] (en provenance du circuitd’entrées/sorties) passent d’abord par un AND avec le signalET ; si ET = 0 l’occurrencede l’interruption est purement et simplement ignorée.

Mémorisation des interruptions

Les interruptions timer et entrées/sorties ont besoin d’être mémorisées, car ce sont desoccurrences fugitives de fronts montants ou descendants. Des latchs RS asynchrones sontalors le moyen le plus adapté : le vecteur de 32 latchs du haut mémorise les interruptions surles entrées/sorties et le latch du bas mémorise une interruption timer.

Le signaltimer_out , après passage au travers du AND avecET, va sur l’entrée Sdu latch : l’arrivée d’un front montant surtimer_out va se traduire par la mémorisation


d’un 1 dans le latch. De la même façon, chaque signalio[i] passe d’abord au travers duAND, puis au travers d’un XOR qui va éventuellement l’inverser, selon la valeur du signaldir_ioint[i] qui permet de régler le sens du front (montant ou descendant) qui vadéclencher l’interruption.

Commandes de gestion des interruptions mémorisées

Le tableau de la figure VI.23 résume toutes les opérations qui doivent être renduespossiblespar programme pour gérer les interruptions timer et entrées/sorties.Chacune d’elleest mise en place par un élément du schéma général.

adresse read write opération

0x600008 1 0 lire interruptions entrées/sorties mémorisées

0x600008 0 1 raz des interruptions entrées/sorties mémorisées

0x60000C 1 0 lire sens du front d’interruption (0 = front montant)

0x60000C 0 1 écrire sens du front d’interruption

0x400008 1 0 lire bit d’interruption timer

0x400008 0 1 raz bit d’interruption timer

Figure VI.23. Commandes de gestion des interruptions timer et entrées/sorties.

La lecture des interruptions d’entrées/sorties mémorisées est faite par le buffertrois-états du bas du schéma qui a pour entréeio_int[31..0] . Cette lecture a lieu lorsquecs_io*read*/excep_mode*abus[3]*/abus[2] , c’est à dire pour une adresse quiactivecs_io (le segment [0x600000,0x600010[) et qui se termine par 10XX : 0x600008.

La remise à zéro des interruptions d’entrées/sorties mémorisées est réalisée par leregistre dont les sorties se nommentreset_ioint[31..0] ; elles vont en effet sur lesentrées R des latchs de mémorisation des interruptions d’entrées/sorties. Cette écriture alieu lorsquecs_io*write*/excep_mode*abus[3]*/abus[2] , c’est à dire à la mêmeadresse que la lecture précédente : 0x600008.

Les sens des fronts des interruptions d’entrées/sorties sont configurablesindividuellement par écriture dans le registre dont les sorties se nommentdir_ioint[31..0] ; elles commandent l’inversion éventuelle des signauxen provenance du circuit d’entrées/sortiesio[31..0] . Cette écriture a lieu pourcs_io*write*/excep_mode*abus[3]*abus[2] , c’est à dire 0x60000C.

Le bit d’interruption timertimer_int arrive sur un des buffers trois-étatsdu bas ; il estlu pourcs_timer*write*/excep_mode*abus[3]*/abus[2] , c’est à dire 0x400008.La remise à zéro du latch de mémorisation de cette interruption se fait par écriture dans labascule dont la sortie se nommereset_tint , à l’adresse 0x400008.

Enfin, la valeur du niveau d’exception le plus élevé est placée automatiquement sur lebus dès queexcep_mode = 1 ; on se souvient (figure VI.10) qu’il s’agit de la troisièmesource d’écriture sur le bus de donnéesdbus , qui se produira lorsqu’une exception seraeffectivement prise en compte et qu’il s’agira d’obtenir son niveau pour élever le niveaud’exécution du processeur.

8. Séquencement des instructions 209

8. Séquencement des instructions

8.1. Problématique du séquencement

Nous avons jusqu’ici décrit ce qui s’appelle lamicromachine, c’est à dire la réuniondes différentssous-systèmes registres, mémoire, UAL et exceptions. Cette micromachinese manoeuvre avec desmicrocommandes, dont on peut donner la liste complète pour lamachine CRAPS :

• read etwrite pour l’accès à la mémoire.

• areg , breg etdreg pour l’accès aux registres.

• cmd_ual pour la commande de l’opération UAL.

• excep_mode pour obtenir le niveau de priorité de l’exception en cours de traitement.

C’est tout ! Tous les autres signaux,abus , bbus , dbus , etc. ne sont pas des commandes ;ce sont des éléments de la micromachine, qui sont indirectement modifiés par lesmicrocommandes listées ci-dessus.

On appelleséquenceurle sous-système du processeur chargé de générer les bonnesséquences de microcommandes en fonction de l’instruction en cours d’exécution. Ilfonctionne avec le reste du processeur selon l’organisation de la figure VI.24.

micromachineséquenceur %ir

CLK

N,Z,V,C

microcommandes

excep_req

Figure VI.24. Le séquenceur envoie des microcommandes en fonction de l’instruction encours,de la valeur des flags et de l’éventuelle présence d’une interruption.

Le séquenceur est l’âme du processeur :sans lui la micromachine reste inerte.À chaquecycle d’horloge, le séquenceur présente une nouvelle combinaison de microcommandes,afin de poursuivre l’exécution de l’instruction en cours.On peut le comparer à un pianiste etles microcommandes à des touches de piano : à chaque tempo il effectue un accord, c’est àdire qu’il actionne plusieurs microcommandes en parallèle. Il effectue le séquencement desinstructions l’une après l’autre, le registre%pc lui servant à connaître l’emplacement de laprochaine instruction à séquencer.


Le début du séquencement d’une instruction s’appelle la phaseFETCH ; il consiste àaller charger dans le registre%ir l’instruction en mémoire centrale située à l’adresse%pc.Cette partie initiale du séquencement est fixe, car le séquenceur ne sait pas encore à quelleinstruction il va avoir à faire. À l’issue de cette phase, l’instruction est disponible dans%ir

et le séquenceur y a accès. Il peut ainsi catégoriser l’instruction parmi des groupes dontle séquencement va être commun. Pour les instructions de branchement conditionnel, leséquencement correct nécessite qu’il dispose de la valeur des flags.

Il ne faut pas oublier les exceptions : lorsque l’une d’elle se produit (excep_req = 1 ),elle affecte le séquencement d’une manière qui sera décrite plus loin.

8.2. Séquenceurs câblés et microprogrammés

Le séquenceur est un circuit séquentiel synchrone parfaitement classique et on pourrale réaliser en utilisant les méthodes présentées au chapitre 3, une fois qu’on aura spécifiéexactement son graphe d’états. On utilisera alors des portes et des bascules pour réaliser lamachine de changements d’états dont les entrées seront les signaux%ir , excep_req et lesflags ; un transcodeur générera les microcommandes qui seront les sorties du circuit.

On parle dans ce cas deséquenceur câblé ;c’est bien sûr la méthode qui assure leséquencement le plus rapide et qui occupe le moins de surface sur la puce.

Pour les processeurs complexes et en particulier pour les processeursCISC, le graphepeut devenir tellement complexe qu’il est préférable d’utiliser une autre approche dite deséquenceur microprogrammédont l’étude détaillée sort du cadre de cet ouvrage. On peuttout de même dire qu’alors, le séquenceur est lui même un petit processeur qui exécutedes sortes de routines associées à chaque instruction, contenues dans une mémoire interneappelée mémoire de microprogramme.Cette approche est plus souple que l’approche câbléecar on peut facilement modifier le séquenceur en modifiant les microprogrammes,mais elleajoute bien sûr un surcoût en temps et en espace.

Dans le cas de CRAPS, le graphe d’états est suffisamment simple pour permettre sansdifficulté un séquenceur câblé ; cela est essentiellement dû au fait que son jeu d’instructionsde type RISC est particulièrement réduit et régulier.

Le graphe d’états complet est trop grand pour être présenté d’un seul morceau et il seradonné par parties, d’abord pour la phase FETCH commune à toutes les instructions, puispour chacun des groupes d’instructions. Il s’agit d’un graphe de MEALY, qui est plus adaptéqu’un graphe de MOORE car, en fournissant au plus tôt les valeurs des sorties, les partiesasynchrones comme l’UAL et la mémoire peuvent commencer leur travail plus tôt.

8.3. Séquencement de la phase FETCH

La phase FETCH forme le début commun au séquencement de toutes les instructions.Elle consiste à lire en mémoire à l’adresse contenue dans%pc, puis à stocker la valeur luedans le registre%ir (figure VI.25).

L’état de départ s’appellefetch ; c’est également l’état vers lequel on retourneà la fin de l’exécution de toute instruction. On va defetch versdecode seulement siexcep_req=0 , c’est à dire si aucune exception n’est en attente de traitement. Sinon il fautaller vers lesous-graphe de gestion des exceptions qui sera décrit plus loin.

Si donc le processeur n’a pas d’exception en attente, il doit aller lire le mot mémoire


read=1, write=0,ual=000000 (ADD), excep_mode=0areg=62, breg=0, creg=63

excep_req = 0 /

decodefetch

de séquencement des exceptionsvers sous−graphe

except_req = 1op = 11

instructions d’accès memoirede séquencement des

vers sous−graphe

instructions de calculde séquencement des

vers sous−graphe

vers sous−graphede séquencement de SETHI et

des instructions de branchement

vers sous−graphede séquencement de CALL

op = 10

op = 01

op = 00

Figure VI.25. Sous-graphe de séquencement de la phase FETCH.

situé à l’adresse contenue dans le registre%pc (= %r62) . Pour cela, il faut se débrouillerpour placer la valeur de%pc sur le bus A : c’est ce qui est fait en plaçant 62 surareg .On place également une valeur quelconque surbreg et on commande une opérationquelconque sur l’UAL, qui toutefois ne modifie pas les flags (ici ADD).read est égalementforcé à 1, ce qui déclenche immédiatement (avant le prochain front d’horloge) la lectureen mémoire à l’adressepc . À l’arrivée du prochain front d’horloge, si la période a étéassez longue, la mémoire aura placé son résultat sur le bus D, et il sera écrit dans le registre%ir (= %r63) , puisqu’on a placé 63 sur la commandedreg .

Si la mémoire est un peu lente par rapport à la fréquence de l’horloge, on peut rajouterun état d’attente intermédiaire entre les étatsfetch etdecode . C’est technique pourra êtreutilisée également avec l’UAL lors des calculs de multiplication et de division qui prennentun temps important.

Arrivé à l’état decode , le séquencement va être orienté vers dessous-graphesdifférents selon le groupe auquel appartient l’instruction courante, maintenant contenuedans%ir . Si on se réfère à la structure des instructions vue à la section 2.4, ce groupe est trèssimplement identifié par le champop constitué des deux bits de poids forts de%ir .

8.4. Séquencement d’une instruction de calcul

Les instructions dont le séquencement est le plus simple sont les instructions de calcularithmétique et logique. Elles sont repérée à partir de l’étatdecode par le fait que le champop de%ir vaut102. (figure VI.26).

Il y a néanmoins deux cas, selon que le deuxième argument de l’instruction est unevaleur immédiate (comme dansaddcc %r1, 5, %r2 ) ou un registre (comme dansaddcc%r1, %r2, %r3 ). Ces deux cas sont distingués par le bit 13 de%psr , comme on le voit surle graphe.

Instruction de calcul avec une constante comme deuxième argument

Si %ir[13]=1 , le deuxième argument est une constante immédiate sur 13 bits, quiest logée à l’intérieur même de l’instruction%ir . On va alors l’extraire de%ir et la copierdans le registre temporaire%tmp1, puis faire ensuite l’opération entre le registre de numérors1 et tmp1 , pour enfin mettre le résultat dans le registre de numérord . rs1 et rd sont


fetch calc_immdecode

null /

areg=rs1, breg=32, dreg=rdcmd_ual=op3read=0, write=0, oe_num=01

null /read=0, write=0, oe_num=01cmd_ual=ADDareg=62, breg=35, dreg=62

pc+4

op = 10, %ir[13]=0 /read=0, write=0, oe_num=01cmd_ual=op3areg=rs1, breg=rs2, dreg=rd

op = 10, %ir[13]=1 /

areg=63, breg=0, dreg=32

read=0, write=0, excep_mode=0cmd_ual=SIGNEXT13

...

Figure VI.26. Sous-graphe de séquencement d’une instruction de calcul.

des champs de 5 bits du registre%ir qui contiennent les numéros des registres traités parl’instruction (voir figure 2.4).

L’extraction de la constante de 13 bits est effectuée entre l’étatdecode et l’étatcalc_imm , par envoi du registre%ir sur le bus A (areg = 63 ) et par application dela commandecmd_ual = SIGNEXT13 sur l’UAL. On a déjà vu (section 2.2) que cetteopération avait pour effet de ne garder que les 13 bits de poids faibles de la valeur (ici%ir )et d’effectuer une extension du signe. La constante ainsi ’nettoyée’, est copiée dans%tmp1

(dreg = 32) au prochain front d’horloge.

Avant de revenir à l’étatfetch pour exécuter l’instruction suivante, il faut incrémenterle registre%pcde 4, pour qu’il pointe sur l’instruction suivante. C’est ce qui est fait à partirde l’étatpc+4 , qui effectue une addition sans modification des flags(cmd_ual = ADD)

entre la valeur de%pc (areg = 62) et la valeur du registre%r35 (breg = 35) dont onse rappelle qu’il vaut toujours 4 (voir section 1). Le résultat est stocké dans%pc (dreg =32) avant de retourner à l’étatfetch , prêt pour l’exécution de l’instruction suivante qui setrouve en séquence.

Instruction de calcul avec un registre comme deuxième argument

Lorsque le deuxième argument de l’instruction de calcul est un registre(%ir[13] =0) , il n’est pas nécessaire d’avoir cet état intermédiairecalc_imm ; on peut directementdemander l’opération entre les registres, ce qui est fait dans la transition entredecode etpc+4 : cmd_ual = op3, areg = rs1, breg = rs2, dreg = rd . On incrémenteensuite%pcde 4 pour passer à l’instruction suivante.

8.5. Séquencement des instructions d’accès mémoire

Les instructions d’accès mémoire ont des arguments similaires à ceux des instructionsde calcul ; ils partagent d’ailleurs le même format d’instruction (format 3, figure V.8).

Séquencement des instructions ld et ldub

La figure VI.27 montre lesous-graphe de séquencement de ces deux instructions. Leséquencement deld est simple; le séquencement deldub l’est moins et occupe l’essentieldu bas de la figure.

Le début du séquencement est le même que pour une instruction de calcul. L’adresse


fetch decode

...excep_req = 0 /

null /

areg=rs1, breg=32, dreg=32

read=0, write=0, excep_mode=0cmd_ual=ADD

read=0, write=0, excep_mode=0cmd_ual=ADDareg=rs1, breg=rs2, dreg=32

op = 11, op3 = ld+ldub, %ir[13] = 0 /null /read=0, write=0, excep_mode=0cmd_ual=ADDareg=62, breg=35, dreg=62

pc+4

byte2byte0 byte1 byte3

cmd_ual=SRLareg=32, breg=38

null /read=0, write=0excep_mode = 0,

dreg=rd

ldshift

cmd_ual=SLLareg=32, breg=36


dreg=32



dreg=32

cmd_ual=SRLareg=32, breg=38


dreg=rd

read=1, write=0, excep_mode=0cmd_ual=ADDareg=32, breg=0, dreg=rd

op3 = ld /

cmd_ual=ADDareg=32, breg=0

read=1, write=0excep_mode = 0,

dreg=32

%tmp1[1,0]=00 /op3 = ldub,



dreg=32

%tmp1[1,0]=01 /op3 = ldub,



dreg=32

%tmp1[1,0]=10 /op3 = ldub,



dreg=32

%tmp1[1,0]=11 /op3 = ldub,



dreg=32

op = 11, op3 = ld+ldub, %ir[13] = 1 /



read

ld_imm

Figure VI.27. Sous-graphe de séquencement des instructionsld et ldub .

de la donnée à lire est le résultat d’une addition,dont le deuxième terme peut être un registre(comme dansld [%r1+%r2], %r3 ) ou une constante immédiate (comme dansldub[%r1-5], %r2 ). Cette différence est également distinguée par le bit%ir[13] , ce quiconduit aux deux branches à partir dedecode . Une fois enread , l’adresse de la donnée àlire en mémoire est dans le registre%tmp1 (numéro 32).

À partir deread , si l’instruction estld et nonldub , les chosessont simples : lire le moten mémoire et le stocker dans le registre de numérord , ce qui est fait entreread etpc+4 ;

il ne reste plus qu’à incrémenter%pcde 4.

Si l’instruction estldub , il va falloir lire le mot mémoire de 32 bits situé à l’adressecontenue dans%tmp1et isoler parmi les 4 octets qui composent ce mot, celui qui est désignépar l’instructionldub . On rappelle (voir annexe B) queldub place dans les 8 bits de poidsfaibles du registre destination l’octet d’adresse désignée et force à 0 les 24 bits de poids forts.On rappelle également que lors d’un accès mémoire, les circuits mémoire ne reçoivent pasles 2 bits de poids faibles de l’adresse (voir section 4) et par conséquent lisent 4 octets à lafois. Si on considère par exemple la situation de la figure VI.28 et qu’on souhaite lire l’octetE6 situé à l’adresse 0x1000005, la demande de lecture à cette adresse va lire tout le motmémoire de 32 bits 0x7AE6329F qui entoure cet octet, à partir de l’adresse 0x1000004 quiest le multiple de 4 le plus petit avant 0x1000005.

C’est cette lecture de 32 bits qui est faite entre l’étatread et les étatsbyte0 , byte1 ,etc. Le choix de passer versbyte0 , byte1 , etc. est fait à partir de la valeur des deux bits de


7A E6 32 9F

1000004 1000008

Figure VI.28. Situation de lecture pour l’instruction ldub. L’adresse lue étant 0x1000005,on souhaite isoler l’octet E6 du reste du mot.

poids faibles de l’adresse contenue dans%tmp1. Cela implique d’ailleurs que le schéma dela figure VI.24 a été légèrement simplifié et qu’il y a en réalité les deux signaux%tmp[1,0]

qui vont également de la micromachine vers le séquenceur, nécessaires dans les instructionsldub etstb pour repérer l’octet à isoler.

Dans le cas deldub , cette isolation de l’octet sur les 8 bits de poids faibles du registredestination,avec remplissage à gauche de 24 zéros,est réalisée à l’aide des commandes SRLet SLL de l’UAL. Pour notre exemple, si on veut extraire E6 du mot 7AE6329F, il suffitde le décaler à gauche de 8 positions : E6329F00 (8 zéros entrent par la droite), puis de ledécaler à droite de 24 position : 000000E6 (24 zéros entrent par la gauche). Pour faire cesdifférents décalages, il est nécessaire de disposer des constantes8, 16 et 24.C’est dans ce butqu’on a fait en sorte que ces constantes soient les valeurs des registres%r36, %r37 et%r38

respectivement (voir section 1). À partir debyte0 , seul un décalage à droite de 24 positionsest nécessaire.À partir debyte1 , byte2 etbyte3 , un décalage à gauche préalable de 8, 16et 24 positions (respectivement) est nécessaire.

Séquencement des instructions st et stb

La figure VI.29 montre lesous-graphe de séquencement de ces deux instructions.

Après l’étatdecode , il y a à nouveau la bifurcation entre les instructions avec unevaleur immédiate (telle quest %r1, [%r2+12] ) et celles sans constante immédiate (tellequestb %r1, [%r2+%r4] ).Comme pourld/ldub , on arrive à l’étatw_read après avoircalculé dans%tmp1 (= %r32) la somme de ces deux arguments, qui forme l’adresse où doitêtre effectuée l’écriture.

Dans le cas d’une écriture standardstb , on va directement de l’étatw_read à l’étatpc+4 en effectuant la commande d’écriturewrite=1 . On place l’adresse d’écriture sur lebus A avecareg=32 (=%tmp1); on place la valeur à écrire sur le bus D en la faisant venir surle bus B (breg=rd ) puis en lui faisant traverser l’UAL sans changement avec la commandeNOPB. Après l’écriture en mémoire, qui est supposée durer ici un seul cycle d’horloge, onpasse à l’étatpc+4 pour le passage à l’instruction suivante.

Le cas d’une écriture dans un octet (stb ) est beaucoup plus complexe et inefficace, caron a pris le parti dans l’architecture de CRAPS de ne pas faciliter cette instruction par desconnexions spécialisées entre la mémoire et le bus D. On se rappelle que cette écriture doitse traduire par la modification d’un seul octet en mémoire, c’est à dire la modification de8 bits à l’intérieur d’un mot mémoire de 32 bits, tous les autres bits restants inchangés. Laseule façon de faire consiste à :

1. lire à l’adresse%tmp1 le mot de 32 bits dans lequel se situe l’octet à modifier et leplacer dans le registre temporaire%tmp2.

2. remplacer au sein de%tmp2les 8bits concernéspar les 8bits de poids faiblesdu registreà écrire.On utilisera pour cela les commandes INSBYTE0,etc.de l’UAL,spécialement


fetch decode

...excep_req = 0 /

null /


read=0, write=0, excep_mode=0cmd_ual=ADD

null /read=0, write=0, excep_mode=0cmd_ual=ADDareg=62, breg=33, dreg=62

pc+4

read=0, write=1, excep_mode=0cmd_ual=NOPBareg=32, breg=rd, dreg=0

op3 = st /

read=0, write=0, excep_mode=0cmd_ual=ADDareg=rs1, breg=rs2, dreg=32

op = 11, op3 = st+stb, %ir[13] = 0 /

read=1, write=0, excep_mode=0cmd_ual=ADDareg=32, breg=0, dreg=33

op3 = stb /

insbyte

read=0, write=0op3 = stb, tmp1[1..0]=00 /

cmd_ual=INSBYTE0excep_mode=0











read=0, write=1null /

cmd_ual=NOPBexcep_mode=0


op = 11, op3 = st+stb, %ir[13] = 1 /



st_imm

w_read

write

Figure VI.29. Sous-graphe de séquencement des instructionsst et stb .

conçues à cet effet.

3. réécrire tout le mot de 32 bits%tmp2 à l’adresse d’origine, toujours contenue dans%tmp1.

L’étape 1est réalisée entre les étatsw_read et insbyte , par lancement d’une commande delecture à l’adresse%tmp1(areg=32 et read=1) et stockage du résultat dans le registre%tmp2

(=%r33). On l’aura compris, c’est tout un mot de 32 bits qui est lu, c’est à dire 4 octets.L’étape 2 est réalisée entreinsbyte etwrite , avec 4 chemins possibles selon le numéro del’octet à modifier ; ce numéro est constitué des deux bits de poids faibles de l’adresse%tmp1.L’étape 3 de réécriture est faite entrewrite et pc+4 : placement de l’adresse%tmp1 surle bus A (areg=32) et placement de la donnée à écrire%tmp2 sur le bus D en la plaçant surle bus B (breg=33) et en appliquant la commande NOPB pour lui faire traverser l’UAL.

8.6. Séquencement des instructions de branchement

Avec les instructions de branchement il n’y a que deux cas possibles : soit lebranchement doit être fait, auquel cas il faut ajouter à la valeur de%pc le déplacement,préalablement multiplié par 4 ; soit le branchement ne doit pas être fait auquel cas il fautpasser à l’instruction suivante en ajoutant 4 à%pc.

Ces deux cas correspondent aux deux flèches qui partent de l’étatdecode ; le


séquenceur dispose de l’instruction et des valeurs des flags et a donc tous les moyensde savoir si le branchement doit être effectué. Il doit l’être si l’instruction estba, ou sil’instruction estbe et que Z=1, etc. Il ne doit pas l’être dans toutes les autres situations.

En cas de non branchement, on revient simplement à l’étatfetch en ajoutant 4 à%pc.En cas de branchement, il faut d’abord extraire la constante de déplacement relatif codéesur 22 bits qui est stockée au sein même de l’instruction ; on utilise pour cela la commandeSIGNEXT22 de l’UAL, qui stocke son résultat dans%tmp1 (dreg=32). Ce déplacementétant codé en nombre de mots mémoire, il faut maintenant le multiplier par 4 en le décalantde 2 bits vers la gauche,en plaçant%tmp1sur le bus A (areg=32) et en plaçant la constante 2sur le bus B (breg=34) avec la commande SLL. Le résultat est à nouveau stocké dans%tmp1

(dreg=32), et il est finalement ajouté à%pc (areg=62, breg=32, dreg=62, cmd_ual=ADD)avant le retour à l’étatfetch .

decodefetch

op=00, op2=010, (op3=be et Z=0) ou

areg=62, breg=35, dreg=62cmd_ual=ADDexcep_mode=0read=0, write=0(op3=bneg et N=0) ou etc. /

...excep_req = 0 /

op=00, op2=010, op3 = ba

areg=63, breg=0, dreg=32cmd_ual=SIGNEXT22excep_mode=0read=0, write=0ou (op3=be et Z=1) ou etc. /

branchdispx4

areg=62, breg=32, dreg=62cmd_ual=ADDexcep_mode=0read=0, write=0

null /

areg=32, breg=34, dreg=32cmd_ual=SLLexcep_mode=0read=0, write=0

null /

Figure VI.30. Sous-graphe de séquencement des instructions de branchement.

8.7. Réalisation du séquenceur

Tous lessous-graphes de séquencement n’ont pas été présentés ; ils utilisent tousles techniques qui viennent d’être présentées. Le lecteur est encouragé à les réaliser àtitre d’exercice.

On pourrait également concevoir sans difficultés le circuit séquentiel synchrone,de type MEALY, qui implémente le séquenceur de CRAPS. On utiliserait pour cela lestechniques présentées au chapitre 3 ; il est d’une complexité modeste, avec moins de 50états et ses quelques signaux d’entrées et de sorties. Son étude détaillée serait lourde et d’unintérêt limité ; il a été effectivement mis en oeuvre sur une carte à base de FPGA XILINXSpartan 3. Il fonctionne à une fréquence d’horloge de 25MHz ce qui lui donne une puissancede calcul raisonnable, mais elle pourrait être grandement augmentée par l’utilisation detechniques avancées qui sortent du cadre de cet ouvrage.



9.1. Exercice 1 : décodage d’adresse

Énoncé

Modifier le câblage dusous-système mémoire de CRAPS pour que la RAM soit vuepar le programmeur à partir de l’adresse 0x02000000.

Solution

Il ne s’agit ici que de modifier le signal de décodageRAMproduit par le sous-moduledecod_mem.

On imposait que les 8 bits de poids forts de l’adresse soient : 000000012, c’est à direune adresse de la forme 0000 0001xxxx xxxx xxxx xxxx xxxx xxxx, c’est à dire encore enhexadécimal une adresse de l’intervalle [0x01000000,0x01FFFFFF].En notation SHDL, ona l’écriture suivante, oùadr[15..0] représentent les 16 bits de poids forts de l’adresse :

RAM=CS*/adr15*/adr14*/adr13*/adr12*/adr11*/adr10*/adr9*adr8;

On désire maintenant que les adresses d’implantation de la RAM soient celles dusegment [0x02000000,0x02FFFFFF], c’est à dire que les 8 bits de poids forts de l’adressesoient 000000102. Il suffit donc de modifier la fin de l’équation de décodage de la RAM :

RAM=CS*/adr15*/adr14*/adr13*/adr12*/adr11*/adr10*adr9*/adr8;

9.2. Exercice 2 : construction d’un circuit d’entrées/sorties simplifié

Énoncé

Concevoir un circuit d’entrées/sorties au fonctionnement simplifié :

1 il possède 32 lignes d’entréesins[31..0] et 32 lignes de sortiesouts[31..0] ,

2 l’écriture à l’adresse 0x600000 (pour le programmeur) projète la valeur écrite surouts ,

3 la lecture à l’adresse 0x600000 fournit les valeurs échantillonnées surins ,

4 les changements de valeurs sur les entrées ne déclenchent aucune interruption.

Solution

L’adresse 0x00600000 à laquelle réagit le circuit est celle qui est vue par leprogrammeur; son utilisation en lecture ou en écriture conduit à l’activation de la ligneCS

par la logique de décodage. Comme le circuit ne réagit qu’à cette seule adresse, il n’a plusbesoin d’aucune ligne d’adresse (alors qu’il en utilisait 2 dans sa version initiale), ce quiconduit à l’interface de la figure VI.31et au mode d’utilisation de la figure VI.32.

Finalement, le schéma qui réalise ces fonctions s’obtient par simplification du schémadu circuit initial (figure VI.33).


Figure VI.31. Interface du circuit d’entrées/sorties.

W opération

0 lire l’état des entrées

1 écrire sur les sorties

Figure VI.32. Spécification de fonctionnement du circuit d’entrées/sorties.

Figure VI.33. Structure du circuit d’entrées/sorties,pour un biti .

L’écriture en 0x00600000 provoqueCS*W = 1, soit un stockage deDATA[i] dansla bascule, avec sortie de la valeur surouts[i] . La lecture en 0x00600000 provoqueCS*/W = 1 , soit le passage de la valeur présente surins[i] sur le bus de donnéesDATA[i] .

Références[1] A. Cezes et J. Delacroix.Architecture des Machines et des Systèmes Informatiques.

Dunod. 2nd Édition, 2005.

[2] Hennessy and Patterson.Computer Organisation and Design. Morgan Kaufman.Second Edition, 1998.

[3] J.-J. Schwarz.Architecture des Ordinateurs. Eyrolles. 2nd Edition, 2005.

[4] R. Strandh et I. Durand.Architecture de l’ordinateur. Dunod, 2005.

[5] Andrew S. Tanenbaum.Architecture de l’ordinateur. Pearson Education, 2005.

[6] John F. Wakely.Digital Design. Prentice Hall. 5th Edition, 2000.

[7] P. Zanela et Y. Ligier.Architecture et Technologie des Ordinateurs. Dunod, 2005.

219

Annexe A

Tables diverses

Puissances de 2−12 0,5 12 2

−22 0,25 22 4

−32 0,125 32 8

−42 0,0625 42 16

−52 0,03125 52 32

−62 0,015625 62 64

−72 0,0078125 72 128

−82 0,00390625 82 256

−92 0,001953125 92 512

−102 0,0009765625 102 1024

−112 0,00048828125 112 2048

−122 0,000244140625 122 4096

−132 0,0001220703125 132 8192

−142 0,00006103515625 142 16384

−152 0,000030517578125 152 32768

−162 0,0000152587890625 162 65536

unités

milliseconde (ms) −310 s Kilo (K) 102 ∼− 310microseconde (µs) −610 s Mega (M) 202 ∼− 610nanoseconde (ns) −910 s Giga (G) 302 ∼− 910picoseconde (ps) −1210 s Tera (T) 402 ∼− 1210

220

Annexe B

CRAPS : guide du programmeur

Le langage assembleur du processeur CRAPSest largement inspiré de celui du SPARCversion 8. Il n’implémente pas la notion de fenêtre de registres et les instructions qui suiventles branchements n’ont pas de statut spécial. Il ne possède pas d’unité de calcul flottant.

B.1. Instructions synthétiques

Les instructions du tableau suivant sont appeléesinstructions synthétiques; ce sont des casparticuliers d’instructions plus générales. Plusieursd’entre-elles s’appuient sur le fait que%r0 vaut toujours 0.

Instruction Effet Implémentation

clr %ri met à zéro %ri orcc %r0, %r0, %ri

mov %ri,%rj copie %ri dans %rj orcc %ri, %r0, %rj

inccc %ri incrémente %ri addcc %ri, 1, %ri

deccc %ri décrémente %ri subcc %ri, 1, %ri

notcc %ri,%rj %rj <- complément de %ri xnorcc %ri, %ri, %rj

setval31..0, %ri copieval dans %ri sethival31..10, %ri

orcc %ri,val9..0, %ri

setq val, %ri copie val dans %ri orcc %r0, val, %ri

( − 4096 ≤val ≤ 4095)

cmp %ri, %rj compare %ri et %rj subcc %ri, %rj, %r0

tst %ri teste nullité et signe de %ri orcc %ri, %r0, %r0

negcc %ri inverse %ri subcc %r0, %ri, %ri

notcc %ri,%rj complémente %ri en %rj xnorcc %ri, %r0, %rj

nop no operation sethi 0,%r0

221

222 ANNEXEB. CRAPS :GUIDE DU PROGRAMMEUR

jmp %ri branchement à l’adresse absolue %rijmpl %ri, %r0

ret retour de procédure terminale jmpl %r31+4, %r0

push %ri empile %ri sub %r30, 4, %r30

st %ri, [%r30]

pop %ri dépile %ri ld [%r30], %ri

add %r30, 4, %r30

B.1. Instructions synthétiques 223

B.2. Jeu d’instructions du processeur CRAPS

Les instructions marquées d’un † sont privilégiées, et ne peuvent être exécutées que si le bitsuperviseur dans %psr est à 1.

Instruction : add

Description : Effectue l’addition en complément à deux des deux opérandes, et place lerésultat dans l’opérande résultat. La retenue C n’est pas ajoutée aux arguments. Les flags(condition codes, cc) ne sont pas modifiés par cette opération, contrairement àaddcc.Flags affectés :aucunExemple :add %r1, 5, %r1

Ajoute 5 au contenu de%r1; ne modifie pas les flags.

Instruction : addcc

Description : Effectue l’addition en complément à deux des deux opérandes, et place lerésultat dans l’opérande résultat. La retenue C n’est pas ajoutée aux arguments. Les flags(condition codes, cc) sont positionnés conformément au résultat (voiradd).Flags affectés :N, Z, V, CExemple :addcc %r1, 5, %r1

Ajoute 5 au contenu de%r1, et positionne les flags.

Instruction : andcc

Description :Effectue un ET logique bit à bit entre les opérandessources,et place le résultatdans l’opérande résultat. Les flags (condition codes, cc) sont positionnés conformémentau résultat.Flags affectés :N, ZExemple :andcc %r1, %r2, %r3

Effectue le ET logique bit à bit entre les contenus de%r1 et %r2, et place le résultatdans%r3

Instruction : ba

Description : Se branche à l’adresse obtenue en ajoutant 4 xdisp22 à l’adresse del’instruction courante (ba elle-même).disp22peut être négatif, ce qui correspond à unbranchement à un point antérieur du programme.Flags affectés :aucunExemple :ba label

Se branche àlabel . Le déplacementdisp22codé dans l’instruction est égal à la distance(en mots) qui sépare l’instruction courante de l’adresselabel .

Instruction : bcc

Description : Si la conditioncc est vérifiée, se branche à l’adresse obtenue en ajoutant4 x disp22à l’adresse de l’instruction courante. Si la condition n’est pas vérifiée, passeà l’instruction suivante en séquence.disp22peut être négatif, ce qui correspond à unbranchement à un point antérieur du programme. On trouvera en annexe B.3 les tablescomplètes des conditions de test possibles.Flags affectés :aucunExemple :bcs label


Se branche àlabelsiC vaut 1.C’est le déplacement relatif entrelabel et l’adresse courantede l’instruction, en nombre de mots, qui est codé dans le champdisp22de l’instruction.

Instruction : call

Description : Appelle unsous-programme et stocke l’adresse de l’instruction courante(celle du call lui-même) dans%r31. Le champdisp30 du code machine contient unevaleur de déplacement par rapport à l’adresse de l’instruction courante, comptée en mots.Autrement dit, l’adresse de la prochaine instruction à exécuter est calculée en ajoutant 4 xdisp30à l’adresse de l’instruction courante (dans %pc).disp30peut bien sûr être négatif.Flags affectés :aucunExemple :call ssprog

Sauvegarde %pc dans %r31, puis se branche au sous-programme qui commence à l’adressessprog.

Instruction : jmpl

Description : Jump and Link: retour d’un sous-programme. Effectue un saut à l’adressedéfinie par l’opérande source, et sauve l’adresse de l’instruction courante (lejmpl) dansl’opérande résultat.Flags affectés :aucunExemple :jmpl %r31 + 4, %r0

Retour d’un sous-programme, équivalent à l’instruction synthétiqueret . La valeurdu PC ayant été sauvegardée dans%r31 lors ducall précédent, l’adresse de retour doiteffectivement être%r31 + 4. L’adresse courante est éliminée dans%r0.

Instruction : ld

Description : Load word. Charge un registre à partir d’un mot de 32 bits de la mémoirecentrale, soit 4 octets consécutifs. L’adresse doit être alignée en mémoire sur un mot,c’est à dire qu’elle doit être un multiple de 4, sinon une exceptionalign_error est générée.L’adresse est calculée en ajoutant le contenu du registre du champrs1au contenu du champrs2ou de la valeur immédiate contenue dans le champsimm13, selon le cas.Flags affectés :N et Z.Exemple :ld [%r2+%r3], %r1

Copie dans le registre%r1 les 4 octets en mémoire commençant à l’adresse obtenue enadditionnant les valeurs des registres%r2 et %r3. Le premier octet (celui d’adresse%r2 +%r3) sera copié dans les poids forts de%r1, le quatrième octet (d’adresse%r2 + %r3 + 3)sera copié dans les poids faibles de%r1.

Instruction : ldub

Description : Load unsigned byte. Charge les 8 bits de poids faibles d’un registre depuis lamémoire centrale. L’adresse peut être quelconque. Elle est calculée en ajoutant le contenudu registre du champrs1au contenu du champrs2ou à valeur immédiate contenue dans lechampsimm13, selon le cas. Les 24 bits de poids forts du registre sont forcés à 0.Flags affectés :N et Z.Exemple :ldub [%r2+6], %r1

Copie l’octet situé à l’adresse%r2+ 6 dans les 8 bits de poids faibles du registre%r1, et forceà 0 les 24 bits de poids forts.

B.2. Jeu d’instructions du processeur CRAPS 225

Instruction : orcc

Description : Effectue un OU logique bit à bit entre les opérandes sources, et placele résultat dans l’opérande résultat. Les flags (condition codes, cc) sont positionnésconformément au résultat.Flags affectés :N, ZExemple :orcc %r1, 1, %r1

Positionne à 1 le bit de poids le plus faible de%r1et laisse tous les autres inchangés.

Instruction : rdpsr †

Description : Lit le registre d’état %psr et le copie dans un registre %ri.Flags affectés :aucunExemple :rdpsr %r1

Lit %psr et le copie dans %r1

Instruction : rete

Description : Défait les empilements de %pc et de %psr qui sont réalisés lors de la priseen compte d’une exception. %psr reprend donc sa valeur initiale (et en particulier le niveaud’exécutionpil), et %pc reprend la valeur qu’il avait au moment du départ. Cette instructiondoit être placée à la fin de chaque handler d’exception.Flags affectés :potentiellement tous, lors du dépilement de %psrExemple :rete

Instruction : sethi

Description : Positionne les 22 bits de poids forts d’un registre, et force à zéro les 10 bits depoids faibles.Flags affectés :aucunExemple :sethi 0xE2F1, %r1

Positionne les 22 bits de poids forts de%r1 à E2F116 et force à 0 les 10 bits de poidsfaibles.

Instruction : sll

Description : Décale le contenu d’un registre vers la gauche d’un nombre de positionsdésigné par le deuxième argument, compris entre 0 et 31.Si ce nombre est fourni sous formed’une valeur de registre, seuls les 5 bits de poids faibles sont utilisés.Flags affectés :aucunExemple :sll %r1, 7, %r2

Décale le contenu de%r1vers la gauche de 7 bits, avec insertion de 7 zéros par la droite, etstocke le résultat dans%r2. Aucun flag n’est affecté.

Instruction : srl

Description : Décale le contenu d’un registre vers la droite d’un nombre de positionsdésigné par le deuxième argument, compris entre 0 et 31.Si ce nombre est fourni sous formed’une valeur de registre, seuls les 5 bits de poids faibles sont utilisés.Flags affectés :aucunExemple :srl %r1, 7, %r2

Décale le contenu de%r1vers la droite de 7 bits, avec insertion de 7 zéros par la gauche, etstocke le résultat dans%r2. Aucun flag n’est affecté.


Instruction : st

Description : Stocke le contenu d’un registre en mémoire centrale. L’adresse doit êtrealignée en mémoire sur un mot, c’est à dire qu’elle doit être un multiple de 4. L’adresse estcalculée en ajoutant le contenu du registre du champrs1au contenu du champrs2ou de lavaleur contenue dans le champsimm13, selon le cas. Le champrd est utilisé pour désignerle registre source.Flags affectés :aucunExemple :st %r1, [%r2]

Copie le contenu du registre%r1dans la case mémoire dont l’adresse est la valeur de %r2.Dans ce cas particulier,rs2= 0, et l’instruction pourrait être écrite :st %r1, [%r2+%r0]

Instruction : stb

Description : Stocke les 8 bits de poids faibles d’un registre, à une adresse quelconque enmémoire centrale.Seul un octet de la mémoire est affecté.L’adresse est calculée en ajoutantle contenu du registre du champrs1au contenu du champrs2ou de la valeur contenue dansle champsimm13, selon le cas. Le champrd est utilisé pour désigner le registre source.Flags affectés :aucunExemple :stb %r1, [%r2+5]

Copie les 8 bits de poids faibles de%r1dans la case mémoire dont l’adresse est la valeur de%r2+5. Seul cet octet est affecté en mémoire.

Instruction : sub

Description : Effectue la soustraction en complément à deux des deux opérandes, et placele résultat dans l’opérande résultat. les flags (condition codes, cc) ne sont pas affectés.Flags affectés :aucunExemple :sub %r1, 5, %r1

Soustrait 5 au contenu de%r1, et ne modifie pas les flags.

Instruction : subcc

Description : Effectue la soustraction en complément à deux des deux opérandes, etplace le résultat dans l’opérande résultat. Les flags (condition codes, cc) sont positionnésconformément au résultat.Flags affectés :N, Z, V, CExemple :subcc %r1, 5, %r1

Soustrait 5 au contenu de%r1, et positionne les flags.

Instruction : udivcc

Description : Unsigned divide. Effectue une division non signée 32 bits / 16 bits aveccalcul du quotient et du reste. Le quotient est placé dans les 16 bits de poids forts du registredestination, le reste dans les 16 bits de poids faibles.Flags affectés :ZExemple :udiv %r7, %r1, %r6

Effectue la division entière non signée entre les 16 bits de poids faibles de %r7 et les 16 bitsde poids faible de %r1, et place le quotient dans les 16 bits de poids forts de %r6 et le restedans les 16 bits de poids faibles de %r6.

Instruction : umulcc

Description : Unsigned multiply. Effectue une multiplication non signée 16 bits x 16 bitsvers 32 bits. Seuls les 16 bits de poids faibles des deux opérandes source sont pris en compte

B.2. Jeu d’instructions du processeur CRAPS 227

dans le calcul.Flags affectés :ZExemple :umul %r7, %r1, %r6

Copie dans %r6 le résultat de la multiplication non signée entre les 16 bits de poids faiblesde %r7 et les 16 bits de poids faibles de %r1.

Instruction : wrpsr †

Description : Copie dans %psr (Processor Status Register) le contenu d’un registre %ri.Flags affectés :aucunExemple :wrpsr %r1

Copie dans %psr le contenu de %r1.

Instruction : wrtbr †

Description : Copie dans %tbr (Trap Base Register) le contenu d’un registre %ri.Flags affectés :aucunExemple :wrtbr %r1

Copie dans %tbr le contenu de %r1.

Instruction : xnorcc

Description : Effectue un XNOR logique (inverse du XOR, encore appelé coïncidence)bit à bit entre les opérandes sources et place le résultat dans l’opérande résultat. Les flags(condition codes, cc) sont positionnés conformément au résultat.Flags affectés :N, ZExemple :xnorcc %r7, %r1, %r6

Copie dans %r6 le xnor calculé bit à bit entre %r7 et %r1 et positionne les flags N et Zen conséquence.

Instruction : xorcc

Description : Effectue un XOR logique bit à bit entre les opérandes sources et placele résultat dans l’opérande résultat. Les flags (condition codes, cc) sont positionnésconformément au résultat.Flags affectés :N, ZExemple :xorcc %r7, %r1, %r6

Copie dans %r6 le xor calculé bit à bit entre %r7 et %r1, et positionne les flags N et Zen conséquence.


B.3. Tables des branchements conditionnels


ba Branch Always 1

beq (synonyme : bz) Branch on Equal Z

bne (synonyme : bnz) Branch on Not Equal not Z

bneg (synonyme : bn) Branch on Negative N

bpos (synonyme : bnn) Branch on Positive not N

bcs Branch on Carry Set C

bcc Branch on Carry Clear not C

bvs Branch on Overflow Set V

bvc Branch on Overflow Clear not V

Figure B.1. Branchements conditionnels associés à un seul flag.


bg Branch on Greater not (Z or (N xor V))

bge Branch on Greater or Equal not (N xor V)

bl Branch on Less (Nxor V)

ble Branch on Less or Equal Zor (N xor V)

Figure B.2. Branchements conditionnels associés à une arithmétique signée.


bgu Branch on Greater Unsigned not (Z or C)

bcc Branch on greater than, or equal, unsigned not C

bcs Branch on less than, unsigned C

bleu Branch on Less or Equal Unsigned Zor C

Figure B.3. Branchements conditionnels associés à une arithmétique non signée.

B.4. Format binaire des instructions de CRAPS

B.4. Format binaire des instructions de CRAPS 229

0

Format 1 : call

1 disp30

op

0 0 cond op2 disp220

op

0 0 rd op2 imm22

op Format 2 : sethi et branchements

2b

2a

rd1 op3 rs1

rd1 op3 rs1 rs2

simm13 3b

3at

t

− − − − − −

t = 1 : accès mémoire, t = 0 : instruction arithmétique

op Format 3 : accès mémoire, instructions arithmétiques

0 −−

1

op2 Instr.

010 branch

100 sethi

op3 (t = 0) Instr.

000000 add

010000 addcc

000100 sub

010100 subcc

011010 umulcc

010001 andcc

010010 orcc

010011 xorcc

010111 xnorcc

110101 sll

110110 srl

111000 jmpl

op3 (t = 1) Instr.

000000 ld

000001 ldub

000100 st

000101 stb

cond Branchement

1000 ba

0001 be

1001 bne

0101 bcs

1101 bcc

1110 bpos

0110 bneg

0111 bvs

1111 bvc

1010 bg

0010 ble

1011 bge

0011 bl

1100 bgu

0100 bleu


B.5. Directives de l’assembleur CRAPS

Syntaxe Rôle

.org val32 force à val la nouvelle adressed’assemblage

ex : data .org 0x8000

label .eq val32 associeval 3 2 à label dans la table dessymboles

label = val32 idem

ex :NB .eq 5

.word val32(,val32) ∗ alloue et initialise des mots mémoire de 32bits consécutifsex :list .word 2,3,5,7

.byte vbyte(, vbyte) ∗ alloue et initialise en mémoire des octetsconsécutifsex text .byte 10,13,"erreur",0

.malloc n alloue sans initialisern octets consécutifs

ex :buffer .malloc 100

.global sym Fait desymun symbole global, visible parles autres modulesex :.global strout

val32 représente un nombre de l’intervalle[0, 322 − 1], ou de l’intervalle 32[ − 2 , 322 − 1].vbytereprésente une ou plusieurs descriptions d’octets : un nombre de[0, 255]ou une suitede caractères entre apostrophes.

B.5. Directives de l’assembleur CRAPS 231

B.6. Cartographie mémoire de CRAPS

timer

[0000 0000 − 0000 FFFF]

[0060 0000 − 0060 000F]

direction

0060 0000

0060 0004

[0100 0000 − 01FF FFFF]

ROM (64K)

entrées / sorties

RAM (16 Mo)

[0040 0000 − 0040 000B]

0060 0008

0060 000C

données

ITs memorisees

sens front ITs

0040 0004

0040 0000

0040 0008IT timer

commande #2

commande #1

B.7. Programmation des entrées/sorties


0x600000 0 lire l’état des entrées

0x600000 1 écrire sur les sorties

0x600004 0 lire configuration lignes

0x600004 1 configurer les lignes

0x600008 0 lire interruptions mémorisées

0x600008 1 raz des interruptions mémorisées

0x60000C 0 lire sens du front d’interruption (0 = front montant)

0x60000C 1 écrire sens du front d’interruption

B.8. Programmation du timer


0x400000 0 lire le registre de commande #1 (P + N)

0x400000 1 écrire le registre de commande #1 (P + N)

0x400004 0 lire le registre de commande #2 (prediv + start)

0x400004 1 écrire le registre de commande #2 (prediv + start)

0x400008 0 lire bit d’interruption timer

0x400008 1 raz bit d’interruption timer


B.9. Liste des exceptions

exception priorité numéro de type (tt)

reset 15 voir texte

bus error 14 14

instruction privilégiée 13 13

instruction illégale 12 12

division par zéro 11 11

erreur d’alignement 10 10

interruption timer 8 8

interruption entrées/sorties 7 7

Glossaire

accès aléatoirePour une mémoire, indique la possibilitéde faire des opérations successives delecture et-ou d’écriture à des adressesquelconques, dans n’importe quel ordre.Pour un fichier, indique la possibilitéd’effectuer une suite d’accès en lecture ouen écriture à desenregistrementssitués àdes positions quelconques.Voir aussiaccèsséquentiel.

accès direct mémoireVoir DMA.

accès séquentielSerial access. Mode de lecture oud’écriture de données qui suit un ordre derangement préétabli.

adressage absoluVoir adressage direct.

adressage directUtilisé en langage d’assemblage et enlangage machine. Mode d’adressage danslequel l’adresse (fixe) de la donnée enmémoire est fournie dans l’instruction. Estaussi appelé adressage absolu.

adressage immédiatUtilisé en langage d’assemblage et enlangage machine. Mode d’adressagedans lequel la donnée est fournie dansl’instruction elle même. Aucun autre accèsen mémoire n’est nécessaire.

AGPAdvanced Graphics Port. Portde communication spécialisé entre leprocesseur graphique et la carte mère,opérant à un débit de 522 MBs.

algèbre de BooleVoir Boole.

ASCIIAmerican Standard Code for InternationalInterchange. Codage des caractèresanglo-saxons sur 7 bits. La plupart descodages de caractères (par exempleISO-Latin 1) sont des extensions sur 8 bitsde l’encodage ASCII.

ASICUn ASIC (Application SpecificIntegrated Circuit) est un circuit intégréréalisé pour une application spécifique,contrairement auxPLDs et FPGAs quisont reprogrammables et peuvent réaliserun ensemble varié de fonctions. Un ASICest un peu plus rapide que son équivalentPLD ou FPGA, mais il doit être produiten grandes quantités pour que son coût àl’unité soit raisonnable.

assembleur (langage)Language symbolique de programmationassocié à un processeur, qui est en faitune expression directe plus lisible d’unprogramme écrit enlangage machine.

assembleur (programme)Programme de traduction qui convertit enlangage machineun programme écrit enlangage assembleur.

asynchroneSe dit d’un circuit ou d’un composant quin’est passynchrone, c’est à dire dont lessorties changent peu de temps après queles entrées aient changées, et non après unfront d’horloge.

233

234 GLOSSAIRE

big-endianVoir little-endian.

bistableVoir latch.

bitForme abrégée de ’binary digit’.Information représentée par un symbole àdeux valeurs, généralement notées 0 et 1,associées aux deux états d’un dispositif.

bogueTraduction officielle française de ’bug’.Voir bug.

BooleGeorges Boole (1815-1864),mathématicien anglais, publie en 1954ses travaux sur une algèbre permettantde représenter des informations factuellesbinaires telles que ’La porte est fermée’ou ’La porte n’est pas fermée’. L’algèbrede Boole a été ensuite développéepar Shannon sous la forme que nousconnaissons aujourd’hui.

bufferSe dit d’un élément logiciel ou matériel.Mémoire ou partie de mémoire permettantle stockage temporaire de données entredeux organes.

bugDéfaut d’un programme se manifestant pardes anomalies de fonctionnement.

busEnsemble de lignes électriques véhiculantun groupe de signaux particuliers.

byteForme anglaise du mot ’octet’. Groupe de8 bits.

carte mèreCircuit imprimé sur lequel est situé le

processeur, la mémoire centrale et lescontrôleurs des principaux périphériqueset bus d’un ordinateur. Des cartesadditionnelles (carte graphique, carteson, etc.) viennent s’enficher sur lesconnecteurs qui y sont présents (PCI, AGP,USB, etc.)

chargeurModule du système d’exploitationresponsable du placement en mémoirecentrale d’un programme à exécuter.

CISCComplex Instruction Set Computer. Ceterme a été créé en même temps etpour s’opposer au termeRISC. Désigneles processeurs aux jeux d’instructionscomplexes et de longueurs variables, quiutilisent généralement un séquenceurmicroprogrammé pour s’exécuter. L’IntelPentium, le Motorola 68000 sont desexemples de processeurs CISC.

CMOSComplementary Metal OxydeSemiconductor. Technologie defabrication de circuits intégrésutilisée pourles processeurs, les microcontrôleursetles mémoires statiques. Ils se distinguentpar leur fort taux d’intégration, leur faibledissipation thermique, et le fait qu’ils neconsomment du courant significativementque lors des changements d’état.

codage par champsFaçon de coder les instructions d’unlangage machine, dans laquelle unesuccession hiérarchique de champs de bitsdans l’instruction permet de la décoder etde l’exécuter.

compilateurTraducteur d’un langage vers un autre,généralement d’un langage évolué vers uncode objet proche du langage machine.

CPLD

Glossaire 235

Complex Programmable Logic Device.UnCPLD est unPLD de grande capacité.

CPUCentral Processing Unit. Souvent utilisécomme synonyme deprocesseur. Voirunité centrale.

debuggerOutil logiciel permettant d’exécuter unprogramme sous contrôle, en y plaçant despoints d’arrêt et en permettant l’inspectionde l’état des variables et de la mémoire.

décodageVoir décodeur.

décodeurCircuit traduisant une adresse enune information d’appartenance à unsous-espace d’adresse.

DMADirect Memory Acces = accès directmémoire. Dispositif lié à la mémoire quipermet d’y faire des lectures et-ou desécritures sans passer par l’unité centrale.Les disques durs, les cartes graphiques,les cartes son fonctionnent le plus souventen DMA.

DRAMVoir mémoire dynamique.

EBCDICAncien codage de caractères tombé endésuétude, qui était employé dans lesmachines de gestion.

échantillonnageMémorisation de la valeur d’un signal(0 ou 1 en logique digitale) à un momentprécis,généralement déterminé par le frontmontant ou descendant d’un autre signal.

éditeur de lienVoir édition de lien.

éditeur de texteProgramme permettant l’édition de fichierscontenant uniquement des lignes de texte,sans aucune indication de formatage.L’encodage des caractèrespeut être ASCII,un encodage ISO sur 8 bits ou Unicode.

édition de lienOpération de fusion de plusieurs fichiersde code objetpour produire un fichier decode exécutable.

EEPROMElectrically Erasable PROM. Mémoiremorte reprogrammable, effaçableélectriquement par octet.

enregistrementDans un fichier, se dit d’un élémentlogique de celui-ci. Dans un programme,synonyme de structure de données.

entranceVoir fan-in.

EPROMErasable PROM. Est parfois appeléREPROM (REprogramable PROM).Mémoire morte reprogrammable munied’une petite fenêtre de quartz, et effaçablepar une exposition aux ultra-violets.

exceptionÉvénement exceptionnel qui intervientpendant le déroulement d’unprogramme. Les exceptions à causeinterne sont appeléestraps (division par0, débordement arithmétique, bus error,etc.) et les exception à cause externesont appelées interruptions (find’entrée/sortie disque, réseau ; événementclavier, USB ; etc.). La prise en comptede l’exception provoque l’exécutiond’un sous-programme associé appelégestionnaire d’exception.

fan-in

236 GLOSSAIRE

Caractérise le courant qu’absorbe l’entréed’une porte logique, mesuré en nombre detelles entrées qui peuvent être reliées à unesortie de même technologie.

fan-outCaractérise le courant maximumque peut générer la sortie d’une portelogique, mesuré en nombre d’entrées demême technologie qui peuvent lui êtreconnectées.

flagVoir indicateur.

flashVoir mémoire flash.

FPGAField Programmable Gate Array. Type decircuit logique reconfigurable basé sur latechnologie des ’gate arrays’ (matricesde portes). Ils sont généralement de plusgrande capacité que lesPLDs ; leurconfiguration est stockée dans uneRAMqui doit être rechargée à chaque mise soustension.

génération de codePhase finale lors de la compilation d’unprogramme, durant laquelle le codeassembleur associé au programme sourceest effectivement généré.

gestionnaire d’exceptionSous-programme associé à uneexception,qui est exécuté à chaque occurrence del’exception, de façon transparente pour leprogramme en cours.

glitchUn glitch est une erreur fugitive dans unsystème informatique. Dans les circuitscombinatoires ou séquentiels, c’est unétat fugitif 0 ou 1 qui apparaît sur unsignal, à un moment où il devrait êtrestable, et qui est dû à un problème de

différence de temps de propagation surdes sous-termes d’un terme complexe. Lestables de Karnaughpermettent de détecteret d’éliminer les glitchs des expressionscombinatoires.

handler d’exceptionVoir gestionnaire d’exception.

Harvard (modèle de)Organisation générale d’un ordinateurcaractérisée par la présence de deuxmémoires séparées pour le stockage duprogramme et des données. VoirVonNeumann (modèle de).

harwarePartie matérielle d’un ordinateur.

haute impédanceSe dit d’une sortie d’un circuit logique.Lorsqu’elle est dans cet état, tout se passecomme si elle était déconnectée du circuit,car elle ne produit ni ne consomme plusaucun courant. Des sorties qui peuvent semettre en état haute impédance peuventêtre reliées entre elles directement (surun bus par exemple), pourvu qu’unelogique de décodagegarantisse qu’auplus une seule de ces sorties est source decourant à un moment donné (sous peinede court-circuit).

HDLHarware Description Language. Langagede description de circuits, logique ouanalogiques. Certains sontstructurels,dérivant en détails la composition et lastructure de tous leurs composants, tandisque d’autres sont fonctionnels, décrivantles relations fonctionnelles entre les fluxd’entrées/sorties.

hexadécimalSystème de comptage en base 16. Leschiffres sont : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B,C, D, E, F. On l’utilise comme écriture pluslisible du binaire,en regroupant les bits par

Glossaire 237

paquets de 4.

hold (temps de)Durée après le front d’horloge durantlaquelle les entrées d’une bascule doiventêtre stables pour que le basculement sepasse correctement. Voirsetup.

indicateurBit mémorisé par un processeur,fournissant une indication sur un calculqui vient d’être effectué par l’unitéarithmétique et logique. Ils s’appellentle plus souvent N (negative), Z (zero), V(overflow), C (Carry).

interpréteurProgramme ou dispositif matérielfonctionnant cycliquement, en décodantet exécutant à chaque cycle une nouvelleinstruction d’un programme. Unprocesseur est toujours un interpréteur(matériel) de son langage machine.

interruptionEvénement asynchrone, déclenché parl’environnement matériel d’un ordinateur(disque, réseau, souris, etc.), destiné àprévenir le processeur d’une conditionparticulière qui doit être traitée rapidementen suspendant le programme en coursd’exécution de manière transparente. Lesinterruptions sont desexceptionsà causeinterne.

ISA (bus)Industry Standard Architecture. Nom d’unbus de communication pour compatiblePC, maintenant obsolète.

ISA (instructions)Instruction Set Architecture. Jeud’instructions d’un microprocesseur.

JTAGNorme internationale permettantl’interconnexion et la configuration de

circuits reconfigurables tels queFPGAsetPLDs.

langage machineLanguage qu’exécute un microprocesseur,formé d’une suite d’instructions binaires.

latchCellule de mémorisation de 1 bit.

linkVoir édition de lien.

little-endian,big-endianCes termes sont issus des ’Voyages deGulliver’ de Swift, lorsque Gulliver est aupays des politiciens. Une guerre d’opinionfait rage à propos de la manière demanger son oeuf à la coque, entre leparti des ’big-endian’ qui pense qu’ondoit le casser par le gros bout, et le partides ’little-endian’ qui veut commencerpar le petit. En informatique, désignedeux conventions d’écriture d’un nombrebinaire sur plusieurs octets successifs.Dans l’écriture big-endian, les octets sontcopiés en terminant par les 8 bits depoids les plus faibles ; dans l’écriturelittle-endian on termine par les 8 bitsde poids fort. L’écriture little-endian(la moins naturelle) n’est actuellementutilisée que dans les processeurs x86d’Intel, et elle est une des principalessources d’incompatibilité entre structureset fichiers de données issues de machinesdifférentes.

load-storeSe dit d’une architecture d’ordinateur quipossède un petit nombre d’instructions detransfert entre la mémoire et les registresde type load et store, et dont toutes lesautres instructions opèrent sur les registresinternes au processeur. C’est souvent unecaractéristique des processeurs RISC.

loaderVoir chargeur.

238 GLOSSAIRE

logicielVoir software.

mappée en mémoireSe dit des entrées/sorties d’un processeur,lorsque celui-ci ne peut agir sur ellesque par des opérations de lecture oud’écriture en mémoire, à des adressesdédiées. Un tel type de programmationdes entrées/sorties s’oppose à l’utilisationd’instructions spéciales d’entrées/sortiescomme sur lesx86par exemple.

mémoire dynamiqueMémoire à accès aléatoire dont les cellulesde mémorisation sont des capacitésmémoire. Les mémoires dynamiques ontun taux d’intégration plus élevé que lesmémoires statiques, mais elles nécessitentune électronique de rafraîchissement ducontenu des cellules.

mémoire flashMémoire morte reprogrammable,effaçable électriquement par blocs.

mémoire statiqueMémoire à accès aléatoire dont les cellulesde mémorisation sont des bistables.

mémoire tamponVoir buffer.

microcontrôleurC’est un circuit intégré unique, quicontient à la fois le microprocesseur,sa mémoire centrale et des circuitsd’entrées/sorties. Il fonctionne donc defaçon autonome avec un minimum decomposants extérieurs, et ce sont cescircuits qui équipent nos voitures, jouets,appareils électroménagers, etc.

microprocesseurProcesseur dont tous les éléments sontrassemblés en un seul circuit intégré.Il n’est généralement pas autonome et

nécessite plusieurs autres composantsautour de lui pour fonctionner.

microprogrammeEnsemble d’instructions placées dansune mémoire interne au processeur, nonaccessible au programmeur, qui permetl’exécution des instructions non câblées dulangage machine.

modes d’adressageMéthodes d’accès aux données pourun microprocesseur. Voir par exempleadressage direct.

moduleEn software, bloc de code réutilisable.En hardware, circuit réutilisable. Dans lesdeux cas, c’est un outil fondamental demaîtrise de la complexité.

Moore (loi de)Gordon Moore est un des fondateursd’Intel Corporation. Il a remarqué que tousles 18 mois environ, la puissance de calculet la capacité mémoire des ordinateurssontmultipliées par deux. Cette progression aété appelée loi de Moore, et elle est encorevalable actuellement.

multiprocesseurSe dit d’un ordinateur qui possèdeplusieurs processeurs centraux.

octetByte en anglais. Groupe de 8 bits.

PCIBus de communication entre un processeuret des cartes additionnelles, fonctionnantà une fréquence typique de 33 MHz. Il aété conçu par Intel, qui en a placé tous lesbrevets dans le domaine publique.

PLDProgrammable Logic Device. Circuitlogique dont les fonctions combinatoire

Glossaire 239

ou séquentielles sont programmables.On appelle souvent PLD uniquement lescircuits dont la configuration est stockéedans uneEEPROMou unemémoire flash,et qui sont opérationnels dès la mise soustension, contrairement auxFPGAs.

processeurOrgane principal d’un ordinateur, quipermet d’interpréter les instructions de sonlangage machine.

progicielEnsemble de programmes professionnels,documentés et livrés sous forme d’unpackage.

PROMProgramable ROM. Mémoire morteprogrammable dont les bits sont analoguesà des fusibles que l’on fait fondre parapplication d’un courant élevé lors de laprogrammation.

RAMRandom Acces Memory. Mémoire vive,accessible en lecture et en écriture.

random accessVoir accès aléatoire.

recordVoir enregistrement.

réentrantSe dit d’un programme dont une seulecopie en mémoire peut être exploitéepar plusieurs processus dans un systèmemultitâches, sans que leur données nese confondent. Tous les compilateursproduisent automatiquement du coderéentrant.

registreCircuit synchrone de mémorisation deplusieurs bits.

relogeable

Se dit d’une partie de code machine quipeut s’exécuter où qu’elle soit placéeen mémoire ; qui peut donc être relogée.Tous les compilateurs produisent un coderelogeable, pour que lechargeur puissele placer en mémoire à l’endroit le plusfavorable.

REPROMVoir EPROM.

RISCReduced Instruction Set Computer. Se ditde processeurs possédant des instructionsen nombre limité, de taille fixe, et quiles exécutent généralement en un cycled’horloge.

ROMRead Only Memory. Mémoire morte,accessible en lecture seulement.

routineVoir sous-programme.

SDRAMSynchronous Dynamic RAM : RAMdynamique synchrone.

setup (temps de)Durée avant le front d’horloge durantlaquelle les entrées d’une bascule doiventêtre stables pour que le basculement sepasse correctement. Voirhold.

softwareLogiciel. Tout ce qui concerne laprogrammation d’un ordinateur, paropposition àhardware.

sortanceVoir fan-out.

sous-programmePartie de programme réutilisable. Onl’invoque par une instruction spécialisée,et on lui communique en général desarguments par la pile ou dans des registres.

240 GLOSSAIRE

Lorsque son exécution est terminée, uneinstructions spéciale reprend le contrôledans le programme appelant aprèsl’instruction d’appel.

stack framePortion de la pile d’un programme en coursd’exécution, dans laquelle sont stockéesles valeurs associées au bloc en cours(généralement les paramètresd’appel et lesvariables locales d’unsous-programme).

statiqueVoir mémoire statique.

synchroneSe dit d’un circuit qui possède une entréed’horloge qui synchronise toutes sesopérations.

tamponVoir buffer.

temps d’accèsSe dit d’un dispositif de mémorisation,disque ou mémoire centrale. Tempsmaximum de réalisation d’une opérationde lecture ou d’écriture.

temps de propagationDurée qui s’écoule entre le moment où lesentrées d’un circuit changent et le momentoù ses sorties prennent une nouvelle valeurstable.

timerCircuit périphérique à un microprocesseur,qui lui fournit des impulsions à intervallesréguliers pour lui donner une unité detemps.

transistorÉlément actif de base des portes logiques.Il est dans ce cas employé en modecommutation, c’est à dire en tout ou rien.L’Intel 8088 comportait 29000 transistors ;le Pentium II 7,5 millions.

translatableVoir relogeable.

trapÉxceptionà cause interne, provoquée parl’exécution d’une instruction, telle quedivision par 0, débordement arithmétique,bus error, etc.

tri-stateVoir haute-impédance.

trois-étatsVoir haute-impédance.

TTLTransistor Transistor Logic. Technologiede réalisation de circuits logiques, dontla caractéristique principale est sa vitessed’exécution. On lui préfère actuellementla technologieCMOS pour les circuits àforte intégration.

UnicodeNom d’un système de codage de caractèreset d’idéogrammes dont l’ambition estde permettre de prendre en compte defaçon unifiée la plupart des languesécrites du monde. Ce système fait ladifférence entre les codes-points, nombresentiers associés de façon unique à chaquecaractère ou idéogramme, et l’encodagede ces codes-points, suite d’octets qui lesreprésentent en mémoire. UTF-8 est lenom de l’encodage le plus répandu.

unité centralePartie de l’ordinateur qui effectuel’interprétation et le traitement desinstructions.

USBUniversal Serial Bus. Bus de connexionde périphériques série. C’est un bus enétoile,qui nécessite des hubs de connexion.Les périphériques peuvent être branchés àchaud. Dans son mode lent, il permet des

Glossaire 241

échanges à 1.5 MBs

VLSIVery Large Scale Integration.Technique deréalisation de circuits intégrés qui permetde mettre sur la même puce des millionsde transistors, en utilisant des méthodeslithographiques.

Von Neumann (modèle de)Organisation générale d’un ordinateurcaractérisée par la présence d’une unitéde calcul, une unité de contrôle et d’uneunique mémoire centrale qui contient àla fois les instructions du programme etles données manipulées. VoirHarvard(modèle de).

x86Terme générique désignant un membrede la famille Intel dans la descendance8080, 8085, 8086, 80186, 80286, …,80x86 (x étant maintenant supérieur à 7).À partir du 80586, Intel a commencé àutiliser également le terme commercial dePentium.

IndexABEL, 27addition, 37additionneur

carry-lookahead, 39complet, 37, 47group carry-lookahead, 41ripple-carry, 38

adressagedirect, 145immédiat, 145indirect, 145registre, 144

adresse, 115algèbre de Boole, 3, 18, 22allocation, 146and, 21ASCII, 10ASIC, 26asynchrone, 63barrel shifter, 108bascule

D, 71JK, 74maître-esclave, 85synchrone, 69T, 73

big-endian, 130, 134binaire pur, 11bistable, 62bit, 3bloc, 160Boole, 3, 18booléen, 18branchement

absolu, 144conditionnel, 140inconditionnel, 140relatif, 143

buffer 3-états, 99bus, 2, 101, 187, 195

d’adresses, 195

bus(suite)de données, 195synchrone, 102système, 2

carte mère, 2cartographie, 198cercle des nombres, 13circuit

combinatoire, 18séquentiel, 61

CISC, 130CMOS, 3, 6codecode point, 10

de Gray de Gray, 14, 30combinaison interdite, 31comparaison, 14comparateur, 50compatibilité ascendante, 130complément à 2, 12compteur, 86contrôleur de périphérique, 2CPLD, 29CRAPS, 129débordement, 14décaleur à barillet, 108décodage, 198décodeur, 103décompteur, 86décrémentation, 8demi-additionneur, 37détecteur de séquence, 64directive, 145diviseur de fréquence, 88division, 48ECL, 5EEPROM, 29, 117emprunt, 43encodeur de priorité, 105entrées-sorties, 163, 201EPROM, 117

242

Index 243

équationd’évolution, 73

Eratosthène, 184et, 21état

équivalent, 67exception, 170, 205extension de signe, 107FETCH, 210flag, 111fonctionnel, 27FPGA, 26, 29front

d’horloge, 63descendant, 63montant, 63

GAL, 29génération de code, 159gestionnaire d’exception, 170, 174giga, 7glitch, 32graphegraphe d’état, 62

graphe de Mealy, 65graphe de Moore, 64

Gray, 30handler d’exception, 174hardware, 129haute-impédance, 98HDL, 26hexadécimal, 9high-Z, 98hold, 84horloge, 63IEEE 754, 6implicant premier, 36

essentiel, 36imprimeur, 11incrémentation, 8indicateur, 111instruction, 2

de rupture de séquence, 140synthétique, 138

interpréteur, 129interruption, 171, 207inverseur commandé, 25ISA, 129ISO_8859, 10

JTAG, 29Karnaugh, 30kilo, 7langagelangage machine, 2

assembleur assembleur, 129, 135machine, 129

latch, 62, 70lecteur, 11little-endian, 130, 134LSB, 7maître-esclave, 85majorité, 22mappé en mémoire, 133, 164masquage, 207MDL, 27Mealy, 65, 77méga, 7mémoire, 62, 198

centrale, 1dynamique, 117, 120flash, 29, 117statique, 6, 117

microcommande, 209micromachine, 209minterm, 21, 30MLI, 114mode d’adressage, 144Moore, 64, 77mot, 6MSB, 7multiplexeur, 26, 99, 104multiplicateur

systolique, 47multiplication, 47NAND, 23niveau, 63niveau de priorité, 172non, 20NOR, 23not, 20octet, 6opérateur

booléen, 20complet, 24logique, 20

OR, 21ou, 21

244 INDEX

PALASM, 27parité, 24PCI, 103périphérique, 2pile, 153PLD, 26, 29poids

faible, 7fort, 7

pointeur de pile, 153porte

et, 21logique, 20non, 20ou, 21

processeur, 2PROM, 117PWM, 114, 166, 203Quine-Mc Cluskey, 34RAM, 116récursif, 156, 162réfléchi, 14registre, 2, 90, 132, 186regroupement, 31RISC, 130ROM, 116scheduler de tâches, 176SDRAM, 117séquenceurséquenceur.cabléséquenceur.microprogramméséquenceur, 209servo-moteur, 168setup, 84Shannon, 18SHDL, 26, 27simplification, 31, 35software, 129sous-programme, 152

terminal, 153soustracteur

complet, 44ripple borrow, 45

soustraction, 43SPARC, 131stack-frame, 159structurel, 27

symbole, 147synchrone, 63table

de Huffman, 66de Karnaugh, 30de transitions, 66de vérité, 20

tempstemps d’accès, 118

de hold, 84de propagation, 4de setup, 84

théorèmed’absorption, 22de De Morgan, 22

timer, 114, 166, 203tranche de bits, 112transistor, 5trap, 170trois états, 98TTL, 3, 5UAL, 111, 190UNICODE, 10unité

arithmétique et logiquearithmétique et logique, 111, 190

de calcul, 2de contrôle, 2

UTF-8, 10vecteur d’exception, 174VHDL, 27VLSI, 5Von-Neumann, 1XOR, 24, 38, 44

Buisson Concevoir son microprocesseur - Structure des systèmes logiques (Ellipses)

Documents

Transcript of Buisson Concevoir son microprocesseur - Structure des systèmes logiques (Ellipses)