Cours Architecture d'Ordinateur
Short Description
Nom du document : CoursArchitectureOrd Répertoire : E: Modèle : C:\Documents and Settings\Administrateur\Application ...
Description
SMAI-S3
Année Universitaire : 2009/2010
TABLE DES MATIERES CHAPITRE 1 : GENERALITES.................................................................................. 4 1.
Introduction ..................................................................................................................4
2.
Qu’est ce qu’une architecture ? ...................................................................................4
3.
Qu’est ce qu’un microprocesseur ? ..............................................................................4
4.
Où trouve-t-on des systèmes à microprocesseur ? .......................................................5
5.
Rappels ..........................................................................................................................6
CHAPITRE 2 : ARCHITECTURE DE BASE .............................................................. 7 1.
Modèle de Von Neumann .............................................................................................7
2.
L’unité centrale .............................................................................................................7
3.
La mémoire principale..................................................................................................8
4.
Les interfaces d’entrées / sorties...................................................................................8
5.
Les bus...........................................................................................................................8
6.
Décodage d’adresses .....................................................................................................9
CHAPITRE 3 : LES MEMOIRES .............................................................................. 10 1.
Organisation d’une mémoire...................................................................................... 10
2.
Caractéristiques d’une mémoire ................................................................................ 12
3.
Différents types de mémoires ..................................................................................... 12 3.1. Les mémoires vives (RAM) .................................................................................. 12 3.1.1. Les RAM Statiques ....................................................................................... 13 3.1.2. Les RAM Dynamiques .................................................................................. 13 3.2. Les mémoires mortes ............................................................................................ 13
4.
Critères de choix d’une mémoire ............................................................................... 14
5.
Notion de hiérarchie mémoire .................................................................................... 14
CHAPITRE 4 : LE MICROPROCESSEUR ............................................................... 16
Architecture des ordinateurs
1/48
SMAI-S3
Année Universitaire : 2009/2010
1.
Architecture de base d’un microprocesseur .............................................................. 16 1.1. L’unité de Commande ........................................................................................... 17 1.2. L’unité de Traitement ............................................................................................ 17 1.3. Les registres .......................................................................................................... 19 1.4. Schéma fonctionnel ............................................................................................... 20
2.
Cycle d’exécution d’une instruction ........................................................................... 20
3.
Jeu d’instructions........................................................................................................ 22 3.1. Définition .............................................................................................................. 22 3.2. Type d’instructions ............................................................................................... 22 3.3. Codage .................................................................................................................. 23 3.4. Temps d’exécution ................................................................................................ 23
4.
Langage de programmation ....................................................................................... 23
5.
Performances d’un microprocesseur ......................................................................... 24
6.
Notion d’architecture CISC et RISC ......................................................................... 25 6.1. L’architecture CISC .............................................................................................. 25 6.1.1. Pourquoi........................................................................................................ 25 6.1.2. Comment....................................................................................................... 25 6.2. L’architecture RISC .............................................................................................. 26 6.2.1. Pourquoi........................................................................................................ 26 6.2.2. Comment....................................................................................................... 26 6.3. Comparaison ......................................................................................................... 26
7.
Amélioration de l’architecture de base ...................................................................... 27 7.1. Architecture Pipeline ............................................................................................. 27 7.1.1. Principe ......................................................................................................... 27 7.1.2. Gain de performance ..................................................................................... 29 7.2. Notion de cache mémoire ...................................................................................... 29 7.2.1. Principe ......................................................................................................... 29 7.3. Architecture superscalaire ..................................................................................... 30 7.4. Architecture pipeline et superscalaire .................................................................... 31
8.
Etude du processeur 8088 ........................................................................................... 32 8.1. Architecture externe du 8088................................................................................. 32 8.1.1. Bus de commande ......................................................................................... 33 8.1.2. Signaux de contrôle ....................................................................................... 34 8.2. Architecture interne du 8088 ................................................................................. 35 8.2.1. UIB ............................................................................................................... 35 8.2.2. UE ................................................................................................................. 35 8.3. Les registres du 8088 ............................................................................................ 36 8.3.1. Groupe de données ........................................................................................ 37 8.3.2. Groupe de pointeurs et indexes ...................................................................... 37 8.3.3. Registre IP (Instruction Pointer) .................................................................... 40 8.3.4. Registre d’état (Flag) ..................................................................................... 40 8.3.5. Les registres segment .................................................................................... 42 8.4. Gestion de la mémoire........................................................................................... 43 8.4.1. Introduction ................................................................................................... 43
Architecture des ordinateurs
2/48
SMAI-S3
8.4.2. 8.4.3.
Année Universitaire : 2009/2010
Adresse physique (segmentation de la mémoire)............................................ 44 Exemple de configuration des 4 segments de la mémoire............................... 45
CHAPITRE 5 : LES ECHANGES DE DONNEES .................................................... 46 1.
L’interface d’entrée/sortie .......................................................................................... 46 1.1. Rôle ...................................................................................................................... 46 1.2. Constitution .......................................................................................................... 46
2.
Techniques d’échange de données .............................................................................. 47 2.1. Echange programmé.............................................................................................. 47 2.1.1. Scrutation ...................................................................................................... 47 2.1.2. Interruption ................................................................................................... 47 2.2. Echange direct avec la mémoire (DMA)................................................................ 47
3.
Types de liaisons ......................................................................................................... 48 3.1. Liaison parallèle .................................................................................................... 48 3.2. Liaison série .......................................................................................................... 48
Architecture des ordinateurs
3/48
SMAI-S3
Année Universitaire : 2009/2010
Chapitre 1 : Généralités 1. Introduction
Le cours d’architecture des systèmes à microprocesseur expose les principes de base du traitement programmé de l’information.
La mise en œuvre de ces systèmes s’appuie sur 2 modes de réalisation distincts : Matériel + Logiciel.
Matériel (Hardware) = Correspond à l’aspect concret du système : Unité Centrale, Mémoires, Organes d’Entrées / Sorties, etc…
Logiciel (Software) = correspond à un ensemble d’instructions : appelé programme, qui sont contenues dans les différentes du système et qui définissent les actions effectuées par le matériel.
2. Qu’est ce qu’une architecture ?
L’architecture d’un système à microprocesseur représente l’organisation de ses différentes unités et de leurs interconnexions.
Le choix d’une architecture est toujours le résultat d’un compromis : o Entre performances et coûts, o Entre efficacités et facilités de constructions, o Etc…
3. Qu’est ce qu’un microprocesseur ?
Un microprocesseur est un circuit intégré complexe. Il résulte de l’intégration sur une puce de fonctions logiques combinatoires (logique et/ou arithmétique) et séquentielles (registres, compteurs, etc…).
Le microprocesseur est capable d’interpréter et d’exécuter les instructions d’un programme.
Un microprocesseur est le résultat d’intégration d’un ensemble de transistors sur une seule puce mémoire. Ex : Le premier microprocesseur noté le 4004, qui était une unité de calcul 4 bits fonctionnant à 108 kHz, intégrant 2300 transistors, apparue en 1947.
Architecture des ordinateurs
4/48
SMAI-S3
Année Universitaire : 2009/2010
4. Où trouve-t-on des systèmes à microprocesseur ?
Les applications des systèmes à microprocesseurs sont multiples et variées : o Ordinateur o Console de jeux o Calculatrice o Télévision o Téléphone portable o Distributeur automatique d’argent o Robotique o Lecteur carte à puce, code barre o Automobile o Instrumentation o etc…
Architecture des ordinateurs
5/48
SMAI-S3
Année Universitaire : 2009/2010
5. Rappels
Les informations traitées par un microprocesseur sont de différents types (nombres, instructions, images, vidéo, etc…) mais elles sont toujours représentées sous un format binaire.
Le binaire est représenté physiquement par 2 niveaux de tensions différents.
En binaire, une information élémentaire est appelé bit et ne peut prendre que deux valeurs différentes : 0 ou 1.
Une information plus complexe sera codée sur plusieurs Bits. On appelle cet ensemble un mot. Un mot de 8 bits est appelé un Octet. Remarque : o 1 kilobit = 210 bit = 1024 bit o 1 mégabit = 210 kbit = 1024 kbit o 1 gigabit = 210 Mbit = 1024 Mbit
Voir le complément du cours : Système de représentation des informations au TDs.
Architecture des ordinateurs
6/48
SMAI-S3
Année Universitaire : 2009/2010
Chapitre 2 : Architecture de base 1. Modèle de Von Neumann
Pour traiter une information, un microprocesseur seul ne suffit pas, il faut l’insérer au sein d’un système minimum de traitement programmé de l’information.
John Von Neumann est à l'origine d'un modèle de machine universelle de traitement programmé de l’information (1946).
Cette architecture sert de base à la plupart des systèmes à microprocesseur actuel. Elle est composée des éléments suivants : o une unité centrale o une mémoire principale o des interfaces d’entrées/sorties
Les différents organes du système sont reliés par des voies de communication appelées Bus.
Unité Centrale
Mémoire Principale
Interfaces E/S
Bus
2. L’unité centrale
Elle est composée par le microprocesseur qui est chargé d’interpréter et d’exécuter les instructions d’un programme, de lire ou de sauvegarder les résultats dans la mémoire et de communiquer avec les unités d’échange.
Toutes les activités du microprocesseur sont cadencées par une horloge.
On caractérise le microprocesseur par :
Architecture des ordinateurs
7/48
SMAI-S3
Année Universitaire : 2009/2010
o sa fréquence d’horloge : en MHz ou GHz o le nombre d’instructions par secondes qu’il est capable d’exécuter : en MIPS o la taille des données qu’il est capable de traiter : en bits
3. La mémoire principale
Elle contient les instructions du ou des programmes en cours d’exécution et les données associées à ce programme.
Physiquement, elle se décompose souvent en : o Une mémoire morte (ROM = Read Only Memory) chargée de stocker le programme. C’est une mémoire à lecture seule. o Une mémoire vive (RAM = Random Access Memory) chargée de stocker les données intermédiaires ou les résultats de calculs. On peut lire ou écrire des données dedans, ces données sont perdues à la mise hors tension.
Remarque :
Les disques durs, disquettes, CDROM, etc… sont des périphériques de stockage, et considérés comme des mémoires secondaires.
4. Les interfaces d’entrées / sorties
Elles permettent d’assurer la communication entre le microprocesseur et les périphériques. (capteur, clavier, moniteur ou afficheur, imprimante, modem, etc…).
5. Les bus
Un bus est un ensemble de fils (appelés broches) qui assure la transmission du même type d’information.
On retrouve trois types de bus véhiculant des informations en parallèle dans un système de traitement programmé de l’information : o Un bus de données : C’est un ensemble de broches qui véhiculent les instructions et les données à traités. Ce bus est bidirectionnel, le nombre de broches de ce bus correspond à la capacité de traitement du microprocesseur. Ex :
- microprocesseur de 8 bits Bus de données à 8 broches. - microprocesseur de 16 bits Bus de données à 16 broches. - microprocesseur de 32 bits Bus de données à 32 broches.
Architecture des ordinateurs
8/48
SMAI-S3
Année Universitaire : 2009/2010
o Un bus d'adresses: C’est un ensemble de broches qui permettent au microprocesseur d’adresser des différentes cases mémoires et des interfaces d’E/S. ce bus est unidirectionnel (du microprocesseur mémoire centrale ou interface d’E/S). le nombre n de broches détermine la capacité maximale d’adressage qui est égal à 2n. Ex :
- Bus d’adresses à 16 broches adresser 216 = 65536 cases mémoires = 64 KOct. - Bus d’adresses à 20 broches adresser 220 = 1 Méga Octet. - Bus d’adresses à 30 broches adresser 230 = 1 Géga Octet. - Bus d’adresses à 40 broches adresser 240 = 1 Méga Octet.
o Un bus de commande: constitué par quelques conducteurs qui assurent la synchronisation des flux d'informations sur les bus des données et des adresses.
6. Décodage d’adresses
La multiplication des périphériques autour du microprocesseur oblige la présence d’un décodeur d’adresse chargé d’aiguiller les données présentes sur le bus de données.
En effet, le microprocesseur peut communiquer avec les différentes mémoires et les différents boîtiers d’interface. Ceux-ci sont tous reliés sur le même bus de données et afin d’éviter des conflits, un seul composant doit être sélectionné à la fois.
Ainsi, on a besoin d’un décodeur d’adresses qui doit attribuer à chaque périphérique une zone d’adresses spécifique. Décodeur d’adresses
Bus d’adresses Bus de Commande
Unité Centrale
Mémoire Principale
Interfaces E/S
Bus Architecture des ordinateurs
9/48
SMAI-S3
Année Universitaire : 2009/2010
Chapitre 3 : Les mémoires
Une mémoire est un circuit intégré permettant d’enregistrer, de conserver et de restituer des informations (instructions et variables).
Les informations peuvent être écrites ou lues. Il y a écriture lorsqu'on enregistre des informations en mémoire, lecture lorsqu'on récupère des informations précédemment enregistrées.
1. Organisation d’une mémoire
Une mémoire peut être représentée comme une armoire de rangement constituée de différents tiroirs.
Chaque tiroir représente alors une case mémoire qui peut contenir un seul élément : des données.
Le nombre de cases mémoires pouvant être très élevé, il est alors nécessaire de pouvoir les identifier par un numéro.
Ce numéro est appelé adresse. Chaque donnée devient alors accessible grâce à son adresse. Adresse
Case mémoire
7 = 111 6 = 110 5 = 101 4 = 100 3 = 011 2 = 010 1 = 001 0 = 000
Architecture des ordinateurs
0001 0110
10/48
SMAI-S3
Année Universitaire : 2009/2010
Avec une adresse de n bits il est possible de référencer au plus 2n cases mémoire.
Chaque case est remplie par un mot de données (sa longueur m est toujours une puissance de 2).
Le nombre de broches du bus d’adresses d’un boîtier mémoire définit donc le nombre de cases mémoire que comprend le boîtier.
Le nombre de broches du bus de données définit la taille des données que l’on peut sauvegarder dans chaque case mémoire.
En plus du bus d’adresses et du bus de données, un boîtier mémoire comprend une entrée de commande qui permet de définir le type d’action que l’on effectue avec la mémoire (lecture/écriture) et une entrée de sélection qui permet de mettre les entrées/sorties du boîtier en haute impédance.
On peut donc schématiser un circuit mémoire par la figure suivante où l’on peut distinguer : Adresses (n bits) Mémoire
R/W IO/M
Données (m bits)
o Les entrées d’adresses o Les entrées de données o Les sorties de données o Les entrées de commandes :
Une entrée de sélection de lecture ou écriture ( R / W ).
Une entrée de sélection du circuit ( IO / M ).
Une opération de lecture ou d’écriture de la mémoire suit toujours le même cycle : 1. Sélection de l’adresse 2. Choix de l’opération à effectuer ( R / W ) 3. Sélection de la mémoire ( IO / M = 0) 4. Lecture ou écriture la donnée
Architecture des ordinateurs
11/48
SMAI-S3
Année Universitaire : 2009/2010
2. Caractéristiques d’une mémoire
La capacité : c’est le nombre total de bits que contient la mémoire. Elle s’exprime aussi souvent en octet.
Le format des données : c’est le nombre de bits que l’on peut mémoriser par case mémoire. On dit aussi que c’est la largeur du mot mémorisable.
Le temps d’accès : c’est le temps qui s'écoule entre l'instant où a été lancée une opération de lecture/écriture en mémoire et l'instant où la première information est disponible sur le bus de données.
Le temps de cycle : il représente l'intervalle minimum qui doit séparer deux demandes successives de lecture ou d'écriture.
Le débit : c’est le nombre maximum d'informations lues ou écrites par seconde.
Volatilité : elle caractérise la permanence des informations dans la mémoire. L'information stockée est volatile si elle risque d'être altérée par un défaut d'alimentation électrique et non volatile dans le cas contraire.
Exemple : Chronogramme d’un cycle de lecture Bus @
@x Données Accessibles
Bus D
Dx T accès T cycle
3. Différents types de mémoires 3.1. Les mémoires vives (RAM)
Une mémoire vive sert au stockage temporaire de données.
Elle doit avoir un temps de cycle très court pour ne pas ralentir le microprocesseur.
Architecture des ordinateurs
12/48
SMAI-S3
Année Universitaire : 2009/2010
Les mémoires vives sont en général volatiles : elles perdent leurs informations en cas de coupure d'alimentation.
Il existe deux grandes familles de mémoires RAM (Random Acces Memory : mémoire à accès aléatoire) : o Les RAM statiques o Les RAM dynamiques
3.1.1.
Les RAM Statiques
Le bit mémoire d’une RAM Statique (SRAM) contient entre 4 à 6 transistors.
Les SRAM sont non volatiles tant qu’il n’y a pas de coupure d’alimentation.
Les SRAM sont plus rapides (T accès) que les RAM Dynamiques (DRAM).
Au niveau du coût, les SRAM sont plus chers que les DRAM.
Les SRAM sont utilisées lorsque le facteur vitesse est critique, notamment pour des mémoires de petite taille comme les caches et les registres.
3.1.2.
Les RAM Dynamiques
Le bit mémoire d’une RAM Dynamique (DRAM) contient entre un seul transistor.
Cette technique permet une plus grande densité d'intégration, car un point mémoire nécessite environ quatre fois moins de transistors que dans une mémoire statique. Sa consommation s’en retrouve donc aussi très réduite.
Les DRAM sont moins chers que les SRAM.
Les DRAM doivent être rafraîchies régulièrement pour entretenir la mémorisation : l’information dans le transistor est perdue si on ne la régénère pas périodiquement. Donc toute lecture doit être suivie d’une réécriture.
Ce rafraîchissement indispensable a plusieurs conséquences : o Gestion compliquée des DRAM. o Temps d’accès plus important.
En général les DRAM, qui offrent une plus grande densité d'information et un coût par bit plus faible, sont utilisées pour la mémoire centrale.
3.2. Les mémoires mortes
Pour certaines applications, il est nécessaire de pouvoir conserver des informations de façon permanente même lorsque l'alimentation électrique est interrompue.
Architecture des ordinateurs
13/48
SMAI-S3
Année Universitaire : 2009/2010
On utilise alors des mémoires mortes ou mémoires à lecture seule (ROM : Read Only Memory). Ces mémoires sont non volatiles.
L’inscription en mémoire des données restent possible mais est appelée programmation.
Suivant le type de ROM, la méthode de programmation changera. Il existe donc plusieurs types de ROM : o
ROM : Elle est programmée par le fabricant et son contenu ne peut plus être ni modifié, ni effacé par l'utilisateur.
o PROM : C’est une ROM qui peut être programmée une seule fois par l'utilisateur (Programmable ROM). La programmation est réalisée à partir d’un programmateur spécifique o EPROM : Pour faciliter la mise au point d'un programme ou tout simplement permettre une erreur de programmation, il est intéressant de pouvoir reprogrammer une PROM. L'EPROM (Erasable Programmable ROM) est une PROM qui peut être effacée. o FLASH EPROM : est une mémoire programmable et effaçable électriquement. Elle répond ainsi à l’inconvénient principal de l’EPROM (Impossible de sélectionner une seule cellule à effacer) et peut être reprogrammée in situ (mot par mot).
4. Critères de choix d’une mémoire
Les principaux critères à retenir sont : o Capacité o Vitesse o Consommation o Coût
5. Notion de hiérarchie mémoire Une mémoire idéale serait une mémoire de grande capacité, capable de stocker un maximum d’informations et possédant un temps d’accès très faible afin de pouvoir travailler rapidement sur ces informations. Mais il se trouve que les mémoires de grande capacité sont souvent très lentes et que les mémoires rapides sont très chères. Et pourtant, la vitesse d’accès à la mémoire conditionne dans une large mesure les performances d’un système. En effet, c’est là Architecture des ordinateurs
14/48
SMAI-S3
Année Universitaire : 2009/2010
que se trouve le goulot d’étranglement entre un microprocesseur capable de traiter des informations très rapidement et une mémoire beaucoup plus lente (ex : processeur actuel à 3Ghz et mémoire à 400MHz). Or, on n’a jamais besoin de toutes les informations au même moment. Afin d’obtenir le meilleur compromis coût - performance, on définie donc une hiérarchie mémoire. On utilise des mémoires de faible capacité mais très rapide pour stocker les informations dont le microprocesseur se sert le plus et on utilise des mémoires de capacité importante mais beaucoup plus lente pour stocker les informations dont le microprocesseur se sert le moins. Ainsi, plus on s’éloigne du microprocesseur et plus la capacité et le temps d’accès des mémoires vont augmenter. + 1 ns
< 400 oct
Registres Vitesse
5 ns
10 ns
Mémoire cache Mémoire principale Mémoire d’appui
5 ms
Mémoire de masse
8Ko à 4Mo
Capacité
Jusqu’à 1Go
2 à 4 Go
200Go
+
Les registres sont les éléments de mémoire les plus rapides. Ils sont situés au niveau du processeur et servent au stockage des opérandes et des résultats intermédiaires.
La mémoire cache est une mémoire rapide de faible capacité destinée à accélérer l’accès à la mémoire centrale en stockant les données les plus utilisées.
La mémoire principale est l’organe principal de rangement des informations. Elle contient les programmes (instructions et données) et est plus lente que les deux mémoires précédentes.
La mémoire d’appui sert de mémoire intermédiaire entre la mémoire centrale et les mémoires de masse. Elle joue le même rôle que la mémoire cache.
La mémoire de masse est une mémoire périphérique de grande capacité utilisée pour le stockage permanent ou la sauvegarde des informations. Elle utilise pour cela des supports magnétiques (disque dur) ou optiques (CDROM, DVDROM).
Architecture des ordinateurs
15/48
SMAI-S3
Année Universitaire : 2009/2010
Chapitre 4 : Le microprocesseur
Un microprocesseur est un circuit intégré complexe caractérisé par une très grande intégration et doté des facultés d'interprétation et d'exécution des instructions d'un programme.
Il est chargé d’organiser les tâches précisées par le programme et d’assurer leur exécution.
1. Architecture de base d’un microprocesseur
Un microprocesseur est construit autour de deux éléments principaux : o Une unité de commande. o Une unité de traitement.
Ces unités sont associées à des registres chargés de stocker les différentes informations à traiter.
Ces trois éléments sont reliés entre eux par des bus interne (Adresses, Données et Commande) permettant les échanges d’informations.
Bus d’adresses @
Programmes Unité de Traitement
Unité de Commande Données
D Bus de données
Architecture des ordinateurs
16/48
SMAI-S3
Année Universitaire : 2009/2010
Remarque :
Il existe deux types de registres : o Les registres d'usage général permettent à l'unité de traitement de manipuler des données à vitesse élevée. Ils sont connectés au bus de données interne au microprocesseur. o Les registres d'adresses (pointeurs) connectés sur le bus adresses.
1.1. L’unité de Commande Elle permet de séquencer le déroulement des instructions : elle effectue la recherche en mémoire de l'instruction. Comme chaque instruction est codée sous forme binaire elle en assure le décodage pour enfin réaliser son exécution puis effectue la préparation de l'instruction suivante. Pour cela, elle est composée par :
Le compteur de programme constitué par un registre dont le contenu est initialisé avec l'adresse de la première instruction du programme. Il contient toujours l’adresse de l’instruction à exécuter.
Le registre d'instruction et le décodeur d'instruction : chacune des instructions à exécuter est rangée dans le registre instruction puis est décodée par le décodeur d’instruction.
Bloc logique de commande (ou séquenceur) : Il organise l'exécution des instructions au rythme d’une horloge. Il élabore tous les signaux de synchronisation internes ou externes (bus de commande) du microprocesseur en fonction des divers signaux de commande provenant du décodeur d’instruction ou du registre d’état par exemple. Il s'agit d'un automate réalisé soit de façon câblée (obsolète), soit de façon microprogrammée, on parle alors de microprocesseur.
1.2. L’unité de Traitement
C’est le coeur du microprocesseur. Elle regroupe les circuits qui assurent les traitements nécessaires à l'exécution des instructions. Cette unité est composée de : o L’Unité Arithmétique et Logique (UAL) est un circuit complexe qui assure les fonctions logiques (ET, OU, Ou exclusif, etc…) ou arithmétique (Addition, soustraction, multiplication).
Architecture des ordinateurs
17/48
SMAI-S3
Année Universitaire : 2009/2010
Table logique de ET (produit) A
B
A ET B (noté A .B)
0
0
0
0
1
0
1
0
0
1
1
1
Table logique de OU (Somme) A
B
A OU B (noté A +B)
0
0
0
0
1
1
1
0
1
1
1
1
Table logique de Ou exclusif A
B
A OU Exclusif B (noté A B )
0
0
0
0
1
1
1
0
1
1
1
0
o Le registre d’état : ce registre est directement relié à l’UAL, il stocke certaines informations particulières concernant les opérations effectuées par l’UAL. Ce registre est généralement composé de 8 bits ou 16 bits, quelques bits de ce registre (connu sous le nom d’indicateurs d’états).
Bit ou Indicateur de retenue (CF) : – CF = 1, il y a un retenu à la fin d’une opération d’addition ou soustraction. – CF = 0, dans le cas contraire (pas de retenu). Exemple : Addition de 2 données sur 8 bits.
11111111 00000001 , CF = 1 00000000
00001000 00010000 , CF = 0 00011000
Bit ou Indicateur de zéro (CZ) : – CZ = 1, résultat d’une opération est nul.
Architecture des ordinateurs
18/48
SMAI-S3
Année Universitaire : 2009/2010
– CZ = 0, dans le cas contraire (résultat non nul). Exemple : Addition de 2 données sur 8 bits.
11111111 00000001 , CF = 1 et CZ = 1 00000000
00001000 00010000 , CF = 0 et CZ = 0 00011000
Bit ou Indicateur de signe (CS) : – CS = 1, le bit le plus significatif du résultat d’une opération est à 1 (le résultat est négatif car le résultat est codé en complément à 2). – CS = 0, le bit le plus significatif du résultat d’une opération est à 0 (le résultat est positif). Exemple : Addition de 2 données sur 8 bits.
11111111 00000001 , CS = 0 00000000
01001000 01010110 , CS = 1 10011110
Bit ou Indicateur de débordement (OV) : – OV = 1, dépassement de capacité de codage. – OV = 0, pas de dépassement de codage. Exemple : Addition des 2 données -64 et -65 sur 8 bits codées en complément à 2 (cà2).
11000000 10111111 , CF = 1, CZ = 0, CS = 0 et OV = 1 01111111 o Les accumulateurs sont des registres de travail qui servent à stocker un opérande au début d'une opération arithmétique et le résultat à la fin de l'opération.
1.3. Les registres
Un registre est un ensemble de bits qui permet de stocker une information binaire dans un microprocesseur. Cette information peut être une instruction, une donnée a traitée, ou une adresse d’une instruction. Il existe 6 registres fondamentaux qu’on trouve dans chaque microprocesseur :
Compteur ordinale ou compteur de programme (CP) de l’unité de commande.
Architecture des ordinateurs
19/48
SMAI-S3
Année Universitaire : 2009/2010
Registre d’instructions de l’unité de commande.
Registre d’état de l’unité de traitement.
L’accumulateur de l’unité de traitement.
Registre d’adresse : ce registre est directement relié au compteur de programme (CP), il représente une interface entre le compteur de programme et le bus d’adresse (voir figure du schéma fonctionnel).
Registre de données : il représente une interface entre le bus de données et l’UAL (voir figure du schéma fonctionnel), ce registre continent les données a traitées par l’UAL.
1.4. Schéma fonctionnel Bus d’adresses
Registre d’@
Acc Programmes
Registre d’état
PC
UAL
Bloc logique de commande
Registre d’instruction Registre
Bus Commande Données
Décodeur d’instructio ns Horlog
Bus de données
2. Cycle d’exécution d’une instruction
Le traitement d’une instruction peut être décomposé en trois phases : o Phase 1: Recherche de l'instruction à traiter. 1. Le Compteur de Programmes PC contient l'adresse de l'instruction suivante du programme. Cette valeur est placée sur le bus d'adresses par l'unité de commande qui émet un ordre de lecture. 2. Au bout d'un certain temps (temps d'accès à la mémoire), le contenu de la case mémoire sélectionnée est disponible sur le bus des données. 3. L'instruction est stockée dans le registre d’instruction du processeur.
Architecture des ordinateurs
20/48
SMAI-S3
Année Universitaire : 2009/2010
Microprocesseur 1 PC
Mémoire
$2000 @ $2000
RI
Instr 1
2 3
$2000
Instr 1
$2001
Opér 1
$2002
Instr 2
$2003
Instr 3
$2004
. . .
Décodeur d’Instruction
Instr1
$FFF
o Phase 2: Décodage de l’instruction et recherche de l’opérande. Le registre d'instruction contient maintenant le premier mot de l'instruction qui peut être codée sur plusieurs mots. Ce premier mot contient le code opératoire qui définit la nature de l'opération à effectuer (addition, rotation,...) et le nombre de mots de l'instruction. 1. L'unité de commande transforme l'instruction en une suite de commandes élémentaires nécessaires au traitement de l'instruction. 2. Si l'instruction nécessite une donnée en provenance de la mémoire, l'unité de commande récupère sa valeur sur le bus de données. 3. L’opérande est stocké dans un registre.
Microprocesseur Bloc logique de commande
PC
RI
$2000
Instr 1
2 Mémoire @ $2001
Décodeur d’Instruction
1
$2000
Instr 1
$2001
Opér 1
$2002
Instr 2
$2003
Instr 3
$2004
. . .
UAL
Opér 2
Opér 1
3 Instr1
Architecture des ordinateurs
$FFF
21/48
SMAI-S3
Année Universitaire : 2009/2010
o Phase 3: Exécution de l’instruction. 1. Le micro-programme réalisant l'instruction est exécuté. 2. Les drapeaux sont positionnés (registre d'état). 3. L'unité de commande positionne le PC pour l'instruction suivante.
Microprocesseur 3 Bloc logique de commande
PC
$2002
RI
Instr 1
Décodeur d’Instruction
Mémoire $2000
Instr 1
$2001
Opér 1
$2002
Instr 2
$2003
Instr 3
$2004 UAL
1 Résult
. . .
CF=0, CZ=1, … Opér 1
2 $FFF
3. Jeu d’instructions 3.1. Définition
Le jeu d’instructions décrit l’ensemble des opérations élémentaires que le microprocesseur pourra exécuter.
Il représente l’aspect programmable du microprocesseur : c’est de faire fonctionner le microprocesseur dans le déroulement de l’application à exécuter.
Ce jeu d’instruction doit respecter une certaine syntaxe, appelée syntaxe du langage de programmation : Langage Assembleur.
3.2. Type d’instructions
Les instructions que l’on retrouve dans chaque microprocesseur peuvent être classées en 4 groupes : o Transfert de données pour charger ou sauver en mémoire, effectuer des transferts de registre à registre, etc… o Opérations arithmétiques : addition, soustraction, division, multiplication
Architecture des ordinateurs
22/48
SMAI-S3
Année Universitaire : 2009/2010
o Opérations logiques : ET, OU, NON, NAND, comparaison, test, etc… o Contrôle de séquence : branchement, test, etc…
3.3. Codage
Les instructions et leurs opérandes (paramètres) sont stockés en mémoire principale. La taille totale d’une instruction (nombre de bits nécessaires pour la représenter en mémoire) dépend du type d’instruction et aussi du type d’opérande. Chaque instruction est toujours codée sur un nombre entier d’octets afin de faciliter son décodage par le processeur. Une instruction est composée de deux champs : o Le code instruction, qui indique au processeur quelle instruction réaliser o Le champ opérande qui contient la donnée, ou la référence à une donnée en mémoire (son adresse). Exemple : Code Instruction Code Opérande 10010011
00111110
Le nombre d'instructions du jeu d'instructions est directement lié au format du code instruction. Ainsi un octet permet de distinguer au maximum 256 instructions différentes.
3.4. Temps d’exécution
Chaque instruction nécessite un certain nombre de cycles d’horloges pour s’effectuer.
Le nombre de cycles dépend de la complexité de l’instruction.
Il est plus long d’accéder à la mémoire principale qu’à un registre du processeur.
La durée d’un cycle dépend de la fréquence d’horloge du séquenceur.
4. Langage de programmation
Le langage machine est le langage compris par le microprocesseur. Ce langage est difficile à maîtriser puisque chaque instruction est codée par une séquence propre de bits. Afin de faciliter la tâche du programmeur, on a créé différents langages plus ou moins évolués.
Le langage assembleur est le langage le plus « proche » du langage machine. Il est composé par des instructions en général assez rudimentaires que l’on appelle des
Architecture des ordinateurs
23/48
SMAI-S3
Année Universitaire : 2009/2010
mnémoniques. Ce sont essentiellement des opérations de transfert de données entre les registres et l'extérieur du microprocesseur (mémoire ou périphérique), ou des opérations arithmétiques ou logiques. Chaque instruction représente un code machine différent. Chaque microprocesseur peut posséder un assembleur différent.
La difficulté de mise en oeuvre de ce type de langage, et leur forte dépendance avec la machine a nécessité la conception de langages de haut niveau, plus adaptés à l'homme, et aux applications qu'il cherchait à développer. Faisant abstraction de toute architecture de machine, ces langages permettent l'expression d'algorithmes sous une forme plus facile à apprendre, et à dominer (C, Pascal, Java, etc…). Chaque instruction en langage de haut niveau correspondra à une succession d’instructions en langage assembleur. Une fois développé, le programme en langage de haut niveau n’est donc pas compréhensible par le microprocesseur. Il faut le compiler pour le traduire en assembleur puis l’assembler pour le convertir en code machine compréhensible par le microprocesseur. Ces opérations sont réalisées à partir de logiciels spécialisés appelés compilateur et assembleur.
Langage Haut niveau (for, if…then, write, etc…) Compilation
Langage Assembleur (cmp, add, mov, etc…) Assemblage
Langage Machine (00011100, 11010011, etc…)
5. Performances d’un microprocesseur
On peut caractériser la puissance d’un microprocesseur par le nombre d’instructions qu’il est capable de traiter par seconde. Pour cela, on définit : o Le CPI (Cycle Par Instruction) qui représente le nombre moyen de cycles d’horloge
nécessaire
pour
l’exécution
d’une
instruction
pour
un
microprocesseur donné.
Architecture des ordinateurs
24/48
SMAI-S3
Année Universitaire : 2009/2010
o Le MIPS (Millions d'Instructions Par Seconde) qui représente la puissance de traitement du microprocesseur : MIPS
FH , avec FH en MHz CPI
Pour augmenter les performances d’un microprocesseur, on peut donc soit augmenter la fréquence d'horloge (limitation matérielle), soit diminuer le CPI (choix d'un jeu d'instruction adapté).
6. Notion d’architecture CISC et RISC
Actuellement l’architecture des microprocesseurs se compose de deux grandes familles : o L’architecture CISC (Complex Instruction Set Computer) o L’architecture RISC (Reduced Instruction Set Computer)
6.1. L’architecture CISC 6.1.1.
Pourquoi CISC est l’architecture la plus ancienne, était la seule envisageable pour les machines à microprocesseur.
En effet, vue que la mémoire travaillait très lentement par rapport au processeur, on pensait qu’il était plus intéressant de soumettre au microprocesseur des instructions complexes.
Ainsi, plutôt que de coder une opération complexe par plusieurs instructions plus petites (qui demanderaient autant d’accès mémoire très lent).
Il semblait préférable d’ajouter au jeu d’instructions du microprocesseur une instruction complexe qui se chargerait de réaliser cette opération.
On a donc eu tendance à incorporer au niveau processeur des instructions plus proches de la structure de ces langages.
6.1.2.
Comment C’est donc une architecture avec un grand nombre d’instructions où le microprocesseur doit exécuter des tâches complexes par instruction unique.
Architecture des ordinateurs
25/48
SMAI-S3
Année Universitaire : 2009/2010
Pour une tâche donnée, une machine CISC exécute ainsi un petit nombre d’instructions mais chacune nécessite un plus grand nombre de cycles d’horloge.
Le code machine de ces instructions varie d’une instruction à l’autre et nécessite donc un décodeur complexe (micro-code).
6.2. L’architecture RISC 6.2.1.
Pourquoi Des études statistiques menées au cours des années 70 ont clairement montré que les programmes générés par les compilateurs se contentaient le plus souvent d'affectations, d'additions et de multiplications par des constantes.
Ainsi, 80% des traitements des langages de haut niveau faisaient appel à seulement 20% des instructions du microprocesseur.
D’où l’idée de réduire le jeu d’instructions à celles le plus couramment utilisées et d’en améliorer la vitesse de traitement.
6.2.2.
Comment C’est donc une architecture dans laquelle les instructions sont en nombre réduit (chargement, branchement, appel sous-programme).
Les architectures RISC peuvent donc être réalisées à partir de séquenceur câblé. Leur réalisation libère de la surface permettant d’augmenter le nombre de registres ou d’unités de traitement par exemple.
Chacune de ces instructions s’exécutent ainsi en un cycle d’horloge.
Les accès à la mémoire s’effectuent seulement à partir de deux instructions (Load et Store). Par contre, les instructions complexes doivent être réalisées à partir de séquences basées sur les instructions élémentaires, ce qui nécessite un compilateur très évolué dans le cas de programmation en langage de haut niveau.
6.3. Comparaison Le choix dépendra des applications visées. En effet, si on diminue le nombre d'instructions, on crée des instructions complexes (CISC) qui nécessitent plus de cycles pour être décodées et si on diminue le nombre de cycles par instruction, on crée des instructions simples (RISC) mais on augmente alors le nombre d'instructions nécessaires pour réaliser le même traitement.
Architecture des ordinateurs
26/48
SMAI-S3
Année Universitaire : 2009/2010
Architecture RISC
Architecture CISC
Instructions simples ne prenant qu’un seul
Instructions complexes prenant plusieurs
cycle machine.
cycles machines.
Décodeur simple.
Décodeur complexe (microcode).
Beaucoup de registres.
Peu de registres.
Seules les instructions LOAD et STORE
Toutes les instructions sont susceptibles
ont accès à la mémoire.
d’accéder à la mémoire.
Compilateur complexe.
Compilateur simple.
7. Amélioration de l’architecture de base
L'ensemble des améliorations des microprocesseurs visent à diminuer le temps d'exécution du programme : 1. La première idée qui vient à l’esprit est d’augmenter tout simplement la fréquence de l’horloge du microprocesseur. Mais l’accélération des fréquences provoque un surcroît de consommation ce qui entraîne une élévation de température. On est alors amené à équiper les processeurs de systèmes de refroidissement ou à diminuer la tension d’alimentation. 2. Une autre possibilité d’augmenter la puissance de traitement d’un microprocesseur est de diminuer le nombre moyen de cycles d’horloge nécessaire à l’exécution d’une instruction : o Dans le cas d’une programmation en langage de haut niveau, cette amélioration peut se faire en optimisant le compilateur. Il faut qu’il soit capable de sélectionner les séquences d’instructions minimisant le nombre moyen de cycles par instructions. o Une autre solution est d’utiliser une architecture de microprocesseur qui réduise le nombre de cycles par instruction.
7.1. Architecture Pipeline 7.1.1.
Principe L’exécution d’une instruction est décomposée en une succession d’étapes et chaque étape correspond à l’utilisation d’une des fonctions du microprocesseur. Lorsqu’une
Architecture des ordinateurs
27/48
SMAI-S3
Année Universitaire : 2009/2010
instruction se trouve dans l’une des étapes, les composants associés aux autres étapes ne sont pas utilisés. Le fonctionnement d’un microprocesseur simple n’est donc pas efficace.
L’architecture pipeline permet d’améliorer l’efficacité du microprocesseur. En effet, lorsque la première étape de l’exécution d’une instruction est achevée, l’instruction entre dans la seconde étape de son exécution et la première phase de l’exécution de l’instruction suivante débute.
Il peut donc y avoir une instruction en cours d’exécution dans chacune des étapes et chacun des composants du microprocesseur peut être utilisé à chaque cycle d’horloge.
Une machine pipeline se caractérise par le nombre d’étapes utilisées pour l’exécution d’une instruction, on appelle aussi ce nombre d’étapes le nombre d’étages du pipeline.
Exemple d’une exécution en 4 phases :
Recherche
Décodage
Exécution
Sauv. Résultat
Modèle classique : R1
R2 D1
R3 D2
E1
D3 E2
S1
1
2
3
E3 S2
S3
4
5
6
7
8
9
10
11
12
Nbre de cycles
Modèle pipeliné : R1
1
R2
R3
R4
R5
R6
R7
R8
R9
D1
D2
D3
D4
D5
D6
D7
D8
D9
E1
E2
E3
E4
E5
E6
E7
E8
E9
S1
S2
S3
S4
S5
S6
S7
S8
2
3
4
Architecture des ordinateurs
5
6
7
8
9
10
11
S9
12
Nbre de cycles
28/48
SMAI-S3
7.1.2.
Année Universitaire : 2009/2010
Gain de performance Dans cette structure, la machine débute l’exécution d’une instruction à chaque cycle et le pipeline est pleinement occupé à partir du quatrième cycle.
Le gain obtenu dépend donc du nombre d’étages du pipeline.
En effet, pour exécuter n instructions, en supposant que chaque instruction s’exécute en k cycles d’horloge, il faut : o n.k cycles d’horloge pour une exécution séquentielle. o k cycles d’horloge pour exécuter la première instruction puis n-1 cycles pour les n-1 instructions suivantes si on utilise un pipeline de k étages. Donc lorsque le nombre n d’instructions à exécuter est grand par rapport à k, on peut admettre qu’on divise le temps d’exécution par k.
Exemples :
Les Pentium 2, 3 et 4 d’Intel comprennent respectivement un pipeline de 10, 12 et 20 étages.
7.2. Notion de cache mémoire 7.2.1.
Principe Depuis le début des années 80, une des solutions utilisées pour masquer cette latence est de disposer une mémoire très rapide entre le microprocesseur et la mémoire. Elle est appelée cache mémoire.
On compense ainsi la faible vitesse relative de la mémoire en permettant au microprocesseur d’acquérir les données à sa vitesse propre.
Au départ cette mémoire était intégrée en dehors du microprocesseur mais elle fait maintenant partie intégrante du microprocesseur.
Le principe de cache est très simple : le microprocesseur n’a pas conscience de sa présence et lui envoie toutes ses requêtes comme s’il agissait de la mémoire principale: o Soit la donnée ou l’instruction requise est présente dans le cache et elle est alors envoyée directement au microprocesseur. On parle de succès de cache. (a)
Architecture des ordinateurs
29/48
SMAI-S3
Année Universitaire : 2009/2010
o Soit la donnée ou l’instruction n’est pas dans le cache, et le contrôleur de cache envoie alors une requête à la mémoire principale. Une fois l’information récupérée, il la renvoie au microprocesseur tout en la stockant dans le cache. On parle de défaut de cache. (b) a) Microprocesseur
Mémoire 1
Unité de traitement
Unité de commande
Cache
2
b) Microprocesseur
Mémoire 2
1
Unité de traitement
Unité de commande
Cache
3
4
7.3. Architecture superscalaire
Une autre façon de gagner en performance est d’exécuter plusieurs instructions en même temps.
L'approche superscalaire consiste à doter le microprocesseur de plusieurs unités de traitement travaillant en parallèle.
Les instructions sont alors réparties entre les différentes unités d'exécution.
Architecture scalaire : I1
I2
I3
I4
I5
I6
I7
I8
Unité de traitement
N cycles
Architecture des ordinateurs
30/48
SMAI-S3
Année Universitaire : 2009/2010
Architecture superscalaire : I1 I2
I5
I7 I3
Unité de traitement 1
I8 I4
I6
Unité de traitement 2
N/2 cycles
Remarque : C'est le type d'architecture mise en oeuvre dans les premiers Pentium d'Intel apparus en 1993.
7.4. Architecture pipeline et superscalaire
Le principe est d’exécuté les instructions de façon pipelinée dans chacune des unités de traitement travaillant en parallèle.
UT1
Recherche
Décodage
Exécution
Sauv. Résultat
UT2
Recherche
Décodage
Exécution
Sauv. Résultat
1
Architecture des ordinateurs
11
Nbre de cycles
31/48
SMAI-S3
Année Universitaire : 2009/2010
8. Etude du processeur 8088
Le processeur 8086 d'Intel est à la base des processeurs Pentium actuels. Les processeurs successifs (de PC) se sont en effet construits petit à petit en ajoutant à chaque processeurs des instructions et des fonctionnalités supplémentaires, mais en conservant à chaque fois les spécificités du processeur précédent.
8.1. Architecture externe du 8088
A13 A12 A11 A10 A9 A8
A14 A15 A16 A17 A18 A19
Bus de commande AD7
Signaux de contrôle AD0
Horloge
Alimentation
Masse
Nombre de broches : 40.
Bus de données de AD0 à AD7 : 8 broches.
Bus d’adresses de AD0 à AD7 et de A8 à A19 : 20 broches. (AD0 à AD7 représente à la fois le bus de données et une partie du bus d’adresses).
Capacité de la mémoire centrale adressable est : 2 20bit = 1 MegaOctet.
L’adresse d’un mot mémoire est sur 5 bits : de 00000 H à FFFFF H.
Architecture des ordinateurs
32/48
SMAI-S3
8.1.1.
Année Universitaire : 2009/2010
Bus de commande
RD WR IO / M ALE READY
8088
Bus de commande
RD : Broche de lecture mémoire ou interface. Si RD 0 le microprocesseur effectue une lecture de données à partir de la mémoire ou d’une interface d’E/S.
WR : Broche d’écriture.
Si
WR 1 le microprocesseur effectue une écriture dans la mémoire ou dans
l’interface d’E/S.
IO / M : Broche de sélection. o Si IO / M 1 c’est la mémoire qui est sélectionnée pour une lecture ou une écriture. o Si IO / M 0 c’est l’interface qui est sélectionnée pour une lecture ou une écriture.
Remarque :
RD
WR
IO / M
0
0
0
Lecture d’une interface d’E/S.
1
1
0
Ecriture dans une interface d’E/S.
0
0
1
Lecture de la mémoire.
1
1
1
Ecriture dans la mémoire.
Opération
ALE : validité du bus d’adresse AD0 à AD7. o Si ALE = 1, AD0 à AD7 représente l’octet faible d’une adresse : AD0 à AD7 et A8 à AD19 (20 broches). o Si ALE = 0, AD0 à AD7 représente le bus de données.
Architecture des ordinateurs
33/48
SMAI-S3
Année Universitaire : 2009/2010
READY : Broche de synchronisation. o Si READY = 1, la mémoire ou l’interface d’E/S est prête à recevoir des informations où à fournir des informations au microprocesseur. o Si READY = 0, mémoire où interface d’E/S non prête pour le dialogue.
8.1.2.
Signaux de contrôle
INTR NMI
8088
Quelques signaux de contrôle
INTA Hold HOLDA
INTR : Interruption masquable (considérée ou non par le microprocesseur). o Si INTR = 1, une interruption est demandée. Remarque : au niveau du registre d’état, il y a un bit appelé IF. Il est utilisé pour accepter l’interruption demandée.
Si IF = 1, l’interruption sera prise en compte par le microprocesseur saut au sous programme de dialogue : microproc – Interface d’E/S.
Si
IF = 0, l’interruption ne sera pas prise en compte par le
microprocesseur pas de saut au sous programme de dialogue : microproc – Interface d’E/S. Si INTR est acceptée INTR = 1 et IF = 1.
INTA : Broche de réponse
o Si INTA = 0, pour informer l’interface d’E/S que l’interruption demandée a été acceptée.
8088
INTR
Interface D’E/S
Périphérique externe
INTA
Architecture des ordinateurs
34/48
SMAI-S3
Année Universitaire : 2009/2010
NMI : Broche d’interruption non masquable. o Si NMI = 1, saut obligatoire à un sous programme de dialogue avec l’interface d’E/S qui a générée l’interruption NMI.
HOLD : Broche de demande des bus de données, d’adresses et de commande. o Si HOLD = 0, les bus de données, d’adresses et de commande effectuent la liaison entre le microprocesseur et la mémoire. Echange d’information entre le microprocesseur et la mémoire. o Si HOLD = 1, le contrôleur du disque dur demande les bus de données, d’adresses et de commande (liaison entre le contrôleur et la mémoire). Echange d’information entre le contrôleur et la mémoire. Utilisation : dans le cas d’un transfert d’une grande quantité d’informations entre une interface d’E/S et la mémoire. Ceci pour augmenter la vitesse de transfert d’informations.
HOLDA : Broche de réponse à HOLD. o Si HOLDA = 1, le microprocesseur informe l’interface qu’il est déconnecté de ses bus. Elle pourra faire l’échange d’informations avec la mémoire.
8.2. Architecture interne du 8088
Il existe deux unités internes distinctes: l'UE (Unité d'Exécution) et l'UIB (Unité d'Interfaçage avec le Bus).
8.2.1.
UIB Elle est constituée d’un ensemble de registres d’adressage, d’un générateur d’adresse (compteur ordinal) et d’une file d’attente (registre d’instruction), son rôle est de chercher séquentiellement les instructions et les données stockées dans la mémoire.
8.2.2.
UE Elle est destinée au traitement de données, elle se compose essentiellement d’une UAL, d’une unité de commande et des registres opérationnels et d’adressage. Son rôle est de lire les instructions stockées dans la file d’attente pour décodage et d’exécution.
Architecture des ordinateurs
35/48
SMAI-S3
Année Universitaire : 2009/2010
8.3. Les registres du 8088
Un registre est une petite partie de mémoire intégrée au microprocesseur, dans le but de recevoir des informations spécifiques, notamment des adresses et des données stockées durant l'exécution d'un programme.
Les registres peuvent être utilisés dans toutes les opérations arithmétiques et logiques que le programmeur insère dans le code assembleur.
Un registre complet présente une grandeur de 16 bits.
chaque registre est en réalité divisé en deux registres distincts de 8 bits.
De cette façon, nous pouvons utiliser une partie du registre si nous désirons y stocker une valeur n'excédant pas 8 bits.
Si, au contraire, la valeur que nous désirons y ranger excède 8 bits, nous utiliserons le registre complet, c'est à dire 16 bits.
Le programmeur dispose de 8 registres internes de 16 bits qu'on peut diviser en deux groupes : o Groupe de données : formé par 4 registres de 16 bits (AX, BX, CX, et DX) chaque registre peut être divisé en deux registres de 8 bits (AH, AL, BH, BL, CH, CL, DH et DL). 15
8 7
0
AX
AH
AL
BX
BH
BL
CX
CH
CL
DX
DH
DL
o Groupe de pointeur et indexe : formé de 4 registres de 16 bits (SI, DI, SP, BP) et font généralement référence à un emplacement en mémoire. 15
0
Stack Pointer
SP
Base Pointer
BP
Source Index
SI
Destination Index
DI
Architecture des ordinateurs
36/48
SMAI-S3
8.3.1.
Année Universitaire : 2009/2010
Groupe de données
Registre AX : (Accumulateur)
Toutes les opérations de transferts de données avec les entrées-sorties ainsi que le traitement des chaînes de caractères se font dans ce registre, de même les opérations arithmétiques et logiques.
Registre BX : (Registre de Base)
Il contient une adresse de décalage par rapport à une adresse de référence. Par exemple, l'adresse de début d'un tableau.
Registre CX : (Le Compteur)
Lors de l'exécution d'une boucle on a souvent recours à un compteur de boucles pour compter le nombre d'itérations, le registre CX a été fait pour servir comme compteur lors des instructions de boucle.
Registre DX
On utilise le registre DX pour les opérations de multiplication et de division mais surtout pour contenir le numéro d'un port d'entrée/sortie pour adresser les interfaces d'E/S.
8.3.2.
Groupe de pointeurs et indexes Ces registres sont plus spécialement adaptés au traitement des éléments dans la mémoire. Ils sont en général munis de propriétés d'incrémentation et de décrémentation.
Registre SP : pointeur sommet de la pile (Stach Pointer)
Une pile est un ensemble de cases mémoire définie dans une RAM pour stocker temporairement les données d’un programme et les contenues des registres interne du microprocesseur. Elle est utilisée dans le cas d’une rupture de séquence d’un programme, saut à un sous programme ou appel à une procédure.
Si on n’effectue pas l’empilement des registres interne (AX, BX, CX et DX) utilisés par un programme, leurs contenues peuvent être détruits par les instructions du sous programme ou de la procédure appelée.
Le registre SP (Pointeur de Pile) à une longueur de 16 bits, il permet l’adressage des cases mémoire de la pile. Il pointe toujours sur la première case mémoire libre de la pile.
La pile a une structure LIFO (Last In First Out), dernier entré premier sortie, ainsi :
Architecture des ordinateurs
37/48
SMAI-S3
Année Universitaire : 2009/2010
o Lors d’un empilement du contenu d’un registre interne, le contenu du registre SP est décrémenté par 2 (SP=SP-2). o Lors du dépilement, le contenu du registre SP est incrémenté par 2 (SP=SP+2). Exemple : RAM Programme Principal …….. Instructions utilisant les registres AX, BX, CX et DX ………. Empilement du contenu de AX, BX, CX et DX Saut à un sousprogramme
Instructions du sousprogramme utilisant les registres AX, BX, CX et DX
Dépilement du contenu de AX, BX, CX et DX
Empilement (Sauvegarde)
…….. Instructions suite du programme principal ……….
RAM
AX
AL
BX
AH
CX
BL
DX
…. …. ….
Dépilement (Chargement)
DH
Pile RAM Sommet de la pile (1ère case mémoire libre) FF4B
Empilement Dépilement AX
11
FF4C
01
FF4D
01
11
01
FF4E
AH
AL
0E
FF4F
SP = FF4B Après empilement et avant dépilement
SP = FF4D Après dépilement de AX
FF50
Architecture des ordinateurs
38/48
SMAI-S3
Année Universitaire : 2009/2010
Registre BP : pointeur base de la pile (Base Pointer)
C’est un registre de 16 bits qui permet l’adressage de la 1 ère case mémoire de la pile (libre ou non).
SP = BP, dans le cas d’une pile vide.
BP reste constant durant l’exécution d’un programme.
Registres SI et DI : ( SI : Source Indexe, DI : Destination Indexe)
A partir d’une adresse de base associée à un bloc de données (tableau, chaîne de caractères, …) (l’adresse de base correspond à la 1ère adresse de stockage), les registres SI et DI permettent l’adressage séquentiel des données de ce bloc.
Adresse d’une données du bloc = Adresse associée au bloc + contenu du registre SI ou DI.
Ces registres ont une taille de 16 bits chacun.
Exemple : RAM Adresse associée au bloc 1000H 1001H Bloc de données
1100H
o Adresse du 1 er élément du bloc de données (SI = 0 ou DI = 0) = 1000H + SI (ou DI) = 1000H Puis, SI (ou DI) est incrémenté automatiquement : SI = SI + 1 (ou DI = DI + 1) o Adresse du 2 er élément du bloc de données (SI = 1 ou DI = 1) = 1000H + SI (ou DI) = 1001H Puis, SI (ou DI) est incrémenté automatiquement : SI = SI + 1 (ou DI = DI + 1)
Architecture des ordinateurs
39/48
SMAI-S3
8.3.3.
Année Universitaire : 2009/2010
Registre IP (Instruction Pointer) 15
0
IP
Instruction Pointer
IP, Instruction Pointer ou Compteur de Programme ou Compteur Ordinale, contient l'adresse de l'emplacement mémoire où se situe la prochaine instruction à exécuter. Autrement dit, il doit indiquer au processeur la prochaine instruction à exécuter.
Le registre IP est constamment modifié après l'exécution de chaque instruction afin qu'il pointe sur l'instruction suivante.
8.3.4.
Registre d’état (Flag) 15
8 7
Registre d’état
FLAGSH
0
FLAGSL
Le registre d'état FLAG sert à contenir l'état de certaines opérations effectuées par le processeur.
Par exemple, quand le résultat d'une opération est trop grand pour être contenu dans le registre cible (celui qui doit contenir le résultat de l'opération), un bit spécifique du registre d'état (le bit OF) est mis à 1 pour indiquer le débordement.
Flags = Drapeaux, Les drapeaux sont des indicateurs suite à des opérations arithmétiques ou logiques.
Le registre d'état du 8088 est formé par les bits suivants : X
X
X
X
OF
DF
IF
TF
SF
ZF
X
AF
X
PF
X
CF
Remarque : X : bit non utilisé CF : (Carry Flag)
Bit indicateur au retenue, positionné à 1 lors d’un retenu dans une opération d’addition (ADD) ou soustraction (SUB) (voir partie : 1.2. Unité de commande).
PF : (Parity Flag)
Parité : si le résultat de l'opération contient un nombre pair de 1 cet indicateur est mis à 1, sinon zéro.
Architecture des ordinateurs
40/48
SMAI-S3
Année Universitaire : 2009/2010
AF : (Auxiliary Flag)
Demie retenue : Ce bit est égal à 1 si on a un retenue du quarter de poids faible dans le quarter de poids plus fort.
ZF : (Zero Flag)
Zéro : Cet
indicateur est
mis à 1 quand le résultat d'une opération est égal à zéro.
Lorsque l'on vient d'effectuer une soustraction (ou une addition). (voir partie : 1.2. Unité de commande). SF : (Sign Flag)
SF est positionné à 1 si le bit de poids fort du résultat d'une addition ou soustraction est 1 ; sinon SF=0.
SF est utile lorsque l'on manipule des entiers signés, car le bit de poids fort donne alors le signe du résultat. (voir partie : 1.2. Unité de commande).
OF : (Overflow Flag)
Débordement : si on a un débordement arithmétique ce bit est mis à 1, c-a-d le résultat d'une opération excède la capacité de l'opérande (registre ou case mémoire), sinon il est à 0.
DF : (Direction Flag)
Auto Incrémentation/Décrémentation : utilisée pendant les instructions sur des blocs de données (chaînes de caractères, tableaux, …) pour auto incrémenter ou auto décrémenter le SI et le DI.
IF : (Interrupt Flag)
Masque d'interruption : pour masquer les interruptions venant de l'extérieur ce bit est mis à 0, dans le cas contraire le microprocesseur reconnaît l'interruption de l'extérieur.
TF : (Trap Flag)
Piége : pour que le microprocesseur exécute le programme pas à pas.
Architecture des ordinateurs
41/48
SMAI-S3
8.3.5.
Année Universitaire : 2009/2010
Les registres segment 15
Le
0
Code Segment
CS
Data Segment
DS
Stack Segment
SS
Extra Segment
ES
8088 a quatre registres segments de 16 bits chacun : CS (Code Segment),
DS (Data Segment), ES (Extra Segment) et SS (Stack Segment).
Ces registres sont chargés de sélectionner les différents segments (parties) de la mémoire en pointant sur le début de chacun d'entre eux.
Chaque segment de la mémoire ne peut excéder les 65535 octets.
Registre CS : (Code Segment)
Il pointe sur le segment qui contient les codes des instructions du programme en cours.
Si la taille du programme dépasse les 65535 octets alors on peut diviser le code sur plusieurs segments (chacun ne dépasse pas les 65535 octets) et pour basculer d'une partie à une autre du programme il suffit de changer la valeur du registre CS et de cette manière on résout le problème des programmes qui ont une taille supérieure à 65535 octets.
Registre DS : (Data Segment)
Le registre segment de données pointe sur le segment des variables globales du programme, bien évidemment la taille ne peut excéder 65535 octets. S
Si on a des données qui dépassent cette limite, on utilise la même astuce citée dans la remarque précédente mais dans ce cas on change la valeur de DS.
Registre ES : (Extra Segment)
Le registre de données supplémentaires ES est utilisé par le microprocesseur lorsque l'accès aux autres registres est devenu difficile ou impossible pour modifier des données, de même ce segment est utilisé pour le stockage des chaînes de caractères.
Architecture des ordinateurs
42/48
SMAI-S3
Année Universitaire : 2009/2010
Registre SS : (Stack Segment)
Le registre SS pointe sur la pile : la pile est une zone mémoire ou on peut sauvegarder les registres ou les adresses ou les données pour les récupérer après l'exécution d'un sous programme ou l'exécution d'un programme d'interruption.
En général il est conseillée de ne pas changer le contenu de ce registre car on risque de perdre des informations très importantes (exemple les passages d'arguments entre le programme principal et le sous programme).
8.4. Gestion de la mémoire 8.4.1.
Introduction L'espace mémoire adressable (1 Méga Octet = 2 20 Octets, 20 broches du bus d'adresse) du 8088 est divisé en quatre segment logiques allant jusqu'à 64 KOctets chacun.
L'accès à ces espaces est direct et simultané, or Le compteur de programme est de 16 bits donc la possibilité d'adressage est de 2 16 Octet= 64 KOctet (Ce qui ne couvre pas la totalité de la mémoire), alors on utilise deux registres pour indiquer une adresse au processeur.
Chaque segment débute à l'endroit spécifié par le registre
segment. Le
déplacement (offset) à l'intérieur de chaque segment se fait par un registre de décalage qui permet de trouver une information à l'intérieur du segment. o IP est un registre de déplacement dans le segment code (CS). o SP est un registre de déplacement dans le segment pile (SS). o SI et DI sont des registres de déplacement dans les segments de données (DS) et segment de données supplémentaires (ES).
Architecture des ordinateurs
43/48
SMAI-S3
Année Universitaire : 2009/2010 7
0
IP
64 Ko
Segment Code
64 Ko
Segment Données
64 Ko
Segment Extra
64 Ko
Segment Pile
CS DS SI ou DI
ES SS
SI ou DI
SP
8.4.2.
Adresse physique (segmentation de la mémoire)
La mémoire est divisée en segments de taille 64 Ko.
Chaque segment contient un type différent d’information : o Segment Code, contient les instructions d’un programme, o Segment Données, contient les données d’un programme, o Segment Extra, contient des données supplémentaires (utilisé dans des données blocs : chaînes de caractères, tableaux, …), o Segment Pile, contient le contenu des registres interne AX, BX, CX et DX lors d’une interruption.
Chaque segment est adressé par deux registres : o Registre Segment ou Registre Base : pointe sur le début du segment (Base), o Registre de décalage : pointe sur l’information à l’intérieur du segment (Offset).
Ainsi, L’adresse physique = Base * 16 + Offset.
Remarque : o L’adresse segment (Base) et l’adresse de déplacement (Offset) sont des adresses sur 16 bits (4 chiffres hexadécimaux), adressées par des registres sur 16bits.
Architecture des ordinateurs
44/48
SMAI-S3
Année Universitaire : 2009/2010
o Tandis que l’adresse physique est une adresse sur 20 bits (5 chiffres hexadécimaux), adressées par le bus d’adresse de 20 broches.
Le schéma de la figure suivante illustre la formation d'une adresse 20 bits à partir du segment et du déplacement sur 16 bits :
19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Bits
Base +
0000
=
0000 Offset
Adresse Physique
Exemple : Pour
8.4.3.
:
CS = 1000H et IP = 2006H Adresse Physique = 10000H + 02006H = 12006H
Exemple de configuration des 4 segments de la mémoire La mémoire Adresse physique
Zone Inutilisée
Adr phy = 0200H*10H+0000H = 02000H Segment Code 11FFFH Zone Inutilisée 13000H
Segment Données
22FFFH Zone Inutilisée 30000H 3FFFFH
Segment Extra Zone Inutilisée
40000H 4FFFFH
Architecture des ordinateurs
Segment Pile
Case mémoire IP = 0000H CS = 0200H IP = FFFFH SI = 0000H DS = 1300H SI = FFFFH DI = 0000H ES = 3000H DI = FFFFH SP = 0000H SS = 4000H SP = FFFFH
45/48
SMAI-S3
Année Universitaire : 2009/2010
Chapitre 5 : Les échanges de données
La fonction d’un système à microprocesseurs, quel qu’il soit, est le traitement de l’information. Il est donc évident qu’il doit acquérir l’information fournie par son environnement et retourner les résultats de ses traitements.
Chaque système est donc équipé d’une ou plusieurs interfaces d’entrées/sorties permettant d’assurer la communication entre le microprocesseur et le monde extérieur.
Durant une opération d’entrée/sortie, l’information est échangée entre la mémoire principale et un périphérique relié au système, appelé périphérique d’entrée / sortie (clavier, imprimante, écran, scanner, …).
Cet échange nécessite une interface (ou contrôleur) pour gérer la connexion.
Plusieurs techniques sont employées pour effectuer ces échanges.
1. L’interface d’entrée/sortie 1.1. Rôle
Chaque périphérique sera relié au système par l’intermédiaire d’une interface (ou contrôleur) dont le rôle est de : o Connecter le périphérique au bus de données. o Gérer les échanges entre le microprocesseur et le périphérique
1.2. Constitution
Pour cela l’interface est constituée par : o Un registre de commande dans lequel le processeur décrit le travail à effectuer (sens de transfert, mode de transfert). o Un ou plusieurs registres de données qui contiennent les mots à échanger entre le périphérique et la mémoire. o Un registre d’état qui indique si l’unité d’échange est prête, si l’échange s’est bien déroulé, etc…
On accède aux données de l’interface par le biais d’un espace d’adresses d’entrées/sorties.
Architecture des ordinateurs
46/48
SMAI-S3
Année Universitaire : 2009/2010
2. Techniques d’échange de données
Avant d’envoyer ou de recevoir des informations, le microprocesseur doit savoir si un périphérique est prêt à recevoir ou à transmettre une information pour que la transmission se fasse correctement.
Il existe 2 modes d’échange d’information : o Le mode programmé par scrutation ou interruption où le microprocesseur sert d’intermédiaire entre la mémoire et le périphérique. o Le mode en accès direct à la mémoire (DMA) où le microprocesseur ne se charge pas de l’échange de données.
2.1. Echange programmé 2.1.1.
Scrutation Le microprocesseur interroge l’interface pour savoir si des transferts sont prêts. Tant que des transferts ne sont pas prêts, le microprocesseur attend.
Inconvénient : le microprocesseur se retrouve souvent en phase d’attente. Il est occupé par l’interface d’entrée/sortie ce type d’échange est très lent.
2.1.2.
Interruption Une interruption est un signal, pouvant être émis par tout dispositif externe au microprocesseur.
Le microprocesseur possède une ou plusieurs entrées réservées à cet effet.
L’interruption interrompre le travail courant du microprocesseur pour forcer l’exécution d’un programme traitant la cause de l’interruption.
Ainsi, dans un échange de données par interruption, le microprocesseur exécute donc son programme principal jusqu’à ce qu’il reçoive un signal sur sa ligne de requête d’interruption. Il se charge alors d’effectuer le transfert de données entre l’interface et la mémoire.
2.2. Echange direct avec la mémoire (DMA)
Ce mode permet le transfert de blocs de données entre la mémoire et un périphérique sans passer par le microprocesseur.
Architecture des ordinateurs
47/48
SMAI-S3
Année Universitaire : 2009/2010
Pour cela, un circuit appelé contrôleur de DMA (Direct Memory Access) prend en charge les différentes opérations.
Le DMA se charge entièrement du transfert d’un bloc de données. Le microprocesseur doit tout de même : o Initialiser l’échange en donnant au DMA l’identification du périphérique concerné. o Donner le sens du transfert. o Fournir l’adresse du premier et du dernier mot concernés par le transfert.
3. Types de liaisons
Les systèmes à microprocesseur utilisent deux types de liaisons différentes pour se connecter à des périphériques : o Liaison parallèle. o Liaison série.
3.1. Liaison parallèle
Dans ce type de liaison, tous les bits d’un mot sont transmis simultanément.
Ce type de transmission permet des transferts rapides mais reste limitée à de faibles distances de transmission à cause du nombre important de lignes nécessaires (coût).
Microprocesseur
. . .
Interface
. . .
Périphérique
3.2. Liaison série
Dans ce type de liaison, les bits constitutifs d’un mot sont transmis les uns après les autres sur un seul fil.
Les distances de transmission peuvent donc être plus beaucoup plus importantes mais la vitesse de transmission est plus faible.
Microprocesseur
Architecture des ordinateurs
Interface
Périphérique
48/48
Nom du document : CoursArchitectureOrd Répertoire : E: Modèle : C:\Documents and Settings\Administrateur\Application Data\Microsoft\Templates\Normal.dotm Titre : Sujet : Auteur : Hatim Mots clés : Commentaires : Date de création : 18/02/2004 23:26:00 N° de révision : 193 Dernier enregistr. le : 31/10/2009 20:13:00 Dernier enregistrement par : fatijeune Temps total d'édition :5 444 Minutes Dernière impression sur : 06/01/2010 22:36:00 Tel qu'à la dernière impression Nombre de pages : 48 Nombre de mots : 9 554 (approx.) Nombre de caractères : 52 549 (approx.)
View more...
Comments
