cours architecture d'ordinateur

SMAI-S3 Année Universitaire : 2009/2010

Architecture des ordinateurs 1/48

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



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



8.4.2. Adresse physique (segmentation de la mémoire)............................................ 44 8.4.3. 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



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.



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…



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.



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.

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 :

Unité Centrale

Mémoire Principale

Interfaces E/S

Bus



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.



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.

Unité Centrale

Mémoire

Principale

Interfaces E/S

Bus

Bus d’adresses

Décodeur d’adresses

Bus de Commande



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.

Case mémoire Adresse

7 = 111

6 = 110

5 = 101

4 = 100

3 = 011

2 = 010

1 = 001

0 = 000 0001 0110



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 :

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 ( WR / ).

Une entrée de sélection du circuit ( MIO / ).

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 ( WR / )

3. Sélection de la mémoire ( MIO / = 0)

4. Lecture ou écriture la donnée

Mémoire

Adresses (n bits)

R / W

IO/M

Données (m bits)



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

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.

Bus @ @ x

Dx Bus D

Données Accessibles

T accès

T cycle



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.



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à



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.

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).

Mémoire de masse

Mémoire d’appui

Mémoire principale

Mémoire cache

Registres < 400 oct

8Ko à 4Mo

Jusqu’à 1Go

2 à 4 Go

200Go

1 ns

5 ns

10 ns

5 ms

+

Vitesse

+

Capacité



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.

Unité de Traitement

Unité de Commande

Bus d’adresses

Bus de données

Programmes

Données

@

D



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 micro-

programmé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).



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é BA )

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.

00000000

00000001

11111111

, CF = 1

00011000

00010000

00001000

, CF = 0

Bit ou Indicateur de zéro (CZ) :

– CZ = 1, résultat d’une opération est nul.



– CZ = 0, dans le cas contraire (résultat non nul).


00000000

00000001

11111111

, CF = 1 et CZ = 1

00011000

00010000

00001000

, CF = 0 et CZ = 0

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).


00000000

00000001

11111111

, CS = 0

10011110

01010110

01001000

, CS = 1

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).

01111111

10111111

11000000

, CF = 1, CZ = 0, CS = 0 et OV = 1

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.



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

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.

Bus d’adresses

Bus de données

Programmes

Données

Acc

Registre d’état

UAL

Registre

Registre d’@

PC

Bloc logique de commande

Registre d’instruction

Décodeur d’instructio

ns

Horlog

Bus Commande



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

PC $2000

Instr 1 RI

Décodeur d’Instruction

Mémoire

Instr 1

Opér 1

Instr 2

Instr 3

. . .

$2000

$2001

$2002

$2003

$2004

$FFF

@ $2000

Instr1

1

2

3

Microprocesseur PC $2000

Instr 1 RI


Mémoire

Instr 1

Opér 1

Instr 2

Instr 3

. . .

$2000

$2001

$2002

$2003

$2004

$FFF

@ $2001

Instr1

1

2

3


UAL

Opér 1 Opér 2



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.

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

Microprocesseur PC $2002

Instr 1 RI


Mémoire

Instr 1

Opér 1

Instr 2

Instr 3

. . .

$2000

$2001

$2002

$2003

$2004

$FFF

1

2

3


UAL

Opér 1 Résult

CF=0, CZ=1, …



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



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.

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é.

Langage Haut niveau (for, if…then, write, etc…)

Langage Assembleur (cmp, add, mov, etc…)

Langage Machine (00011100, 11010011, etc…)

Compilation

Assemblage



o Le MIPS (Millions d'Instructions Par Seconde) qui représente la puissance de

traitement du microprocesseur :

CPI

FMIPS H , avec MHzenFH

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.



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 RISC Architecture CISC

Instructions simples ne prenant qu’un seul

cycle machine.

Décodeur simple.

Beaucoup de registres.

Seules les instructions LOAD et STORE

ont accès à la mémoire.

Compilateur complexe.

Instructions complexes prenant plusieurs

cycles machines.

Décodeur complexe (microcode).

Peu de registres.

Toutes les instructions sont susceptibles

d’accéder à la mémoire.

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



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 :

Modèle classique :

Modèle pipeliné :

Recherche Décodage Exécution Sauv. Résultat

R1

D1

E1

S1

R2

D2

E2

S2

R3

D3

E3

S3

1 2 3 4 5 6 7 8 9 10 11 12

Nbre de cycles

R1

D1

E1

S1

R2

D2

E2

S2

R3

D3

E3

S3

1 2 3 4 5 6 7 8 9 10 11 12

Nbre de cycles

R4 R5 R6 R7 R8 R9

D4 D5 D6 D7 D8 D9

E4 E5 E6 E7 E8 E9

S4 S5 S6 S7 S8 S9



7.1.2. 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)



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)

b)

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 :

Unité de

traitement

Unité de

commande

Cache

Microprocesseur Mémoire

1

2

Unité de

traitement

Unité de

commande

Cache

Microprocesseur Mémoire

1 2

3 4

I1 I2 I3 I4 I5 I6 I7 I8

N cycles

Unité de traitement



Architecture superscalaire :

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.

I1

I3

I5 I7

I2 I4 I6

I8

N/2 cycles

Unité de traitement 1

Unité de traitement 2

Recherche Décodage Exécution Sauv. Résultat UT1

Recherche Décodage Exécution Sauv. Résultat UT2

Nbre de cycles

1 11



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

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 : 220bit = 1 MegaOctet.

L’adresse d’un mot mémoire est sur 5 bits : de 00000 H à FFFFF H.

A13 A12

A8 A9 A10

A11

A14 A15

A19 A18 A17

A16

AD7

AD0

Alimentation Masse

Horloge

Bus de commande

Signaux de contrôle



8.1.1. Bus de commande

RD : Broche de lecture mémoire ou interface.

Si 0RD 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 1WR le microprocesseur effectue une écriture dans la mémoire ou dans

l’interface d’E/S.

MIO / : Broche de sélection.

o Si 1/ MIO c’est la mémoire qui est sélectionnée pour une lecture ou une

écriture.

o Si 0/ MIO c’est l’interface qui est sélectionnée pour une lecture ou une

écriture.

Remarque :

RD WR MIO / Opération

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.

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.

8088 Bus de commande

RD WR

MIO / ALE

READY



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 : 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 Quelques signaux de contrôle NMI

INTA Hold

HOLDA

INTR

8088 Interface D’E/S

Périphérique externe

INTR

INTA



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.



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).

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.

AH AL

BH BL

CH CL

DH DL

15 8 7 0

AX

BX

CX

DX

SP

BP

SI

DI

15 0

Stack Pointer

Base Pointer

Source Index

Destination Index



8.3.1. 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 :



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 sous-programme

Dépilement du contenu de AX, BX, CX et DX

…….. Instructions suite du programme principal ……….

Instructions du sous-programme utilisant les registres AX, BX, CX et DX

AX

BX

CX

DX …. …. ….

AL

AH

BL

DH

RAM

Pile

Empilement (Sauvegarde)

Dépilement (Chargement)

RAM

11

01

01

0E

01 11

AX

AL AH

Empilement

Dépilement FF4C

FF4D

FF4E

FF4F

FF50

FF4B

Sommet de la pile (1ère case mémoire libre)

SP = FF4B Après empilement et

avant dépilement

SP = FF4D Après dépilement de AX



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 :

o Adresse du 1er é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 2er é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)

RAM Adresse associée au bloc

1000H

1001H

1100H

Bloc de données



8.3.3. Registre 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)

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 :

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.

Instruction Pointer

0 15

IP

FLAGSH

0 15

Registre d’état FLAGSL

8 7

X X X X OF DF IF TF SF ZF X AF X PF X CF



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.



8.3.5. Les registres segment

Le 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.

CS

DS

SS

ES

15 0

Code Segment

Data Segment

Stack Segment

Extra Segment



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 = 220 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 216 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).



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.

CS

DS

ES

SS

IP

SI ou DI

SI ou DI

SP

7 0

64 Ko Segment Code

64 Ko Segment Données

64 Ko Segment Extra

64 Ko Segment Pile



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 :

Exemple :

Pour : CS = 1000H et IP = 2006H

Adresse Physique = 10000H + 02006H = 12006H

8.4.3. Exemple de configuration des 4 segments de la mémoire

19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Bits

Base 0 0 0 0

0 0 0 0 Offset

Adresse Physique

+

=

Segment Code

Segment Pile

Segment Données

Segment Extra

Zone Inutilisée

Zone Inutilisée

Zone Inutilisée

Zone Inutilisée

Case mémoire

Adresse physique

La mémoire

IP = 0000H

CS = 0200H IP = FFFFH

DS = 1300H SI = FFFFH

ES = 3000H DI = FFFFH

SS = 4000H SP = FFFFH

SI = 0000H

DI = 0000H

SP = 0000H

Adr phy = 0200H*10H+0000H = 02000H

11FFFH

13000H

22FFFH

30000H

3FFFFH

40000H

4FFFFH



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.



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.



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).

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

Interface

Périphérique . . .

.

.

.

Microprocesseur

Interface

Périphérique

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.)