Cours-ISN-Architectu..

Commentaires

Transcription

Cours-ISN-Architectu..
Informatique & Sciences du Numérique
Machines numériques
Architecture des machines - Matériel
Olivier SEBASTIEN
ESIROI-STIM
oliviers[@]co.univ-reunion.fr
2
Ce cours est sous licence
Par Olivier SEBASTIEN et al, sauf cas particulier
Ce cours est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas
d’Utilisation Commerciale - Pas de Modification 3.0 non transcrit.
3
Table des matières
1 Introduction : vue générale................................................................................................ 6
2 Rappels : le binaire............................................................................................................. 7
2.1 Concept................................................................................................................................................. 7
2.1.1 Origine................................................................................................................................................. 7
2.1.2 Unités de base.................................................................................................................................... 7
2.1.3 Unités usuelles.................................................................................................................................... 7
2.1.4 Unités du système international ...................................................................................................... 8
2.2 Exercices............................................................................................................................................... 9
2.2.1 Exercice 1............................................................................................................................................ 9
2.2.1.1. Objectif de l'exercice................................................................................................................................ 9
2.2.1.2. Logiciel utilisé.......................................................................................................................................... 9
2.2.1.3. Stratégie.................................................................................................................................................... 9
2.2.1.4. Consignes................................................................................................................................................. 9
2.2.2 Exercice 2.......................................................................................................................................... 10
2.2.2.1. Objectif de l'exercice.............................................................................................................................. 10
2.2.2.2. Logiciel utilisé........................................................................................................................................ 10
2.2.2.3. Stratégie.................................................................................................................................................. 10
2.2.2.4. Consignes............................................................................................................................................... 10
3 Architecture matérielle..................................................................................................... 11
3.1 Concepts théoriques.......................................................................................................................... 11
3.1.1 Principe fondamental..................................................................................................................... 11
3.1.2 Fonctions élémentaires d'une architecture ................................................................................... 11
3.1.3 Modèle de l'architecture matérielle ............................................................................................... 12
3.1.3.1. Chipset.................................................................................................................................................... 12
3.1.3.2. Modèle.................................................................................................................................................... 12
3.1.4 Horloge.............................................................................................................................................. 12
3.1.5 Bus..................................................................................................................................................... 13
3.1.5.1. Définition............................................................................................................................................... 13
3.1.5.2. Caractéristiques..................................................................................................................................... 13
3.1.5.3. Bande passante...................................................................................................................................... 14
3.2 Exercices............................................................................................................................................. 15
3.2.1 Exercice 1.......................................................................................................................................... 15
3.2.1.1. Objectif de l'exercice.............................................................................................................................. 15
3.2.1.2. Logiciels utilisés..................................................................................................................................... 15
3.2.1.3. Stratégie.................................................................................................................................................. 15
3.2.1.4. Consignes............................................................................................................................................... 15
3.2.2 Exercice 2.......................................................................................................................................... 16
3.2.2.1. Objectif de l'exercice.............................................................................................................................. 16
3.2.2.2. Logiciels utilisés..................................................................................................................................... 16
3.2.2.3. Stratégie.................................................................................................................................................. 16
3.2.2.4. Consignes............................................................................................................................................... 16
3.2.3 Exercice 3.......................................................................................................................................... 16
3.2.3.1. Objectif de l'exercice.............................................................................................................................. 16
3.2.3.2. Logiciels utilisés..................................................................................................................................... 16
3.2.3.3. Stratégie.................................................................................................................................................. 16
3.2.3.4. Consignes............................................................................................................................................... 16
4 Microprocesseur................................................................................................................ 19
4.1 Concepts théoriques.......................................................................................................................... 19
4.1.1 Architecture interne.........................................................................................................................19
4.2 Exercices............................................................................................................................................. 21
4.2.1 Exercice 1.......................................................................................................................................... 21
4.2.1.1. Objectif de l'exercice.............................................................................................................................. 21
4.2.1.2. Logiciel utilisé........................................................................................................................................ 21
4.2.1.3. Stratégie.................................................................................................................................................. 21
4.2.1.4. Consignes............................................................................................................................................... 21
4.2.2 Exercice 2.......................................................................................................................................... 24
4.2.2.1. Objectif de l'exercice.............................................................................................................................. 24
4.2.2.2. Logiciel utilisé........................................................................................................................................ 24
4.2.2.3. Stratégie.................................................................................................................................................. 24
4
4.2.2.4. Consignes............................................................................................................................................... 24
5 Communication dans l'architecture................................................................................. 25
5.1 Concepts théoriques.......................................................................................................................... 25
5.1.1 Introduction..................................................................................................................................... 25
5.1.2 Mécanisme d'interruption ............................................................................................................... 25
5.1.3 Projection mémoire des Entrées/Sorties (E/S) ............................................................................. 25
5.1.4 Assembleur....................................................................................................................................... 26
5.2 Exercices............................................................................................................................................. 27
5.2.1 Exercice 1.......................................................................................................................................... 27
5.2.1.1. Objectif de l'exercice.............................................................................................................................. 27
5.2.1.2. Logiciel utilisé........................................................................................................................................ 27
5.2.1.3. Stratégie.................................................................................................................................................. 27
5.2.1.4. Consignes............................................................................................................................................... 27
5.2.2 Exercice 2.......................................................................................................................................... 28
5.2.2.1. Objectif de l'exercice.............................................................................................................................. 28
5.2.2.2. Logiciel utilisé........................................................................................................................................ 28
5.2.2.3. Stratégie.................................................................................................................................................. 28
5.2.2.4. Consignes............................................................................................................................................... 29
5
1 Introduction : vue générale
Ce cours vise à étudier quelle structure matérielle permet d'exécuter les programmes
répondant à nos divers besoins. On se demandera également comment évaluer les
performances d'une telle architecture.
Bien entendu, il sera difficile d'ignorer complètement les aspects logiciels : ils sont
étroitement associés au matériel. Le logiciel de bas niveau qui se trouve à l'interface sera donc
lui aussi évoqué.
Après un bref rappel sur le binaire, notre parcours commencera par une présentation
globale et générique de l'architecture matérielle. Puis, nous nous focaliserons sur son « chef
d'orchestre », le microprocesseur. Finalement, nous terminerons en faisant une initiation au
langage le plus simple qui régisse cette architecture : l'assembleur.
6
2 Rappels : le binaire
Le binaire constitue le langage de base de notre architecture. On est donc à tout moment
contraint à utiliser un alphabet constitué de deux lettres : 0 et 1.
2.1 Concept
2.1.1
Origine
Les circuits électroniques manipulent des courants électriques. Toute l'information plus
complexe (image, son, …) doit, comme on l'a vu précédemment, être exprimée de cette
manière.
On aurait pu définir un langage constitué d'une multitude de pas de tensions mais la
précision des circuits, notamment dans les années 40, à l'aube des premiers ordinateurs, ne
permettait pas une détection des changements de niveaux suffisamment fine. C'est pourquoi il
a été décidé de se fonder sur une détection du niveau de courant plus simple : il y a du
courant (état 1) ou il n'y en a pas (état 0).
2.1.2
0.
Unités de base
L'entité élémentaire de stockage d'information est le bit, qui stock soit un état 1, soit un état
De là découlent des multiples et des variantes utilisées pour mesure la vitesse de
transmission des données.
 Le Kilobit: 1 kb = 210 = 1024 bits
• unité de mesure des connexions Internet les plus lentes : Kb/s
 Le Megabit: 1 Mb = 220 bits
• unité de mesure des connexions Internet et réseau local : Mb/s
 Le Gigabit: 1 Gb = 230 bits
• unité de mesure des connexions très haut débit : Gb/s
 Le Terabit: 1 Tb = 240 bits
• unité de mesure des connexions fibre : Tb/s
2.1.3
Unités usuelles
Les unités de base sont complétées par une mesure en octets est plus courante. En effet,
historiquement, un octet était la capacité mémoire requise pour stocker un caractère (lettre,
chiffres, symboles) en ASCII. Le texte étant quasiment le seul type d'information manipulée à
l'époque, on pouvait donc évaluer pratiquement la capacité d'un support.
On distingue plusieurs multiples :
 Le Kilo-octet: 1 Ko = 210 = 1024 octets (KB en anglais)
7
 Le Mega-octet: 1 Mo = 220 octets = 210 Ko = 1024 Ko (MB en anglais)
 Le Giga-octet: 1 Go = 230 octets = 210 Mo = 1024 Mo (GB en anglais)
 Le Tera-octet : 1 To = 240 octets = 210 Go = 1024 Go (TB en anglais)
 Le Peta-octet : 1 Po = 250 octets = 210 To = 1024 To (PB en anglais)
Remarque : la traduction anglaise de mot octet est byte. Toutefois, la confusion avec le bit
est tout à fait possible lorsqu'on utilise les unités. C'est pourquoi, on respectera à la lettre la
convention suivante : le bit est représenté par un b minuscule, le Byte par un B majuscule.
2.1.4
Unités du système international
En décembre 1998, la Commission Electrotechnique Internationale (IEC) a adopté une
nouvelle charte de nommage des unités de mesure de l'information informatique afin de
l'harmoniser avec les autres unités du Système International (SI). En effet, dans ce système, le
préfixe Kilo fait référence à un facteur 1000 alors qu'en informatique, le facteur est 1024,
fondé sur la base 2.
Il a donc été créé un préfixe binaire utilisant les mêmes multiples. On parle donc de Kilo
Binaire, de Mega Binaire, de Giga Binaire, … Deux sous-variantes existent, pour les bits et les
octets.
Nom SI
Symbole
Facteur
Nom complet
Ancien préfixe
Kibi
Ki
210
Kilobinaire
Kilo
Mebi
Mi
220
Megabinaire
Mega
Gibi
Gi
230
Gigabinaire
Giga
Tebi
Ti
240
Terabinaire
Tera
Pebi
Pi
250
Petabinaire
Peta
Tableau 2.1 : préfixes standards de représentation de l'information binaire
8
Nom SI (anglais entre parenthèses)
Abréviation
Kibibit
1 Kib = 210 bit = 1024 bit
Kilobit
1 Kb = 103 bit = 1000 bit
Mebibit
1 Mib = 220 bit
Megabit
1 Mb = 106 bit
Mebioctet (MebiByte)
1 Mio = 1 MiB = 220 octets = 1048576 bit
Megaoctet (MegaByte)
1 Mo = 1 MB = 106 octets = 1000000 octets
Gibioctet (GibiByte)
1 Gio = 1 GiB = 230 octets
Gigaoctet (GigaByte)
1 Go = 1 GB = 109 octets
Pebioctet (PebiByte)
1 Pio = 1 PiB = 240 octets
Petaoctet (PetaByte)
1 Po = 1 PB = 1012 octets
Tableau 2.2 : quelques unités standards de représentation de l'information binaire
2.2 Exercices
2.2.1
Exercice 1
2.2.1.1.
Objectif de l'exercice
Manipuler les unités de mesure de l'information et faire le lien avec des faits rencontrés
dans la réalité.
2.2.1.2.
Logiciel utilisé
Calculatrice intégrée à tout système d'exploitation.
2.2.1.3.
Stratégie
Cet exercice est basé sur la réflexion. La stratégie consiste à comparer deux valeurs : l'une
théorique, l'autre pratique.
2.2.1.4.
Consignes
La capacité réelle d'un disque dur de 500 Go est de 465 Go. Expliquer ce fait. Y a-t-il
tromperie sur la marchandise ?
9
2.2.2
Exercice 2
2.2.2.1.
Objectif de l'exercice
Manipuler les unités de mesure de l'information et faire le lien avec des faits rencontrés
dans la réalité.
Approcher un des principes du stockage d'information sur un disque numérique.
2.2.2.2.
Logiciel utilisé
Calculatrice intégrée à tout système d'exploitation.
2.2.2.3.
Stratégie
Cet exercice est basé sur la réflexion. Toutefois, il peut être nécessaire de revoir le principe
de l'échantillonnage vu dans le cours précédent.
2.2.2.4.
Consignes
En audionumérique grand public, les spécifications du CD audio prévoient f s = 44,1 KHz
avec une quantification q = 16 bits en stéréo. A partir de ces données, il est possible de
calculer la consommation mémoire par minute de son : 10,09 Mo.
1. Quelle est la durée maximale de son que peut stocker un CD gravable de 700 Mo ?
2. Sur la boîte, il est écrit que le disque peut supporter 80 minutes de son en qualité CD.
Comment expliquer la différence par rapport à la question 1. ? Y a-t-il tromperie sur la
marchandise ?
10
3 Architecture matérielle
La structure présentée ici est valable pour l'immense majorité des systèmes existants : on
pense bien sûr aux micro-ordinateurs, mais tout autre système numérique est bâti sur les
mêmes principes : lecteur DVD/Bluray, console de jeux, téléphone portable, synthétiseur,
montre, ...
3.1 Concepts théoriques
3.1.1
Principe fondamental
Le principe de l'architecture informatique remonte aux années 40-50, même encore
actuellement. L'idée globale est la suivante : le système peut exécuter un nombre indéfini
d'actions, à partir des mêmes composants. On appelle programme l'élément qui implémente
une action que doit accomplir ce système. On reste bien sûr soumis aux capacités du matériel.
La grande originalité de ce concept est donc que l'on peut faire accomplir à une telle
machine, appelée ordinateur, des tâches qui n'ont pas été pré-programmées par son fabricant,
par opposition au concept d'automate.
3.1.2
Fonctions élémentaires d'une architecture
Une architecture informatique comporte obligatoirement les catégories de fonctions
suivantes :

Un circuit de traitement : il réalise les opérations nécessaires à l'accomplissement
d'un programme. C'est ce qu'on appelle le microprocesseur (ou processeur), du nom
du composant qui de nos jours intègre ce rôle autrefois dévolu à plusieurs
composants

De la mémoire RAM (Random Access Memory) : c'est la zone de travail du
microprocesseur. Une donnée et l'instruction qui intervient dessus doivent être
transférées dans la mémoire pour que le traitement opère. Cette mémoire est
volatile, c'est-à-dire que son contenu est perdu lorsque l'électricité est coupée

Des périphériques d'entrée/sortie (I/O en anglais, pour input/output) : cette
catégorie recouvre de multiples rôles :
◦ Stockage : disques, cassettes, cartouches, cartes perforées, ...
◦ Entrée d'information : clavier, souris, joystick, scanner, ...
◦ Sortie d'information : imprimante, affichage sur l'écran, ...
◦ Entrée/sortie : réseau, carte son, …
Tous ces circuits communiquent entre eux par l'intermédiaire de voies appelées bus à la
cadence donnée par une horloge.
Physiquement, la plupart prend place aujourd'hui sur une carte mère, concentrant
beaucoup de rôles.
11
3.1.3
Modèle de l'architecture matérielle
3.1.3.1.
Chipset
Pour assurer le fonctionnement de l'architecture, un contrôle permanent doit être effectué
afin d'organiser les échanges entre composants. Autrefois, il était assuré par un jeu de puces
différentes. Les progrès techniques ont permis l'intégration de ces fonctions au sein d'un
ensemble central appelé chipset (littéralement « jeu de puces »). C'est lui qui assure la
régulation des flux et l'accès du processeur aux autres ressources.
Physiquement, sur les ordinateurs traditionnels, les chipsets actuels sont composés de deux
parties :

Northbridge (encore appelé SPP) : il gère principalement la mémoire, le système
graphique et la liaison au Southbridge

Southbridge (encore appelé MCP) : il gère les ports d'entrée/sortie (PCI, USB, …),
l'alimentation (passage en veille) et le signal de l'horloge
Sur les équipement mobiles, le chipset est un seul composant et peut même être intégré au
processeur.
3.1.3.2.
Modèle
L'imbrication entre les différents éléments vus précédemment est présenté sur l''Illustration
3.1.
3.1.4
Horloge
L'horloge rythme les échanges et traitements de l'architecture. Elle produit des « tops »
déclenchant ces événements. Il est ainsi possible d'exprimer la vitesse, en Hertz (Hz) de chaque
composant comme un multiple de la pulsation de base que donne l'horloge. Actuellement,
elles varient de l'ordre de la centaine de mégahertz (MHz) dans les systèmes embarqués et sur
certains composants des cartes mère à quelques gigahertz (GHz) dans les microprocesseurs et
les cartes graphiques.
Techniquement, il s'agit d'un quartz qui oscille lorsqu'il est traversé par un courant. Le
signal produit est une forme d'onde carrée, visualisée à l'Illustration 3.2.
12
Initialement, c'était le front montant de l'horloge qui est utilisé pour déclencher les
opérations et les échanges. A l'heure actuelle, le front descendant est aussi utilisé pour doubler
(théoriquement) la quantité d'information échangée par cycle. On a ainsi deux modes :

SDR : Single Data Rate : transfert normal reposant uniquement sur les fronts
montants

DDR : Double Data Rate : transfert doublé utilisant fronts montants et descendants,
on a donc deux échanges par période au lieu d'une
3.1.5
Bus
3.1.5.1.
Définition
Comme on l'a vu précédemment, le bus est la voie d'interconnexion des composants. Il se
décompose en deux parties :

le bus d'adresse (address bus), qui donne la destination des données

le bus de données (data bus) qui contient l'information elle-même.
Le bus principal d'une architecture, celui qui interconnecte le microprocesseur, la mémoire
et le chipset est le FSB (Front Side Bus).
Plus généralement, les bus sont gérés par des contrôleurs et peuvent être reliés entre eux par
des ponts.
3.1.5.2.
Caractéristiques
Un bus est défini par les caractéristiques suivantes :

sa largeur en bits, ce qui induit deux grandes familles de bus
◦ série : les bits sont transmis l'un après l'autre, la largeur du bus est de 1
◦ parallèle : plusieurs voies (ou lignes) en parallèle transmettent plusieurs bits en
un cycle

sa vitesse, en MHz
13

sa directionnalité :
◦ half duplex : sur chaque voie, les bits ne peuvent circuler que dans un seul sens
◦ duplex : la communication peut se faire dans les deux sens entre circuits.
Autrement dit, émetteur et récepteurs peuvent échanger leurs rôles
◦ full duplex : la communication peut se faire dans les deux sens entre circuits,
simultanément

son type : SDR ou DDR. Dans ce dernier cas, il existe des variantes aux apports plus
ou moins réels. On peut noter le cas du DDR2 qui utilise fronts montants et
descendants simultanément pour une lecture de donnée et une écriture ce qui
double encore le débit par rapport au DDR et donc le quadruple par rapport au
SDR. Du moins théoriquement, car dans la pratique, on conçoit aisément qu'il faut
être prêt à faire les lectures et écritures simultanées à chaque cycle, ce qui est
rarement le cas
Illustration 3.3 : représentation imagée d'un bus
L'Illustration 3.3 propose un parallèle avec une autoroute pour évoquer la plupart de ces
caractéristiques. Les voitures représentent les bits d'information.
3.1.5.3.
Bande passante
Dans la pratique, les caractéristiques techniques d'un bus peuvent souvent être assimilées à
sa bande passante, c'est-à-dire la quantité d'information pouvant être transférée par seconde.
Le plus souvent, sa valeur maximale théorique est calculable grâce à la formule suivante :
B=T×L×f
14
où B : bande passante en bits/s
T : type de bus : T = 1 si SDR ou T = 2 si DDR
L : largeur du bus en bits
f : fréquence du bus en Herz
Étant données les valeurs actuelles, on a souvent l'habitude de convertir la bande passante
en Mo/s ou en Go/s. Pour cela, on divise d'abord la valeur calculée par la formule ci-dessus
par 8 (pour obtenir des octets) puis un certain nombre de fois par 1024.
Remarque : par définition, il n'est pas possible d'utiliser la formule précédente pour certains
bus, par exemple si celui-ci propose un système de compression des données. En effet, dans ce
cas, le taux de compression dépend du type de données.
3.2 Exercices
3.2.1
Exercice 1
3.2.1.1.
Objectif de l'exercice
Visualiser les différentes fonctions de l'architecture matérielle sur deux systèmes numériques
de la vie courante.
3.2.1.2.
Logiciels utilisés
3.2.1.3.
Stratégie
Aucun
L'idée est de décomposer chaque équipement par rapport à son usage : que produit-il ?
Comment le manipule-t-on ?
3.2.1.4.
Consignes
On considère les deux équipements suivants.
Équipement 1
Équipement 2
Donner pour chacun d'eux la liste de leurs périphériques d'entrées/sorties.
15
3.2.2
Exercice 2
3.2.2.1.
Objectif de l'exercice
Déterminer les performances d'un bus à travers sa bande passante.
3.2.2.2.
Logiciels utilisés
Calculatrice intégrée à tout système.
3.2.2.3.
Stratégie
Il suffit d'appliquer la formule.
3.2.2.4.
Consignes
Calculer la bande passante du bus mémoire d'un circuit graphique possédant les
caractéristiques suivantes : 128 bits DDR @500 MHz.
3.2.3
Exercice 3
3.2.3.1.
Objectif de l'exercice
Appréhender les principaux composants d'un ordinateur.
3.2.3.2.
Logiciels utilisés
3.2.3.3.
Stratégie
Aucun
Pas de stratégie particulière.
3.2.3.4.
Consignes
Voici les photographies d'une carte mère et de divers composants. Donner les nom des pièces
repérés par les numéros et expliquer leur rôle.
16
17
18
4 Microprocesseur
Dans l'architecture matérielle telle que présentée précédemment, le microprocesseur joue un
rôle clé car c'est lui qui accomplit le travail demandé. Même si au fil des années il s'est vu
adjoindre de nombreux circuits pour le décharger de certaines tâches, c'est lui qui dirige les
opérations, agissant comme un chef d'orchestre avec ses musiciens.
4.1 Concepts théoriques
4.1.1
Architecture interne
Le processeur est composé des unités fondamentales suivantes, représentées à l'Illustration
4.1 :

Des registres : mémoires très rapides contenant
◦ les données à traiter : registres de données
◦ les instructions : registre d'instruction
Il existe plusieurs types de registres. Les plus utilisés sont les registres généraux,
nommés dans l'architecture des PC EAX, EBX, ECX, EDX, ESI et EDI

Une unité de commande qui contrôle le travail à accomplir et les cycles

Un compteur ordinal qui contient l'adresse mémoire de la prochaine instruction à
exécuter

Des tampons (buffers) stockant temporairement les données et/ou instructions afin
d'éviter des accès à la mémoire hors processeur (RAM/ROM/Mémoire cache
externe), plus lents, pour les éléments utilisés fréquemment

D'un décodeur d'instruction qui paramètre le registre d'instruction

Des unités de traitement : ce sont elles qui font les calculs à proprement dit. On
compte en particulier :
◦ L'Unité Arithmétique et Logique (Arithmetic and Logical Unit – ALU) : elle
réalise et gère
▪ les opérations arithmétiques (addition, soustration, division, multiplication)
sur les nombres entiers (naturels ou relatifs)
▪ les opérations logiques (ET, OU, NON, OU EXCLUSIF)
▪ les accès à la mémoire ou transferts de données entre registres
▪ le contrôle de séquence et les branchements conditionnels
◦ L'Unité de Calcul en Virgule Flottante (Floating Point Unit – FPU) : réalise les
opérations arithmétiques sur les réels. Elle supporte également des nombreuses
fonctions non arithmétiques : trigonométrie, exponentielle, logarithme, …
19
◦ Les unités SIMD. Plus récentes, elles sont spécialisées dans le calcul de fonctions
complexes mais répétitives (qui s'appliquent sur un vecteur, par exemple). Ainsi,
ces unités sont spécialisées et sont capables d'aller très vite et en parallèle sur ce
qu'elles savent traiter. Elles sont largement liées au multimédia et au jeu vidéo.
Les plus connues sont, par ordre chronologique d'apparition :
▪ MMX et MMX2 : MultiMedia eXtension d'Intel. Apparues en 1997 pour
accélérer le codage et le décodage de la vidéo ainsi que les jeux vidéo en 3D
▪ 3DNow! : d'AMD. C'est le pendant du MMX chez AMD
▪ SSE, SSE2, SSE3, SSE4 : d'Intel, unité ayant évoluée depuis sont apparition
sur les Pentium 4 en 2002
▪ AltiVec : d'AIM (alliance Apple IBM Motorola). Encore connu sous le nom de
Velocity Engine, c'est une unité SIMD embarquée dans les processeurs G4 et
G5 utilisés jusqu'en 2006 dans les ordinateurs Macintosh
Toutes ces unités sont reliées entre elles par des bus pouvant être dédiés au transport de
données, d'instructions ou d'adresses. L'accès aux différentes mémoires externes se fait aussi
par des bus externes de données et d'adresses.
Illustration 4.1 : architecture interne d'un microprocesseur
Enfin, le processeur dispose de deux liaisons vers l'environnement extérieur : un bus externe
de contrôle et une ligne de signaux de contrôle afin de communiquer avec le chipset (et donc
le reste des composants).
Il existe beaucoup d'autres unités spécifiques à certains types de processeurs particuliers ou
20
dont l'équipement varie en fonction des progrès technologiques.
4.2 Exercices
4.2.1
Exercice 1
4.2.1.1.
Objectif de l'exercice
Comparer deux architectures différentes conçues pour répondre au même objectif.
4.2.1.2.
Logiciel utilisé
4.2.1.3.
Stratégie
Aucun
Il faut d'abord identifier les critères qui seront utilisés pour définir les performances.
Exemple : processeur, mémoire... Ensuite, on pourra remplir un tableau avec dans chaque
colonne l'une et l'autre des architectures.
4.2.1.4.
Consignes
Le but de cet exercice est de comparer deux architectures dédiées au même but : le jeu
vidéo. Pour cela, une documentation est fournie ci-dessous.
1. Comparer les deux architectures proposées
2. Proposer une conclusion sur les deux philosophies architecturales qui s'opposent ici
21
Architecture 1
Architecture 2
Sega Megadrive
Nintendo Super Nintendo
Technical specifications Sega Mega Drive
Super Nintendo Hardware
CPU
Specifications/features
* Main processor: 16-bit Motorola M68000 (or
The design of the Super Nintendo/Super Famicom
equivalent)
was unusual for its time. It featured a relatively lowperformance CPU supported by very powerful custom
o runs at 7.61MHz in PAL consoles, 7.67MHz chips for sound and video processing. This approach
would become common in subsequent video game
in NTSC consoles
hardware, but at the time it was new to game
developers. As a result early third-party games were of
* Sound processor: 8-bit Zilog Z80a (or equivalent) low technical quality. Developers later became
accustomed to the system, and were able to take
o runs at 3.55MHz in PAL consoles, 3.58MHz advantage of its full potential. It was the first console
in NTSC consoles
capable of applied acoustics in video game audio sold
in North America, Europe, and Japan.
o used as main CPU in Master System
compatibility mode.
* Core
Memory
* Boot ROM: 2 KBytes
o runs when console is first switched on.........
* CPU: Nintendo custom '5A22', believed to be
produced by Ricoh; based around a 16-bit CMD/GTE
65c816 (a predecessor of the WDC 65C816). The CPU
runs the 65c816-alike core with a variable-speed bus,
with bus access times determined by addresses accessed,
with a maximum theoretical effective clock rate around
3.58 MHz. The SNES/SFC provided the CPU with 128
KB of Work RAM.
o contains 'copyright check' code for locking out
The CPU also contains other support hardware,
unlicensed games
including hardware:
o displays message 'Produced by or under
license from Sega Enterprises Ltd.' when a licensed
game is detected
o Boot ROM is not present on earlier versions of
the Mega Drive 1
o The name Sega gave this boot ROM was the
TMSS (TradeMark Security System)
* Main RAM: 64 KBytes
o part of M68000 address space
o for interfacing with controller ports;
o for generating NMI interrupts on Vblank;
positions;
o for generating IRQ interrupts on screen
o DMA unit, supporting two primary modes, general
DMA (for block transfers, at a rate of 2.68MB/second)
and Hblank DMA (for transferring small data sets at the
end of each scanline, outside of the active display
period);
o multiplication and division registers.
* Video RAM: 64 KBytes
o cannot be accessed directly by CPU, must be
read and written via VDP (Video Display Processor - see
* Cartridge Size Specifications: 2 - 32 Mb which
below)
ran at two speeds ('SlowROM' and 'FastROM'). Custom
address decoders allow larger sizes, eg. 64 Mb for Star
* Sound RAM: 8 KBytes
Ocean and Tales of Phantasia
o part of Z80 address space
o used as main RAM in Master System
compatibility mode
* Sound
o Sound Controller Chip: 8-bit Sony SPC700
* Cartridge memory area: up to 4 MBytes (32 CPU for controlling the DSP; running at an effective
Megabits)
clock rate around 1.024 MHz.
o part of M68000 address space
with
22
o Main Sound Chip: 8-channel Sony S-DSP
hardware
ADPCM
decompression,
pitch
o Game cartridges larger than 4 MBytes must modulation,
echo
effect
with
feedback
(for
use bank switching
reverberation) with 8-tap FIR filter, and ADSR and
'GAIN' (discretely controlled) volume envelopes.
o Memory Cycle Time: 279 Minutes
Graphics
o Low-pass filter for improved quality of lowThe Mega Drive has a dedicated VDP (Video Display frequency (bass) tones
Processor) for playfield and sprite control. This is an
improved version of the Sega Master System VDP, which
o Sound RAM: 512 Kb shared between SPC700
in turn is derived from the Texas Instruments TMS9918. and S-DSP.
* Planes: 4 (2 scrolling playfields, 1 sprite plane, 1
o Pulse Code Modulator: 16-Bit ADPCM (using
'window' plane)
4-bit compressed ADPCM samples, expanded to 15-bit
resolution, processed with an additional 4-point
* Sprites: up to 80 onscreen, depending on display Gaussian sound interpolation).
mode
o Note - while not directly related to SNES
hardware, the standard extension for SNES audio
* Palette: 512 colours (29)
subsystem state files saved by emulators is .SPC, a
format used by SPC players.
* Onscreen colours: 64 x 9-bit words of colour
RAM, allowing 61 onscreen colours (up to 1536 using
raster effects and Shadow/Hilight mode)
* Video
* Pixel resolution: depends on display mode
o Picture Processor Unit: 15-Bit
o up to 320x240 (40x30 cells) for PAL
o Video RAM: 64 KB of video RAM for screen
maps (for 'background' layers) and tile sets (for
backgrounds and objects); 512 + 32 bytes of 'OAM'
o interlaced modes can provide double the (Object Attribute Memory) for objects.
vertical resolution (i.e. 320x448 for NTSC). Used in
Sonic 2 for 2-player split screen
o Palette: 32,768 Colors.
o up to 320x224 (40x28 cells) for NTSC
o Maximum colors per layer per scanline: 256.
Sound
* Main sound chip: Yamaha YM2612 6 channels
(5 FM channels + 1 PCM/FM channel)
o Maximum colors on-screen: 32,768 (using
color arithmetic for transparency effects).
o Resolution: between 256x224 and 512x478.
Most games used 256x224 pixels since higher
* Additional sound chip: Texas Instruments resoulutions caused slowdown, flicker, and/or had
SN76489 4 channel PSG (Programmable Sound increased limitations on layers and colors (due to
Generator)
memory bandwidth constraints); the higher resolutions
were used for less processor-intensive games, in-game
o 3 sound generators, 4 octaves each, 1 white menus, text, and high resolution images.
noise generator
o Maximum onscreen objects (sprites): 128 (32
per line, up to 34 8x8 tiles per line).
Inputs and outputs
only
o Maximum number of sprite pixels on one
scanline: 256. The renderer was designed such that it
would drop the frontmost sprites instead of the rearmost
* RF output: connects to TV aerial input
sprites if a scanline exceeded the limit, allowing for
o exists on European and Asian Mega Drive 1 creative clipping effects.
o Most common display modes: Pixel-to-pixel
o other models must use external RF modulator text mode 1 (16 colors per tile; 3 scrolling layers) and
affine mapped text mode 7 (256 colors per tile; one
which plugs into A/V output
rotating/scaling layer).
* A/V output: DIN connector with composite video,
RGB, and audio outputs
o Effects
# Pixelization (mosaic) per background
o Mega Drive 1 has 8-pin socket (same as
Master System), supports mono audio only
23
o Mega Drive 2, Multimega, and other models
have 9-pin mini DIN socket with both mono and stereo
audio
* Power input: requires 9-10 volts DC, 0.85-1.2 A
depending on model
# Color addition and subtraction
# Clipping windows (per background, affecting color,
math, or both)
# Scrolling per 8x8 tile
* Headphone output: 3.5 mm stereo jack on front
of console (Mega Drive 1 only)
# Mode 7 matrix operation
* "EXT" port: 9-pin D socket for Meganet modem
connection
* Power Adapter
o exists on all Japanese and Asian Mega Drive 1
units, and on early European Mega Drive 1 units
o Transformer Input: 120 VAC, 60 Hz, 17 watts
o Transformer Output: 10 VDC, 850 mA
* Control pad inputs: 2 x 9-pin D connectors on
(NTSC),
9
VAC
(PAL)
front of console
* Plugs
* Expansion port: Edge connector on bottom right
hand side of console for Sega Mega-CD connection
o 2x Controllers - Response: 16ms
o Expansion port
o A/V output
4.2.2
Exercice 2
4.2.2.1.
Objectif de l'exercice
Découvrir les caractéristiques d'un ordinateur sans l'ouvrir.
4.2.2.2.
Logiciel utilisé
A chercher !
4.2.2.3.
Stratégie
Il existe des logiciels et des manipulations permettant de connaître les principales
caractéristiques techniques d'un ordinateur. Quelques recherches sur Internet permettront de
trouver des idées adaptées au système d'exploitation (Windows, Mac, Linux) de la machine en
présence.
4.2.2.4.
Consignes
Déterminer les caractéristiques de processeur, de mémoire, de disque et de ports
d'entrée/sortie de l'ordinateur en face de vous.
24
5 Communication dans l'architecture
Nous terminerons ce cours en analysant comment fonctionne la communication et la
programmation de bas niveau dans l'architecture
5.1 Concepts théoriques
5.1.1
Introduction
Conceptuellement, tous les circuits de l'architecture sont conçus pour réagir à des
sollicitations électriques. On distingue les instructions, qui déclenchent des fonctions et les
données, qui sont l'information sur laquelle les fonctions seront appliquées.
Le but de ce chapitre est de passer en revue quelques commandes qui utilisent le
microprocesseur pour commander des périphériques d'entrée-sortie.
5.1.2
Mécanisme d'interruption
Le fonctionnement de l'architecture est organisé en cycles réguliers. Le travail à accomplir à
chaque pas de temps ne peut toutefois pas tout le temps être anticipé dans la liste des
instructions. D'où l'implémentation d'un mécanisme d'interruptions qui permet d'interrompre
les tâches courantes du processeur afin d'exécuter des tâches plus « urgentes » ou en rapport
avec l’occurrence d'événements spéciaux comme par exemple le dépassement d'une valeur
seuil, la notification d'un périphérique qui a terminé son traitement et qui en attend un
autre, la sollicitation d'un contrôleur, …
Il existe deux types d'interruptions :

matérielles: utilisées par les unités d'entrée/sortie

logicielles: servant à appeler des routines du BIOS, logiciel le plus simple d'un
ordinateur ou du système d'exploitation
Il convient à présent d'étudier comment le processeur peut communiquer avec les
périphériques, à travers ce dispositif et par l'intermédiaire du chipset.
5.1.3
Projection mémoire des Entrées/Sorties (E/S)
Toutes les unités ont une adresse propre, un port d'E/S en mémoire RAM, pour réaliser les
échanges de données. C'est ce qu'on appelle la projection mémoire des E/S (I/O memory
mapping). Ainsi, le processeur s'adresse à cette adresse pour atteindre l'unité en question, en
lecture et/ou écriture.
Sur les PC, ordinateur historiquement 16 bits, il y a 2 16 adresses possibles pour cette
projection.
Exemple : fonctionnement d'une carte réseau (Illustration 5.3)
Une portion de la mémoire RAM est dédiée, de façon logicielle ou matérielle (en déplaçant
des cavaliers sur la carte) à la carte réseau. La moitié pour lire les données reçues, l'autre
moitié pour envoyer des données.
Du point de vue du processeur, il suffit donc d'aller lire les données localisées aux adresses
de réception de la projection mémoire pour accéder à ce que la carte réseau a transporté en
entrée. La carte réseau, de son côté, ira chercher les données à expédier sur le réseau dans la
plage d'adresses réservée aux données en sortie.
25
Le circuit PIC (Programmable Interruption Controller) se charge de gérer les interruptions.
Ce mécanisme permet des subtilités intéressantes, comme le partage de la mémoire RAM
centrale aux périphériques. Exemples: carte graphique à mémoire partagée, chargement de
samples dans les cartes son avancées, RAMdisks...
Illustration 5.1 : modèle de projection des entrées/sorties
5.1.4
Assembleur
Avant de définir l'assembleur, il convient de présenter le langage machine. C'est le langage
que le microprocesseur est capable de comprendre sans « traduction ». Concrètement, il s'agit
d'une suite de 0 et de 1 qui représentent soit des ordres (instructions) soit des informations à
traiter (données).
Voici un exemple d'opération en langage machine : A1 01 10 03 06 01 12 A3 01 14
On peut voir aisément qu'il s'agit de l'addition du contenu de deux adresses mémoire et du
stockage du résultat dans une troisième adresse mémoire (ironie inside). Toutefois, certaines
personnes éprouvent du mal à lire ce genre de code, c'est pourquoi il a été nécessaire
d'imaginer une couche d'abstraction qui facilite l'écriture et la lecture d'un programme, sans
trop s'éloigner du langage machine : l'assembleur.
L'assembleur est le langage le plus proche du langage machine car les opérations qui sont
décrites dans un tel programme peuvent être interprétées directement par les différentes
unités du processeur.
Pour des raisons de commodité et de lisibilité, les instructions sont représentées par des
mots-clés plus faciles à manipuler par les humains. Les données peuvent quant à elles se voir
représentées par des labels, des noms choisis par le développeur.
Les mots clés sont appelés mnémoniques. Ils forment la représentation symbolique et
permettent de séparer les opérateurs des opérandes.
Exemple : l'addition donnée au paragraphe précédent peut s'écrire de la façon suivante en
assembleur :
ADD @A, @B, @C
26
5.2 Exercices
5.2.1
Exercice 1
5.2.1.1.
Objectif de l'exercice
Concevoir et exécuter un programme en assembleur. Découvrir « l'envers du décor ».
5.2.1.2.
Logiciel utilisé
Nasm et ld : ce sont des programmes basiques (en ligne de commande) mais puissants pour
programmer en assembleur.
5.2.1.3.
Stratégie
Un code de base est fourni. L'idée consiste à voir d'abord les différentes sections du
programme puis à comprendre, à l'intérieur, à quoi sert chaque instruction.
5.2.1.4.
Consignes
On donne le code assembleur suivant :
section .data
hello:
helloLen:
db 'Hello world!',10
equ $-hello
section .text
global _start
_start:
; Write 'Hello world!'
mov eax,4
;
mov ebx,1
;
mov ecx,hello
;
mov edx,helloLen
;
int 80h
;
; Terminate program
mov eax,1
mov ebx,0
int 80h
to the screen
'write' system call
file descriptor 1 = screen
string to write
length of string to write
call the kernel
; 'exit' system call
; exit with error code 0
; call the kernel
Code extrait du cours d'Assembleur de Derick Swanepoel © 2002
1. Le recopier et le lier dans un fichier texte enregistré sous le nom hello.asm
2. L'assembler et le lier grâce aux instructions suivantes :
•
nasm -f elf hello.asm
•
ld -s -o hello hello.o
•
Exécuter le programme : ./hello
27
5.2.2
Exercice 2
5.2.2.1.
Objectif de l'exercice
Découvrir des interruptions utilisées dans la gestion des fichiers dans une architecture
matérielle.
5.2.2.2.
Logiciel utilisé
Nasm et ld : comme à l'exercice précédent.
5.2.2.3.
Stratégie
Un code de base est aussi fourni. Il suffira de l'adapter au contexte. Il y a ici une nouveauté :
des informations fournies par l'utilisateur sont récupérées grâce à une pile.
La pile (stack en anglais) est une structure d'organisation des données : c'est un espace
mémoire réservé à l'enregistrement continu de données.
Pour l'expliquer, on peut tout à fait prendre la métaphore de la pile d'assiettes dans l'évier,
comme montré à l'Illustration 5.2.
Illustration 5.2 : structure de pile
L'instruction assembleur PUSH permet de mettre une information au sommet de la pile,
alors que l'instruction POP permet de la retirer.
Dans la structure de pile, c'est la dernière donnée à être entrée qui est la première à être
accessible. On dit alors que c'est une structure de type LIFO : Last In First Out.
L'inverse de ce concept est le FIFO : First In First Out. Autrement dit, le premier arrivé est le
premier servi. C'est le cas de la file d'attente à une caisse de supermarché.
Dans l'environnement que nous utilisons un mécanisme très pratique permet de récupérer
dans la pile les paramètres que l'utilisateur a entré lors du lancement du programme.
Tout part de la ligne de commande qui lance le programme. Après le nom de celui-ci sont
passés les différents paramètres séparés chacun par un espace.
28
Exemple : ./monprogramme parametre1 parametre2 parametre3
Tous ces éléments sont automatiquement placés sur la pile, dans cet ordre. Chacun d'eux est
un argument (arg[n]), y compris le nom du programme qui est l'argument 0. Le nombre total
d'arguments (argc) les précède dans la pile.
La structure de la pile au démarrage sera conforme à l'Illustration 5.3.
Illustration 5.3 : structure de la pile lors du lancement d'un programme
5.2.2.4.
Consignes
Écrire et exécuter le programme donné ci-dessous
section .data
hello
helloLen
db
equ
'Hello, world!',10
$ - hello
; Our dear string
; Length of our dear string
section .text
global _start
_start:
pop
pop
pop
ebx
ebx
ebx
; argc (argument count)
; argv[0] (argument 0, the program name)
; The first real arg, a filename
mov
eax,8
mov
int
ecx,00644Q
80h
; The syscall number for creat()
;(we already have the filename in ebx)
; Read/write permissions in octal (rw_rw_rw_)
; Call the kernel
; Now we have a file descriptor in eax
test
js
eax,eax
skipWrite
call
fileWrite
; Lets make sure the file descriptor is valid
; If the file descriptor has the sign flag
;(which means it's less than 0) there was an
;oops, so skip the writing. Otherwise call the
;filewrite "procedure"
29
skipWrite:
mov
mov
int
ebx,eax
eax,1
80h
; If there was an error, save the errno in ebx
; Put the exit syscall number in eax
; Bail out
; proc fileWrite - write a string to a file
fileWrite:
mov
ebx,eax
mov
eax,4
mov
mov
ecx,hello
edx,helloLen
int
80h
mov
int
ret
eax,6
80h
;
;
;
;
;
;
;
sys_creat returned file descriptor into eax,
now move into ebx
sys_write
ebx is already set up
We are putting the ADDRESS of hello in ecx
This is the VALUE of helloLen because
it's a constant (defined with equ)
; sys_close, ebx already contains file descriptor
; endp fileWrite
Code extrait du cours d'Assembleur de Derick Swanepoel © 2002
30