1009-05 Systemes Microp - Syllabus 2018 - 180404 - Relu-CV Microprocessor-Based Systems FR (001-076)

Machine Translated by Google
1009-03 Électronique
Systèmes à base deNumérique
microprocesseur
Université de Mons
Faculté Polytechnique de Mons

Service d'Électronique et de Microélectronique
21.02.22
Créé par : Pr C. Valderrama
À BASE DE MICROPROCESSEUR
SYSTÈMES
Université de Mons
Faculté Polytechnique de Mons

Service d'Électronique et de Microélectronique
Pr Valderrama
Ce cours est plus que de simples compétences en programmation. Il est destiné à comprendre l'architecture des processeurs,
le comportement des composants internes du bâtiment et comment tout cela est lié aux langages de programmation. Pour faire
simple, le cours utilisera de petits processeurs, cependant nous verrons comment faire de la programmation en utilisant les langages
Assembleur et C. De cette manière, nous aborderons les connaissances de base requises et les défis lors de la programmation de
petits dispositifs de mémoire et des opérations de bas niveau telles que les interruptions et les protocoles standard. Les sessions
de laboratoire seront consacrées à la programmation et à l'interfaçage de processeurs 8 bits et d'appareils embarqués sans fil, ainsi
qu'à l'utilisation de Linux OS sur des processeurs embarqués 32 bits (Raspberry PI - Système Broadcom sur puce SoC avec unité
centrale compatible ARM). Ce travail pratique d'apprentissage des bases aidera l'étudiant à se préparer à travailler sur des projets dans le
futur proche.
La description
Ce cours vous aidera à comprendre les bases de l'architecture d'un ordinateur, comment il interagit avec l'environnement à
l'aide de protocoles standards et, pendant le laboratoire, comment contrôler un processeur par programmation. Le cours théorique
propose l'étude de l'organisation interne des ordinateurs : leurs structures, les interactions entre les différentes unités fonctionnelles
qui les constituent, la compréhension approfondie des différentes architectures de microprocesseurs, les implications au niveau de
la programmation et les mécanismes d'interaction avec le environnement. Les travaux pratiques de laboratoire feront largement
appel aux techniques de programmation, à l'utilisation des interruptions et à l'utilisation des circuits périphériques. A l'issue de ce
cours, l'étudiant aura une compréhension approfondie du fonctionnement d'un ordinateur d'un point de vue architectural, des options
architecturales de ses principaux composants internes, de l'impact du jeu d'instructions et des modes d'adressage choisis sur ses
performances. , ses entrées/sorties et ses périphériques standards.
Résultats d'apprentissage spécifiques
A l'issue de ce cours, les étudiants seront capables de : Comprendre la structure et le comportement interne des
microprocesseurs. Développer une analyse critique des systèmes informatiques et identification des contraintes, des performances
et des interactions entre leurs différents composants. Avoir un équilibre technologique pour développer globalement un système
informatique face à une application donnée. Pouvoir optimiser leur utilisation tout en appliquant les techniques présentées. Maîtriser
les outils de développement et les langages de programmation. Mise en œuvre de solutions à base de microprocesseur en
sélectionnant des composants, des outils et des périphériques ciblant une application spécifique. A l'issue de ce cours, l'étudiant
aura une compréhension approfondie d'un processeur, du point de vue architectural et comportemental, des alternatives
architecturales et des principaux composants matériels internes, de l'impact du jeu d'instructions et des modes d'adressage sur les
performances d'un ordinateur , E/S et périphériques.
1
Contenu
L'étude de l'organisation interne des ordinateurs : leur structure interne, les interactions entre ses différents éléments constitutifs,
la compréhension des différentes architectures de microprocesseurs, les implications de la programmation et les mécanismes
d'interaction. Le travail pratique fera un usage intensif des techniques de programmation, des mécanismes d'interruption et de
l'interaction avec les périphériques.
1. Structure d'un ordinateur. Concepts de base, langages et machines virtuelles, machines multicouches, principales étapes des
ordinateurs, la famille Intel, la famille Motorola. Composants de base, CPU, mémoire, bus, E / S. L'unité centrale de traitement
ou CPU, l'exécution d'une instruction, le chemin de données, l'instruction et les flux de données. Mémoire, bits, adresses
mémoire, organisation des octets, codes correcteurs d'erreurs, mémoire cache, mémoires secondaires.
Entrées/sorties, structure logique, terminaux à écran, modems, souris, imprimantes, codage des caractères.
2. La couche physique. Portes logiques, algèbre de Boole, circuits logiques de base. Circuits arithmétiques, horloges et
temporisateurs, circuits logiques avec mémoire. Le bus interne, le bus mémoire principal. L'organisation interne d'une mémoire.
Le microprocesseur et le bus. Bus synchrones et asynchrones, modes de transfert de données. Arbitrage d'autobus.
Techniques d'interfaçage. Gestion des interruptions, circuits d'interface ou contrôleurs d'entrées/sorties, circuits série UART et
USART, circuits parallèles PIO, chronomètre-minuterie, convertisseurs numérique-analogique, convertisseurs analogique-
numérique. Exemples de microprocesseurs, exemples de bus.
3. La couche microprogrammée. Microarchitecture. Macro-architecture ou architecture de jeu d'instructions (ISA). Exemple de

micro machine. Le chemin des données. Stockage d'informations. Composants de base. Registres généraux.
ALU. Shifter. Registres tampons. Cycles de chemin de données. Echanges avec la mémoire. Micro-instructions. Signaux de
commande et contrôle du chemin des données. Le format d'une micro-instruction. La microarchitecture.
4. La section de contrôle. Le cycle d'exécution des micro-instructions. Le calcul de l'adresse de la micro-instruction suivante.
Instructions branchant JAM. Exemples de micro-instructions. Un exemple de machine macro. La structure de la pile (pile, LIFO,
pointeur de pile, opérateurs de pile, un exemple d'appel de procédure, pile d'opérandes). Un modèle mémoire : modes
d'adressage classiques (direct, indirect, local), adressage mémoire (implicite/absolu), organisation mémoire. Un jeu
d'instructions : registres dédiés, formats de représentation et de codage, types d'instructions, exemple de jeu d'instructions,
appel de procédure, et retour, compilation et
exécution.
5. Optimisation de la couche microprogrammée. Les performances requises (compromis entre rapidité et coût). Augmentation
de la vitesse d'exécution (réduction du nombre de cycles d'horloge, organisation simplifiée, chevauchement d'instructions,
réduction de la longueur du chemin d'exécution, récupération partielle, choix de la vitesse d'horloge, parallélisme des tâches
et augmentation de la vitesse d'exécution, quantité de décodage ). La réduction du cycle du chemin d'exécution (fusion de la
boucle d'interprétation et du microcode, architecture à trois bus, utilisation d'une Instruction fetch Unit indépendante, description
IFU). Architecture du pipeline (fonctionnement du pipeline, pipeline à 4 étages, dépendance des données, connexions, pipeline
à 7 étages, microprogrammation horizontale et verticale, nano programmation). Mémoire cache (latence et bande passante,
principe du cache, taux de réussite, temps moyen d'accès aux données, niveaux de cache (inclusif, séparé, unifié), organisation
du cache (ligne de cache, localité spatiale, algorithmes de remplacement, localité temporelle, cache direct, cache associatif,
technique pour écrire des données dans le cache).
6. La couche conventionnelle. Architecture et mode d'emploi. Modèle d'organisation de la mémoire (modèles de mémoire,
cellules, mots, alignement, adressage). Les types de registres et de données (généraux, spécialisés, classification, registre
d'état, pointeur de pile, segments). Les instructions ou opérations disponibles (instructions, types d'opérations).
Le format des instructions (champs, types d'opérations, variantes, taille, critères de sélection, codes opération expansifs).
Modes d'adressage (modes d'adressage, adressage immédiat, adressage direct, adressage de registre, adressage de registre
indirect, adressage indexé, adressage basé sur l'index, adressage basé sur la pile, notation polonaise infixe et inversée,
adressage pour les instructions de branchement, orthogonalité des codes d'opération et adresses des opérandes). Types
d'instructions (instructions de transfert de données, opérations dyadiques, opérations monadiques, branchements et
comparaisons conditionnels, instructions d'appel de procédure, instructions de contrôle de boucle, entrée/sortie
2
des instructions). Le flux de contrôle (flux de commande séquentiel et connexions, procédures, co-routines, dé routage
ou traps, interruptions). La couche de langage d'assemblage. Architectures avancées. RISC et CISC.
Références
1. Andrew Tanenbaum, Architecture de l'ordinateur, Dunod, ISBN 2-10-004467-2, http://www.dunod.com
2. Gilmore, Microprocesseurs, McGraw-Hill, ISBN 0-07-113965-6
Les soutiens
Notes de cours (syllabus), transparents, ouvrages de référence :
- Andrew Tanenbaum, Architecture de l'ordinateur, Dunod, ISBN 2-10-004467-2, http://www.dunod.com
- Gilmore, Microprocesseurs, McGraw-Hill, ISBN 0-07-113965-6

-
Sites Web et références transmises durant l'année : microprocesseurs 8051
Diverses informations disponibles sur le site Moodle : notes de cours, transparents, tests des années précédentes (avec parfois
des résolutions), exercices de préparation aux cours théoriques et séances de laboratoire.
Méthodes d'enseignement et d'apprentissage
Séances théoriques. Le cours pose rigoureusement les bases théoriques et présente les outils qui seront nécessaires à la
compréhension, au développement, au choix et à l'utilisation des microprocesseurs lors de la résolution de problèmes pratiques.
La présence et la participation de l'étudiant sont très importantes (les informations utiles pour l'examen ne sont disponibles que
pendant les séances théoriques). Le cours théorique propose l'étude de l'organisation interne des ordinateurs : leurs structures,
les interactions entre les différentes unités fonctionnelles qui les constituent, la compréhension approfondie des différentes
architectures de microprocesseurs, les implications au niveau de la programmation et les mécanismes d'interaction avec
l'environnement. L'étudiant aura une compréhension approfondie du fonctionnement d'un ordinateur d'un point de vue
architectural, des options architecturales de ses principaux composants internes, de l'impact du jeu d'instructions choisi et des
méthodes d'adressage sur ses performances, sur ses entrées /sorties et périphériques standards.
Séances de laboratoire. Les séances de laboratoire sont illustrées par des exemples simples. Ils sont indispensables pour
permettre d'appréhender par la pratique les notions nécessaires à la manipulation des microprocesseurs, leurs interfaces,
l'interaction avec l'environnement, l'utilisation des mécanismes d'interaction avec les actionneurs et les périphériques, les détails
propres aux langages de programmation assembleur et C, la manipulation mémoire , utilisation d'outils de programmation,
installation de systèmes d'exploitation Linux sur un processeur 32 bits (plate-forme Raspberry PI), et utilisation de
microprocesseurs communicants sans fil (ESP8266). Les séances de laboratoire sont fractionnées et organisées par groupes
de 2 étudiants (liste des groupes à rendre avant le 1er laboratoire). Au cours de ces séances, l'étudiant rédige un rapport sur
les mesures effectuées et l'analyse des résultats obtenus. A la fin de la session, l'étudiant répond à un questionnaire en ligne.
Evaluation et pondération 1ère session
Consultez les diapositives du cours pour voir la dernière version.
Evaluation et pondération 2ème session
Consultez les diapositives du cours pour voir la dernière version.
3
Sommaire
1 INTRODUCTION................................................. .................................................. .......................6
1.1 LANGAGES ET MACHINES VIRTUELLES ......................................................... .......................................9
1.2 LA LOI DE MOORE ................................................ .................................................. ...............dix
1.3 PARAMÈTRES DE PERFORMANCES DU PROCESSEUR ...................................... ..................................11
2 STRUCTURE DE BASE DU PROCESSEUR ................................................... .................................................. ......15

2.1 ORGANISATION DE VON NEUMANN ET HARVARD ......................................................... ................................15
2.2 L'UCT DE L'UNITÉ CENTRALE DE TRAITEMENT ................................... ..................................................16
2.3 EXÉCUTION D'UNE INSTRUCTION .................................................................. ...............................................17
2.4 LE CHEMIN DES DONNÉES .................................................. .................................................. ..................18
2.5 LE JEU D' INSTRUCTIONS : MACHINES RISC ET CISC .................................. .......................19

2.5.1 ORTHOGONALITÉ .................................................. .................................................. .....20
2.5.2 INSTRUCTIONS DE TAILLE FIXE : CODE D'OPÉRATION EXPANSIF .............................. .........21
2.5.3 TAILLE ET NOMBRE D' INSTRUCTIONS ......................................................... ..................................22

2.5.4 PRINCIPES DE CONCEPTION DES RISQUES ....................................... ...............................................23
2.6 CLASSIFICATION SELON LE FLUX DES INSTRUCTIONS ET DES DONNÉES ..................................24
2.7 LES FORMATS DE CODAGE .................................................. .................................................. ........30

2.7.1 VALEURS SIGNÉES ................................................................ .................................................. ........32
2.7.2 REPRÉSENTATION EN POINT FIXE .................................................. .......................................33
2.7.3 CODES DE CORRECTION D' ERREUR ................................................ ..................................................35
2.8 LA MÉMOIRE : CONCEPTS DE BASE ......................................................... ..................................................38
2.8.1 LA MÉMOIRE : ENDIANNESS OU BYTE ORDERING......................................................... .......................40
2.8.2 MÉMOIRE : TYPES, CONTENU ET EXEMPLES .................................................. .......................42

2.8.3 HIERARCHIE DES SOUVENIRS .................................................. .............................................44
2.9 LES ENTREES/SORTIES .............................................. .................................................. ..........50
3 LA COUCHE PHYSIQUE : LES CIRCUITS LOGIQUES.................................................. .......................................53
3.1 LES PORTES LOGIQUES DE BASE............................................ ..................................................53

3.2 LA LOI DE MORGAN..................................................... .................................................. .............55
3.3 L'ALGÈBRE DE BOOLE.................................................. .................................................. ............56
3.4 LES CIRCUITS LOGIQUES COMBINATOIRES .............................................. ..................................57
3.5 LES CIRCUITS ARITHMÉTIQUES .............................................................. ..................................................60
3.6 LES CIRCUITS SÉQUENTIELS............................................... .................................................. ...62
4 LA COUCHE PHYSIQUE : LE MICROPROCESSEUR......................................................... .......................................71
4.1 LE MICROPROCESSEUR ................................................................ .................................................. .......71
4.1.1 PARAMETRES DES PERFORMANCES D'UN MICROPROCESSEUR ........................................... ..71
4.1.2 SIGNAUX DE COMMUNICATION ....................................................... .......................................72

4.1.3 CATÉGORIES DE COMMANDES .................................................. .............................................72
4.1.4 QUELQUES INFORMATIONS A PROPOS DU 8051................................................ ....................73

4.1.5 UN PROCESSEUR VIRTUEL MICROJAVA 701......................................................... .......................75
4.2 LE BUS .................................................. .................................................. ................................76
4.2.1 LE BUS SYNCHRONE ................................................................ .................................................. ....79

4.2.2 LE BUS PCI (PERIPHERAL COMPONENT INTERCONNECT) ................................................ ..........80
4.2.3 LE TRANSFERT PAR BLOC..................................................... ..................................................81
4.2.4 LE BUS ASYNCHRONE ....................................................... .................................................. ..82
4
4.3 L'ARBITRAGE DU BUS ............................................. .................................................. ............83
4.4 TECHNIQUES D'INTERFACE ............................................. .................................................. .....86

4.4.1 GESTION DES INTERRUPTIONS ....................................................... .......................................86
4.4.2 CIRCUITS D'INTERFACE ET CONTROLEURS D'ENTREE/SORTIE......................................... .........89
4.4.3 CIRCUITS SERIE UART............................................................ .................................................. .90
4.4.4 CIRCUITS SERIE USART............................................................ ..................................................91
4.4.5 CIRCUITS PARALLELES PIO..................................................... .............................................92
4.4.6 CHRONOMÈTRE (TIMER) OU TEMPORISATEUR......................................................... .......................95
4.4.7 CONVERTISSEUR NUMERIQUE-ANALOGIQUE .............................................. .......................96
4.4.8 CONVERTISSEUR ANALOGIQUE-NUMERIQUE .............................................. .......................97
5 MICROPROGRAMMÉE LA COUCHE .................................................. .................................................. .98
5.1 LA MICROARCHITECTURE ................................................................ .................................................. ....98

5.1.1 UN EXEMPLE DE MICROMACHINE......................................................... .....................................99
5.1.1.1 LE CHEMIN DES DONNEES ....................................................... ...............................................99
5.1.1.2 LES MICRO-INSTRUCTIONS ......................................................... ..................................................103
5.1.1.3 LA MICROARCHITECTURE ............................................. ..................................................104
5.2 UN EXEMPLE DE MACROMACHINE......................................................... ..................................................108
5.2.1 LA STRUCTURE DE PILE ....................................................... ..................................................108
5.2.2 UN MODÈLE DE MÉMOIRE ............................................. .......................................110
5.2.3 UN JEU D'INSTRUCTIONS ............................................. ...............................................112

5.3 MICROPROGRAMMÉE OPTIMISATION DE LA COUCHE ............................................. ..................116
5.3.1 RÉDUCTION DU CYCLE DU CHEMIN D'EXÉCUTION ............................................. ..................117

5.3.1.1 FUSION DE LA BOUCLE D'INTERPRÉTATION ET DU MICROCODE.................................................. ..117
5.3.1.2 ARCHITECTURE A TROIS BUS ...................................................... .......................................118
5.3.1.3 EMPLOI D'UNE UNITÉ DE RECHERCHE D'INSTRUCTION INDÉPENDANTE............................120
5.3.2 ARCHITECTURE AVEC CANALISATION ............................................... .......................................121
5.3.3 CACHE MÉMOIRE .................................................................. .................................................. ....125
5.3.3.1 LE CACHE DIRECT OU UNE CORRESPONDANCE DIRECTE.............................. .............127

5.3.3.2 LE CACHE ASSOCIATIF ................................................ ..................................................128
5.3.3.3 OPERATION D'ECRITURE DES DONNEES DANS LE CACHE...................................... ..........129
6 LA COUCHE CONVENTIONNELLE ....................................................... .................................................. ...130
6.1 L'ARCHITECTURE ET LES INSTRUCTIONS ................................................ .....................................130
6.1.1 MODÈLE D'ORGANISATION DE LA MÉMOIRE......................................................... .......................130
6.1.2 TYPES DE REGISTRES ET DONNÉES......................................................... .......................................131
6.1.3 LES INSTRUCTIONS OU OPÉRATIONS DISPONIBLES ............................................. ..............133
6.2 LE FORMAT DES INSTRUCTIONS.................................................. ...............................................133
6.3 LES MODES D'ADRESSAGE..................................................... .................................................. ....136
6.4 TYPES D'INSTRUCTIONS ....................................................... .................................................. ......139
5
1. Introduction
"L'ordinateur est une machine conçue pour résoudre certains problèmes en obéissant à des instructions préalablement données à
ça" Andrew Tanenbaum.
L' ordinateur est devenu un compagnon indispensable et familier, cependant, la majorité d'entre nous n'a pas eu l'occasion de
comprendre son fonctionnement ni même les éléments qui le composent. De plus, du fait de la diversité des usages, c'est devenu une
machine prête à tout et très complexe à la fois. Cependant, ces dernières années, on a vu arriver des capteurs dits intelligents,
communiquant sans fil, pour créer des objets interconnectés ou IoT (Internet of Things). Egalement utilisées pour la robotique, ces
machines programmables doivent interagir avec l'environnement par l'intermédiaire de périphériques, mais en plus, répondre en temps
réel, être compactes, et parfois peu énergivores.
On voit que ces deux types de machines ont beaucoup de points communs, à commencer par la façon dont on les programme.
Pour commencer, un ordinateur a besoin d'un programme. Un programme est un ensemble d'instructions décrivant comment une
certaine tâche doit être effectuée (Figure 1). Le programme est écrit dans un langage plus ou moins adapté au type d'activité à réaliser.
Ainsi, les langages de haut niveau comme le langage C, sont des langages génériques qui permettent d'écrire des programmes utilisant
des équations plus ou moins lisibles et compréhensibles, indépendants du processeur, donc dits portables.
Mais, il existe d'autres langages plus proches de la machine, permettant de créer des programmes mieux adaptés aux contraintes
d'exécution à respecter. Ces langages, appelés langages à bas niveau d'abstraction, sont si proches de la machine qu'ils sont plus
difficiles à lire, mais très puissants. En effet, à un niveau d'abstraction inférieur, les instructions qui seront exécutées par l'ordinateur
sont écrites dans un autre langage plus proche de la machine, appelé langage machine ou assembleur. Les instructions sont
directement exécutées par la machine. Cette proximité implique que pour chaque processeur, il existe un ensemble d'instructions
associées. Mais parfois, le même jeu d'instructions peut aussi être exécuté par plusieurs processeurs de la même famille. Cet ensemble
est conçu en même temps que le processeur de base et complété par les opérations dédiées des processeurs de la même famille.
langues
Programme
Des instructions
Mémoire
Processeur
Figure 1 : Du programme au processeur. Les langages sont nécessaires pour écrire un programme qui sera exécuté
par le processeur. Ce programme consiste en un ensemble d'instructions. Le programme est enregistré dans une
mémoire que le processeur lira lors de son exécution
Le niveau d'abstraction d'un langage détermine sa proximité avec une application, l'utilisateur et la machine
(Figure 2). Plus le niveau d'abstraction est élevé, plus la distance entre le langage utilisé et la machine qui exécutera les instructions
associées est grande. Nous augmentons le niveau d'abstraction pour plusieurs raisons : pour permettre
le langage doit être indépendant de la machine, donc portableÿ; pour permettre à l'utilisateur d'effectuer des opérations particulières, par
6
par exemple des opérations avec des matrices, ou plus puissantes, comme pour le traitement du signal, ou des opérations
complexes. Plus le niveau d'abstraction est élevé, plus la productivité du programmeur est élevée ; avec quelques lignes de code,
on pourrait écrire un programme. Cependant, pour certaines tâches que le processeur devra effectuer, notamment celles où le
temps d'exécution doit être respecté, par exemple un pilote de périphérique, on utilisera des langages de bas niveau pour que le
code soit optimal.
Langues Machines
Python
Niveau Python Application
d'abstraction
augmente C
Python
Assembleur
Python
Micro-instructions
Python Processeur
Figure 2 : Langages et niveaux d'abstraction. Plus le niveau d'abstraction est élevé, plus le langage de l'application
et de l'utilisateur (Python ou C) est proche. Au contraire, un langage plus proche de la machine (Assembleur) devient
plus difficile à lire et à comprendre
Le processeur est la machine qui va finalement exécuter les instructions, une fois qu'elles ont été écrites dans un langage
compréhensible par lui. Pour passer d'un niveau d'abstraction proche de l'utilisateur à un autre plus proche de la machine, on
utilise généralement un compilateur (Figure 3). Celui-ci est chargé non seulement de vérifier que le programme est bien écrit,
mais aussi de faire l' analyse syntaxique et sémantique du programme en question afin de faire la traduction d'un programme
dans un langage plus proche de la machine, donc de niveau inférieur. Pour votre information, l' analyse syntaxique consiste à
vérifier que les mots-clés, commandes et symboles sont correctement utilisés et l' analyse sémantique vérifie que le sens est
correct ou que la structure du programme est acceptable. Cependant, certains langages ne sont pas traduits, mais interprétés et
donc exécutés par un autre programme situé entre lui et la machine cible ; ce sont les interpréteurs utilisés pour des langages
tels que Java, Matlab ou Python.
Langues Langues
C ou Java ou
Assemblée De base
Programme Programme
Des instructions Des instructions
Compilateur
Pré-traitement
Code
machine
Exécutable
Mémoire
Des instructions
Interprète
Traitement
Traitement
Figure 3 : Compilateur et interpréteur. Le compilateur traduit le programme dans un langage de niveau inférieur
(C, Assembleur). L'interpréteur exécute notre programme ligne par ligne (Java, Matlab, Pyton)
sept
Celui qui va exécuter les instructions, le processeur, microprocesseur ou microcontrôleur, est composé d'un ensemble d'unités de
commande, de calcul et de mémoire, regroupées dans un circuit intégré. Bien qu'il existe plusieurs définitions, un microcontrôleur est une
machine plus basique qu'un microprocesseur, mais bien adaptée aux opérations de contrôle, contrairement aux opérations de flux de
données effectuées par des processeurs de traitement du signal ou DSP (Digital Signal Processor) qui nécessitent des opérateurs dédiés
(par exemple MAC multiplier-accumuler). D'autres soulignent que le microprocesseur n'a pas tous les éléments en interne (dans la puce)
comme la mémoire ou les périphériques, contrairement au microcontrôleur (Figure 4).
Mais en fait, tout processeur possède une mémoire interne et des ports d'E/S, donc cette différence n'est pas très précise.
Externe Interne Interne

MÉM ROM RAM
PROGRAMME
LES DONNÉES
E/S CPU ALU
Microprocesseur (Intel Pentium)
PÉRIPHÉ
RALS
Microcontrôleur (Microchip PIC)
Figure 4 : Microcontrôleur et microprocesseur. Certaines définitions les distinguent de ce qui est contenu en
interne, par exemple la mémoire programme ou les périphériques à l'intérieur de la puce
Pour certaines applications, on a besoin d'un processeur adapté en fonction des contraintes, parfois c'est la puissance requise, la
vitesse de traitement, la taille des données ou le temps de réponse. Il existe donc plusieurs paramètres de mesure. En règle générale, un
processeur est mesuré par la taille des données qu'il peut traiter dans une instruction (Figure 5). La mesure du mot de données est
exprimée en nombre de bits. Ainsi, il existe des processeurs de 4, 8, 16, 32 bits ou plus. Pour rappel, un mot de 8 bits est un octet. Pour les
gros programmes et les opérations complexes, les processeurs 32 ou 64 bits seront privilégiés. Pour les systèmes de contrôle embarqués,
en particulier, appliqués à l' IoT, les processeurs 8 bits sont, dans la plupart des cas, plus que suffisants. Il existe également un mot pour
l'adresse mémoire, qui détermine la taille de la mémoire à laquelle il peut s'adresser. Par exemple, un mot d' adresse de 16 bits équivaut à
16
65 536 (2 ou 64K) mémoire différente
Emplacements. La vitesse du processeur est mesurée par la fréquence d' horloge (cycles d'horloge en Hz) ou par le nombre d'instructions
par unité de temps IPS ou en MIPS (Million Instructions Per Second).
La taille du processeur sera également déterminée par le type, le nombre et la complexité des instructions qu'il peut exécuter. Les
instructions complexes devront ensuite être décodées en interne. En effet, pour traiter les instructions, certains microprocesseurs utilisent
donc un programme interne, le firmware ou microprogramme. Ce microprogramme est stocké dans la mémoire interne de la fabrication. Il
organise et exécute des opérations de base (voir ci-dessous) ainsi que des instructions complexesÿ; ce qui montre pourquoi certaines
instructions prennent plusieurs cycles d'horloge pour s'exécuter. La plupart des instructions comprennent des opérations de base. Il existe
deux types d'opérations de baseÿ: pour le chemin de données et pour le chemin de contrôle. Les opérateurs intervenant dans le
cheminement des données sont (liste non exhaustive) : des opérations arithmétiques, logiques, de comparaison ou de transfert (mémoire ou
registre). Les opérateurs pour le chemin de contrôle sont les branchements conditionnels ou inconditionnels (ou sauter, si-sinon, aller à,
pause), les itérations ou les boucles (aller à, tandis que, pour, faire-tout), l'appel de procédure (call) ou l' interruption (arrêter l'exécution de
programme principal pour répondre à une interruption).
Dans cette section, nous verrons plus en détail les termes introduits précédemment, à partir des éléments nécessaires à la compréhension
des opérations, de leurs implications sur les performances et des évolutions dues aux évolutions technologiques.
8
Programme
Taille (bits/octets)
Mot de données
Taille (bits/octets)
Mot d'instruction
Processeur Mémoire
Adresse
Mot de données Mot de données

IPS
Mot d'instruction
Dword
IDENTIFIANT
Mot d'instruction
Je mot Mot d'instruction
L'horloge
La fréquence
hertz
Figure 5 : Paramètres du processeur. Il existe plusieurs paramètres de mesure. Généralement, un processeur se

mesure par la taille des données qu'il peut traiter dans une instruction (Data Word Dword) exprimée en nombre de bits
et par la taille des instructions (Instruction Word Iword)
1.1 Langages et machines virtuelles

Pour écrire un programme, il existe pléthore de langages parfois classés selon le type d'application ou le niveau
d'abstraction. On peut donc imaginer qu'un même programme puisse être représenté différemment selon le niveau d'abstraction,
et cela pour chaque niveau ou couche ; il existerait un langage et une machine virtuelle capable de comprendre et d'exécuter le
programme écrit dans ce langage (Erreur ! Source du renvoi introuvable.).
Langues
Machines
PythonPython
Langue Ln Abstraction Application
Niveau n
Machine virtuelle Mn
C
Python
Langue L1
Niveau 1 Machine virtuelle M1
Assembleur
Python
Langue L0 Micro-instructions
Niveau 0 Machine M0 Python Processeur
Figure 6 : Langages et machines virtuelles. Pour chaque niveau d'abstraction, on peut trouver un langage et une
machine virtuelle capable d'exécuter un programme écrit dans ce langage. Plus le niveau d'abstraction est élevé, plus
on est proche de l'application contrairement au processeur
Les langues peuvent être classées de différentes manières, par exemple, en fonction de la proximité avec le processeur, en
application, système d'exploitation et assemblage (Erreur ! Source du renvoi introuvable.).
Les langages applicatifs utilisent des mécanismes plus ou moins dédiés au type d'application (par exemple Matlab, ADA,
VHDL, etc.) ou des langages plus génériques, mais qui ne dépendent toujours pas du type de processeur, donc de haut niveau
d'abstraction, et avec sur lesquels nous construisons des programmes applicatifs (C/ C++, Python ou Java). Ils peuvent être
compilés, donc traduits dans des langages de plus bas niveau (C/ C++), ou interprétés, donc exécutés par un autre programme
(Basic, Matlab, Java ou Python).
9
Le langage assembleur ou assembleur est une représentation symbolique des opérations réalisables par les instructions. Dans la
plupart des cas, ce sont des mnémoniques pour faciliter la lecture du programme. Il sera traduit en code machine ou interprété par le
système d'exploitation.
Le système d'exploitation est une couche ou un niveau d'abstraction intermédiaire entre le programme d'application et le processeur/
les périphériques. Il permet le multitâche ou l'organisation et le partage de la mémoire et des périphériques. Lorsque nous nous rapprochons
du processeur, nous trouvons les instructions qu'il peut lire et exécuter. En effet, l'architecture au niveau du jeu d'instructions (Instruction
Set Architecture ISA) est composée du jeu d'instructions que la microarchitecture
du processeur peut interpréter et exécuter.
Dans la couche de microarchitecture, on retrouve : le chemin de contrôle, avec chargement des instructions ; le chemin de données,
constitué par la banque de registres (pour le stockage temporaire des valeurs intermédiaires) et l' unité arithmétique et logique ALU pour
effectuer les opérations. Certains processeurs utilisent un firmware ou un microprogramme pour contrôler cette architecture, lorsqu'il s'agit
de supporter des instructions complexes (qui pourraient être composées de plusieurs étapes d'exécution du firmware), par exemple : une
instruction complexe qui nécessite plusieurs étapes d'exécution lorsqu'elle est exécutée par une unité dédiée autre que l'additionneurÿ;
instructions de multiplication ou de matriceÿ; à l'opérateur d'accélérer l'exécution de boucles ou d'appeler des procédures. Cependant, les
instructions complexes peuvent prendre plusieurs cycles d'horloge et occuper plus d'espace dans la mémoire programme. Dans d'autres
architectures, l' unité de contrôle exécute directement les instructions, permettant des machines rapides avec un jeu d'instructions simples,
mais de taille réduite.
La couche physique, le dernier niveau, correspond aux circuits numériques logiques pour les opérations, et aux registres pour
stocker les résultats des opérations. Ce sont les circuits de base trouvés dans le chemin de données et le chemin de contrôle.
Niveau 5 Langage orienté vers les

problèmes d'application
Compilation/Traduction
Niveau 4 Langages d'assemblage
Traduction/Assemblage
Langages machine et
Niveau 3
Systèmes opérationnels
Interprète partiel (OS ou SE)

Niveau instructions
Niveau 2
architecture
Interprète de microprogramme ou exécution directe
Niveau 1 Microarchitecture
Machine
Niveau 0 Logique numérique
Circuits électroniques (Transistors, portes, …)
Figure 7 : Couches d'abstraction typiques. Quand on se rapproche du processeur, en plus de l' Assemblée
langage, on retrouve la couche Operating System OS (par exemple Linux), l' Instruction Set Architecture ISA
propre au processeur, le firmware ou la microarchitecture (responsable du décodage et de l'exécution des instructions),
et enfin les circuits logiques et numériques qui seront utilisés
1.2 La Loi de Moore

Gordon Moore, l'un des fondateurs d' INTEL, avait dit en 1967 la phrase suivante "le nombre de transistors dans un microprocesseur
ou une puce double tous les deux ans" (Electronics Magazine, 1965-75), ce qu'on avait appelé la loi de Moore. En effet, entre 1971 et
2001, la densité de transistors a doublé tous les 1,96 ans (Figure 8). De ce fait, l'électronique est devenue de moins en moins chère et de
plus en plus puissante. Cette croissance avait été possible
dix
grâce à des technologies de développement de circuits intégrés capables de réduire la taille des transistors, arrivant aujourd'hui à des mesures
submicroniques (<1000 nm). Cela dit, nous avons atteint les limites technologiques et physiques. En effet, au-delà du coût de fabrication des CI
en technologie submicronique, on ne peut plus rétrécir les transistors sans tenir compte des effets autrement ignorés.
Figure 8 Loi de Moore pour les processeurs Intel. Le nombre de transistors dans un microprocesseur a doublé tous les
18 mois depuis 1971.
Cette loi s'applique aussi aux mémoires (figure 9), avec plus de facilité, du fait de la régularité et de la relative simplicité
des circuits pour les souvenirs.
Figure 9 : Nombre de transistors pour les mémoires : la loi s'applique aussi bien aux transistors des microprocesseurs
qu'aux mémoires.
Cependant, la loi de Moore ralentit aujourd'hui, en raison des courants de fuite, plus importants par rapport à la taille des transistors, des
résistances plus élevées, des comportements non linéaires, des effets de bruit parasite et des difficultés de dissipation thermique empêchant
une augmentation de la fréquence. Pour ces raisons, des solutions alternatives sont apparues, comme le doublement du nombre de processeurs
(multi-cœurs) fonctionnant à des fréquences égales ou inférieures, l'utilisation de circuits asynchrones, ou encore des ordinateurs quantiques (un
ordinateur qui utilise les propriétés quantiques de la matière, comme superposition et intrication, pour effectuer des opérations sur les données).
1.3 Paramètres de performance du processeur

Les performances du processeur peuvent être données par plusieurs paramètres, tels que le temps de réponse, le temps CPU, le débit, etc.
Le temps d'exécution est inversement proportionnel aux performances du processeur :
11
Un processeur qui met plus de temps à exécuter une tâche est moins efficace que les autres.
Le temps de réponse (temps de réponse, temps écoulé ou temps d'exécution) peut être mesuré comme le temps entre le début et la fin d'une tâche
(en cycles d'horloge - ticks/période/taux ou juste temps).
Le temps d'exécution du CPU est le temps réellement utilisé par le CPU pour exécuter une tâche sans compter le temps d'attente des E/S ou le
temps d'exécution d'un autre programme. Cette durée est subdivisée en Utilisateur (le programme de l'utilisateur dépend du nombre d'instructions) et
Système (tâches système). Ce temps peut être mesuré en nombre de cycles d'horloge nécessaires pour exécuter le programme à une certaine vitesse
d'horloge :
Notez qu'une fréquence d'horloge plus élevée (cycles par unité de temps) équivaut à moins de temps d'exécution, au prix d'une consommation d'énergie
plus élevée.
Le débit ou la bande passante est la quantité de travail effectué dans un temps spécifique pour produire un résultat. Ainsi, en réduisant
le temps de réponse améliore presque toujours le débit.
Le nombre de cycles d'horloge par instruction (CPI) est le nombre moyen de cycles d'horloge nécessaires pour exécuter une instruction. Avec le
CPI et le nombre d'instructions, on peut donc estimer le temps d'exécution CPU :
Notez que le CPI est un paramètre important lors de la définition des consignes. Nous verrons plus loin que des instructions complexes, ou des
instructions d'accès à la mémoire, peuvent nécessiter plus de cycles d'horloge, leur nombre affectera le CPI, donc le temps d'exécution du CPU.
La consommation d'énergie est également un paramètre important lié au temps d'exécution. La puissance d'un CPU a deux
composants principaux : puissance statique et dynamique.
La consommation électrique est également un paramètre important lié au temps d'exécution. La puissance d'un CPU a deux
composants principaux : puissance statique et dynamique.
La puissance dynamique est dissipée lors de l'alternance du signal d'horloge. C'est une fonction de la capacité de charge
des transistors, la tension d'alimentation et la fréquence d'horloge. La capacité de charge est elle-même fonction de la sortance (nombre de transistors
connectés en sortie) et de la technologie (capacités des lignes et tailles des transistors).
Là encore, cette puissance dynamique sera d'autant plus grande que la tension d'alimentation ou la fréquence d'horloge est plus élevée.
La puissance statique (ou fuite) augmente comparativement (aujourd'hui à 40% de la puissance totale dissipée) du fait de la réduction de la taille des
transistors et de la tension d'alimentation.
Cependant, le pourcentage d'utilisation n'est pas proportionnel à la puissance consommée (Barroso et Holzle). La
la consommation, lorsque le processeur est inactif, est parfois supérieure à la moitié de la puissance crête.
Pour obtenir des mesures de performances comparatives, il existe des benchmarks, ou des programmes spécifiquement choisis pour mesurer les
performances du processeur. SPEC (System Performance Evaluation Cooperative) fournit un ensemble de programmes permettant d'évaluer la vitesse, par
exemple SPECINTC2006 des benchmarks entiers CPU, ou la consommation d'énergie, par exemple SPECpower SPECJBB2005. La charge de travail
définit tous les programmes utilisés pour évaluer les performances.
La vitesse d'exécution d'un programme est mesurée en MIPS (Million d'instructions par seconde) qui dépend de la
nombre d'instructions exécutées et le temps d'exécutionÿ:
12
Cependant, un même programme peut être exécuté par plusieurs CPU, dans ce cas une partie de l'exécution se fait en parallèle
ou en accéléré. La loi des rendements décroissants (Amdahl) calculera alors l'augmentation possible de performance obtenue par
une amélioration donnée :
Selon Amdahl, cette augmentation des performances est limitée par la quantité que l'on utilise de cette fonctionnalité améliorée.
Ainsi, vous obtenez plus si vous améliorez le temps d'exécution des fonctionnalités les plus fréquemment utilisées ou celles qui sont
le plus souvent utilisées. Cependant, l'accélération est limitée par la partie du code qui s'exécute de manière séquentielle.
Figure 10 : La loi des rendements décroissants (Amdahl). La loi des rendements décroissants - Amdahl. Le temps
d'exécution ET sera réduit en fonction de l'accélération de l'exécution du programme, par exemple par des tâches en
parallèle ou en utilisant plusieurs processeurs ou CPU. Le pourcentage de parallélisme utilisé augmentera la vitesse
d'exécution.
13
14
2 Structure de base du processeur

L'ordinateur et les microcontrôleurs sont constitués du même ensemble de composants de baseÿ: l' unité centrale de traitement de contrôle CPU, la
mémoire principale (où les données et les instructions sont stockées), le bus de communication (pour échanger des données ou des instructions avec la
mémoire ou les périphériques) et les ports d'entrée/sortie (E/S) auxquels les périphériques et autres appareils peuvent être connectés. Le CPU contient,
en plus de l'unité de contrôle CU, une unité de calcul, appelée unité arithmétique et logique ALU, et des registres où les valeurs courantes sont stockées
temporairement. Notez que parfois dans ce texte, CPU et CU sont utilisés de manière interchangeable, juste pour se souvenir de la partie contrôle du
processeur.
Figure 11 : Structure de base d'un processeur (vue Von Neumann). L'unité de traitement de commande CPU
contient l'unité de commande CU, l'unité arithmétique et logique ALU et des registres internes. Le CPU est connecté à
la mémoire principale et aux périphériques via un bus.
L'UC de l'unité centrale de contrôle et de traitement exécute les instructions du programme qui est stocké dans la mémoire principale ou programme
(la partie de la mémoire principale contenant les instructions à exécuter). Un processeur générique exécutera une instruction à la fois. La mémoire
principale peut contenir des instructions ou des données. En effet, parfois les deux, instructions et données, sont dans la même mémoire, dans d'autres
cas les instructions sont placées dans une mémoire non volatile (Read-Only Memory ROM) et les données dans une RAM (Random Access Memory)
ou mémoire volatile.
Le bus permet l'échange d'informations entre les unités rattachées au processeur. Des instructions ou des données sont échangées entre le processeur
et la mémoire principale, ou entre le processeur et les périphériques. Les ports d'entrée/sortie permettent d'échanger des informations avec des
périphériques (à l'aide d'un port de communication série ou parallèle) ou des interfaces humaines (par exemple une imprimante, un clavier ou un écran).
Le bus répond à un protocole de communication ou d'échange particulier. La plupart utilisent des lignes d'adresse, de données et de contrôle (selon le
type de protocole d'échange).
2.1 Organisation Von Neumann et Harvard

Il existe deux principales organisations architecturales de base, elles utilisent les mêmes éléments de base mais diffèrent dans la manière dont elles
stocker et obtenir des instructions et des donnéesÿ:
15
Figure 12 : Structures de Von Neumann et Harvard. Le Von Neumann utilise une mémoire principale partagée dans laquelle
les instructions et les données sont récupérées via un bus commun connecté à l'unité de contrôle et à l'unité logique
arithmétique. L'architecture de Harvard utilise des mémoires séparées pour les instructions (non volatiles) et les données
(volatiles) ainsi que des bus séparés.
L'architecture Von Neumann utilise une seule mémoire pour stocker les instructions et les données. Un seul bus permet d'accéder
aux instructions (à utiliser par l'unité de contrôle) ou aux données (à utiliser dans le chemin de données par l'ALU). L'accès unique
implique que vous pouvez récupérer une instruction ou une donnée, c'est-à-dire que vous ne pouvez pas effectuer les deux opérations
simultanément. Cependant, une architecture plus simple et plus compacte est obtenue avec une seule mémoire et un bus de partage. Le Harvard
L'architecture utilise deux chemins distinctsÿ: un pour les instructions et un autre pour les données. Cette architecture permet une
organisation plus cohérente pour l'accès et l'organisation des instructions et des données. Nous verrons plus loin que cette organisation
permet une meilleure gestion de la mémoire selon le type de contenu (instruction ou données). Il permet également un accès simultané
aux données et aux instructions. L'inconvénient est qu'il aura besoin de deux bus ou chemins ainsi que de deux mémoires distinctes.
2.2 L'unité centrale CPU

L' unité centrale de traitement CPU contient trois éléments de baseÿ: l' unité de contrôle CU, les registres ou
emplacements de mémoire et l' unité logique arithmétique ALU.
Figure 13 : L'UC de l'unité centrale de traitement. L'ALU échange des données avec la mémoire et les registres internes.
L' accumulateur ACC est un registre, parfois disponible, pour stocker temporairement les opérandes et les résultats produits
par l'ALU. L' unité de contrôle CU récupère l'instruction pointée dans la mémoire programme par le registre PC du compteur
de programme. L'instruction en cours d'exécution par la CU est stockée dans le registre d'instructions
IR.
L' unité de contrôle CU est responsable de l'exécution des instructions au sens large, c'est-à-dire de la récupération de l'instruction
de la mémoire programme (Fetch), de son interprétation (Decode), de la récupération des données nécessaires à l'exécution de la
instruction (Read), l'exécution de l'instruction elle-même et enfin, le stockage
16
(Écriture) du résultat de l'exécution dans la mémoire ou dans des registres internes. Dans certains processeurs, l'unité de contrôle est une
simple machine à états, avec des étapes d'exécution relativement courtes, mais dans d'autres processeurs, elle représente une véritable micro
machine équipée d'un firmware capable de décoder et d'exécuter des instructions plus complexes pouvant nécessiter plusieurs cycles d'horloge.
On verra donc que selon le type et le jeu d'instructions, il y aura des machines de type RISC (Reduced Instruction Set Computer) et CISC
(Complex instruction Set Computer) dans lesquelles l'unité de contrôle est une machine à états simple (RISC) ou une micro-machine (CISC).
Nous verrons plus loin qu'il existe une autre classification selon le nombre d'unités de contrôle : SIXX pour Single Instruction ou MIXX pour
Multiple Instructions.
L' unité d'arithmétique et de logique (ALU) est chargée d'effectuer des opérations avec des données. Habituellement, les données sont déjà
disponibles dans des registres internes (mémoires rapides, mais regroupées en petit nombre). Il peut effectuer des opérations simples
(arithmétiques et logiques) ainsi que des opérations plus complexes (par exemple, multiplication, division, racine carrée, etc.). L'ALU permet
également la prise de décision lors d' instructions de branchement conditionnelles (IF-ELSE) ou itératives (boucles WHILE, FOR, DO WHILE).
D'autre part, il permet l'analyse de données comme par exemple savoir si une valeur est positive, négative, paire, impaire ou s'il y a eu un
débordement lors d'une opération.
Le chemin des données est le chemin emprunté par les données lors de l'exécution des opérations. Dans ce chemin se trouvent la mémoire
de données, les registres internes et l'ALU. Le nombre et le type d'ALU dépendent du type de processeur, les microcontrôleurs ont une ALU très
simple, les processeurs de signaux numériques DSP, mieux adaptés au traitement du signal, utilisent des unités de traitement de données plus
complexes et plus puissantes. On peut également avoir une ou plusieurs ALU : XXSD pour Single Data ou XXMD pour Multiple Data, donc
plusieurs chemins de données (parallèles) et plusieurs ALU.
Les registres internes sont des mémoires très rapides dans lesquelles certaines données sont temporairement stockées, telles que les
opérandes et les résultats des opérations, l'adressage (pointeurs), les instructions, la commande et l'état. Ils interviennent dans les instructions
pour les données ou les adresses des opérandes. Ils peuvent être modifiés, additionnés, échangés ou traduits. Le transfert entre registres ou
entre un registre et un emplacement mémoire, conditionne la vitesse du CPU. Certains registres sont génériques, polyvalents, et d'autres dédiés,
comme l'ordinal ou Program Counter PC, le Instruction Register IR ou le Status Register. Le Program Counter PC est un registre dédié qui
contient l'adresse de la prochaine instruction à exécuter. Ce registre est consulté par l'unité de contrôle lorsqu'elle est prête à exécuter
l'instruction suivante. Grâce à ce registre, elle sait où se trouve, et donc où chercher la prochaine instruction. Le registre d'instructions IR
est un registre dédié qui contient l'instruction en cours d'exécution. Lors de l'étape de récupération, l' unité de contrôle récupère l'instruction
suivante, celle pointée par le PC, de la mémoire principale et la place dans l'IR. Cette instruction sera ensuite décodée et exécutée. Le registre
d'état ST informe l' unité de contrôle de la dernière opération effectuée par l' ALU et indique si elle a produit un zéro, ou une retenue, un
débordement, ou sur le bit significatif du résultat, un nombre négatif, un nombre pair ou impair.
2.3 Exécution d'une instruction

L' unité de contrôle CU est responsable de l'exécution des instructions. Cela se fait en plusieurs étapes d'exécutionÿ:
• Fetch : chargement de la prochaine instruction à exécuter. Le compteur de programme PC pointe vers l'adresse de la mémoire
principale où se trouve la prochaine instruction à exécuter. L'instruction est ensuite récupérée et placée dans le registre
d'instructions IR. Le PC est alors incrémenté, ou mis à jour, pour pointer vers la prochaine instruction à exécuter.
• Decode : décodage de l'instruction. L' unité de contrôle détermine quelle opération l'instruction demande à être effectuée.
Facultativement, l'instruction demandera des opérandes qui doivent également être extraits de la mémoire de données ou des
registres à l'étape suivante.
• Lecture : Lecture, à partir de la mémoire de données ou d'un registre local, de toute donnée éventuellement requise pour exécuter le
instruction.
• Exécuter : exécution de l'instruction, c'est-à-dire. l'opération ALU, après le décodage de l'instruction et la récupération des données,
ou un branchement dans le cas d'une instruction de contrôle (saut ou appel de procédure).
• Ecriture : stockage de tout résultat éventuel soit dans la mémoire de données, soit dans un registre local.
17
• Revenez à l'étape 1 : passez à l'instruction suivante.
Figure 14 : l'unité de contrôle et les étapes d'exécution d'une instruction : l'exécution d'une instruction comporte
6 étapes élémentaires (certaines ne sont pas toujours nécessaires) : (1) trouver l'instruction à exécuter, (2) décoder
l'instruction, (3 ) lire les opérandes, (4) exécuter l'opération, (5) écrire les résultats, (6) revenir à l'étape 1 (après mise
à jour du compteur programme).
2.4 Le chemin des données
Le chemin de données est constitué de tous les éléments nécessaires pour effectuer une opération : les opérandes et l'opérateur.
Les opérandes (données) à utiliser par l'opérateur peuvent être extraites de la mémoire de données (RAM) ou sont déjà disponibles
dans des registres internes. L'opérateur, l'opération à effectuer, est sélectionné par l'unité de contrôle à l'aide de signaux qui contrôlent
l'ALU. L'état du processeur après l'opération est indiqué dans un registre spécifique appelé Status Register SR. Ainsi, lors, par
exemple, d'une opération d'addition, s'il y a eu un report arithmétique, un bit du registre d'état appelé Carry sera mis à '1' pour indiquer
que le résultat de l'opération est incomplet. D'autres bits sont également disponibles dans ce registre, par exemple pour indiquer la
parité (pair/impair), le signe, un résultat nul ou une opération incorrecte (par exemple une division par zéro). Les entrées/sorties de
l'ALU peuvent être séparées des registres internes, où
les données sont localisées à l'origine, par des registres intermédiaires d'entrée (A et B) ou de sortie (A + B), appelés registres
tampons. Par exemple, le 8051 a l' accumulateur ACC comme registre tampon d'entrée/sortie de l'ALU. Nous verrons plus loin que
ces registres tampons permettront d'effectuer des opérations en pipeline, augmentant ainsi la cadence des opérations, le débit.
Cependant, des étapes intermédiaires seront nécessaires pour sélectionner et prendre les opérandes de la mémoire de données, ou
des registres internes, et les placer directement sur les tampons d'entrée de l'ALU, ainsi que pour le résultat de l'opération, disponible
dans un registre de tampon de sortie , qui devront être replacés dans les registres internes, affectant la latence des opérations.
18
Figure 15 : Exemple de chemin de données et de pipeline de données. L'exemple n'inclut pas la mémoire de données (qui fait
également partie du chemin de données) en supposant que les données sont déjà récupérées et placées sur des registres internes. Étape
(1) les données sont extraites des registres internes et placées dans les registres tampons d'entrée (A, B) de l'ALU, (2) l'opération ALU
déjà sélectionnée est effectuée, le résultat stocké dans le registre tampon de sortie (A ope B) et le registre d'état mis à jour, (3) le résultat
est extrait du registre tampon de sortie et replacé dans les registres internes. Le pipeline de données (figure de droite) montre la latence (le
nombre de cycles d'horloge nécessaires pour effectuer l'opération complète sur le chemin des données), chaque étape est séparée par
des registres où le stockage des données est piloté par le signal d'horloge.
2.5 Le jeu d'instructions : machines RISC et CISC
L' architecture de jeu d'instructions ISA est un ensemble d'instructions disponibles pour le programmeur que le
processeur peut comprendre et exécuter. Ils définissent une famille de processeurs aux caractéristiques et
comportements similaires. Ils se distinguent par la taille et le nombre d'instructions. En effet, il peut y avoir des
ensembles d'instructions de même taille (comme les processeurs ARM et Microchip PIC ) ou de tailles différentes
(occupant plusieurs mots, ce qui est le cas du Pentium et de l'INTEL 8051). Le nombre d'instructions peut être faible,
comme le RISC à jeu d'instructions réduit ou un grand nombre d'instructions complexes et puissantes, dans le cas des
ordinateurs à jeu d'instructions complexes CISC.
Figure 16 : Exemples d'instructions de taille fixe et variable (processeurs CISC 8051 et RISC ARM). Les instructions de taille variable
sont des instructions dont la taille varie de un à plusieurs octets. Les instructions 8051 sont de taille variable. Ses instructions peuvent alors
être courtes, un seul octet, et ne contenir qu'un code d'opération IPCODE, par exemple, les instructions ANL A,Rn , ANL A,@Ri (l'opération
logique ET) et CLR A (effacer l'accumulateur) ne t contenir
Rn un champ d'adresse ou d'opérandes, la source (accumulateur A, registre interne
soit l'adresse d'un registre interne pointé par un registre Ri) et la destination A sont des adresses implicites déjà indiquées dans le code
opération. D'autres instructions peuvent occuper plusieurs octets et avoir deux champs d'opérande ou plus. Par exemple, l'instruction ANL
direct, #data aura besoin d'un champ d'opérande de 2 octets car le
19
L'instruction fonctionne avec un emplacement indiqué par l'adresse de la mémoire de données (directe), qui nécessite 2
octets. Les processeurs RISC utilisent des instructions de taille fixe. Par exemple, le processeur ARM a des instructions 15 bits.
Dans ce cas, le nombre et la taille des champs sont ajustés à la taille de l'instruction.
La structure d'une instruction se compose du champ Operation Code (OP CODE) qui indique le type d'opération à effectuer, suivi éventuellement
des champs pour les opérandes (une valeur constante, un registre, une adresse directe ou un emplacement relatif OFFSET ), indiquant le type d'
opérande destination (DEST) ou source (SRC) .
Ainsi, le champ opérande peut représenter une valeur constante (#FF), un registre (R0) où la valeur est placée, une valeur dans un emplacement
mémoire pointé par un registre (@R0), l'adresse mémoire directe (ADDRESS), ou une adresse mémoire relative (OFFSET). Ce dernier, OFFSET, indique
une position mémoire relative au Program Counter PC.
Figure 17 : Exemple d'instruction 8051. L'instruction comporte deux champs principaux : le code d'opération (CODE OP)
et les opérandes. Les opérandes source SRC et destination DEST sont utilisés pour indiquer les opérandes d'entrée et les
emplacements des résultats. L'exemple montre l'addition avec l'instruction de retenue ADDC. Cette instruction est composée
du code d'opération 0x34 et de deux champs d'opérande, l' accumulateur A (source et destination) et la valeur constante
#data. Comme indiqué par le mnémonique (la représentation lisible de l'instruction d'assemblage), l'instruction ajoutera le
contenu de l' accumulateur (A) à la valeur constante #data et au Carry bit (C). Le résultat de cette addition sera stocké dans
l' accumulateur.
Il existe deux grands groupes d'instructions : contrôle et traitement des données :
• Les instructions de contrôle : elles contrôlent le chemin des données et déterminent l'ordre d'exécution des opérations. Ils peuvent modifier
l'ordre dans lequel les instructions sont exécutées. Les exemples sont les branchements conditionnels (il y a une condition avec une
expression à évaluer, c'est-à-dire si ou bien) ou inconditionnels (saut, aller à, pause ou continuer) ,
itérations (boucle, for, while, do-while), appels de fonctions et de procédures et interruptions.
• Instructions de traitement des données : ces instructions prennent en charge les opérations dans le chemin des données. Ces instructions
utilisent des opérandes. Les opérandes peuvent être des valeurs constantes, des emplacements de mémoire (une adresse), des registres ou
des pointeurs. Certains ne sont que des transferts de données entre emplacements de mémoireÿ:
o Registre ÿ Mémoire : échange de données entre la mémoire de données et un registre interne
o Registre ÿ Registre : échange de données entre registres o Mémoire ÿ
Mémoire : échange de données entre emplacements de mémoire de données (il peut être indexé dans le cas de vecteurs et de
tableaux)
2.5.1 Orthogonalité
La propriété d'orthogonalité implique qu'une même instruction doit supporter plusieurs modes ou variantes d'adressage.
Ceci est pris en charge par la plupart des machines CISC. Les instructions nécessitent donc un champ (MODE) pour indiquer le mode d'adressage à
utiliser (immédiat, direct, par registre, indirect par registre, indexé, par pile).
Dans le cas des instructions de contrôle, l'orthogonalité implique, par exemple, que le branchement doit supporter plusieurs modes d'adressage tels
que conditionnel, inconditionnel, long (à une adresse spécifique) ou relatif (à la position indiquée par l'ordinal ou le compteur de programme PC). De
même, la même opération de données peut être effectuée avec une constante, une valeur dans
20
un registre ou à une adresse mémoire, une valeur pointée par l'adresse contenue dans un registre (par exemple le registre
DPTR dans le cas du 8051). Par exemple, l'instruction d'addition peut prendre plusieurs formats ou modes d'adressage
lorsqu'elle prend en charge l'orthogonalité. En effet, l'addition peut être faite entre l'accumulateur et une valeur constante, une
valeur dans un emplacement de mémoire ou de registre, ou pointée par un registre (comme le DPTR, qui contient donc
l'adresse de l'emplacement de données donné). La figure suivante montre un exemple de l'instruction d'addition 8051 et des
modes d'adressage prenant en charge l'orthogonalité. On notera dans l'exemple (Figure 18) qu'une même instruction peut
occuper 1 ou 2 octets (instructions de taille variable) en plus de prendre des cycles d'horloge différents selon la complexité du
mode d'adressage.
1 CODE OP
2 CODE OP MODE CONSTE
3 CODE OP MODE ADRESSE
Jeu d'instructions 8051ÿ: AJOUTER (ajout)

Opération: ADD, ADDC (avec Carry)
Fonction: Ajouter un accumulateur, ajouter un accumulateur avec transport
Syntaxe: AJOUTER A, opérande

adresse
ADDC A, opérande
0x30
MÉM
Les données
Instruction (mnémonique) OpCode Octets Drapeaux
2 ADDC A,#données 0x34 2 C, CA, VO

3 ADDC A, adresse iram 0x35 2 C, CA, VO
ACC(A) ACC(A)
+ 3 ADDC A,@R0 0x36 1 C, CA, VO
Porter(C) Porter(C) 3 ADDC A,R0 0x38 1 C, CA, VO
Figure 18 : Exemple d'orthogonalité : l'instruction d'addition supporte plusieurs modes d'adressage : immédiat (une
valeur constante #data), direct (l'adresse mémoire iram addr), par registre (le registre qui contient la donnée R0) ou
pointé par un registre ( @R0). Le mode indique le type d'opérande et la taille de l'instruction, par exemple, le code
d'opération 0x3X inclut déjà le mode : 0x34 (immédiat, 2 octets), 0x35 (direct, 2 octets), 0x38 (registre direct, 1 octet) et
0x36 (indirect, 1 octet). La figure montre également le mode d'adressage direct de la mémoire (côté gauche) où
l'adresse mémoire (0x30, le deuxième octet de l'instruction) indique l'emplacement des données qui seront ajoutées à
l'accumulateur (ACC) et au bit de retenue (C), le le résultat sera stocké dans l'accumulateur et le bit de retenue sera
affecté en conséquence.
2.5.2 Instructions de taille fixeÿ: code d'opération expansif

Surtout dans les machines RISC, les instructions sont toutes de la même taille. Dans ce cas, la taille du code d'opération,
l'OpCode, doit être ajustée pour laisser de l'espace pour d'autres champs. Ainsi, une instruction de taille fixe devra supporter
des codes opération de taille variable (l'opcode devient de plus en plus long).
La stratégie pour créer des instructions de même taille consiste à utiliser des codes d'opération expansifs. Par exemple, la
création d'instructions de taille k + n où k est la taille du code opération et n la taille en bits du mot mémoire (donnée ou
k
adresse). Dans ce cas, nous pouvons créer, par exemple, 2 les opcodes avec de la place pour 2 n mots mémoire de taille n
2 k-1 bits, et les opcodes (demi) avec de la place pour des mots mémoire de taille n + 1 bits (double nombre de mots). En suivant
cette stratégie, la taille de l'opcode est réduite pour faire de la place au mot mémoire. L'exemple suivant (Figure 19) montre la
création de 4 types d' instructions 16 bits .
21
Figure 19 : Exemple de code d'opération expansive : la création de 4 types d' instructions 16 bits. Le premier groupe contient 15 (2
4 -1) instructions avec codes opération de taille k = 4 et 3 emplacements pour 3 adresses ou 4 bits
mots; notez que 15 instructions au lieu de 16 ont été créées, donc d'autres opcodes peuvent commencer par 0xF. De même, le deuxième
groupe contient 14 instructions (2 4 -2) avec des opcodes de taille k = 8 (notez les 4 premiers bits de l'opcode
commencer par 0xF) et 2 emplacements pour les adresses 4 bits. Encore une fois, deux opcodes ont été réservés pour le reste pour
commencer par 0xFE et 0xFF. Le troisième groupe contient 31 (2 5 -1) instructions avec des opcodes de taille k = 12 (remarque
les 7 premiers bits de l'opcode commencent par 0x7F) et un emplacement pour une adresse de 4 bitsÿ; seulement le dernier opcode 0xFFF
était réservé aux opérations restantes. Le dernier groupe est composé de 16 instructions avec des codes opération de taille k = 16 bits,
donc pas de place pour une adresse mémoire ; notez que seuls les 4 derniers bits peuvent être utilisés pour identifier l'opcode.
2.5.3 Taille et nombre d'instructions

Les stratégies précédentes sont utilisées pour construire l'ISA des machines RISC à jeu d'instructions réduit et CISC à jeu
d'instructions complexes (Figure 20). Les ISA peuvent être différents en nombre d'instructions (de 20 à 300 et plus), en taille (fixe ou
variable), en format, en type et en complexité. La propriété d'orthogonalité implique qu'une même instruction doit supporter plusieurs
modes ou variantes d'adressage, ainsi les instructions ont une taille et une complexité variables, ce qui est le cas dans la plupart des
machines CISC. Avec des instructions de taille fixe, le code d'opération expansif permet d'avoir des instructions de même taille,
requises pour les machines RISC.
Les ordinateurs à jeu d'instructions réduit (RISC Berkeley – processeurs ARM et SPARC) ont en général un ISA composé d'un
petit nombre d'instructions simples de même taille. Les instructions sont si simples que plusieurs instructions seront nécessaires pour
effectuer une opération complexe, ainsi le programme est susceptible d'avoir besoin de plus de mémoire par rapport aux machines
CISC. Comme l'orthogonalité n'est pas nécessaire, les machines RISC n'ont pas besoin d'un grand nombre d'instructions. Parce que
les instructions sont simples, le décodage l'est aussi, et les instructions peuvent être directement exécutées (non interprétées) par la
couche physique (matériel) et la plupart d'entre elles (à l'exception des opérations de transfert de mémoire) prendront un cycle
d'exécution. Le compilateur est également simple, mais il faudra plus de temps pour déterminer la combinaison d'instructions la plus appropriée.
Enfin, l'architecture des machines RISC est simple et rapide, généralement sans microarchitecture (une simple machine à états est
nécessaire pour récupérer et exécuter des instructions), un bon candidat pour les stratégies d'instructions et de pipeline de données
pour augmenter le débit. Cependant, beaucoup plus de registres sont nécessaires pour que le pipeline fonctionne, pour avoir moins
d'accès à la mémoire et donc toutes les données nécessaires restent dans la banque de registres.
22
Les ordinateurs à jeu d'instructions complexes (CISC INTEL et IBM) ont un ISA composé d'un grand nombre d'instructions complexes et puissantes.
L'orthogonalité étant généralement supportée par les machines CISC, le nombre d'instructions est plus important (par rapport à RISC), de taille variable
(plusieurs octets). Les instructions étant complexes et de tailles différentes, leur exécution peut prendre plusieurs cycles d'exécution (au détriment de la
nécessité d'une micro-architecture capable de décoder et d'exécuter des instructions), rendant difficile l'utilisation des techniques de pipeline. Ainsi, l'
unité centrale est complexe et encombrante. Comme les instructions peuvent être complexes et puissantes, en plus d'être de taille différente, la taille du
programme peut être optimisée en économisant de la mémoire. Cependant, le compilateur est plus complexe, car il a plus d'alternatives pour implémenter
un programme qui peut être optimisé pour sa taille ou sa vitesse.
Figure 20 : Comparaison des architectures RISC et CISC selon leur ISA. Une seule instruction complexe sur un
CISC nécessitera une micro-architecture pour décoder et exécuter l'instruction. Cela peut prendre plusieurs cycles
d'horloge, une micro-machine est utilisée pour décoder l'instruction, cependant, l'instruction peut prendre moins de place en mémoire.
La même instruction CISC sera éventuellement implémentée par plusieurs instructions simples sur une machine RISC.
Cela nécessitera plus d'espace mémoire, cependant, le décodage est simplifié et l'instruction peut être pipelinée.
2.5.4 Principes de conception RISC

Les machines RISC présentent plusieurs avantages par rapport aux CISC en raison de leur ISA simplifié.
Comme les instructions ont toutes la même taille, la récupération des instructions prend toujours le même temps. Pour réduire le temps d'exécution
des instructions, les instructions sont directement exécutées par l'unité de contrôle, donc non interprétées. En effet, comme les instructions sont simples,
le décodage est rapide ; pas besoin d'être interprété par une micro-architecture. Avec des instructions de taille fixe, le décodeur est moins flexible,
utilisant un nombre limité de champs. Le format d'instruction ne prend pas en charge l'orthogonalité ; ainsi moins de ressources sont nécessaires pour
l'exécution. Pour ces raisons, le pipeline d'instructions peut être efficace.
La plupart des instructions font référence à des registres (Registre ÿ Registre sont des opérations plus rapides) au lieu d'accéder à des emplacements
de mémoire, ce qui facilite le pipeline de données. En effet, les accès mémoire nécessitent plus de temps et se limitent aux seules instructions Load et
Store. Pour cela, un nombre suffisant et significatif de registres doit être prévu pour stocker les opérandes et les résultats intermédiaires, jusqu'à ce qu'ils
ne soient plus utilisés.
Grâce aux pipelines d'instructions et de données, les machines RISC peuvent maximiser la vitesse d'émission des instructions, en exécutant autant
d'instructions par seconde (MIPS millions d'instructions par seconde) que possible. Les branchements conditionnels et les dépendances de données
peuvent produire un blocage du pipeline, mais cela peut être évité avec des techniques de compilateur.
L'Advanced RISC Machine ARM est un bon exemple où tous les principes appliqués peuvent être identifiés par
inspecter son architecture (Figure 21).
23
Registre des adresses
Banque d'enregistrement
(registres 31x32bit)
(6 registres d'état)
alu 32 bits
Chaîne d'instructions
Écrire le registre de données
& Lire le registre de données
Figure 21 : L'architecture de l'ARM Advanced RISC Machine. Le processeur RISC ARM7 32 bits (bus de données et bus
d'adresses 32 bits) est un bon exemple de processeurs populaires avec une réponse rapide aux interruptions pour une
utilisation dans des applications en temps réel. Afin de faciliter le pipeline de données, il propose un nombre important de registres, un
Banque de registres 31x32 bits plus 6 registres d'état. En effet, il faut éviter d'accéder à la mémoire (des instructions plus
lentes provoquent un décrochage du pipeline). Les instructions peuvent être directement exécutées avec un décodage
simplifié, ainsi, un pipeline d'instructions de taille fixe maximise la vitesse d'émission des instructions (débit).
2.6 Classification selon le flux d'instructions et de données

Flynn classe les processeurs en fonction des instructions et du flux de données dans SISD, SIMD MISD et MIMD. Il s'agit d'une
classification simple qui considère le processeur capable d'exécuter une seule instruction à la fois SI ou plusieurs instructions MI
simultanément. Il en va de même pour les données, car il peut être capable de traiter des données avec un seul chemin de données SD ou
plusieurs chemins de données parallèles identiques ou différents. Nous verrons que cette classification s'applique toujours aux processeurs
modernes, multi-cœurs, GPU, Grid et Clusters.
Données uniques à instruction unique (SISD). Une seule instruction à la fois et un seul chemin de données (Figure 22).
Il s'agit de la machine classique de Von Neumann ou de Harvard (avec des mémoires séparées pour les instructions et les données). Cette
machine peut encore être optimisée en fournissant un pipeline d'instructions ou de données.
Von Neumann Harvard
Principal Mémoire Mémoire

Mémoire
Données Des instructions
Des instructions
Données
adresse adresse
adresse Consignes/Données
Des instructions
Bus externe Données Données
Des instructions
Bus interne
CU ALU ALU UC
Bus interne
Registres
Registres
Figure 22 : Exemples SISD : Les machines Von Neumann et Hardware sont de type SISD, une seule instruction peut être
exécutée à la fois et le chemin de données est unique. Leur principale différence est d'avoir des mémoires unifiées ou
séparées pour les données et les instructions.
Données uniques à instruction unique (SISD) avec pipeline d'instructions. Lorsque cela est possible (avec des étapes avec des
temps d'exécution similaires ou identiques), un pipeline d'instructions augmente le taux (débit) des opérations (un résultat
24
par cycle de fonctionnement). Alors que la latence (le temps total nécessaire pour exécuter une instruction) n'est pas modifiée, la fréquence
d'horloge peut être augmentée, donc le débit.
Un pipeline d'instructions à N étages utilise N unités, chacune nécessitant t temps d'exécution (Figure 23). Le temps d'exécution total
(latence) sera T = t * N. Cependant, nous produisons un résultat toutes les t unités de temps ou une instruction complète toutes les t
secondes. La programmation ou le compilateur doit faire attention aux branchements qui pourraient casser le pipeline (lors de l'exécution
d'instructions consécutives, le branchement implique de sauter à une instruction autre que celles déjà dans le pipeline).
S1 S2 S3 S4 S5
Instruction Instruction Opérande Opérande Opérande

321 Aller chercher Décoder Aller chercher Exécuter Écrire
des instructions unité unité unité unité unité
Flux d'instructions
1 1
2 2 1
3 2 1 5
4 3 2 1
5 5 4 3 2 1
6 5 4 3 2 1 1
6 5 4 3 2 1
temps sept
(cycles)
S1 S2 S3 S4 S5
Figure 23 : Single instruction single data (SISD) avec pipeline d'instructions. Cinq étages sont utilisés pour prendre en charge
simultanément les instructions provenant de la mémoire. Chaque étape prend le même temps. L'instruction est finalement exécutée
après 5 étapes d'exécution.
Instruction unique à données multiples (SIMD). Un chemin d'instruction unique est utilisé pour contrôler un ensemble de chemins
de données parallèles travaillant sur différents flux de données (Figure 24). Ces architectures sont dédiées au traitement du signal avec
peu de communication entre elles (presque pas d'opérations de contrôle). Les processeurs vectoriels utilisent cette organisation dans un pipeline
mode. Le compilateur se charge d'exploiter le parallélisme des opérations. Cette architecture est intéressante pour les calculs gourmands
en ressources : virgule flottante, compression de données, calculs en grands entiers (cryptographie). Il est également intéressant pour des
opérateurs spécifiques pouvant travailler en parallèle, c'est le cas des processeurs de Signal Numérique DSP.
Chemin de données multiple
saisir saisir
des instructions Les données Les données
contrôler
unité
Données Données
Chemin Chemin
SIMD production production

architecture Les données Les données
Opération Parallélisme
Figure 24 : exemple SIMD. Une seule instruction contrôle les deux chemins de données, c'est-à-dire que la même opération est
effectuée simultanément sur des flux de données distincts.
Single instruction multiple data (SIMD) avec pipeline. L'architecture SIMD utilise également le pipeline d'instructions combiné au
parallélisme des données pour augmenter le débit de traitement (des instructions ou des données). Par exemple, l'architecture SIMD
superscalaire à cinq unités fonctionnelles combine le pipeline d'instructions avec le parallélisme des opérateurs nécessaire pour traiter les
opérations d'unités à virgule flottante (FPU) ou vectorielles (Figure 25). Les machines CISC ou VLIW reçoivent
25
des instructions complexes pouvant piloter des chemins de données distincts, une architecture SIMD à double pipeline (instructions et données)
combine le décodage des sous-instructions avec le parallélisme des opérateurs (Figure 26).
S3 S4 S5
ALU
S1 S2 ALU
Instruction Opérande Écrire

Décoder
Aller chercher Aller chercher retour
BOUTIQUE
Superscalaire SIMD
5 fonctionnel UPC
unités – 4
chemins de données
Figure 25 : Superscalaire SIMD avec pipeline d'instructions et chemins de données parallèles. Pipeline d'instructions
et parallélisme d'opérateurs hétérogènes (virgule flottante et autres opérations lentes et complexes)/homogènes (machine
vectorielle).
Figure 26 : Double pipeline SIMD avec étages de pipeline parallèles. Il fournit un pipeline d'instructions et un
parallélisme de données. Une seule instruction complexe VLIW (Very Large Instruction Word) extraite de la mémoire est
divisée en deux pipelines parallèles exécutant des instructions séparées (machines CISC ou VLIW).
GPU à unité de traitement graphique à instruction unique et données multiples (SIMD). L'architecture SIMD est largement utilisée
pour le traitement d'images. Le GPU de l'unité de traitement graphique utilise le calcul matriciel (par exemple, les processeurs NVidia utilisant le
langage de programmation CUDA) combinant, dans un tableau, des processeurs et des mémoires (cache) avec une seule unité de contrôle.
Des architectures SIMD similaires utilisent le concept de grille informatique, une grille d'éléments processeur/mémoire, mais avec une unité
centrale de traitement des instructions (Figure 27).
des instructions
Unité de contrôle
Consignes diffusées
CPU CPU CPU
MÉM MÉM MÉM
CPU CPU CPU Grille

de processeur/mémoire
MÉM MÉM MÉM 3x3
CPU CPU CPU
MÉM MÉM MÉM
Figure 27 : Architecture de base du GPU SIMD. Basé sur le GRID computing : grille de processeurs et d'éléments de
mémoire mais une seule unité de contrôle. Graphics Processing Unit GPU : Calcul matriciel (NVidia) et mémoire cache
par unité de traitement.
Multiple Instruction Multiple Data (MIMD)ÿ: chaque unité de calcul possède une instruction et un chemin de données uniques, effectuant
des opérations de manière asynchrone et indépendante (Figure 28). Pour assurer la cohérence des données, il est souvent
26
nécessaires pour synchroniser les processus parallèles. La technique de synchronisation dépend de l'organisation de la mémoire (partagée
ou distribuée).
saisir saisir
Les données Les données
des instructions des instructions
contrôler Données contrôler Données
unité Chemin unité Chemin
MIM interconnecter
architecture Réseau
production Synchronisation et production

Les données
échange de données Les données
Figure 28 : MIMD multi-instructions multi-données. Multiprocesseurs ou machine multicœur : chaque processeur exécute son
code de manière asynchrone et indépendante. Réseau d'interconnexionÿ: les processeurs doivent être synchronisés pour
l'échange de données afin d'assurer la cohérence des données partagées. Les techniques de synchronisation dépendent de
l'organisation de la mémoire (partagée ou distribuée).
Multiple Instruction Multiple Data (MIMD) avec mémoire partagée : les processus partagent le même espace mémoire (mémoire
partagée) et communiquent par des opérations d'écriture/lecture sur des variables partagées. La mémoire partagée est le mécanisme de
communication interprocessus le plus rapide. Les segments de mémoire partagée sont mappés dans l'espace d'adressage que plusieurs
processus peuvent lire et écrire. Les processeurs peuvent utiliser une mémoire cache, nécessaire pour maintenir la cohérence des
données. Ils peuvent aussi avoir une mémoire privée (sur un bus local).
Nous avons besoin de mécanismes de synchronisation offrant un accès exclusif à la mémoire. Comme ils utilisent une mémoire
partagée, des mécanismes de synchronisation tels que des sémaphores, des verrous, des variables de condition ou des mutex (barrières
d'exclusion et de synchronisation mutuelles) sont nécessaires. Un mutex signifie l'exclusion mutuelle, nécessaire à la synchronisation entre
les processus utilisant une position de mémoire partagée ou commune. Le processus utilisant le mutex peut verrouiller et déverrouiller une région.
Les processus peuvent synchroniser leur exécution en utilisant des variables de condition. Un processus attendra une notification d'un
autre processus pour continuer, par exemple lorsque les deux ont besoin de l'emplacement de la mémoire partagée ou simplement pour
échanger des données. Un sémaphore est un mécanisme de synchronisation entre processus basé sur un nombre qui bloque l'exécution,
l'état d'attente, d'autres processus.
MIMD Multiprocesseurs symétriques (SMP) à mémoire partagée et cache : le cas de MIMD à mémoire partagée uniforme (Figure
29). Les processeurs partagent la connexion avec un espace mémoire unique et accèdent à tous les emplacements mémoire à la même
vitesse. Les processeurs peuvent utiliser une mémoire cache, nécessaire pour maintenir la cohérence des données.
Bus
cache cache cache

partagé
MÉM
CPU CPU CPU
Mémoire globale
MIMD SMP simple avec
multiprocesseurs, cache et partage
Mémoire
Figure 29 : MIMD avec mémoire partagée. Les processeurs accèdent à une mémoire globale partagée commune (sur le Main
Bus) : synchronisation par sémaphores, verrous ou Mutex (exclusion mutuelle). Notez que les données sont partagées, donc
chaque processeur utilise une mémoire cache d'entrée
MIMD Multiprocesseurs symétriques (SMP) à mémoire partagée et locale : cas du MIMD à mémoire partagée uniforme (Figure
30). Les processeurs partagent la connexion avec un seul espace mémoire. Processeurs
27
avoir une mémoire locale (sur un bus local) où les données restent localement et privées. La synchronisation et le partage utilisent des
sockets, un mécanisme de synchronisation et d'échange client-serveur.
Bus
CPU CPU CPU

partagé
MÉM
MÉM MÉM MÉM
Mémoire globale
MIMD SMP avec mémoire partagée et locale
Figure 30 : MIMD avec mémoire partagée et locale. SMP Multiprocesseurs symétriques avec mémoires partagées globales (bus principal) et locales
ou privées (bus local).
Accès mémoire non uniforme (NUMA) : une variante de MIMD avec accès mémoire partagé non uniforme
(Figure 31). L'accès mémoire est non uniforme car certains processeurs ont des accès privilégiés (ils sont plus proches ou plus rapides), ce
qui est le cas entre deux SMP. Comme les processeurs peuvent nécessiter les mêmes données sur différentes banques de mémoire, NUMA
déplace les données entre les banques de mémoire. Pour équilibrer les temps d'exécution, chaque processeur dispose d'un cache et d'un
protocole nécessaires pour assurer la cohérence des données.
Bus Bus
cache cache cache cache

partagé partagé
MÉM MÉM
CPU CPU CPU CPU
SMP
architecture
NUMA
architecture
Figure 31 : Accès mémoire non uniforme (NUMA) : variante de MIMD avec accès mémoire partagée non uniforme. Des SMP séparés peuvent
fonctionner à des vitesses différentes et partager des données sur des banques de mémoire séparées.
Mémoire répartie MIMD : chaque processeur possède son propre espace mémoire ou mémoire locale et communique (synchronise ou
échange des données) avec les autres par messages. Cette architecture nécessite un réseau d'interconnexion
synchronisation. La vitesse de communication dépend de la topologie. L'échange d'informations entre processeurs peut utiliser le passage de
messages (envoi/réception de messages synchrones ou asynchrones) ou RPC Remote Procedure Call, l'exécution d'un processus sur la
machine distante. Les processeurs massivement parallèles et les clusters appartiennent à cette classe.
interconnecter
réseau
CPU CPU CPU
MÉM MÉM MÉM
Mémoire distribuée MIMD

Figure 32 : Mémoire distribuée MIMD : chaque processeur possède son propre espace mémoire ou mémoire locale et communique (synchronise ou
échange des données) avec les autres par des messages sur le réseau d'interconnexion.
Les données sont locales pour chaque processeur mais peuvent être échangées à l'aide de mécanismes de transmission de messages ou d'appel de
procédure distante.
Processeurs massivement parallèles (MPP)ÿ: les processeurs et l'infrastructure réseau sont très spécialisés. C'est une architecture
évolutive (facilement adaptable en taille et en nombre d'unités). Chaque processeur utilise son propre système d'exploitation et sa propre
mémoire. Les processeurs MPP peuvent travailler sur la même application, en communiquant à l'aide d'une interface de messagerie (les
messages sont envoyés entre les processeurs). MPP est considéré comme meilleur qu'un SMP parallèle pour les applications utilisant de
nombreuses bases de données à rechercher en parallèle.
28
Ils peuvent être classés comme suit :
o Clusters : réseau homogène de processeurs qui utilise des composants « prêts à l'emploi » prêts à l'emploi pour
processeurs et interconnecter les réseaux avec une gestion centralisée.
o Grids : réseau hétérogène de processeurs, semblable à des clusters, mais ne bénéficiant pas de centralisation
gestion (les ressources appartiennent à des organisations différentes).
29
2.7 Les formats de codage

Afin de faciliter la lecture des valeurs, des formats de codage autres que le codage binaire sont utilisés (voir Figure 33).
Les plus courants sont le binaire (base 2 - efficace pour stocker des données en mémoire), l' octal (base 8 - très peu utilisé
actuellement), le décimal (base 10 - moins pratique, mais on y est plus habitué) et l' hexadécimal (base 16 - plus compact).
La base est déterminée par le nombre de symboles utilisés pour la représentation de la valeur numérique. Par exemple, en décimal
on utilise 10 symboles (de 0 à 9), donc on utilise la base 10. Dans ce cas, la valeur 15d (décimal) est égale à 1*101+5*100
.
Figure 33 : Formats de codage communs et de base. (a) Tableau d'équivalence. Binaire : base 2, utilise seulement 2
valeurs 0 et 1, c'est le format utilisé pour stocker les données en mémoire. Hexadécimal, base 16, il est plus compact que décimal
nombres (un seul symbole hexadécimal représente un nombre décimal de 0d à 15d), et plus facile à lire que les valeurs
binaires (un symbole au lieu de 4 bits), c'est pourquoi il est préférable de représenter des valeurs numériques au lieu
d'utiliser des formats décimaux ou binairesÿ; il utilise 16 symboles, des chiffres de 0 à 9 et des lettres de A à F ; le tableau
montre la représentation équivalente par rapport aux valeurs décimales et binaires. (b) Représentation binaire de la valeur
décimale 15dÿ; la base 2 est utilisée pour calculer le poids des valeurs binaires à chaque position selon la position à partir
de 0, la valeur de position la moins significative 20 = 1 ; l'ajout des valeurs décimales pondérées résultantes nous permet
de récupérer la valeur décimale d'origine. (c) représentation hexadécimale de la valeur décimale 15d; la base 16 sert à
calculer le poids des valeurs hexadécimales à chaque position selon la position à partir de 0, la valeur de position la moins
significative 160 = 1 ; l'ajout des valeurs décimales pondérées résultantes nous permet de récupérer la valeur décimale
d'origine. Notez qu'une seule valeur hexadécimale peut être représentée en utilisant 4 bits, ainsi, un octet utilise 8 bits ou 2
symboles hexadécimaux.
Le format binaire, qui utilise la base 2 pour représenter les valeurs numériques, est le plus couramment utilisé pour stocker
des données en mémoire Comme indiqué sur la figure, seules deux valeurs, 0 et 1, sont utilisées pour représenter les nombres,
puis 4 bits représenteront uniquement les valeurs de 0d (décimal) à 15d (1111b=15d) et 8 bits, un octet, permettront de représenter
juste 256 valeurs décimales (28=256d). Comme pour les nombres décimaux, la valeur la moins significative se trouve du côté droit
à la position 0 et correspond au poids pondéré en base 2 20=1d (voir Figure 33).
Le format Hexadécimal (dans certaines langues représenté par un h ou un x devant ou après la valeur) est préférable car il
s'étend sur un ensemble de 4 bits (de 0000b ou 0h à 1111b ou Fh ; Notez que Ah=10d et Fh=15d ) au lieu du codage décimal qui
n'utilise que 10 symboles (de 0 à 9). Ainsi, pour un nombre de 4 bits, on a 24 ou 16 combinaisons possibles (on peut coder toutes
les valeurs de 4 bits dans un seul caractère hexadécimal).
30
Le BCD décimal codé binaire était autrefois utilisé pour représenter des nombres décimaux, alors 4 bits ne peuvent représenter
que des valeurs de 0d à 9d. Bien qu'il soit plus facile de suivre l'équivalence avec les valeurs décimales lors de la lecture des valeurs,
par groupes de 4 bits, ce codage n'est pas optimal car toutes les positions binaires ne seront pas utilisées (c'est-à-dire que les valeurs
de 10d=1010b à 15d=1111b ne sont pas représentées ). En effet, c'est moins compact, pour une cellule de 4 bits, il y a 24 ou 16
combinaisons possibles, mais seules 10 valeurs possibles sont utilisées (les 6 dernières valeurs sont perdues). Ainsi, pour 16 bits (4
groupes de 4 bits), seules 104 combinaisons (10 000) seront utilisées. Cependant, il est préférable lors de la conversion de nombres en
ASCII.
Les données non numériques telles que les caractères et les touches d'un clavier (touches de contrôle telles que ESC, Enter ou
Shift) utilisent la représentation ASCII , l' American Standard Code for Information Interchange (voir Erreur ! Source du renvoi
introuvable.). La représentation ASCII de base, qui utilise 7 bits, aide à représenter les caractères et les commandes de contrôle.
Cela a été défini à l'origine pour éditer des fichiers texte ainsi que pour envoyer un message entre machines.
L'extension 8 bits prend en charge des caractères supplémentaires autres que ceux utilisés par l'alphabet anglais et des symboles
supplémentaires pour représenter des équations et des dessins. Ce type de représentation peut être vu en détail plus tard, en
regardant les protocoles de communication et les interfaces telles que de UART RS232.
Figure 34 : Le codage des caractères ASCII et des commandes de contrôle. Les caractères et les commandes
de contrôle sont codés en utilisant des valeurs de 7 bits. Les chiffres sont codés de '0' (30h) à '9' (39h), les minuscules
de 'a`' (61h) à 'z' (7Ah) et les majuscules de 'A' (41h) à ' Z' (5Ah), les commandes de NULL (0h) à ESPACE (20h) et
DEL (7Fh) ne peuvent pas être imprimées, elles sont utilisées pour l'édition (TAB, retour de retenue CR, saut de ligne
LF, fin de texte EOT) et communication ou transmission de données (début de transmission STX, fin de transmission
ETX, acquittement ACK/NACK, synchronisation SYN, voire sonnerie BEL).
31
2.7.1 Valeurs signées

Lors du codage de valeurs entières positives, l'ensemble complet de bits est disponible, donc avec des mots de n bits, nous pouvons avoir
2n entiers positifs possibles. Lorsque le même nombre de bits sera utilisé pour représenter des entiers positifs et négatifs, cette valeur est
réduite de moitién-1
à2 . Le codage des valeurs négatives peut se faire en utilisant le complément à 1 ou le complément à 2.
Codage des entiers signés : son Complément. Afin d'obtenir la valeur négative équivalente d'un entier positif, il est nécessaire
d'effectuer l'opération NOT sur n'importe quel bit du mot, c'est-à-dire le complément du nombre. Notez que dans ce cas, les valeurs négatives
auront le bit le plus significatif mis à 1. Ce codage, bien que symétrique, aboutit à deux représentations possibles pour 00h et FFh. Le tableau
montre quelques exemples de codage en complément à un (voir la figure 35).
Figure 35 : Codage des entiers signés : son Complément. Les entiers positifs peuvent être convertis en entiers
négatifs en appliquant l'opération NOR à chacun des bits, c'est-à-dire l'opérateur de complément. Notez que le 0d aura
deux représentations +0(0h) et -0(Fh). Notez également la relation de séquence entre équivalent positif et équivalent
négatif : 0/F, 1/E, 2/D, 3/C, 4/B, 5/A, 6/9, 7/8. Comme dans l'exemple que nous codons sur 4 bits, nous ne pouvons
avoir que 0 à 7 valeurs positives (2 n-1 ) et F à 8 valeurs négatives.
Codage des entiers signés : Complément à deux. Le complément à un, bien qu'utile et symétrique, n'utilise pas l'ensemble complet des
bits disponibles ; par exemple, avec 4 bits, nous aurons 8 valeurs positives et 8 valeurs négatives, le 0 a deux représentations possibles. Afin
d'avoir une représentation unique, il suffit de décaler les valeurs de complément à un en ajoutant 1 au résultat (voir Figure 36). Dans ce cas,
nous aurons une seule représentation pour la valeur 0 et en plus nous aurons une valeur négative supplémentaire. Par exemple, lors du
codage de mots de 4 bits, on aura 8 valeurs positives (de 0 à 7) et 8 valeurs négatives (de -1 à -8).
Figure 36 : Codage des entiers signés : Complément à deux. Nous complétons tous les bits, donnant l'expression
intermédiaire (complément à un), puis, nous ajoutons 1, pour obtenir la valeur négative (complément à deux).
Pour décoder un nombre, vérifiez d'abord le bit de signe (le bit le plus significatif - à gauche), si le bit de signe est zéro,
c'est un nombre positif, sinon (le bit sing est 1) un nombre négatif.
Entiers signés : addition et soustraction. On peut remarquer que l'addition binaire peut toujours être utilisée pour faire une soustraction.
Par exemple, AB=A+(-B), dans ce cas nous devons utiliser le complément à deux de B, et l'addition devient une soustraction. Cependant,
comme pour les valeurs positives (vous le verrez plus tard), nous sommes limités au nombre de bits utilisés par le codage et un éventuel
surcoût (l'ajout de deux nombres pourrait nécessiter 1 bit supplémentaire) sera placé
sur le Carry Bit. La même situation se produit avec certaines valeurs signées, par exemple l'ajout de deux valeurs positives peut produire une
mauvaise valeur négative (voir Figure 37).
32
Figure 37 : Entiers signés : addition et soustraction. Les valeurs signées et non signées sont limitées au nombre de
bits disponiblesÿ; 4 bits dans l'exemple. Pour cette raison, certaines opérations valides peuvent produire un débordement ;
le bit supplémentaire est mis de côté et l'indicateur de débordement est défini. Le premier exemple montre l'addition de
valeurs non signées et signées. La première addition de deux valeurs positives produit le résultat correct, cependant, en
utilisant signé, l'addition se traduira par une mauvaise valeur négative. Les deux dernières soustractions de valeurs
signées produiront le résultat correct, mais l'indicateur de débordement est défini sur 1.
2.7.2 Représentation en point fixe

La représentation en virgule fixe est le format de codage le plus simple pour représenter les nombres décimaux. Comme pour les
valeurs signées/non signées, les valeurs à représenter seront limitées au nombre de bits, mais en plus de la position de la virgule
décimale. Cette représentation a un nombre fixe de bits pour la partie entière et pour la partie fractionnaire. La valeur maximale d'une
représentation en virgule fixe non signée avec i bits pour la partie entière et f bits pour la partie fractionnaire est calculée comme (2i
-1)+(1-2 -f ) pour non signé ou (2i-1 -1)+ (1-2 -f ) pour signé, et la valeur minimale
représenté par 2 -f . pour non signé ou –(2 i-1+(1-2 -f )) pour signé. Par exemple, la représentation en virgule fixe F.Fh ( entier 4
-4
bits et fraction 4 bits) peut prendre en charge une valeur non signée maximale 15,9375d=(24 -1)+(1-2) ( ou -7.9375d=(24-1 -1)+(1-
2 -4) signé) et une valeur minimale non signée 0,0625d=2 -4
(ou -8.9375d=(24-1 -1)+(1-2 -4
) signé). Comme pour les
nombres décimaux, par exemple 1,23d = 1*100+2*10-1+3*10-2 nous utilisons la position négative après le point pour calculer la
fractionÿ; dans son format binaire deviendra 0001.0100b ou 1.25d = 1*2 0+0*2 -1+1*2 -2 ; notez que la précision est
dégradée. Un avantage de la représentation en virgule fixe est que les opérateurs arithmétiques peuvent être appliqués directement (voir
Figure 38). Par rapport à la représentation en virgule flottante, les performances de calcul sont cependant plus élevées avec une
précision et une exactitude limitées au nombre de bits, donc insuffisantes pour l'analyse numérique.
Figure 38 : Représentation en point fixe. La principale différence entre la représentation entière et la représentation en
virgule fixe est que l'ensemble de bits est divisé en parties entières et fractionnaires, avec un nombre fixe de bits pour
chacune des parties. Le premier exemple montre comment un nombre décimal est représenté au format binaire à virgule
fixe et comment le nombre décimal peut être récupéré à partir de la représentation binaire. Notez que la précision de la
partie fractionnaire dépend de son nombre de bits. Les valeurs signées peuvent être obtenues avec le complément à
deux. L'addition et la soustraction peuvent être appliquées directement.
2.7.3 Nombres à virgule flottante

Les nombres à virgule flottante sont analogues à la notation scientifique. Ils contournent la limitation d'avoir un nombre constant
de bits entiers et fractionnaires, comme dans les représentations à virgule fixe , permettant ainsi la représentation de très grands et
très petits nombres avec une grande précision. Comme la notation scientifique, les nombres à virgule flottante ont un signe, la mantisse
M, base B et exposant E. Par exemple, le nombre 4,1 × 103 est la notation scientifique décimale pour 4100. Il a une mantisse de 4,1,
une base de 10 et un exposant de 3. La virgule décimale flotte à la position juste après le plus important
33
chiffre. Les nombres à virgule flottante sont en base 2 avec une mantisse binaire. En général, 32 bits sont utilisés pour représenter 1 bit de signe , 8
bits d' exposant et 23 bits de mantisse (voir Figure 39).
Figure 39 : Représentation en virgule flottante : forme binaire. La représentation en virgule flottante utilisée pour la
notation scientifique a un signe (pour distinguer les valeurs positives/ négatives ), la mantisse (un nombre décimal), la
base utilisée et l' exposant. L'exemple montre comment le nombre entier 228d est représenté en utilisant cette notation.
Dans la représentation binaire à virgule flottante, en général, 32 bits sont utilisés pour représenter 1 bit de signe, 8 bits
d'exposant et 23 bits de mantisse. Cependant, l'IEEE 754 utilise une polarisation constante 127d pour calculer un exposant
à polarisation positive. Le premier implicite, le bit le plus à gauche de la mantisse, est toujours 1, c'est pourquoi il n'est pas
inclus dans la partie fractionnaire. L'exposant doit représenter à la fois les exposants positifs et négatifs. Pour ce faire, la
virgule flottante utilise un exposant biaisé, qui est l'exposant d'origine plus un biais constant. L' exposant, lorsqu'il est
converti en sa forme binaire, est d'abord converti en un nombre binaire et biaisé avec la valeur +127. De cette manière,
l'exposant est codé sur 8 bits non signés.
La norme à virgule flottante IEEE a des cas spéciaux pour représenter des nombres tels que zéro, infini et résultats illégaux .
Par exemple, la représentation du nombre zéro est problématique en notation à virgule flottante en raison du premier implicite. Les codes spéciaux
dont les exposants ne sont que des 0 ou des l sont réservés à ces cas particuliers (voir Figure 40).
Figure 40 : Représentation en virgule flottante : cas particuliers. La norme à virgule flottante IEEE a des cas spéciaux
pour représenter des nombres tels que zéro, infini et résultats illégaux. Par exemple, la représentation du nombre zéro est
problématique en notation à virgule flottante en raison du premier implicite. Les codes spéciaux dont les exposants ne
sont que des 0 ou des l sont réservés à ces cas particuliers. Le 0 est un cas particulier où l'exposant et la fraction sont
tous deux des 0. Le dépassement de capacité ±ÿ est représenté avec la valeur maximale de l'exposant et toute la fraction de 0. NaN
est utilisé pour les nombres qui n'existent pas, comme –1 ou log2(ÿ5), pour cela, l'exposant maximum est utilisé mais la
fraction est non nulle.
Les opérations arithmétiques en virgule flottante impliquent plusieurs étapes de transformation (voir Figure 41) nécessitant de prendre soin du
signe, du biais d'exposant et de l'accommodation des fractions avant d'effectuer l'opération. Pour cette raison, une opération simple telle qu'une
addition nécessite de la puissance de calcul et du temps pour être effectuée.
34
Figure 41 : Virgule flottante : addition. Une seule addition de deux nombres à virgule flottante implique 8 étapes
nécessaires pour préparer les fractions et les exposants. Les mantisses peuvent être ajoutées mais seulement après
polarisation, comparaison et ajustement de la différence entre les exposants, ce qui conduira à repositionner (décaler) la plus petite mantisse.
Le premier doit être ajouté avant l'ajout et supprimé lors de la construction du résultat.
2.7.4 Codes de correction d'erreur

Les données peuvent être modifiées en mémoire par accident ou pendant la transmission. Afin d'éviter les pannes dues à des imprévus
des changements sur les bits de données, des bits supplémentaires sont utilisés pour permettre la détection d'erreurs lors du stockage ou de
la transmission de données, ce sont les codes correcteurs d'erreurs. Lorsque l'on ajoute r bits de contrôle à une séquence de m bits de
données, on obtient un mot codé de n bits (n=m+r) ou un ensemble de 2 n mots dans lequel seuls 2 m mots seront valides. Avec ces bits de
contrôle, il est possible de détecter le changement de valeur d'un ou plusieurs bits, voire, avec des méthodes plus élaborées, de corriger des erreurs.
Le bit de parité. Le mécanisme le plus simple pour détecter les erreurs de transmission de données ou de données stockées consiste à
vérifier la parité du mot. Le bit de parité est un bit supplémentaire permettant la détection d'une erreur dans un ensemble de bits. Il est ajouté
pour obtenir un nombre pair (parité paire) ou impair ( parité impaire) de bits à 1 dans un mot. Il ne permet que la détection d'une erreur simple
(changement d'un seul bit) ; il ne peut pas être utilisé pour déterminer lequel des bits a changé ou quand deux bits ou plus ont changé. La
parité paire consiste à ajouter un bit de contrôle (bit de parité paire) pour obtenir un nombre pair de bits à 1. Le contrôle de redondance cyclique
CRC, effectué lors de la transmission des données, utilise dans sa forme la plus élémentaire le bit de parité (ou division par le polynôme x+1).
La parité impaire ajoute un bit de contrôle (odd parity bit) afin d'obtenir un nombre impair de bits à 1.
35
Figure 42 : Le bit de parité. (a) Le bit de parité est un bit de contrôle ajouté à un mot de données. La valeur du bit de parité
sert à avoir une parité paire ou impaire pour un ensemble complet de bits. L'erreur, le changement d'un seul bit dans
l'ensemble, sera détectée en vérifiant simplement la parité. (b) l'exemple montre la parité paire et impaire d'un ensemble
de 8 bits (1 contrôle de partie + 7 données). Les 3 exemples montrent les valeurs de ce bit de contrôle dans le cas d'une
parité paire (nombre de bits impair à 1) ou impaire (nombre de bits impair à 1).
La distance de Hamming. Pour généraliser la détection d'erreurs, il existe des règles indiquant le nombre de bits de contrôle qu'il faut ajouter à un
mot de données et les erreurs qui peuvent être détectées et/ou corrigées. La distance de Hamming
représente le nombre de bits qui doivent changer pour transformer un mot correct en un autre mot également correct
(voir Figure 43). Cette distance est une mesure de la robustesse du codage. La distance de Hamming d entre deux mots indique le nombre de bits
différents entre ces deux mots. Pour déterminer le nombre de bits différents entre
deux mots, on utilise l'opération OU exclusif XOR entre les deux mots, le nombre de bits à 1 détermine cette distance d. Plus cette distance est grande,
plus les mots valides seront séparés, ce qui facilitera la détection des erreurs ; on obtiendra donc un code plus robuste.
Figure 43 : La distance de Hamming. La distance de Hamming d entre deux mots indique le nombre de bits différents
entre ces deux mots. L'exemple montre que pour avoir une distance de Hamming d=3, il faut au moins 23 -2=6 mots non
valides entre deux mots valides.
En utilisant des bits de contrôle ajoutés à un mot valide, il est possible de détecter ou de corriger une erreur, le changement d'un ou
plusieurs bits dans l'ensemble.
Détection d'erreur. Pour pouvoir détecter une erreur sur e bits, il faut utiliser des mots codés à l'aide d'une distance de Hamming d=e+1. Il faudra
donc modifier (e+1) bits pour transformer un mot valide en un autre mot également valide. Le bit de parité permet de détecter l'erreur d'un seul bit, donc
e=1 et la distance d=2, pour cela un seul bit de contrôle a été ajouté (voir Figure 42).
Figure 44 : Détection d'erreur à l'aide du bit de parité. Le bit de parité permet de détecter une erreur simple e=1. Le bit
de parité est ajouté au mot à protéger. Deux mots valides différents auront une distance de Hamming d=2=e+1, cela
signifie qu'un seul changement de bit dans l'un des mots reçus sera détecté. Notez deux exemples où un seul bit change,
en vérifiant simplement la parité, l'erreur peut être détectée (les valeurs résultantes n'ont pas de parité paire).
Correction des erreurs. Lorsqu'il est nécessaire, non seulement de détecter une erreur mais aussi de la corriger, des bits de contrôle
supplémentaires doivent être ajoutés. Pour pouvoir corriger une erreur sur e bits, il faut utiliser des mots codés avec une distance de Hamming d=2e+1.
Dans ce cas, lorsque l'erreur sera détectée, il faudra remplacer le mot par celui dont la distance de Hamming sera la plus proche. Par exemple, pour
corriger une double erreur (e = 2), il faudra donc utiliser un code de distance de Hamming d=5 (2*2 + 1).
36
Figure 45 : Correction d'erreur. Pour détecter et corriger une erreur simple e=1 il est nécessaire d'avoir une distance
de Hamming d=3=2e+1. L'exemple montre deux symboles valides avec une distance de Hamming d=5 entre eux,
dans ce cas une erreur e=2 (d=2e+1=5) peut être détectée et corrigée. L'erreur est détectée en calculant la distance
de la valeur reçue aux symboles valides. L'exemple montre le deuxième symbole valide reçu avec quelques bits
modifiés. Dans le premier exemple, 2 bits ont changé, dans le second 3 bits ont changé et dans le troisième pour les
bits changés. Seulement dans le premier cas, le bon symbole a été identifié.
Bits de contrôle. Pour corriger une erreur simple (e = 1), il faut au moins un code avec une distance de Hamming d =
3 ou (2e + 1) entre deux mots valides. Nous avons besoin d'une distance de Hamming d=2e+1, il faudra ajouter n mots non
valides pour chaque 2m mots valides, donc, le nombre total de mots 2nÿ n*2 m + 2m = (n + 1) 2m mots . En supposant que
le nombre de bits résultant (mot valide + contrôle) n=m+r, le nombre minimum de bits de contrôle r à ajouter doit satisfaire 2
r ÿ m+r+1 (voir tableau de la Figure 46).
Figure 46 : Correction d'erreur : Bits de contrôle nécessaires pour corriger une erreur simple e=1. Le nombre
de r bits de contrôle qu'il faut ajouter à 2 m mots de m bits doit satisfaire l'inéquation 2 r ÿ m+r+1. Notez que dans le
cas de seulement 2 mots valides (m = 1), r = 2 bits de contrôle doivent être ajoutés, et le nombre de bits résultant n =
3 montre une surcharge de 200 %. Cependant, la surcharge diminue lorsque le nombre de bits à protéger augmente.
Dans le cas de mots de 512 bits, il suffit d'ajouter r=10 bits de contrôle, produisant un surcoût de seulement 2 %.
L'algorithme de Hamming (1950). Le principe de fonctionnement de l'algorithme de Hamming peut être démontré par
un schéma du Ven. L'exemple montre le codage de mots de 4 bits pour détecter et corriger 1 seule erreur (erreur de 1 bit).
Dans ce schéma, un mot valide de 4 bits peut être représenté par des bits placés à l'intersection des trois ensembles A, B et
C et r = 3 bits de contrôle peuvent être ajoutés aux places restantes ; le nombre total de bits devient n=m+r=7. La valeur de
chaque bit de commande peut être calculée pour avoir une parité paire sur chaque ensemble. Dans le cas d'un seul bit
modifié, l'ensemble où la parité n'est même pas indique l'endroit où se trouve le bit modifié. Dans l'exemple (voir ) la parité
a changé sur l'intersection AC mais pas sur l'intersection ABC, c'est-à-dire que AC – ABC indique l'endroit où le
la valeur du bit a été modifiée.
Figure 47 : Correction d'erreur : L'algorithme de Hamming. Les 4 bits d'une valeur donnée (0100) sont représentés
dans l'intersection AB, AC, BC et ABC (un bit à chaque intersection) de trois cercles A, B et C. Dans chaque région
vide, on ajoute un peu de parité donc que la parité de chaque cercle est paire (bits en rouge) ; 3 bits de contrôle seront
donc utilisés (voir tableau du nombre de bits de contrôle nécessaires). Lorsqu'un bit est modifié (par exemple l'AC
37
bit d'intersection), la parité des régions A et C sera affectée. Cependant, l'intersection ABC n'a pas été affectée, ainsi,
la place du bit erroné est AC - ABC.
Code Hamming. Chaque bit de contrôle r fixe la parité d'un certain nombre m de bits du mot de code. Ainsi, un peu + bj = b. Dans l'exemple,
b peut être contrôlé par les bits tels que b1, b2, …, bj de manière à ce que b1 + b2 + … pour un mot de 16 bits (m=16), et r=5
bits de contrôle, le bit en position 5 est contrôlé par les bits b1 et b4 de sorte que 1+4=5. Les bits sont numérotés à partir de 1, le bit 1 étant le plus à
gauche (le plus significatif). Les bits de parité portent les nombres correspondant à des puissances de 2. Dans l'exemple (voir Figure 48), les bits 1, 2,
4, 8 et 16 sont des bits de parité et les autres sont des bits de données. Une autre façon de trouver l'erreur consiste à détecter d'abord les positions
de bit avec une parité incorrecteÿ; la somme des valeurs de position incorrectes donnera la position du bit défectueux.
Figure 48 : Correction d'erreur : Le codage de Hamming. Le bit 1 contrôle les bits 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 et 21.
Le bit 2 vérifie les bits 2, 3, 6, 7, 10, 11, 14, 15, 18 et 19. Dans l'exemple, si le bit 5 est inversé, les bits 1 et 4 affichent
une parité incorrecte. Par différence entre les bits 1 et 4, on trouve que l'erreur se situe entre les bits 5, 7, 11, 15 et 19.
Mais, en considérant les bits 2, 8 et 16 où la parité est correcte, on sait que les bits 7, 11, 15 et 19 sont corrects. Une
autre façon de trouver l'erreur consiste à détecter d'abord les positions de bit avec une parité incorrecteÿ; la somme
des valeurs de position incorrectes donnera la position du bit défectueux. Dans l'exemple, si les bits de parité 1 et 4
sont incorrects, le bit 5 = 1 + 4 a été inversé.
2.8 La mémoire : concepts de base

Le processeur nécessite une mémoire pour stocker le programme d'exécution ainsi que des données. En effet, la mémoire stocke
les programmes, sous forme d'instructions à exécuter, ainsi que des données.
La mémoire est constituée d'un tableau de bits disposés en lignes et en colonnes (voir Figure 49). Une mémoire ordinaire est donc constituée
d'un nombre de cellules C d'une certaine taille k en bits (k cellules de 1 bit par exemple). Un bit est une unité de mémoire, qui peut avoir une valeur
binaire (base 2) de 0 ou 1. Le codage binaire est très efficace en termes de capacité de stockage de données.
Les bits peuvent être organisés en groupes pour former un autre type de cellule. Par exemple, des cellules de 1 bit, regroupées en ligne,
constituent un mot de données de k bits. Un mot est la plus petite quantité d'information adressable ou d' unité adressable. Ça peut
consistent en un ou plusieurs bits (par exemple 8 bits, soit 1 octet). La quantité ou quantité d'information, pour un mot de k bits, est représentée par
k
le nombre de valeurs différentes que ce mot peut stocker, dans notre exemple 2 différentes valeurs possibles.
8
Par exemple, un mot de 8 bits, un octet, peut représenter 2 (256) valeurs possibles. Notez qu'un mot de 1 méga-octet
20
(ou Mo) en base 10 représente 106 octets, mais en base 2 est 1 048 576 octets (= 10242 octets = 2 octets). Lorsque
organisant les bits d'un mot, les bits de poids fort MSB sont parfois (nous le verrons plus loin) placés à l'extrême gauche et les bits de poids faible
LSB à l'extrême droite (voir Figure 51).
Les mots mémoire sont accessibles à l'aide d'une adresse. L' adresse fait référence à la position d'un mot de k bits dans la mémoire.
Pour une mémoire de mots C , nous avons besoin de 0 à C-1 adresses différentes codées à l'aide d'adresses de n bits (n = log2C). Ainsi, pour
accéder à un seul mot dans une mémoire de 1024 mots, nous avons besoin d'une adresse de 10 bits (10 = log21024).
Il est important de mentionner que la taille en bits d'un mot de données détermine généralement la taille des registres de données
utilisé par le processeur ainsi que la façon dont les processeurs sont nommés, par exemple un processeur 8 bits ou 32 bits . Autrefois, les processeurs
utilisaient des registres de tailles différentes, parfois liées à leur puissance de traitement, cependant, les processeurs d'aujourd'hui utilisent
majoritairement des multiples d'octets (1,2,… octets).
38
Figure 49 : Principes de base des mots mémoire et des adresses. (a) une simple mémoire sous la forme d'un tableau de 4 lignes de 3 bits
chacune peut stocker 4 mots de 3 bits. (b) mémoire générique et exemple montrant la relation entre le nombre de mots, le nombre de bits
d'adresse requis et la taille des données. (c) des exemples de certains processeurs traditionnels bien connus et de leurs tailles de registre
(notez qu'aujourd'hui les processeurs de bureau sont de 32 à 64 bits, mais les processeurs de 4 à 8 bits sont toujours utilisés pour les tâches
embarquées, périphériques et à faible consommation).
Parfois, la mémoire n'est pas bien adaptée à la taille des mots de données utilisés par le processeur, comme cela peut arriver avec
des mémoires externes. Dans ce cas, nous pouvons remarquer qu'une partie de la mémoire ou des adresses sont inutilisées. Ainsi,
l'organisation de la mémoire est très importante, car elle détermine le meilleur rapport entre le nombre de bits par mot (ou cellule
d'information) et le nombre de bits d'adressage. Dans le passé, le nombre de bits, et donc l'organisation utilisée par les fabricants
d'ordinateurs, n'était pas standardisé (voir Figure 49). Par exemple, l'IBM a utilisé 8-
cellules 16 bits, tandis que DEC utilisait 12 bits. Le nombre de bits d'adresse limite parfois la taille de la mémoire, par exemple, les
processeurs 8 bits tels que l'Intel 8051, qui utilisent des adresses 16 bits, ne peuvent adresser que 65k positions mémoire (2
16
= 65 536). Cependant, faire correspondre l'adresse, la mémoire et la taille des données reste un problème courant, particulièrement
important non seulement lors de la conception, mais également lorsque la capacité de stockage d'un processeur existant doit être étendue.
Par exemple, le PIC 16F est un microprocesseur 8 bits, soit une taille de données de 8 bits mais selon la sous-famille, les instructions
peuvent avoir une taille de 11, 12 ou 14 bits. Ensuite, pour l'instant, nous allons juste voir ce qui se passe lorsque cette relation de taille
n'est pas totalement atteinte.
L'exemple suivant montre la relation de taille qui doit exister entre la mémoire, les données et l'adresse pour avoir une correspondance
parfaite (pas de perte de mémoire ou d'emplacements de mémoire ou d'adresse inutilisés). Considérons une mémoire d'une certaine taille
M en bits qui doit être organisée en un nombre de C cellules de k bits. Le choix de la taille k de bits par cellule par rapport à la taille M de
la mémoire détermine le nombre de bits nécessaires à l'adressage des cellules. Pour une organisation M=C*k , nous aurons besoin des
bits d'adresse A=log2C . Par exemple, pour une mémoire de M = 96 bits et 8 bits par mot, il faudra adresser 12 mots (96/8) et il faudra au
moins des adresses de 4 bits (log212=3.6), on perd donc 4 adresses (24 -12 = 16–12 = 4 adresses inutilisées). Au contraire, pour la même
taille de mémoire et 16 bits
mots, nous devrons adresser 6 mots (96/16) et nous aurons besoin d'adresses d'au moins 3 bits (log26=2,58), donc nous perdons 2
adresses (23 -6 = 8–6 = 2 adresses inutilisées). Pour cette mémoire, la correspondance parfaite utilise des mots de 12 bits, puis nous
devrons adresser 8 cellules (96/12) en utilisant une adresse de 3 bits (log28=3), nous utiliserons donc toutes les adresses disponibles (23
= 8 ). Maintenant, même si cela sort du cadre de l'exemple, vous pouvez imaginer des problèmes de correspondance similaires lorsque
l'adresse ou la taille du mot ne peut pas changer, d'autres techniques de conception doivent donc être appliquées.
39
Figure 50 : Mémoire, mots et adresses : relation de taille exemple : une mémoire de 96 bits. (a) 12 mots de 8 bits nécessitent
des adresses de 4 bits, c'est-à-dire 4 adresses inutilisées. (b) 8 mots de 12 bits nécessitent des adresses de 3 bits (toutes les
adresses sont utilisées). (c) 6 mots de 16 bits nécessitent des adresses de 3 bits, c'est-à-dire 2 adresses inutilisées.
2.8.1 La mémoire : endianness ou ordre des octets

En un mot, les bits peuvent être ordonnés de gauche à droite ou de droite à gauche. Cet ordre n'est pas toujours le même, cela
dépend du type et de la famille de processeurs que nous utilisons, et des problèmes surgiront si nous ne connaissons pas cet ordre.
Dans le premier cas, les bits les plus significatifs sont placés à partir du côté gauche du mot et les bits les moins significatifs sont
placés à droite.
La même chose peut arriver avec les octets d'un mot composé de plus de 8 bits, qui sont placés dans une mémoire de 8 bits.
Dans ce cas, nous pouvons placer les octets les plus significatifs MSB en premier, puis les octets les moins significatifs LSB, ou
vice versa. Un autre cas est lorsque nous utilisons une mémoire qui peut contenir des mots longs de plusieurs octets, nous avons
besoin de savoir comment ces octets sont ordonnés sur la mémoire, pour récupérer la bonne valeur lors de la lecture de la mémoire (voir Figure 51).
Ces deux ordres différents de bits ou d'octets sont appelés endianness. On distingue ainsi l'ordre Big Endian
et le petit boutien.
Adresse
MÉM
0x00 Mot 0
0x02 Mot 1
0x04 Mot 2
0xCA 0xFE
Octet 0.0 Octet 0.1
0b11001010 0b11111110
1 1
ESM LSB
Figure 51 : Les mots mémoire et les adresses ne sont pas toujours liés. Un mot mémoire est composé de plusieurs bits. Dans
l'exemple, un mot de 16 bits (2 octets) est représenté. Les bits sont organisés en plaçant les bits les plus significatifs MSB à
gauche et les bits les moins significatifs LSB à droite. L'adresse est utilisée pour accéder à chacun des mots mémoire. Dans
l'exemple, la mémoire est organisée en octets, puis deux positions d'adresse sont utilisées pour stocker un seul mot de 2 octets.
Le Big Endian (utilisé par les microsystèmes Motorola, MIPS et SUN) est l'ordre des octets sur un mot commençant par l'octet le
plus à gauche, le MSB, de gauche à droite, jusqu'au LSB (voir Figure 52 (b)). C'est pourquoi est nommé Big Endian, nous partons de
la plus grande valeur significative qui est normalement placée sur le côté gauche du mot. Cependant, l'ordre inverse existe.
Le Little Endian (utilisé par Intel) est l'ordre des octets en commençant par l'octet le plus à droite, le LSB, à partir de
de droite à gauche, vers le MSB (voir Figure 52 (c)).
40
Figure 52 : Endianité : Big et Little Endian. (a) un mot mémoire composé de plusieurs octets peut être ordonné et
lu de gauche, ou les octets les plus significatifs MSB, vers la droite, les octets les moins significatifs LSB. (b) Le grand
L'ordre Endian commence par écrire en mémoire le MSB, donc de gauche à droite. Dans ce cas, le mot d'origine, qui
peut parfaitement tenir sur un mot mémoire de 4 octets, sera placé sur une mémoire de deux octets en écrivant les
deux premiers MSB à la première adresse et les deux derniers (le LSB) placés à la deuxième adresse. (c) L' ordre
Little Endian commencera par écrire les octets les moins significatifs. Dans ce cas, le mot d'origine lorsqu'il est placé
sur une mémoire de mots de 4 octets contiendra le MSB à droite du mot et le LSB à gauche. Lors de l'utilisation d'une
mémoire de mots de 2 octets, Little Endian commencera par écrire les deux premiers LSB à la première adresse et
les deux derniers octets (le MSB) seront placés à la deuxième position d'adresse.
L'endianité devient un problème lors de l'écriture de mots qui ne tiennent pas sur une seule position de mémoire. En effet,
selon la taille d'un mot en mémoire, vous pouvez voir que les octets d'un seul mot long, par exemple de 4 octets, seront découpés
et placés à plusieurs positions d'adresse selon l'endianité. Cela peut devenir un problème lors de la récupération du mot de la
mémoire, si nous ne connaissons pas l'ordre dans lequel les octets ont été stockés, nous ne saurons pas comment construire le
mot d'origine (voir Figure 53).
Figure 53 : Endianité et taille du mot mémoire. (a) un mot mémoire composé de plusieurs octets peut être ordonné
et lu de gauche, ou les octets les plus significatifs MSB, vers la droite, les octets les moins significatifs LSB. (b) Dans
une mémoire adressable par octet, une mémoire qui contient des mots de 1 octet, lorsqu'elle suit l'ordre Big Endian,
aura le MSB placé à la première adresse et le LSB à la dernière. (c) Dans une mémoire adressable à 2 octets et
utilisant Bit Endianness, les deux premiers MSB seront placés aux deux premières positions de mémoire et les deux
derniers LSB placés à la fin. Ici, chaque adresse contient 2 octets également ordonnés selon le Big Endianness. (d)
Dans une mémoire de 4 octets, le mot complet peut être parfaitement placé et nous n'aurons pas de problème pour
le lire, mais seulement si le processeur est un gros boutien.
L'endianness devient un problème lors de l'utilisation d'une mémoire partagée entre des processeurs d'endianness différents.
Dans ce cas, la lecture et l'écriture peuvent changer complètement le sens ou la valeur d'un mot stocké en mémoire (voir Figure
54).
Figure 54 : Endianité et transfert de données. (a) une machine Big endian écrira la mémoire en plaçant le MSB à la
première adresse et les octets consécutifs jusqu'au LSB aux adresses suivantes. Ainsi, le MSB est d'abord envoyé à
travers le bus mémoire pour être placé à la première position mémoire. Cependant, si cette mémoire est lue par une
machine Little Endian, elle considérera le premier octet comme le LSB, puis l'ordre des octets dans le
41
mot récupéré sera le contraire. (b) La machine Little Endian commencera par transférer le LSB, qui sera placé au premier
emplacement d'adresse de la mémoire. Le MSB sera placé au dernier emplacement de mémoire.
Lors de la récupération de ce mot de la mémoire à l'aide d'une machine Big Endian, elle considérera, à tort, que l'octet à la première
position de la mémoire est le MSB, et le mot récupéré aura les octets inversés.
2.8.2 Mémoire : types, contenus et exemples

Une mémoire peut contenir aussi bien des instructions que des données, c'est-à-dire une mémoire unifiée, ou une seule de ces deux choses. Basé
là-dessus, nous verrons comment la mémoire est utilisée et aussi la terminologie qui va avec.
Une mémoire qui ne contient que des instructions ne sera utilisée qu'en mode lecture seule, ainsi, le terme utilisé est ROM ou Read-Only-Memory.
Normalement, ce type de mémoire ne contient que le programme qui sera exécuté par le processeur, écrit uniquement ceux-ci et stocké en permanence.
Comme le programme ne changera pas, du moins jusqu'à sa prochaine mise à jour, et qu'il doit rester en mémoire avec ou sans mise sous tension du
processeur, le programme est écrit sur une mémoire non volatile. Ainsi, une mémoire non volatile NVM n'a pas besoin d'une alimentation constante
pour conserver ses données, qui restent même lorsque le processeur est éteint. Comme un programme, qui est composé d'instructions, peut également
contenir des valeurs constantes, ces valeurs sont également stockées sur la mémoire ROM destinée aux instructions.
Une mémoire peut également contenir uniquement des données qui peuvent être produites ou consommées, dans ce cas, nous devons lire et
écrire cette mémoire. Le terme traditionnel utilisé est RAM ou Random-Access-Memory, ou une mémoire en lecture-écriture. Dans le cas où ces
données n'ont pas besoin d'être conservées, elles peuvent être stockées sur une mémoire non volatile . Cependant, certaines données utilisées pour
configurer le processeur, par exemple définir la fréquence, la taille et l'emplacement de la mémoire, ou le nombre d'E/S disponibles, doivent être
conservées sur une mémoire non volatile , même si cette mémoire ne contient que des données.
On peut voir quelques exemples d'organisation de la mémoire en fonction de son contenu en regardant les architectures de base, les Von
Neumann et Harvard. Comme le Von Neumann utilise une mémoire unifiée qui contient des données et des instructions, les emplacements de mémoire
peuvent être regroupés en instructions (le programme) placées sur une ROM et des données, placées sur une RAM. Dans le cas de l' architecture
Harvard (voir Figure 55), la mémoire est scindée en ROM d'instructions et RAM de données mais en utilisant deux bus séparés, un pour les instructions,
allant à l' unité de contrôle, et un autre pour les données, utilisées par l' arithmétique et la logique. unité. Dans ce cas, nous avons deux chemins
parallèles : le chemin de contrôle (composé de la mémoire d'instructions et de l'unité de contrôle) et le chemin de données (composé de l'ALU et de la
mémoire de données).
L'adressage, le type et le contenu de la mémoire dépendront de l'architecture du processeur. Par exemple,
les processeurs comme le Zilog Z8 8 bits auront, selon les versions, une adresse 12 bits ou 13 bits pour accéder à la 4K
(212=4096) ou 8K (213=8192) positions de mémoire ROM ou Flash non volatiles pour stocker le programme, et seulement 64 à 512 positions dans la
mémoire RAM volatile pour stocker les variables et les données.
Processeurs à usage général GPP doit pouvoir charger les programmes de plusieurs utilisateurs, il utilise donc la mémoire RAM pour ces
programmes, et le chargeur de démarrage, stocké dans la mémoire ROM, est prêt à rediriger l'exécution vers les programmes des utilisateurs (voir
Figure 55 ). Le bootloader, est alors un petit programme qui va d'abord gérer le téléchargement du programme utilisateur, l' application, sur une
mémoire RAM non volatile, et après cela, le programme utilisateur sera exécuté par l'unité de contrôle.
ROM RAM ROM RAM RAM

Données Botte Programme Données
Programme
chargeur Mémoire Mémoire
Mémoire Mémoire
adresse adresse/données adresse adresse/données
Entrée sortie Entrée sortie

Contrôler Arithmétique Contrôler Arithmétique
Unité Unité logique Unité Unité logique
Harvard Harvard
Figure 55 : L'architecture de Harvard et deux organisations de mémoire possibles : (a) programme d'application stocké sur une
mémoire morte non volatile ROM et une mémoire RAM de données séparée pour le chemin de données. (b) Un programme bootloader stocké sur non
42
mémoire ROM volatile (pour télécharger le programme d'application de l'utilisateur) et le programme d'application sur une deuxième mémoire RAM non volatile
en lecture-écriture.
Le processeur Intel 8051 (architecture A Von Neumann) utilise un bus d'adresse 16 bits (64K positions mémoire) pour adresser
les instructions et les données (voir Figure 56). Les instructions sont stockées dans la mémoire ROM externe et les données dans la
mémoire RAM externe. Les deux échangent avec le processeur via un seul bus de données 8 bits. Les instructions sont donc de taille
variable, composées de 1 ou plusieurs groupes de 8 bits. Les instructions placées à l'extérieur
Les ROM sont adressées à l'aide de l'adresse PC + AC (PC, le compteur de programme et AC, l' accumulateur, un registre dédié).
Cette ROM peut contenir le programme ou le bootloader. Dans le second cas, la RAM externe peut contenir l'application ou le
programme utilisateur en plus des données. Les données placées dans la RAM externe peuvent être adressées en utilisant le DPTR +
AC (DPTR, le pointeur de données, un registre 12 bits pour accéder aux données dans la mémoire externe). Les instructions placées
dans la RAM externe peuvent être adressées en utilisant l' adresse PC+AC . Une RAM interne est disponible pour les registres (4
bancs de 8 registres de 8 bits chacun), les opérandes de bits, la pile et les registres de fonctions spéciales.
Figure 56 : Organisation mémoire du processeur Intel 8051 : Le processeur Intel 8051 utilise un bus d'adressage 16 bits (64K positions mémoire)
pour adresser la mémoire externe contenant les instructions (CODE) et les données. Les deux échanges via un seul bus 8 bits. Les instructions, de
taille variable, sont composées de 1 ou plusieurs groupes de 8 bits. L'adresse PC+AC (PC, le compteur de programme et AC, l'accumulateur) est
utilisée pour les instructions. L'adresse DPTR+AC (DPTR, le pointeur de données, un registre 12 bits) est utilisée pour les données. La ROM peut
contenir le programme ou le bootloader. Dans le second cas, la RAM externe peut contenir l'application ou le programme utilisateur. Une RAM interne
est disponible pour les registres (4 bancs de 8 registres de 8 bits chacun), les opérandes de bits, la pile et les registres de fonctions spéciales.
Le Microchip PIC16 utilise trois mémoires avec des tailles de mots différentes selon le type de contenu (voir Figure 57). Le PIC16
étant à la base une architecture Harvard, il dispose des instructions, de taille 12, 14 ou 16 bits selon les familles, stockées sur une
ROM 8K, des valeurs constantes sur une petite EEPROM 256x8 séparée, et des données sur une mémoire 368x8 bits RAM. Vous
remarquerez également qu'il dispose d'une petite RAM utilisée comme pile de données temporaires, pointée par le pointeur de pile.
Les premières adresses de la ROM contiennent le vecteur d'interruption, les adresses des routines à utiliser pour traiter les interruptions
(voir la section Interruptions), en particulier l'adresse de la routine d'interruption de réinitialisation (la routine prenant en charge
l'interruption de réinitialisation) placée à l'adresse 0h, le reste de cette mémoire contient le programme.
Figure 57 : Les mémoires Microchip PIC16. Le PIC16 est une architecture Harvard, avec des mémoires ROM et EEPROM pour les instructions et les
constantes et des mémoires RAM pour les données et la pile de données (pointées par le pointeur de pile). La
43
les instructions, de taille 12, 14 ou 16 bits selon les familles, sont stockées sur une ROM 8K, les valeurs constantes sur une petite EEPROM 256x8 séparée,
et les données sur une RAM 368x8 bits. Les premières adresses de la ROM contiennent le vecteur d'interruption, les adresses des routines à utiliser pour
traiter les interruptions, l'adresse de la routine d'interruption de réinitialisation (la routine prenant en charge l'interruption de réinitialisation) est placée à
l'adresse 0h. Le compteur de programme PC pointe vers l'adresse de la prochaine instruction à exécuter. Lors d'une réinitialisation du processeur, le PC
pointe sur la première position de cette mémoire (généralement, l'adresse 0000h) où se trouve la première instruction à exécuter ou sur un pointeur (une
adresse placée à cet endroit) sur la prochaine instruction ou à la position où se trouve réellement le programme (dans l'exemple, l'adresse 005h). Dans
cette dernière position, on peut placer un bootloader (c'est le cas pour notre 8051, ainsi que pour le PIC). La pile est placée en mémoire RAM et sert à
garder un ordre d'exécution lors des appels et retours de fonction et des interruptions (nous verrons cela plus tard).
2.8.3 Hiérarchie des mémoires

Différents types de mémoires sont utilisés par le microprocesseur pour de multiples raisons, par exemple la vitesse, la capacité de stockage, le prix ou
la taille, qu'un seul type de mémoire ne peut pas toujours satisfaire. Cependant, les mémoires sont classées selon la proximité avec le cœur du processeur,
de manière hiérarchique qui dépend de la rapidité, du prix
et la capacité de stockage des données (voir Figure 58).
Les registres sont utilisés à l'intérieur du processeur pour stocker des données. Les registres sont au cœur du processeur. Un registre
est une mémoire rapide pouvant stocker un certain nombre de bits. Les registres les plus couramment utilisés par l' unité de contrôle sont le compteur de
programme PC, utilisé pour pointer vers la prochaine instruction à exécuter, et le registre d'instructions IR, pour stocker l'instruction en cours d'exécution.
Le chemin de données a également des registres dédiés tels que l' accumulateur ACC, pour stocker les opérandes d'entrée/sortie/résultats utilisés/produits
par l'ALU, le pointeur de pile SP, un mécanisme qui fournit une organisation de pile de données, et le registre d'état STA, qui contient des drapeaux
indiquant l'état de l'ALU après avoir effectué une certaine opération ou des événements entrants. Certains registres sont plus génériques et utilisés
indistinctement par l'ALU ou l'unité de contrôle et regroupés dans une banque de registres. D'autres sont liés aux périphériques d'E/S (par exemple, registres
pour la transmission/réception de données UART, ADC/DAC, temporisateurs ou ports d'E/S génériques). Ce sont les éléments mémoire les plus chers mais
les plus rapides, c'est pourquoi il est préférable d'utiliser des instructions utilisant des registres plutôt que tout autre type d'accès mémoire. Chaque bit d'un
registre est un bistable volatile, un verrou ou un maître-esclave
combinaison de verrous, nommé Flip-Flop.
Figure 58 : Hiérarchie des mémoires. Les mémoires les plus rapides, les bascules et les verrous, sont utilisées dans le processeur. Plusieurs
bascules sont combinées pour former des registres dédiés d'une certaine taille en bits. Des banques et des piles de registres sont ensuite fournies
en utilisant des SRAM volatiles à lecture/écriture statiques. Les SRAM peuvent également être utilisées comme mémoires cache. Des mémoires
vives dynamiques en lecture/écriture, plus lentes mais avec une capacité de stockage plus élevée sont également utilisées comme mémoires
caches. Les mémoires non volatiles ROM en lecture seule et Flash sont utilisées pour stocker des ensembles de données encore plus grands, y
compris plusieurs programmes, en tant que mémoires externes. Les disques magnétiques et les CD sont également encore utilisés comme
mémoires bon marché et à grande capacité de stockage.
44
La mémoire SRAM à lecture/ écriture statique à accès aléatoire est une mémoire utilisée pour stocker de grands ensembles de données, y compris des banques
de registres et des piles. Les bascules et les RAM sont toutes deux des mémoires volatiles (perdent de la valeur lorsqu'elles ne sont pas alimentées) et ne peuvent donc
pas contenir de programmes en permanence, mais elles sont très rapides (avec des temps de lecture/écriture de 0,5 à 2,5 ns).
Les SRAM et les DRAM à lecture/ écriture volatiles dynamiques sont également utilisées comme mémoires cache. Les DRAM sont moins chères et
fournir un stockage de données plus important que SRAM.
La mémoire ROM en lecture seule est non volatile ; il peut donc contenir le programme à exécuter,
en permanence. C'est une mémoire de grande capacité et moins chère que la SRAM. Différents types de ROM existent. Certains ne peuvent être écrits qu'une seule fois,
d'autres sont effaçables, en utilisant de la lumière ultraviolette UV ou des signaux de contrôle de tension plus élevée. Les mémoires Flash modernes à haute capacité de
stockage offrent un stockage non volatile à long terme et peuvent être écrites plusieurs fois.
La mémoire Flash (voir Figure 59) est non volatile, les données peuvent être écrites plusieurs fois mais à vitesse lente, et apporte une capacité de stockage bon
marché et élevée pour les données et les programmes comme n'importe quelle ROM. C'est une mémoire moins chère et plus lente qu'une mémoire RAM, mais plus chère
(de 6 à 10 fois) et plus rapide (de 100 à 1k fois - entre 10-40Mo/s en lecture et 0.4-8Mo/s en écriture) qu'une disque magnétique. Aussi, il consomme moins qu'une mémoire
RAM et un disque magnétique, mais sa durabilité est moindre (supportant un nombre d'écritures compris entre 100k et 1M).
Les cellules de mémoire Flash sont regroupées dans des structures de stockage de données compactes NOR (plus rapide) et NAND (plus longue durée). Il s'agit
d'une ROM effaçable électriquement de type EEPROM, ayant les caractéristiques d'une mémoire à accès aléatoire
mémoire (peut être écrite plusieurs fois), mais dont les données ne disparaissent pas à la mise hors tension. Sa cellule de base est un transistor MOS à grille flottante
enterrée au milieu de l'oxyde de grille (entre le canal et la grille). Les données sont stockées en piégeant des électrons dans cette grille flottante (voir Figure 59). Les
données sont écrites et effacées en appliquant différentes tensions aux points d'entrée de la cellule.
Figure 59 : Mémoires flash. Les mémoires flash sont utilisées comme (a) cartes SD, (b) disques durs à semi-conducteurs,
clés USB et EEROM sur microprocesseurs. La mémoire Flash est non volatile, un transistor MOS à grille flottante (c) est utilisé
comme interrupteur (marche/arrêt) et les données peuvent être lues comme 0 ou 1 selon leur état. Le transistor devient actif
(allumé) en stockant des charges dans cette grille flottante. Le processus d'écriture est lent, car des tensions supérieures à la
normale et des signaux de commande supplémentaires doivent être appliqués au transistor pour être effacé ou écrit. Les
transistors sont regroupés en formant deux types de structures, NOR (plus rapide) et NAND (données plus durables), rendant
les cellules plus compactes et facilitant un effacement simultané. Cependant, pour réduire le temps d'écriture, le processus
d'écriture s'applique à un bloc de cellules de données.
La mémoire cache est utilisée pour accélérer le processus de lecture des données/instructions à partir d'une mémoire externe ou secondaire. Pour cette raison, le
cache est placé entre le processeur et la mémoire principale ou externe, permettant un accès plus rapide aux données et/ou aux instructions. Comme cela sera détaillé
plus loin, le cache contient des données fréquemment utilisées ou des blocs d'instructions, auxquels on peut accéder plus rapidement que la mémoire principale. Le
processeur consulte d'abord le cache et si les données ne s'y trouvent pas, il accède à la mémoire principale et copie les données sur le cache. Cependant, les mémoires
cache ne peuvent contenir qu'une petite partie de la mémoire externe, en raison de sa plus petite capacité de stockage. Les mémoires cache peuvent être construites à
l'aide de SRAM statique (plus rapide) ou de DRAM dynamique (plus grande capacité). Les DRAM sont plus lentes que les SRAM (de 50 à 70 ns), nécessitent un mécanisme
de rafraîchissement pour conserver les données (les données doivent être réécrites fréquemment à l'aide d'un signal d'horloge de rafraîchissement) mais son prix (supérieur
à celui d'une mémoire secondaire mais moins cher qu'une SRAM) et la capacité de stockage (inférieure à la ROM) limite la quantité d'informations qu'elle peut contenir.
45
Figure 60 : Mémoires cache. Les caches sont des mémoires rapides placées entre le processeur et la mémoire principale pour
accélérer l'accès aux données. Les technologies couramment utilisées sont la SRAM statique et la DRAM dynamique (plus lente
mais avec une capacité de stockage plus élevée que les SRAM). Selon le contenu, un cache peut être unifié (contenant des
données et des instructions) ou séparé (contenant uniquement les instructions I ou les données D). Comme la taille du cache
diminue lorsqu'on se rapproche du processeur, les caches multiniveaux sont inclusifs, le contenu d'un cache plus petit est inclus dans le plus grand.
Nous verrons plus de détails plus tard, mais en attendant, le cache et les mémoires principales sont organisés en blocs de taille
fixe. La référence d'un bloc de données dans le cache est appelée ligne de cache. Pour plusieurs raisons, lorsqu'une donnée
recherchée est absente du cache, une ligne complète (contenant le bloc de données) est chargée de la mémoire principale vers le
cache. C'est le principe de localité ; le programme fait référence à une partie relativement petite de son espace d'adressage
pendant un certain intervalle de temps. En d'autres termes, dans le meilleur des cas, les processeurs accéderont plusieurs fois à
une petite partie des données. De plus, la récupération d'un bloc de données prend moins de temps que la récupération d'un mot à
la fois. Enfin, l' entrée de cache représente ce groupe de mots, et par conséquent, les récupérations en mémoire seront en principe
moins nombreusesÿ; les données nécessaires sont déjà dans le cache. Lorsque le mot est dans le cache, nous avons un accès au
cache. Le taux de réussite du cache h=(k – 1)/ k est le rapport entre le nombre de références (fois qu'une donnée dans un bloc est
accédée) satisfaite par le cache (k – 1, la première référence est dans la mémoire principale) et le nombre total de références k. Le
processeur consulte d'abord le cache et si le mot n'y est pas, on a un manque de cache ; le processeur doit accéder à la mémoire
principale pour récupérer un bloc de données à placer dans le cache. Le taux d'absence, d'échec ou de défaut du cache est donc
de 1 h. Le temps d'accès moyen est c+(1-h)m, avec un temps d'accès au cache c et un temps d'accès à la mémoire principale m.
Lorsque h tend vers 1, presque toutes les références sont dans le cache et le temps d'accès se rapproche de c. A l'inverse, lorsque
le temps d'accès est proche de c+m, il sera encore plus long que sans le cache. Les performances dépendent de la taille et du
nombre de lignes du cache, ainsi que de son organisation, ou de la manière dont il conserve la trace des mots mémoire, et du type
de données, d'instructions ou de données stockées. Par exemple, dans un cache unique ou unifié, on ne fait pas la distinction entre
les instructions et les données, mais on sait que les instructions sont chargées à partir d'emplacements consécutifs ( principe du
programme séquentiel ) et que les données sont toujours référencées à la même position (et, dans De plus, elle peut être modifiée ;
la mémoire principale sera donc mise à jour en conséquence). Pour ces raisons, l'organisation du cache n'est pas unique et doit être
ajustée ou optimisée en fonction du type de données référencées.
Le contrôleur DMA d'accès direct à la mémoire assiste le processeur dans les tâches liées au transfert de données entre les
périphériques et la mémoire. En effet, le DMA remplace le processeur lorsque des données provenant d'un périphérique doivent
être écrites en mémoire (voir Figure 61). Le contrôleur contrôle le périphérique d'entrée/sortie et gère l'accès au bus. Il évite
d'attendre la disponibilité, permettant ainsi un transfert de données plus rapide entre la mémoire et l'appareil sans passer par le
processeur. Le processeur détermine l' adresse de départ/ destination (la position d'adresse périphérique et mémoire des données
à transférer) ainsi que le nombre d'octets à transférer ; autorise l' interruption
(INTERRUPT ENABLE) pour donner accès au bus au DMA quand il en a besoin et attend (volant le cycle) la fin du transfert de
données. Le DMA récupère les données de l'appareil (serial bit stream), écrit les données directement dans la mémoire et à la fin
du processus de lecture/écriture, il donne le contrôle au processeur par une interruption.
46
Figure 61 : Le contrôleur DMA d'accès direct à la mémoire. Le DMA agit comme un maître qui utilise le bus pour utiliser directement la mémoire
pour stocker ou échanger des données avec un périphérique, libérant le processeur de cette tâche d'accès mémoire. Le DMA est configuré pour
utiliser le registre pour indiquer les adresses de destination et de source des données
(périphérique/mémoire) ainsi que la taille des données transférées. Le DMA utilise l'interruption pour avertir le processeur lorsqu'il doit devenir le
maître du bus.
Les mémoires secondaires sont magnétiques, optiques (DVD, CD, Blu-ray), disquettes et bandes magnétiques, moins chères, amovibles
et avec une grande capacité de stockage, mais beaucoup plus lentes en écriture/lecture. Les bandes magnétiques sont des mémoires à accès
séquentiel (par opposition aux mémoires à accès aléatoire), vous devez donc parcourir toute la bande pour trouver les données que vous
recherchez. Ils sont toujours utilisés comme système de sauvegarde, et leur organisation d'accès aux données, la distribution et la taille des
adresses, les blocs de données et les codes de validation sont toujours utilisés lors du partitionnement des cartes SD et des systèmes de fichiers.
Figure 62 : Mémoire secondaire : disque magnétique. Ils peuvent atteindre des vitesses de transfert de 20 à 40 Mo. Ils se composent de
plusieurs cylindres de données (winchester) et d'un bras/tête de lecture/écriture. Chaque cylindre est divisé en plusieurs pistes concentriques
séparées par des espaces interpistes. Un cylindre peut contenir 5 à 10k pistes par cm (1 à 2 microns de large) et tourne à une vitesse de 3,6 à
15k RPM. Chaque piste est divisée en secteurs de données séparés par des espaces.
Ainsi, une opération d'accès aux données est composée de la recherche dans la piste et du positionnement du secteur (le bras de lecture a une
latence de positionnement de la recherche dans la piste de 1 à 10 ms et une rotation, positionnement du secteur, latence de 3 à 6 ms). Chaque
secteur est composé de trois régions : le préambule (pour la synchronisation), le bloc de données (512 octets) et le code de correction d'erreur
ECC, qui contient soit un bit de parité, soit un code de correction de Hamming, soit un Reed Solomon.
Le temps de lecture est de 13 à 26 us.
Les disques magnétiques sont des mémoires non volatiles pour les processeurs et les serveurs. Elles sont préférées aux mémoires Flash
pour leur prix et pour leur grande capacité de stockage. Elles sont moins robustes que les mémoires Flash en raison de leur taille (disques de
diamètres compris entre 1 et 3,5 pouces) et parce qu'elles contiennent des pièces mobiles (avec une vitesse de rotation de 5,4k à 15k RPM),
mais elles supportent un nombre de lectures/écritures plus élevé (voir Figure 62). En raison de leur prix, de leur vitesse et de leur capacité de
stockage, ils sont actuellement préférés aux bandes magnétiques et aux disques optiques pour stocker des données/programmes. Les disques
magnétiques sont composés de plusieurs cylindres rotatifs, avec des données stockées dans des pistes concentriques, et des bras qui seront
positionnés sur une piste et un secteur. L'opération d'accès aux données nécessitait la recherche dans la piste et le positionnement du secteur.
Chaque secteur est composé de trois régions : le préambule (pour la synchronisation), le bloc de données (512 octets) et le code de correction
d'erreur ECC, qui contient soit un bit de parité, soit un code de correction de Hamming, soit un Reed Solomon.
47
Il existe plusieurs types de disques et de contrôleurs de disques magnétiques (pilotes). Les plus connus sont IDE (EIDE et ATA plus tard,
pour les ordinateurs de type IBM PC), SCSI (pour Unix-Sun et HP) et RAID. L' IDE d'électronique de lecteur intégré
Le disque dispose d'un contrôleur prenant en charge jusqu'à 16 têtes (4 bits), 63 secteurs (6 bits) et 1024 cylindres (10 bits), pour un volume
total de données de 528Mo (~504Mo effectifs). Cette organisation est similaire à celle utilisée dans les disques compacts CD. Le disque IDE
EIDE étendu utilise un LBA d'adressage de bloc logique 28 bits pour indiquer le secteur, donc 228-1 secteurs *29 octets/secteur = 137 Go (~128
Go effectifs). Les disques AT Attachment ATA (avec un débit de 33Mo/s) et ATA Packet Interface ATAPI (qui peut donner un débit de données
de 66 à 100 Mo/s selon la version) utilisent un LBA 48 bits, un bus de données de 8 ou 16 bits et ont une capacité mémoire de 248-1 secteurs *
29 octets/secteur = 128Po (Po = 1015). Le disque Small Computer System Interface SCSI (Unix, HP) permet une connexion chaînée de disques
par un bus 8 ou 16 bits avec une fréquence d'horloge de 5 à 160 MHz et un débit de 5 à 320 Mo/s. L'organisation de Redundant Array de
disques RAID indépendants consiste en la répartition (striping) des données sur un ensemble de disques, permettant ainsi des traitements
parallèles (accès simultanés). Il présente plusieurs types d'organisation ou modes de fonctionnement (niveaux). Il y a donc un ordonnancement
circulaire des blocs de données sur tous les disques, et la redondance des disques et des données (unités primaires et redondantes) empêchant
données d'échec perdues.
Figure 63 : Mémoire secondaire : CD Compact Disk. (a) Disque compact CD-R enregistrable. et DVD de
disque numérique polyvalent. Le CD, en polycarbonate fondu dans le moule, est recouvert d'une fine pellicule
d'aluminium réfléchissante, puis d'une laque de protection. En double couche, une surface réfléchissante est
placée en profondeur et une surface semi-réfléchissante est placée à une profondeur intermédiaire. Le disque
double face est formé de deux disques simple face de 0,6 mm d'épaisseur collés l'un à l'autre. (b) surface du
CD. Le Compact Disc CD, spécification technique IS10149, a un diamètre de 120 mm et une épaisseur de 1,2
mm, avec un trou de 15 mm au milieu. Le processus d'écriture laser infrarouge creuse des trous de 0,8 micron,
des micropits, dans le disque maître en verre revêtu, formant une seule spirale continue du trou à environ 32 mm
du bord. La transition entre les zones planes non brûlées, les méplats et les creux (un 1 logique) est identifiée
lors de la lecture à l'aide d'une diode laser infrarouge émettant un rayon d'une longueur d'onde de 0,78 microns
du côté du polycarbonate. La lumière réfléchie par les micropits est plus faible et déphasée d'une demi-longueur
d'onde avec la surface. Une lecture complète du disque correspond à 22 188 tours, soit environ 600 tours par
millimètre. La rotation du CD garde une vitesse linéaire constante de 120 cm/s, soit environ 530 tours/minute au
centre et 200 tours/minute en périphérie.
Les disques optiques sont des mémoires secondaires non volatiles qui utilisent la lumière pour lire des données. Le Compact Disc CD,
spécification technique IS10149, a un diamètre de 120 mm et une épaisseur de 1,2 mm, avec un trou de 15 mm au milieu (voir Figure 63). Le
processus d'écriture utilise un laser infrarouge à haute énergie qui creuse des trous ou micropits de 0,8 micron dans le disque maître en verre
revêtu, formant une seule spirale continue du trou à environ 32 mm du bord. Les zones planes non brûlées, présentes entre les creux, sont
appelées terres. Le disque maître est utilisé pour créer un moule. Le CD, en polycarbonate fondu dans le moule, est recouvert d'une fine pellicule
d'aluminium réfléchissante, puis d'une laque de protection. A la lecture, une diode laser infrarouge émet un rayon d'une longueur d'onde de 0,78
microns du côté du polycarbonate. La lumière réfléchie par les micropits est plus faible et déphasée d'une demi-longueur d'onde avec la surface.
Un 1 logique correspond à la transition microfosse/terre ou terre/microfosse et un 0 logique lorsqu'il n'y a pas de transition.
Le CD-ROM Compact Disc Read Only Memory est utilisé pour le stockage des données (voir Figure 64). Il garde les mêmes dimensions
que le CD audio. Chaque octet est codé dans un symbole de 14 bits , y compris le codage de Hamming et les bits de synchronisation. Une donnée
48
trame se compose de 42 symboles de 14 bits chacun. Ce qui fait un total de 588 bits. Comme il n'y a que 24 octets de données dans
une trame, soit 192 bits, 396 bits sont utilisés pour la correction d'erreurs et les commandes. Un secteur en mode 1 (98 trames) est
constitué d'un préambule (16 octets, dont 12 pour le positionnement, 3 pour le numéro de secteur et 1 octet pour le mode), de
données et de codes correcteurs d'erreurs (288 octets, Cross Interleaved Reed-Solomon code CIRC). Le secteur mode 2 dispose
de 2336 octets pour stocker des données lorsqu'il n'a pas besoin de correction d'erreur (c'est le cas des applications audio par
exemple). Il y a donc trois protections : correction d'erreur au niveau d'un symbole, d'une trame et d'un secteur (ce qui correspond à
7203 octets de protection pour 2048 octets de données, soit un rendement de 28%). La vitesse de lecture est de 75 secteurs par
seconde pour un CD-ROM x1 ; la vitesse de transmission des données est donc de 153 600 octets par seconde en mode 1 et de
175 200 octets par seconde en mode 2. Cette vitesse est bien inférieure à celle d'un lecteur de disque magnétique : un SCSI-2
tourne à 10 Mo/s est supérieur au 5 Mo d'un CD-ROMx32. Les fichiers sont organisés selon la norme internationale IS 9660, appelée
High Sierra. Cette norme comporte trois niveaux. Pour le niveau 1, le nom du fichier est codé sur 8 caractères suivis d'une extension
de 3 caractères (MS-DOS). Le niveau 2 permet des noms jusqu'à 32 caractères. Le niveau 3 autorise les fichiers non contigus.
L'extension Rock Ridge autorise les noms très longs, l'ID utilisateur (UID) ou l'ID de groupe (GID) et les liens symboliques.
Figure 64 : Mémoire secondaire : mécanisme des disques optiques et organisation des données. (a) Disque optique générique :
Le disque en polycarbonate est recouvert d'un mince film d'aluminium réfléchissant et d'une laque protectrice. Une diode laser infrarouge
émet un rayon de longueur d'onde de 0,78 microns (CD ROM) du côté du polycarbonate et un photodétecteur recueille la lumière réfléchie
par les microcuvettes (plus faible et déphasée d'une demi-longueur d'onde). (b) Organisation des données du CD. Chaque octet est
codé dans un symbole de 14 bits , y compris le codage de Hamming et les bits de synchronisation. Une trame de données (588 bits) se
compose de 42 symboles : 24 octets de données et 50 octets pour la correction d'erreurs et les commandes. Un secteur en mode 1 (98
trames) est constitué d'un préambule (16 octets, dont 12 pour le positionnement, 3 pour le numéro de secteur et 1 octet pour le mode), de
données et de codes correcteurs d'erreurs (288 octets, Cross Interleaved Reed-Solomon code CIRC). Le secteur mode 2 dispose de
2336 octets pour stocker des données lorsqu'il n'a pas besoin de correction d'erreur (c'est le cas des applications audio par exemple). Il
existe trois protections : correction d'erreur au niveau d'un symbole, d'une trame et d'un secteur (7203 octets de protection pour 2048
octets de données, soit un rendement de 28%). La vitesse de lecture est de 75 secteurs par seconde pour un CD-ROM x1 et une vitesse
de transmission des données de 153 600 octets par seconde en mode 1 et 175 200 octets par seconde en mode 2. Cette vitesse est bien
inférieure à celle d'un lecteur de disque magnétique (SCSI -2 à 10 Mo/s).
Le CD-R enregistrable sur disque compact utilise une rainure de 0,6 mm de large pour guider le laser lors de la gravure. La
rainure présente une variation sinusoïdale de 0,3 mm d'amplitude à une fréquence de 22,05 kHz afin de fournir une rétroaction
permettant un contrôle et un réglage précis de la vitesse de rotation. Il utilise une couche de matière colorée (cyanine, verte, ou
phtalocyanine, jaune orangé). Le laser, à forte puissance (de 8 à 16 mW) chauffe et provoque la rupture de certaines liaisons
chimiques à l'intérieur du colorant, permettant ainsi un point noir. Lors de la lecture (à 0,5 mW), le photodétecteur capte les
différences entre les zones sombres et les zones claires. La table du contenu du disque (VTOC ou Volume Table of Contents) est
écrite à chaque fois pour le CD multisession.
D'autres types de disques optiques utilisent des variantes de matériaux et de faisceaux laser. Le CD-RW Compact Disc-
ReWritable utilise un alliage d'argent, d'indium, d'antimoine et de tellium, à deux états chimiques (cristallin et amorphe), avec une
réflectivité spécifique. À haute puissance, le laser fait fondre l'alliage, le transformant en un état amorphe faiblement réfléchissant.
A moyenne puissance, l'alliage retrouve son état cristallin initial. Le DVD Digital Versatile Disk a des creux plus petits (0,4 microns),
une spirale plus serrée (0,74 microns entre les pistes) et le laser est rouge (0,65 microns), simple face simple couche (4,7 Go ou 1,4
Mo/s) ou double -double couche (17 Go). En double couche, une surface réfléchissante est placée en profondeur et une surface
semi-réfléchissante est placée à une profondeur intermédiaire. Le disque double face est formé de deux disques simple face de 0,6
mm d'épaisseur collés l'un à l'autre. Le Blu-Ray utilise un laser bleu. Il est de longueur d'onde plus courte, et contient donc plus de
données (25 Go pour le simple face et 50 Go pour le double face) avec une vitesse de transmission des données de 4,5 Mo/s.
49
2.9 Les entrées/sorties

• Il existe plusieurs types d'échange de données et d'interfaces entre le processeur et les périphériques.
Dans un premier temps, nous verrons quelques caractéristiques et principes.
• Le standard le plus connu pour désigner les caractères alphanumériques lors de la transmission de données est
le code ASCII (American Standard Code for Information Interchange). Un caractère ASCII utilise 8 bits. 7 bits
sont utilisés pour les 128 (27=128) caractères différents. Pour les numéros, le '0' est codé 30h (ou 48 en
décimale) et le '9' est 39h. le caractère 'A' '1h et le 'a'61h. Puis, les caractères de contrôle correspondant aux
touches du clavier tels que ESC (1Bh) ou BS (Backspace 08h), ou pour le traitement du texte, comme STX
(start of text 02h) ou ETX (end of text 03h), ou la transmission de données, telles que EOT (End of Transmission
04h), NAK (Pas d'acquittement 15h) ou SYN (Synchronous inactif 16h). Les codes de transmission sont utilisés,
par exemple, pour contrôler le début (XON) ou la fin (XOFF) d'un message envoyé par le récepteur au
transmetteur.
• L'échange de données peut être synchrone ou asynchrone. Lors d'une transmission synchrone, on connait
le temps de début et de fin de transmission d'un octet. Ce temps est déterminé par une horloge unique entre le
transmetteur et le récepteur. Lors d'une transmission asynchrone, on ne connaît pas exactement le temps
d'échange. Dans ce cas, il faut encore des lignes de contrôle supplémentaires pour synchroniser l'échange.
Dans un protocole synchrone, une trame est envoyée pour synchroniser l'échange. Le cadre peut contenir un entête
(header) pour identifier le cadre, puis il est suivi par un bloc de données, et terminé par un caractère de
fermeture ou de contrôle d'erreur.
• Entrée sortie parallèle. Un bus parallèle peut transmettre plus d'un bit d'information simultanément.
Il peut être accompagné par un bus d'adresse (pour l'accès à une position de mémoire), la logique pour
décodeur l'adresse et des circuits pour stocker les données sortant du bus et pour habiliter l'entrée de données
au bus . L'adresse détermine le port I/O, par exemple le port 00 et le décodeur détermine s'il s'agit d'un port
d'entrée ou de sortie (selon l'état des registres internes de configuration des ports). Des signaux de lecture ou
d'écriture (I/O read/write) sont activés selon l'état du décodeur d'adresse (pour la sortie ou l'entrée de données).
Le bus de données du microprocesseur est bidirectionnel. Les données entrantes sont transférées dans un
verrou à l'entrée du processeur et les données sortantes sont disponibles sur le bus de données interne, par
une porte tri-state. Il peut exister des signaux pour contrôler l'échange, par exemple pour établir une poignée
de main (on verra plus tard) lors de la transmission de données. Par exemple, lorsque la donnée est disponible
en sortie, le signal data out available est activé pour indiquer que la donnée est disponible. Cependant, ce
signal ne sera désactivé que lorsque le périphérique activera le signal de sortie des données reçues, pour
indiquer que la donnée a été reprise. De même, ce dernier signal sera désactivé lorsque le signal data out
disponible sera également désactivé. Lorsqu'un périphérique souhaite envoyer une donnée au processeur, il
active le signal Input data available, ce qui produit l'entrée d'une interruption. En réponse à cette interruption,
le processeur active le signal de lecture I/ O lu, pour stocker la donnée dans le bus interne et le signal Données d'entrée reçues p
50
au périphérique la réception de la donnée. Autres exemples d'interfaces parallèles : le IEEE-488 ou GPIB

(General Purpose Interface Bus) utilisé pour commander et transférer des données entre le processeur et les
instruments de mesure, et le bus SCSI (Small Computer System Interface), pour l'interconnexion avec les
dispositifs de stockage de données (HD).
• Entrée/sortie sérieÿ: en demandant le nombre de fils, on réduit également le nombre de pilotes nécessaires
pour transmettre les données sur de longues distances. Cependant, une série de circuits est nécessaire pour
faire un transfert série. L'UART (Universal Asynchronous Receiver-Transmitter) est le dispositif à charge
de la conversion parallèle-série, série-parallèle, du transfert des bits en série. Il faut aussi déterminer le type
de signal à utiliser pour transférer les données et comment récupérer les données transmises. La conversion
parallèle série est faite avec un registre de décalage (shift register). Les bits sortent 1 bit à la fois ; le
premier bit à transférer est le moins significatif (LSB). À la réception, le bit reçu est aussi envoyé vers un
registre de décalage, les N données sortent ainsi en parallèle après la réception de N bits. Les 8 bits de
données sont envoyés avec un bit avant pour indiquer le début de transmission (Start bit ou bit à 0) et un
autre bit pour marquer la fin de transmission (Stop bit ou bit à 1). La vitesse de transmission de données est
indiquée en nombre de bits transmis par seconde ou débit en bauds. Il existe différentes vitesses normalisées : 9600, 4800, 24
Par exemple, une transmission à 1200 bauds implique l'envoi de 120 x 10 bits (dont 8 bits de données) par
seconde. La transmission à 110 bauds utilise 11 bits, dont 2 bits de stop. Lorsqu'on utilise la détection d'erreur
de transmission, le huitième bit est le bit de parité. Lors d'une parité paire, ce bit est à '1' ou à '0' pour que,
dans l'ensemble de bits envoyé, on trouve un nombre paire de bits à '1'. Lorsqu'une erreur de parité est
détectée, le registre d'état de l'UART est activé pour indiquer la présence d'une erreur, et on peut donc
demander la retransmission de la donnée. Le registre d'état peut indiquer d'autres messages, par exemple,
overrun ou sur écriture (la donnée précédente n'est pas arrivée à la sortie), framing error (le bit de stop n'a
pas été trouvé), buffer empty (le tampon est disponible pour une nouvelle transmission), et les données
disponibles indiquent la réception d'une nouvelle donnée. Le processeur peut consulter directement ce registre
pour déterminer l'arrivée d'une nouvelle donnée, ou utiliser une routine d'interruption spécialement prévue
pour la communication UART. La transmission UART est asynchrone parce que le début d'une transmission
n'est pas connu et, en plus, bien que la vitesse de transmission (baud rate) doive être la même aux deux extrêmes,
et donc, que l'intervalle de temps entre chaque bit transmis est connu (synchrone de bit à bit), le signal
d'horloge n'est pas unique. Le RS-232 utilise deux types de connecteurs, le DB-25 et le DB-9. Le DB-9, plus
populaire, est alimenté par 12 V parce qu'il a généré un bit '1' au moins à 3 V et un bit '0' à -3 V au grand
maximum. Il dispose d'une ligne de transmission et d'une autre de réception en plus des lignes de contrôle
qui ne sont pas toujours utilisées.
51
52
3 La couche physique : Les Circuits logiques

Cette section présente les notions de circuits numériques de base utilisés dans l'architecture d'un microprocesseur.
3.1 Les portes logiques de base

• Les portes logiques utilisées pour les opérations booléennes supportent le transistor (bipolaire ou CMOS Complementary MOS
transistor) comme un switch. Les valeurs logiques 0 et 1 correspondent aux valeurs de sortie de la porte : ground (0 volt ou la
terre) et Vdd (la tension d'alimentation). Les opérateurs booléens de base utilisent la porte NOT (NON) la porte NAND (NON-
ET), et la porte NOR (NON-OU).
• Convention logique : notez que, même pour les valeurs logiques 1 et 0, il faut établir une convention lorsqu'il s'agit de circuits
électroniques et de tensions électriques (0 volt ou ground et 5 volts ou Vcc) représentés par la table ( un). On trouve ainsi la
logique positive (table b) ou ground qui représente un '0'
logique et VCC un '1' logique, et la logique négative ou ground qui représente l'opposé, donc un '1' logique, et Vcc un '0'
logique. Pour simplifier, nous utiliserons la convention logique positive.
• L'inverseur ou porte NOT (NON)ÿ: son symbole et sa table de vérité sont représentés par la figure ci-dessous.
Cette porte peut être implémentée par un transistor bipolaire car, lorsqu'à son entrée Vin, on applique une tension Vcc, le
transistor conduit et sur l'instantané donc, à sa sortie, la valeur 0 volt ou '0' logique. Autrement, il ne conduit pas et, à sa sortie,
sur la valeur Vcc ou '1' logique.
• La porte NAND (NON-ET), représentée dans la figure par son symbole et sa table de vérité, aurait besoin de deux transistors
bipolaires en série, et donc, pour avoir un 1 logique en sortie, il faudra que les deux transistors fonctionnent , sinon on obtiendra
un 0 logique en sortie.
53
• La porte NOR (NON-OU). La troisième porte logique de base est la porte NOR (NON-OU), représentée dans
la figure par son symbole et sa table de vérité. Les deux transistors sont en parallèle, il suffit donc qu'un des
transistors conduit pour avoir un '0' logique en sortie.
• On peut construire tous les opérateurs logiques avec ces trois portes y compris les deux autres portes de base
AND (ET) et OR (OU)ÿ; NAND = NON + ET et NOR = OU + NON. La figure montre les symboles de
l'ensemble des 5 opérateurs logiques de base et leurs tables de vérité.
• Les portes peuvent être plus au moins rapides (et donc consomment moins ou plus) selon la technologie de
fabrication. Les plus économiques (moins de consommation) sont construits en technologie MOS (PMOS,
NMOS, CMOS, HMOS, XMOS) et les plus rapides en ECL ou TTL (plus de puissance, vitesse et consommation).
54
• Les portes NAND et NOR sont dites des portes complètes. Avec une de ses portes, on peut construire toutes
les autres fonctions logiques. La figure (a) montre une porte NOT construite avec une porte NAND ou une
porte NOR. La figure (b) montre la porte logique AND construite avec des portes NAND ou avec des portes
NOR. La figure (c) montre la porte logique OR construite avec des portes NAND ou avec des portes NOR.
3.2 La loi de Morgan

• La loi de Morgan nous permet d'obtenir des représentations alternatives, donc le même résultat avec des
opérateurs différents. La figure (a) montre l'équivalence entre une porte NAND et une porte OR avec les
entrées inversées. La figure (b) montre la porte NOR équivalant à une porte AND avec ses entrées inversées.
La figure (c) montre la porte AND équivalent à une porte NOR avec ses entrées inversées. La figure (d) montre
la porte OR équivalente à une porte NAND avec ses entrées inversées.
• La loi de Morgan nous permet aussi de faire la conversion entre les formes pures NAND et NOR.
Par exempleÿ: la fonction logique XOR (OR exclusive), représentée dans la figure (b) par des portes AND et
OR (notez que les entrées A-bar et B-bar sont donc inversées), peut être transformée en porte équivalente
NAND et NOR (d) grâce à la loi de Morgan. Il suffit (c) de rajouter des doubles inversions (donc sans altérer
le résultat) pour obtenir les portes NAND suivies par une porte OR avec ses entrées inversées, donc une porte
NAND aussi selon la loi de Morgan.
55
• Cela dit, l'exemple nous montre la loi d'équivalence entre circuitsÿ: deux fonctions logiques sont équivalentes si,
et seulement si, les valeurs de leurs sorties sont les mêmes pour toutes les configurations identiques de leurs
variables d'entrée. La figure nous montre deux fonctions logiques (a) et (b) équivalentes,
montrées par leurs tables de vérité identiques. Cependant, la fonction logique (a) utilise trois portes et la fonction
logique (b) n'utilise que deux portes. L'utilité est que l'on peut obtenir une fonction équivalente qui utilise un
nombre réduit d'opérateurs (moins d'opérations pour un même résultat). Cette réduction est faite grâce à la loi
distributive, qu'on verra plus tard (AB + AC = À(B+C)).
3.3 L'algèbre de Boole

• La Table de vérité indique la valeur d'une fonction booléenne pour chaque configuration binaire des n
variables d'entrée (2 n configurations ou états possibles). Cette table est utilisée pour obtenir le circuit logique
équivalent à cette fonction en utilisant des portes logiques. On peut ainsi construire, par exemple, la fonction
majoritaire M = f(A,B,C) où M vaut 0 si la majorité des variables valent 0. Cette fonction est représentée par sa
forme compactée ou simplifiée, en utilisant la somme des termes produits M = ABC + ABC + ABC + ABC ,
ce qui nous donne deux rangées d'opérateurs, la première pour les produits (avec les portes AND) et la seconde
pour les sommes (portes OR).
56
• L'algèbre de Booleÿ: les opérations booléennes sont régies par les lois de l'algèbre de Boole. La table montre
les principales lois représentatives de cette algèbre, notamment la dualité des formes représentatives
(somme de produits et produit des sommes en utilisant les portes NOR ou NAND).
3.4 Les circuits logiques combinatoires

• Les circuits intégrésÿ: les portes logiques sont réalisées sur silicium sous forme de circuits intégrés encapsulés
dans des boitiers rectangulaires en plastique ou céramique. Les boitiers les plus communs sont du type DIL
ou DIP (Dual Inline Package) avec deux rangées parallèles de connexions. Les broches ou pattes sont les
connexions électriques externes ou portes d'entrée/sortie du boitier. La figure montre un chip contenant 4
portes logiques NAND en technologie SSI (Small Scale Integration).
57
• Densité d'intégrationÿ: la densité d'intégration détermine le nombre de portes par circuit intégré ou par
mm2 . On trouve ainsi plusieurs familles de produits :
o SSI (Small Scale Integration) : à faible intégration (1 à 10 portes). Circuits TTL, par exemple la
famille 7400 CMOS 74C00.
o MSI (Medium Scale Intégration) : à moyenne intégration (10 à 100 portes).
o LSI (Large Scale Integration) : à haute intégration (100 à 100k portes).
o VLSI (Very Large Scale Integration) : à très haute intégration (plus de 100k portes).
• Les circuits en technologie MSI et plus peuvent contenir plusieurs portes et donc des circuits plus complexes comme
le multiplexeur, le décodeur, le comparateur, les réseaux logiques programmables, etc.
• Les circuits logiques combinatoires se caractérisent par une fonction où les sorties dépendent uniquement des
variables d'entrée et qui peuvent donc être présentées par une table de vérité entrée/sortie. Les plus connus sont
le multiplexeur, le décodeur, le comparateur et les réseaux logiques programmables.
• Le multiplexeur permet la sélection d'une des entrées parmi les 2 n (1 parmi 2 n ) existantes où n est le nombre de
lignes de sélection. Il s'agit donc d'une fonction logique de 2 n entrées Di[2n ] (voir son symbole dans la figure),
n lignes de sélection Ss[n] et une sortie F. Le multiplexeur est couramment utilisé pour faire la conversion
parallèle /serie. Son inverse est le démultiplexeur. Comme le montre la figure, le circuit est composé de portes
NAND et OR, donc, par une somme de produits.
• Le multiplexeur sert à construire des fonctions logiques avec plusieurs variables d'entrée. Par exemple, avec le
multiplexeur à 8 entrées Di et 3 lignes de sélection (A, B, C), montré dans la figure, on peut construire la fonction
majoritaire M vue précédemment. Il ici d'utiliser les lignes de sélection comme lignes de données et les lignes des
données D avec des valeurs prédéfinies pour suffire combinaison des valeurs A, B, C. La figure montre aussi la
table de vérité et son circuit logique en somme de produits.
58
• Le décodeur utilise n lignes d'entrée S[n] pour sélectionner une des 2 n lignes de sortie D [2 n ] (n vers 2 n ).
Il peut servir pour commander le multiplexeur et donc choisir quelle entrée se trouvera en sortie. Dans la
figure, on trouve un décodeur 3 à 8 (n=3 vers 2 n= 8). La sortie D0 sera à '1' lorsque l'entrée est ABC=000
et la sortie D1 sera '1' avec une entrée ABC=001. Il permet la sélection du boitier mémoire ou le décodage
DCB (Décimal Codé en Binaire), donc 4 vers 10.
• Le comparateur effectue la comparaison de deux mots, de n bits chacun, présente sur ses entrées ; la sortie
présente le résultat de l'opération. Dans la figure, le comparateur dispose de 2n entrées A et B. Les entrées
sont comparées bit à bit et le résultat sera '1' ou '0' selon l'état des entrées. Dans un autre exemple, une
entrée de sélection S, de 2 bits, permet de sélectionner l'opération à effectuer : A=B, AÿB, A>B, A<B.
59
• Les réseaux logiques programmables PLA (Programmable Logic Array). Avec un PLA, on peut réaliser
tout un ensemble d'opérations et de fonctions logiques. Son circuit est composé de trois étages, entrée
directe et inversée, portes AND (terme produit) et portes OR (terme somme) pour effectuer la somme des
produits. À l'état non programmé, toutes les entrées sont liées à toutes les portes ET. Les fusibles sont les
éléments de programmation permettant la connexion d'une entrée directe ou inversée aux portes ET ainsi
que la connexion des portes ET aux entrées des portes OR. La PLA de la figure présente 12 entrées (A,
B .. L), donc 24 fusibles (12x2) pour chaque entrée de la porte AND, 50 portes AND et 6 portes OR, on peut
donc réaliser 6 fonctions différentes.
3.5 Les circuits arithmétiques

• Le décaleur (Shifter) ou circuit de décalage. Il effectue le déplacement d'une position, d'un bit, à droite ou à
gauche, de tous les n bits d'entrée. Le bit le plus à gauche (droite), lors d'un décalage à gauche (droite)
sera, soit perdu (simple décalage pour des opérations de multiplication/division par multiples de 2) ou
stocké dans un registre temporaire (pour récupérer un bit et voir son état), soit remplacé à la droite (gauche)
de tous les bits déplacés (rotation). Il dispose de n entrées, n sorties et d'une entrée de commande C (pour
spécifique un décalage gauche/droite). La figure montre un décaleur de 8 bits avec une ligne de contrôle C
(décalage à gauche '0' et décalage à droite '1'). Dans l'exemple, lors d'un décalage à droite, le dernier bit
est perdu et on retrouve un zéro venant de la gauche (le bit le plus à gauche) ; notez que la valeur 0xCC
(204d) devient 0x66 (102d), donc une division par 2. Lors d'un décalage à gauche, le bit le plus à gauche
est perdu et on rajoute un zéro à l'extrémité droite ; notez que la valeur 0x0C (12d) devient 0x18 (24d), donc
une multiplication par 2.
• Le demi-additionneur ou HA (Half Adder) effectue l'addition de 2 valeurs (2 entrées A et B) et donne le

rapport (Carry) lorsqu'il y a eu un dépassement dans l'opération. L'addition est effectuée par une opération
60
XOR et le rapport est produit par une opération ET des deux entrées A et B. La figure montre un HA de
deux entrées de 1 bit chacune. La sortie de cet exemple est SUM, résultat de l'opération XOR des entrées,
et Carry, résultat de l'opération AND des entrées.
• L'additionneur complet ou FA (Full Adder)ÿ: effectue l'addition S des entrées A, B et du rapport (Carry)
de l'addition précédente Ci :
o S = (A xou B) xou Ci .
o Co = (A et B) ou ((A xou B) et Ci)
• La figure montre un additionneur complet simple, construit à partir de deux demi-additionneurs (le deuxième
pour additionner le Carry-in, rapport de l'addition précédente, au résultat de l'addition A+B). Le Carry de
l'addition actuelle sera un des deux Carry (Co1 ou Co2) résultant des additions HA1 et HA2. Les deux
types d'additionneurs les plus connus sont l'additionneur à propagation ou Ripple Carry (lent à cause de la
propagation du Carry entre les additions successives) et l'additionneur à anticipation de Carry ou Carry
Look Ahead (plus rapide).
• L'unité arithmétique et logique ou ALU (Arithmetic Logical Unit) effectue l'ensemble des opérations
logiques et arithmétiques de base (ET/ AND, OU/ OR, NON/ NOT, comparaison, somme et soustraction de
deux nombres binaires A et B , complément à 1, additionneur 1, complément à 2, inversion de tous les bits,
etc.). La figure montre une ALU basique avec les entrées A, B, INVA (entrée A inversée), ENA et ENB
(activation de l'entrée A ou B), l'entrée de Carry (Carry-in), la sortie du résultat de l'opération (Output)
61
ainsi que du Carry (Carry-out) et l'entrée de sélection d'opérations (F0 et F1). Du fait de disposer de deux bits
pour la sélection d'opérations, cet ALU est capable de faire 4 opérations de base (AB, A+B, !B, Somme) sans
compter l'entrée A inversée. L'entrée de sélection est connectée à un décodeur qui activera une des quatre
opérations possibles. Notez que pour faire l'addition, elle utilise un Full Adder. L'ALU contrôle les bits du
registre d'état, SR ou Status Register (non représentés dans la figure principale, mais dans le symbole de
l'ALU). Le SR peut contenir plusieurs bits pour indiquer l'état de l'opération, par exemple, si la valeur d'entrée
est nulle, positive/négative, paire/impaire, si A est égale/majeure à B, s'il ya eu un Overhead ou propagation
du Carry, etc. Le SR peut par la suite être utilisé pour faire un branchement (Jump) conditionnel lors de
l'analyse d'une valeur ou de la comparaison de deux valeurs A et B.
• Avec des ALU d'un bit, on peut faire des opérations avec des valeurs binaires de plusieurs bits. La figure montre
une cascade d'ALUs avec les entrées A et B associées aux bits des valeurs A0-7 et B0-7. Le résultat de
l'opération se trouvera à la sortie O1-7. Notez l'entrée INC qui peut servir pour additionner 1 (incrémenter la
valeur d'entrée) ainsi que pour propager le Carry de l'addition précédente.
• Ce circuit utilise le Carry Ripple pour propager le Carry (notez la sortie du Carry, Carry-out, d'une ALU
connectée à l'entrée de Carry, Carry-in, de la prochaine). Les signaux de sélection d'opérations F1-0 sont
connectés à tous les ALU.
3.6 Les circuits séquentiels

• L'unité de contrôle, ainsi que le chemin de données, utilise un signal d'horloge pour cadencer les opérations
(donner le temps d'exécution ou le transfert des données). L'horloge donne cette base de temps qui sert aussi
pour mesurer le temps d'exécution d'une instruction (en cycles d'horloge).
62
• L'horloge est émise par un cristal de quartz calibré pour vibrer à une certaine fréquence (fréquence d'horloge en
MHz ou nombre de cycles par unité de temps) et produit un signal carré (avec des valeurs alternées '1' et '0 '). La
période, ou alternance complète (paire '0' et '1'), est mesurée en ns ou nanosecondes. On trouve des signaux
d'horloge multiples, symétriques (avec un facteur de forme 0/1
identique ou 50-50), mais avec un déphasage produit par un circuit de retardement du signal d'horloge (figure (b),
et asymétriques, avec un facteur de forme 0/1 non identique (figure (c)), chaque signal contrôle un groupe
de registres (ou FF) différents. Notez que la fréquence d'horloge est associée à la vitesse de calcul, mais aussi
à la consommation (puissance dynamique consommée).
• Le signal d'horloge sert à contrôler les circuits bistables (latch, bascule, flip-flop), les registres et mémoires
de stockage de données.
• Pour rappel, la bascule RS ou Latch utilisent une entrée S, ou Set, forçant la sortie à '1' et une entrée R, ou Reset,
forçant la sortie à '0'. Il s'agit d'un bistable, avec un état stable (la valeur de sortie est maintenue
lorsque R=S=0) et un état interdit ou instable (R=S=1). La figure montre l'état stable '0' (a) et '1' (b) ainsi que la
table de vérité du circuit (c).
• La bascule RS avec horloge, (ou Clocked SR Latch) use le signal d'horloge Clock pour habiliter/ déshabiliter les
signaux d'entrée R et S. Alors, selon le niveau (haut '1' ou bas '0') du signal d'horloge, il existe un état d'activation,
validation ou d'échantillonnage (enable/ strobe) où la sortie Q
prendre la valeur S ou R.
63
• La bascule D (ou Latch D) ne dispose pas d'entrées R/ S, mais d'une entrée de données D. La sortie Q
conservera la dernière valeur d'entrée D selon le niveau (bas ou '0' dans la figure) du signal d'horloge.
• Cependant, dans le cas contraire (état transparent ou signal d'horloge au niveau haut dans la figure) tout changement
de valeur d'entrée D se retrouvera à la sortie Q. Dans la figure, le signal D remplace le signal S et le signal D_bar
(ou D inversé) remplace le signal R. Lors de l'état transparent, le Latch D laisse passer des valeurs intermédiaires
non souhaitées ou « glitch » d'une durée inférieure à la demi-période du signal d'horloge. La figure montre le
symbole du Latch D selon le niveau du signal d'horloge (haut (a) et bas (b) que commande l'entrée D.
• Le flip-flop D (ou FF) transfère à la sortie la dernière valeur d'entrée lors du montant avant (changement '0' à '1') ou
descendant (changement '1' à '0') du signal d' horloge (dans la figure (d), le transfert se fera lors du descendant
avant). L'avantage par rapport au Latch est qu'il laisse passer uniquement la valeur précédente
ou enregistré, ne peut pas passer le « glitch ». En contrepartie, le flip-flop utilise plus de place qu'un loquet.
Le FF est à la base des registres.
• Pour échantillonner la donnée D lors du front du signal d'horloge, un circuit générateur d'impulsions émettant un signal
d'horloge asymétrique permettant que la bascule D soit transparente uniquement dans un très bref tours
de temps. La figure montre le symbole du FF-D selon le niveau du signal d'horloge (haut (a) et bas (b)) pendant
lequel la sortie Q ne sera pas modifiée.
64
• Le générateur d'impulsions, représenté dans la figure, transforme un signal d'horloge symétrique (dans
la figure, les signaux a, b et c avec un facteur de forme 50/50) en un signal d'horloge asymétrique (signal d
dans la figure avec un facteur de forme 10/90). Le circuit qui produit le retard ÿ est représenté par
l'inverseur.
• Les registres utilisés pour stocker les instructions et les données à l'intérieur du processeur sont des circuits
séquentiels très rapides intégrés par des portes Flip-Flop D. La figure (a) montre deux registres d'un bit
avec des entrées CK, CLR et PR indépendantes. Le signal CLR ou Clear ou Reset met la sortie Q à la
valeur '0'. Le signal PR, Pre-set ou Set, met la sortie à la valeur '1'. La figure (b) montre un registre de 8
bits composé de 8 Flip-Flops D et les signaux CK, CLR et PR identiques pour tous les Flip-Flops. Le
signal d'horloge CK utilise un inverseur pour régénérer le signal, éventuellement dégradé lors d'un long parcours.
• Les mémoires de type RAM (Random Access Memory) sont des mémoires de lecture et d'écriture.
Il existe des mémoires de types statiques et dynamiques ; toutes les deux (volatiles) perdent la valeur
lors d'une coupure de la source d'alimentation. La mémoire RAM statique est plus rapide que la mémoire
dynamique, mais occupe plus de place. La mémoire RAM dynamique est plus compacte (donc, avec plus de
65
capacité de stockage pour une même taille), mais elle utilise un signal de refresh qui sert à régénérer la valeur,
autrement elle sera perdue après un certain temps.
• La figure montre la structure d'une mémoire RAM statique 4x3 (12 bits) avec une cellule pour chaque bit et des
rangées de 3 cellules en fichiers et 4 colonnes. Les cellules sont ici représentées par des FF-D, cependant, elles
sont bien plus compactes et plus lentes qu'un registre. L'entrée A0-1 (donc, 2 bits d'adresse pour sélectionner une
des 4 (22 ) lignes) sert à adresser la ligne des cellules (un mot) à utiliser. Les entrées J0-2
servent pour les données en écriture (donc, 3 bits par mot). Les sorties Q0-2 sont utilisées pour récupérer la
donnée stockée dans la mémoire lors de la lecture (idem, 3 bits par mot). Les signaux de contrôle sont, RD
pour la lecture ('1') ou écriture (RD_bar ou '0'), CS pour activer la mémoire en même temps que le processeur
place l'adresse, et le signal OE pour activer la sortie tri-state (Z, haute impédance ou troisième
état), pour déconnecter physiquement la mémoire du bus de données lors d'une écriture (la sortie de la mémoire
sera en haute impédance). Avec OE='1', la sortie (Dout=Din dans la figure (b)) est connectée. Avec OE='0', la
sortie est déconnectée ou à haute impédance (l'interrupteur est ouvert (c)). Un circuit, tampon
(a), est contrôlé par ce signal de contrôle OE.
• Organisation d'une mémoire. La figure montre deux exemples d'organisation d'une mémoire de 4M bits.
La figure (a) montre une organisation mémoire de 512K mots d'1 octet (512kx8) avec 19 broches d'adresse A0-18
19
pour sélectionner un des 2 mots et 8 broches de données D0-7 (mots de 8 bits) et trois signaux de contrôle CS,
WE (Write Enable ou activation d'écriture) et OE. La deuxième figure (b) montre une organisation mémoire
alternative de 4096K mots (2 11x211) de 1 bit avec 11 pins d'adresse A0-10 pour la sélection d'un fichier ou
colonne, une pin de données D (1 bit), et deux signaux de contrôle RAS (Raw Address Selector) pour la sélection
de l'adresse de fichier et CAS (Column Address Selector) pour la sélection de l'adresse de la colonne.
L'avantage est d'utiliser moins de broches pour les adresses (11 contre 19), mais l'opération prendra plus de
temps parce qu'il faut d'abord sélectionner l'adresse de fichier (ARAS) et puis l'adresse de la colonne (ACAS).
66
• Famille de mémoires vives ou RAM. Les mémoires de type RAM (Random Access Memory) sont disponibles
pour l'écriture et la lecture des données et des instructions. Il existe plusieurs types selon les caractéristiques
telles que la vitesse d'écriture/lecture, la permanence des données (combien de temps elles peuvent rester
en mémoire) ou la capacité de stockage (leur taille) :
o RAM statiques. Ce sont des circuits similaires aux bascules D, donc très rapides, mais chers, avec
une faible capacité d'intégration, parce qu'ils utilisent des cellules mémoire de grande taille (plusieurs
transistors), et volatiles (les données apparaissent lorsque le circuit n 'est plus alimenté). Pour leur
facilité d'utilisation (n'ont pas besoin de signaux de rafraichissement comme les DRAM), elles sont
utilisées dans les registres, cache et buffers. Leur consommation dépend de la fréquence d'accès
aux données, donc, très basse lorsqu'elle n'est pas utilisée ou Idle .
o RAM dynamique. Ce sont des circuits plus simples, avec peu de transistors (1 ou 2 transistors par
cellule), donc, avec une grande capacité d'intégration (ou de stockage), où la donnée est la charge (ou
67
décharge) d'un condensateur. Les données disparaissent rapidement après quelques millisecondes
(à cause du courant de fuite du condensateur) ; elles ont donc besoin d'un circuit de rafraichissement
(récupération de la donnée ou charge du disque). Puisqu'elles ont une plus grande capacité de
stockage, elles sont utilisées comme mémoire principale. À cause du
consommation
rafraichissement,
dynamique
leur est
plus importante que les statiques.
o RAM non volatile ou NVRAM (mémoire FLASH). Dans une mémoire non volatile, la donnée peut
rester stockée même en absence d'alimentation. L'écriture est plus lente qu'une DRAM, il faut
insérer la charge dans la grille du transistor (de façon similaire à une EEPROM), mais elle consomme
moins d'énergie et elle est moins chère. La capacité de stockage est grande (utilisez 1 ou 2 transistors).
L'inconvénient est qu'il faut écrire les données par grands blocs, ce qui prend plus de temps et réduit
les performances. La longévité est aussi un inconvénient, environ 100k d'écritures avant qu'elle ne
soit inutilisable.
o Écritureÿ: il faut appliquer une tension supérieure à la normale sur la grille et le drain du transistor pour
stocker une charge dans la grille flottante (injection d'électrons). Dans ce cas, un canal sera établi
et le transistor sera ON, c.-à-d. qu'il conduira. Un transistor non programmé conduira uniquement
avec une tension de grille.
o Effacementÿ: il faut inverser la tension de la grille pour permettre la circulation des charges dans la
grille flottante.
68
o Organisation des cellules : type NOR ou NAND.
o Type NOR : les cellules sont en parallèle sur la Bit Line, il suffit donc de sélectionner une des cellules
(activation de la Word Line) pour obtenir la valeur (1 bit) en sortie sur la Bit Line. La lecture et
l'écriture sont plus rapides comparées au type NAND, mais ces cellules occupent plus de place.
o Type NAND : les cellules sont en série (opérations en séquence). Elles sont plus compactes, et ont
donc une capacité de stockage supérieure au type NOR. La lecture et l'écriture sont plus lentes, il
faut activer la Word Line de la cellule sélectionnée (juste à la tension de seuil VT) et faire conduire
toutes les autres (avec une tension au-delà de la tension de seuil VT).
• Mémoire morte ou ROM (Read Only Memory ou à lecture seule). Ce sont des mémoires non volatiles
utilisables uniquement en mode lecture (sans port d'entrée de données). Le type varie selon les
caractéristiques de programmation (si les données sont inscrites à la fabrication ou par l'utilisateur) et si elles peuvent être
69
écrites plusieurs fois (réutilisables/effaçables). À l'exception des mémoires EEPROM, elles sont moins chères
qu'une mémoire RAM, plus rapides et avec une plus grande capacité de stockage.
• Masqueÿ: un masque est utilisé pour enregistrer les données lors de la fabrication de la puce. Ces mémoires sont
Dépenses s'il faut commander leur fabrication, mais elles ont la plus grande capacité de stockage et sont les
plus rapides.
• PROM : mémoire morte programmable (ni réinscriptible ni effaçable). On ne peut écrire la donnée qu'une
seule fois. Il s'agit d'un ensemble de fusibles (fusibles à griller).
• EPROM : effaçable par rayonnement ultraviolet (réutilisable, réinscriptible et effaçable). Elle dispose d'une
configuration similaire à la mémoire RAM statique.
• EEPROM/EAEPROM : effaçable électriquement (réutilisable, réinscriptible et effaçable). Elles sont plus

petites et plus lentes qu'une EPROM ou RAM.
• FLASH : voir NVRAM (décrit précédemment).
• Comparaison des types de mémoire. Le tableau reprend l'ensemble des mémoires et leurs
caractéristiques les plus remarquables.
70
4 La couche physique : le microprocesseur

4.1 Le microprocesseur
4.1.1 Paramètres des performances d'un microprocesseur
• Il existe un ensemble de signaux du processeur directement associés aux paramètres de performance (voir
chiffre) :
Adressage Arbitrage de bus

Typique
Données
Microprocesseur
Coprocesseur
Commande d'autobus Puce du processeur
Statut
Interruptions
Divers
Signal d'horloge Ø
Alimentation +5Volts / Masse
• Le bus de données Data : est le bus dans lequel circulent les données. La taille du bus de données, en nombre
de bits, représente la taille d'un mot mémoire. Sa taille est fréquente à la taille des registres internes du chemin
de données. Pour rappel, la taille des registres dans le chemin de données représente aussi la taille d'un mot
donné que le processeur peut traiter dans une seule opération (par exemple, lors d'une addition). Si D=8, il
s'agit d'un mot mémoire de D=8 bits. Le double sens des flèches indique aussi qu'il s'agit d'un bus bidirectionnel
(d'entrée et de sortie).
• Le bus d'adresse Addressingÿ: c'est le bus composé par les lignes d'adresse utilisées pour accéder à un
emplacement spécifique de la mémoire. Le nombre de lignes d'adresse détermine le nombre maximal de
positions de mémoire auquel le processeur peut accéder. Par exemple, si le nombre de lignes d'adresse A=8
UN
on pourra accéder à 2 = 28 = 256 mots en mémoire. Puisque seul le processeur fixe l'adresse, il s'agit d'un
port de sortie (flèche sortant du processeur).
• Le signal d'horloge (Cloc signal)ÿ: le signal d'horloge ainsi que les signaux de contrôle du bus servent au
cadencement des opérations à l'intérieur du processeur. Le signal d'horloge est un signal d'entrée (flèche vers
l'entrée du processeur). Les signaux internes, les opérations et le traitement des instructions sont des opérations
toutes cadencées par le signal d'horloge. Sauf dans des cas particuliers (utilisation de fréquences
multiples générés par une ou plusieurs PLL), le processeur ne peut pas exécuter des opérations à une
fréquence plus élevée que celle imposée par le signal d'horloge système. De ce fait, la fréquence du signal
d'horloge système représente un paramètre de performance du microprocesseur. À une
le processeur
plus grande
travaille
fréquence,
plus
vite, bien que la consommation et sa température seront aussi plus élevées.
• Le contrôle du busÿ: les signaux de contrôle du bus servent à cadencer l'échange d'informations
traversant le bus, et comme il sera expliqué plus loin, ces signaux suivent un protocole bien précis. Ces signaux
contrôlent les échanges entre le processeur et la mémoire (ports I/O ou périphériques) pouvant commander
des opérations telles que l'activation du périphérique, la lecture ou l'écriture d'une mémoire, etc. Les signaux
de contrôle sont multiples et existants dans les deux sens (entrée/sortie), mais ils ne sont pas nécessairement
bidirectionnels (comme on le verra plus loin).
• Arbitre du bus ou contrôle d'arbitrageÿ: l'arbitre s'occupe de la gestion de l'accès au bus, de son utilisation et de la
priorité d'utilisation. Ces signaux de contrôle servent donc à communiquer avec le processeur pour faire, par
exemple, la demande et accorder l'utilisation du bus ou indiquer si le bus est occupé
71
ous pas. Puisqu'un seul maître à la fois peut utiliser le bus, ces signaux servent à réguler le trafic circulant sur le bus, évitant
ainsi une éventuelle utilisation simultanée. Le processeur désirant utiliser le bus ainsi qu'une requête d'accès avant de pouvoir
l'utiliser.
• Gestion des interruptionsÿ: signaux nécessaires pour faire une demande d'interruption de l'exécution du processeur lorsqu'un
périphérique externe (dont un esclave) veut que le processeur s'occupe de lui, par exemple, lors d'une entrée de données par
le port UART ou lors d'une interruption externe du type bouton poussé. Il s'agit d'une entrée transmise au processeur par un ou
plusieurs esclaves pour avertir le processeur qu'il a fini sa tâche, et pouvant même indiquer quel esclave produit l'interruption.
Ainsi, le processeur arrête l'action qu'il est en train d'effectuer et s'occupe de l'esclave. Il peut aussi y avoir un signal de sortie
d'accusé de réception.
• Registre d'état : ce registre permet la visualisation de l'état du processeur à chaque instruction ou pas d'exécution. Le registre
montre, par exemple, si le résultat d'une opération est nul, positif, négatif ou pair, s'il ya eu un rapport ou un dépassement (ou
CARRY) lors d'une opération arithmétique, l'arrivée d'une interruption, une opération non autorisée (TRAP), etc.
• Coprocesseurÿ: certains processeurs dotés d'une unité de calcul externe, un coprocesseur, pour effectuer une tâche plus spécifique,
comme par exemple faire des calculs en virgule flottante. L'échange d'informations
entre le processeur et son coprocesseur utilisent ses broches dédiées à commander les opérations, l'échange de données ou
pour avertir le processeur de la fin d'une opération.
4.1.2 Signaux de communication

• Les broches et les signaux qui traversent permettent l'échange d'informations entre le système (l'environnement du processeur) et
le processeur, ou entre plusieurs entités, par exemple, entre la mémoire et les circuits d'entrée/sortie. On trouve ainsi :
o Les busÿ: pour l'adressage de la mémoire (bus d'adresse), le transfert des données (bus de données)
et les signaux de contrôle du bus.
o L'horloge et les signaux de temporisationÿ: ce sont des signaux utilisés pour commander l'enregistrement des
données dans les registres, contrôler les pas d'exécution, ou pour faire avancer les compteurs.
o L'alimentation du processeur (ou le boitier).
o Signaux de commandeÿ: ils permettent la synchronisation des échanges (les interruptions, les commandes du
coprocesseur, l'arbitrage du bus) entre le processeur et la mémoire, les périphériques (I/O), le bus ou le coprocesseur,
la sélection ou l'activation (reset, lecture/écriture), ou la vérification de l'état des opérations du processeur.
4.1.3 Catégories de commandes

On peut ainsi regrouper les signaux selon plusieurs catégories de commandes :
• Les échanges sur le bus (de lecture ou d'écriture) avec la mémoire, les circuits E/S, les périphériques.
• Les interruptionsÿ: entrées de demande de communication ou notification d'un évènement (communication de l'esclave vers le
maître).
• La gestion des accès au busÿ: pour le contrôle et la synchronisation du trafic sur le bus (avec le contrôleur
du bus, l'arbitre, et d'autres maîtres).
72
• La signalisation destinée aux coprocesseursÿ: pour le dialogue avec les coprocesseurs (esclaves).
• La signalisation à propos des états fonctionnelsÿ: signaux spécifiques d'information à propos de l'état
interne du processeur.
• Divers : l'alimentation et les entrées de contrôle (horloge).
4.1.4 Quelques informations à propos du 8051

• Comme exemple, on peut regarder le microprocesseur 8051 d'INTEL. Pour rappel, le 8051 est un processeur de 8
bits, petit et économique (il appartient à la famille des systèmes enfouis ou Embedded Systems), dans un boitier
standard de 40 broches réparties en :
o L'entrée du signal d'horlogeÿ: le cristal pour générer le signal d'horloge (33ÿMHz) est placé sur les
broches XTAL1-2.
o L'alimentation : VCC et GND.
o Le contrôle du bus d'adresse. ALE (Address Latch Enable), pour faire le temps d'adresse
Le multiplexage, qui consiste à activer l'enregistrement de la partie basse de l'adresse (A0-7) dans un
registre (Latch) de 8 bits (notez que les ports P0 et P2 sont utilisés pour la sortie de l'adresse A0- 15
ainsi que l'entrée/sortie des données D0-7) pour ainsi avoir une adresse de 16 bits sur le bus d'adresse
et puis libère le port P0 pour l'entrée/sortie de données. EAn pour sélectionner l'adresse de la mémoire
ROM interne (0) ou externe (1).
o Le contrôle du bus de données. PSENn (Program Store Enable) pour enregistrer l'instruction placée
sur le bus de données (port P0.0-7). RDn/ WRn pour lire ou écrire la donnée placée sur le bus de
données (port P0.0-7).
o Le bus de données : pour le transfert, par tranches de 8 bits, des instructions ou données (port
P0.0-7).
o Le bus d'adresse : un bus de 16 lignes. 8 lignes d'adresses sur le port P0.0-7 et 8 lignes d'adresses sur
le port P2.8-15 sont utilisées pour la sortie de l'adresse sur le bus d'adresse externe.
o Ports d'entrée/sortie (I/O Ports) : 32 lignes (4x8 ou P0-3) d'E/S organisés par groupes de 8 bits chacun.
Lignes bidirectionnelles programmables (AD address/data, entrée d'interruptions externes
INT (P3.2-3), de communication série TxD/ RxD (P3.0-1) et entrées des timers T0-1 (P3.4-5).
73
• Le 8051 dispose de plusieurs types de mémoire :
o Mémoire externe RAM : jusqu'à 64 ko (2 16) de mémoire externe pour stocker les instructions ou
données (adresse de 16 bits). Elle utilise le signal PSENn (Programme Store ENable) actif lorsqu'il
s'agit d'une lecture de mémoire program (récupérer les instructions). Utiliser les signaux RDn/ WRn
pour lire ou écrire les données placées sur le bus de données.
o Mémoire interne RAM : 128o (2

sept
00h-7Fh), pour les bancs des registres RB (8x4o), la mémoire

adressable par bit (16o), le pointeur de pile SP (Stack Pointer) et les SFR (Special Function Registers).
Notez que les registres A et B, dont A est l'accumulateur, sont utilisés par l'unité arithmétique et
logique pour stocker leurs valeurs d'entrée. Notez aussi le PSW qui est le registre d'état de l'ALU.
o Mémoire interne ROM : 4Ko. Utilisable lorsque le signal de contrôle EA (External Access) est au
repos.
o Les ports d'entrée/sortie sont aussi associés à des registres pour, selon la direction, stocker les valeurs.
Certains ports sont utilisés pour stocker les adresses (Port 2) et d'autres les adresses et les données
(Port 0). Certains ports servent aussi pour faire la communication série (Port 3) réservant des broches
pour la transmission Tx et la réception Rx.
• Le 8051 utilise deux bus principauxÿ: celui qui transfère l'adresse et celui des donnéesÿ:
74
o Le bus d'adresse (16 bits) est connecté au compteur de programme ou PC (Program Counter), au
pointeur de données DPTR (Data Pointer), et au pointeur de programme PAR (Program Address
Register).
o Le bus de données connecte les registres de données tels que l'accumulateur ACC ou registre A, le
registre B, l'ALU (Arithmetic Logic Unit), le registre d'état de l'ALU ou PSW, le DPTR pour lui insérer
l'adresse à laquelle on trouvera la donnée en mémoire externe, et le registre d'instruction ou IR
(Instruction Register) que contient l'instruction à décodeur.
4.1.5 Un processeur virtuel MicroJava 701

• On peut voir un autre exemple de processeur, cette fois virtuel, qui n'existe donc pas réellement, mais qui est
émulé (imité ou simulé) par un programme écrit en Java.
• Ce processeur utilise un bus principal pour accéder à la mémoire (Bus Mémoire)ÿ: PROM Flash (où sont fournies
les instructions et les constantes) et MAIN (où sont fournies les instructions et les données).
• Le processeur dispose d'une mémoire cache interneÿ: I pour stocker les instructions et D pour les données qui
sont récupérées par le bus mémoire.
75

1009-05 Systemes Microp - Syllabus 2018 - 180404 - Relu-CV Microprocessor-Based Systems FR (001-076)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

1009-05 Systemes Microp - Syllabus 2018 - 180404 - Relu-CV Microprocessor-Based Systems FR (001-076)

Transféré par

Droits d'auteur :

Formats disponibles

Machine Translated by Google

Faculté Polytechnique de Mons

Faculté Polytechnique de Mons

Résultats d'apprentissage spécifiques

3. La couche microprogrammée. Microarchitecture. Macro-architecture ou architecture de jeu d'instructions (ISA). Exemple de

1. Andrew Tanenbaum, Architecture de l'ordinateur, Dunod, ISBN 2-10-004467-2, http://www.dunod.com

2. Gilmore, Microprocesseurs, McGraw-Hill, ISBN 0-07-113965-6

Notes de cours (syllabus), transparents, ouvrages de référence :

- Andrew Tanenbaum, Architecture de l'ordinateur, Dunod, ISBN 2-10-004467-2, http://www.dunod.com

- Gilmore, Microprocesseurs, McGraw-Hill, ISBN 0-07-113965-6

Méthodes d'enseignement et d'apprentissage

Evaluation et pondération 1ère session

Consultez les diapositives du cours pour voir la dernière version.

Evaluation et pondération 2ème session

Consultez les diapositives du cours pour voir la dernière version.

1.3 PARAMÈTRES DE PERFORMANCES DU PROCESSEUR ...................................... ..................................11

2 STRUCTURE DE BASE DU PROCESSEUR ................................................... .................................................. ......15

2.2 L'UCT DE L'UNITÉ CENTRALE DE TRAITEMENT ................................... ..................................................16

2.3 EXÉCUTION D'UNE INSTRUCTION .................................................................. ...............................................17

2.4 LE CHEMIN DES DONNÉES .................................................. .................................................. ..................18

2.5 LE JEU D' INSTRUCTIONS : MACHINES RISC ET CISC .................................. .......................19

2.5.2 INSTRUCTIONS DE TAILLE FIXE : CODE D'OPÉRATION EXPANSIF .............................. .........21

2.5.3 TAILLE ET NOMBRE D' INSTRUCTIONS ......................................................... ..................................22

2.7 LES FORMATS DE CODAGE .................................................. .................................................. ........30

2.7.2 REPRÉSENTATION EN POINT FIXE .................................................. .......................................33

2.7.3 CODES DE CORRECTION D' ERREUR ................................................ ..................................................35

2.8 LA MÉMOIRE : CONCEPTS DE BASE ......................................................... ..................................................38

2.8.1 LA MÉMOIRE : ENDIANNESS OU BYTE ORDERING......................................................... .......................40

2.8.2 MÉMOIRE : TYPES, CONTENU ET EXEMPLES .................................................. .......................42

3.1 LES PORTES LOGIQUES DE BASE............................................ ..................................................53

4.1.2 SIGNAUX DE COMMUNICATION ....................................................... .......................................72

4.1.4 QUELQUES INFORMATIONS A PROPOS DU 8051................................................ ....................73

4.2 LE BUS .................................................. .................................................. ................................76

4.2.1 LE BUS SYNCHRONE ................................................................ .................................................. ....79

4.3 L'ARBITRAGE DU BUS ............................................. .................................................. ............83

4.4 TECHNIQUES D'INTERFACE ............................................. .................................................. .....86

5.1 LA MICROARCHITECTURE ................................................................ .................................................. ....98

5.2.3 UN JEU D'INSTRUCTIONS ............................................. ...............................................112

5.3.1 RÉDUCTION DU CYCLE DU CHEMIN D'EXÉCUTION ............................................. ..................117

5.3.3.1 LE CACHE DIRECT OU UNE CORRESPONDANCE DIRECTE.............................. .............127

Des instructions Des instructions

Externe Interne Interne

E/S CPU ALU

Microprocesseur (Intel Pentium)

Microcontrôleur (Microchip PIC)

programme principal pour répondre à une interruption).

Mot de données Mot de données

Mot de données Mot de données

Figure 5 : Paramètres du processeur. Il existe plusieurs paramètres de mesure. Généralement, un processeur se

1.1 Langages et machines virtuelles

Niveau 5 Langage orienté vers les

Niveau 4 Langages d'assemblage

Interprète partiel (OS ou SE)

Interprète de microprogramme ou exécution directe

Niveau 0 Logique numérique

Circuits électroniques (Transistors, portes, …)

1.2 La Loi de Moore

1.3 Paramètres de performance du processeur

Le temps d'exécution est inversement proportionnel aux performances du processeur :

(en cycles d'horloge - ticks/période/taux ou juste temps).

le temps de réponse améliore presque toujours le débit.

composants principaux : puissance statique et dynamique.

composants principaux : puissance statique et dynamique.